36dc32a61c001695a18089ea75808974a0b21703
[librecmc/librecmc.git] / package / mac80211 / src / mac80211 / ieee80211_ioctl.c
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005-2006, Devicescape Software, Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/netdevice.h>
13 #include <linux/types.h>
14 #include <linux/slab.h>
15 #include <linux/skbuff.h>
16 #include <linux/etherdevice.h>
17 #include <linux/if_arp.h>
18 #include <linux/wireless.h>
19 #include <net/iw_handler.h>
20 #include <asm/uaccess.h>
21
22 #include <net/mac80211.h>
23 #include "ieee80211_i.h"
24 #include "hostapd_ioctl.h"
25 #include "ieee80211_rate.h"
26 #include "wpa.h"
27 #include "aes_ccm.h"
28 #include "debugfs_key.h"
29
30 static int ieee80211_regdom = 0x10; /* FCC */
31 module_param(ieee80211_regdom, int, 0444);
32 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain; 64=MKK");
33
34 /*
35  * If firmware is upgraded by the vendor, additional channels can be used based
36  * on the new Japanese regulatory rules. This is indicated by setting
37  * ieee80211_japan_5ghz module parameter to one when loading the 80211 kernel
38  * module.
39  */
40 static int ieee80211_japan_5ghz /* = 0 */;
41 module_param(ieee80211_japan_5ghz, int, 0444);
42 MODULE_PARM_DESC(ieee80211_japan_5ghz, "Vendor-updated firmware for 5 GHz");
43
44
45 static int ieee80211_ioctl_set_beacon(struct net_device *dev,
46                                       struct prism2_hostapd_param *param,
47                                       int param_len,
48                                       int flag)
49 {
50         struct ieee80211_sub_if_data *sdata;
51         struct ieee80211_if_ap *ap;
52         u8 **b_head, **b_tail;
53         int *b_head_len, *b_tail_len;
54         int len;
55
56         len = ((char *) param->u.beacon.data - (char *) param) +
57                 param->u.beacon.head_len + param->u.beacon.tail_len;
58
59         if (param_len > len)
60                 param_len = len;
61         else if (param_len != len)
62                 return -EINVAL;
63
64         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
65         if (sdata->type != IEEE80211_IF_TYPE_AP)
66                 return -EINVAL;
67         ap = &sdata->u.ap;
68
69         switch (flag) {
70         case 0:
71                 b_head = &ap->beacon_head;
72                 b_tail = &ap->beacon_tail;
73                 b_head_len = &ap->beacon_head_len;
74                 b_tail_len = &ap->beacon_tail_len;
75                 break;
76         default:
77                 printk(KERN_DEBUG "%s: unknown beacon flag %d\n",
78                        dev->name, flag);
79                 return -EINVAL;
80         }
81
82         kfree(*b_head);
83         kfree(*b_tail);
84         *b_head = NULL;
85         *b_tail = NULL;
86
87         *b_head_len = param->u.beacon.head_len;
88         *b_tail_len = param->u.beacon.tail_len;
89
90         *b_head = kmalloc(*b_head_len, GFP_KERNEL);
91         if (*b_head)
92                 memcpy(*b_head, param->u.beacon.data, *b_head_len);
93         else {
94                 printk(KERN_DEBUG "%s: failed to allocate beacon_head\n",
95                        dev->name);
96                 return -ENOMEM;
97         }
98
99         if (*b_tail_len > 0) {
100                 *b_tail = kmalloc(*b_tail_len, GFP_KERNEL);
101                 if (*b_tail)
102                         memcpy(*b_tail, param->u.beacon.data + (*b_head_len),
103                                (*b_tail_len));
104                 else {
105                         printk(KERN_DEBUG "%s: failed to allocate "
106                                "beacon_tail\n", dev->name);
107                         return -ENOMEM;
108                 }
109         }
110
111         return ieee80211_if_config_beacon(dev);
112 }
113
114
115 static int ieee80211_ioctl_get_hw_features(struct net_device *dev,
116                                            struct prism2_hostapd_param *param,
117                                            int param_len)
118 {
119         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
120         u8 *pos = param->u.hw_features.data;
121         int left = param_len - (pos - (u8 *) param);
122         int i;
123         struct hostapd_ioctl_hw_modes_hdr *hdr;
124         struct ieee80211_rate_data *rate;
125         struct ieee80211_channel_data *chan;
126         struct ieee80211_hw_mode *mode;
127
128         param->u.hw_features.flags = 0;
129         if (local->hw.flags & IEEE80211_HW_DATA_NULLFUNC_ACK)
130                 param->u.hw_features.flags |= HOSTAP_HW_FLAG_NULLFUNC_OK;
131
132         param->u.hw_features.num_modes = 0;
133         list_for_each_entry(mode, &local->modes_list, list) {
134                 int clen, rlen;
135
136                 param->u.hw_features.num_modes++;
137                 clen = mode->num_channels * sizeof(struct ieee80211_channel_data);
138                 rlen = mode->num_rates * sizeof(struct ieee80211_rate_data);
139                 if (left < sizeof(*hdr) + clen + rlen)
140                         return -E2BIG;
141                 left -= sizeof(*hdr) + clen + rlen;
142
143                 hdr = (struct hostapd_ioctl_hw_modes_hdr *) pos;
144                 hdr->mode = mode->mode;
145                 hdr->num_channels = mode->num_channels;
146                 hdr->num_rates = mode->num_rates;
147
148                 pos = (u8 *) (hdr + 1);
149                 chan = (struct ieee80211_channel_data *) pos;
150                 for (i = 0; i < mode->num_channels; i++) {
151                         chan[i].chan = mode->channels[i].chan;
152                         chan[i].freq = mode->channels[i].freq;
153                         chan[i].flag = mode->channels[i].flag;
154                 }
155                 pos += clen;
156
157                 rate = (struct ieee80211_rate_data *) pos;
158                 for (i = 0; i < mode->num_rates; i++) {
159                         rate[i].rate = mode->rates[i].rate;
160                         rate[i].flags = mode->rates[i].flags;
161                 }
162                 pos += rlen;
163         }
164
165         return 0;
166 }
167
168 static int ieee80211_ioctl_flush(struct net_device *dev,
169                                  struct prism2_hostapd_param *param)
170 {
171         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
172         sta_info_flush(local, NULL);
173         return 0;
174 }
175
176
177 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
178 struct iapp_layer2_update {
179         u8 da[ETH_ALEN]; /* broadcast */
180         u8 sa[ETH_ALEN]; /* STA addr */
181         __be16 len; /* 6 */
182         u8 dsap; /* 0 */
183         u8 ssap; /* 0 */
184         u8 control;
185         u8 xid_info[3];
186 } __attribute__ ((packed));
187
188 static void ieee80211_send_layer2_update(struct net_device *dev,
189                                          const u8 *addr)
190 {
191         struct iapp_layer2_update *msg;
192         struct sk_buff *skb;
193
194         /* Send Level 2 Update Frame to update forwarding tables in layer 2
195          * bridge devices */
196
197         skb = dev_alloc_skb(sizeof(*msg));
198         if (!skb)
199                 return;
200         msg = (struct iapp_layer2_update *) skb_put(skb, sizeof(*msg));
201
202         /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
203          * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
204
205         memset(msg->da, 0xff, ETH_ALEN);
206         memcpy(msg->sa, addr, ETH_ALEN);
207         msg->len = htons(6);
208         msg->dsap = 0;
209         msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */
210         msg->control = 0xaf; /* XID response lsb.1111F101.
211                               * F=0 (no poll command; unsolicited frame) */
212         msg->xid_info[0] = 0x81; /* XID format identifier */
213         msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */
214         msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */
215
216         skb->dev = dev;
217         skb->protocol = eth_type_trans(skb, dev);
218         memset(skb->cb, 0, sizeof(skb->cb));
219         netif_rx(skb);
220 }
221
222
223 static int ieee80211_ioctl_add_sta(struct net_device *dev,
224                                    struct prism2_hostapd_param *param)
225 {
226         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
227         struct sta_info *sta;
228         u32 rates;
229         int i, j;
230         struct ieee80211_sub_if_data *sdata;
231         struct ieee80211_hw_mode *mode;
232         int add_key_entry = 1;
233
234         /* Prevent a race with changing the rate control algorithm */
235         if (!netif_running(dev))
236                 return -ENETDOWN;
237
238         sta = sta_info_get(local, param->sta_addr);
239
240         if (!sta) {
241                 sta = sta_info_add(local, dev, param->sta_addr, GFP_KERNEL);
242                 if (!sta)
243                         return -ENOMEM;
244         }
245
246         if (sta->dev != dev) {
247                 /* Binding STA to a new interface, so remove all references to
248                  * the old BSS. */
249                 spin_lock_bh(&local->sta_lock);
250                 sta_info_remove_aid_ptr(sta);
251                 spin_unlock_bh(&local->sta_lock);
252         }
253
254         /* TODO
255          * We "steal" the device in case someone owns it
256          * This will hurt WDS links and such when we have a
257          * WDS link and a client associating from the same station
258          */
259         sta->dev = dev;
260         sdata = IEEE80211_DEV_TO_SUB_IF(sta->dev);
261
262         sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC;
263         sta->aid = param->u.add_sta.aid;
264         if (sta->aid > IEEE80211_MAX_AID)
265                 sta->aid = 0;
266         sta->listen_interval = param->u.add_sta.listen_interval;
267
268         rates = 0;
269         mode = local->oper_hw_mode;
270         for (i = 0; i < sizeof(param->u.add_sta.supp_rates); i++) {
271                 int rate = (param->u.add_sta.supp_rates[i] & 0x7f) * 5;
272                 if (mode->mode == MODE_ATHEROS_TURBO ||
273                     mode->mode == MODE_ATHEROS_TURBOG)
274                         rate *= 2;
275                 for (j = 0; j < mode->num_rates; j++) {
276                         if (mode->rates[j].rate == rate)
277                                 rates |= BIT(j);
278                 }
279
280         }
281         sta->supp_rates = rates;
282
283         rate_control_rate_init(sta, local);
284
285         if (param->u.add_sta.wds_flags & 0x01)
286                 sta->flags |= WLAN_STA_WDS;
287         else
288                 sta->flags &= ~WLAN_STA_WDS;
289
290         if (add_key_entry && !sta->key && !sdata->default_key &&
291             local->ops->set_key) {
292                 struct ieee80211_key_conf conf;
293                 /* Add key cache entry with NULL key type because this may used
294                  * for TX filtering. */
295                 memset(&conf, 0, sizeof(conf));
296                 conf.hw_key_idx = HW_KEY_IDX_INVALID;
297                 conf.alg = ALG_NULL;
298                 conf.flags |= IEEE80211_KEY_FORCE_SW_ENCRYPT;
299                 if (local->ops->set_key(local_to_hw(local), SET_KEY,
300                                        sta->addr, &conf, sta->aid)) {
301                         sta->key_idx_compression = HW_KEY_IDX_INVALID;
302                 } else {
303                         sta->key_idx_compression = conf.hw_key_idx;
304                 }
305         }
306
307         sta_info_put(sta);
308
309         if (sdata->type == IEEE80211_IF_TYPE_AP ||
310             sdata->type == IEEE80211_IF_TYPE_VLAN)
311                 ieee80211_send_layer2_update(dev, param->sta_addr);
312
313         return 0;
314 }
315
316
317 static int ieee80211_ioctl_remove_sta(struct net_device *dev,
318                                       struct prism2_hostapd_param *param)
319 {
320         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
321         struct sta_info *sta;
322
323         sta = sta_info_get(local, param->sta_addr);
324         if (sta) {
325                 sta_info_put(sta);
326                 sta_info_free(sta, 0);
327         }
328
329         return sta ? 0 : -ENOENT;
330 }
331
332
333 static int ieee80211_ioctl_get_dot11counterstable(struct net_device *dev,
334                                         struct prism2_hostapd_param *param)
335 {
336         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
337         struct ieee80211_low_level_stats stats;
338
339         memset(&stats, 0, sizeof(stats));
340         if (local->ops->get_stats)
341                 local->ops->get_stats(local_to_hw(local), &stats);
342         param->u.dot11CountersTable.dot11TransmittedFragmentCount =
343                 local->dot11TransmittedFragmentCount;
344         param->u.dot11CountersTable.dot11MulticastTransmittedFrameCount =
345                 local->dot11MulticastTransmittedFrameCount;
346         param->u.dot11CountersTable.dot11ReceivedFragmentCount =
347                 local->dot11ReceivedFragmentCount;
348         param->u.dot11CountersTable.dot11MulticastReceivedFrameCount =
349                 local->dot11MulticastReceivedFrameCount;
350         param->u.dot11CountersTable.dot11TransmittedFrameCount =
351                 local->dot11TransmittedFrameCount;
352         param->u.dot11CountersTable.dot11FCSErrorCount =
353                 stats.dot11FCSErrorCount;
354         param->u.dot11CountersTable.dot11ACKFailureCount =
355                 stats.dot11ACKFailureCount;
356         param->u.dot11CountersTable.dot11RTSFailureCount =
357                 stats.dot11RTSFailureCount;
358         param->u.dot11CountersTable.dot11RTSSuccessCount =
359                 stats.dot11RTSSuccessCount;
360
361         return 0;
362 }
363
364
365 static int ieee80211_ioctl_get_info_sta(struct net_device *dev,
366                                         struct prism2_hostapd_param *param)
367 {
368         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
369         struct ieee80211_hw_mode *mode;
370         struct sta_info *sta;
371
372         if (is_broadcast_ether_addr(param->sta_addr)) {
373                 struct net_device_stats *stats;
374
375                 stats = ieee80211_dev_stats(local->mdev);
376                 param->u.get_info_sta.rx_bytes = stats->rx_bytes;
377                 param->u.get_info_sta.tx_bytes = stats->tx_bytes;
378                 /* go through all STAs and get STA with lowest max. rate */
379                 param->u.get_info_sta.current_tx_rate =
380                         sta_info_min_txrate_get(local);
381                 return 0;
382         }
383
384         sta = sta_info_get(local, param->sta_addr);
385
386         if (!sta)
387                 return -ENOENT;
388
389         param->u.get_info_sta.inactive_msec =
390                 jiffies_to_msecs(jiffies - sta->last_rx);
391         param->u.get_info_sta.rx_packets = sta->rx_packets;
392         param->u.get_info_sta.tx_packets = sta->tx_packets;
393         param->u.get_info_sta.rx_bytes = sta->rx_bytes;
394         param->u.get_info_sta.tx_bytes = sta->tx_bytes;
395         param->u.get_info_sta.channel_use = sta->channel_use;
396         param->u.get_info_sta.flags = sta->flags;
397         mode = local->oper_hw_mode;
398         if (sta->txrate >= 0 && sta->txrate < mode->num_rates)
399                 param->u.get_info_sta.current_tx_rate =
400                         mode->rates[sta->txrate].rate;
401         param->u.get_info_sta.num_ps_buf_frames =
402                 skb_queue_len(&sta->ps_tx_buf);
403         param->u.get_info_sta.tx_retry_failed = sta->tx_retry_failed;
404         param->u.get_info_sta.tx_retry_count = sta->tx_retry_count;
405         param->u.get_info_sta.last_rssi = sta->last_rssi;
406         param->u.get_info_sta.last_ack_rssi = sta->last_ack_rssi[2];
407
408         sta_info_put(sta);
409
410         return 0;
411 }
412
413
414 static int ieee80211_ioctl_set_flags_sta(struct net_device *dev,
415                                          struct prism2_hostapd_param *param)
416 {
417         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
418         struct sta_info *sta;
419
420         sta = sta_info_get(local, param->sta_addr);
421         if (sta) {
422                 sta->flags |= param->u.set_flags_sta.flags_or;
423                 sta->flags &= param->u.set_flags_sta.flags_and;
424                 if (local->ops->set_port_auth &&
425                     (param->u.set_flags_sta.flags_or & WLAN_STA_AUTHORIZED) &&
426                     local->ops->set_port_auth(local_to_hw(local), sta->addr, 1))
427                         printk(KERN_DEBUG "%s: failed to set low-level driver "
428                                "PAE state (authorized) for " MAC_FMT "\n",
429                                dev->name, MAC_ARG(sta->addr));
430                 if (local->ops->set_port_auth &&
431                     !(param->u.set_flags_sta.flags_and & WLAN_STA_AUTHORIZED) &&
432                     local->ops->set_port_auth(local_to_hw(local), sta->addr, 0))
433                         printk(KERN_DEBUG "%s: failed to set low-level driver "
434                                "PAE state (unauthorized) for " MAC_FMT "\n",
435                                dev->name, MAC_ARG(sta->addr));
436                 sta_info_put(sta);
437         }
438
439         return sta ? 0 : -ENOENT;
440 }
441
442
443 int ieee80211_set_hw_encryption(struct net_device *dev,
444                                 struct sta_info *sta, u8 addr[ETH_ALEN],
445                                 struct ieee80211_key *key)
446 {
447         struct ieee80211_key_conf *keyconf = NULL;
448         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
449         int rc = 0;
450
451         /* default to sw encryption; this will be cleared by low-level
452          * driver if the hw supports requested encryption */
453         if (key)
454                 key->force_sw_encrypt = 1;
455
456         if (key && local->ops->set_key &&
457             (keyconf = ieee80211_key_data2conf(local, key))) {
458                 if (local->ops->set_key(local_to_hw(local), SET_KEY, addr,
459                                        keyconf, sta ? sta->aid : 0)) {
460                         rc = HOSTAP_CRYPT_ERR_KEY_SET_FAILED;
461                         key->force_sw_encrypt = 1;
462                         key->hw_key_idx = HW_KEY_IDX_INVALID;
463                 } else {
464                         key->force_sw_encrypt =
465                                 !!(keyconf->flags & IEEE80211_KEY_FORCE_SW_ENCRYPT);
466                         key->hw_key_idx =
467                                 keyconf->hw_key_idx;
468
469                 }
470         }
471         kfree(keyconf);
472
473         return rc;
474 }
475
476
477 static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr,
478                                     int idx, int alg, int set_tx_key, u32 *err,
479                                     const u8 *_key, size_t key_len)
480 {
481         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
482         int ret = 0;
483         struct sta_info *sta;
484         struct ieee80211_key *key, *old_key;
485         int try_hwaccel = 1;
486         struct ieee80211_key_conf *keyconf;
487         struct ieee80211_sub_if_data *sdata;
488
489         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
490
491         if (is_broadcast_ether_addr(sta_addr)) {
492                 sta = NULL;
493                 if (idx >= NUM_DEFAULT_KEYS) {
494                         printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
495                                dev->name, idx);
496                         return -EINVAL;
497                 }
498                 key = sdata->keys[idx];
499
500                 /* TODO: consider adding hwaccel support for these; at least
501                  * Atheros key cache should be able to handle this since AP is
502                  * only transmitting frames with default keys. */
503                 /* FIX: hw key cache can be used when only one virtual
504                  * STA is associated with each AP. If more than one STA
505                  * is associated to the same AP, software encryption
506                  * must be used. This should be done automatically
507                  * based on configured station devices. For the time
508                  * being, this can be only set at compile time. */
509         } else {
510                 set_tx_key = 0;
511                 if (idx != 0) {
512                         printk(KERN_DEBUG "%s: set_encrypt - non-zero idx for "
513                                "individual key\n", dev->name);
514                         return -EINVAL;
515                 }
516
517                 sta = sta_info_get(local, sta_addr);
518                 if (!sta) {
519                         if (err)
520                                 *err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
521 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
522                         printk(KERN_DEBUG "%s: set_encrypt - unknown addr "
523                                MAC_FMT "\n",
524                                dev->name, MAC_ARG(sta_addr));
525 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
526
527                         return -ENOENT;
528                 }
529
530                 key = sta->key;
531         }
532
533         /* FIX:
534          * Cannot configure default hwaccel keys with WEP algorithm, if
535          * any of the virtual interfaces is using static WEP
536          * configuration because hwaccel would otherwise try to decrypt
537          * these frames.
538          *
539          * For now, just disable WEP hwaccel for broadcast when there is
540          * possibility of conflict with default keys. This can maybe later be
541          * optimized by using non-default keys (at least with Atheros ar521x).
542          */
543         if (!sta && alg == ALG_WEP && !local->default_wep_only &&
544             sdata->type != IEEE80211_IF_TYPE_IBSS &&
545             sdata->type != IEEE80211_IF_TYPE_AP) {
546                 try_hwaccel = 0;
547         }
548
549         if (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP) {
550                 /* Software encryption cannot be used with devices that hide
551                  * encryption from the host system, so always try to use
552                  * hardware acceleration with such devices. */
553                 try_hwaccel = 1;
554         }
555
556         if ((local->hw.flags & IEEE80211_HW_NO_TKIP_WMM_HWACCEL) &&
557             alg == ALG_TKIP) {
558                 if (sta && (sta->flags & WLAN_STA_WME)) {
559                 /* Hardware does not support hwaccel with TKIP when using WMM.
560                  */
561                         try_hwaccel = 0;
562                 }
563                 else if (sdata->type == IEEE80211_IF_TYPE_STA) {
564                         sta = sta_info_get(local, sdata->u.sta.bssid);
565                         if (sta) {
566                                 if (sta->flags & WLAN_STA_WME) {
567                                         try_hwaccel = 0;
568                                 }
569                                 sta_info_put(sta);
570                                 sta = NULL;
571                         }
572                 }
573         }
574
575         if (alg == ALG_NONE) {
576                 keyconf = NULL;
577                 if (try_hwaccel && key &&
578                     key->hw_key_idx != HW_KEY_IDX_INVALID &&
579                     local->ops->set_key &&
580                     (keyconf = ieee80211_key_data2conf(local, key)) != NULL &&
581                     local->ops->set_key(local_to_hw(local), DISABLE_KEY,
582                                        sta_addr, keyconf, sta ? sta->aid : 0)) {
583                         if (err)
584                                 *err = HOSTAP_CRYPT_ERR_KEY_SET_FAILED;
585                         printk(KERN_DEBUG "%s: set_encrypt - low-level disable"
586                                " failed\n", dev->name);
587                         ret = -EINVAL;
588                 }
589                 kfree(keyconf);
590
591                 if (set_tx_key || sdata->default_key == key) {
592                         ieee80211_debugfs_key_remove_default(sdata);
593                         sdata->default_key = NULL;
594                 }
595                 ieee80211_debugfs_key_remove(key);
596                 if (sta)
597                         sta->key = NULL;
598                 else
599                         sdata->keys[idx] = NULL;
600                 ieee80211_key_free(key);
601                 key = NULL;
602         } else {
603                 old_key = key;
604                 key = ieee80211_key_alloc(sta ? NULL : sdata, idx, key_len,
605                                           GFP_KERNEL);
606                 if (!key) {
607                         ret = -ENOMEM;
608                         goto err_out;
609                 }
610
611                 /* default to sw encryption; low-level driver sets these if the
612                  * requested encryption is supported */
613                 key->hw_key_idx = HW_KEY_IDX_INVALID;
614                 key->force_sw_encrypt = 1;
615
616                 key->alg = alg;
617                 key->keyidx = idx;
618                 key->keylen = key_len;
619                 memcpy(key->key, _key, key_len);
620                 if (set_tx_key)
621                         key->default_tx_key = 1;
622
623                 if (alg == ALG_CCMP) {
624                         /* Initialize AES key state here as an optimization
625                          * so that it does not need to be initialized for every
626                          * packet. */
627                         key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
628                                 key->key);
629                         if (!key->u.ccmp.tfm) {
630                                 ret = -ENOMEM;
631                                 goto err_free;
632                         }
633                 }
634
635                 if (set_tx_key || sdata->default_key == old_key) {
636                         ieee80211_debugfs_key_remove_default(sdata);
637                         sdata->default_key = NULL;
638                 }
639                 ieee80211_debugfs_key_remove(old_key);
640                 if (sta)
641                         sta->key = key;
642                 else
643                         sdata->keys[idx] = key;
644                 ieee80211_key_free(old_key);
645                 ieee80211_debugfs_key_add(local, key);
646                 if (sta)
647                         ieee80211_debugfs_key_sta_link(key, sta);
648
649                 if (try_hwaccel &&
650                     (alg == ALG_WEP || alg == ALG_TKIP || alg == ALG_CCMP)) {
651                         int e = ieee80211_set_hw_encryption(dev, sta, sta_addr,
652                                                             key);
653                         if (err)
654                                 *err = e;
655                 }
656         }
657
658         if (set_tx_key || (!sta && !sdata->default_key && key)) {
659                 sdata->default_key = key;
660                 if (key)
661                         ieee80211_debugfs_key_add_default(sdata);
662
663                 if (local->ops->set_key_idx &&
664                     local->ops->set_key_idx(local_to_hw(local), idx))
665                         printk(KERN_DEBUG "%s: failed to set TX key idx for "
666                                "low-level driver\n", dev->name);
667         }
668
669         if (sta)
670                 sta_info_put(sta);
671
672         return 0;
673
674 err_free:
675         ieee80211_key_free(key);
676 err_out:
677         if (sta)
678                 sta_info_put(sta);
679         return ret;
680 }
681
682
683 static int ieee80211_ioctl_set_encryption(struct net_device *dev,
684                                           struct prism2_hostapd_param *param,
685                                           int param_len)
686 {
687         int alg;
688
689         param->u.crypt.err = 0;
690         param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0';
691
692         if (param_len <
693             (int) ((char *) param->u.crypt.key - (char *) param) +
694             param->u.crypt.key_len) {
695                 printk(KERN_DEBUG "%s: set_encrypt - invalid param_lem\n",
696                        dev->name);
697                 return -EINVAL;
698         }
699
700         if (strcmp(param->u.crypt.alg, "none") == 0)
701                 alg = ALG_NONE;
702         else if (strcmp(param->u.crypt.alg, "WEP") == 0)
703                 alg = ALG_WEP;
704         else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
705                 if (param->u.crypt.key_len != ALG_TKIP_KEY_LEN) {
706                         printk(KERN_DEBUG "%s: set_encrypt - invalid TKIP key "
707                                "length %d\n", dev->name,
708                                param->u.crypt.key_len);
709                         return -EINVAL;
710                 }
711                 alg = ALG_TKIP;
712         } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
713                 if (param->u.crypt.key_len != ALG_CCMP_KEY_LEN) {
714                         printk(KERN_DEBUG "%s: set_encrypt - invalid CCMP key "
715                                "length %d\n", dev->name,
716                                param->u.crypt.key_len);
717                         return -EINVAL;
718                 }
719                 alg = ALG_CCMP;
720         } else {
721                 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ALG;
722                 printk(KERN_DEBUG "%s: set_encrypt - unknown alg\n",
723                        dev->name);
724                 return -EINVAL;
725         }
726
727         return ieee80211_set_encryption(
728                 dev, param->sta_addr,
729                 param->u.crypt.idx, alg,
730                 param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY,
731                 &param->u.crypt.err, param->u.crypt.key,
732                 param->u.crypt.key_len);
733 }
734
735
736 static int ieee80211_ioctl_get_encryption(struct net_device *dev,
737                                           struct prism2_hostapd_param *param,
738                                           int param_len)
739 {
740         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
741         int ret = 0;
742         struct sta_info *sta;
743         struct ieee80211_key **key;
744         int max_key_len;
745         struct ieee80211_sub_if_data *sdata;
746         u8 *pos;
747
748         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
749
750         param->u.crypt.err = 0;
751
752         max_key_len = param_len -
753                 (int) ((char *) param->u.crypt.key - (char *) param);
754         if (max_key_len < 0)
755                 return -EINVAL;
756
757         if (is_broadcast_ether_addr(param->sta_addr)) {
758                 sta = NULL;
759                 if (param->u.crypt.idx >= NUM_DEFAULT_KEYS) {
760                         param->u.crypt.idx = sdata->default_key ?
761                                 sdata->default_key->keyidx : 0;
762                         return 0;
763                 } else
764                         key = &sdata->keys[param->u.crypt.idx];
765         } else {
766                 sta = sta_info_get(local, param->sta_addr);
767                 if (!sta) {
768                         param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
769                         return -EINVAL;
770                 }
771
772                 key = &sta->key;
773         }
774
775         memset(param->u.crypt.seq_counter, 0, HOSTAP_SEQ_COUNTER_SIZE);
776         if (!*key) {
777                 memcpy(param->u.crypt.alg, "none", 5);
778                 param->u.crypt.key_len = 0;
779                 param->u.crypt.idx = 0xff;
780         } else {
781                 switch ((*key)->alg) {
782                 case ALG_WEP:
783                         memcpy(param->u.crypt.alg, "WEP", 4);
784                         break;
785                 case ALG_TKIP:
786                 {
787                         u32 iv32;
788                         u16 iv16;
789
790                         memcpy(param->u.crypt.alg, "TKIP", 5);
791                         if (local->ops->get_sequence_counter) {
792                         /* Get transmit counter from low level driver */
793                                 if (local->ops->get_sequence_counter(
794                                                 local_to_hw(local),
795                                                 param->sta_addr,
796                                                 (*key)->keyidx,
797                                                 IEEE80211_SEQ_COUNTER_TX,
798                                                 &iv32,
799                                                 &iv16)) {
800                                         /* Error getting value from device */
801                                         return -EIO;
802                                 }
803                         } else {
804                                 /* Get it from our own local data */
805                                 iv32 = (*key)->u.tkip.iv32;
806                                 iv16 = (*key)->u.tkip.iv16;
807                         }
808                         pos = param->u.crypt.seq_counter;
809                         *pos++ = iv16 & 0xff;
810                         *pos++ = (iv16 >> 8) & 0xff;
811                         *pos++ = iv32 & 0xff;
812                         *pos++ = (iv32 >> 8) & 0xff;
813                         *pos++ = (iv32 >> 16) & 0xff;
814                         *pos++ = (iv32 >> 24) & 0xff;
815                         break;
816                         }
817                 case ALG_CCMP:
818                 {
819                         u8 *pn;
820                         memcpy(param->u.crypt.alg, "CCMP", 5);
821                         pos = param->u.crypt.seq_counter;
822                         pn = (*key)->u.ccmp.tx_pn;
823                         *pos++ = pn[5];
824                         *pos++ = pn[4];
825                         *pos++ = pn[3];
826                         *pos++ = pn[2];
827                         *pos++ = pn[1];
828                         *pos++ = pn[0];
829                         break;
830                 }
831                 default:
832                         memcpy(param->u.crypt.alg, "unknown", 8);
833                         break;
834                 }
835
836                 if (max_key_len < (*key)->keylen)
837                         ret = -E2BIG;
838                 else {
839                         param->u.crypt.key_len = (*key)->keylen;
840                         memcpy(param->u.crypt.key, (*key)->key,
841                                (*key)->keylen);
842                 }
843         }
844
845         if (sta)
846                 sta_info_put(sta);
847
848         return ret;
849 }
850
851
852 #ifdef CONFIG_HOSTAPD_WPA_TESTING
853 static int ieee80211_ioctl_wpa_trigger(struct net_device *dev,
854                                        struct prism2_hostapd_param *param)
855 {
856         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
857         struct sta_info *sta;
858
859         if (is_broadcast_ether_addr(param->sta_addr)) {
860                 local->wpa_trigger = param->u.wpa_trigger.trigger;
861                 return 0;
862         }
863
864         sta = sta_info_get(local, param->sta_addr);
865         if (!sta) {
866                 printk(KERN_DEBUG "%s: wpa_trigger - unknown addr\n",
867                        dev->name);
868                 return -EINVAL;
869         }
870
871         sta->wpa_trigger = param->u.wpa_trigger.trigger;
872
873         sta_info_put(sta);
874         return 0;
875 }
876 #endif /* CONFIG_HOSTAPD_WPA_TESTING */
877
878
879 static int ieee80211_ioctl_set_rate_sets(struct net_device *dev,
880                                          struct prism2_hostapd_param *param,
881                                          int param_len)
882 {
883         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
884         u16 *pos = (u16 *) param->u.set_rate_sets.data;
885         int left = param_len - ((u8 *) pos - (u8 *) param);
886         int i, mode, num_supp, num_basic, *supp, *basic, *prev;
887         struct ieee80211_hw_mode *hw_mode;
888
889         mode = param->u.set_rate_sets.mode;
890         num_supp = param->u.set_rate_sets.num_supported_rates;
891         num_basic = param->u.set_rate_sets.num_basic_rates;
892
893         if (left < (num_supp + num_basic) * 2) {
894                 printk(KERN_WARNING "%s: invalid length in hostapd set rate "
895                        "sets ioctl (%d != %d)\n", dev->name, left,
896                        (num_supp + num_basic) * 2);
897                 return -EINVAL;
898         }
899
900         supp = (int *) kmalloc((num_supp + 1) * sizeof(int), GFP_KERNEL);
901         basic = (int *) kmalloc((num_basic + 1) * sizeof(int), GFP_KERNEL);
902
903         if (!supp || !basic) {
904                 kfree(supp);
905                 kfree(basic);
906                 return -ENOMEM;
907         }
908
909         for (i = 0; i < num_supp; i++)
910                 supp[i] = *pos++;
911         supp[i] = -1;
912
913         for (i = 0; i < num_basic; i++)
914                 basic[i] = *pos++;
915         basic[i] = -1;
916
917         if (num_supp == 0) {
918                 kfree(supp);
919                 supp = NULL;
920         }
921
922         if (num_basic == 0) {
923                 kfree(basic);
924                 basic = NULL;
925         }
926
927         prev = local->supp_rates[mode];
928         local->supp_rates[mode] = supp;
929         kfree(prev);
930
931         prev = local->basic_rates[mode];
932         local->basic_rates[mode] = basic;
933         kfree(prev);
934
935         /* TODO: should update STA TX rates and remove STAs if they
936          * do not have any remaining supported rates after the change
937          */
938         list_for_each_entry(hw_mode, &local->modes_list, list)
939                 if (hw_mode->mode == mode)
940                         ieee80211_prepare_rates(local, hw_mode);
941
942         return 0;
943 }
944
945
946 static int ieee80211_ioctl_add_if(struct net_device *dev,
947                                   struct prism2_hostapd_param *param,
948                                   int param_len)
949 {
950         u8 *pos = param->u.if_info.data;
951         int left = param_len - ((u8 *) pos - (u8 *) param);
952         struct net_device *new_dev;
953         int res;
954         struct hostapd_if_wds *wds;
955         struct hostapd_if_bss *bss;
956
957         printk(KERN_WARNING "PRISM2_HOSTAPD_ADD_IF ioctl is deprecated!");
958         switch (param->u.if_info.type) {
959         case HOSTAP_IF_WDS:
960                 wds = (struct hostapd_if_wds *) param->u.if_info.data;
961
962                 if (left < sizeof(struct hostapd_if_wds))
963                         return -EPROTO;
964
965                 res = ieee80211_if_add(dev, param->u.if_info.name, &new_dev,
966                                        IEEE80211_IF_TYPE_WDS);
967                 if (res)
968                         return res;
969                 res = ieee80211_if_update_wds(new_dev, wds->remote_addr);
970                 if (unlikely(res)) {
971                         struct ieee80211_local *local =
972                                 wdev_priv(dev->ieee80211_ptr);
973                         struct ieee80211_sub_if_data *sdata =
974                                 IEEE80211_DEV_TO_SUB_IF(new_dev);
975                         write_lock_bh(&local->sub_if_lock);
976                         list_del(&sdata->list);
977                         write_unlock_bh(&local->sub_if_lock);
978                         __ieee80211_if_del(local, sdata);
979                 }
980                 return res;
981         case HOSTAP_IF_VLAN:
982                 if (left < sizeof(struct hostapd_if_vlan))
983                         return -EPROTO;
984
985                 res = ieee80211_if_add(dev, param->u.if_info.name, NULL,
986                                        IEEE80211_IF_TYPE_VLAN);
987                 return res;
988         case HOSTAP_IF_BSS:
989                 bss = (struct hostapd_if_bss *) param->u.if_info.data;
990
991                 if (left < sizeof(struct hostapd_if_bss))
992                         return -EPROTO;
993
994                 res = ieee80211_if_add(dev, param->u.if_info.name, &new_dev,
995                                        IEEE80211_IF_TYPE_AP);
996                 if (res)
997                         return res;
998                 memcpy(new_dev->dev_addr, bss->bssid, ETH_ALEN);
999                 return 0;
1000         case HOSTAP_IF_STA:
1001                 if (left < sizeof(struct hostapd_if_sta))
1002                         return -EPROTO;
1003
1004                 res = ieee80211_if_add(dev, param->u.if_info.name, NULL,
1005                                        IEEE80211_IF_TYPE_STA);
1006                 return res;
1007         default:
1008                 return -EINVAL;
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int ieee80211_ioctl_remove_if(struct net_device *dev,
1015                                      struct prism2_hostapd_param *param)
1016 {
1017         unsigned int type;
1018
1019         switch (param->u.if_info.type) {
1020         case HOSTAP_IF_WDS:
1021                 type = IEEE80211_IF_TYPE_WDS;
1022                 break;
1023         case HOSTAP_IF_VLAN:
1024                 type = IEEE80211_IF_TYPE_VLAN;
1025                 break;
1026         case HOSTAP_IF_BSS:
1027                 type = IEEE80211_IF_TYPE_AP;
1028                 break;
1029         case HOSTAP_IF_STA:
1030                 type = IEEE80211_IF_TYPE_STA;
1031                 break;
1032         default:
1033                 return -EINVAL;
1034         }
1035
1036         return ieee80211_if_remove(dev, param->u.if_info.name, type);
1037 }
1038
1039 static int ieee80211_ioctl_update_if(struct net_device *dev,
1040                                      struct prism2_hostapd_param *param,
1041                                      int param_len)
1042 {
1043         u8 *pos = param->u.if_info.data;
1044         int left = param_len - ((u8 *) pos - (u8 *) param);
1045
1046         if (param->u.if_info.type == HOSTAP_IF_WDS) {
1047                 struct hostapd_if_wds *wds =
1048                         (struct hostapd_if_wds *) param->u.if_info.data;
1049                 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1050                 struct net_device *wds_dev = NULL;
1051                 struct ieee80211_sub_if_data *sdata;
1052
1053                 if (left < sizeof(struct ieee80211_if_wds))
1054                         return -EPROTO;
1055
1056                 read_lock(&local->sub_if_lock);
1057                 list_for_each_entry(sdata, &local->sub_if_list, list) {
1058                         if (strcmp(param->u.if_info.name,
1059                                    sdata->dev->name) == 0) {
1060                                 wds_dev = sdata->dev;
1061                                 break;
1062                         }
1063                 }
1064                 read_unlock(&local->sub_if_lock);
1065
1066                 if (!wds_dev || sdata->type != IEEE80211_IF_TYPE_WDS)
1067                         return -ENODEV;
1068
1069                 return ieee80211_if_update_wds(wds_dev, wds->remote_addr);
1070         } else {
1071                 return -EOPNOTSUPP;
1072         }
1073 }
1074
1075
1076 static int ieee80211_ioctl_scan_req(struct net_device *dev,
1077                                     struct prism2_hostapd_param *param,
1078                                     int param_len)
1079 {
1080         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1081         u8 *pos = param->u.scan_req.ssid;
1082         int left = param_len - ((u8 *) pos - (u8 *) param);
1083         int len = param->u.scan_req.ssid_len;
1084
1085         if (local->user_space_mlme)
1086                 return -EOPNOTSUPP;
1087
1088         if (!netif_running(dev))
1089                 return -ENETDOWN;
1090
1091         if (left < len || len > IEEE80211_MAX_SSID_LEN)
1092                 return -EINVAL;
1093
1094         return ieee80211_sta_req_scan(dev, pos, len);
1095 }
1096
1097
1098 static int ieee80211_ioctl_sta_get_state(struct net_device *dev,
1099                                          struct prism2_hostapd_param *param)
1100 {
1101         struct ieee80211_sub_if_data *sdata;
1102
1103         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1104         if (sdata->type != IEEE80211_IF_TYPE_STA &&
1105             sdata->type != IEEE80211_IF_TYPE_IBSS)
1106                 return -EINVAL;
1107         param->u.sta_get_state.state = sdata->u.sta.state;
1108         return 0;
1109 }
1110
1111
1112 static int ieee80211_ioctl_mlme(struct net_device *dev,
1113                                 struct prism2_hostapd_param *param)
1114 {
1115         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1116         struct ieee80211_sub_if_data *sdata;
1117
1118         if (local->user_space_mlme)
1119                 return -EOPNOTSUPP;
1120
1121         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1122         if (sdata->type != IEEE80211_IF_TYPE_STA &&
1123             sdata->type != IEEE80211_IF_TYPE_IBSS)
1124                 return -EINVAL;
1125         switch (param->u.mlme.cmd) {
1126         case MLME_STA_DEAUTH:
1127                 return ieee80211_sta_deauthenticate(dev, param->u.mlme.reason_code);
1128         case MLME_STA_DISASSOC:
1129                 return ieee80211_sta_disassociate(dev, param->u.mlme.reason_code);
1130         }
1131         return 0;
1132 }
1133
1134
1135 static int ieee80211_ioctl_get_load_stats(struct net_device *dev,
1136                                           struct prism2_hostapd_param *param)
1137 {
1138         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1139
1140         param->u.get_load_stats.channel_use = local->channel_use;
1141 /*      if (param->u.get_load_stats.flags & LOAD_STATS_CLEAR)
1142                 local->channel_use = 0; */ /* now it's not raw counter */
1143
1144         return 0;
1145 }
1146
1147
1148 static int ieee80211_ioctl_set_sta_vlan(struct net_device *dev,
1149                                         struct prism2_hostapd_param *param)
1150 {
1151         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1152         struct sta_info *sta;
1153
1154         sta = sta_info_get(local, param->sta_addr);
1155         if (sta) {
1156                 struct net_device *new_vlan_dev;
1157                 new_vlan_dev =
1158                         dev_get_by_name(param->u.set_sta_vlan.vlan_name);
1159                 if (new_vlan_dev) {
1160 #if 0
1161                         printk("%s: Station " MAC_FMT " moved to vlan: %s\n",
1162                                dev->name, MAC_ARG(param->sta_addr),
1163                                new_vlan_dev->name);
1164 #endif
1165                         if (sta->dev != new_vlan_dev) {
1166                                 ieee80211_send_layer2_update(new_vlan_dev,
1167                                                              sta->addr);
1168                         }
1169                         sta->dev = new_vlan_dev;
1170                         sta->vlan_id = param->u.set_sta_vlan.vlan_id;
1171                         dev_put(new_vlan_dev);
1172                 }
1173                 sta_info_put(sta);
1174         }
1175
1176         return sta ? 0 : -ENOENT;
1177 }
1178
1179
1180 static int ieee80211_set_gen_ie(struct net_device *dev, u8 *ie, size_t len)
1181 {
1182         struct ieee80211_sub_if_data *sdata;
1183         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1184
1185         if (local->user_space_mlme)
1186                 return -EOPNOTSUPP;
1187
1188         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1189         if (sdata->type == IEEE80211_IF_TYPE_STA ||
1190             sdata->type == IEEE80211_IF_TYPE_IBSS) {
1191                 int ret = ieee80211_sta_set_extra_ie(dev, ie, len);
1192                 if (ret)
1193                         return ret;
1194                 sdata->u.sta.auto_bssid_sel = 0;
1195                 ieee80211_sta_req_auth(dev, &sdata->u.sta);
1196                 return 0;
1197         }
1198
1199         if (sdata->type == IEEE80211_IF_TYPE_AP) {
1200                 kfree(sdata->u.ap.generic_elem);
1201                 sdata->u.ap.generic_elem = kmalloc(len, GFP_KERNEL);
1202                 if (!sdata->u.ap.generic_elem)
1203                         return -ENOMEM;
1204                 memcpy(sdata->u.ap.generic_elem, ie, len);
1205                 sdata->u.ap.generic_elem_len = len;
1206                 return ieee80211_if_config(dev);
1207         }
1208         return -EOPNOTSUPP;
1209 }
1210
1211
1212 static int
1213 ieee80211_ioctl_set_generic_info_elem(struct net_device *dev,
1214                                       struct prism2_hostapd_param *param,
1215                                       int param_len)
1216 {
1217         u8 *pos = param->u.set_generic_info_elem.data;
1218         int left = param_len - ((u8 *) pos - (u8 *) param);
1219         int len = param->u.set_generic_info_elem.len;
1220
1221         if (left < len)
1222                 return -EINVAL;
1223
1224         return ieee80211_set_gen_ie(dev, pos, len);
1225 }
1226
1227
1228 static int ieee80211_ioctl_set_regulatory_domain(struct net_device *dev,
1229                                             struct prism2_hostapd_param *param)
1230 {
1231         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1232         struct ieee80211_conf *conf = &local->hw.conf;
1233         conf->regulatory_domain = param->u.set_regulatory_domain.rd;
1234         return 0;
1235 }
1236
1237
1238 static int ieee80211_ioctl_set_radio_enabled(struct net_device *dev,
1239                                              int val)
1240 {
1241         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1242         struct ieee80211_conf *conf = &local->hw.conf;
1243
1244         conf->radio_enabled = val;
1245         return ieee80211_hw_config(wdev_priv(dev->ieee80211_ptr));
1246 }
1247
1248 static int
1249 ieee80211_ioctl_set_tx_queue_params(struct net_device *dev,
1250                                     struct prism2_hostapd_param *param)
1251 {
1252         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1253         struct ieee80211_tx_queue_params qparam;
1254
1255         if (!local->ops->conf_tx) {
1256                 printk(KERN_DEBUG "%s: low-level driver does not support TX "
1257                        "queue configuration\n", dev->name);
1258                 return -EOPNOTSUPP;
1259         }
1260
1261         memset(&qparam, 0, sizeof(qparam));
1262         qparam.aifs = param->u.tx_queue_params.aifs;
1263         qparam.cw_min = param->u.tx_queue_params.cw_min;
1264         qparam.cw_max = param->u.tx_queue_params.cw_max;
1265         qparam.burst_time = param->u.tx_queue_params.burst_time;
1266
1267         return local->ops->conf_tx(local_to_hw(local),
1268                                   param->u.tx_queue_params.queue,
1269                                   &qparam);
1270 }
1271
1272
1273 static int ieee80211_ioctl_get_tx_stats(struct net_device *dev,
1274                                         struct prism2_hostapd_param *param)
1275 {
1276         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1277         struct ieee80211_tx_queue_stats stats;
1278         int ret, i;
1279
1280         if (!local->ops->get_tx_stats)
1281                 return -EOPNOTSUPP;
1282
1283         memset(&stats, 0, sizeof(stats));
1284         ret = local->ops->get_tx_stats(local_to_hw(local), &stats);
1285         if (ret)
1286                 return ret;
1287
1288         for (i = 0; i < 4; i++) {
1289                 param->u.get_tx_stats.data[i].len = stats.data[i].len;
1290                 param->u.get_tx_stats.data[i].limit = stats.data[i].limit;
1291                 param->u.get_tx_stats.data[i].count = stats.data[i].count;
1292         }
1293
1294         return 0;
1295 }
1296
1297
1298 static int ieee80211_ioctl_set_channel_flag(struct net_device *dev,
1299                                             struct prism2_hostapd_param *param)
1300 {
1301         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1302         struct ieee80211_hw_mode *mode;
1303         struct ieee80211_channel *chan = NULL;
1304         int i;
1305
1306         list_for_each_entry(mode, &local->modes_list, list) {
1307                 if (mode->mode == param->u.set_channel_flag.mode)
1308                         goto found;
1309         }
1310         return -ENOENT;
1311 found:
1312
1313         for (i = 0; i < mode->num_channels; i++) {
1314                 chan = &mode->channels[i];
1315                 if (chan->chan == param->u.set_channel_flag.chan)
1316                         break;
1317                 chan = NULL;
1318         }
1319
1320         if (!chan)
1321                 return -ENOENT;
1322
1323         chan->flag = param->u.set_channel_flag.flag;
1324         chan->power_level = param->u.set_channel_flag.power_level;
1325         chan->antenna_max = param->u.set_channel_flag.antenna_max;
1326
1327         return 0;
1328 }
1329
1330
1331 static int ieee80211_ioctl_set_quiet_params(struct net_device *dev,
1332                                             struct prism2_hostapd_param *param)
1333 {
1334         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1335         struct ieee80211_conf *conf = &local->hw.conf;
1336
1337         conf->quiet_duration = param->u.quiet.duration;
1338         conf->quiet_offset = param->u.quiet.offset;
1339         conf->quiet_period = param->u.quiet.period;
1340         return 0;
1341 }
1342
1343
1344 static int ieee80211_ioctl_set_radar_params(struct net_device *dev,
1345                                             struct prism2_hostapd_param *param)
1346 {
1347         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1348         struct ieee80211_conf *conf = &local->hw.conf;
1349
1350         conf->radar_firpwr_threshold = param->u.radar.radar_firpwr_threshold;
1351         conf->radar_rssi_threshold = param->u.radar.radar_rssi_threshold;
1352         conf->pulse_height_threshold = param->u.radar.pulse_height_threshold;
1353         conf->pulse_rssi_threshold = param->u.radar.pulse_rssi_threshold;
1354         conf->pulse_inband_threshold = param->u.radar.pulse_inband_threshold;
1355         return 0;
1356 }
1357
1358
1359 static int ieee80211_ioctl_priv_hostapd(struct net_device *dev,
1360                                         struct iw_point *p)
1361 {
1362         struct prism2_hostapd_param *param;
1363         int ret = 0;
1364
1365         if (p->length < sizeof(struct prism2_hostapd_param) ||
1366             p->length > PRISM2_HOSTAPD_MAX_BUF_SIZE || !p->pointer) {
1367                 printk(KERN_DEBUG "%s: hostapd ioctl: ptr=%p len=%d min=%d "
1368                        "max=%d\n", dev->name, p->pointer, p->length,
1369                        (int)sizeof(struct prism2_hostapd_param),
1370                        PRISM2_HOSTAPD_MAX_BUF_SIZE);
1371                 return -EINVAL;
1372         }
1373
1374         param = (struct prism2_hostapd_param *) kmalloc(p->length, GFP_KERNEL);
1375         if (!param)
1376                 return -ENOMEM;
1377
1378         if (copy_from_user(param, p->pointer, p->length)) {
1379                 ret = -EFAULT;
1380                 goto out;
1381         }
1382
1383         switch (param->cmd) {
1384         case PRISM2_HOSTAPD_FLUSH:
1385                 ret = ieee80211_ioctl_flush(dev, param);
1386                 break;
1387         case PRISM2_HOSTAPD_ADD_STA:
1388                 ret = ieee80211_ioctl_add_sta(dev, param);
1389                 break;
1390         case PRISM2_HOSTAPD_REMOVE_STA:
1391                 ret = ieee80211_ioctl_remove_sta(dev, param);
1392                 break;
1393         case PRISM2_HOSTAPD_GET_INFO_STA:
1394                 ret = ieee80211_ioctl_get_info_sta(dev, param);
1395                 break;
1396         case PRISM2_SET_ENCRYPTION:
1397                 ret = ieee80211_ioctl_set_encryption(dev, param, p->length);
1398                 break;
1399         case PRISM2_GET_ENCRYPTION:
1400                 ret = ieee80211_ioctl_get_encryption(dev, param, p->length);
1401                 break;
1402         case PRISM2_HOSTAPD_SET_FLAGS_STA:
1403                 ret = ieee80211_ioctl_set_flags_sta(dev, param);
1404                 break;
1405         case PRISM2_HOSTAPD_SET_BEACON:
1406                 ret = ieee80211_ioctl_set_beacon(dev, param, p->length, 0);
1407                 break;
1408         case PRISM2_HOSTAPD_GET_HW_FEATURES:
1409                 ret = ieee80211_ioctl_get_hw_features(dev, param, p->length);
1410                 break;
1411 #ifdef CONFIG_HOSTAPD_WPA_TESTING
1412         case PRISM2_HOSTAPD_WPA_TRIGGER:
1413                 ret = ieee80211_ioctl_wpa_trigger(dev, param);
1414                 break;
1415 #endif /* CONFIG_HOSTAPD_WPA_TESTING */
1416         case PRISM2_HOSTAPD_SET_RATE_SETS:
1417                 ret = ieee80211_ioctl_set_rate_sets(dev, param, p->length);
1418                 break;
1419         case PRISM2_HOSTAPD_ADD_IF:
1420                 ret = ieee80211_ioctl_add_if(dev, param, p->length);
1421                 break;
1422         case PRISM2_HOSTAPD_REMOVE_IF:
1423                 ret = ieee80211_ioctl_remove_if(dev, param);
1424                 break;
1425         case PRISM2_HOSTAPD_GET_DOT11COUNTERSTABLE:
1426                 ret = ieee80211_ioctl_get_dot11counterstable(dev, param);
1427                 break;
1428         case PRISM2_HOSTAPD_GET_LOAD_STATS:
1429                 ret = ieee80211_ioctl_get_load_stats(dev, param);
1430                 break;
1431         case PRISM2_HOSTAPD_SET_STA_VLAN:
1432                 ret = ieee80211_ioctl_set_sta_vlan(dev, param);
1433                 break;
1434         case PRISM2_HOSTAPD_SET_GENERIC_INFO_ELEM:
1435                 ret = ieee80211_ioctl_set_generic_info_elem(dev, param,
1436                                                             p->length);
1437                 break;
1438         case PRISM2_HOSTAPD_SET_CHANNEL_FLAG:
1439                 ret = ieee80211_ioctl_set_channel_flag(dev, param);
1440                 break;
1441         case PRISM2_HOSTAPD_SET_REGULATORY_DOMAIN:
1442                 ret = ieee80211_ioctl_set_regulatory_domain(dev, param);
1443                 break;
1444         case PRISM2_HOSTAPD_SET_TX_QUEUE_PARAMS:
1445                 ret = ieee80211_ioctl_set_tx_queue_params(dev, param);
1446                 break;
1447         case PRISM2_HOSTAPD_GET_TX_STATS:
1448                 ret = ieee80211_ioctl_get_tx_stats(dev, param);
1449                 break;
1450         case PRISM2_HOSTAPD_UPDATE_IF:
1451                 ret = ieee80211_ioctl_update_if(dev, param, p->length);
1452                 break;
1453         case PRISM2_HOSTAPD_SCAN_REQ:
1454                 ret = ieee80211_ioctl_scan_req(dev, param, p->length);
1455                 break;
1456         case PRISM2_STA_GET_STATE:
1457                 ret = ieee80211_ioctl_sta_get_state(dev, param);
1458                 break;
1459         case PRISM2_HOSTAPD_MLME:
1460                 ret = ieee80211_ioctl_mlme(dev, param);
1461                 break;
1462         case PRISM2_HOSTAPD_SET_RADAR_PARAMS:
1463                 ret = ieee80211_ioctl_set_radar_params(dev, param);
1464                 break;
1465         case PRISM2_HOSTAPD_SET_QUIET_PARAMS:
1466                 ret = ieee80211_ioctl_set_quiet_params(dev, param);
1467                 break;
1468         default:
1469                 ret = -EOPNOTSUPP;
1470                 break;
1471         }
1472
1473         if (copy_to_user(p->pointer, param, p->length))
1474                 ret = -EFAULT;
1475
1476  out:
1477         kfree(param);
1478
1479         return ret;
1480 }
1481
1482
1483 static int ieee80211_ioctl_giwname(struct net_device *dev,
1484                                    struct iw_request_info *info,
1485                                    char *name, char *extra)
1486 {
1487         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1488
1489         switch (local->hw.conf.phymode) {
1490         case MODE_IEEE80211A:
1491                 strcpy(name, "IEEE 802.11a");
1492                 break;
1493         case MODE_IEEE80211B:
1494                 strcpy(name, "IEEE 802.11b");
1495                 break;
1496         case MODE_IEEE80211G:
1497                 strcpy(name, "IEEE 802.11g");
1498                 break;
1499         case MODE_ATHEROS_TURBO:
1500                 strcpy(name, "5GHz Turbo");
1501                 break;
1502         default:
1503                 strcpy(name, "IEEE 802.11");
1504                 break;
1505         }
1506
1507         return 0;
1508 }
1509
1510
1511 static int ieee80211_ioctl_giwrange(struct net_device *dev,
1512                                  struct iw_request_info *info,
1513                                  struct iw_point *data, char *extra)
1514 {
1515         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1516         struct iw_range *range = (struct iw_range *) extra;
1517
1518         data->length = sizeof(struct iw_range);
1519         memset(range, 0, sizeof(struct iw_range));
1520
1521         range->we_version_compiled = WIRELESS_EXT;
1522         range->we_version_source = 21;
1523         range->retry_capa = IW_RETRY_LIMIT;
1524         range->retry_flags = IW_RETRY_LIMIT;
1525         range->min_retry = 0;
1526         range->max_retry = 255;
1527         range->min_rts = 0;
1528         range->max_rts = 2347;
1529         range->min_frag = 256;
1530         range->max_frag = 2346;
1531
1532         range->encoding_size[0] = 5;
1533         range->encoding_size[1] = 13;
1534         range->num_encoding_sizes = 2;
1535         range->max_encoding_tokens = NUM_DEFAULT_KEYS;
1536
1537         range->max_qual.qual = local->hw.max_signal;
1538         range->max_qual.level = local->hw.max_rssi;
1539         range->max_qual.noise = local->hw.max_noise;
1540         range->max_qual.updated = local->wstats_flags;
1541
1542         range->avg_qual.qual = local->hw.max_signal/2;
1543         range->avg_qual.level = 0;
1544         range->avg_qual.noise = 0;
1545         range->avg_qual.updated = local->wstats_flags;
1546
1547         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
1548                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
1549
1550         IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
1551         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWTHRSPY);
1552         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
1553         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
1554
1555         return 0;
1556 }
1557
1558
1559 struct ieee80211_channel_range {
1560         short start_freq;
1561         short end_freq;
1562         unsigned char power_level;
1563         unsigned char antenna_max;
1564 };
1565
1566 static const struct ieee80211_channel_range ieee80211_fcc_channels[] = {
1567         { 2412, 2462, 27, 6 } /* IEEE 802.11b/g, channels 1..11 */,
1568         { 5180, 5240, 17, 6 } /* IEEE 802.11a, channels 36..48 */,
1569         { 5260, 5320, 23, 6 } /* IEEE 802.11a, channels 52..64 */,
1570         { 5745, 5825, 30, 6 } /* IEEE 802.11a, channels 149..165, outdoor */,
1571         { 0 }
1572 };
1573
1574 static const struct ieee80211_channel_range ieee80211_mkk_channels[] = {
1575         { 2412, 2472, 20, 6 } /* IEEE 802.11b/g, channels 1..13 */,
1576         { 5170, 5240, 20, 6 } /* IEEE 802.11a, channels 34..48 */,
1577         { 5260, 5320, 20, 6 } /* IEEE 802.11a, channels 52..64 */,
1578         { 0 }
1579 };
1580
1581
1582 static const struct ieee80211_channel_range *channel_range =
1583         ieee80211_fcc_channels;
1584
1585
1586 static void ieee80211_unmask_channel(struct net_device *dev, int mode,
1587                                      struct ieee80211_channel *chan)
1588 {
1589         int i;
1590
1591         chan->flag = 0;
1592
1593         if (ieee80211_regdom == 64 &&
1594             (mode == MODE_ATHEROS_TURBO || mode == MODE_ATHEROS_TURBOG)) {
1595                 /* Do not allow Turbo modes in Japan. */
1596                 return;
1597         }
1598
1599         for (i = 0; channel_range[i].start_freq; i++) {
1600                 const struct ieee80211_channel_range *r = &channel_range[i];
1601                 if (r->start_freq <= chan->freq && r->end_freq >= chan->freq) {
1602                         if (ieee80211_regdom == 64 && !ieee80211_japan_5ghz &&
1603                             chan->freq >= 5260 && chan->freq <= 5320) {
1604                                 /*
1605                                  * Skip new channels in Japan since the
1606                                  * firmware was not marked having been upgraded
1607                                  * by the vendor.
1608                                  */
1609                                 continue;
1610                         }
1611
1612                         if (ieee80211_regdom == 0x10 &&
1613                             (chan->freq == 5190 || chan->freq == 5210 ||
1614                              chan->freq == 5230)) {
1615                                     /* Skip MKK channels when in FCC domain. */
1616                                     continue;
1617                         }
1618
1619                         chan->flag |= IEEE80211_CHAN_W_SCAN |
1620                                 IEEE80211_CHAN_W_ACTIVE_SCAN |
1621                                 IEEE80211_CHAN_W_IBSS;
1622                         chan->power_level = r->power_level;
1623                         chan->antenna_max = r->antenna_max;
1624
1625                         if (ieee80211_regdom == 64 &&
1626                             (chan->freq == 5170 || chan->freq == 5190 ||
1627                              chan->freq == 5210 || chan->freq == 5230)) {
1628                                 /*
1629                                  * New regulatory rules in Japan have backwards
1630                                  * compatibility with old channels in 5.15-5.25
1631                                  * GHz band, but the station is not allowed to
1632                                  * use active scan on these old channels.
1633                                  */
1634                                 chan->flag &= ~IEEE80211_CHAN_W_ACTIVE_SCAN;
1635                         }
1636
1637                         if (ieee80211_regdom == 64 &&
1638                             (chan->freq == 5260 || chan->freq == 5280 ||
1639                              chan->freq == 5300 || chan->freq == 5320)) {
1640                                 /*
1641                                  * IBSS is not allowed on 5.25-5.35 GHz band
1642                                  * due to radar detection requirements.
1643                                  */
1644                                 chan->flag &= ~IEEE80211_CHAN_W_IBSS;
1645                         }
1646
1647                         break;
1648                 }
1649         }
1650 }
1651
1652
1653 static int ieee80211_unmask_channels(struct net_device *dev)
1654 {
1655         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1656         struct ieee80211_hw_mode *mode;
1657         int c;
1658
1659         list_for_each_entry(mode, &local->modes_list, list) {
1660                 for (c = 0; c < mode->num_channels; c++) {
1661                         ieee80211_unmask_channel(dev, mode->mode,
1662                                                  &mode->channels[c]);
1663                 }
1664         }
1665         return 0;
1666 }
1667
1668
1669 int ieee80211_init_client(struct net_device *dev)
1670 {
1671         if (ieee80211_regdom == 0x40)
1672                 channel_range = ieee80211_mkk_channels;
1673         ieee80211_unmask_channels(dev);
1674         return 0;
1675 }
1676
1677
1678 static int ieee80211_ioctl_siwmode(struct net_device *dev,
1679                                    struct iw_request_info *info,
1680                                    __u32 *mode, char *extra)
1681 {
1682         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1683         int type;
1684
1685         if (sdata->type == IEEE80211_IF_TYPE_VLAN)
1686                 return -EOPNOTSUPP;
1687
1688         switch (*mode) {
1689         case IW_MODE_MASTER:
1690                 type = IEEE80211_IF_TYPE_AP;
1691                 break;
1692         case IW_MODE_INFRA:
1693                 type = IEEE80211_IF_TYPE_STA;
1694                 break;
1695         case IW_MODE_ADHOC:
1696                 type = IEEE80211_IF_TYPE_IBSS;
1697                 break;
1698         case IW_MODE_MONITOR:
1699                 type = IEEE80211_IF_TYPE_MNTR;
1700                 break;
1701         case IW_MODE_REPEAT:
1702                 type = IEEE80211_IF_TYPE_WDS;
1703                 break;
1704         default:
1705                 return -EINVAL;
1706         }
1707
1708         if (type == sdata->type)
1709                 return 0;
1710         if (netif_running(dev))
1711                 return -EBUSY;
1712
1713         ieee80211_if_reinit(dev);
1714         ieee80211_if_set_type(dev, type);
1715
1716         return 0;
1717 }
1718
1719
1720 static int ieee80211_ioctl_giwmode(struct net_device *dev,
1721                                    struct iw_request_info *info,
1722                                    __u32 *mode, char *extra)
1723 {
1724         struct ieee80211_sub_if_data *sdata;
1725
1726         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1727         switch (sdata->type) {
1728         case IEEE80211_IF_TYPE_AP:
1729                 *mode = IW_MODE_MASTER;
1730                 break;
1731         case IEEE80211_IF_TYPE_STA:
1732                 *mode = IW_MODE_INFRA;
1733                 break;
1734         case IEEE80211_IF_TYPE_IBSS:
1735                 *mode = IW_MODE_ADHOC;
1736                 break;
1737         case IEEE80211_IF_TYPE_MNTR:
1738                 *mode = IW_MODE_MONITOR;
1739                 break;
1740         case IEEE80211_IF_TYPE_WDS:
1741                 *mode = IW_MODE_REPEAT;
1742                 break;
1743         case IEEE80211_IF_TYPE_VLAN:
1744                 *mode = IW_MODE_SECOND;         /* FIXME */
1745                 break;
1746         default:
1747                 *mode = IW_MODE_AUTO;
1748                 break;
1749         }
1750         return 0;
1751 }
1752
1753 int ieee80211_set_channel(struct ieee80211_local *local, int channel, int freq)
1754 {
1755         struct ieee80211_hw_mode *mode;
1756         int c, set = 0;
1757         int ret = -EINVAL;
1758
1759         list_for_each_entry(mode, &local->modes_list, list) {
1760                 if (!(local->enabled_modes & (1 << mode->mode)))
1761                         continue;
1762                 for (c = 0; c < mode->num_channels; c++) {
1763                         struct ieee80211_channel *chan = &mode->channels[c];
1764                         if (chan->flag & IEEE80211_CHAN_W_SCAN &&
1765                             ((chan->chan == channel) || (chan->freq == freq))) {
1766                                 /* Use next_mode as the mode preference to
1767                                  * resolve non-unique channel numbers. */
1768                                 if (set && mode->mode != local->next_mode)
1769                                         continue;
1770
1771                                 local->oper_channel = chan;
1772                                 local->oper_hw_mode = mode;
1773                                 set++;
1774                         }
1775                 }
1776         }
1777
1778         if (set) {
1779                 if (local->sta_scanning)
1780                         ret = 0;
1781                 else
1782                         ret = ieee80211_hw_config(local);
1783
1784                 rate_control_clear(local);
1785         }
1786
1787         return ret;
1788 }
1789
1790 static int ieee80211_ioctl_siwfreq(struct net_device *dev,
1791                                    struct iw_request_info *info,
1792                                    struct iw_freq *freq, char *extra)
1793 {
1794         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1795         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1796
1797         if (sdata->type == IEEE80211_IF_TYPE_STA)
1798                 sdata->u.sta.auto_channel_sel = 0;
1799
1800         /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
1801         if (freq->e == 0) {
1802                 if (freq->m < 0) {
1803                         if (sdata->type == IEEE80211_IF_TYPE_STA)
1804                                 sdata->u.sta.auto_channel_sel = 1;
1805                         return 0;
1806                 } else
1807                         return ieee80211_set_channel(local, freq->m, -1);
1808         } else {
1809                 int i, div = 1000000;
1810                 for (i = 0; i < freq->e; i++)
1811                         div /= 10;
1812                 if (div > 0)
1813                         return ieee80211_set_channel(local, -1, freq->m / div);
1814                 else
1815                         return -EINVAL;
1816         }
1817 }
1818
1819
1820 static int ieee80211_ioctl_giwfreq(struct net_device *dev,
1821                                    struct iw_request_info *info,
1822                                    struct iw_freq *freq, char *extra)
1823 {
1824         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1825
1826         /* TODO: in station mode (Managed/Ad-hoc) might need to poll low-level
1827          * driver for the current channel with firmware-based management */
1828
1829         freq->m = local->hw.conf.freq;
1830         freq->e = 6;
1831
1832         return 0;
1833 }
1834
1835
1836 static int ieee80211_ioctl_siwessid(struct net_device *dev,
1837                                     struct iw_request_info *info,
1838                                     struct iw_point *data, char *ssid)
1839 {
1840         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1841         struct ieee80211_sub_if_data *sdata;
1842         size_t len = data->length;
1843
1844         /* iwconfig uses nul termination in SSID.. */
1845         if (len > 0 && ssid[len - 1] == '\0')
1846                 len--;
1847
1848         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1849         if (sdata->type == IEEE80211_IF_TYPE_STA ||
1850             sdata->type == IEEE80211_IF_TYPE_IBSS) {
1851                 int ret;
1852                 if (local->user_space_mlme) {
1853                         if (len > IEEE80211_MAX_SSID_LEN)
1854                                 return -EINVAL;
1855                         memcpy(sdata->u.sta.ssid, ssid, len);
1856                         sdata->u.sta.ssid_len = len;
1857                         return 0;
1858                 }
1859                 sdata->u.sta.auto_ssid_sel = !data->flags;
1860                 ret = ieee80211_sta_set_ssid(dev, ssid, len);
1861                 if (ret)
1862                         return ret;
1863                 ieee80211_sta_req_auth(dev, &sdata->u.sta);
1864                 return 0;
1865         }
1866
1867         if (sdata->type == IEEE80211_IF_TYPE_AP) {
1868                 memcpy(sdata->u.ap.ssid, ssid, len);
1869                 memset(sdata->u.ap.ssid + len, 0,
1870                        IEEE80211_MAX_SSID_LEN - len);
1871                 sdata->u.ap.ssid_len = len;
1872                 return ieee80211_if_config(dev);
1873         }
1874         return -EOPNOTSUPP;
1875 }
1876
1877
1878 static int ieee80211_ioctl_giwessid(struct net_device *dev,
1879                                     struct iw_request_info *info,
1880                                     struct iw_point *data, char *ssid)
1881 {
1882         size_t len;
1883
1884         struct ieee80211_sub_if_data *sdata;
1885         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1886         if (sdata->type == IEEE80211_IF_TYPE_STA ||
1887             sdata->type == IEEE80211_IF_TYPE_IBSS) {
1888                 int res = ieee80211_sta_get_ssid(dev, ssid, &len);
1889                 if (res == 0) {
1890                         data->length = len;
1891                         data->flags = 1;
1892                 } else
1893                         data->flags = 0;
1894                 return res;
1895         }
1896
1897         if (sdata->type == IEEE80211_IF_TYPE_AP) {
1898                 len = sdata->u.ap.ssid_len;
1899                 if (len > IW_ESSID_MAX_SIZE)
1900                         len = IW_ESSID_MAX_SIZE;
1901                 memcpy(ssid, sdata->u.ap.ssid, len);
1902                 data->length = len;
1903                 data->flags = 1;
1904                 return 0;
1905         }
1906         return -EOPNOTSUPP;
1907 }
1908
1909
1910 static int ieee80211_ioctl_siwap(struct net_device *dev,
1911                                  struct iw_request_info *info,
1912                                  struct sockaddr *ap_addr, char *extra)
1913 {
1914         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1915         struct ieee80211_sub_if_data *sdata;
1916
1917         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1918         if (sdata->type == IEEE80211_IF_TYPE_STA ||
1919             sdata->type == IEEE80211_IF_TYPE_IBSS) {
1920                 int ret;
1921                 if (local->user_space_mlme) {
1922                         memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data,
1923                                ETH_ALEN);
1924                         return 0;
1925                 }
1926                 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data)) {
1927                         sdata->u.sta.auto_bssid_sel = 1;
1928                         sdata->u.sta.auto_channel_sel = 1;
1929                 } else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
1930                         sdata->u.sta.auto_bssid_sel = 1;
1931                 else
1932                         sdata->u.sta.auto_bssid_sel = 0;
1933                 ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data);
1934                 if (ret)
1935                         return ret;
1936                 ieee80211_sta_req_auth(dev, &sdata->u.sta);
1937                 return 0;
1938         } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
1939                 if (memcmp(sdata->u.wds.remote_addr, (u8 *) &ap_addr->sa_data,
1940                            ETH_ALEN) == 0)
1941                         return 0;
1942                 return ieee80211_if_update_wds(dev, (u8 *) &ap_addr->sa_data);
1943         }
1944
1945         return -EOPNOTSUPP;
1946 }
1947
1948
1949 static int ieee80211_ioctl_giwap(struct net_device *dev,
1950                                  struct iw_request_info *info,
1951                                  struct sockaddr *ap_addr, char *extra)
1952 {
1953         struct ieee80211_sub_if_data *sdata;
1954
1955         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1956         if (sdata->type == IEEE80211_IF_TYPE_STA ||
1957             sdata->type == IEEE80211_IF_TYPE_IBSS) {
1958                 ap_addr->sa_family = ARPHRD_ETHER;
1959                 memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN);
1960                 return 0;
1961         } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
1962                 ap_addr->sa_family = ARPHRD_ETHER;
1963                 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
1964                 return 0;
1965         }
1966
1967         return -EOPNOTSUPP;
1968 }
1969
1970
1971 static int ieee80211_ioctl_siwscan(struct net_device *dev,
1972                                    struct iw_request_info *info,
1973                                    struct iw_point *data, char *extra)
1974 {
1975         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1976         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1977         u8 *ssid = NULL;
1978         size_t ssid_len = 0;
1979
1980         if (!netif_running(dev))
1981                 return -ENETDOWN;
1982
1983         if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) {
1984                 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1985                     sdata->type == IEEE80211_IF_TYPE_IBSS) {
1986                         ssid = sdata->u.sta.ssid;
1987                         ssid_len = sdata->u.sta.ssid_len;
1988                 } else if (sdata->type == IEEE80211_IF_TYPE_AP) {
1989                         ssid = sdata->u.ap.ssid;
1990                         ssid_len = sdata->u.ap.ssid_len;
1991                 } else
1992                         return -EINVAL;
1993         }
1994         return ieee80211_sta_req_scan(dev, ssid, ssid_len);
1995 }
1996
1997
1998 static int ieee80211_ioctl_giwscan(struct net_device *dev,
1999                                    struct iw_request_info *info,
2000                                    struct iw_point *data, char *extra)
2001 {
2002         int res;
2003         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2004         if (local->sta_scanning)
2005                 return -EAGAIN;
2006         res = ieee80211_sta_scan_results(dev, extra, data->length);
2007         if (res >= 0) {
2008                 data->length = res;
2009                 return 0;
2010         }
2011         data->length = 0;
2012         return res;
2013 }
2014
2015
2016 static int ieee80211_ioctl_giwrate(struct net_device *dev,
2017                                   struct iw_request_info *info,
2018                                   struct iw_param *rate, char *extra)
2019 {
2020         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2021         struct sta_info *sta;
2022         struct ieee80211_sub_if_data *sdata;
2023
2024         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2025         if (sdata->type == IEEE80211_IF_TYPE_STA)
2026                 sta = sta_info_get(local, sdata->u.sta.bssid);
2027         else
2028                 return -EOPNOTSUPP;
2029         if (!sta)
2030                 return -ENODEV;
2031         if (sta->txrate < local->oper_hw_mode->num_rates)
2032                 rate->value = local->oper_hw_mode->rates[sta->txrate].rate * 100000;
2033         else
2034                 rate->value = 0;
2035         sta_info_put(sta);
2036         return 0;
2037 }
2038
2039 static int ieee80211_ioctl_siwrts(struct net_device *dev,
2040                                   struct iw_request_info *info,
2041                                   struct iw_param *rts, char *extra)
2042 {
2043         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2044
2045         if (rts->disabled)
2046                 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
2047         else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD)
2048                 return -EINVAL;
2049         else
2050                 local->rts_threshold = rts->value;
2051
2052         /* If the wlan card performs RTS/CTS in hardware/firmware,
2053          * configure it here */
2054
2055         if (local->ops->set_rts_threshold)
2056                 local->ops->set_rts_threshold(local_to_hw(local),
2057                                              local->rts_threshold);
2058
2059         return 0;
2060 }
2061
2062 static int ieee80211_ioctl_giwrts(struct net_device *dev,
2063                                   struct iw_request_info *info,
2064                                   struct iw_param *rts, char *extra)
2065 {
2066         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2067
2068         rts->value = local->rts_threshold;
2069         rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD);
2070         rts->fixed = 1;
2071
2072         return 0;
2073 }
2074
2075
2076 static int ieee80211_ioctl_siwfrag(struct net_device *dev,
2077                                    struct iw_request_info *info,
2078                                    struct iw_param *frag, char *extra)
2079 {
2080         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2081
2082         if (frag->disabled)
2083                 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
2084         else if (frag->value < 256 ||
2085                  frag->value > IEEE80211_MAX_FRAG_THRESHOLD)
2086                 return -EINVAL;
2087         else {
2088                 /* Fragment length must be even, so strip LSB. */
2089                 local->fragmentation_threshold = frag->value & ~0x1;
2090         }
2091
2092         /* If the wlan card performs fragmentation in hardware/firmware,
2093          * configure it here */
2094
2095         if (local->ops->set_frag_threshold)
2096                 local->ops->set_frag_threshold(
2097                         local_to_hw(local),
2098                         local->fragmentation_threshold);
2099
2100         return 0;
2101 }
2102
2103 static int ieee80211_ioctl_giwfrag(struct net_device *dev,
2104                                    struct iw_request_info *info,
2105                                    struct iw_param *frag, char *extra)
2106 {
2107         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2108
2109         frag->value = local->fragmentation_threshold;
2110         frag->disabled = (frag->value >= IEEE80211_MAX_RTS_THRESHOLD);
2111         frag->fixed = 1;
2112
2113         return 0;
2114 }
2115
2116
2117 static int ieee80211_ioctl_siwretry(struct net_device *dev,
2118                                     struct iw_request_info *info,
2119                                     struct iw_param *retry, char *extra)
2120 {
2121         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2122
2123         if (retry->disabled ||
2124             (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
2125                 return -EINVAL;
2126
2127         if (retry->flags & IW_RETRY_MAX)
2128                 local->long_retry_limit = retry->value;
2129         else if (retry->flags & IW_RETRY_MIN)
2130                 local->short_retry_limit = retry->value;
2131         else {
2132                 local->long_retry_limit = retry->value;
2133                 local->short_retry_limit = retry->value;
2134         }
2135
2136         if (local->ops->set_retry_limit) {
2137                 return local->ops->set_retry_limit(
2138                         local_to_hw(local),
2139                         local->short_retry_limit,
2140                         local->long_retry_limit);
2141         }
2142
2143         return 0;
2144 }
2145
2146
2147 static int ieee80211_ioctl_giwretry(struct net_device *dev,
2148                                     struct iw_request_info *info,
2149                                     struct iw_param *retry, char *extra)
2150 {
2151         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2152
2153         retry->disabled = 0;
2154         if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) {
2155                 /* first return min value, iwconfig will ask max value
2156                  * later if needed */
2157                 retry->flags |= IW_RETRY_LIMIT;
2158                 retry->value = local->short_retry_limit;
2159                 if (local->long_retry_limit != local->short_retry_limit)
2160                         retry->flags |= IW_RETRY_MIN;
2161                 return 0;
2162         }
2163         if (retry->flags & IW_RETRY_MAX) {
2164                 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
2165                 retry->value = local->long_retry_limit;
2166         }
2167
2168         return 0;
2169 }
2170
2171 static int ieee80211_ioctl_clear_keys(struct net_device *dev)
2172 {
2173         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2174         struct ieee80211_key_conf key;
2175         int i;
2176         u8 addr[ETH_ALEN];
2177         struct ieee80211_key_conf *keyconf;
2178         struct ieee80211_sub_if_data *sdata;
2179         struct sta_info *sta;
2180
2181         memset(addr, 0xff, ETH_ALEN);
2182         read_lock(&local->sub_if_lock);
2183         list_for_each_entry(sdata, &local->sub_if_list, list) {
2184                 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
2185                         keyconf = NULL;
2186                         if (sdata->keys[i] &&
2187                             !sdata->keys[i]->force_sw_encrypt &&
2188                             local->ops->set_key &&
2189                             (keyconf = ieee80211_key_data2conf(local,
2190                                                                sdata->keys[i])))
2191                                 local->ops->set_key(local_to_hw(local),
2192                                                    DISABLE_KEY, addr,
2193                                                    keyconf, 0);
2194                         kfree(keyconf);
2195                         ieee80211_key_free(sdata->keys[i]);
2196                         sdata->keys[i] = NULL;
2197                 }
2198                 sdata->default_key = NULL;
2199         }
2200         read_unlock(&local->sub_if_lock);
2201
2202         spin_lock_bh(&local->sta_lock);
2203         list_for_each_entry(sta, &local->sta_list, list) {
2204                 keyconf = NULL;
2205                 if (sta->key && !sta->key->force_sw_encrypt &&
2206                     local->ops->set_key &&
2207                     (keyconf = ieee80211_key_data2conf(local, sta->key)))
2208                         local->ops->set_key(local_to_hw(local), DISABLE_KEY,
2209                                            sta->addr, keyconf, sta->aid);
2210                 kfree(keyconf);
2211                 ieee80211_key_free(sta->key);
2212                 sta->key = NULL;
2213         }
2214         spin_unlock_bh(&local->sta_lock);
2215
2216         memset(&key, 0, sizeof(key));
2217         if (local->ops->set_key &&
2218                     local->ops->set_key(local_to_hw(local), REMOVE_ALL_KEYS,
2219                                        NULL, &key, 0))
2220                 printk(KERN_DEBUG "%s: failed to remove hwaccel keys\n",
2221                        dev->name);
2222
2223         return 0;
2224 }
2225
2226
2227 static int
2228 ieee80211_ioctl_force_unicast_rate(struct net_device *dev,
2229                                    struct ieee80211_sub_if_data *sdata,
2230                                    int rate)
2231 {
2232         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2233         struct ieee80211_hw_mode *mode;
2234         int i;
2235
2236         if (sdata->type != IEEE80211_IF_TYPE_AP)
2237                 return -ENOENT;
2238
2239         if (rate == 0) {
2240                 sdata->u.ap.force_unicast_rateidx = -1;
2241                 return 0;
2242         }
2243
2244         mode = local->oper_hw_mode;
2245         for (i = 0; i < mode->num_rates; i++) {
2246                 if (mode->rates[i].rate == rate) {
2247                         sdata->u.ap.force_unicast_rateidx = i;
2248                         return 0;
2249                 }
2250         }
2251         return -EINVAL;
2252 }
2253
2254
2255 static int
2256 ieee80211_ioctl_max_ratectrl_rate(struct net_device *dev,
2257                                   struct ieee80211_sub_if_data *sdata,
2258                                   int rate)
2259 {
2260         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2261         struct ieee80211_hw_mode *mode;
2262         int i;
2263
2264         if (sdata->type != IEEE80211_IF_TYPE_AP)
2265                 return -ENOENT;
2266
2267         if (rate == 0) {
2268                 sdata->u.ap.max_ratectrl_rateidx = -1;
2269                 return 0;
2270         }
2271
2272         mode = local->oper_hw_mode;
2273         for (i = 0; i < mode->num_rates; i++) {
2274                 if (mode->rates[i].rate == rate) {
2275                         sdata->u.ap.max_ratectrl_rateidx = i;
2276                         return 0;
2277                 }
2278         }
2279         return -EINVAL;
2280 }
2281
2282
2283 static void ieee80211_key_enable_hwaccel(struct ieee80211_local *local,
2284                                          struct ieee80211_key *key)
2285 {
2286         struct ieee80211_key_conf *keyconf;
2287         u8 addr[ETH_ALEN];
2288
2289         if (!key || key->alg != ALG_WEP || !key->force_sw_encrypt ||
2290             (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP))
2291                 return;
2292
2293         memset(addr, 0xff, ETH_ALEN);
2294         keyconf = ieee80211_key_data2conf(local, key);
2295         if (keyconf && local->ops->set_key &&
2296             local->ops->set_key(local_to_hw(local),
2297                                SET_KEY, addr, keyconf, 0) == 0) {
2298                 key->force_sw_encrypt =
2299                         !!(keyconf->flags & IEEE80211_KEY_FORCE_SW_ENCRYPT);
2300                 key->hw_key_idx = keyconf->hw_key_idx;
2301         }
2302         kfree(keyconf);
2303 }
2304
2305
2306 static void ieee80211_key_disable_hwaccel(struct ieee80211_local *local,
2307                                           struct ieee80211_key *key)
2308 {
2309         struct ieee80211_key_conf *keyconf;
2310         u8 addr[ETH_ALEN];
2311
2312         if (!key || key->alg != ALG_WEP || key->force_sw_encrypt ||
2313             (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP))
2314                 return;
2315
2316         memset(addr, 0xff, ETH_ALEN);
2317         keyconf = ieee80211_key_data2conf(local, key);
2318         if (keyconf && local->ops->set_key)
2319                 local->ops->set_key(local_to_hw(local), DISABLE_KEY,
2320                                    addr, keyconf, 0);
2321         kfree(keyconf);
2322         key->force_sw_encrypt = 1;
2323 }
2324
2325
2326 static int ieee80211_ioctl_default_wep_only(struct ieee80211_local *local,
2327                                             int value)
2328 {
2329         int i;
2330         struct ieee80211_sub_if_data *sdata;
2331
2332         local->default_wep_only = value;
2333         read_lock(&local->sub_if_lock);
2334         list_for_each_entry(sdata, &local->sub_if_list, list)
2335                 for (i = 0; i < NUM_DEFAULT_KEYS; i++)
2336                         if (value)
2337                                 ieee80211_key_enable_hwaccel(local,
2338                                                              sdata->keys[i]);
2339                         else
2340                                 ieee80211_key_disable_hwaccel(local,
2341                                                               sdata->keys[i]);
2342         read_unlock(&local->sub_if_lock);
2343
2344         return 0;
2345 }
2346
2347
2348 void ieee80211_update_default_wep_only(struct ieee80211_local *local)
2349 {
2350         int i = 0;
2351         struct ieee80211_sub_if_data *sdata;
2352
2353         read_lock(&local->sub_if_lock);
2354         list_for_each_entry(sdata, &local->sub_if_list, list) {
2355
2356                 if (sdata->dev == local->mdev)
2357                         continue;
2358
2359                 /* If there is an AP interface then depend on userspace to
2360                    set default_wep_only correctly. */
2361                 if (sdata->type == IEEE80211_IF_TYPE_AP) {
2362                         read_unlock(&local->sub_if_lock);
2363                         return;
2364                 }
2365
2366                 i++;
2367         }
2368
2369         read_unlock(&local->sub_if_lock);
2370
2371         if (i <= 1)
2372                 ieee80211_ioctl_default_wep_only(local, 1);
2373         else
2374                 ieee80211_ioctl_default_wep_only(local, 0);
2375 }
2376
2377
2378 static int ieee80211_ioctl_prism2_param(struct net_device *dev,
2379                                         struct iw_request_info *info,
2380                                         void *wrqu, char *extra)
2381 {
2382         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2383         struct ieee80211_sub_if_data *sdata;
2384         int *i = (int *) extra;
2385         int param = *i;
2386         int value = *(i + 1);
2387         int ret = 0;
2388
2389         if (!capable(CAP_NET_ADMIN))
2390                 return -EPERM;
2391
2392         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2393
2394         switch (param) {
2395         case PRISM2_PARAM_HOST_ENCRYPT:
2396         case PRISM2_PARAM_HOST_DECRYPT:
2397                 /* TODO: implement these; return success now to prevent
2398                  * hostapd from aborting */
2399                 break;
2400
2401         case PRISM2_PARAM_BEACON_INT:
2402                 local->hw.conf.beacon_int = value;
2403                 if (ieee80211_hw_config(local))
2404                         ret = -EINVAL;
2405                 break;
2406
2407         case PRISM2_PARAM_AP_BRIDGE_PACKETS:
2408                 local->bridge_packets = value;
2409                 break;
2410
2411         case PRISM2_PARAM_AP_AUTH_ALGS:
2412                 if (sdata->type == IEEE80211_IF_TYPE_STA ||
2413                     sdata->type == IEEE80211_IF_TYPE_IBSS) {
2414                         sdata->u.sta.auth_algs = value;
2415                 } else
2416                         ret = -EOPNOTSUPP;
2417                 break;
2418
2419         case PRISM2_PARAM_DTIM_PERIOD:
2420                 if (value < 1)
2421                         ret = -EINVAL;
2422                 else if (sdata->type != IEEE80211_IF_TYPE_AP)
2423                         ret = -ENOENT;
2424                 else
2425                         sdata->u.ap.dtim_period = value;
2426                 break;
2427
2428         case PRISM2_PARAM_IEEE_802_1X:
2429                 if (local->ops->set_ieee8021x)
2430                         ret = local->ops->set_ieee8021x(local_to_hw(local),
2431                                                         value);
2432                 if (ret)
2433                         printk(KERN_DEBUG "%s: failed to set IEEE 802.1X (%d) "
2434                                "for low-level driver\n", dev->name, value);
2435                 else
2436                         sdata->ieee802_1x = value;
2437                 break;
2438
2439         case PRISM2_PARAM_ANTSEL_TX:
2440                 local->hw.conf.antenna_sel_tx = value;
2441                 if (ieee80211_hw_config(local))
2442                         ret = -EINVAL;
2443                 break;
2444
2445         case PRISM2_PARAM_ANTSEL_RX:
2446                 local->hw.conf.antenna_sel_rx = value;
2447                 if (ieee80211_hw_config(local))
2448                         ret = -EINVAL;
2449                 break;
2450
2451         case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
2452                 local->cts_protect_erp_frames = value;
2453                 break;
2454
2455         case PRISM2_PARAM_DROP_UNENCRYPTED:
2456                 sdata->drop_unencrypted = value;
2457                 break;
2458
2459         case PRISM2_PARAM_PREAMBLE:
2460                 local->short_preamble = value;
2461                 break;
2462
2463         case PRISM2_PARAM_STAT_TIME:
2464                 if (!local->stat_time && value) {
2465                         local->stat_timer.expires = jiffies + HZ * value / 100;
2466                         add_timer(&local->stat_timer);
2467                 } else if (local->stat_time && !value) {
2468                         del_timer_sync(&local->stat_timer);
2469                 }
2470                 local->stat_time = value;
2471                 break;
2472         case PRISM2_PARAM_SHORT_SLOT_TIME:
2473                 if (value)
2474                         local->hw.conf.flags |= IEEE80211_CONF_SHORT_SLOT_TIME;
2475                 else
2476                         local->hw.conf.flags &= ~IEEE80211_CONF_SHORT_SLOT_TIME;
2477                 if (ieee80211_hw_config(local))
2478                         ret = -EINVAL;
2479                 break;
2480
2481         case PRISM2_PARAM_PRIVACY_INVOKED:
2482                 if (local->ops->set_privacy_invoked)
2483                         ret = local->ops->set_privacy_invoked(
2484                                         local_to_hw(local), value);
2485                 break;
2486
2487         case PRISM2_PARAM_NEXT_MODE:
2488                 local->next_mode = value;
2489                 break;
2490
2491         case PRISM2_PARAM_CLEAR_KEYS:
2492                 ret = ieee80211_ioctl_clear_keys(dev);
2493                 break;
2494
2495         case PRISM2_PARAM_RADIO_ENABLED:
2496                 ret = ieee80211_ioctl_set_radio_enabled(dev, value);
2497                 break;
2498
2499         case PRISM2_PARAM_ANTENNA_MODE:
2500                 local->hw.conf.antenna_mode = value;
2501                 if (ieee80211_hw_config(local))
2502                         ret = -EINVAL;
2503                 break;
2504
2505         case PRISM2_PARAM_BROADCAST_SSID:
2506                 if ((value < 0) || (value > 1))
2507                         ret = -EINVAL;
2508                 else if (value)
2509                         local->hw.conf.flags |= IEEE80211_CONF_SSID_HIDDEN;
2510                 else
2511                         local->hw.conf.flags &= ~IEEE80211_CONF_SSID_HIDDEN;
2512                 break;
2513
2514         case PRISM2_PARAM_STA_ANTENNA_SEL:
2515                 local->sta_antenna_sel = value;
2516                 break;
2517
2518         case PRISM2_PARAM_FORCE_UNICAST_RATE:
2519                 ret = ieee80211_ioctl_force_unicast_rate(dev, sdata, value);
2520                 break;
2521
2522         case PRISM2_PARAM_MAX_RATECTRL_RATE:
2523                 ret = ieee80211_ioctl_max_ratectrl_rate(dev, sdata, value);
2524                 break;
2525
2526         case PRISM2_PARAM_RATE_CTRL_NUM_UP:
2527                 local->rate_ctrl_num_up = value;
2528                 break;
2529
2530         case PRISM2_PARAM_RATE_CTRL_NUM_DOWN:
2531                 local->rate_ctrl_num_down = value;
2532                 break;
2533
2534         case PRISM2_PARAM_TX_POWER_REDUCTION:
2535                 if (value < 0)
2536                         ret = -EINVAL;
2537                 else
2538                         local->hw.conf.tx_power_reduction = value;
2539                 break;
2540
2541         case PRISM2_PARAM_EAPOL:
2542                 sdata->eapol = value;
2543                 break;
2544
2545         case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
2546                 local->key_tx_rx_threshold = value;
2547                 break;
2548
2549         case PRISM2_PARAM_KEY_INDEX:
2550                 if (value < 0 || value >= NUM_DEFAULT_KEYS)
2551                         ret = -EINVAL;
2552                 else if (!sdata->keys[value])
2553                         ret = -ENOENT;
2554                 else
2555                         sdata->default_key = sdata->keys[value];
2556                 break;
2557
2558         case PRISM2_PARAM_DEFAULT_WEP_ONLY:
2559                 ret = ieee80211_ioctl_default_wep_only(local, value);
2560                 break;
2561
2562         case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
2563                 local->wifi_wme_noack_test = value;
2564                 break;
2565
2566         case PRISM2_PARAM_ALLOW_BROADCAST_ALWAYS:
2567                 local->allow_broadcast_always = value;
2568                 break;
2569
2570         case PRISM2_PARAM_SCAN_FLAGS:
2571                 local->scan_flags = value;
2572                 break;
2573
2574         case PRISM2_PARAM_MIXED_CELL:
2575                 if (sdata->type != IEEE80211_IF_TYPE_STA &&
2576                     sdata->type != IEEE80211_IF_TYPE_IBSS)
2577                         ret = -EINVAL;
2578                 else
2579                         sdata->u.sta.mixed_cell = !!value;
2580                 break;
2581
2582         case PRISM2_PARAM_KEY_MGMT:
2583                 if (sdata->type != IEEE80211_IF_TYPE_STA)
2584                         ret = -EINVAL;
2585                 else
2586                         sdata->u.sta.key_mgmt = value;
2587                 break;
2588
2589         case PRISM2_PARAM_HW_MODES:
2590                 local->enabled_modes = value;
2591                 break;
2592
2593         case PRISM2_PARAM_CREATE_IBSS:
2594                 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
2595                         ret = -EINVAL;
2596                 else
2597                         sdata->u.sta.create_ibss = !!value;
2598                 break;
2599         case PRISM2_PARAM_WMM_ENABLED:
2600                 if (sdata->type != IEEE80211_IF_TYPE_STA &&
2601                     sdata->type != IEEE80211_IF_TYPE_IBSS)
2602                         ret = -EINVAL;
2603                 else
2604                         sdata->u.sta.wmm_enabled = !!value;
2605                 break;
2606         case PRISM2_PARAM_RADAR_DETECT:
2607                 local->hw.conf.radar_detect = value;
2608                 break;
2609         case PRISM2_PARAM_SPECTRUM_MGMT:
2610                 local->hw.conf.spect_mgmt = value;
2611                 break;
2612         case PRISM2_PARAM_MGMT_IF:
2613                 if (value == 1) {
2614                         if (!local->apdev)
2615                                 ret = ieee80211_if_add_mgmt(local);
2616                 } else if (value == 0) {
2617                         if (local->apdev)
2618                                 ieee80211_if_del_mgmt(local);
2619                 } else
2620                         ret = -EINVAL;
2621                 break;
2622         case PRISM2_PARAM_USER_SPACE_MLME:
2623                 local->user_space_mlme = value;
2624                 break;
2625         default:
2626                 ret = -EOPNOTSUPP;
2627                 break;
2628         }
2629
2630         return ret;
2631 }
2632
2633
2634 static int ieee80211_ioctl_get_prism2_param(struct net_device *dev,
2635                                             struct iw_request_info *info,
2636                                             void *wrqu, char *extra)
2637 {
2638         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2639         struct ieee80211_sub_if_data *sdata;
2640         int *param = (int *) extra;
2641         int ret = 0;
2642
2643         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2644
2645         switch (*param) {
2646         case PRISM2_PARAM_BEACON_INT:
2647                 *param = local->hw.conf.beacon_int;
2648                 break;
2649
2650         case PRISM2_PARAM_AP_BRIDGE_PACKETS:
2651                 *param = local->bridge_packets;
2652                 break;
2653
2654         case PRISM2_PARAM_AP_AUTH_ALGS:
2655                 if (sdata->type == IEEE80211_IF_TYPE_STA ||
2656                     sdata->type == IEEE80211_IF_TYPE_IBSS) {
2657                         *param = sdata->u.sta.auth_algs;
2658                 } else
2659                         ret = -EOPNOTSUPP;
2660                 break;
2661
2662         case PRISM2_PARAM_DTIM_PERIOD:
2663                 if (sdata->type != IEEE80211_IF_TYPE_AP)
2664                         ret = -ENOENT;
2665                 else
2666                         *param = sdata->u.ap.dtim_period;
2667                 break;
2668
2669         case PRISM2_PARAM_IEEE_802_1X:
2670                 *param = sdata->ieee802_1x;
2671                 break;
2672
2673         case PRISM2_PARAM_ANTSEL_TX:
2674                 *param = local->hw.conf.antenna_sel_tx;
2675                 break;
2676
2677         case PRISM2_PARAM_ANTSEL_RX:
2678                 *param = local->hw.conf.antenna_sel_rx;
2679                 break;
2680
2681         case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
2682                 *param = local->cts_protect_erp_frames;
2683                 break;
2684
2685         case PRISM2_PARAM_DROP_UNENCRYPTED:
2686                 *param = sdata->drop_unencrypted;
2687                 break;
2688
2689         case PRISM2_PARAM_PREAMBLE:
2690                 *param = local->short_preamble;
2691                 break;
2692
2693         case PRISM2_PARAM_STAT_TIME:
2694                 *param = local->stat_time;
2695                 break;
2696         case PRISM2_PARAM_SHORT_SLOT_TIME:
2697                 *param = !!(local->hw.conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME);
2698                 break;
2699
2700         case PRISM2_PARAM_NEXT_MODE:
2701                 *param = local->next_mode;
2702                 break;
2703
2704         case PRISM2_PARAM_ANTENNA_MODE:
2705                 *param = local->hw.conf.antenna_mode;
2706                 break;
2707
2708         case PRISM2_PARAM_BROADCAST_SSID:
2709                 *param = !!(local->hw.conf.flags & IEEE80211_CONF_SSID_HIDDEN);
2710                 break;
2711
2712         case PRISM2_PARAM_STA_ANTENNA_SEL:
2713                 *param = local->sta_antenna_sel;
2714                 break;
2715
2716         case PRISM2_PARAM_RATE_CTRL_NUM_UP:
2717                 *param = local->rate_ctrl_num_up;
2718                 break;
2719
2720         case PRISM2_PARAM_RATE_CTRL_NUM_DOWN:
2721                 *param = local->rate_ctrl_num_down;
2722                 break;
2723
2724         case PRISM2_PARAM_TX_POWER_REDUCTION:
2725                 *param = local->hw.conf.tx_power_reduction;
2726                 break;
2727
2728         case PRISM2_PARAM_EAPOL:
2729                 *param = sdata->eapol;
2730                 break;
2731
2732         case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
2733                 *param = local->key_tx_rx_threshold;
2734                 break;
2735
2736         case PRISM2_PARAM_KEY_INDEX:
2737                 if (!sdata->default_key)
2738                         ret = -ENOENT;
2739                 else if (sdata->default_key == sdata->keys[0])
2740                         *param = 0;
2741                 else if (sdata->default_key == sdata->keys[1])
2742                         *param = 1;
2743                 else if (sdata->default_key == sdata->keys[2])
2744                         *param = 2;
2745                 else if (sdata->default_key == sdata->keys[3])
2746                         *param = 3;
2747                 else
2748                         ret = -ENOENT;
2749                 break;
2750
2751         case PRISM2_PARAM_DEFAULT_WEP_ONLY:
2752                 *param = local->default_wep_only;
2753                 break;
2754
2755         case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
2756                 *param = local->wifi_wme_noack_test;
2757                 break;
2758
2759         case PRISM2_PARAM_ALLOW_BROADCAST_ALWAYS:
2760                 *param = local->allow_broadcast_always;
2761                 break;
2762
2763         case PRISM2_PARAM_SCAN_FLAGS:
2764                 *param = local->scan_flags;
2765                 break;
2766
2767         case PRISM2_PARAM_HW_MODES:
2768                 *param = local->enabled_modes;
2769                 break;
2770
2771         case PRISM2_PARAM_CREATE_IBSS:
2772                 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
2773                         ret = -EINVAL;
2774                 else
2775                         *param = !!sdata->u.sta.create_ibss;
2776                 break;
2777
2778         case PRISM2_PARAM_MIXED_CELL:
2779                 if (sdata->type != IEEE80211_IF_TYPE_STA &&
2780                     sdata->type != IEEE80211_IF_TYPE_IBSS)
2781                         ret = -EINVAL;
2782                 else
2783                         *param = !!sdata->u.sta.mixed_cell;
2784                 break;
2785
2786         case PRISM2_PARAM_KEY_MGMT:
2787                 if (sdata->type != IEEE80211_IF_TYPE_STA)
2788                         ret = -EINVAL;
2789                 else
2790                         *param = sdata->u.sta.key_mgmt;
2791                 break;
2792         case PRISM2_PARAM_WMM_ENABLED:
2793                 if (sdata->type != IEEE80211_IF_TYPE_STA &&
2794                     sdata->type != IEEE80211_IF_TYPE_IBSS)
2795                         ret = -EINVAL;
2796                 else
2797                         *param = !!sdata->u.sta.wmm_enabled;
2798                 break;
2799         case PRISM2_PARAM_MGMT_IF:
2800                 if (local->apdev)
2801                         *param = local->apdev->ifindex;
2802                 else
2803                         ret = -ENOENT;
2804                 break;
2805         case PRISM2_PARAM_USER_SPACE_MLME:
2806                 *param = local->user_space_mlme;
2807                 break;
2808
2809         default:
2810                 ret = -EOPNOTSUPP;
2811                 break;
2812         }
2813
2814         return ret;
2815 }
2816
2817 static int ieee80211_ioctl_siwmlme(struct net_device *dev,
2818                                    struct iw_request_info *info,
2819                                    struct iw_point *data, char *extra)
2820 {
2821         struct ieee80211_sub_if_data *sdata;
2822         struct iw_mlme *mlme = (struct iw_mlme *) extra;
2823
2824         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2825         if (sdata->type != IEEE80211_IF_TYPE_STA &&
2826             sdata->type != IEEE80211_IF_TYPE_IBSS)
2827                 return -EINVAL;
2828
2829         switch (mlme->cmd) {
2830         case IW_MLME_DEAUTH:
2831                 /* TODO: mlme->addr.sa_data */
2832                 return ieee80211_sta_deauthenticate(dev, mlme->reason_code);
2833         case IW_MLME_DISASSOC:
2834                 /* TODO: mlme->addr.sa_data */
2835                 return ieee80211_sta_disassociate(dev, mlme->reason_code);
2836         default:
2837                 return -EOPNOTSUPP;
2838         }
2839 }
2840
2841
2842 static int ieee80211_ioctl_siwencode(struct net_device *dev,
2843                                      struct iw_request_info *info,
2844                                      struct iw_point *erq, char *keybuf)
2845 {
2846         struct ieee80211_sub_if_data *sdata;
2847         int idx, i, alg = ALG_WEP;
2848         u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2849
2850         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2851
2852         idx = erq->flags & IW_ENCODE_INDEX;
2853         if (idx == 0) {
2854                 if (sdata->default_key)
2855                         for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
2856                                 if (sdata->default_key == sdata->keys[i]) {
2857                                         idx = i;
2858                                         break;
2859                                 }
2860                         }
2861         } else if (idx < 1 || idx > 4)
2862                 return -EINVAL;
2863         else
2864                 idx--;
2865
2866         if (erq->flags & IW_ENCODE_DISABLED)
2867                 alg = ALG_NONE;
2868         else if (erq->length == 0) {
2869                 /* No key data - just set the default TX key index */
2870                 if (sdata->default_key != sdata->keys[idx]) {
2871                         ieee80211_debugfs_key_remove_default(sdata);
2872                         sdata->default_key = sdata->keys[idx];
2873                         if (sdata->default_key)
2874                                 ieee80211_debugfs_key_add_default(sdata);
2875                 }
2876                 return 0;
2877         }
2878
2879         return ieee80211_set_encryption(
2880                 dev, bcaddr,
2881                 idx, alg,
2882                 !sdata->default_key,
2883                 NULL, keybuf, erq->length);
2884 }
2885
2886
2887 static int ieee80211_ioctl_giwencode(struct net_device *dev,
2888                                      struct iw_request_info *info,
2889                                      struct iw_point *erq, char *key)
2890 {
2891         struct ieee80211_sub_if_data *sdata;
2892         int idx, i;
2893
2894         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2895
2896         idx = erq->flags & IW_ENCODE_INDEX;
2897         if (idx < 1 || idx > 4) {
2898                 idx = -1;
2899                 if (!sdata->default_key)
2900                         idx = 0;
2901                 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
2902                         if (sdata->default_key == sdata->keys[i]) {
2903                                 idx = i;
2904                                 break;
2905                         }
2906                 }
2907                 if (idx < 0)
2908                         return -EINVAL;
2909         } else
2910                 idx--;
2911
2912         erq->flags = idx + 1;
2913
2914         if (!sdata->keys[idx]) {
2915                 erq->length = 0;
2916                 erq->flags |= IW_ENCODE_DISABLED;
2917                 return 0;
2918         }
2919
2920         memcpy(key, sdata->keys[idx]->key,
2921                min((int)erq->length, sdata->keys[idx]->keylen));
2922         erq->length = sdata->keys[idx]->keylen;
2923         erq->flags |= IW_ENCODE_ENABLED;
2924
2925         return 0;
2926 }
2927
2928
2929 static int ieee80211_ioctl_siwgenie(struct net_device *dev,
2930                                     struct iw_request_info *info,
2931                                     struct iw_point *data, char *extra)
2932 {
2933         return ieee80211_set_gen_ie(dev, extra, data->length);
2934 }
2935
2936
2937 static int ieee80211_ioctl_siwauth(struct net_device *dev,
2938                                    struct iw_request_info *info,
2939                                    struct iw_param *data, char *extra)
2940 {
2941         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2942         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2943         int ret = 0;
2944
2945         switch (data->flags & IW_AUTH_INDEX) {
2946         case IW_AUTH_WPA_VERSION:
2947         case IW_AUTH_CIPHER_PAIRWISE:
2948         case IW_AUTH_CIPHER_GROUP:
2949         case IW_AUTH_WPA_ENABLED:
2950         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2951                 break;
2952         case IW_AUTH_KEY_MGMT:
2953                 if (sdata->type != IEEE80211_IF_TYPE_STA)
2954                         ret = -EINVAL;
2955                 else {
2956                         /*
2957                          * TODO: sdata->u.sta.key_mgmt does not match with WE18
2958                          * value completely; could consider modifying this to
2959                          * be closer to WE18. For now, this value is not really
2960                          * used for anything else than Privacy matching, so the
2961                          * current code here should be more or less OK.
2962                          */
2963                         if (data->value & IW_AUTH_KEY_MGMT_802_1X) {
2964                                 sdata->u.sta.key_mgmt =
2965                                         IEEE80211_KEY_MGMT_WPA_EAP;
2966                         } else if (data->value & IW_AUTH_KEY_MGMT_PSK) {
2967                                 sdata->u.sta.key_mgmt =
2968                                         IEEE80211_KEY_MGMT_WPA_PSK;
2969                         } else {
2970                                 sdata->u.sta.key_mgmt =
2971                                         IEEE80211_KEY_MGMT_NONE;
2972                         }
2973                 }
2974                 break;
2975         case IW_AUTH_80211_AUTH_ALG:
2976                 if (sdata->type == IEEE80211_IF_TYPE_STA ||
2977                     sdata->type == IEEE80211_IF_TYPE_IBSS)
2978                         sdata->u.sta.auth_algs = data->value;
2979                 else
2980                         ret = -EOPNOTSUPP;
2981                 break;
2982         case IW_AUTH_PRIVACY_INVOKED:
2983                 if (local->ops->set_privacy_invoked)
2984                         ret = local->ops->set_privacy_invoked(
2985                                         local_to_hw(local), data->value);
2986                 break;
2987         default:
2988                 ret = -EOPNOTSUPP;
2989                 break;
2990         }
2991         return ret;
2992 }
2993
2994 /* Get wireless statistics.  Called by /proc/net/wireless and by SIOCGIWSTATS */
2995 static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev)
2996 {
2997         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2998         struct iw_statistics *wstats = &local->wstats;
2999         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3000         struct sta_info *sta = NULL;
3001
3002         if (sdata->type == IEEE80211_IF_TYPE_STA ||
3003             sdata->type == IEEE80211_IF_TYPE_IBSS)
3004                 sta = sta_info_get(local, sdata->u.sta.bssid);
3005         if (!sta) {
3006                 wstats->discard.fragment = 0;
3007                 wstats->discard.misc = 0;
3008                 wstats->qual.qual = 0;
3009                 wstats->qual.level = 0;
3010                 wstats->qual.noise = 0;
3011                 wstats->qual.updated = IW_QUAL_ALL_INVALID;
3012         } else {
3013                 wstats->qual.level = sta->last_rssi;
3014                 wstats->qual.qual = sta->last_signal;
3015                 wstats->qual.noise = sta->last_noise;
3016                 wstats->qual.updated = local->wstats_flags;
3017                 sta_info_put(sta);
3018         }
3019         return wstats;
3020 }
3021
3022 static int ieee80211_ioctl_giwauth(struct net_device *dev,
3023                                    struct iw_request_info *info,
3024                                    struct iw_param *data, char *extra)
3025 {
3026         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3027         int ret = 0;
3028
3029         switch (data->flags & IW_AUTH_INDEX) {
3030         case IW_AUTH_80211_AUTH_ALG:
3031                 if (sdata->type == IEEE80211_IF_TYPE_STA ||
3032                     sdata->type == IEEE80211_IF_TYPE_IBSS)
3033                         data->value = sdata->u.sta.auth_algs;
3034                 else
3035                         ret = -EOPNOTSUPP;
3036                 break;
3037         default:
3038                 ret = -EOPNOTSUPP;
3039                 break;
3040         }
3041         return ret;
3042 }
3043
3044
3045 static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
3046                                         struct iw_request_info *info,
3047                                         struct iw_point *erq, char *extra)
3048 {
3049         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3050         struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
3051         int alg, idx, i;
3052
3053         switch (ext->alg) {
3054         case IW_ENCODE_ALG_NONE:
3055                 alg = ALG_NONE;
3056                 break;
3057         case IW_ENCODE_ALG_WEP:
3058                 alg = ALG_WEP;
3059                 break;
3060         case IW_ENCODE_ALG_TKIP:
3061                 alg = ALG_TKIP;
3062                 break;
3063         case IW_ENCODE_ALG_CCMP:
3064                 alg = ALG_CCMP;
3065                 break;
3066         default:
3067                 return -EOPNOTSUPP;
3068         }
3069
3070         if (erq->flags & IW_ENCODE_DISABLED)
3071                 alg = ALG_NONE;
3072
3073         idx = erq->flags & IW_ENCODE_INDEX;
3074         if (idx < 1 || idx > 4) {
3075                 idx = -1;
3076                 if (!sdata->default_key)
3077                         idx = 0;
3078                 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
3079                         if (sdata->default_key == sdata->keys[i]) {
3080                                 idx = i;
3081                                 break;
3082                         }
3083                 }
3084                 if (idx < 0)
3085                         return -EINVAL;
3086         } else
3087                 idx--;
3088
3089         return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg,
3090                                         ext->ext_flags &
3091                                         IW_ENCODE_EXT_SET_TX_KEY,
3092                                         NULL, ext->key, ext->key_len);
3093 }
3094
3095
3096 static const struct iw_priv_args ieee80211_ioctl_priv[] = {
3097         { PRISM2_IOCTL_PRISM2_PARAM,
3098           IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "param" },
3099         { PRISM2_IOCTL_GET_PRISM2_PARAM,
3100           IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3101           IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_param" },
3102 };
3103
3104
3105 int ieee80211_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3106 {
3107         struct iwreq *wrq = (struct iwreq *) rq;
3108         int ret = 0;
3109
3110         switch (cmd) {
3111                 /* Private ioctls (iwpriv) that have not yet been converted
3112                  * into new wireless extensions API */
3113         case PRISM2_IOCTL_HOSTAPD:
3114                 if (!capable(CAP_NET_ADMIN)) ret = -EPERM;
3115                 else ret = ieee80211_ioctl_priv_hostapd(dev, &wrq->u.data);
3116                 break;
3117         default:
3118                 ret = -EOPNOTSUPP;
3119                 break;
3120         }
3121
3122         return ret;
3123 }
3124
3125
3126 /* Structures to export the Wireless Handlers */
3127
3128 static const iw_handler ieee80211_handler[] =
3129 {
3130         (iw_handler) NULL,                              /* SIOCSIWCOMMIT */
3131         (iw_handler) ieee80211_ioctl_giwname,           /* SIOCGIWNAME */
3132         (iw_handler) NULL,                              /* SIOCSIWNWID */
3133         (iw_handler) NULL,                              /* SIOCGIWNWID */
3134         (iw_handler) ieee80211_ioctl_siwfreq,           /* SIOCSIWFREQ */
3135         (iw_handler) ieee80211_ioctl_giwfreq,           /* SIOCGIWFREQ */
3136         (iw_handler) ieee80211_ioctl_siwmode,           /* SIOCSIWMODE */
3137         (iw_handler) ieee80211_ioctl_giwmode,           /* SIOCGIWMODE */
3138         (iw_handler) NULL,                              /* SIOCSIWSENS */
3139         (iw_handler) NULL,                              /* SIOCGIWSENS */
3140         (iw_handler) NULL /* not used */,               /* SIOCSIWRANGE */
3141         (iw_handler) ieee80211_ioctl_giwrange,          /* SIOCGIWRANGE */
3142         (iw_handler) NULL /* not used */,               /* SIOCSIWPRIV */
3143         (iw_handler) NULL /* kernel code */,            /* SIOCGIWPRIV */
3144         (iw_handler) NULL /* not used */,               /* SIOCSIWSTATS */
3145         (iw_handler) NULL /* kernel code */,            /* SIOCGIWSTATS */
3146         iw_handler_set_spy,                             /* SIOCSIWSPY */
3147         iw_handler_get_spy,                             /* SIOCGIWSPY */
3148         iw_handler_set_thrspy,                          /* SIOCSIWTHRSPY */
3149         iw_handler_get_thrspy,                          /* SIOCGIWTHRSPY */
3150         (iw_handler) ieee80211_ioctl_siwap,             /* SIOCSIWAP */
3151         (iw_handler) ieee80211_ioctl_giwap,             /* SIOCGIWAP */
3152         (iw_handler) ieee80211_ioctl_siwmlme,           /* SIOCSIWMLME */
3153         (iw_handler) NULL,                              /* SIOCGIWAPLIST */
3154         (iw_handler) ieee80211_ioctl_siwscan,           /* SIOCSIWSCAN */
3155         (iw_handler) ieee80211_ioctl_giwscan,           /* SIOCGIWSCAN */
3156         (iw_handler) ieee80211_ioctl_siwessid,          /* SIOCSIWESSID */
3157         (iw_handler) ieee80211_ioctl_giwessid,          /* SIOCGIWESSID */
3158         (iw_handler) NULL,                              /* SIOCSIWNICKN */
3159         (iw_handler) NULL,                              /* SIOCGIWNICKN */
3160         (iw_handler) NULL,                              /* -- hole -- */
3161         (iw_handler) NULL,                              /* -- hole -- */
3162         (iw_handler) NULL,                              /* SIOCSIWRATE */
3163         (iw_handler) ieee80211_ioctl_giwrate,           /* SIOCGIWRATE */
3164         (iw_handler) ieee80211_ioctl_siwrts,            /* SIOCSIWRTS */
3165         (iw_handler) ieee80211_ioctl_giwrts,            /* SIOCGIWRTS */
3166         (iw_handler) ieee80211_ioctl_siwfrag,           /* SIOCSIWFRAG */
3167         (iw_handler) ieee80211_ioctl_giwfrag,           /* SIOCGIWFRAG */
3168         (iw_handler) NULL,                              /* SIOCSIWTXPOW */
3169         (iw_handler) NULL,                              /* SIOCGIWTXPOW */
3170         (iw_handler) ieee80211_ioctl_siwretry,          /* SIOCSIWRETRY */
3171         (iw_handler) ieee80211_ioctl_giwretry,          /* SIOCGIWRETRY */
3172         (iw_handler) ieee80211_ioctl_siwencode,         /* SIOCSIWENCODE */
3173         (iw_handler) ieee80211_ioctl_giwencode,         /* SIOCGIWENCODE */
3174         (iw_handler) NULL,                              /* SIOCSIWPOWER */
3175         (iw_handler) NULL,                              /* SIOCGIWPOWER */
3176         (iw_handler) NULL,                              /* -- hole -- */
3177         (iw_handler) NULL,                              /* -- hole -- */
3178         (iw_handler) ieee80211_ioctl_siwgenie,          /* SIOCSIWGENIE */
3179         (iw_handler) NULL,                              /* SIOCGIWGENIE */
3180         (iw_handler) ieee80211_ioctl_siwauth,           /* SIOCSIWAUTH */
3181         (iw_handler) ieee80211_ioctl_giwauth,           /* SIOCGIWAUTH */
3182         (iw_handler) ieee80211_ioctl_siwencodeext,      /* SIOCSIWENCODEEXT */
3183         (iw_handler) NULL,                              /* SIOCGIWENCODEEXT */
3184         (iw_handler) NULL,                              /* SIOCSIWPMKSA */
3185         (iw_handler) NULL,                              /* -- hole -- */
3186 };
3187
3188 static const iw_handler ieee80211_private_handler[] =
3189 {                                                       /* SIOCIWFIRSTPRIV + */
3190         (iw_handler) ieee80211_ioctl_prism2_param,      /* 0 */
3191         (iw_handler) ieee80211_ioctl_get_prism2_param,  /* 1 */
3192 };
3193
3194 const struct iw_handler_def ieee80211_iw_handler_def =
3195 {
3196         .num_standard   = ARRAY_SIZE(ieee80211_handler),
3197         .num_private    = ARRAY_SIZE(ieee80211_private_handler),
3198         .num_private_args = ARRAY_SIZE(ieee80211_ioctl_priv),
3199         .standard       = (iw_handler *) ieee80211_handler,
3200         .private        = (iw_handler *) ieee80211_private_handler,
3201         .private_args   = (struct iw_priv_args *) ieee80211_ioctl_priv,
3202         .get_wireless_stats = ieee80211_get_wireless_stats,
3203 };