err.no Git - linux-2.6/blob - drivers/net/wireless/libertas/assoc.c

   1 /* Copyright (C) 2006, Red Hat, Inc. */
   2
   3 #include <linux/bitops.h>
   4 #include <net/ieee80211.h>
   5 #include <linux/etherdevice.h>
   6
   7 #include "assoc.h"
   8 #include "join.h"
   9 #include "decl.h"
  10 #include "hostcmd.h"
  11 #include "host.h"
  12 #include "cmd.h"
  13
  14
  15 static const u8 bssid_any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  16 static const u8 bssid_off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  17
  18
  19 static int assoc_helper_essid(struct lbs_private *priv,
  20                               struct assoc_request * assoc_req)
  21 {
  22         int ret = 0;
  23         struct bss_descriptor * bss;
  24         int channel = -1;
  25
  26         lbs_deb_enter(LBS_DEB_ASSOC);
  27
  28         /* FIXME: take channel into account when picking SSIDs if a channel
  29          * is set.
  30          */
  31
  32         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
  33                 channel = assoc_req->channel;
  34
  35         lbs_deb_assoc("SSID '%s' requested\n",
  36                       escape_essid(assoc_req->ssid, assoc_req->ssid_len));
  37         if (assoc_req->mode == IW_MODE_INFRA) {
  38                 lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
  39                         assoc_req->ssid_len, 0);
  40
  41                 bss = lbs_find_ssid_in_list(priv, assoc_req->ssid,
  42                                 assoc_req->ssid_len, NULL, IW_MODE_INFRA, channel);
  43                 if (bss != NULL) {
  44                         memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
  45                         ret = lbs_associate(priv, assoc_req);
  46                 } else {
  47                         lbs_deb_assoc("SSID not found; cannot associate\n");
  48                 }
  49         } else if (assoc_req->mode == IW_MODE_ADHOC) {
  50                 /* Scan for the network, do not save previous results.  Stale
  51                  *   scan data will cause us to join a non-existant adhoc network
  52                  */
  53                 lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
  54                         assoc_req->ssid_len, 1);
  55
  56                 /* Search for the requested SSID in the scan table */
  57                 bss = lbs_find_ssid_in_list(priv, assoc_req->ssid,
  58                                 assoc_req->ssid_len, NULL, IW_MODE_ADHOC, channel);
  59                 if (bss != NULL) {
  60                         lbs_deb_assoc("SSID found, will join\n");
  61                         memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
  62                         lbs_join_adhoc_network(priv, assoc_req);
  63                 } else {
  64                         /* else send START command */
  65                         lbs_deb_assoc("SSID not found, creating adhoc network\n");
  66                         memcpy(&assoc_req->bss.ssid, &assoc_req->ssid,
  67                                 IW_ESSID_MAX_SIZE);
  68                         assoc_req->bss.ssid_len = assoc_req->ssid_len;
  69                         lbs_start_adhoc_network(priv, assoc_req);
  70                 }
  71         }
  72
  73         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
  74         return ret;
  75 }
  76
  77
  78 static int assoc_helper_bssid(struct lbs_private *priv,
  79                               struct assoc_request * assoc_req)
  80 {
  81         int ret = 0;
  82         struct bss_descriptor * bss;
  83         DECLARE_MAC_BUF(mac);
  84
  85         lbs_deb_enter_args(LBS_DEB_ASSOC, "BSSID %s",
  86                 print_mac(mac, assoc_req->bssid));
  87
  88         /* Search for index position in list for requested MAC */
  89         bss = lbs_find_bssid_in_list(priv, assoc_req->bssid,
  90                             assoc_req->mode);
  91         if (bss == NULL) {
  92                 lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, "
  93                         "cannot associate.\n", print_mac(mac, assoc_req->bssid));
  94                 goto out;
  95         }
  96
  97         memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
  98         if (assoc_req->mode == IW_MODE_INFRA) {
  99                 ret = lbs_associate(priv, assoc_req);
 100                 lbs_deb_assoc("ASSOC: lbs_associate(bssid) returned %d\n", ret);
 101         } else if (assoc_req->mode == IW_MODE_ADHOC) {
 102                 lbs_join_adhoc_network(priv, assoc_req);
 103         }
 104
 105 out:
 106         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 107         return ret;
 108 }
 109
 110
 111 static int assoc_helper_associate(struct lbs_private *priv,
 112                                   struct assoc_request * assoc_req)
 113 {
 114         int ret = 0, done = 0;
 115
 116         lbs_deb_enter(LBS_DEB_ASSOC);
 117
 118         /* If we're given and 'any' BSSID, try associating based on SSID */
 119
 120         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 121                 if (compare_ether_addr(bssid_any, assoc_req->bssid)
 122                     && compare_ether_addr(bssid_off, assoc_req->bssid)) {
 123                         ret = assoc_helper_bssid(priv, assoc_req);
 124                         done = 1;
 125                 }
 126         }
 127
 128         if (!done && test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 129                 ret = assoc_helper_essid(priv, assoc_req);
 130         }
 131
 132         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 133         return ret;
 134 }
 135
 136
 137 static int assoc_helper_mode(struct lbs_private *priv,
 138                              struct assoc_request * assoc_req)
 139 {
 140         int ret = 0;
 141
 142         lbs_deb_enter(LBS_DEB_ASSOC);
 143
 144         if (assoc_req->mode == priv->mode)
 145                 goto done;
 146
 147         if (assoc_req->mode == IW_MODE_INFRA) {
 148                 if (priv->psstate != PS_STATE_FULL_POWER)
 149                         lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
 150                 priv->psmode = LBS802_11POWERMODECAM;
 151         }
 152
 153         priv->mode = assoc_req->mode;
 154         ret = lbs_prepare_and_send_command(priv,
 155                                     CMD_802_11_SNMP_MIB,
 156                                     0, CMD_OPTION_WAITFORRSP,
 157                                     OID_802_11_INFRASTRUCTURE_MODE,
 158                 /* Shoot me now */  (void *) (size_t) assoc_req->mode);
 159
 160 done:
 161         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 162         return ret;
 163 }
 164
 165
 166 static int update_channel(struct lbs_private *priv)
 167 {
 168         int ret;
 169
 170         /* the channel in f/w could be out of sync, get the current channel */
 171         lbs_deb_enter(LBS_DEB_ASSOC);
 172
 173         ret = lbs_get_channel(priv);
 174         if (ret > 0)
 175                 priv->curbssparams.channel = (u8) ret;
 176
 177         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 178         return ret;
 179 }
 180
 181 void lbs_sync_channel(struct work_struct *work)
 182 {
 183         struct lbs_private *priv = container_of(work, struct lbs_private,
 184                 sync_channel);
 185
 186         lbs_deb_enter(LBS_DEB_ASSOC);
 187         if (update_channel(priv) != 0)
 188                 lbs_pr_info("Channel synchronization failed.");
 189         lbs_deb_leave(LBS_DEB_ASSOC);
 190 }
 191
 192 static int assoc_helper_channel(struct lbs_private *priv,
 193                                 struct assoc_request * assoc_req)
 194 {
 195         int ret = 0;
 196
 197         lbs_deb_enter(LBS_DEB_ASSOC);
 198
 199         ret = update_channel(priv);
 200         if (ret < 0) {
 201                 lbs_deb_assoc("ASSOC: channel: error getting channel.");
 202         }
 203
 204         if (assoc_req->channel == priv->curbssparams.channel)
 205                 goto done;
 206
 207         lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
 208                priv->curbssparams.channel, assoc_req->channel);
 209
 210         ret = lbs_set_channel(priv, assoc_req->channel);
 211         if (ret < 0)
 212                 lbs_deb_assoc("ASSOC: channel: error setting channel.");
 213
 214         /* FIXME: shouldn't need to grab the channel _again_ after setting
 215          * it since the firmware is supposed to return the new channel, but
 216          * whatever... */
 217         ret = update_channel(priv);
 218         if (ret < 0)
 219                 lbs_deb_assoc("ASSOC: channel: error getting channel.");
 220
 221         if (assoc_req->channel != priv->curbssparams.channel) {
 222                 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d",
 223                               assoc_req->channel);
 224                 goto done;
 225         }
 226
 227         if (   assoc_req->secinfo.wep_enabled
 228             &&   (assoc_req->wep_keys[0].len
 229                || assoc_req->wep_keys[1].len
 230                || assoc_req->wep_keys[2].len
 231                || assoc_req->wep_keys[3].len)) {
 232                 /* Make sure WEP keys are re-sent to firmware */
 233                 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
 234         }
 235
 236         /* Must restart/rejoin adhoc networks after channel change */
 237         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
 238
 239 done:
 240         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 241         return ret;
 242 }
 243
 244
 245 static int assoc_helper_wep_keys(struct lbs_private *priv,
 246                                  struct assoc_request * assoc_req)
 247 {
 248         int i;
 249         int ret = 0;
 250
 251         lbs_deb_enter(LBS_DEB_ASSOC);
 252
 253         /* Set or remove WEP keys */
 254         if (   assoc_req->wep_keys[0].len
 255             || assoc_req->wep_keys[1].len
 256             || assoc_req->wep_keys[2].len
 257             || assoc_req->wep_keys[3].len) {
 258                 ret = lbs_prepare_and_send_command(priv,
 259                                             CMD_802_11_SET_WEP,
 260                                             CMD_ACT_ADD,
 261                                             CMD_OPTION_WAITFORRSP,
 262                                             0, assoc_req);
 263         } else {
 264                 ret = lbs_prepare_and_send_command(priv,
 265                                             CMD_802_11_SET_WEP,
 266                                             CMD_ACT_REMOVE,
 267                                             CMD_OPTION_WAITFORRSP,
 268                                             0, NULL);
 269         }
 270
 271         if (ret)
 272                 goto out;
 273
 274         /* enable/disable the MAC's WEP packet filter */
 275         if (assoc_req->secinfo.wep_enabled)
 276                 priv->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
 277         else
 278                 priv->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
 279         ret = lbs_set_mac_packet_filter(priv);
 280         if (ret)
 281                 goto out;
 282
 283         mutex_lock(&priv->lock);
 284
 285         /* Copy WEP keys into priv wep key fields */
 286         for (i = 0; i < 4; i++) {
 287                 memcpy(&priv->wep_keys[i], &assoc_req->wep_keys[i],
 288                         sizeof(struct enc_key));
 289         }
 290         priv->wep_tx_keyidx = assoc_req->wep_tx_keyidx;
 291
 292         mutex_unlock(&priv->lock);
 293
 294 out:
 295         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 296         return ret;
 297 }
 298
 299 static int assoc_helper_secinfo(struct lbs_private *priv,
 300                                 struct assoc_request * assoc_req)
 301 {
 302         int ret = 0;
 303         u32 do_wpa;
 304         u32 rsn = 0;
 305
 306         lbs_deb_enter(LBS_DEB_ASSOC);
 307
 308         memcpy(&priv->secinfo, &assoc_req->secinfo,
 309                 sizeof(struct lbs_802_11_security));
 310
 311         ret = lbs_set_mac_packet_filter(priv);
 312         if (ret)
 313                 goto out;
 314
 315         /* If RSN is already enabled, don't try to enable it again, since
 316          * ENABLE_RSN resets internal state machines and will clobber the
 317          * 4-way WPA handshake.
 318          */
 319
 320         /* Get RSN enabled/disabled */
 321         ret = lbs_prepare_and_send_command(priv,
 322                                     CMD_802_11_ENABLE_RSN,
 323                                     CMD_ACT_GET,
 324                                     CMD_OPTION_WAITFORRSP,
 325                                     0, &rsn);
 326         if (ret) {
 327                 lbs_deb_assoc("Failed to get RSN status: %d", ret);
 328                 goto out;
 329         }
 330
 331         /* Don't re-enable RSN if it's already enabled */
 332         do_wpa = (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled);
 333         if (do_wpa == rsn)
 334                 goto out;
 335
 336         /* Set RSN enabled/disabled */
 337         rsn = do_wpa;
 338         ret = lbs_prepare_and_send_command(priv,
 339                                     CMD_802_11_ENABLE_RSN,
 340                                     CMD_ACT_SET,
 341                                     CMD_OPTION_WAITFORRSP,
 342                                     0, &rsn);
 343
 344 out:
 345         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 346         return ret;
 347 }
 348
 349
 350 static int assoc_helper_wpa_keys(struct lbs_private *priv,
 351                                  struct assoc_request * assoc_req)
 352 {
 353         int ret = 0;
 354         unsigned int flags = assoc_req->flags;
 355
 356         lbs_deb_enter(LBS_DEB_ASSOC);
 357
 358         /* Work around older firmware bug where WPA unicast and multicast
 359          * keys must be set independently.  Seen in SDIO parts with firmware
 360          * version 5.0.11p0.
 361          */
 362
 363         if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 364                 clear_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
 365                 ret = lbs_prepare_and_send_command(priv,
 366                                         CMD_802_11_KEY_MATERIAL,
 367                                         CMD_ACT_SET,
 368                                         CMD_OPTION_WAITFORRSP,
 369                                         0, assoc_req);
 370                 assoc_req->flags = flags;
 371         }
 372
 373         if (ret)
 374                 goto out;
 375
 376         if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 377                 clear_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
 378
 379                 ret = lbs_prepare_and_send_command(priv,
 380                                         CMD_802_11_KEY_MATERIAL,
 381                                         CMD_ACT_SET,
 382                                         CMD_OPTION_WAITFORRSP,
 383                                         0, assoc_req);
 384                 assoc_req->flags = flags;
 385         }
 386
 387 out:
 388         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 389         return ret;
 390 }
 391
 392
 393 static int assoc_helper_wpa_ie(struct lbs_private *priv,
 394                                struct assoc_request * assoc_req)
 395 {
 396         int ret = 0;
 397
 398         lbs_deb_enter(LBS_DEB_ASSOC);
 399
 400         if (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled) {
 401                 memcpy(&priv->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len);
 402                 priv->wpa_ie_len = assoc_req->wpa_ie_len;
 403         } else {
 404                 memset(&priv->wpa_ie, 0, MAX_WPA_IE_LEN);
 405                 priv->wpa_ie_len = 0;
 406         }
 407
 408         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 409         return ret;
 410 }
 411
 412
 413 static int should_deauth_infrastructure(struct lbs_private *priv,
 414                                         struct assoc_request * assoc_req)
 415 {
 416         int ret = 0;
 417
 418         lbs_deb_enter(LBS_DEB_ASSOC);
 419
 420         if (priv->connect_status != LBS_CONNECTED)
 421                 return 0;
 422
 423         if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 424                 lbs_deb_assoc("Deauthenticating due to new SSID\n");
 425                 ret = 1;
 426                 goto out;
 427         }
 428
 429         if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 430                 if (priv->secinfo.auth_mode != assoc_req->secinfo.auth_mode) {
 431                         lbs_deb_assoc("Deauthenticating due to new security\n");
 432                         ret = 1;
 433                         goto out;
 434                 }
 435         }
 436
 437         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 438                 lbs_deb_assoc("Deauthenticating due to new BSSID\n");
 439                 ret = 1;
 440                 goto out;
 441         }
 442
 443         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
 444                 lbs_deb_assoc("Deauthenticating due to channel switch\n");
 445                 ret = 1;
 446                 goto out;
 447         }
 448
 449         /* FIXME: deal with 'auto' mode somehow */
 450         if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 451                 if (assoc_req->mode != IW_MODE_INFRA) {
 452                         lbs_deb_assoc("Deauthenticating due to leaving "
 453                                 "infra mode\n");
 454                         ret = 1;
 455                         goto out;
 456                 }
 457         }
 458
 459 out:
 460         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 461         return 0;
 462 }
 463
 464
 465 static int should_stop_adhoc(struct lbs_private *priv,
 466                              struct assoc_request * assoc_req)
 467 {
 468         lbs_deb_enter(LBS_DEB_ASSOC);
 469
 470         if (priv->connect_status != LBS_CONNECTED)
 471                 return 0;
 472
 473         if (lbs_ssid_cmp(priv->curbssparams.ssid,
 474                               priv->curbssparams.ssid_len,
 475                               assoc_req->ssid, assoc_req->ssid_len) != 0)
 476                 return 1;
 477
 478         /* FIXME: deal with 'auto' mode somehow */
 479         if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 480                 if (assoc_req->mode != IW_MODE_ADHOC)
 481                         return 1;
 482         }
 483
 484         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
 485                 if (assoc_req->channel != priv->curbssparams.channel)
 486                         return 1;
 487         }
 488
 489         lbs_deb_leave(LBS_DEB_ASSOC);
 490         return 0;
 491 }
 492
 493
 494 void lbs_association_worker(struct work_struct *work)
 495 {
 496         struct lbs_private *priv = container_of(work, struct lbs_private,
 497                 assoc_work.work);
 498         struct assoc_request * assoc_req = NULL;
 499         int ret = 0;
 500         int find_any_ssid = 0;
 501         DECLARE_MAC_BUF(mac);
 502
 503         lbs_deb_enter(LBS_DEB_ASSOC);
 504
 505         mutex_lock(&priv->lock);
 506         assoc_req = priv->pending_assoc_req;
 507         priv->pending_assoc_req = NULL;
 508         priv->in_progress_assoc_req = assoc_req;
 509         mutex_unlock(&priv->lock);
 510
 511         if (!assoc_req)
 512                 goto done;
 513
 514         lbs_deb_assoc(
 515                 "Association Request:\n"
 516                 "    flags:     0x%08lx\n"
 517                 "    SSID:      '%s'\n"
 518                 "    chann:     %d\n"
 519                 "    band:      %d\n"
 520                 "    mode:      %d\n"
 521                 "    BSSID:     %s\n"
 522                 "    secinfo:  %s%s%s\n"
 523                 "    auth_mode: %d\n",
 524                 assoc_req->flags,
 525                 escape_essid(assoc_req->ssid, assoc_req->ssid_len),
 526                 assoc_req->channel, assoc_req->band, assoc_req->mode,
 527                 print_mac(mac, assoc_req->bssid),
 528                 assoc_req->secinfo.WPAenabled ? " WPA" : "",
 529                 assoc_req->secinfo.WPA2enabled ? " WPA2" : "",
 530                 assoc_req->secinfo.wep_enabled ? " WEP" : "",
 531                 assoc_req->secinfo.auth_mode);
 532
 533         /* If 'any' SSID was specified, find an SSID to associate with */
 534         if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)
 535             && !assoc_req->ssid_len)
 536                 find_any_ssid = 1;
 537
 538         /* But don't use 'any' SSID if there's a valid locked BSSID to use */
 539         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 540                 if (compare_ether_addr(assoc_req->bssid, bssid_any)
 541                     && compare_ether_addr(assoc_req->bssid, bssid_off))
 542                         find_any_ssid = 0;
 543         }
 544
 545         if (find_any_ssid) {
 546                 u8 new_mode;
 547
 548                 ret = lbs_find_best_network_ssid(priv, assoc_req->ssid,
 549                                 &assoc_req->ssid_len, assoc_req->mode, &new_mode);
 550                 if (ret) {
 551                         lbs_deb_assoc("Could not find best network\n");
 552                         ret = -ENETUNREACH;
 553                         goto out;
 554                 }
 555
 556                 /* Ensure we switch to the mode of the AP */
 557                 if (assoc_req->mode == IW_MODE_AUTO) {
 558                         set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
 559                         assoc_req->mode = new_mode;
 560                 }
 561         }
 562
 563         /*
 564          * Check if the attributes being changing require deauthentication
 565          * from the currently associated infrastructure access point.
 566          */
 567         if (priv->mode == IW_MODE_INFRA) {
 568                 if (should_deauth_infrastructure(priv, assoc_req)) {
 569                         ret = lbs_send_deauthentication(priv);
 570                         if (ret) {
 571                                 lbs_deb_assoc("Deauthentication due to new "
 572                                         "configuration request failed: %d\n",
 573                                         ret);
 574                         }
 575                 }
 576         } else if (priv->mode == IW_MODE_ADHOC) {
 577                 if (should_stop_adhoc(priv, assoc_req)) {
 578                         ret = lbs_stop_adhoc_network(priv);
 579                         if (ret) {
 580                                 lbs_deb_assoc("Teardown of AdHoc network due to "
 581                                         "new configuration request failed: %d\n",
 582                                         ret);
 583                         }
 584
 585                 }
 586         }
 587
 588         /* Send the various configuration bits to the firmware */
 589         if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 590                 ret = assoc_helper_mode(priv, assoc_req);
 591                 if (ret)
 592                         goto out;
 593         }
 594
 595         if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
 596                 ret = assoc_helper_channel(priv, assoc_req);
 597                 if (ret)
 598                         goto out;
 599         }
 600
 601         if (   test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)
 602             || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags)) {
 603                 ret = assoc_helper_wep_keys(priv, assoc_req);
 604                 if (ret)
 605                         goto out;
 606         }
 607
 608         if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 609                 ret = assoc_helper_secinfo(priv, assoc_req);
 610                 if (ret)
 611                         goto out;
 612         }
 613
 614         if (test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
 615                 ret = assoc_helper_wpa_ie(priv, assoc_req);
 616                 if (ret)
 617                         goto out;
 618         }
 619
 620         if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)
 621             || test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 622                 ret = assoc_helper_wpa_keys(priv, assoc_req);
 623                 if (ret)
 624                         goto out;
 625         }
 626
 627         /* SSID/BSSID should be the _last_ config option set, because they
 628          * trigger the association attempt.
 629          */
 630         if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)
 631             || test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 632                 int success = 1;
 633
 634                 ret = assoc_helper_associate(priv, assoc_req);
 635                 if (ret) {
 636                         lbs_deb_assoc("ASSOC: association unsuccessful: %d\n",
 637                                 ret);
 638                         success = 0;
 639                 }
 640
 641                 if (priv->connect_status != LBS_CONNECTED) {
 642                         lbs_deb_assoc("ASSOC: association unsuccessful, "
 643                                 "not connected\n");
 644                         success = 0;
 645                 }
 646
 647                 if (success) {
 648                         lbs_deb_assoc("ASSOC: associated to '%s', %s\n",
 649                                 escape_essid(priv->curbssparams.ssid,
 650                                              priv->curbssparams.ssid_len),
 651                                 print_mac(mac, priv->curbssparams.bssid));
 652                         lbs_prepare_and_send_command(priv,
 653                                 CMD_802_11_RSSI,
 654                                 0, CMD_OPTION_WAITFORRSP, 0, NULL);
 655
 656                         lbs_prepare_and_send_command(priv,
 657                                 CMD_802_11_GET_LOG,
 658                                 0, CMD_OPTION_WAITFORRSP, 0, NULL);
 659                 } else {
 660                         ret = -1;
 661                 }
 662         }
 663
 664 out:
 665         if (ret) {
 666                 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
 667                         ret);
 668         }
 669
 670         mutex_lock(&priv->lock);
 671         priv->in_progress_assoc_req = NULL;
 672         mutex_unlock(&priv->lock);
 673         kfree(assoc_req);
 674
 675 done:
 676         lbs_deb_leave(LBS_DEB_ASSOC);
 677 }
 678
 679
 680 /*
 681  * Caller MUST hold any necessary locks
 682  */
 683 struct assoc_request *lbs_get_association_request(struct lbs_private *priv)
 684 {
 685         struct assoc_request * assoc_req;
 686
 687         lbs_deb_enter(LBS_DEB_ASSOC);
 688         if (!priv->pending_assoc_req) {
 689                 priv->pending_assoc_req = kzalloc(sizeof(struct assoc_request),
 690                                                      GFP_KERNEL);
 691                 if (!priv->pending_assoc_req) {
 692                         lbs_pr_info("Not enough memory to allocate association"
 693                                 " request!\n");
 694                         return NULL;
 695                 }
 696         }
 697
 698         /* Copy current configuration attributes to the association request,
 699          * but don't overwrite any that are already set.
 700          */
 701         assoc_req = priv->pending_assoc_req;
 702         if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 703                 memcpy(&assoc_req->ssid, &priv->curbssparams.ssid,
 704                        IW_ESSID_MAX_SIZE);
 705                 assoc_req->ssid_len = priv->curbssparams.ssid_len;
 706         }
 707
 708         if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
 709                 assoc_req->channel = priv->curbssparams.channel;
 710
 711         if (!test_bit(ASSOC_FLAG_BAND, &assoc_req->flags))
 712                 assoc_req->band = priv->curbssparams.band;
 713
 714         if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags))
 715                 assoc_req->mode = priv->mode;
 716
 717         if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 718                 memcpy(&assoc_req->bssid, priv->curbssparams.bssid,
 719                         ETH_ALEN);
 720         }
 721
 722         if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) {
 723                 int i;
 724                 for (i = 0; i < 4; i++) {
 725                         memcpy(&assoc_req->wep_keys[i], &priv->wep_keys[i],
 726                                 sizeof(struct enc_key));
 727                 }
 728         }
 729
 730         if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags))
 731                 assoc_req->wep_tx_keyidx = priv->wep_tx_keyidx;
 732
 733         if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 734                 memcpy(&assoc_req->wpa_mcast_key, &priv->wpa_mcast_key,
 735                         sizeof(struct enc_key));
 736         }
 737
 738         if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 739                 memcpy(&assoc_req->wpa_unicast_key, &priv->wpa_unicast_key,
 740                         sizeof(struct enc_key));
 741         }
 742
 743         if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 744                 memcpy(&assoc_req->secinfo, &priv->secinfo,
 745                         sizeof(struct lbs_802_11_security));
 746         }
 747
 748         if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
 749                 memcpy(&assoc_req->wpa_ie, &priv->wpa_ie,
 750                         MAX_WPA_IE_LEN);
 751                 assoc_req->wpa_ie_len = priv->wpa_ie_len;
 752         }
 753
 754         lbs_deb_leave(LBS_DEB_ASSOC);
 755         return assoc_req;
 756 }