net/mac80211/key.c

   1 /*
   2  * Copyright 2002-2005, Instant802 Networks, Inc.
   3  * Copyright 2005-2006, Devicescape Software, Inc.
   4  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
   5  * Copyright 2007-2008  Johannes Berg <johannes@sipsolutions.net>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/if_ether.h>
  13 #include <linux/etherdevice.h>
  14 #include <linux/list.h>
  15 #include <linux/rcupdate.h>
  16 #include <linux/rtnetlink.h>
  17 #include <linux/slab.h>
  18 #include <linux/export.h>
  19 #include <net/mac80211.h>
  20 #include "ieee80211_i.h"
  21 #include "driver-ops.h"
  22 #include "debugfs_key.h"
  23 #include "aes_ccm.h"
  24 #include "aes_cmac.h"
  25
  26
  27 /**
  28  * DOC: Key handling basics
  29  *
  30  * Key handling in mac80211 is done based on per-interface (sub_if_data)
  31  * keys and per-station keys. Since each station belongs to an interface,
  32  * each station key also belongs to that interface.
  33  *
  34  * Hardware acceleration is done on a best-effort basis for algorithms
  35  * that are implemented in software,  for each key the hardware is asked
  36  * to enable that key for offloading but if it cannot do that the key is
  37  * simply kept for software encryption (unless it is for an algorithm
  38  * that isn't implemented in software).
  39  * There is currently no way of knowing whether a key is handled in SW
  40  * or HW except by looking into debugfs.
  41  *
  42  * All key management is internally protected by a mutex. Within all
  43  * other parts of mac80211, key references are, just as STA structure
  44  * references, protected by RCU. Note, however, that some things are
  45  * unprotected, namely the key->sta dereferences within the hardware
  46  * acceleration functions. This means that sta_info_destroy() must
  47  * remove the key which waits for an RCU grace period.
  48  */
  49
  50 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  51
  52 static void assert_key_lock(struct ieee80211_local *local)
  53 {
  54         lockdep_assert_held(&local->key_mtx);
  55 }
  56
  57 static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
  58 {
  59         if (key->sta)
  60                 return &key->sta->sta;
  61
  62         return NULL;
  63 }
  64
  65 static void increment_tailroom_need_count(struct ieee80211_sub_if_data *sdata)
  66 {
  67         /*
  68          * When this count is zero, SKB resizing for allocating tailroom
  69          * for IV or MMIC is skipped. But, this check has created two race
  70          * cases in xmit path while transiting from zero count to one:
  71          *
  72          * 1. SKB resize was skipped because no key was added but just before
  73          * the xmit key is added and SW encryption kicks off.
  74          *
  75          * 2. SKB resize was skipped because all the keys were hw planted but
  76          * just before xmit one of the key is deleted and SW encryption kicks
  77          * off.
  78          *
  79          * In both the above case SW encryption will find not enough space for
  80          * tailroom and exits with WARN_ON. (See WARN_ONs at wpa.c)
  81          *
  82          * Solution has been explained at
  83          * http://mid.gmane.org/1308590980.4322.19.camel@jlt3.sipsolutions.net
  84          */
  85
  86         if (!sdata->crypto_tx_tailroom_needed_cnt++) {
  87                 /*
  88                  * Flush all XMIT packets currently using HW encryption or no
  89                  * encryption at all if the count transition is from 0 -> 1.
  90                  */
  91                 synchronize_net();
  92         }
  93 }
  94
  95 static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
  96 {
  97         struct ieee80211_sub_if_data *sdata;
  98         struct ieee80211_sta *sta;
  99         int ret;
 100
 101         might_sleep();
 102
 103         if (!key->local->ops->set_key)
 104                 goto out_unsupported;
 105
 106         assert_key_lock(key->local);
 107
 108         sta = get_sta_for_key(key);
 109
 110         /*
 111          * If this is a per-STA GTK, check if it
 112          * is supported; if not, return.
 113          */
 114         if (sta && !(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE) &&
 115             !(key->local->hw.flags & IEEE80211_HW_SUPPORTS_PER_STA_GTK))
 116                 goto out_unsupported;
 117
 118         sdata = key->sdata;
 119         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
 120                 /*
 121                  * The driver doesn't know anything about VLAN interfaces.
 122                  * Hence, don't send GTKs for VLAN interfaces to the driver.
 123                  */
 124                 if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE))
 125                         goto out_unsupported;
 126                 sdata = container_of(sdata->bss,
 127                                      struct ieee80211_sub_if_data,
 128                                      u.ap);
 129         }
 130
 131         ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
 132
 133         if (!ret) {
 134                 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
 135
 136                 if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
 137                       (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV) ||
 138                       (key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)))
 139                         sdata->crypto_tx_tailroom_needed_cnt--;
 140
 141                 WARN_ON((key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) &&
 142                         (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV));
 143
 144                 return 0;
 145         }
 146
 147         if (ret != -ENOSPC && ret != -EOPNOTSUPP)
 148                 wiphy_err(key->local->hw.wiphy,
 149                           "failed to set key (%d, %pM) to hardware (%d)\n",
 150                           key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
 151
 152  out_unsupported:
 153         switch (key->conf.cipher) {
 154         case WLAN_CIPHER_SUITE_WEP40:
 155         case WLAN_CIPHER_SUITE_WEP104:
 156         case WLAN_CIPHER_SUITE_TKIP:
 157         case WLAN_CIPHER_SUITE_CCMP:
 158         case WLAN_CIPHER_SUITE_AES_CMAC:
 159                 /* all of these we can do in software */
 160                 return 0;
 161         default:
 162                 return -EINVAL;
 163         }
 164 }
 165
 166 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
 167 {
 168         struct ieee80211_sub_if_data *sdata;
 169         struct ieee80211_sta *sta;
 170         int ret;
 171
 172         might_sleep();
 173
 174         if (!key || !key->local->ops->set_key)
 175                 return;
 176
 177         assert_key_lock(key->local);
 178
 179         if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
 180                 return;
 181
 182         sta = get_sta_for_key(key);
 183         sdata = key->sdata;
 184
 185         if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
 186               (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV) ||
 187               (key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)))
 188                 increment_tailroom_need_count(sdata);
 189
 190         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 191                 sdata = container_of(sdata->bss,
 192                                      struct ieee80211_sub_if_data,
 193                                      u.ap);
 194
 195         ret = drv_set_key(key->local, DISABLE_KEY, sdata,
 196                           sta, &key->conf);
 197
 198         if (ret)
 199                 wiphy_err(key->local->hw.wiphy,
 200                           "failed to remove key (%d, %pM) from hardware (%d)\n",
 201                           key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
 202
 203         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
 204 }
 205
 206 void ieee80211_key_removed(struct ieee80211_key_conf *key_conf)
 207 {
 208         struct ieee80211_key *key;
 209
 210         key = container_of(key_conf, struct ieee80211_key, conf);
 211
 212         might_sleep();
 213         assert_key_lock(key->local);
 214
 215         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
 216
 217         /*
 218          * Flush TX path to avoid attempts to use this key
 219          * after this function returns. Until then, drivers
 220          * must be prepared to handle the key.
 221          */
 222         synchronize_rcu();
 223 }
 224 EXPORT_SYMBOL_GPL(ieee80211_key_removed);
 225
 226 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
 227                                         int idx, bool uni, bool multi)
 228 {
 229         struct ieee80211_key *key = NULL;
 230
 231         assert_key_lock(sdata->local);
 232
 233         if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
 234                 key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
 235
 236         if (uni)
 237                 rcu_assign_pointer(sdata->default_unicast_key, key);
 238         if (multi)
 239                 rcu_assign_pointer(sdata->default_multicast_key, key);
 240
 241         ieee80211_debugfs_key_update_default(sdata);
 242 }
 243
 244 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx,
 245                                bool uni, bool multi)
 246 {
 247         mutex_lock(&sdata->local->key_mtx);
 248         __ieee80211_set_default_key(sdata, idx, uni, multi);
 249         mutex_unlock(&sdata->local->key_mtx);
 250 }
 251
 252 static void
 253 __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
 254 {
 255         struct ieee80211_key *key = NULL;
 256
 257         assert_key_lock(sdata->local);
 258
 259         if (idx >= NUM_DEFAULT_KEYS &&
 260             idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
 261                 key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
 262
 263         rcu_assign_pointer(sdata->default_mgmt_key, key);
 264
 265         ieee80211_debugfs_key_update_default(sdata);
 266 }
 267
 268 void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
 269                                     int idx)
 270 {
 271         mutex_lock(&sdata->local->key_mtx);
 272         __ieee80211_set_default_mgmt_key(sdata, idx);
 273         mutex_unlock(&sdata->local->key_mtx);
 274 }
 275
 276
 277 static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
 278                                     struct sta_info *sta,
 279                                     bool pairwise,
 280                                     struct ieee80211_key *old,
 281                                     struct ieee80211_key *new)
 282 {
 283         int idx;
 284         bool defunikey, defmultikey, defmgmtkey;
 285
 286         if (new)
 287                 list_add_tail(&new->list, &sdata->key_list);
 288
 289         if (sta && pairwise) {
 290                 rcu_assign_pointer(sta->ptk, new);
 291         } else if (sta) {
 292                 if (old)
 293                         idx = old->conf.keyidx;
 294                 else
 295                         idx = new->conf.keyidx;
 296                 rcu_assign_pointer(sta->gtk[idx], new);
 297         } else {
 298                 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
 299
 300                 if (old)
 301                         idx = old->conf.keyidx;
 302                 else
 303                         idx = new->conf.keyidx;
 304
 305                 defunikey = old &&
 306                         old == key_mtx_dereference(sdata->local,
 307                                                 sdata->default_unicast_key);
 308                 defmultikey = old &&
 309                         old == key_mtx_dereference(sdata->local,
 310                                                 sdata->default_multicast_key);
 311                 defmgmtkey = old &&
 312                         old == key_mtx_dereference(sdata->local,
 313                                                 sdata->default_mgmt_key);
 314
 315                 if (defunikey && !new)
 316                         __ieee80211_set_default_key(sdata, -1, true, false);
 317                 if (defmultikey && !new)
 318                         __ieee80211_set_default_key(sdata, -1, false, true);
 319                 if (defmgmtkey && !new)
 320                         __ieee80211_set_default_mgmt_key(sdata, -1);
 321
 322                 rcu_assign_pointer(sdata->keys[idx], new);
 323                 if (defunikey && new)
 324                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
 325                                                     true, false);
 326                 if (defmultikey && new)
 327                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
 328                                                     false, true);
 329                 if (defmgmtkey && new)
 330                         __ieee80211_set_default_mgmt_key(sdata,
 331                                                          new->conf.keyidx);
 332         }
 333
 334         if (old)
 335                 list_del(&old->list);
 336 }
 337
 338 struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
 339                                           const u8 *key_data,
 340                                           size_t seq_len, const u8 *seq)
 341 {
 342         struct ieee80211_key *key;
 343         int i, j, err;
 344
 345         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
 346
 347         key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
 348         if (!key)
 349                 return ERR_PTR(-ENOMEM);
 350
 351         /*
 352          * Default to software encryption; we'll later upload the
 353          * key to the hardware if possible.
 354          */
 355         key->conf.flags = 0;
 356         key->flags = 0;
 357
 358         key->conf.cipher = cipher;
 359         key->conf.keyidx = idx;
 360         key->conf.keylen = key_len;
 361         switch (cipher) {
 362         case WLAN_CIPHER_SUITE_WEP40:
 363         case WLAN_CIPHER_SUITE_WEP104:
 364                 key->conf.iv_len = WEP_IV_LEN;
 365                 key->conf.icv_len = WEP_ICV_LEN;
 366                 break;
 367         case WLAN_CIPHER_SUITE_TKIP:
 368                 key->conf.iv_len = TKIP_IV_LEN;
 369                 key->conf.icv_len = TKIP_ICV_LEN;
 370                 if (seq) {
 371                         for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
 372                                 key->u.tkip.rx[i].iv32 =
 373                                         get_unaligned_le32(&seq[2]);
 374                                 key->u.tkip.rx[i].iv16 =
 375                                         get_unaligned_le16(seq);
 376                         }
 377                 }
 378                 spin_lock_init(&key->u.tkip.txlock);
 379                 break;
 380         case WLAN_CIPHER_SUITE_CCMP:
 381                 key->conf.iv_len = CCMP_HDR_LEN;
 382                 key->conf.icv_len = CCMP_MIC_LEN;
 383                 if (seq) {
 384                         for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
 385                                 for (j = 0; j < CCMP_PN_LEN; j++)
 386                                         key->u.ccmp.rx_pn[i][j] =
 387                                                 seq[CCMP_PN_LEN - j - 1];
 388                 }
 389                 /*
 390                  * Initialize AES key state here as an optimization so that
 391                  * it does not need to be initialized for every packet.
 392                  */
 393                 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
 394                 if (IS_ERR(key->u.ccmp.tfm)) {
 395                         err = PTR_ERR(key->u.ccmp.tfm);
 396                         kfree(key);
 397                         return ERR_PTR(err);
 398                 }
 399                 break;
 400         case WLAN_CIPHER_SUITE_AES_CMAC:
 401                 key->conf.iv_len = 0;
 402                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
 403                 if (seq)
 404                         for (j = 0; j < 6; j++)
 405                                 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
 406                 /*
 407                  * Initialize AES key state here as an optimization so that
 408                  * it does not need to be initialized for every packet.
 409                  */
 410                 key->u.aes_cmac.tfm =
 411                         ieee80211_aes_cmac_key_setup(key_data);
 412                 if (IS_ERR(key->u.aes_cmac.tfm)) {
 413                         err = PTR_ERR(key->u.aes_cmac.tfm);
 414                         kfree(key);
 415                         return ERR_PTR(err);
 416                 }
 417                 break;
 418         }
 419         memcpy(key->conf.key, key_data, key_len);
 420         INIT_LIST_HEAD(&key->list);
 421
 422         return key;
 423 }
 424
 425 static void __ieee80211_key_destroy(struct ieee80211_key *key)
 426 {
 427         if (!key)
 428                 return;
 429
 430         /*
 431          * Synchronize so the TX path can no longer be using
 432          * this key before we free/remove it.
 433          */
 434         synchronize_rcu();
 435
 436         if (key->local)
 437                 ieee80211_key_disable_hw_accel(key);
 438
 439         if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
 440                 ieee80211_aes_key_free(key->u.ccmp.tfm);
 441         if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
 442                 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
 443         if (key->local) {
 444                 ieee80211_debugfs_key_remove(key);
 445                 key->sdata->crypto_tx_tailroom_needed_cnt--;
 446         }
 447
 448         kfree(key);
 449 }
 450
 451 int ieee80211_key_link(struct ieee80211_key *key,
 452                        struct ieee80211_sub_if_data *sdata,
 453                        struct sta_info *sta)
 454 {
 455         struct ieee80211_key *old_key;
 456         int idx, ret;
 457         bool pairwise;
 458
 459         BUG_ON(!sdata);
 460         BUG_ON(!key);
 461
 462         pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
 463         idx = key->conf.keyidx;
 464         key->local = sdata->local;
 465         key->sdata = sdata;
 466         key->sta = sta;
 467
 468         if (sta) {
 469                 /*
 470                  * some hardware cannot handle TKIP with QoS, so
 471                  * we indicate whether QoS could be in use.
 472                  */
 473                 if (test_sta_flag(sta, WLAN_STA_WME))
 474                         key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
 475         } else {
 476                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 477                         struct sta_info *ap;
 478
 479                         /*
 480                          * We're getting a sta pointer in, so must be under
 481                          * appropriate locking for sta_info_get().
 482                          */
 483
 484                         /* same here, the AP could be using QoS */
 485                         ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
 486                         if (ap) {
 487                                 if (test_sta_flag(ap, WLAN_STA_WME))
 488                                         key->conf.flags |=
 489                                                 IEEE80211_KEY_FLAG_WMM_STA;
 490                         }
 491                 }
 492         }
 493
 494         mutex_lock(&sdata->local->key_mtx);
 495
 496         if (sta && pairwise)
 497                 old_key = key_mtx_dereference(sdata->local, sta->ptk);
 498         else if (sta)
 499                 old_key = key_mtx_dereference(sdata->local, sta->gtk[idx]);
 500         else
 501                 old_key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
 502
 503         increment_tailroom_need_count(sdata);
 504
 505         __ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
 506         __ieee80211_key_destroy(old_key);
 507
 508         ieee80211_debugfs_key_add(key);
 509
 510         ret = ieee80211_key_enable_hw_accel(key);
 511
 512         mutex_unlock(&sdata->local->key_mtx);
 513
 514         return ret;
 515 }
 516
 517 void __ieee80211_key_free(struct ieee80211_key *key)
 518 {
 519         if (!key)
 520                 return;
 521
 522         /*
 523          * Replace key with nothingness if it was ever used.
 524          */
 525         if (key->sdata)
 526                 __ieee80211_key_replace(key->sdata, key->sta,
 527                                 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
 528                                 key, NULL);
 529         __ieee80211_key_destroy(key);
 530 }
 531
 532 void ieee80211_key_free(struct ieee80211_local *local,
 533                         struct ieee80211_key *key)
 534 {
 535         mutex_lock(&local->key_mtx);
 536         __ieee80211_key_free(key);
 537         mutex_unlock(&local->key_mtx);
 538 }
 539
 540 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
 541 {
 542         struct ieee80211_key *key;
 543
 544         ASSERT_RTNL();
 545
 546         if (WARN_ON(!ieee80211_sdata_running(sdata)))
 547                 return;
 548
 549         mutex_lock(&sdata->local->key_mtx);
 550
 551         sdata->crypto_tx_tailroom_needed_cnt = 0;
 552
 553         list_for_each_entry(key, &sdata->key_list, list) {
 554                 increment_tailroom_need_count(sdata);
 555                 ieee80211_key_enable_hw_accel(key);
 556         }
 557
 558         mutex_unlock(&sdata->local->key_mtx);
 559 }
 560
 561 void ieee80211_iter_keys(struct ieee80211_hw *hw,
 562                          struct ieee80211_vif *vif,
 563                          void (*iter)(struct ieee80211_hw *hw,
 564                                       struct ieee80211_vif *vif,
 565                                       struct ieee80211_sta *sta,
 566                                       struct ieee80211_key_conf *key,
 567                                       void *data),
 568                          void *iter_data)
 569 {
 570         struct ieee80211_local *local = hw_to_local(hw);
 571         struct ieee80211_key *key;
 572         struct ieee80211_sub_if_data *sdata;
 573
 574         ASSERT_RTNL();
 575
 576         mutex_lock(&local->key_mtx);
 577         if (vif) {
 578                 sdata = vif_to_sdata(vif);
 579                 list_for_each_entry(key, &sdata->key_list, list)
 580                         iter(hw, &sdata->vif,
 581                              key->sta ? &key->sta->sta : NULL,
 582                              &key->conf, iter_data);
 583         } else {
 584                 list_for_each_entry(sdata, &local->interfaces, list)
 585                         list_for_each_entry(key, &sdata->key_list, list)
 586                                 iter(hw, &sdata->vif,
 587                                      key->sta ? &key->sta->sta : NULL,
 588                                      &key->conf, iter_data);
 589         }
 590         mutex_unlock(&local->key_mtx);
 591 }
 592 EXPORT_SYMBOL(ieee80211_iter_keys);
 593
 594 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
 595 {
 596         struct ieee80211_key *key;
 597
 598         ASSERT_RTNL();
 599
 600         mutex_lock(&sdata->local->key_mtx);
 601
 602         list_for_each_entry(key, &sdata->key_list, list)
 603                 ieee80211_key_disable_hw_accel(key);
 604
 605         mutex_unlock(&sdata->local->key_mtx);
 606 }
 607
 608 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
 609 {
 610         struct ieee80211_key *key, *tmp;
 611
 612         mutex_lock(&sdata->local->key_mtx);
 613
 614         ieee80211_debugfs_key_remove_mgmt_default(sdata);
 615
 616         list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
 617                 __ieee80211_key_free(key);
 618
 619         ieee80211_debugfs_key_update_default(sdata);
 620
 621         mutex_unlock(&sdata->local->key_mtx);
 622 }
 623
 624
 625 void ieee80211_gtk_rekey_notify(struct ieee80211_vif *vif, const u8 *bssid,
 626                                 const u8 *replay_ctr, gfp_t gfp)
 627 {
 628         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 629
 630         trace_api_gtk_rekey_notify(sdata, bssid, replay_ctr);
 631
 632         cfg80211_gtk_rekey_notify(sdata->dev, bssid, replay_ctr, gfp);
 633 }
 634 EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_notify);
 635
 636 void ieee80211_get_key_tx_seq(struct ieee80211_key_conf *keyconf,
 637                               struct ieee80211_key_seq *seq)
 638 {
 639         struct ieee80211_key *key;
 640         u64 pn64;
 641
 642         if (WARN_ON(!(keyconf->flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
 643                 return;
 644
 645         key = container_of(keyconf, struct ieee80211_key, conf);
 646
 647         switch (key->conf.cipher) {
 648         case WLAN_CIPHER_SUITE_TKIP:
 649                 seq->tkip.iv32 = key->u.tkip.tx.iv32;
 650                 seq->tkip.iv16 = key->u.tkip.tx.iv16;
 651                 break;
 652         case WLAN_CIPHER_SUITE_CCMP:
 653                 pn64 = atomic64_read(&key->u.ccmp.tx_pn);
 654                 seq->ccmp.pn[5] = pn64;
 655                 seq->ccmp.pn[4] = pn64 >> 8;
 656                 seq->ccmp.pn[3] = pn64 >> 16;
 657                 seq->ccmp.pn[2] = pn64 >> 24;
 658                 seq->ccmp.pn[1] = pn64 >> 32;
 659                 seq->ccmp.pn[0] = pn64 >> 40;
 660                 break;
 661         case WLAN_CIPHER_SUITE_AES_CMAC:
 662                 pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
 663                 seq->ccmp.pn[5] = pn64;
 664                 seq->ccmp.pn[4] = pn64 >> 8;
 665                 seq->ccmp.pn[3] = pn64 >> 16;
 666                 seq->ccmp.pn[2] = pn64 >> 24;
 667                 seq->ccmp.pn[1] = pn64 >> 32;
 668                 seq->ccmp.pn[0] = pn64 >> 40;
 669                 break;
 670         default:
 671                 WARN_ON(1);
 672         }
 673 }
 674 EXPORT_SYMBOL(ieee80211_get_key_tx_seq);
 675
 676 void ieee80211_get_key_rx_seq(struct ieee80211_key_conf *keyconf,
 677                               int tid, struct ieee80211_key_seq *seq)
 678 {
 679         struct ieee80211_key *key;
 680         const u8 *pn;
 681
 682         key = container_of(keyconf, struct ieee80211_key, conf);
 683
 684         switch (key->conf.cipher) {
 685         case WLAN_CIPHER_SUITE_TKIP:
 686                 if (WARN_ON(tid < 0 || tid >= NUM_RX_DATA_QUEUES))
 687                         return;
 688                 seq->tkip.iv32 = key->u.tkip.rx[tid].iv32;
 689                 seq->tkip.iv16 = key->u.tkip.rx[tid].iv16;
 690                 break;
 691         case WLAN_CIPHER_SUITE_CCMP:
 692                 if (WARN_ON(tid < -1 || tid >= NUM_RX_DATA_QUEUES))
 693                         return;
 694                 if (tid < 0)
 695                         pn = key->u.ccmp.rx_pn[NUM_RX_DATA_QUEUES];
 696                 else
 697                         pn = key->u.ccmp.rx_pn[tid];
 698                 memcpy(seq->ccmp.pn, pn, CCMP_PN_LEN);
 699                 break;
 700         case WLAN_CIPHER_SUITE_AES_CMAC:
 701                 if (WARN_ON(tid != 0))
 702                         return;
 703                 pn = key->u.aes_cmac.rx_pn;
 704                 memcpy(seq->aes_cmac.pn, pn, CMAC_PN_LEN);
 705                 break;
 706         }
 707 }
 708 EXPORT_SYMBOL(ieee80211_get_key_rx_seq);