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 30static int ieee80211_regdom = 0x10; /* FCC */ 31module_param(ieee80211_regdom, int, 0444); 32MODULE_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 */ 40static int ieee80211_japan_5ghz /* = 0 */; 41module_param(ieee80211_japan_5ghz, int, 0444); 42MODULE_PARM_DESC(ieee80211_japan_5ghz, "Vendor-updated firmware for 5 GHz"); 43 44static void ieee80211_set_hw_encryption(struct net_device *dev, 45 struct sta_info *sta, u8 addr[ETH_ALEN], 46 struct ieee80211_key *key) 47{ 48 struct ieee80211_key_conf *keyconf = NULL; 49 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 50 51 /* default to sw encryption; this will be cleared by low-level 52 * driver if the hw supports requested encryption */ 53 if (key) 54 key->force_sw_encrypt = 1; 55 56 if (key && local->ops->set_key && 57 (keyconf = ieee80211_key_data2conf(local, key))) { 58 if (local->ops->set_key(local_to_hw(local), SET_KEY, addr, 59 keyconf, sta ? sta->aid : 0)) { 60 key->force_sw_encrypt = 1; 61 key->hw_key_idx = HW_KEY_IDX_INVALID; 62 } else { 63 key->force_sw_encrypt = 64 !!(keyconf->flags & IEEE80211_KEY_FORCE_SW_ENCRYPT); 65 key->hw_key_idx = 66 keyconf->hw_key_idx; 67 68 } 69 } 70 kfree(keyconf); 71} 72 73 74static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr, 75 int idx, int alg, int set_tx_key, 76 const u8 *_key, size_t key_len) 77{ 78 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 79 int ret = 0; 80 struct sta_info *sta; 81 struct ieee80211_key *key, *old_key; 82 int try_hwaccel = 1; 83 struct ieee80211_key_conf *keyconf; 84 struct ieee80211_sub_if_data *sdata; 85 86 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 87 88 if (is_broadcast_ether_addr(sta_addr)) { 89 sta = NULL; 90 if (idx >= NUM_DEFAULT_KEYS) { 91 printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n", 92 dev->name, idx); 93 return -EINVAL; 94 } 95 key = sdata->keys[idx]; 96 97 /* TODO: consider adding hwaccel support for these; at least 98 * Atheros key cache should be able to handle this since AP is 99 * only transmitting frames with default keys. */ 100 /* FIX: hw key cache can be used when only one virtual 101 * STA is associated with each AP. If more than one STA 102 * is associated to the same AP, software encryption 103 * must be used. This should be done automatically 104 * based on configured station devices. For the time 105 * being, this can be only set at compile time. */ 106 } else { 107 set_tx_key = 0; 108 if (idx != 0) { 109 printk(KERN_DEBUG "%s: set_encrypt - non-zero idx for " 110 "individual key\n", dev->name); 111 return -EINVAL; 112 } 113 114 sta = sta_info_get(local, sta_addr); 115 if (!sta) { 116#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 117 printk(KERN_DEBUG "%s: set_encrypt - unknown addr " 118 MAC_FMT "\n", 119 dev->name, MAC_ARG(sta_addr)); 120#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ 121 122 return -ENOENT; 123 } 124 125 key = sta->key; 126 } 127 128 /* FIX: 129 * Cannot configure default hwaccel keys with WEP algorithm, if 130 * any of the virtual interfaces is using static WEP 131 * configuration because hwaccel would otherwise try to decrypt 132 * these frames. 133 * 134 * For now, just disable WEP hwaccel for broadcast when there is 135 * possibility of conflict with default keys. This can maybe later be 136 * optimized by using non-default keys (at least with Atheros ar521x). 137 */ 138 if (!sta && alg == ALG_WEP && !local->default_wep_only && 139 sdata->type != IEEE80211_IF_TYPE_IBSS && 140 sdata->type != IEEE80211_IF_TYPE_AP) { 141 try_hwaccel = 0; 142 } 143 144 if (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP) { 145 /* Software encryption cannot be used with devices that hide 146 * encryption from the host system, so always try to use 147 * hardware acceleration with such devices. */ 148 try_hwaccel = 1; 149 } 150 151 if ((local->hw.flags & IEEE80211_HW_NO_TKIP_WMM_HWACCEL) && 152 alg == ALG_TKIP) { 153 if (sta && (sta->flags & WLAN_STA_WME)) { 154 /* Hardware does not support hwaccel with TKIP when using WMM. 155 */ 156 try_hwaccel = 0; 157 } 158 else if (sdata->type == IEEE80211_IF_TYPE_STA) { 159 sta = sta_info_get(local, sdata->u.sta.bssid); 160 if (sta) { 161 if (sta->flags & WLAN_STA_WME) { 162 try_hwaccel = 0; 163 } 164 sta_info_put(sta); 165 sta = NULL; 166 } 167 } 168 } 169 170 if (alg == ALG_NONE) { 171 keyconf = NULL; 172 if (try_hwaccel && key && 173 key->hw_key_idx != HW_KEY_IDX_INVALID && 174 local->ops->set_key && 175 (keyconf = ieee80211_key_data2conf(local, key)) != NULL && 176 local->ops->set_key(local_to_hw(local), DISABLE_KEY, 177 sta_addr, keyconf, sta ? sta->aid : 0)) { 178 printk(KERN_DEBUG "%s: set_encrypt - low-level disable" 179 " failed\n", dev->name); 180 ret = -EINVAL; 181 } 182 kfree(keyconf); 183 184 if (set_tx_key || sdata->default_key == key) { 185 ieee80211_debugfs_key_remove_default(sdata); 186 sdata->default_key = NULL; 187 } 188 ieee80211_debugfs_key_remove(key); 189 if (sta) 190 sta->key = NULL; 191 else 192 sdata->keys[idx] = NULL; 193 ieee80211_key_free(key); 194 key = NULL; 195 } else { 196 old_key = key; 197 key = ieee80211_key_alloc(sta ? NULL : sdata, idx, key_len, 198 GFP_KERNEL); 199 if (!key) { 200 ret = -ENOMEM; 201 goto err_out; 202 } 203 204 /* default to sw encryption; low-level driver sets these if the 205 * requested encryption is supported */ 206 key->hw_key_idx = HW_KEY_IDX_INVALID; 207 key->force_sw_encrypt = 1; 208 209 key->alg = alg; 210 key->keyidx = idx; 211 key->keylen = key_len; 212 memcpy(key->key, _key, key_len); 213 if (set_tx_key) 214 key->default_tx_key = 1; 215 216 if (alg == ALG_CCMP) { 217 /* Initialize AES key state here as an optimization 218 * so that it does not need to be initialized for every 219 * packet. */ 220 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt( 221 key->key); 222 if (!key->u.ccmp.tfm) { 223 ret = -ENOMEM; 224 goto err_free; 225 } 226 } 227 228 if (set_tx_key || sdata->default_key == old_key) { 229 ieee80211_debugfs_key_remove_default(sdata); 230 sdata->default_key = NULL; 231 } 232 ieee80211_debugfs_key_remove(old_key); 233 if (sta) 234 sta->key = key; 235 else 236 sdata->keys[idx] = key; 237 ieee80211_key_free(old_key); 238 ieee80211_debugfs_key_add(local, key); 239 if (sta) 240 ieee80211_debugfs_key_sta_link(key, sta); 241 242 if (try_hwaccel && 243 (alg == ALG_WEP || alg == ALG_TKIP || alg == ALG_CCMP)) 244 ieee80211_set_hw_encryption(dev, sta, sta_addr, key); 245 } 246 247 if (set_tx_key || (!sta && !sdata->default_key && key)) { 248 sdata->default_key = key; 249 if (key) 250 ieee80211_debugfs_key_add_default(sdata); 251 252 if (local->ops->set_key_idx && 253 local->ops->set_key_idx(local_to_hw(local), idx)) 254 printk(KERN_DEBUG "%s: failed to set TX key idx for " 255 "low-level driver\n", dev->name); 256 } 257 258 if (sta) 259 sta_info_put(sta); 260 261 return 0; 262 263err_free: 264 ieee80211_key_free(key); 265err_out: 266 if (sta) 267 sta_info_put(sta); 268 return ret; 269} 270 271static int ieee80211_ioctl_siwgenie(struct net_device *dev, 272 struct iw_request_info *info, 273 struct iw_point *data, char *extra) 274{ 275 struct ieee80211_sub_if_data *sdata; 276 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 277 278 if (local->user_space_mlme) 279 return -EOPNOTSUPP; 280 281 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 282 if (sdata->type == IEEE80211_IF_TYPE_STA || 283 sdata->type == IEEE80211_IF_TYPE_IBSS) { 284 int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length); 285 if (ret) 286 return ret; 287 sdata->u.sta.auto_bssid_sel = 0; 288 ieee80211_sta_req_auth(dev, &sdata->u.sta); 289 return 0; 290 } 291 292 if (sdata->type == IEEE80211_IF_TYPE_AP) { 293 kfree(sdata->u.ap.generic_elem); 294 sdata->u.ap.generic_elem = kmalloc(data->length, GFP_KERNEL); 295 if (!sdata->u.ap.generic_elem) 296 return -ENOMEM; 297 memcpy(sdata->u.ap.generic_elem, extra, data->length); 298 sdata->u.ap.generic_elem_len = data->length; 299 return ieee80211_if_config(dev); 300 } 301 return -EOPNOTSUPP; 302} 303 304static int ieee80211_ioctl_set_radio_enabled(struct net_device *dev, 305 int val) 306{ 307 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 308 struct ieee80211_conf *conf = &local->hw.conf; 309 310 conf->radio_enabled = val; 311 return ieee80211_hw_config(wdev_priv(dev->ieee80211_ptr)); 312} 313 314static int ieee80211_ioctl_giwname(struct net_device *dev, 315 struct iw_request_info *info, 316 char *name, char *extra) 317{ 318 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 319 320 switch (local->hw.conf.phymode) { 321 case MODE_IEEE80211A: 322 strcpy(name, "IEEE 802.11a"); 323 break; 324 case MODE_IEEE80211B: 325 strcpy(name, "IEEE 802.11b"); 326 break; 327 case MODE_IEEE80211G: 328 strcpy(name, "IEEE 802.11g"); 329 break; 330 case MODE_ATHEROS_TURBO: 331 strcpy(name, "5GHz Turbo"); 332 break; 333 default: 334 strcpy(name, "IEEE 802.11"); 335 break; 336 } 337 338 return 0; 339} 340 341 342static int ieee80211_ioctl_giwrange(struct net_device *dev, 343 struct iw_request_info *info, 344 struct iw_point *data, char *extra) 345{ 346 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 347 struct iw_range *range = (struct iw_range *) extra; 348 349 data->length = sizeof(struct iw_range); 350 memset(range, 0, sizeof(struct iw_range)); 351 352 range->we_version_compiled = WIRELESS_EXT; 353 range->we_version_source = 21; 354 range->retry_capa = IW_RETRY_LIMIT; 355 range->retry_flags = IW_RETRY_LIMIT; 356 range->min_retry = 0; 357 range->max_retry = 255; 358 range->min_rts = 0; 359 range->max_rts = 2347; 360 range->min_frag = 256; 361 range->max_frag = 2346; 362 363 range->encoding_size[0] = 5; 364 range->encoding_size[1] = 13; 365 range->num_encoding_sizes = 2; 366 range->max_encoding_tokens = NUM_DEFAULT_KEYS; 367 368 range->max_qual.qual = local->hw.max_signal; 369 range->max_qual.level = local->hw.max_rssi; 370 range->max_qual.noise = local->hw.max_noise; 371 range->max_qual.updated = local->wstats_flags; 372 373 range->avg_qual.qual = local->hw.max_signal/2; 374 range->avg_qual.level = 0; 375 range->avg_qual.noise = 0; 376 range->avg_qual.updated = local->wstats_flags; 377 378 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 379 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 380 381 IW_EVENT_CAPA_SET_KERNEL(range->event_capa); 382 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWTHRSPY); 383 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP); 384 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN); 385 386 return 0; 387} 388 389 390struct ieee80211_channel_range { 391 short start_freq; 392 short end_freq; 393 unsigned char power_level; 394 unsigned char antenna_max; 395}; 396 397static const struct ieee80211_channel_range ieee80211_fcc_channels[] = { 398 { 2412, 2462, 27, 6 } /* IEEE 802.11b/g, channels 1..11 */, 399 { 5180, 5240, 17, 6 } /* IEEE 802.11a, channels 36..48 */, 400 { 5260, 5320, 23, 6 } /* IEEE 802.11a, channels 52..64 */, 401 { 5745, 5825, 30, 6 } /* IEEE 802.11a, channels 149..165, outdoor */, 402 { 0 } 403}; 404 405static const struct ieee80211_channel_range ieee80211_mkk_channels[] = { 406 { 2412, 2472, 20, 6 } /* IEEE 802.11b/g, channels 1..13 */, 407 { 5170, 5240, 20, 6 } /* IEEE 802.11a, channels 34..48 */, 408 { 5260, 5320, 20, 6 } /* IEEE 802.11a, channels 52..64 */, 409 { 0 } 410}; 411 412 413static const struct ieee80211_channel_range *channel_range = 414 ieee80211_fcc_channels; 415 416 417static void ieee80211_unmask_channel(struct net_device *dev, int mode, 418 struct ieee80211_channel *chan) 419{ 420 int i; 421 422 chan->flag = 0; 423 424 if (ieee80211_regdom == 64 && 425 (mode == MODE_ATHEROS_TURBO || mode == MODE_ATHEROS_TURBOG)) { 426 /* Do not allow Turbo modes in Japan. */ 427 return; 428 } 429 430 for (i = 0; channel_range[i].start_freq; i++) { 431 const struct ieee80211_channel_range *r = &channel_range[i]; 432 if (r->start_freq <= chan->freq && r->end_freq >= chan->freq) { 433 if (ieee80211_regdom == 64 && !ieee80211_japan_5ghz && 434 chan->freq >= 5260 && chan->freq <= 5320) { 435 /* 436 * Skip new channels in Japan since the 437 * firmware was not marked having been upgraded 438 * by the vendor. 439 */ 440 continue; 441 } 442 443 if (ieee80211_regdom == 0x10 && 444 (chan->freq == 5190 || chan->freq == 5210 || 445 chan->freq == 5230)) { 446 /* Skip MKK channels when in FCC domain. */ 447 continue; 448 } 449 450 chan->flag |= IEEE80211_CHAN_W_SCAN | 451 IEEE80211_CHAN_W_ACTIVE_SCAN | 452 IEEE80211_CHAN_W_IBSS; 453 chan->power_level = r->power_level; 454 chan->antenna_max = r->antenna_max; 455 456 if (ieee80211_regdom == 64 && 457 (chan->freq == 5170 || chan->freq == 5190 || 458 chan->freq == 5210 || chan->freq == 5230)) { 459 /* 460 * New regulatory rules in Japan have backwards 461 * compatibility with old channels in 5.15-5.25 462 * GHz band, but the station is not allowed to 463 * use active scan on these old channels. 464 */ 465 chan->flag &= ~IEEE80211_CHAN_W_ACTIVE_SCAN; 466 } 467 468 if (ieee80211_regdom == 64 && 469 (chan->freq == 5260 || chan->freq == 5280 || 470 chan->freq == 5300 || chan->freq == 5320)) { 471 /* 472 * IBSS is not allowed on 5.25-5.35 GHz band 473 * due to radar detection requirements. 474 */ 475 chan->flag &= ~IEEE80211_CHAN_W_IBSS; 476 } 477 478 break; 479 } 480 } 481} 482 483 484static int ieee80211_unmask_channels(struct net_device *dev) 485{ 486 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 487 struct ieee80211_hw_mode *mode; 488 int c; 489 490 list_for_each_entry(mode, &local->modes_list, list) { 491 for (c = 0; c < mode->num_channels; c++) { 492 ieee80211_unmask_channel(dev, mode->mode, 493 &mode->channels[c]); 494 } 495 } 496 return 0; 497} 498 499 500int ieee80211_init_client(struct net_device *dev) 501{ 502 if (ieee80211_regdom == 0x40) 503 channel_range = ieee80211_mkk_channels; 504 ieee80211_unmask_channels(dev); 505 return 0; 506} 507 508 509static int ieee80211_ioctl_siwmode(struct net_device *dev, 510 struct iw_request_info *info, 511 __u32 *mode, char *extra) 512{ 513 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 514 int type; 515 516 if (sdata->type == IEEE80211_IF_TYPE_VLAN) 517 return -EOPNOTSUPP; 518 519 switch (*mode) { 520 case IW_MODE_INFRA: 521 type = IEEE80211_IF_TYPE_STA; 522 break; 523 case IW_MODE_ADHOC: 524 type = IEEE80211_IF_TYPE_IBSS; 525 break; 526 case IW_MODE_MONITOR: 527 type = IEEE80211_IF_TYPE_MNTR; 528 break; 529 default: 530 return -EINVAL; 531 } 532 533 if (type == sdata->type) 534 return 0; 535 if (netif_running(dev)) 536 return -EBUSY; 537 538 ieee80211_if_reinit(dev); 539 ieee80211_if_set_type(dev, type); 540 541 return 0; 542} 543 544 545static int ieee80211_ioctl_giwmode(struct net_device *dev, 546 struct iw_request_info *info, 547 __u32 *mode, char *extra) 548{ 549 struct ieee80211_sub_if_data *sdata; 550 551 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 552 switch (sdata->type) { 553 case IEEE80211_IF_TYPE_AP: 554 *mode = IW_MODE_MASTER; 555 break; 556 case IEEE80211_IF_TYPE_STA: 557 *mode = IW_MODE_INFRA; 558 break; 559 case IEEE80211_IF_TYPE_IBSS: 560 *mode = IW_MODE_ADHOC; 561 break; 562 case IEEE80211_IF_TYPE_MNTR: 563 *mode = IW_MODE_MONITOR; 564 break; 565 case IEEE80211_IF_TYPE_WDS: 566 *mode = IW_MODE_REPEAT; 567 break; 568 case IEEE80211_IF_TYPE_VLAN: 569 *mode = IW_MODE_SECOND; 570 break; 571 default: 572 *mode = IW_MODE_AUTO; 573 break; 574 } 575 return 0; 576} 577 578int ieee80211_set_channel(struct ieee80211_local *local, int channel, int freq) 579{ 580 struct ieee80211_hw_mode *mode; 581 int c, set = 0; 582 int ret = -EINVAL; 583 584 list_for_each_entry(mode, &local->modes_list, list) { 585 if (!(local->enabled_modes & (1 << mode->mode))) 586 continue; 587 for (c = 0; c < mode->num_channels; c++) { 588 struct ieee80211_channel *chan = &mode->channels[c]; 589 if (chan->flag & IEEE80211_CHAN_W_SCAN && 590 ((chan->chan == channel) || (chan->freq == freq))) { 591 /* Use next_mode as the mode preference to 592 * resolve non-unique channel numbers. */ 593 if (set && mode->mode != local->next_mode) 594 continue; 595 596 local->oper_channel = chan; 597 local->oper_hw_mode = mode; 598 set++; 599 } 600 } 601 } 602 603 if (set) { 604 if (local->sta_scanning) 605 ret = 0; 606 else 607 ret = ieee80211_hw_config(local); 608 609 rate_control_clear(local); 610 } 611 612 return ret; 613} 614 615static int ieee80211_ioctl_siwfreq(struct net_device *dev, 616 struct iw_request_info *info, 617 struct iw_freq *freq, char *extra) 618{ 619 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 620 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 621 622 if (sdata->type == IEEE80211_IF_TYPE_STA) 623 sdata->u.sta.auto_channel_sel = 0; 624 625 /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */ 626 if (freq->e == 0) { 627 if (freq->m < 0) { 628 if (sdata->type == IEEE80211_IF_TYPE_STA) 629 sdata->u.sta.auto_channel_sel = 1; 630 return 0; 631 } else 632 return ieee80211_set_channel(local, freq->m, -1); 633 } else { 634 int i, div = 1000000; 635 for (i = 0; i < freq->e; i++) 636 div /= 10; 637 if (div > 0) 638 return ieee80211_set_channel(local, -1, freq->m / div); 639 else 640 return -EINVAL; 641 } 642} 643 644 645static int ieee80211_ioctl_giwfreq(struct net_device *dev, 646 struct iw_request_info *info, 647 struct iw_freq *freq, char *extra) 648{ 649 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 650 651 /* TODO: in station mode (Managed/Ad-hoc) might need to poll low-level 652 * driver for the current channel with firmware-based management */ 653 654 freq->m = local->hw.conf.freq; 655 freq->e = 6; 656 657 return 0; 658} 659 660 661static int ieee80211_ioctl_siwessid(struct net_device *dev, 662 struct iw_request_info *info, 663 struct iw_point *data, char *ssid) 664{ 665 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 666 struct ieee80211_sub_if_data *sdata; 667 size_t len = data->length; 668 669 /* iwconfig uses nul termination in SSID.. */ 670 if (len > 0 && ssid[len - 1] == '\0') 671 len--; 672 673 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 674 if (sdata->type == IEEE80211_IF_TYPE_STA || 675 sdata->type == IEEE80211_IF_TYPE_IBSS) { 676 int ret; 677 if (local->user_space_mlme) { 678 if (len > IEEE80211_MAX_SSID_LEN) 679 return -EINVAL; 680 memcpy(sdata->u.sta.ssid, ssid, len); 681 sdata->u.sta.ssid_len = len; 682 return 0; 683 } 684 sdata->u.sta.auto_ssid_sel = !data->flags; 685 ret = ieee80211_sta_set_ssid(dev, ssid, len); 686 if (ret) 687 return ret; 688 ieee80211_sta_req_auth(dev, &sdata->u.sta); 689 return 0; 690 } 691 692 if (sdata->type == IEEE80211_IF_TYPE_AP) { 693 memcpy(sdata->u.ap.ssid, ssid, len); 694 memset(sdata->u.ap.ssid + len, 0, 695 IEEE80211_MAX_SSID_LEN - len); 696 sdata->u.ap.ssid_len = len; 697 return ieee80211_if_config(dev); 698 } 699 return -EOPNOTSUPP; 700} 701 702 703static int ieee80211_ioctl_giwessid(struct net_device *dev, 704 struct iw_request_info *info, 705 struct iw_point *data, char *ssid) 706{ 707 size_t len; 708 709 struct ieee80211_sub_if_data *sdata; 710 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 711 if (sdata->type == IEEE80211_IF_TYPE_STA || 712 sdata->type == IEEE80211_IF_TYPE_IBSS) { 713 int res = ieee80211_sta_get_ssid(dev, ssid, &len); 714 if (res == 0) { 715 data->length = len; 716 data->flags = 1; 717 } else 718 data->flags = 0; 719 return res; 720 } 721 722 if (sdata->type == IEEE80211_IF_TYPE_AP) { 723 len = sdata->u.ap.ssid_len; 724 if (len > IW_ESSID_MAX_SIZE) 725 len = IW_ESSID_MAX_SIZE; 726 memcpy(ssid, sdata->u.ap.ssid, len); 727 data->length = len; 728 data->flags = 1; 729 return 0; 730 } 731 return -EOPNOTSUPP; 732} 733 734 735static int ieee80211_ioctl_siwap(struct net_device *dev, 736 struct iw_request_info *info, 737 struct sockaddr *ap_addr, char *extra) 738{ 739 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 740 struct ieee80211_sub_if_data *sdata; 741 742 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 743 if (sdata->type == IEEE80211_IF_TYPE_STA || 744 sdata->type == IEEE80211_IF_TYPE_IBSS) { 745 int ret; 746 if (local->user_space_mlme) { 747 memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data, 748 ETH_ALEN); 749 return 0; 750 } 751 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data)) { 752 sdata->u.sta.auto_bssid_sel = 1; 753 sdata->u.sta.auto_channel_sel = 1; 754 } else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data)) 755 sdata->u.sta.auto_bssid_sel = 1; 756 else 757 sdata->u.sta.auto_bssid_sel = 0; 758 ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data); 759 if (ret) 760 return ret; 761 ieee80211_sta_req_auth(dev, &sdata->u.sta); 762 return 0; 763 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) { 764 if (memcmp(sdata->u.wds.remote_addr, (u8 *) &ap_addr->sa_data, 765 ETH_ALEN) == 0) 766 return 0; 767 return ieee80211_if_update_wds(dev, (u8 *) &ap_addr->sa_data); 768 } 769 770 return -EOPNOTSUPP; 771} 772 773 774static int ieee80211_ioctl_giwap(struct net_device *dev, 775 struct iw_request_info *info, 776 struct sockaddr *ap_addr, char *extra) 777{ 778 struct ieee80211_sub_if_data *sdata; 779 780 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 781 if (sdata->type == IEEE80211_IF_TYPE_STA || 782 sdata->type == IEEE80211_IF_TYPE_IBSS) { 783 ap_addr->sa_family = ARPHRD_ETHER; 784 memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN); 785 return 0; 786 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) { 787 ap_addr->sa_family = ARPHRD_ETHER; 788 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN); 789 return 0; 790 } 791 792 return -EOPNOTSUPP; 793} 794 795 796static int ieee80211_ioctl_siwscan(struct net_device *dev, 797 struct iw_request_info *info, 798 struct iw_point *data, char *extra) 799{ 800 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 801 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 802 u8 *ssid = NULL; 803 size_t ssid_len = 0; 804 805 if (!netif_running(dev)) 806 return -ENETDOWN; 807 808 if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) { 809 if (sdata->type == IEEE80211_IF_TYPE_STA || 810 sdata->type == IEEE80211_IF_TYPE_IBSS) { 811 ssid = sdata->u.sta.ssid; 812 ssid_len = sdata->u.sta.ssid_len; 813 } else if (sdata->type == IEEE80211_IF_TYPE_AP) { 814 ssid = sdata->u.ap.ssid; 815 ssid_len = sdata->u.ap.ssid_len; 816 } else 817 return -EINVAL; 818 } 819 return ieee80211_sta_req_scan(dev, ssid, ssid_len); 820} 821 822 823static int ieee80211_ioctl_giwscan(struct net_device *dev, 824 struct iw_request_info *info, 825 struct iw_point *data, char *extra) 826{ 827 int res; 828 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 829 if (local->sta_scanning) 830 return -EAGAIN; 831 res = ieee80211_sta_scan_results(dev, extra, data->length); 832 if (res >= 0) { 833 data->length = res; 834 return 0; 835 } 836 data->length = 0; 837 return res; 838} 839 840 841static int ieee80211_ioctl_siwrts(struct net_device *dev, 842 struct iw_request_info *info, 843 struct iw_param *rts, char *extra) 844{ 845 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 846 847 if (rts->disabled) 848 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD; 849 else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD) 850 return -EINVAL; 851 else 852 local->rts_threshold = rts->value; 853 854 /* If the wlan card performs RTS/CTS in hardware/firmware, 855 * configure it here */ 856 857 if (local->ops->set_rts_threshold) 858 local->ops->set_rts_threshold(local_to_hw(local), 859 local->rts_threshold); 860 861 return 0; 862} 863 864static int ieee80211_ioctl_giwrts(struct net_device *dev, 865 struct iw_request_info *info, 866 struct iw_param *rts, char *extra) 867{ 868 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 869 870 rts->value = local->rts_threshold; 871 rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD); 872 rts->fixed = 1; 873 874 return 0; 875} 876 877 878static int ieee80211_ioctl_siwfrag(struct net_device *dev, 879 struct iw_request_info *info, 880 struct iw_param *frag, char *extra) 881{ 882 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 883 884 if (frag->disabled) 885 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD; 886 else if (frag->value < 256 || 887 frag->value > IEEE80211_MAX_FRAG_THRESHOLD) 888 return -EINVAL; 889 else { 890 /* Fragment length must be even, so strip LSB. */ 891 local->fragmentation_threshold = frag->value & ~0x1; 892 } 893 894 /* If the wlan card performs fragmentation in hardware/firmware, 895 * configure it here */ 896 897 if (local->ops->set_frag_threshold) 898 local->ops->set_frag_threshold( 899 local_to_hw(local), 900 local->fragmentation_threshold); 901 902 return 0; 903} 904 905static int ieee80211_ioctl_giwfrag(struct net_device *dev, 906 struct iw_request_info *info, 907 struct iw_param *frag, char *extra) 908{ 909 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 910 911 frag->value = local->fragmentation_threshold; 912 frag->disabled = (frag->value >= IEEE80211_MAX_RTS_THRESHOLD); 913 frag->fixed = 1; 914 915 return 0; 916} 917 918 919static int ieee80211_ioctl_siwretry(struct net_device *dev, 920 struct iw_request_info *info, 921 struct iw_param *retry, char *extra) 922{ 923 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 924 925 if (retry->disabled || 926 (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT) 927 return -EINVAL; 928 929 if (retry->flags & IW_RETRY_MAX) 930 local->long_retry_limit = retry->value; 931 else if (retry->flags & IW_RETRY_MIN) 932 local->short_retry_limit = retry->value; 933 else { 934 local->long_retry_limit = retry->value; 935 local->short_retry_limit = retry->value; 936 } 937 938 if (local->ops->set_retry_limit) { 939 return local->ops->set_retry_limit( 940 local_to_hw(local), 941 local->short_retry_limit, 942 local->long_retry_limit); 943 } 944 945 return 0; 946} 947 948 949static int ieee80211_ioctl_giwretry(struct net_device *dev, 950 struct iw_request_info *info, 951 struct iw_param *retry, char *extra) 952{ 953 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 954 955 retry->disabled = 0; 956 if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) { 957 /* first return min value, iwconfig will ask max value 958 * later if needed */ 959 retry->flags |= IW_RETRY_LIMIT; 960 retry->value = local->short_retry_limit; 961 if (local->long_retry_limit != local->short_retry_limit) 962 retry->flags |= IW_RETRY_MIN; 963 return 0; 964 } 965 if (retry->flags & IW_RETRY_MAX) { 966 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX; 967 retry->value = local->long_retry_limit; 968 } 969 970 return 0; 971} 972 973static int ieee80211_ioctl_clear_keys(struct net_device *dev) 974{ 975 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 976 struct ieee80211_key_conf key; 977 int i; 978 u8 addr[ETH_ALEN]; 979 struct ieee80211_key_conf *keyconf; 980 struct ieee80211_sub_if_data *sdata; 981 struct sta_info *sta; 982 983 memset(addr, 0xff, ETH_ALEN); 984 read_lock(&local->sub_if_lock); 985 list_for_each_entry(sdata, &local->sub_if_list, list) { 986 for (i = 0; i < NUM_DEFAULT_KEYS; i++) { 987 keyconf = NULL; 988 if (sdata->keys[i] && 989 !sdata->keys[i]->force_sw_encrypt && 990 local->ops->set_key && 991 (keyconf = ieee80211_key_data2conf(local, 992 sdata->keys[i]))) 993 local->ops->set_key(local_to_hw(local), 994 DISABLE_KEY, addr, 995 keyconf, 0); 996 kfree(keyconf); 997 ieee80211_key_free(sdata->keys[i]); 998 sdata->keys[i] = NULL; 999 } 1000 sdata->default_key = NULL; 1001 } 1002 read_unlock(&local->sub_if_lock); 1003 1004 spin_lock_bh(&local->sta_lock); 1005 list_for_each_entry(sta, &local->sta_list, list) { 1006 keyconf = NULL; 1007 if (sta->key && !sta->key->force_sw_encrypt && 1008 local->ops->set_key && 1009 (keyconf = ieee80211_key_data2conf(local, sta->key))) 1010 local->ops->set_key(local_to_hw(local), DISABLE_KEY, 1011 sta->addr, keyconf, sta->aid); 1012 kfree(keyconf); 1013 ieee80211_key_free(sta->key); 1014 sta->key = NULL; 1015 } 1016 spin_unlock_bh(&local->sta_lock); 1017 1018 memset(&key, 0, sizeof(key)); 1019 if (local->ops->set_key && 1020 local->ops->set_key(local_to_hw(local), REMOVE_ALL_KEYS, 1021 NULL, &key, 0)) 1022 printk(KERN_DEBUG "%s: failed to remove hwaccel keys\n", 1023 dev->name); 1024 1025 return 0; 1026} 1027 1028 1029static int 1030ieee80211_ioctl_force_unicast_rate(struct net_device *dev, 1031 struct ieee80211_sub_if_data *sdata, 1032 int rate) 1033{ 1034 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1035 struct ieee80211_hw_mode *mode; 1036 int i; 1037 1038 if (sdata->type != IEEE80211_IF_TYPE_AP) 1039 return -ENOENT; 1040 1041 if (rate == 0) { 1042 sdata->u.ap.force_unicast_rateidx = -1; 1043 return 0; 1044 } 1045 1046 mode = local->oper_hw_mode; 1047 for (i = 0; i < mode->num_rates; i++) { 1048 if (mode->rates[i].rate == rate) { 1049 sdata->u.ap.force_unicast_rateidx = i; 1050 return 0; 1051 } 1052 } 1053 return -EINVAL; 1054} 1055 1056 1057static int 1058ieee80211_ioctl_max_ratectrl_rate(struct net_device *dev, 1059 struct ieee80211_sub_if_data *sdata, 1060 int rate) 1061{ 1062 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1063 struct ieee80211_hw_mode *mode; 1064 int i; 1065 1066 if (sdata->type != IEEE80211_IF_TYPE_AP) 1067 return -ENOENT; 1068 1069 if (rate == 0) { 1070 sdata->u.ap.max_ratectrl_rateidx = -1; 1071 return 0; 1072 } 1073 1074 mode = local->oper_hw_mode; 1075 for (i = 0; i < mode->num_rates; i++) { 1076 if (mode->rates[i].rate == rate) { 1077 sdata->u.ap.max_ratectrl_rateidx = i; 1078 return 0; 1079 } 1080 } 1081 return -EINVAL; 1082} 1083 1084 1085static void ieee80211_key_enable_hwaccel(struct ieee80211_local *local, 1086 struct ieee80211_key *key) 1087{ 1088 struct ieee80211_key_conf *keyconf; 1089 u8 addr[ETH_ALEN]; 1090 1091 if (!key || key->alg != ALG_WEP || !key->force_sw_encrypt || 1092 (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP)) 1093 return; 1094 1095 memset(addr, 0xff, ETH_ALEN); 1096 keyconf = ieee80211_key_data2conf(local, key); 1097 if (keyconf && local->ops->set_key && 1098 local->ops->set_key(local_to_hw(local), 1099 SET_KEY, addr, keyconf, 0) == 0) { 1100 key->force_sw_encrypt = 1101 !!(keyconf->flags & IEEE80211_KEY_FORCE_SW_ENCRYPT); 1102 key->hw_key_idx = keyconf->hw_key_idx; 1103 } 1104 kfree(keyconf); 1105} 1106 1107 1108static void ieee80211_key_disable_hwaccel(struct ieee80211_local *local, 1109 struct ieee80211_key *key) 1110{ 1111 struct ieee80211_key_conf *keyconf; 1112 u8 addr[ETH_ALEN]; 1113 1114 if (!key || key->alg != ALG_WEP || key->force_sw_encrypt || 1115 (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP)) 1116 return; 1117 1118 memset(addr, 0xff, ETH_ALEN); 1119 keyconf = ieee80211_key_data2conf(local, key); 1120 if (keyconf && local->ops->set_key) 1121 local->ops->set_key(local_to_hw(local), DISABLE_KEY, 1122 addr, keyconf, 0); 1123 kfree(keyconf); 1124 key->force_sw_encrypt = 1; 1125} 1126 1127 1128static int ieee80211_ioctl_default_wep_only(struct ieee80211_local *local, 1129 int value) 1130{ 1131 int i; 1132 struct ieee80211_sub_if_data *sdata; 1133 1134 local->default_wep_only = value; 1135 read_lock(&local->sub_if_lock); 1136 list_for_each_entry(sdata, &local->sub_if_list, list) 1137 for (i = 0; i < NUM_DEFAULT_KEYS; i++) 1138 if (value) 1139 ieee80211_key_enable_hwaccel(local, 1140 sdata->keys[i]); 1141 else 1142 ieee80211_key_disable_hwaccel(local, 1143 sdata->keys[i]); 1144 read_unlock(&local->sub_if_lock); 1145 1146 return 0; 1147} 1148 1149 1150void ieee80211_update_default_wep_only(struct ieee80211_local *local) 1151{ 1152 int i = 0; 1153 struct ieee80211_sub_if_data *sdata; 1154 1155 read_lock(&local->sub_if_lock); 1156 list_for_each_entry(sdata, &local->sub_if_list, list) { 1157 1158 if (sdata->dev == local->mdev) 1159 continue; 1160 1161 /* If there is an AP interface then depend on userspace to 1162 set default_wep_only correctly. */ 1163 if (sdata->type == IEEE80211_IF_TYPE_AP) { 1164 read_unlock(&local->sub_if_lock); 1165 return; 1166 } 1167 1168 i++; 1169 } 1170 1171 read_unlock(&local->sub_if_lock); 1172 1173 if (i <= 1) 1174 ieee80211_ioctl_default_wep_only(local, 1); 1175 else 1176 ieee80211_ioctl_default_wep_only(local, 0); 1177} 1178 1179 1180static int ieee80211_ioctl_prism2_param(struct net_device *dev, 1181 struct iw_request_info *info, 1182 void *wrqu, char *extra) 1183{ 1184 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1185 struct ieee80211_sub_if_data *sdata; 1186 int *i = (int *) extra; 1187 int param = *i; 1188 int value = *(i + 1); 1189 int ret = 0; 1190 1191 if (!capable(CAP_NET_ADMIN)) 1192 return -EPERM; 1193 1194 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1195 1196 switch (param) { 1197 case PRISM2_PARAM_IEEE_802_1X: 1198 if (local->ops->set_ieee8021x) 1199 ret = local->ops->set_ieee8021x(local_to_hw(local), 1200 value); 1201 if (ret) 1202 printk(KERN_DEBUG "%s: failed to set IEEE 802.1X (%d) " 1203 "for low-level driver\n", dev->name, value); 1204 else 1205 sdata->ieee802_1x = value; 1206 break; 1207 1208 case PRISM2_PARAM_ANTSEL_TX: 1209 local->hw.conf.antenna_sel_tx = value; 1210 if (ieee80211_hw_config(local)) 1211 ret = -EINVAL; 1212 break; 1213 1214 case PRISM2_PARAM_ANTSEL_RX: 1215 local->hw.conf.antenna_sel_rx = value; 1216 if (ieee80211_hw_config(local)) 1217 ret = -EINVAL; 1218 break; 1219 1220 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES: 1221 local->cts_protect_erp_frames = value; 1222 break; 1223 1224 case PRISM2_PARAM_DROP_UNENCRYPTED: 1225 sdata->drop_unencrypted = value; 1226 break; 1227 1228 case PRISM2_PARAM_PREAMBLE: 1229 local->short_preamble = value; 1230 break; 1231 1232 case PRISM2_PARAM_STAT_TIME: 1233 if (!local->stat_time && value) { 1234 local->stat_timer.expires = jiffies + HZ * value / 100; 1235 add_timer(&local->stat_timer); 1236 } else if (local->stat_time && !value) { 1237 del_timer_sync(&local->stat_timer); 1238 } 1239 local->stat_time = value; 1240 break; 1241 case PRISM2_PARAM_SHORT_SLOT_TIME: 1242 if (value) 1243 local->hw.conf.flags |= IEEE80211_CONF_SHORT_SLOT_TIME; 1244 else 1245 local->hw.conf.flags &= ~IEEE80211_CONF_SHORT_SLOT_TIME; 1246 if (ieee80211_hw_config(local)) 1247 ret = -EINVAL; 1248 break; 1249 1250 case PRISM2_PARAM_NEXT_MODE: 1251 local->next_mode = value; 1252 break; 1253 1254 case PRISM2_PARAM_CLEAR_KEYS: 1255 ret = ieee80211_ioctl_clear_keys(dev); 1256 break; 1257 1258 case PRISM2_PARAM_RADIO_ENABLED: 1259 ret = ieee80211_ioctl_set_radio_enabled(dev, value); 1260 break; 1261 1262 case PRISM2_PARAM_ANTENNA_MODE: 1263 local->hw.conf.antenna_mode = value; 1264 if (ieee80211_hw_config(local)) 1265 ret = -EINVAL; 1266 break; 1267 1268 case PRISM2_PARAM_STA_ANTENNA_SEL: 1269 local->sta_antenna_sel = value; 1270 break; 1271 1272 case PRISM2_PARAM_FORCE_UNICAST_RATE: 1273 ret = ieee80211_ioctl_force_unicast_rate(dev, sdata, value); 1274 break; 1275 1276 case PRISM2_PARAM_MAX_RATECTRL_RATE: 1277 ret = ieee80211_ioctl_max_ratectrl_rate(dev, sdata, value); 1278 break; 1279 1280 case PRISM2_PARAM_RATE_CTRL_NUM_UP: 1281 local->rate_ctrl_num_up = value; 1282 break; 1283 1284 case PRISM2_PARAM_RATE_CTRL_NUM_DOWN: 1285 local->rate_ctrl_num_down = value; 1286 break; 1287 1288 case PRISM2_PARAM_TX_POWER_REDUCTION: 1289 if (value < 0) 1290 ret = -EINVAL; 1291 else 1292 local->hw.conf.tx_power_reduction = value; 1293 break; 1294 1295 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD: 1296 local->key_tx_rx_threshold = value; 1297 break; 1298 1299 case PRISM2_PARAM_DEFAULT_WEP_ONLY: 1300 ret = ieee80211_ioctl_default_wep_only(local, value); 1301 break; 1302 1303 case PRISM2_PARAM_WIFI_WME_NOACK_TEST: 1304 local->wifi_wme_noack_test = value; 1305 break; 1306 1307 case PRISM2_PARAM_SCAN_FLAGS: 1308 local->scan_flags = value; 1309 break; 1310 1311 case PRISM2_PARAM_MIXED_CELL: 1312 if (sdata->type != IEEE80211_IF_TYPE_STA && 1313 sdata->type != IEEE80211_IF_TYPE_IBSS) 1314 ret = -EINVAL; 1315 else 1316 sdata->u.sta.mixed_cell = !!value; 1317 break; 1318 1319 case PRISM2_PARAM_HW_MODES: 1320 local->enabled_modes = value; 1321 break; 1322 1323 case PRISM2_PARAM_CREATE_IBSS: 1324 if (sdata->type != IEEE80211_IF_TYPE_IBSS) 1325 ret = -EINVAL; 1326 else 1327 sdata->u.sta.create_ibss = !!value; 1328 break; 1329 case PRISM2_PARAM_WMM_ENABLED: 1330 if (sdata->type != IEEE80211_IF_TYPE_STA && 1331 sdata->type != IEEE80211_IF_TYPE_IBSS) 1332 ret = -EINVAL; 1333 else 1334 sdata->u.sta.wmm_enabled = !!value; 1335 break; 1336 case PRISM2_PARAM_RADAR_DETECT: 1337 local->hw.conf.radar_detect = value; 1338 break; 1339 case PRISM2_PARAM_SPECTRUM_MGMT: 1340 local->hw.conf.spect_mgmt = value; 1341 break; 1342 default: 1343 ret = -EOPNOTSUPP; 1344 break; 1345 } 1346 1347 return ret; 1348} 1349 1350 1351static int ieee80211_ioctl_get_prism2_param(struct net_device *dev, 1352 struct iw_request_info *info, 1353 void *wrqu, char *extra) 1354{ 1355 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1356 struct ieee80211_sub_if_data *sdata; 1357 int *param = (int *) extra; 1358 int ret = 0; 1359 1360 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1361 1362 switch (*param) { 1363 case PRISM2_PARAM_IEEE_802_1X: 1364 *param = sdata->ieee802_1x; 1365 break; 1366 1367 case PRISM2_PARAM_ANTSEL_TX: 1368 *param = local->hw.conf.antenna_sel_tx; 1369 break; 1370 1371 case PRISM2_PARAM_ANTSEL_RX: 1372 *param = local->hw.conf.antenna_sel_rx; 1373 break; 1374 1375 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES: 1376 *param = local->cts_protect_erp_frames; 1377 break; 1378 1379 case PRISM2_PARAM_DROP_UNENCRYPTED: 1380 *param = sdata->drop_unencrypted; 1381 break; 1382 1383 case PRISM2_PARAM_PREAMBLE: 1384 *param = local->short_preamble; 1385 break; 1386 1387 case PRISM2_PARAM_STAT_TIME: 1388 *param = local->stat_time; 1389 break; 1390 case PRISM2_PARAM_SHORT_SLOT_TIME: 1391 *param = !!(local->hw.conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME); 1392 break; 1393 1394 case PRISM2_PARAM_NEXT_MODE: 1395 *param = local->next_mode; 1396 break; 1397 1398 case PRISM2_PARAM_ANTENNA_MODE: 1399 *param = local->hw.conf.antenna_mode; 1400 break; 1401 1402 case PRISM2_PARAM_STA_ANTENNA_SEL: 1403 *param = local->sta_antenna_sel; 1404 break; 1405 1406 case PRISM2_PARAM_RATE_CTRL_NUM_UP: 1407 *param = local->rate_ctrl_num_up; 1408 break; 1409 1410 case PRISM2_PARAM_RATE_CTRL_NUM_DOWN: 1411 *param = local->rate_ctrl_num_down; 1412 break; 1413 1414 case PRISM2_PARAM_TX_POWER_REDUCTION: 1415 *param = local->hw.conf.tx_power_reduction; 1416 break; 1417 1418 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD: 1419 *param = local->key_tx_rx_threshold; 1420 break; 1421 1422 case PRISM2_PARAM_DEFAULT_WEP_ONLY: 1423 *param = local->default_wep_only; 1424 break; 1425 1426 case PRISM2_PARAM_WIFI_WME_NOACK_TEST: 1427 *param = local->wifi_wme_noack_test; 1428 break; 1429 1430 case PRISM2_PARAM_SCAN_FLAGS: 1431 *param = local->scan_flags; 1432 break; 1433 1434 case PRISM2_PARAM_HW_MODES: 1435 *param = local->enabled_modes; 1436 break; 1437 1438 case PRISM2_PARAM_CREATE_IBSS: 1439 if (sdata->type != IEEE80211_IF_TYPE_IBSS) 1440 ret = -EINVAL; 1441 else 1442 *param = !!sdata->u.sta.create_ibss; 1443 break; 1444 1445 case PRISM2_PARAM_MIXED_CELL: 1446 if (sdata->type != IEEE80211_IF_TYPE_STA && 1447 sdata->type != IEEE80211_IF_TYPE_IBSS) 1448 ret = -EINVAL; 1449 else 1450 *param = !!sdata->u.sta.mixed_cell; 1451 break; 1452 case PRISM2_PARAM_WMM_ENABLED: 1453 if (sdata->type != IEEE80211_IF_TYPE_STA && 1454 sdata->type != IEEE80211_IF_TYPE_IBSS) 1455 ret = -EINVAL; 1456 else 1457 *param = !!sdata->u.sta.wmm_enabled; 1458 break; 1459 default: 1460 ret = -EOPNOTSUPP; 1461 break; 1462 } 1463 1464 return ret; 1465} 1466 1467static int ieee80211_ioctl_siwmlme(struct net_device *dev, 1468 struct iw_request_info *info, 1469 struct iw_point *data, char *extra) 1470{ 1471 struct ieee80211_sub_if_data *sdata; 1472 struct iw_mlme *mlme = (struct iw_mlme *) extra; 1473 1474 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1475 if (sdata->type != IEEE80211_IF_TYPE_STA && 1476 sdata->type != IEEE80211_IF_TYPE_IBSS) 1477 return -EINVAL; 1478 1479 switch (mlme->cmd) { 1480 case IW_MLME_DEAUTH: 1481 /* TODO: mlme->addr.sa_data */ 1482 return ieee80211_sta_deauthenticate(dev, mlme->reason_code); 1483 case IW_MLME_DISASSOC: 1484 /* TODO: mlme->addr.sa_data */ 1485 return ieee80211_sta_disassociate(dev, mlme->reason_code); 1486 default: 1487 return -EOPNOTSUPP; 1488 } 1489} 1490 1491 1492static int ieee80211_ioctl_siwencode(struct net_device *dev, 1493 struct iw_request_info *info, 1494 struct iw_point *erq, char *keybuf) 1495{ 1496 struct ieee80211_sub_if_data *sdata; 1497 int idx, i, alg = ALG_WEP; 1498 u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 1499 1500 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1501 1502 idx = erq->flags & IW_ENCODE_INDEX; 1503 if (idx == 0) { 1504 if (sdata->default_key) 1505 for (i = 0; i < NUM_DEFAULT_KEYS; i++) { 1506 if (sdata->default_key == sdata->keys[i]) { 1507 idx = i; 1508 break; 1509 } 1510 } 1511 } else if (idx < 1 || idx > 4) 1512 return -EINVAL; 1513 else 1514 idx--; 1515 1516 if (erq->flags & IW_ENCODE_DISABLED) 1517 alg = ALG_NONE; 1518 else if (erq->length == 0) { 1519 /* No key data - just set the default TX key index */ 1520 if (sdata->default_key != sdata->keys[idx]) { 1521 ieee80211_debugfs_key_remove_default(sdata); 1522 sdata->default_key = sdata->keys[idx]; 1523 if (sdata->default_key) 1524 ieee80211_debugfs_key_add_default(sdata); 1525 } 1526 return 0; 1527 } 1528 1529 return ieee80211_set_encryption( 1530 dev, bcaddr, 1531 idx, alg, 1532 !sdata->default_key, 1533 keybuf, erq->length); 1534} 1535 1536 1537static int ieee80211_ioctl_giwencode(struct net_device *dev, 1538 struct iw_request_info *info, 1539 struct iw_point *erq, char *key) 1540{ 1541 struct ieee80211_sub_if_data *sdata; 1542 int idx, i; 1543 1544 sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1545 1546 idx = erq->flags & IW_ENCODE_INDEX; 1547 if (idx < 1 || idx > 4) { 1548 idx = -1; 1549 if (!sdata->default_key) 1550 idx = 0; 1551 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) { 1552 if (sdata->default_key == sdata->keys[i]) { 1553 idx = i; 1554 break; 1555 } 1556 } 1557 if (idx < 0) 1558 return -EINVAL; 1559 } else 1560 idx--; 1561 1562 erq->flags = idx + 1; 1563 1564 if (!sdata->keys[idx]) { 1565 erq->length = 0; 1566 erq->flags |= IW_ENCODE_DISABLED; 1567 return 0; 1568 } 1569 1570 memcpy(key, sdata->keys[idx]->key, 1571 min((int)erq->length, sdata->keys[idx]->keylen)); 1572 erq->length = sdata->keys[idx]->keylen; 1573 erq->flags |= IW_ENCODE_ENABLED; 1574 1575 return 0; 1576} 1577 1578static int ieee80211_ioctl_siwauth(struct net_device *dev, 1579 struct iw_request_info *info, 1580 struct iw_param *data, char *extra) 1581{ 1582 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1583 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1584 int ret = 0; 1585 1586 switch (data->flags & IW_AUTH_INDEX) { 1587 case IW_AUTH_WPA_VERSION: 1588 case IW_AUTH_CIPHER_PAIRWISE: 1589 case IW_AUTH_CIPHER_GROUP: 1590 case IW_AUTH_WPA_ENABLED: 1591 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 1592 break; 1593 case IW_AUTH_KEY_MGMT: 1594 if (sdata->type != IEEE80211_IF_TYPE_STA) 1595 ret = -EINVAL; 1596 else { 1597 /* 1598 * TODO: sdata->u.sta.key_mgmt does not match with WE18 1599 * value completely; could consider modifying this to 1600 * be closer to WE18. For now, this value is not really 1601 * used for anything else than Privacy matching, so the 1602 * current code here should be more or less OK. 1603 */ 1604 if (data->value & IW_AUTH_KEY_MGMT_802_1X) { 1605 sdata->u.sta.key_mgmt = 1606 IEEE80211_KEY_MGMT_WPA_EAP; 1607 } else if (data->value & IW_AUTH_KEY_MGMT_PSK) { 1608 sdata->u.sta.key_mgmt = 1609 IEEE80211_KEY_MGMT_WPA_PSK; 1610 } else { 1611 sdata->u.sta.key_mgmt = 1612 IEEE80211_KEY_MGMT_NONE; 1613 } 1614 } 1615 break; 1616 case IW_AUTH_80211_AUTH_ALG: 1617 if (sdata->type == IEEE80211_IF_TYPE_STA || 1618 sdata->type == IEEE80211_IF_TYPE_IBSS) 1619 sdata->u.sta.auth_algs = data->value; 1620 else 1621 ret = -EOPNOTSUPP; 1622 break; 1623 case IW_AUTH_PRIVACY_INVOKED: 1624 if (local->ops->set_privacy_invoked) 1625 ret = local->ops->set_privacy_invoked( 1626 local_to_hw(local), data->value); 1627 break; 1628 default: 1629 ret = -EOPNOTSUPP; 1630 break; 1631 } 1632 return ret; 1633} 1634 1635/* Get wireless statistics. Called by /proc/net/wireless and by SIOCGIWSTATS */ 1636static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev) 1637{ 1638 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 1639 struct iw_statistics *wstats = &local->wstats; 1640 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1641 struct sta_info *sta = NULL; 1642 1643 if (sdata->type == IEEE80211_IF_TYPE_STA || 1644 sdata->type == IEEE80211_IF_TYPE_IBSS) 1645 sta = sta_info_get(local, sdata->u.sta.bssid); 1646 if (!sta) { 1647 wstats->discard.fragment = 0; 1648 wstats->discard.misc = 0; 1649 wstats->qual.qual = 0; 1650 wstats->qual.level = 0; 1651 wstats->qual.noise = 0; 1652 wstats->qual.updated = IW_QUAL_ALL_INVALID; 1653 } else { 1654 wstats->qual.level = sta->last_rssi; 1655 wstats->qual.qual = sta->last_signal; 1656 wstats->qual.noise = sta->last_noise; 1657 wstats->qual.updated = local->wstats_flags; 1658 sta_info_put(sta); 1659 } 1660 return wstats; 1661} 1662 1663static int ieee80211_ioctl_giwauth(struct net_device *dev, 1664 struct iw_request_info *info, 1665 struct iw_param *data, char *extra) 1666{ 1667 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1668 int ret = 0; 1669 1670 switch (data->flags & IW_AUTH_INDEX) { 1671 case IW_AUTH_80211_AUTH_ALG: 1672 if (sdata->type == IEEE80211_IF_TYPE_STA || 1673 sdata->type == IEEE80211_IF_TYPE_IBSS) 1674 data->value = sdata->u.sta.auth_algs; 1675 else 1676 ret = -EOPNOTSUPP; 1677 break; 1678 default: 1679 ret = -EOPNOTSUPP; 1680 break; 1681 } 1682 return ret; 1683} 1684 1685 1686static int ieee80211_ioctl_siwencodeext(struct net_device *dev, 1687 struct iw_request_info *info, 1688 struct iw_point *erq, char *extra) 1689{ 1690 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 1691 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra; 1692 int alg, idx, i; 1693 1694 switch (ext->alg) { 1695 case IW_ENCODE_ALG_NONE: 1696 alg = ALG_NONE; 1697 break; 1698 case IW_ENCODE_ALG_WEP: 1699 alg = ALG_WEP; 1700 break; 1701 case IW_ENCODE_ALG_TKIP: 1702 alg = ALG_TKIP; 1703 break; 1704 case IW_ENCODE_ALG_CCMP: 1705 alg = ALG_CCMP; 1706 break; 1707 default: 1708 return -EOPNOTSUPP; 1709 } 1710 1711 if (erq->flags & IW_ENCODE_DISABLED) 1712 alg = ALG_NONE; 1713 1714 idx = erq->flags & IW_ENCODE_INDEX; 1715 if (idx < 1 || idx > 4) { 1716 idx = -1; 1717 if (!sdata->default_key) 1718 idx = 0; 1719 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) { 1720 if (sdata->default_key == sdata->keys[i]) { 1721 idx = i; 1722 break; 1723 } 1724 } 1725 if (idx < 0) 1726 return -EINVAL; 1727 } else 1728 idx--; 1729 1730 return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg, 1731 ext->ext_flags & 1732 IW_ENCODE_EXT_SET_TX_KEY, 1733 ext->key, ext->key_len); 1734} 1735 1736 1737static const struct iw_priv_args ieee80211_ioctl_priv[] = { 1738 { PRISM2_IOCTL_PRISM2_PARAM, 1739 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "param" }, 1740 { PRISM2_IOCTL_GET_PRISM2_PARAM, 1741 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 1742 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_param" }, 1743}; 1744 1745/* Structures to export the Wireless Handlers */ 1746 1747static const iw_handler ieee80211_handler[] = 1748{ 1749 (iw_handler) NULL, /* SIOCSIWCOMMIT */ 1750 (iw_handler) ieee80211_ioctl_giwname, /* SIOCGIWNAME */ 1751 (iw_handler) NULL, /* SIOCSIWNWID */ 1752 (iw_handler) NULL, /* SIOCGIWNWID */ 1753 (iw_handler) ieee80211_ioctl_siwfreq, /* SIOCSIWFREQ */ 1754 (iw_handler) ieee80211_ioctl_giwfreq, /* SIOCGIWFREQ */ 1755 (iw_handler) ieee80211_ioctl_siwmode, /* SIOCSIWMODE */ 1756 (iw_handler) ieee80211_ioctl_giwmode, /* SIOCGIWMODE */ 1757 (iw_handler) NULL, /* SIOCSIWSENS */ 1758 (iw_handler) NULL, /* SIOCGIWSENS */ 1759 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */ 1760 (iw_handler) ieee80211_ioctl_giwrange, /* SIOCGIWRANGE */ 1761 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */ 1762 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */ 1763 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */ 1764 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */ 1765 iw_handler_set_spy, /* SIOCSIWSPY */ 1766 iw_handler_get_spy, /* SIOCGIWSPY */ 1767 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */ 1768 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */ 1769 (iw_handler) ieee80211_ioctl_siwap, /* SIOCSIWAP */ 1770 (iw_handler) ieee80211_ioctl_giwap, /* SIOCGIWAP */ 1771 (iw_handler) ieee80211_ioctl_siwmlme, /* SIOCSIWMLME */ 1772 (iw_handler) NULL, /* SIOCGIWAPLIST */ 1773 (iw_handler) ieee80211_ioctl_siwscan, /* SIOCSIWSCAN */ 1774 (iw_handler) ieee80211_ioctl_giwscan, /* SIOCGIWSCAN */ 1775 (iw_handler) ieee80211_ioctl_siwessid, /* SIOCSIWESSID */ 1776 (iw_handler) ieee80211_ioctl_giwessid, /* SIOCGIWESSID */ 1777 (iw_handler) NULL, /* SIOCSIWNICKN */ 1778 (iw_handler) NULL, /* SIOCGIWNICKN */ 1779 (iw_handler) NULL, /* -- hole -- */ 1780 (iw_handler) NULL, /* -- hole -- */ 1781 (iw_handler) NULL, /* SIOCSIWRATE */ 1782 (iw_handler) NULL, /* SIOCGIWRATE */ 1783 (iw_handler) ieee80211_ioctl_siwrts, /* SIOCSIWRTS */ 1784 (iw_handler) ieee80211_ioctl_giwrts, /* SIOCGIWRTS */ 1785 (iw_handler) ieee80211_ioctl_siwfrag, /* SIOCSIWFRAG */ 1786 (iw_handler) ieee80211_ioctl_giwfrag, /* SIOCGIWFRAG */ 1787 (iw_handler) NULL, /* SIOCSIWTXPOW */ 1788 (iw_handler) NULL, /* SIOCGIWTXPOW */ 1789 (iw_handler) ieee80211_ioctl_siwretry, /* SIOCSIWRETRY */ 1790 (iw_handler) ieee80211_ioctl_giwretry, /* SIOCGIWRETRY */ 1791 (iw_handler) ieee80211_ioctl_siwencode, /* SIOCSIWENCODE */ 1792 (iw_handler) ieee80211_ioctl_giwencode, /* SIOCGIWENCODE */ 1793 (iw_handler) NULL, /* SIOCSIWPOWER */ 1794 (iw_handler) NULL, /* SIOCGIWPOWER */ 1795 (iw_handler) NULL, /* -- hole -- */ 1796 (iw_handler) NULL, /* -- hole -- */ 1797 (iw_handler) ieee80211_ioctl_siwgenie, /* SIOCSIWGENIE */ 1798 (iw_handler) NULL, /* SIOCGIWGENIE */ 1799 (iw_handler) ieee80211_ioctl_siwauth, /* SIOCSIWAUTH */ 1800 (iw_handler) ieee80211_ioctl_giwauth, /* SIOCGIWAUTH */ 1801 (iw_handler) ieee80211_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */ 1802 (iw_handler) NULL, /* SIOCGIWENCODEEXT */ 1803 (iw_handler) NULL, /* SIOCSIWPMKSA */ 1804 (iw_handler) NULL, /* -- hole -- */ 1805}; 1806 1807static const iw_handler ieee80211_private_handler[] = 1808{ /* SIOCIWFIRSTPRIV + */ 1809 (iw_handler) ieee80211_ioctl_prism2_param, /* 0 */ 1810 (iw_handler) ieee80211_ioctl_get_prism2_param, /* 1 */ 1811}; 1812 1813const struct iw_handler_def ieee80211_iw_handler_def = 1814{ 1815 .num_standard = ARRAY_SIZE(ieee80211_handler), 1816 .num_private = ARRAY_SIZE(ieee80211_private_handler), 1817 .num_private_args = ARRAY_SIZE(ieee80211_ioctl_priv), 1818 .standard = (iw_handler *) ieee80211_handler, 1819 .private = (iw_handler *) ieee80211_private_handler, 1820 .private_args = (struct iw_priv_args *) ieee80211_ioctl_priv, 1821 .get_wireless_stats = ieee80211_get_wireless_stats, 1822}; 1823