projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
New: mac80211 stack from the wireless-dev tree
[openwrt/openwrt.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 };
OpenWrt Source Repository