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