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