package/mac80211/src/mac80211/ieee80211_ioctl.c

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