blob: 9c27c53cfae58a167ccf35d44f39b88e9fde5835 [file] [log] [blame]
Johannes Berg1f5a7e42007-07-27 15:43:23 +02001/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
Johannes Berg3b967662008-04-08 17:56:52 +02005 * Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net>
Johannes Berg1f5a7e42007-07-27 15:43:23 +02006 *
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
Johannes Berg11a843b2007-08-28 17:01:55 -040012#include <linux/if_ether.h>
13#include <linux/etherdevice.h>
14#include <linux/list.h>
Johannes Bergd4e46a32007-09-14 11:10:24 -040015#include <linux/rcupdate.h>
Johannes Bergdb4d1162008-02-25 16:27:45 +010016#include <linux/rtnetlink.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Johannes Berg1f5a7e42007-07-27 15:43:23 +020018#include <net/mac80211.h>
19#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020020#include "driver-ops.h"
Johannes Berg1f5a7e42007-07-27 15:43:23 +020021#include "debugfs_key.h"
22#include "aes_ccm.h"
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +020023#include "aes_cmac.h"
Johannes Berg1f5a7e42007-07-27 15:43:23 +020024
Johannes Berg11a843b2007-08-28 17:01:55 -040025
Johannes Bergdbbea672008-02-26 14:34:06 +010026/**
27 * DOC: Key handling basics
Johannes Berg11a843b2007-08-28 17:01:55 -040028 *
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 each key
34 * that is eligible the hardware is asked to enable that key but if
35 * it cannot do that they key is simply kept for software encryption.
36 * There is currently no way of knowing this except by looking into
37 * debugfs.
38 *
Johannes Bergad0e2b52010-06-01 10:19:19 +020039 * All key operations are protected internally.
Johannes Bergdb4d1162008-02-25 16:27:45 +010040 *
Johannes Berg3b967662008-04-08 17:56:52 +020041 * Within mac80211, key references are, just as STA structure references,
42 * protected by RCU. Note, however, that some things are unprotected,
43 * namely the key->sta dereferences within the hardware acceleration
Johannes Bergad0e2b52010-06-01 10:19:19 +020044 * functions. This means that sta_info_destroy() must remove the key
45 * which waits for an RCU grace period.
Johannes Berg11a843b2007-08-28 17:01:55 -040046 */
47
48static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Johannes Berg11a843b2007-08-28 17:01:55 -040049
Johannes Bergad0e2b52010-06-01 10:19:19 +020050static void assert_key_lock(struct ieee80211_local *local)
Johannes Berg3b967662008-04-08 17:56:52 +020051{
Johannes Bergad0e2b52010-06-01 10:19:19 +020052 WARN_ON(!mutex_is_locked(&local->key_mtx));
Johannes Berg3b967662008-04-08 17:56:52 +020053}
54
Johannes Bergdc822b52008-12-29 12:55:09 +010055static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
Johannes Berg11a843b2007-08-28 17:01:55 -040056{
Johannes Berg11a843b2007-08-28 17:01:55 -040057 if (key->sta)
Johannes Bergdc822b52008-12-29 12:55:09 +010058 return &key->sta->sta;
Johannes Berg11a843b2007-08-28 17:01:55 -040059
Johannes Bergdc822b52008-12-29 12:55:09 +010060 return NULL;
Johannes Berg11a843b2007-08-28 17:01:55 -040061}
62
63static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
64{
Johannes Bergdc822b52008-12-29 12:55:09 +010065 struct ieee80211_sub_if_data *sdata;
66 struct ieee80211_sta *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -040067 int ret;
68
Johannes Berg3b967662008-04-08 17:56:52 +020069 might_sleep();
70
Johannes Berg11a843b2007-08-28 17:01:55 -040071 if (!key->local->ops->set_key)
72 return;
73
Johannes Bergad0e2b52010-06-01 10:19:19 +020074 assert_key_lock(key->local);
75
Johannes Bergdc822b52008-12-29 12:55:09 +010076 sta = get_sta_for_key(key);
77
78 sdata = key->sdata;
79 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
80 sdata = container_of(sdata->bss,
81 struct ieee80211_sub_if_data,
82 u.ap);
Johannes Berg11a843b2007-08-28 17:01:55 -040083
Johannes Berg12375ef2009-11-25 20:30:31 +010084 ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -040085
Johannes Bergad0e2b52010-06-01 10:19:19 +020086 if (!ret)
Johannes Berg11a843b2007-08-28 17:01:55 -040087 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
88
89 if (ret && ret != -ENOSPC && ret != -EOPNOTSUPP)
90 printk(KERN_ERR "mac80211-%s: failed to set key "
Johannes Berg0c68ae262008-10-27 15:56:10 -070091 "(%d, %pM) to hardware (%d)\n",
Johannes Berg11a843b2007-08-28 17:01:55 -040092 wiphy_name(key->local->hw.wiphy),
Johannes Bergdc822b52008-12-29 12:55:09 +010093 key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
Johannes Berg11a843b2007-08-28 17:01:55 -040094}
95
96static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
97{
Johannes Bergdc822b52008-12-29 12:55:09 +010098 struct ieee80211_sub_if_data *sdata;
99 struct ieee80211_sta *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -0400100 int ret;
101
Johannes Berg3b967662008-04-08 17:56:52 +0200102 might_sleep();
103
Johannes Bergdb4d1162008-02-25 16:27:45 +0100104 if (!key || !key->local->ops->set_key)
Johannes Berg11a843b2007-08-28 17:01:55 -0400105 return;
106
Johannes Bergad0e2b52010-06-01 10:19:19 +0200107 assert_key_lock(key->local);
108
109 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
Johannes Berg11a843b2007-08-28 17:01:55 -0400110 return;
111
Johannes Bergdc822b52008-12-29 12:55:09 +0100112 sta = get_sta_for_key(key);
113 sdata = key->sdata;
114
115 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
116 sdata = container_of(sdata->bss,
117 struct ieee80211_sub_if_data,
118 u.ap);
Johannes Berg11a843b2007-08-28 17:01:55 -0400119
Johannes Berg12375ef2009-11-25 20:30:31 +0100120 ret = drv_set_key(key->local, DISABLE_KEY, sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200121 sta, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400122
123 if (ret)
124 printk(KERN_ERR "mac80211-%s: failed to remove key "
Johannes Berg0c68ae262008-10-27 15:56:10 -0700125 "(%d, %pM) from hardware (%d)\n",
Johannes Berg11a843b2007-08-28 17:01:55 -0400126 wiphy_name(key->local->hw.wiphy),
Johannes Bergdc822b52008-12-29 12:55:09 +0100127 key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
Johannes Berg11a843b2007-08-28 17:01:55 -0400128
Johannes Berg3b967662008-04-08 17:56:52 +0200129 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
Johannes Berg3b967662008-04-08 17:56:52 +0200130}
131
132static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
133 int idx)
134{
135 struct ieee80211_key *key = NULL;
136
Johannes Bergad0e2b52010-06-01 10:19:19 +0200137 assert_key_lock(sdata->local);
138
Johannes Berg3b967662008-04-08 17:56:52 +0200139 if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
140 key = sdata->keys[idx];
141
142 rcu_assign_pointer(sdata->default_key, key);
143
Johannes Bergad0e2b52010-06-01 10:19:19 +0200144 if (key) {
145 ieee80211_debugfs_key_remove_default(key->sdata);
146 ieee80211_debugfs_key_add_default(key->sdata);
147 }
Johannes Berg3b967662008-04-08 17:56:52 +0200148}
149
150void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx)
151{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200152 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200153 __ieee80211_set_default_key(sdata, idx);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200154 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200155}
156
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200157static void
158__ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
159{
160 struct ieee80211_key *key = NULL;
161
Johannes Bergad0e2b52010-06-01 10:19:19 +0200162 assert_key_lock(sdata->local);
163
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200164 if (idx >= NUM_DEFAULT_KEYS &&
165 idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
166 key = sdata->keys[idx];
167
168 rcu_assign_pointer(sdata->default_mgmt_key, key);
169
Johannes Bergad0e2b52010-06-01 10:19:19 +0200170 if (key) {
171 ieee80211_debugfs_key_remove_mgmt_default(key->sdata);
172 ieee80211_debugfs_key_add_mgmt_default(key->sdata);
173 }
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200174}
175
176void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
177 int idx)
178{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200179 mutex_lock(&sdata->local->key_mtx);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200180 __ieee80211_set_default_mgmt_key(sdata, idx);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200181 mutex_unlock(&sdata->local->key_mtx);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200182}
183
Johannes Berg3b967662008-04-08 17:56:52 +0200184
185static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
186 struct sta_info *sta,
187 struct ieee80211_key *old,
188 struct ieee80211_key *new)
189{
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200190 int idx, defkey, defmgmtkey;
Johannes Berg3b967662008-04-08 17:56:52 +0200191
192 if (new)
193 list_add(&new->list, &sdata->key_list);
194
195 if (sta) {
196 rcu_assign_pointer(sta->key, new);
197 } else {
198 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
199
200 if (old)
201 idx = old->conf.keyidx;
202 else
203 idx = new->conf.keyidx;
204
205 defkey = old && sdata->default_key == old;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200206 defmgmtkey = old && sdata->default_mgmt_key == old;
Johannes Berg3b967662008-04-08 17:56:52 +0200207
208 if (defkey && !new)
209 __ieee80211_set_default_key(sdata, -1);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200210 if (defmgmtkey && !new)
211 __ieee80211_set_default_mgmt_key(sdata, -1);
Johannes Berg3b967662008-04-08 17:56:52 +0200212
213 rcu_assign_pointer(sdata->keys[idx], new);
214 if (defkey && new)
215 __ieee80211_set_default_key(sdata, new->conf.keyidx);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200216 if (defmgmtkey && new)
217 __ieee80211_set_default_mgmt_key(sdata,
218 new->conf.keyidx);
Johannes Berg3b967662008-04-08 17:56:52 +0200219 }
220
221 if (old) {
222 /*
223 * We'll use an empty list to indicate that the key
224 * has already been removed.
225 */
226 list_del_init(&old->list);
227 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400228}
229
Johannes Berg97359d12010-08-10 09:46:38 +0200230struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300231 const u8 *key_data,
232 size_t seq_len, const u8 *seq)
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200233{
234 struct ieee80211_key *key;
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100235 int i, j, err;
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200236
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200237 BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
Johannes Berg11a843b2007-08-28 17:01:55 -0400238
239 key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200240 if (!key)
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100241 return ERR_PTR(-ENOMEM);
Johannes Berg11a843b2007-08-28 17:01:55 -0400242
243 /*
244 * Default to software encryption; we'll later upload the
245 * key to the hardware if possible.
246 */
Johannes Berg11a843b2007-08-28 17:01:55 -0400247 key->conf.flags = 0;
248 key->flags = 0;
249
Johannes Berg97359d12010-08-10 09:46:38 +0200250 key->conf.cipher = cipher;
Johannes Berg11a843b2007-08-28 17:01:55 -0400251 key->conf.keyidx = idx;
252 key->conf.keylen = key_len;
Johannes Berg97359d12010-08-10 09:46:38 +0200253 switch (cipher) {
254 case WLAN_CIPHER_SUITE_WEP40:
255 case WLAN_CIPHER_SUITE_WEP104:
Felix Fietkau76708de2008-10-05 18:02:48 +0200256 key->conf.iv_len = WEP_IV_LEN;
257 key->conf.icv_len = WEP_ICV_LEN;
258 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200259 case WLAN_CIPHER_SUITE_TKIP:
Felix Fietkau76708de2008-10-05 18:02:48 +0200260 key->conf.iv_len = TKIP_IV_LEN;
261 key->conf.icv_len = TKIP_ICV_LEN;
Jouni Malinen9f26a952009-05-15 12:38:32 +0300262 if (seq) {
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300263 for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
264 key->u.tkip.rx[i].iv32 =
265 get_unaligned_le32(&seq[2]);
266 key->u.tkip.rx[i].iv16 =
267 get_unaligned_le16(seq);
268 }
269 }
Felix Fietkau76708de2008-10-05 18:02:48 +0200270 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200271 case WLAN_CIPHER_SUITE_CCMP:
Felix Fietkau76708de2008-10-05 18:02:48 +0200272 key->conf.iv_len = CCMP_HDR_LEN;
273 key->conf.icv_len = CCMP_MIC_LEN;
Jouni Malinen9f26a952009-05-15 12:38:32 +0300274 if (seq) {
Jouni Malinen91902522010-06-11 10:27:33 -0700275 for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300276 for (j = 0; j < CCMP_PN_LEN; j++)
277 key->u.ccmp.rx_pn[i][j] =
278 seq[CCMP_PN_LEN - j - 1];
279 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400280 /*
281 * Initialize AES key state here as an optimization so that
282 * it does not need to be initialized for every packet.
283 */
284 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100285 if (IS_ERR(key->u.ccmp.tfm)) {
286 err = PTR_ERR(key->u.ccmp.tfm);
Johannes Berg3b967662008-04-08 17:56:52 +0200287 kfree(key);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100288 key = ERR_PTR(err);
Johannes Berg11a843b2007-08-28 17:01:55 -0400289 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200290 break;
291 case WLAN_CIPHER_SUITE_AES_CMAC:
292 key->conf.iv_len = 0;
293 key->conf.icv_len = sizeof(struct ieee80211_mmie);
294 if (seq)
295 for (j = 0; j < 6; j++)
296 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200297 /*
298 * Initialize AES key state here as an optimization so that
299 * it does not need to be initialized for every packet.
300 */
301 key->u.aes_cmac.tfm =
302 ieee80211_aes_cmac_key_setup(key_data);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100303 if (IS_ERR(key->u.aes_cmac.tfm)) {
304 err = PTR_ERR(key->u.aes_cmac.tfm);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200305 kfree(key);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100306 key = ERR_PTR(err);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200307 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200308 break;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200309 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200310 memcpy(key->conf.key, key_data, key_len);
311 INIT_LIST_HEAD(&key->list);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200312
Johannes Bergdb4d1162008-02-25 16:27:45 +0100313 return key;
314}
Johannes Berg11a843b2007-08-28 17:01:55 -0400315
Johannes Bergad0e2b52010-06-01 10:19:19 +0200316static void __ieee80211_key_destroy(struct ieee80211_key *key)
317{
318 if (!key)
319 return;
320
Jouni Malinen32162a42010-07-26 15:52:03 -0700321 if (key->local)
322 ieee80211_key_disable_hw_accel(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200323
Johannes Berg97359d12010-08-10 09:46:38 +0200324 if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
Johannes Bergad0e2b52010-06-01 10:19:19 +0200325 ieee80211_aes_key_free(key->u.ccmp.tfm);
Johannes Berg97359d12010-08-10 09:46:38 +0200326 if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
Johannes Bergad0e2b52010-06-01 10:19:19 +0200327 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
Jouni Malinen32162a42010-07-26 15:52:03 -0700328 if (key->local)
329 ieee80211_debugfs_key_remove(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200330
331 kfree(key);
332}
333
Johannes Bergdb4d1162008-02-25 16:27:45 +0100334void ieee80211_key_link(struct ieee80211_key *key,
335 struct ieee80211_sub_if_data *sdata,
336 struct sta_info *sta)
337{
338 struct ieee80211_key *old_key;
339 int idx;
340
Johannes Bergdb4d1162008-02-25 16:27:45 +0100341 BUG_ON(!sdata);
342 BUG_ON(!key);
343
344 idx = key->conf.keyidx;
345 key->local = sdata->local;
346 key->sdata = sdata;
347 key->sta = sta;
348
Johannes Berg11a843b2007-08-28 17:01:55 -0400349 if (sta) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400350 /*
351 * some hardware cannot handle TKIP with QoS, so
352 * we indicate whether QoS could be in use.
353 */
Johannes Berg07346f812008-05-03 01:02:02 +0200354 if (test_sta_flags(sta, WLAN_STA_WME))
Johannes Berg11a843b2007-08-28 17:01:55 -0400355 key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
Ivo van Doornc6adbd22008-04-17 21:11:18 +0200356
357 /*
358 * This key is for a specific sta interface,
359 * inform the driver that it should try to store
360 * this key as pairwise key.
361 */
362 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
Johannes Berg11a843b2007-08-28 17:01:55 -0400363 } else {
Johannes Berg05c914f2008-09-11 00:01:58 +0200364 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400365 struct sta_info *ap;
366
Johannes Berg3b967662008-04-08 17:56:52 +0200367 /*
368 * We're getting a sta pointer in,
369 * so must be under RCU read lock.
370 */
Johannes Bergd0709a62008-02-25 16:27:46 +0100371
Johannes Berg11a843b2007-08-28 17:01:55 -0400372 /* same here, the AP could be using QoS */
Johannes Bergabe60632009-11-25 17:46:18 +0100373 ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
Johannes Berg11a843b2007-08-28 17:01:55 -0400374 if (ap) {
Johannes Berg07346f812008-05-03 01:02:02 +0200375 if (test_sta_flags(ap, WLAN_STA_WME))
Johannes Berg11a843b2007-08-28 17:01:55 -0400376 key->conf.flags |=
377 IEEE80211_KEY_FLAG_WMM_STA;
Johannes Berg11a843b2007-08-28 17:01:55 -0400378 }
379 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400380 }
381
Johannes Bergad0e2b52010-06-01 10:19:19 +0200382 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200383
Johannes Bergd4e46a32007-09-14 11:10:24 -0400384 if (sta)
Johannes Bergdb4d1162008-02-25 16:27:45 +0100385 old_key = sta->key;
Johannes Bergd4e46a32007-09-14 11:10:24 -0400386 else
Johannes Bergdb4d1162008-02-25 16:27:45 +0100387 old_key = sdata->keys[idx];
388
389 __ieee80211_key_replace(sdata, sta, old_key, key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200390 __ieee80211_key_destroy(old_key);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400391
Johannes Bergad0e2b52010-06-01 10:19:19 +0200392 ieee80211_debugfs_key_add(key);
Johannes Berg3b967662008-04-08 17:56:52 +0200393
Johannes Bergad0e2b52010-06-01 10:19:19 +0200394 ieee80211_key_enable_hw_accel(key);
Johannes Berg523d2f62009-07-01 21:26:43 +0200395
Johannes Bergad0e2b52010-06-01 10:19:19 +0200396 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3a245762008-04-09 16:45:37 +0200397}
398
399static void __ieee80211_key_free(struct ieee80211_key *key)
400{
401 /*
402 * Replace key with nothingness if it was ever used.
403 */
404 if (key->sdata)
405 __ieee80211_key_replace(key->sdata, key->sta,
406 key, NULL);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200407 __ieee80211_key_destroy(key);
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200408}
409
Jouni Malinen32162a42010-07-26 15:52:03 -0700410void ieee80211_key_free(struct ieee80211_local *local,
411 struct ieee80211_key *key)
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200412{
Johannes Berg8f371712007-08-28 17:01:54 -0400413 if (!key)
414 return;
415
Johannes Bergad0e2b52010-06-01 10:19:19 +0200416 mutex_lock(&local->key_mtx);
Johannes Berg3a245762008-04-09 16:45:37 +0200417 __ieee80211_key_free(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200418 mutex_unlock(&local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200419}
420
421void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
422{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200423 struct ieee80211_key *key;
424
Johannes Berg3a245762008-04-09 16:45:37 +0200425 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200426
Johannes Berg9607e6b2009-12-23 13:15:31 +0100427 if (WARN_ON(!ieee80211_sdata_running(sdata)))
Johannes Berg3b967662008-04-08 17:56:52 +0200428 return;
429
Johannes Bergad0e2b52010-06-01 10:19:19 +0200430 mutex_lock(&sdata->local->key_mtx);
431
432 list_for_each_entry(key, &sdata->key_list, list)
433 ieee80211_key_enable_hw_accel(key);
434
435 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200436}
437
438void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
439{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200440 struct ieee80211_key *key;
441
Johannes Berg3a245762008-04-09 16:45:37 +0200442 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200443
Johannes Bergad0e2b52010-06-01 10:19:19 +0200444 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200445
Johannes Bergad0e2b52010-06-01 10:19:19 +0200446 list_for_each_entry(key, &sdata->key_list, list)
447 ieee80211_key_disable_hw_accel(key);
Johannes Berg3b967662008-04-08 17:56:52 +0200448
Johannes Bergad0e2b52010-06-01 10:19:19 +0200449 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg11a843b2007-08-28 17:01:55 -0400450}
451
452void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
453{
454 struct ieee80211_key *key, *tmp;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100455
Johannes Bergad0e2b52010-06-01 10:19:19 +0200456 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200457
458 ieee80211_debugfs_key_remove_default(sdata);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200459 ieee80211_debugfs_key_remove_mgmt_default(sdata);
Johannes Berg11a843b2007-08-28 17:01:55 -0400460
461 list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
Johannes Berg3a245762008-04-09 16:45:37 +0200462 __ieee80211_key_free(key);
Johannes Berg11a843b2007-08-28 17:01:55 -0400463
Johannes Bergad0e2b52010-06-01 10:19:19 +0200464 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg11a843b2007-08-28 17:01:55 -0400465}