target/linux/package/ieee80211-dscape/src/ieee80211_ioctl.c

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