git.oblomov.eu Git - linux-2.6/blob - net/mac80211/wext.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 "led.h"
  25 #include "rate.h"
  26 #include "wpa.h"
  27 #include "aes_ccm.h"
  28
  29
  30 static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr,
  31                                     int idx, int alg, int remove,
  32                                     int set_tx_key, const u8 *_key,
  33                                     size_t key_len)
  34 {
  35         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  36         struct sta_info *sta;
  37         struct ieee80211_key *key;
  38         struct ieee80211_sub_if_data *sdata;
  39         int err;
  40
  41         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  42
  43         if (idx < 0 || idx >= NUM_DEFAULT_KEYS) {
  44                 printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
  45                        dev->name, idx);
  46                 return -EINVAL;
  47         }
  48
  49         if (remove) {
  50                 rcu_read_lock();
  51
  52                 err = 0;
  53
  54                 if (is_broadcast_ether_addr(sta_addr)) {
  55                         key = sdata->keys[idx];
  56                 } else {
  57                         sta = sta_info_get(local, sta_addr);
  58                         if (!sta) {
  59                                 err = -ENOENT;
  60                                 goto out_unlock;
  61                         }
  62                         key = sta->key;
  63                 }
  64
  65                 ieee80211_key_free(key);
  66         } else {
  67                 key = ieee80211_key_alloc(alg, idx, key_len, _key);
  68                 if (!key)
  69                         return -ENOMEM;
  70
  71                 sta = NULL;
  72                 err = 0;
  73
  74                 rcu_read_lock();
  75
  76                 if (!is_broadcast_ether_addr(sta_addr)) {
  77                         set_tx_key = 0;
  78                         /*
  79                          * According to the standard, the key index of a
  80                          * pairwise key must be zero. However, some AP are
  81                          * broken when it comes to WEP key indices, so we
  82                          * work around this.
  83                          */
  84                         if (idx != 0 && alg != ALG_WEP) {
  85                                 ieee80211_key_free(key);
  86                                 err = -EINVAL;
  87                                 goto out_unlock;
  88                         }
  89
  90                         sta = sta_info_get(local, sta_addr);
  91                         if (!sta) {
  92                                 ieee80211_key_free(key);
  93                                 err = -ENOENT;
  94                                 goto out_unlock;
  95                         }
  96                 }
  97
  98                 if (alg == ALG_WEP &&
  99                         key_len != LEN_WEP40 && key_len != LEN_WEP104) {
 100                         ieee80211_key_free(key);
 101                         err = -EINVAL;
 102                         goto out_unlock;
 103                 }
 104
 105                 ieee80211_key_link(key, sdata, sta);
 106
 107                 if (set_tx_key || (!sta && !sdata->default_key && key))
 108                         ieee80211_set_default_key(sdata, idx);
 109         }
 110
 111  out_unlock:
 112         rcu_read_unlock();
 113
 114         return err;
 115 }
 116
 117 static int ieee80211_ioctl_siwgenie(struct net_device *dev,
 118                                     struct iw_request_info *info,
 119                                     struct iw_point *data, char *extra)
 120 {
 121         struct ieee80211_sub_if_data *sdata;
 122
 123         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 124
 125         if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)
 126                 return -EOPNOTSUPP;
 127
 128         if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
 129             sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
 130                 int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length);
 131                 if (ret)
 132                         return ret;
 133                 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
 134                 ieee80211_sta_req_auth(dev, &sdata->u.sta);
 135                 return 0;
 136         }
 137
 138         return -EOPNOTSUPP;
 139 }
 140
 141 static int ieee80211_ioctl_giwname(struct net_device *dev,
 142                                    struct iw_request_info *info,
 143                                    char *name, char *extra)
 144 {
 145         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 146         struct ieee80211_supported_band *sband;
 147         u8 is_ht = 0, is_a = 0, is_b = 0, is_g = 0;
 148
 149
 150         sband = local->hw.wiphy->bands[IEEE80211_BAND_5GHZ];
 151         if (sband) {
 152                 is_a = 1;
 153                 is_ht |= sband->ht_info.ht_supported;
 154         }
 155
 156         sband = local->hw.wiphy->bands[IEEE80211_BAND_2GHZ];
 157         if (sband) {
 158                 int i;
 159                 /* Check for mandatory rates */
 160                 for (i = 0; i < sband->n_bitrates; i++) {
 161                         if (sband->bitrates[i].bitrate == 10)
 162                                 is_b = 1;
 163                         if (sband->bitrates[i].bitrate == 60)
 164                                 is_g = 1;
 165                 }
 166                 is_ht |= sband->ht_info.ht_supported;
 167         }
 168
 169         strcpy(name, "IEEE 802.11");
 170         if (is_a)
 171                 strcat(name, "a");
 172         if (is_b)
 173                 strcat(name, "b");
 174         if (is_g)
 175                 strcat(name, "g");
 176         if (is_ht)
 177                 strcat(name, "n");
 178
 179         return 0;
 180 }
 181
 182
 183 static int ieee80211_ioctl_giwrange(struct net_device *dev,
 184                                  struct iw_request_info *info,
 185                                  struct iw_point *data, char *extra)
 186 {
 187         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 188         struct iw_range *range = (struct iw_range *) extra;
 189         enum ieee80211_band band;
 190         int c = 0;
 191
 192         data->length = sizeof(struct iw_range);
 193         memset(range, 0, sizeof(struct iw_range));
 194
 195         range->we_version_compiled = WIRELESS_EXT;
 196         range->we_version_source = 21;
 197         range->retry_capa = IW_RETRY_LIMIT;
 198         range->retry_flags = IW_RETRY_LIMIT;
 199         range->min_retry = 0;
 200         range->max_retry = 255;
 201         range->min_rts = 0;
 202         range->max_rts = 2347;
 203         range->min_frag = 256;
 204         range->max_frag = 2346;
 205
 206         range->encoding_size[0] = 5;
 207         range->encoding_size[1] = 13;
 208         range->num_encoding_sizes = 2;
 209         range->max_encoding_tokens = NUM_DEFAULT_KEYS;
 210
 211         if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC ||
 212             local->hw.flags & IEEE80211_HW_SIGNAL_DB)
 213                 range->max_qual.level = local->hw.max_signal;
 214         else if  (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
 215                 range->max_qual.level = -110;
 216         else
 217                 range->max_qual.level = 0;
 218
 219         if (local->hw.flags & IEEE80211_HW_NOISE_DBM)
 220                 range->max_qual.noise = -110;
 221         else
 222                 range->max_qual.noise = 0;
 223
 224         range->max_qual.qual = 100;
 225         range->max_qual.updated = local->wstats_flags;
 226
 227         range->avg_qual.qual = 50;
 228         /* not always true but better than nothing */
 229         range->avg_qual.level = range->max_qual.level / 2;
 230         range->avg_qual.noise = range->max_qual.noise / 2;
 231         range->avg_qual.updated = local->wstats_flags;
 232
 233         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
 234                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
 235
 236
 237         for (band = 0; band < IEEE80211_NUM_BANDS; band ++) {
 238                 int i;
 239                 struct ieee80211_supported_band *sband;
 240
 241                 sband = local->hw.wiphy->bands[band];
 242
 243                 if (!sband)
 244                         continue;
 245
 246                 for (i = 0; i < sband->n_channels && c < IW_MAX_FREQUENCIES; i++) {
 247                         struct ieee80211_channel *chan = &sband->channels[i];
 248
 249                         if (!(chan->flags & IEEE80211_CHAN_DISABLED)) {
 250                                 range->freq[c].i =
 251                                         ieee80211_frequency_to_channel(
 252                                                 chan->center_freq);
 253                                 range->freq[c].m = chan->center_freq;
 254                                 range->freq[c].e = 6;
 255                                 c++;
 256                         }
 257                 }
 258         }
 259         range->num_channels = c;
 260         range->num_frequency = c;
 261
 262         IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
 263         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
 264         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
 265
 266         range->scan_capa |= IW_SCAN_CAPA_ESSID;
 267
 268         return 0;
 269 }
 270
 271
 272 static int ieee80211_ioctl_siwmode(struct net_device *dev,
 273                                    struct iw_request_info *info,
 274                                    __u32 *mode, char *extra)
 275 {
 276         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 277         int type;
 278
 279         if (sdata->vif.type == IEEE80211_IF_TYPE_VLAN)
 280                 return -EOPNOTSUPP;
 281
 282         switch (*mode) {
 283         case IW_MODE_INFRA:
 284                 type = IEEE80211_IF_TYPE_STA;
 285                 break;
 286         case IW_MODE_ADHOC:
 287                 type = IEEE80211_IF_TYPE_IBSS;
 288                 break;
 289         case IW_MODE_REPEAT:
 290                 type = IEEE80211_IF_TYPE_WDS;
 291                 break;
 292         case IW_MODE_MONITOR:
 293                 type = IEEE80211_IF_TYPE_MNTR;
 294                 break;
 295         default:
 296                 return -EINVAL;
 297         }
 298
 299         if (type == sdata->vif.type)
 300                 return 0;
 301         if (netif_running(dev))
 302                 return -EBUSY;
 303
 304         ieee80211_if_reinit(dev);
 305         ieee80211_if_set_type(dev, type);
 306
 307         return 0;
 308 }
 309
 310
 311 static int ieee80211_ioctl_giwmode(struct net_device *dev,
 312                                    struct iw_request_info *info,
 313                                    __u32 *mode, char *extra)
 314 {
 315         struct ieee80211_sub_if_data *sdata;
 316
 317         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 318         switch (sdata->vif.type) {
 319         case IEEE80211_IF_TYPE_AP:
 320                 *mode = IW_MODE_MASTER;
 321                 break;
 322         case IEEE80211_IF_TYPE_STA:
 323                 *mode = IW_MODE_INFRA;
 324                 break;
 325         case IEEE80211_IF_TYPE_IBSS:
 326                 *mode = IW_MODE_ADHOC;
 327                 break;
 328         case IEEE80211_IF_TYPE_MNTR:
 329                 *mode = IW_MODE_MONITOR;
 330                 break;
 331         case IEEE80211_IF_TYPE_WDS:
 332                 *mode = IW_MODE_REPEAT;
 333                 break;
 334         case IEEE80211_IF_TYPE_VLAN:
 335                 *mode = IW_MODE_SECOND;         /* FIXME */
 336                 break;
 337         default:
 338                 *mode = IW_MODE_AUTO;
 339                 break;
 340         }
 341         return 0;
 342 }
 343
 344 int ieee80211_set_freq(struct net_device *dev, int freqMHz)
 345 {
 346         int ret = -EINVAL;
 347         struct ieee80211_channel *chan;
 348         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 349         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 350
 351         chan = ieee80211_get_channel(local->hw.wiphy, freqMHz);
 352
 353         if (chan && !(chan->flags & IEEE80211_CHAN_DISABLED)) {
 354                 if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS &&
 355                     chan->flags & IEEE80211_CHAN_NO_IBSS) {
 356                         printk(KERN_DEBUG "%s: IBSS not allowed on frequency "
 357                                 "%d MHz\n", dev->name, chan->center_freq);
 358                         return ret;
 359                 }
 360                 local->oper_channel = chan;
 361
 362                 if (local->sta_sw_scanning || local->sta_hw_scanning)
 363                         ret = 0;
 364                 else
 365                         ret = ieee80211_hw_config(local);
 366
 367                 rate_control_clear(local);
 368         }
 369
 370         return ret;
 371 }
 372
 373 static int ieee80211_ioctl_siwfreq(struct net_device *dev,
 374                                    struct iw_request_info *info,
 375                                    struct iw_freq *freq, char *extra)
 376 {
 377         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 378
 379         if (sdata->vif.type == IEEE80211_IF_TYPE_STA)
 380                 sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_CHANNEL_SEL;
 381
 382         /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
 383         if (freq->e == 0) {
 384                 if (freq->m < 0) {
 385                         if (sdata->vif.type == IEEE80211_IF_TYPE_STA)
 386                                 sdata->u.sta.flags |=
 387                                         IEEE80211_STA_AUTO_CHANNEL_SEL;
 388                         return 0;
 389                 } else
 390                         return ieee80211_set_freq(dev,
 391                                 ieee80211_channel_to_frequency(freq->m));
 392         } else {
 393                 int i, div = 1000000;
 394                 for (i = 0; i < freq->e; i++)
 395                         div /= 10;
 396                 if (div > 0)
 397                         return ieee80211_set_freq(dev, freq->m / div);
 398                 else
 399                         return -EINVAL;
 400         }
 401 }
 402
 403
 404 static int ieee80211_ioctl_giwfreq(struct net_device *dev,
 405                                    struct iw_request_info *info,
 406                                    struct iw_freq *freq, char *extra)
 407 {
 408         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 409
 410         freq->m = local->hw.conf.channel->center_freq;
 411         freq->e = 6;
 412
 413         return 0;
 414 }
 415
 416
 417 static int ieee80211_ioctl_siwessid(struct net_device *dev,
 418                                     struct iw_request_info *info,
 419                                     struct iw_point *data, char *ssid)
 420 {
 421         struct ieee80211_sub_if_data *sdata;
 422         size_t len = data->length;
 423
 424         /* iwconfig uses nul termination in SSID.. */
 425         if (len > 0 && ssid[len - 1] == '\0')
 426                 len--;
 427
 428         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 429         if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
 430             sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
 431                 int ret;
 432                 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) {
 433                         if (len > IEEE80211_MAX_SSID_LEN)
 434                                 return -EINVAL;
 435                         memcpy(sdata->u.sta.ssid, ssid, len);
 436                         sdata->u.sta.ssid_len = len;
 437                         return 0;
 438                 }
 439                 if (data->flags)
 440                         sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
 441                 else
 442                         sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL;
 443                 ret = ieee80211_sta_set_ssid(dev, ssid, len);
 444                 if (ret)
 445                         return ret;
 446                 ieee80211_sta_req_auth(dev, &sdata->u.sta);
 447                 return 0;
 448         }
 449
 450         if (sdata->vif.type == IEEE80211_IF_TYPE_AP) {
 451                 memcpy(sdata->u.ap.ssid, ssid, len);
 452                 memset(sdata->u.ap.ssid + len, 0,
 453                        IEEE80211_MAX_SSID_LEN - len);
 454                 sdata->u.ap.ssid_len = len;
 455                 return ieee80211_if_config(dev);
 456         }
 457         return -EOPNOTSUPP;
 458 }
 459
 460
 461 static int ieee80211_ioctl_giwessid(struct net_device *dev,
 462                                     struct iw_request_info *info,
 463                                     struct iw_point *data, char *ssid)
 464 {
 465         size_t len;
 466
 467         struct ieee80211_sub_if_data *sdata;
 468         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 469         if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
 470             sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
 471                 int res = ieee80211_sta_get_ssid(dev, ssid, &len);
 472                 if (res == 0) {
 473                         data->length = len;
 474                         data->flags = 1;
 475                 } else
 476                         data->flags = 0;
 477                 return res;
 478         }
 479
 480         if (sdata->vif.type == IEEE80211_IF_TYPE_AP) {
 481                 len = sdata->u.ap.ssid_len;
 482                 if (len > IW_ESSID_MAX_SIZE)
 483                         len = IW_ESSID_MAX_SIZE;
 484                 memcpy(ssid, sdata->u.ap.ssid, len);
 485                 data->length = len;
 486                 data->flags = 1;
 487                 return 0;
 488         }
 489         return -EOPNOTSUPP;
 490 }
 491
 492
 493 static int ieee80211_ioctl_siwap(struct net_device *dev,
 494                                  struct iw_request_info *info,
 495                                  struct sockaddr *ap_addr, char *extra)
 496 {
 497         struct ieee80211_sub_if_data *sdata;
 498
 499         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 500         if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
 501             sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
 502                 int ret;
 503                 if (sdata->flags & IEEE80211_SDATA_USERSPACE_MLME) {
 504                         memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data,
 505                                ETH_ALEN);
 506                         return 0;
 507                 }
 508                 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data))
 509                         sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL |
 510                                 IEEE80211_STA_AUTO_CHANNEL_SEL;
 511                 else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
 512                         sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL;
 513                 else
 514                         sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
 515                 ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data);
 516                 if (ret)
 517                         return ret;
 518                 ieee80211_sta_req_auth(dev, &sdata->u.sta);
 519                 return 0;
 520         } else if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) {
 521                 /*
 522                  * If it is necessary to update the WDS peer address
 523                  * while the interface is running, then we need to do
 524                  * more work here, namely if it is running we need to
 525                  * add a new and remove the old STA entry, this is
 526                  * normally handled by _open() and _stop().
 527                  */
 528                 if (netif_running(dev))
 529                         return -EBUSY;
 530
 531                 memcpy(&sdata->u.wds.remote_addr, (u8 *) &ap_addr->sa_data,
 532                        ETH_ALEN);
 533
 534                 return 0;
 535         }
 536
 537         return -EOPNOTSUPP;
 538 }
 539
 540
 541 static int ieee80211_ioctl_giwap(struct net_device *dev,
 542                                  struct iw_request_info *info,
 543                                  struct sockaddr *ap_addr, char *extra)
 544 {
 545         struct ieee80211_sub_if_data *sdata;
 546
 547         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 548         if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
 549             sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
 550                 if (sdata->u.sta.state == IEEE80211_ASSOCIATED ||
 551                     sdata->u.sta.state == IEEE80211_IBSS_JOINED) {
 552                         ap_addr->sa_family = ARPHRD_ETHER;
 553                         memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN);
 554                         return 0;
 555                 } else {
 556                         memset(&ap_addr->sa_data, 0, ETH_ALEN);
 557                         return 0;
 558                 }
 559         } else if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) {
 560                 ap_addr->sa_family = ARPHRD_ETHER;
 561                 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
 562                 return 0;
 563         }
 564
 565         return -EOPNOTSUPP;
 566 }
 567
 568
 569 static int ieee80211_ioctl_siwscan(struct net_device *dev,
 570                                    struct iw_request_info *info,
 571                                    union iwreq_data *wrqu, char *extra)
 572 {
 573         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 574         struct iw_scan_req *req = NULL;
 575         u8 *ssid = NULL;
 576         size_t ssid_len = 0;
 577
 578         if (!netif_running(dev))
 579                 return -ENETDOWN;
 580
 581         if (sdata->vif.type != IEEE80211_IF_TYPE_STA &&
 582             sdata->vif.type != IEEE80211_IF_TYPE_IBSS &&
 583             sdata->vif.type != IEEE80211_IF_TYPE_MESH_POINT &&
 584             sdata->vif.type != IEEE80211_IF_TYPE_AP)
 585                 return -EOPNOTSUPP;
 586
 587         /* if SSID was specified explicitly then use that */
 588         if (wrqu->data.length == sizeof(struct iw_scan_req) &&
 589             wrqu->data.flags & IW_SCAN_THIS_ESSID) {
 590                 req = (struct iw_scan_req *)extra;
 591                 ssid = req->essid;
 592                 ssid_len = req->essid_len;
 593         }
 594
 595         return ieee80211_sta_req_scan(dev, ssid, ssid_len);
 596 }
 597
 598
 599 static int ieee80211_ioctl_giwscan(struct net_device *dev,
 600                                    struct iw_request_info *info,
 601                                    struct iw_point *data, char *extra)
 602 {
 603         int res;
 604         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 605
 606         if (local->sta_sw_scanning || local->sta_hw_scanning)
 607                 return -EAGAIN;
 608
 609         res = ieee80211_sta_scan_results(dev, info, extra, data->length);
 610         if (res >= 0) {
 611                 data->length = res;
 612                 return 0;
 613         }
 614         data->length = 0;
 615         return res;
 616 }
 617
 618
 619 static int ieee80211_ioctl_siwrate(struct net_device *dev,
 620                                   struct iw_request_info *info,
 621                                   struct iw_param *rate, char *extra)
 622 {
 623         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 624         int i, err = -EINVAL;
 625         u32 target_rate = rate->value / 100000;
 626         struct ieee80211_sub_if_data *sdata;
 627         struct ieee80211_supported_band *sband;
 628
 629         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 630         if (!sdata->bss)
 631                 return -ENODEV;
 632
 633         sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 634
 635         /* target_rate = -1, rate->fixed = 0 means auto only, so use all rates
 636          * target_rate = X, rate->fixed = 1 means only rate X
 637          * target_rate = X, rate->fixed = 0 means all rates <= X */
 638         sdata->bss->max_ratectrl_rateidx = -1;
 639         sdata->bss->force_unicast_rateidx = -1;
 640         if (rate->value < 0)
 641                 return 0;
 642
 643         for (i=0; i< sband->n_bitrates; i++) {
 644                 struct ieee80211_rate *brate = &sband->bitrates[i];
 645                 int this_rate = brate->bitrate;
 646
 647                 if (target_rate == this_rate) {
 648                         sdata->bss->max_ratectrl_rateidx = i;
 649                         if (rate->fixed)
 650                                 sdata->bss->force_unicast_rateidx = i;
 651                         err = 0;
 652                         break;
 653                 }
 654         }
 655         return err;
 656 }
 657
 658 static int ieee80211_ioctl_giwrate(struct net_device *dev,
 659                                   struct iw_request_info *info,
 660                                   struct iw_param *rate, char *extra)
 661 {
 662         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 663         struct sta_info *sta;
 664         struct ieee80211_sub_if_data *sdata;
 665         struct ieee80211_supported_band *sband;
 666
 667         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 668
 669         if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
 670                 return -EOPNOTSUPP;
 671
 672         sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 673
 674         rcu_read_lock();
 675
 676         sta = sta_info_get(local, sdata->u.sta.bssid);
 677
 678         if (sta && sta->txrate_idx < sband->n_bitrates)
 679                 rate->value = sband->bitrates[sta->txrate_idx].bitrate;
 680         else
 681                 rate->value = 0;
 682
 683         rcu_read_unlock();
 684
 685         if (!sta)
 686                 return -ENODEV;
 687
 688         rate->value *= 100000;
 689
 690         return 0;
 691 }
 692
 693 static int ieee80211_ioctl_siwtxpower(struct net_device *dev,
 694                                       struct iw_request_info *info,
 695                                       union iwreq_data *data, char *extra)
 696 {
 697         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 698         bool need_reconfig = 0;
 699         int new_power_level;
 700
 701         if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
 702                 return -EINVAL;
 703         if (data->txpower.flags & IW_TXPOW_RANGE)
 704                 return -EINVAL;
 705
 706         if (data->txpower.fixed) {
 707                 new_power_level = data->txpower.value;
 708         } else {
 709                 /*
 710                  * Automatic power level. Use maximum power for the current
 711                  * channel. Should be part of rate control.
 712                  */
 713                 struct ieee80211_channel* chan = local->hw.conf.channel;
 714                 if (!chan)
 715                         return -EINVAL;
 716
 717                 new_power_level = chan->max_power;
 718         }
 719
 720         if (local->hw.conf.power_level != new_power_level) {
 721                 local->hw.conf.power_level = new_power_level;
 722                 need_reconfig = 1;
 723         }
 724
 725         if (local->hw.conf.radio_enabled != !(data->txpower.disabled)) {
 726                 local->hw.conf.radio_enabled = !(data->txpower.disabled);
 727                 need_reconfig = 1;
 728                 ieee80211_led_radio(local, local->hw.conf.radio_enabled);
 729         }
 730
 731         if (need_reconfig) {
 732                 ieee80211_hw_config(local);
 733                 /* The return value of hw_config is not of big interest here,
 734                  * as it doesn't say that it failed because of _this_ config
 735                  * change or something else. Ignore it. */
 736         }
 737
 738         return 0;
 739 }
 740
 741 static int ieee80211_ioctl_giwtxpower(struct net_device *dev,
 742                                    struct iw_request_info *info,
 743                                    union iwreq_data *data, char *extra)
 744 {
 745         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 746
 747         data->txpower.fixed = 1;
 748         data->txpower.disabled = !(local->hw.conf.radio_enabled);
 749         data->txpower.value = local->hw.conf.power_level;
 750         data->txpower.flags = IW_TXPOW_DBM;
 751
 752         return 0;
 753 }
 754
 755 static int ieee80211_ioctl_siwrts(struct net_device *dev,
 756                                   struct iw_request_info *info,
 757                                   struct iw_param *rts, char *extra)
 758 {
 759         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 760
 761         if (rts->disabled)
 762                 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
 763         else if (!rts->fixed)
 764                 /* if the rts value is not fixed, then take default */
 765                 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
 766         else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD)
 767                 return -EINVAL;
 768         else
 769                 local->rts_threshold = rts->value;
 770
 771         /* If the wlan card performs RTS/CTS in hardware/firmware,
 772          * configure it here */
 773
 774         if (local->ops->set_rts_threshold)
 775                 local->ops->set_rts_threshold(local_to_hw(local),
 776                                              local->rts_threshold);
 777
 778         return 0;
 779 }
 780
 781 static int ieee80211_ioctl_giwrts(struct net_device *dev,
 782                                   struct iw_request_info *info,
 783                                   struct iw_param *rts, char *extra)
 784 {
 785         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 786
 787         rts->value = local->rts_threshold;
 788         rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD);
 789         rts->fixed = 1;
 790
 791         return 0;
 792 }
 793
 794
 795 static int ieee80211_ioctl_siwfrag(struct net_device *dev,
 796                                    struct iw_request_info *info,
 797                                    struct iw_param *frag, char *extra)
 798 {
 799         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 800
 801         if (frag->disabled)
 802                 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
 803         else if (frag->value < 256 ||
 804                  frag->value > IEEE80211_MAX_FRAG_THRESHOLD)
 805                 return -EINVAL;
 806         else {
 807                 /* Fragment length must be even, so strip LSB. */
 808                 local->fragmentation_threshold = frag->value & ~0x1;
 809         }
 810
 811         /* If the wlan card performs fragmentation in hardware/firmware,
 812          * configure it here */
 813
 814         if (local->ops->set_frag_threshold)
 815                 local->ops->set_frag_threshold(
 816                         local_to_hw(local),
 817                         local->fragmentation_threshold);
 818
 819         return 0;
 820 }
 821
 822 static int ieee80211_ioctl_giwfrag(struct net_device *dev,
 823                                    struct iw_request_info *info,
 824                                    struct iw_param *frag, char *extra)
 825 {
 826         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 827
 828         frag->value = local->fragmentation_threshold;
 829         frag->disabled = (frag->value >= IEEE80211_MAX_RTS_THRESHOLD);
 830         frag->fixed = 1;
 831
 832         return 0;
 833 }
 834
 835
 836 static int ieee80211_ioctl_siwretry(struct net_device *dev,
 837                                     struct iw_request_info *info,
 838                                     struct iw_param *retry, char *extra)
 839 {
 840         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 841
 842         if (retry->disabled ||
 843             (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
 844                 return -EINVAL;
 845
 846         if (retry->flags & IW_RETRY_MAX)
 847                 local->long_retry_limit = retry->value;
 848         else if (retry->flags & IW_RETRY_MIN)
 849                 local->short_retry_limit = retry->value;
 850         else {
 851                 local->long_retry_limit = retry->value;
 852                 local->short_retry_limit = retry->value;
 853         }
 854
 855         if (local->ops->set_retry_limit) {
 856                 return local->ops->set_retry_limit(
 857                         local_to_hw(local),
 858                         local->short_retry_limit,
 859                         local->long_retry_limit);
 860         }
 861
 862         return 0;
 863 }
 864
 865
 866 static int ieee80211_ioctl_giwretry(struct net_device *dev,
 867                                     struct iw_request_info *info,
 868                                     struct iw_param *retry, char *extra)
 869 {
 870         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 871
 872         retry->disabled = 0;
 873         if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) {
 874                 /* first return min value, iwconfig will ask max value
 875                  * later if needed */
 876                 retry->flags |= IW_RETRY_LIMIT;
 877                 retry->value = local->short_retry_limit;
 878                 if (local->long_retry_limit != local->short_retry_limit)
 879                         retry->flags |= IW_RETRY_MIN;
 880                 return 0;
 881         }
 882         if (retry->flags & IW_RETRY_MAX) {
 883                 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
 884                 retry->value = local->long_retry_limit;
 885         }
 886
 887         return 0;
 888 }
 889
 890 static int ieee80211_ioctl_siwmlme(struct net_device *dev,
 891                                    struct iw_request_info *info,
 892                                    struct iw_point *data, char *extra)
 893 {
 894         struct ieee80211_sub_if_data *sdata;
 895         struct iw_mlme *mlme = (struct iw_mlme *) extra;
 896
 897         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 898         if (sdata->vif.type != IEEE80211_IF_TYPE_STA &&
 899             sdata->vif.type != IEEE80211_IF_TYPE_IBSS)
 900                 return -EINVAL;
 901
 902         switch (mlme->cmd) {
 903         case IW_MLME_DEAUTH:
 904                 /* TODO: mlme->addr.sa_data */
 905                 return ieee80211_sta_deauthenticate(dev, mlme->reason_code);
 906         case IW_MLME_DISASSOC:
 907                 /* TODO: mlme->addr.sa_data */
 908                 return ieee80211_sta_disassociate(dev, mlme->reason_code);
 909         default:
 910                 return -EOPNOTSUPP;
 911         }
 912 }
 913
 914
 915 static int ieee80211_ioctl_siwencode(struct net_device *dev,
 916                                      struct iw_request_info *info,
 917                                      struct iw_point *erq, char *keybuf)
 918 {
 919         struct ieee80211_sub_if_data *sdata;
 920         int idx, i, alg = ALG_WEP;
 921         u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 922         int remove = 0;
 923
 924         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 925
 926         idx = erq->flags & IW_ENCODE_INDEX;
 927         if (idx == 0) {
 928                 if (sdata->default_key)
 929                         for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
 930                                 if (sdata->default_key == sdata->keys[i]) {
 931                                         idx = i;
 932                                         break;
 933                                 }
 934                         }
 935         } else if (idx < 1 || idx > 4)
 936                 return -EINVAL;
 937         else
 938                 idx--;
 939
 940         if (erq->flags & IW_ENCODE_DISABLED)
 941                 remove = 1;
 942         else if (erq->length == 0) {
 943                 /* No key data - just set the default TX key index */
 944                 ieee80211_set_default_key(sdata, idx);
 945                 return 0;
 946         }
 947
 948         return ieee80211_set_encryption(
 949                 dev, bcaddr,
 950                 idx, alg, remove,
 951                 !sdata->default_key,
 952                 keybuf, erq->length);
 953 }
 954
 955
 956 static int ieee80211_ioctl_giwencode(struct net_device *dev,
 957                                      struct iw_request_info *info,
 958                                      struct iw_point *erq, char *key)
 959 {
 960         struct ieee80211_sub_if_data *sdata;
 961         int idx, i;
 962
 963         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 964
 965         idx = erq->flags & IW_ENCODE_INDEX;
 966         if (idx < 1 || idx > 4) {
 967                 idx = -1;
 968                 if (!sdata->default_key)
 969                         idx = 0;
 970                 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
 971                         if (sdata->default_key == sdata->keys[i]) {
 972                                 idx = i;
 973                                 break;
 974                         }
 975                 }
 976                 if (idx < 0)
 977                         return -EINVAL;
 978         } else
 979                 idx--;
 980
 981         erq->flags = idx + 1;
 982
 983         if (!sdata->keys[idx]) {
 984                 erq->length = 0;
 985                 erq->flags |= IW_ENCODE_DISABLED;
 986                 return 0;
 987         }
 988
 989         memcpy(key, sdata->keys[idx]->conf.key,
 990                min_t(int, erq->length, sdata->keys[idx]->conf.keylen));
 991         erq->length = sdata->keys[idx]->conf.keylen;
 992         erq->flags |= IW_ENCODE_ENABLED;
 993
 994         if (sdata->vif.type == IEEE80211_IF_TYPE_STA) {
 995                 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 996                 switch (ifsta->auth_alg) {
 997                 case WLAN_AUTH_OPEN:
 998                 case WLAN_AUTH_LEAP:
 999                         erq->flags |= IW_ENCODE_OPEN;
1000                         break;
1001                 case WLAN_AUTH_SHARED_KEY:
1002                         erq->flags |= IW_ENCODE_RESTRICTED;
1003                         break;
1004                 }
1005         }
1006
1007         return 0;
1008 }
1009
1010 static int ieee80211_ioctl_siwauth(struct net_device *dev,
1011                                    struct iw_request_info *info,
1012                                    struct iw_param *data, char *extra)
1013 {
1014         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1015         int ret = 0;
1016
1017         switch (data->flags & IW_AUTH_INDEX) {
1018         case IW_AUTH_WPA_VERSION:
1019         case IW_AUTH_CIPHER_PAIRWISE:
1020         case IW_AUTH_CIPHER_GROUP:
1021         case IW_AUTH_WPA_ENABLED:
1022         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1023         case IW_AUTH_KEY_MGMT:
1024                 break;
1025         case IW_AUTH_DROP_UNENCRYPTED:
1026                 sdata->drop_unencrypted = !!data->value;
1027                 break;
1028         case IW_AUTH_PRIVACY_INVOKED:
1029                 if (sdata->vif.type != IEEE80211_IF_TYPE_STA)
1030                         ret = -EINVAL;
1031                 else {
1032                         sdata->u.sta.flags &= ~IEEE80211_STA_PRIVACY_INVOKED;
1033                         /*
1034                          * Privacy invoked by wpa_supplicant, store the
1035                          * value and allow associating to a protected
1036                          * network without having a key up front.
1037                          */
1038                         if (data->value)
1039                                 sdata->u.sta.flags |=
1040                                         IEEE80211_STA_PRIVACY_INVOKED;
1041                 }
1042                 break;
1043         case IW_AUTH_80211_AUTH_ALG:
1044                 if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
1045                     sdata->vif.type == IEEE80211_IF_TYPE_IBSS)
1046                         sdata->u.sta.auth_algs = data->value;
1047                 else
1048                         ret = -EOPNOTSUPP;
1049                 break;
1050         default:
1051                 ret = -EOPNOTSUPP;
1052                 break;
1053         }
1054         return ret;
1055 }
1056
1057 /* Get wireless statistics.  Called by /proc/net/wireless and by SIOCGIWSTATS */
1058 static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev)
1059 {
1060         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1061         struct iw_statistics *wstats = &local->wstats;
1062         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1063         struct sta_info *sta = NULL;
1064
1065         rcu_read_lock();
1066
1067         if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
1068             sdata->vif.type == IEEE80211_IF_TYPE_IBSS)
1069                 sta = sta_info_get(local, sdata->u.sta.bssid);
1070         if (!sta) {
1071                 wstats->discard.fragment = 0;
1072                 wstats->discard.misc = 0;
1073                 wstats->qual.qual = 0;
1074                 wstats->qual.level = 0;
1075                 wstats->qual.noise = 0;
1076                 wstats->qual.updated = IW_QUAL_ALL_INVALID;
1077         } else {
1078                 wstats->qual.level = sta->last_signal;
1079                 wstats->qual.qual = sta->last_qual;
1080                 wstats->qual.noise = sta->last_noise;
1081                 wstats->qual.updated = local->wstats_flags;
1082         }
1083
1084         rcu_read_unlock();
1085
1086         return wstats;
1087 }
1088
1089 static int ieee80211_ioctl_giwauth(struct net_device *dev,
1090                                    struct iw_request_info *info,
1091                                    struct iw_param *data, char *extra)
1092 {
1093         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1094         int ret = 0;
1095
1096         switch (data->flags & IW_AUTH_INDEX) {
1097         case IW_AUTH_80211_AUTH_ALG:
1098                 if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
1099                     sdata->vif.type == IEEE80211_IF_TYPE_IBSS)
1100                         data->value = sdata->u.sta.auth_algs;
1101                 else
1102                         ret = -EOPNOTSUPP;
1103                 break;
1104         default:
1105                 ret = -EOPNOTSUPP;
1106                 break;
1107         }
1108         return ret;
1109 }
1110
1111
1112 static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
1113                                         struct iw_request_info *info,
1114                                         struct iw_point *erq, char *extra)
1115 {
1116         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1117         struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
1118         int uninitialized_var(alg), idx, i, remove = 0;
1119
1120         switch (ext->alg) {
1121         case IW_ENCODE_ALG_NONE:
1122                 remove = 1;
1123                 break;
1124         case IW_ENCODE_ALG_WEP:
1125                 alg = ALG_WEP;
1126                 break;
1127         case IW_ENCODE_ALG_TKIP:
1128                 alg = ALG_TKIP;
1129                 break;
1130         case IW_ENCODE_ALG_CCMP:
1131                 alg = ALG_CCMP;
1132                 break;
1133         default:
1134                 return -EOPNOTSUPP;
1135         }
1136
1137         if (erq->flags & IW_ENCODE_DISABLED)
1138                 remove = 1;
1139
1140         idx = erq->flags & IW_ENCODE_INDEX;
1141         if (idx < 1 || idx > 4) {
1142                 idx = -1;
1143                 if (!sdata->default_key)
1144                         idx = 0;
1145                 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1146                         if (sdata->default_key == sdata->keys[i]) {
1147                                 idx = i;
1148                                 break;
1149                         }
1150                 }
1151                 if (idx < 0)
1152                         return -EINVAL;
1153         } else
1154                 idx--;
1155
1156         return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg,
1157                                         remove,
1158                                         ext->ext_flags &
1159                                         IW_ENCODE_EXT_SET_TX_KEY,
1160                                         ext->key, ext->key_len);
1161 }
1162
1163
1164 /* Structures to export the Wireless Handlers */
1165
1166 static const iw_handler ieee80211_handler[] =
1167 {
1168         (iw_handler) NULL,                              /* SIOCSIWCOMMIT */
1169         (iw_handler) ieee80211_ioctl_giwname,           /* SIOCGIWNAME */
1170         (iw_handler) NULL,                              /* SIOCSIWNWID */
1171         (iw_handler) NULL,                              /* SIOCGIWNWID */
1172         (iw_handler) ieee80211_ioctl_siwfreq,           /* SIOCSIWFREQ */
1173         (iw_handler) ieee80211_ioctl_giwfreq,           /* SIOCGIWFREQ */
1174         (iw_handler) ieee80211_ioctl_siwmode,           /* SIOCSIWMODE */
1175         (iw_handler) ieee80211_ioctl_giwmode,           /* SIOCGIWMODE */
1176         (iw_handler) NULL,                              /* SIOCSIWSENS */
1177         (iw_handler) NULL,                              /* SIOCGIWSENS */
1178         (iw_handler) NULL /* not used */,               /* SIOCSIWRANGE */
1179         (iw_handler) ieee80211_ioctl_giwrange,          /* SIOCGIWRANGE */
1180         (iw_handler) NULL /* not used */,               /* SIOCSIWPRIV */
1181         (iw_handler) NULL /* kernel code */,            /* SIOCGIWPRIV */
1182         (iw_handler) NULL /* not used */,               /* SIOCSIWSTATS */
1183         (iw_handler) NULL /* kernel code */,            /* SIOCGIWSTATS */
1184         (iw_handler) NULL,                              /* SIOCSIWSPY */
1185         (iw_handler) NULL,                              /* SIOCGIWSPY */
1186         (iw_handler) NULL,                              /* SIOCSIWTHRSPY */
1187         (iw_handler) NULL,                              /* SIOCGIWTHRSPY */
1188         (iw_handler) ieee80211_ioctl_siwap,             /* SIOCSIWAP */
1189         (iw_handler) ieee80211_ioctl_giwap,             /* SIOCGIWAP */
1190         (iw_handler) ieee80211_ioctl_siwmlme,           /* SIOCSIWMLME */
1191         (iw_handler) NULL,                              /* SIOCGIWAPLIST */
1192         (iw_handler) ieee80211_ioctl_siwscan,           /* SIOCSIWSCAN */
1193         (iw_handler) ieee80211_ioctl_giwscan,           /* SIOCGIWSCAN */
1194         (iw_handler) ieee80211_ioctl_siwessid,          /* SIOCSIWESSID */
1195         (iw_handler) ieee80211_ioctl_giwessid,          /* SIOCGIWESSID */
1196         (iw_handler) NULL,                              /* SIOCSIWNICKN */
1197         (iw_handler) NULL,                              /* SIOCGIWNICKN */
1198         (iw_handler) NULL,                              /* -- hole -- */
1199         (iw_handler) NULL,                              /* -- hole -- */
1200         (iw_handler) ieee80211_ioctl_siwrate,           /* SIOCSIWRATE */
1201         (iw_handler) ieee80211_ioctl_giwrate,           /* SIOCGIWRATE */
1202         (iw_handler) ieee80211_ioctl_siwrts,            /* SIOCSIWRTS */
1203         (iw_handler) ieee80211_ioctl_giwrts,            /* SIOCGIWRTS */
1204         (iw_handler) ieee80211_ioctl_siwfrag,           /* SIOCSIWFRAG */
1205         (iw_handler) ieee80211_ioctl_giwfrag,           /* SIOCGIWFRAG */
1206         (iw_handler) ieee80211_ioctl_siwtxpower,        /* SIOCSIWTXPOW */
1207         (iw_handler) ieee80211_ioctl_giwtxpower,        /* SIOCGIWTXPOW */
1208         (iw_handler) ieee80211_ioctl_siwretry,          /* SIOCSIWRETRY */
1209         (iw_handler) ieee80211_ioctl_giwretry,          /* SIOCGIWRETRY */
1210         (iw_handler) ieee80211_ioctl_siwencode,         /* SIOCSIWENCODE */
1211         (iw_handler) ieee80211_ioctl_giwencode,         /* SIOCGIWENCODE */
1212         (iw_handler) NULL,                              /* SIOCSIWPOWER */
1213         (iw_handler) NULL,                              /* SIOCGIWPOWER */
1214         (iw_handler) NULL,                              /* -- hole -- */
1215         (iw_handler) NULL,                              /* -- hole -- */
1216         (iw_handler) ieee80211_ioctl_siwgenie,          /* SIOCSIWGENIE */
1217         (iw_handler) NULL,                              /* SIOCGIWGENIE */
1218         (iw_handler) ieee80211_ioctl_siwauth,           /* SIOCSIWAUTH */
1219         (iw_handler) ieee80211_ioctl_giwauth,           /* SIOCGIWAUTH */
1220         (iw_handler) ieee80211_ioctl_siwencodeext,      /* SIOCSIWENCODEEXT */
1221         (iw_handler) NULL,                              /* SIOCGIWENCODEEXT */
1222         (iw_handler) NULL,                              /* SIOCSIWPMKSA */
1223         (iw_handler) NULL,                              /* -- hole -- */
1224 };
1225
1226 const struct iw_handler_def ieee80211_iw_handler_def =
1227 {
1228         .num_standard   = ARRAY_SIZE(ieee80211_handler),
1229         .standard       = (iw_handler *) ieee80211_handler,
1230         .get_wireless_stats = ieee80211_get_wireless_stats,
1231 };