net/ieee80211/ieee80211_wx.c

   1 /******************************************************************************
   2
   3   Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
   4
   5   Portions of this file are based on the WEP enablement code provided by the
   6   Host AP project hostap-drivers v0.1.3
   7   Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
   8   <jkmaline@cc.hut.fi>
   9   Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
  10
  11   This program is free software; you can redistribute it and/or modify it
  12   under the terms of version 2 of the GNU General Public License as
  13   published by the Free Software Foundation.
  14
  15   This program is distributed in the hope that it will be useful, but WITHOUT
  16   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18   more details.
  19
  20   You should have received a copy of the GNU General Public License along with
  21   this program; if not, write to the Free Software Foundation, Inc., 59
  22   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23
  24   The full GNU General Public License is included in this distribution in the
  25   file called LICENSE.
  26
  27   Contact Information:
  28   James P. Ketrenos <ipw2100-admin@linux.intel.com>
  29   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30
  31 ******************************************************************************/
  32
  33 #include <linux/kmod.h>
  34 #include <linux/module.h>
  35 #include <linux/jiffies.h>
  36
  37 #include <net/ieee80211.h>
  38 #include <linux/wireless.h>
  39
  40 static const char *ieee80211_modes[] = {
  41         "?", "a", "b", "ab", "g", "ag", "bg", "abg"
  42 };
  43
  44 #define MAX_CUSTOM_LEN 64
  45 static char *ipw2100_translate_scan(struct ieee80211_device *ieee,
  46                                            char *start, char *stop,
  47                                            struct ieee80211_network *network)
  48 {
  49         char custom[MAX_CUSTOM_LEN];
  50         char *p;
  51         struct iw_event iwe;
  52         int i, j;
  53         u8 max_rate, rate;
  54
  55         /* First entry *MUST* be the AP MAC address */
  56         iwe.cmd = SIOCGIWAP;
  57         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
  58         memcpy(iwe.u.ap_addr.sa_data, network->bssid, ETH_ALEN);
  59         start = iwe_stream_add_event(start, stop, &iwe, IW_EV_ADDR_LEN);
  60
  61         /* Remaining entries will be displayed in the order we provide them */
  62
  63         /* Add the ESSID */
  64         iwe.cmd = SIOCGIWESSID;
  65         iwe.u.data.flags = 1;
  66         if (network->flags & NETWORK_EMPTY_ESSID) {
  67                 iwe.u.data.length = sizeof("<hidden>");
  68                 start = iwe_stream_add_point(start, stop, &iwe, "<hidden>");
  69         } else {
  70                 iwe.u.data.length = min(network->ssid_len, (u8) 32);
  71                 start = iwe_stream_add_point(start, stop, &iwe, network->ssid);
  72         }
  73
  74         /* Add the protocol name */
  75         iwe.cmd = SIOCGIWNAME;
  76         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11%s",
  77                  ieee80211_modes[network->mode]);
  78         start = iwe_stream_add_event(start, stop, &iwe, IW_EV_CHAR_LEN);
  79
  80         /* Add mode */
  81         iwe.cmd = SIOCGIWMODE;
  82         if (network->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
  83                 if (network->capability & WLAN_CAPABILITY_ESS)
  84                         iwe.u.mode = IW_MODE_MASTER;
  85                 else
  86                         iwe.u.mode = IW_MODE_ADHOC;
  87
  88                 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_UINT_LEN);
  89         }
  90
  91         /* Add frequency/channel */
  92         iwe.cmd = SIOCGIWFREQ;
  93 /*      iwe.u.freq.m = ieee80211_frequency(network->channel, network->mode);
  94         iwe.u.freq.e = 3; */
  95         iwe.u.freq.m = network->channel;
  96         iwe.u.freq.e = 0;
  97         iwe.u.freq.i = 0;
  98         start = iwe_stream_add_event(start, stop, &iwe, IW_EV_FREQ_LEN);
  99
 100         /* Add encryption capability */
 101         iwe.cmd = SIOCGIWENCODE;
 102         if (network->capability & WLAN_CAPABILITY_PRIVACY)
 103                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 104         else
 105                 iwe.u.data.flags = IW_ENCODE_DISABLED;
 106         iwe.u.data.length = 0;
 107         start = iwe_stream_add_point(start, stop, &iwe, network->ssid);
 108
 109         /* Add basic and extended rates */
 110         max_rate = 0;
 111         p = custom;
 112         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
 113         for (i = 0, j = 0; i < network->rates_len;) {
 114                 if (j < network->rates_ex_len &&
 115                     ((network->rates_ex[j] & 0x7F) <
 116                      (network->rates[i] & 0x7F)))
 117                         rate = network->rates_ex[j++] & 0x7F;
 118                 else
 119                         rate = network->rates[i++] & 0x7F;
 120                 if (rate > max_rate)
 121                         max_rate = rate;
 122                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
 123                               "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
 124         }
 125         for (; j < network->rates_ex_len; j++) {
 126                 rate = network->rates_ex[j] & 0x7F;
 127                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
 128                               "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
 129                 if (rate > max_rate)
 130                         max_rate = rate;
 131         }
 132
 133         iwe.cmd = SIOCGIWRATE;
 134         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
 135         iwe.u.bitrate.value = max_rate * 500000;
 136         start = iwe_stream_add_event(start, stop, &iwe, IW_EV_PARAM_LEN);
 137
 138         iwe.cmd = IWEVCUSTOM;
 139         iwe.u.data.length = p - custom;
 140         if (iwe.u.data.length)
 141                 start = iwe_stream_add_point(start, stop, &iwe, custom);
 142
 143         /* Add quality statistics */
 144         iwe.cmd = IWEVQUAL;
 145         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
 146             IW_QUAL_NOISE_UPDATED;
 147
 148         if (!(network->stats.mask & IEEE80211_STATMASK_RSSI)) {
 149                 iwe.u.qual.updated |= IW_QUAL_QUAL_INVALID |
 150                     IW_QUAL_LEVEL_INVALID;
 151                 iwe.u.qual.qual = 0;
 152                 iwe.u.qual.level = 0;
 153         } else {
 154                 iwe.u.qual.level = network->stats.rssi;
 155                 if (ieee->perfect_rssi == ieee->worst_rssi)
 156                         iwe.u.qual.qual = 100;
 157                 else
 158                         iwe.u.qual.qual =
 159                             (100 *
 160                              (ieee->perfect_rssi - ieee->worst_rssi) *
 161                              (ieee->perfect_rssi - ieee->worst_rssi) -
 162                              (ieee->perfect_rssi - network->stats.rssi) *
 163                              (15 * (ieee->perfect_rssi - ieee->worst_rssi) +
 164                               62 * (ieee->perfect_rssi -
 165                                     network->stats.rssi))) /
 166                             ((ieee->perfect_rssi -
 167                               ieee->worst_rssi) * (ieee->perfect_rssi -
 168                                                    ieee->worst_rssi));
 169                 if (iwe.u.qual.qual > 100)
 170                         iwe.u.qual.qual = 100;
 171                 else if (iwe.u.qual.qual < 1)
 172                         iwe.u.qual.qual = 0;
 173         }
 174
 175         if (!(network->stats.mask & IEEE80211_STATMASK_NOISE)) {
 176                 iwe.u.qual.updated |= IW_QUAL_NOISE_INVALID;
 177                 iwe.u.qual.noise = 0;
 178         } else {
 179                 iwe.u.qual.noise = network->stats.noise;
 180         }
 181
 182         start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
 183
 184         iwe.cmd = IWEVCUSTOM;
 185         p = custom;
 186
 187         iwe.u.data.length = p - custom;
 188         if (iwe.u.data.length)
 189                 start = iwe_stream_add_point(start, stop, &iwe, custom);
 190
 191         if (network->wpa_ie_len) {
 192                 char buf[MAX_WPA_IE_LEN * 2 + 30];
 193
 194                 u8 *p = buf;
 195                 p += sprintf(p, "wpa_ie=");
 196                 for (i = 0; i < network->wpa_ie_len; i++) {
 197                         p += sprintf(p, "%02x", network->wpa_ie[i]);
 198                 }
 199
 200                 memset(&iwe, 0, sizeof(iwe));
 201                 iwe.cmd = IWEVCUSTOM;
 202                 iwe.u.data.length = strlen(buf);
 203                 start = iwe_stream_add_point(start, stop, &iwe, buf);
 204         }
 205
 206         if (network->rsn_ie_len) {
 207                 char buf[MAX_WPA_IE_LEN * 2 + 30];
 208
 209                 u8 *p = buf;
 210                 p += sprintf(p, "rsn_ie=");
 211                 for (i = 0; i < network->rsn_ie_len; i++) {
 212                         p += sprintf(p, "%02x", network->rsn_ie[i]);
 213                 }
 214
 215                 memset(&iwe, 0, sizeof(iwe));
 216                 iwe.cmd = IWEVCUSTOM;
 217                 iwe.u.data.length = strlen(buf);
 218                 start = iwe_stream_add_point(start, stop, &iwe, buf);
 219         }
 220
 221         /* Add EXTRA: Age to display seconds since last beacon/probe response
 222          * for given network. */
 223         iwe.cmd = IWEVCUSTOM;
 224         p = custom;
 225         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
 226                       " Last beacon: %dms ago",
 227                       jiffies_to_msecs(jiffies - network->last_scanned));
 228         iwe.u.data.length = p - custom;
 229         if (iwe.u.data.length)
 230                 start = iwe_stream_add_point(start, stop, &iwe, custom);
 231
 232         return start;
 233 }
 234
 235 #define SCAN_ITEM_SIZE 128
 236
 237 int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
 238                           struct iw_request_info *info,
 239                           union iwreq_data *wrqu, char *extra)
 240 {
 241         struct ieee80211_network *network;
 242         unsigned long flags;
 243         int err = 0;
 244
 245         char *ev = extra;
 246         char *stop = ev + wrqu->data.length;
 247         int i = 0;
 248
 249         IEEE80211_DEBUG_WX("Getting scan\n");
 250
 251         spin_lock_irqsave(&ieee->lock, flags);
 252
 253         list_for_each_entry(network, &ieee->network_list, list) {
 254                 i++;
 255                 if (stop - ev < SCAN_ITEM_SIZE) {
 256                         err = -E2BIG;
 257                         break;
 258                 }
 259
 260                 if (ieee->scan_age == 0 ||
 261                     time_after(network->last_scanned + ieee->scan_age, jiffies))
 262                         ev = ipw2100_translate_scan(ieee, ev, stop, network);
 263                 else
 264                         IEEE80211_DEBUG_SCAN("Not showing network '%s ("
 265                                              MAC_FMT ")' due to age (%dms).\n",
 266                                              escape_essid(network->ssid,
 267                                                           network->ssid_len),
 268                                              MAC_ARG(network->bssid),
 269                                              jiffies_to_msecs(jiffies -
 270                                                               network->
 271                                                               last_scanned));
 272         }
 273
 274         spin_unlock_irqrestore(&ieee->lock, flags);
 275
 276         wrqu->data.length = ev - extra;
 277         wrqu->data.flags = 0;
 278
 279         IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i);
 280
 281         return err;
 282 }
 283
 284 int ieee80211_wx_set_encode(struct ieee80211_device *ieee,
 285                             struct iw_request_info *info,
 286                             union iwreq_data *wrqu, char *keybuf)
 287 {
 288         struct iw_point *erq = &(wrqu->encoding);
 289         struct net_device *dev = ieee->dev;
 290         struct ieee80211_security sec = {
 291                 .flags = 0
 292         };
 293         int i, key, key_provided, len;
 294         struct ieee80211_crypt_data **crypt;
 295         int host_crypto = ieee->host_encrypt || ieee->host_decrypt || ieee->host_build_iv;
 296
 297         IEEE80211_DEBUG_WX("SET_ENCODE\n");
 298
 299         key = erq->flags & IW_ENCODE_INDEX;
 300         if (key) {
 301                 if (key > WEP_KEYS)
 302                         return -EINVAL;
 303                 key--;
 304                 key_provided = 1;
 305         } else {
 306                 key_provided = 0;
 307                 key = ieee->tx_keyidx;
 308         }
 309
 310         IEEE80211_DEBUG_WX("Key: %d [%s]\n", key, key_provided ?
 311                            "provided" : "default");
 312
 313         crypt = &ieee->crypt[key];
 314
 315         if (erq->flags & IW_ENCODE_DISABLED) {
 316                 if (key_provided && *crypt) {
 317                         IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n",
 318                                            key);
 319                         ieee80211_crypt_delayed_deinit(ieee, crypt);
 320                 } else
 321                         IEEE80211_DEBUG_WX("Disabling encryption.\n");
 322
 323                 /* Check all the keys to see if any are still configured,
 324                  * and if no key index was provided, de-init them all */
 325                 for (i = 0; i < WEP_KEYS; i++) {
 326                         if (ieee->crypt[i] != NULL) {
 327                                 if (key_provided)
 328                                         break;
 329                                 ieee80211_crypt_delayed_deinit(ieee,
 330                                                                &ieee->crypt[i]);
 331                         }
 332                 }
 333
 334                 if (i == WEP_KEYS) {
 335                         sec.enabled = 0;
 336                         sec.encrypt = 0;
 337                         sec.level = SEC_LEVEL_0;
 338                         sec.flags |= SEC_ENABLED | SEC_LEVEL | SEC_ENCRYPT;
 339                 }
 340
 341                 goto done;
 342         }
 343
 344         sec.enabled = 1;
 345         sec.encrypt = 1;
 346         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
 347
 348         if (*crypt != NULL && (*crypt)->ops != NULL &&
 349             strcmp((*crypt)->ops->name, "WEP") != 0) {
 350                 /* changing to use WEP; deinit previously used algorithm
 351                  * on this key */
 352                 ieee80211_crypt_delayed_deinit(ieee, crypt);
 353         }
 354
 355         if (*crypt == NULL && host_crypto) {
 356                 struct ieee80211_crypt_data *new_crypt;
 357
 358                 /* take WEP into use */
 359                 new_crypt = kmalloc(sizeof(struct ieee80211_crypt_data),
 360                                     GFP_KERNEL);
 361                 if (new_crypt == NULL)
 362                         return -ENOMEM;
 363                 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
 364                 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
 365                 if (!new_crypt->ops) {
 366                         request_module("ieee80211_crypt_wep");
 367                         new_crypt->ops = ieee80211_get_crypto_ops("WEP");
 368                 }
 369
 370                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
 371                         new_crypt->priv = new_crypt->ops->init(key);
 372
 373                 if (!new_crypt->ops || !new_crypt->priv) {
 374                         kfree(new_crypt);
 375                         new_crypt = NULL;
 376
 377                         printk(KERN_WARNING "%s: could not initialize WEP: "
 378                                "load module ieee80211_crypt_wep\n", dev->name);
 379                         return -EOPNOTSUPP;
 380                 }
 381                 *crypt = new_crypt;
 382         }
 383
 384         /* If a new key was provided, set it up */
 385         if (erq->length > 0) {
 386                 len = erq->length <= 5 ? 5 : 13;
 387                 memcpy(sec.keys[key], keybuf, erq->length);
 388                 if (len > erq->length)
 389                         memset(sec.keys[key] + erq->length, 0,
 390                                len - erq->length);
 391                 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
 392                                    key, escape_essid(sec.keys[key], len),
 393                                    erq->length, len);
 394                 sec.key_sizes[key] = len;
 395                 if (*crypt)
 396                         (*crypt)->ops->set_key(sec.keys[key], len, NULL,
 397                                                (*crypt)->priv);
 398                 sec.flags |= (1 << key);
 399                 /* This ensures a key will be activated if no key is
 400                  * explicitely set */
 401                 if (key == sec.active_key)
 402                         sec.flags |= SEC_ACTIVE_KEY;
 403
 404         } else {
 405                 if (host_crypto) {
 406                         len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
 407                                                      NULL, (*crypt)->priv);
 408                         if (len == 0) {
 409                                 /* Set a default key of all 0 */
 410                                 IEEE80211_DEBUG_WX("Setting key %d to all "
 411                                                    "zero.\n", key);
 412                                 memset(sec.keys[key], 0, 13);
 413                                 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
 414                                                        (*crypt)->priv);
 415                                 sec.key_sizes[key] = 13;
 416                                 sec.flags |= (1 << key);
 417                         }
 418                 }
 419                 /* No key data - just set the default TX key index */
 420                 if (key_provided) {
 421                         IEEE80211_DEBUG_WX("Setting key %d to default Tx "
 422                                            "key.\n", key);
 423                         ieee->tx_keyidx = key;
 424                         sec.active_key = key;
 425                         sec.flags |= SEC_ACTIVE_KEY;
 426                 }
 427         }
 428         if (erq->flags & (IW_ENCODE_OPEN | IW_ENCODE_RESTRICTED)) {
 429                 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
 430                 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN :
 431                     WLAN_AUTH_SHARED_KEY;
 432                 sec.flags |= SEC_AUTH_MODE;
 433                 IEEE80211_DEBUG_WX("Auth: %s\n",
 434                                    sec.auth_mode == WLAN_AUTH_OPEN ?
 435                                    "OPEN" : "SHARED KEY");
 436         }
 437
 438         /* For now we just support WEP, so only set that security level...
 439          * TODO: When WPA is added this is one place that needs to change */
 440         sec.flags |= SEC_LEVEL;
 441         sec.level = SEC_LEVEL_1;        /* 40 and 104 bit WEP */
 442         sec.encode_alg[key] = SEC_ALG_WEP;
 443
 444       done:
 445         if (ieee->set_security)
 446                 ieee->set_security(dev, &sec);
 447
 448         /* Do not reset port if card is in Managed mode since resetting will
 449          * generate new IEEE 802.11 authentication which may end up in looping
 450          * with IEEE 802.1X.  If your hardware requires a reset after WEP
 451          * configuration (for example... Prism2), implement the reset_port in
 452          * the callbacks structures used to initialize the 802.11 stack. */
 453         if (ieee->reset_on_keychange &&
 454             ieee->iw_mode != IW_MODE_INFRA &&
 455             ieee->reset_port && ieee->reset_port(dev)) {
 456                 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
 457                 return -EINVAL;
 458         }
 459         return 0;
 460 }
 461
 462 int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
 463                             struct iw_request_info *info,
 464                             union iwreq_data *wrqu, char *keybuf)
 465 {
 466         struct iw_point *erq = &(wrqu->encoding);
 467         int len, key;
 468         struct ieee80211_crypt_data *crypt;
 469         struct ieee80211_security *sec = &ieee->sec;
 470
 471         IEEE80211_DEBUG_WX("GET_ENCODE\n");
 472
 473         key = erq->flags & IW_ENCODE_INDEX;
 474         if (key) {
 475                 if (key > WEP_KEYS)
 476                         return -EINVAL;
 477                 key--;
 478         } else
 479                 key = ieee->tx_keyidx;
 480
 481         crypt = ieee->crypt[key];
 482         erq->flags = key + 1;
 483
 484         if (!sec->enabled) {
 485                 erq->length = 0;
 486                 erq->flags |= IW_ENCODE_DISABLED;
 487                 return 0;
 488         }
 489
 490         len = sec->key_sizes[key];
 491         memcpy(keybuf, sec->keys[key], len);
 492
 493         erq->length = (len >= 0 ? len : 0);
 494         erq->flags |= IW_ENCODE_ENABLED;
 495
 496         if (ieee->open_wep)
 497                 erq->flags |= IW_ENCODE_OPEN;
 498         else
 499                 erq->flags |= IW_ENCODE_RESTRICTED;
 500
 501         return 0;
 502 }
 503
 504 int ieee80211_wx_set_encodeext(struct ieee80211_device *ieee,
 505                                struct iw_request_info *info,
 506                                union iwreq_data *wrqu, char *extra)
 507 {
 508         struct net_device *dev = ieee->dev;
 509         struct iw_point *encoding = &wrqu->encoding;
 510         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
 511         int i, idx, ret = 0;
 512         int group_key = 0;
 513         const char *alg, *module;
 514         struct ieee80211_crypto_ops *ops;
 515         struct ieee80211_crypt_data **crypt;
 516
 517         struct ieee80211_security sec = {
 518                 .flags = 0,
 519         };
 520
 521         idx = encoding->flags & IW_ENCODE_INDEX;
 522         if (idx) {
 523                 if (idx < 1 || idx > WEP_KEYS)
 524                         return -EINVAL;
 525                 idx--;
 526         } else
 527                 idx = ieee->tx_keyidx;
 528
 529         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
 530                 crypt = &ieee->crypt[idx];
 531                 group_key = 1;
 532         } else {
 533                 /* some Cisco APs use idx>0 for unicast in dynamic WEP */
 534                 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
 535                         return -EINVAL;
 536                 if (ieee->iw_mode == IW_MODE_INFRA)
 537                         crypt = &ieee->crypt[idx];
 538                 else
 539                         return -EINVAL;
 540         }
 541
 542         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
 543         if ((encoding->flags & IW_ENCODE_DISABLED) ||
 544             ext->alg == IW_ENCODE_ALG_NONE) {
 545                 if (*crypt)
 546                         ieee80211_crypt_delayed_deinit(ieee, crypt);
 547
 548                 for (i = 0; i < WEP_KEYS; i++)
 549                         if (ieee->crypt[i] != NULL)
 550                                 break;
 551
 552                 if (i == WEP_KEYS) {
 553                         sec.enabled = 0;
 554                         sec.encrypt = 0;
 555                         sec.level = SEC_LEVEL_0;
 556                         sec.flags |= SEC_LEVEL;
 557                 }
 558                 goto done;
 559         }
 560
 561         sec.enabled = 1;
 562         sec.encrypt = 1;
 563
 564         if (group_key ? !ieee->host_mc_decrypt :
 565             !(ieee->host_encrypt || ieee->host_decrypt ||
 566               ieee->host_encrypt_msdu))
 567                 goto skip_host_crypt;
 568
 569         switch (ext->alg) {
 570         case IW_ENCODE_ALG_WEP:
 571                 alg = "WEP";
 572                 module = "ieee80211_crypt_wep";
 573                 break;
 574         case IW_ENCODE_ALG_TKIP:
 575                 alg = "TKIP";
 576                 module = "ieee80211_crypt_tkip";
 577                 break;
 578         case IW_ENCODE_ALG_CCMP:
 579                 alg = "CCMP";
 580                 module = "ieee80211_crypt_ccmp";
 581                 break;
 582         default:
 583                 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
 584                                    dev->name, ext->alg);
 585                 ret = -EINVAL;
 586                 goto done;
 587         }
 588
 589         ops = ieee80211_get_crypto_ops(alg);
 590         if (ops == NULL) {
 591                 request_module(module);
 592                 ops = ieee80211_get_crypto_ops(alg);
 593         }
 594         if (ops == NULL) {
 595                 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
 596                                    dev->name, ext->alg);
 597                 ret = -EINVAL;
 598                 goto done;
 599         }
 600
 601         if (*crypt == NULL || (*crypt)->ops != ops) {
 602                 struct ieee80211_crypt_data *new_crypt;
 603
 604                 ieee80211_crypt_delayed_deinit(ieee, crypt);
 605
 606                 new_crypt = (struct ieee80211_crypt_data *)
 607                     kmalloc(sizeof(*new_crypt), GFP_KERNEL);
 608                 if (new_crypt == NULL) {
 609                         ret = -ENOMEM;
 610                         goto done;
 611                 }
 612                 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
 613                 new_crypt->ops = ops;
 614                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
 615                         new_crypt->priv = new_crypt->ops->init(idx);
 616                 if (new_crypt->priv == NULL) {
 617                         kfree(new_crypt);
 618                         ret = -EINVAL;
 619                         goto done;
 620                 }
 621                 *crypt = new_crypt;
 622         }
 623
 624         if (ext->key_len > 0 && (*crypt)->ops->set_key &&
 625             (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
 626                                    (*crypt)->priv) < 0) {
 627                 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name);
 628                 ret = -EINVAL;
 629                 goto done;
 630         }
 631
 632       skip_host_crypt:
 633         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
 634                 ieee->tx_keyidx = idx;
 635                 sec.active_key = idx;
 636                 sec.flags |= SEC_ACTIVE_KEY;
 637         }
 638
 639         if (ext->alg != IW_ENCODE_ALG_NONE) {
 640                 memcpy(sec.keys[idx], ext->key, ext->key_len);
 641                 sec.key_sizes[idx] = ext->key_len;
 642                 sec.flags |= (1 << idx);
 643                 if (ext->alg == IW_ENCODE_ALG_WEP) {
 644                         sec.encode_alg[idx] = SEC_ALG_WEP;
 645                         sec.flags |= SEC_LEVEL;
 646                         sec.level = SEC_LEVEL_1;
 647                 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
 648                         sec.encode_alg[idx] = SEC_ALG_TKIP;
 649                         sec.flags |= SEC_LEVEL;
 650                         sec.level = SEC_LEVEL_2;
 651                 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
 652                         sec.encode_alg[idx] = SEC_ALG_CCMP;
 653                         sec.flags |= SEC_LEVEL;
 654                         sec.level = SEC_LEVEL_3;
 655                 }
 656                 /* Don't set sec level for group keys. */
 657                 if (group_key)
 658                         sec.flags &= ~SEC_LEVEL;
 659         }
 660       done:
 661         if (ieee->set_security)
 662                 ieee->set_security(ieee->dev, &sec);
 663
 664         /*
 665          * Do not reset port if card is in Managed mode since resetting will
 666          * generate new IEEE 802.11 authentication which may end up in looping
 667          * with IEEE 802.1X. If your hardware requires a reset after WEP
 668          * configuration (for example... Prism2), implement the reset_port in
 669          * the callbacks structures used to initialize the 802.11 stack.
 670          */
 671         if (ieee->reset_on_keychange &&
 672             ieee->iw_mode != IW_MODE_INFRA &&
 673             ieee->reset_port && ieee->reset_port(dev)) {
 674                 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name);
 675                 return -EINVAL;
 676         }
 677
 678         return ret;
 679 }
 680
 681 int ieee80211_wx_get_encodeext(struct ieee80211_device *ieee,
 682                                struct iw_request_info *info,
 683                                union iwreq_data *wrqu, char *extra)
 684 {
 685         struct iw_point *encoding = &wrqu->encoding;
 686         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
 687         struct ieee80211_security *sec = &ieee->sec;
 688         int idx, max_key_len;
 689
 690         max_key_len = encoding->length - sizeof(*ext);
 691         if (max_key_len < 0)
 692                 return -EINVAL;
 693
 694         idx = encoding->flags & IW_ENCODE_INDEX;
 695         if (idx) {
 696                 if (idx < 1 || idx > WEP_KEYS)
 697                         return -EINVAL;
 698                 idx--;
 699         } else
 700                 idx = ieee->tx_keyidx;
 701
 702         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
 703             ext->alg != IW_ENCODE_ALG_WEP)
 704                 if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA)
 705                         return -EINVAL;
 706
 707         encoding->flags = idx + 1;
 708         memset(ext, 0, sizeof(*ext));
 709
 710         if (!sec->enabled) {
 711                 ext->alg = IW_ENCODE_ALG_NONE;
 712                 ext->key_len = 0;
 713                 encoding->flags |= IW_ENCODE_DISABLED;
 714         } else {
 715                 if (sec->encode_alg[idx] == SEC_ALG_WEP)
 716                         ext->alg = IW_ENCODE_ALG_WEP;
 717                 else if (sec->encode_alg[idx] == SEC_ALG_TKIP)
 718                         ext->alg = IW_ENCODE_ALG_TKIP;
 719                 else if (sec->encode_alg[idx] == SEC_ALG_CCMP)
 720                         ext->alg = IW_ENCODE_ALG_CCMP;
 721                 else
 722                         return -EINVAL;
 723
 724                 ext->key_len = sec->key_sizes[idx];
 725                 memcpy(ext->key, sec->keys[idx], ext->key_len);
 726                 encoding->flags |= IW_ENCODE_ENABLED;
 727                 if (ext->key_len &&
 728                     (ext->alg == IW_ENCODE_ALG_TKIP ||
 729                      ext->alg == IW_ENCODE_ALG_CCMP))
 730                         ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
 731
 732         }
 733
 734         return 0;
 735 }
 736
 737 EXPORT_SYMBOL(ieee80211_wx_set_encodeext);
 738 EXPORT_SYMBOL(ieee80211_wx_get_encodeext);
 739
 740 EXPORT_SYMBOL(ieee80211_wx_get_scan);
 741 EXPORT_SYMBOL(ieee80211_wx_set_encode);
 742 EXPORT_SYMBOL(ieee80211_wx_get_encode);