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