blob: 687acf23054d9ecfefeaa810d360020e360a3a83 [file] [log] [blame]
Johannes Berg1f5a7e472007-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 Berg1f5a7e472007-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>
Johannes Berg1f5a7e472007-07-27 15:43:23 +020017#include <net/mac80211.h>
18#include "ieee80211_i.h"
19#include "debugfs_key.h"
20#include "aes_ccm.h"
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +020021#include "aes_cmac.h"
Johannes Berg1f5a7e472007-07-27 15:43:23 +020022
Johannes Berg11a843b2007-08-28 17:01:55 -040023
Johannes Bergdbbea672008-02-26 14:34:06 +010024/**
25 * DOC: Key handling basics
Johannes Berg11a843b2007-08-28 17:01:55 -040026 *
27 * Key handling in mac80211 is done based on per-interface (sub_if_data)
28 * keys and per-station keys. Since each station belongs to an interface,
29 * each station key also belongs to that interface.
30 *
31 * Hardware acceleration is done on a best-effort basis, for each key
32 * that is eligible the hardware is asked to enable that key but if
33 * it cannot do that they key is simply kept for software encryption.
34 * There is currently no way of knowing this except by looking into
35 * debugfs.
36 *
Johannes Berg3b967662008-04-08 17:56:52 +020037 * All key operations are protected internally so you can call them at
38 * any time.
Johannes Bergdb4d1162008-02-25 16:27:45 +010039 *
Johannes Berg3b967662008-04-08 17:56:52 +020040 * Within mac80211, key references are, just as STA structure references,
41 * protected by RCU. Note, however, that some things are unprotected,
42 * namely the key->sta dereferences within the hardware acceleration
43 * functions. This means that sta_info_destroy() must flush the key todo
44 * list.
45 *
46 * All the direct key list manipulation functions must not sleep because
47 * they can operate on STA info structs that are protected by RCU.
Johannes Berg11a843b2007-08-28 17:01:55 -040048 */
49
50static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Johannes Berg11a843b2007-08-28 17:01:55 -040051
Johannes Berg3b967662008-04-08 17:56:52 +020052/* key mutex: used to synchronise todo runners */
53static DEFINE_MUTEX(key_mutex);
54static DEFINE_SPINLOCK(todo_lock);
55static LIST_HEAD(todo_list);
56
57static void key_todo(struct work_struct *work)
58{
59 ieee80211_key_todo();
60}
61
62static DECLARE_WORK(todo_work, key_todo);
63
64/**
65 * add_todo - add todo item for a key
66 *
67 * @key: key to add to do item for
68 * @flag: todo flag(s)
69 */
70static void add_todo(struct ieee80211_key *key, u32 flag)
71{
72 if (!key)
73 return;
74
75 spin_lock(&todo_lock);
76 key->flags |= flag;
Johannes Berg245cbe72008-04-13 10:43:50 +020077 /*
78 * Remove again if already on the list so that we move it to the end.
79 */
80 if (!list_empty(&key->todo))
81 list_del(&key->todo);
82 list_add_tail(&key->todo, &todo_list);
Johannes Berg3b967662008-04-08 17:56:52 +020083 schedule_work(&todo_work);
84 spin_unlock(&todo_lock);
85}
86
87/**
88 * ieee80211_key_lock - lock the mac80211 key operation lock
89 *
90 * This locks the (global) mac80211 key operation lock, all
91 * key operations must be done under this lock.
92 */
93static void ieee80211_key_lock(void)
94{
95 mutex_lock(&key_mutex);
96}
97
98/**
99 * ieee80211_key_unlock - unlock the mac80211 key operation lock
100 */
101static void ieee80211_key_unlock(void)
102{
103 mutex_unlock(&key_mutex);
104}
105
106static void assert_key_lock(void)
107{
108 WARN_ON(!mutex_is_locked(&key_mutex));
109}
110
Johannes Bergdc822b52008-12-29 12:55:09 +0100111static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
Johannes Berg11a843b2007-08-28 17:01:55 -0400112{
Johannes Berg11a843b2007-08-28 17:01:55 -0400113 if (key->sta)
Johannes Bergdc822b52008-12-29 12:55:09 +0100114 return &key->sta->sta;
Johannes Berg11a843b2007-08-28 17:01:55 -0400115
Johannes Bergdc822b52008-12-29 12:55:09 +0100116 return NULL;
Johannes Berg11a843b2007-08-28 17:01:55 -0400117}
118
119static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
120{
Johannes Bergdc822b52008-12-29 12:55:09 +0100121 struct ieee80211_sub_if_data *sdata;
122 struct ieee80211_sta *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -0400123 int ret;
124
Johannes Berg3b967662008-04-08 17:56:52 +0200125 assert_key_lock();
126 might_sleep();
127
Johannes Berg11a843b2007-08-28 17:01:55 -0400128 if (!key->local->ops->set_key)
129 return;
130
Johannes Bergdc822b52008-12-29 12:55:09 +0100131 sta = get_sta_for_key(key);
132
133 sdata = key->sdata;
134 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
135 sdata = container_of(sdata->bss,
136 struct ieee80211_sub_if_data,
137 u.ap);
Johannes Berg11a843b2007-08-28 17:01:55 -0400138
139 ret = key->local->ops->set_key(local_to_hw(key->local), SET_KEY,
Johannes Bergdc822b52008-12-29 12:55:09 +0100140 &sdata->vif, sta, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400141
Johannes Berg3b967662008-04-08 17:56:52 +0200142 if (!ret) {
143 spin_lock(&todo_lock);
Johannes Berg11a843b2007-08-28 17:01:55 -0400144 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
Johannes Berg3b967662008-04-08 17:56:52 +0200145 spin_unlock(&todo_lock);
146 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400147
148 if (ret && ret != -ENOSPC && ret != -EOPNOTSUPP)
149 printk(KERN_ERR "mac80211-%s: failed to set key "
Johannes Berg0c68ae262008-10-27 15:56:10 -0700150 "(%d, %pM) to hardware (%d)\n",
Johannes Berg11a843b2007-08-28 17:01:55 -0400151 wiphy_name(key->local->hw.wiphy),
Johannes Bergdc822b52008-12-29 12:55:09 +0100152 key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
Johannes Berg11a843b2007-08-28 17:01:55 -0400153}
154
155static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
156{
Johannes Bergdc822b52008-12-29 12:55:09 +0100157 struct ieee80211_sub_if_data *sdata;
158 struct ieee80211_sta *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -0400159 int ret;
160
Johannes Berg3b967662008-04-08 17:56:52 +0200161 assert_key_lock();
162 might_sleep();
163
Johannes Bergdb4d1162008-02-25 16:27:45 +0100164 if (!key || !key->local->ops->set_key)
Johannes Berg11a843b2007-08-28 17:01:55 -0400165 return;
166
Johannes Berg3b967662008-04-08 17:56:52 +0200167 spin_lock(&todo_lock);
168 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) {
169 spin_unlock(&todo_lock);
Johannes Berg11a843b2007-08-28 17:01:55 -0400170 return;
Johannes Berg3b967662008-04-08 17:56:52 +0200171 }
172 spin_unlock(&todo_lock);
Johannes Berg11a843b2007-08-28 17:01:55 -0400173
Johannes Bergdc822b52008-12-29 12:55:09 +0100174 sta = get_sta_for_key(key);
175 sdata = key->sdata;
176
177 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
178 sdata = container_of(sdata->bss,
179 struct ieee80211_sub_if_data,
180 u.ap);
Johannes Berg11a843b2007-08-28 17:01:55 -0400181
182 ret = key->local->ops->set_key(local_to_hw(key->local), DISABLE_KEY,
Johannes Bergdc822b52008-12-29 12:55:09 +0100183 &sdata->vif, sta, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400184
185 if (ret)
186 printk(KERN_ERR "mac80211-%s: failed to remove key "
Johannes Berg0c68ae262008-10-27 15:56:10 -0700187 "(%d, %pM) from hardware (%d)\n",
Johannes Berg11a843b2007-08-28 17:01:55 -0400188 wiphy_name(key->local->hw.wiphy),
Johannes Bergdc822b52008-12-29 12:55:09 +0100189 key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
Johannes Berg11a843b2007-08-28 17:01:55 -0400190
Johannes Berg3b967662008-04-08 17:56:52 +0200191 spin_lock(&todo_lock);
192 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
193 spin_unlock(&todo_lock);
194}
195
196static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
197 int idx)
198{
199 struct ieee80211_key *key = NULL;
200
201 if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
202 key = sdata->keys[idx];
203
204 rcu_assign_pointer(sdata->default_key, key);
205
206 if (key)
207 add_todo(key, KEY_FLAG_TODO_DEFKEY);
208}
209
210void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx)
211{
212 unsigned long flags;
213
Johannes Bergb16bd152008-04-11 21:40:35 +0200214 spin_lock_irqsave(&sdata->local->key_lock, flags);
Johannes Berg3b967662008-04-08 17:56:52 +0200215 __ieee80211_set_default_key(sdata, idx);
Johannes Bergb16bd152008-04-11 21:40:35 +0200216 spin_unlock_irqrestore(&sdata->local->key_lock, flags);
Johannes Berg3b967662008-04-08 17:56:52 +0200217}
218
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200219static void
220__ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
221{
222 struct ieee80211_key *key = NULL;
223
224 if (idx >= NUM_DEFAULT_KEYS &&
225 idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
226 key = sdata->keys[idx];
227
228 rcu_assign_pointer(sdata->default_mgmt_key, key);
229
230 if (key)
231 add_todo(key, KEY_FLAG_TODO_DEFMGMTKEY);
232}
233
234void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
235 int idx)
236{
237 unsigned long flags;
238
239 spin_lock_irqsave(&sdata->local->key_lock, flags);
240 __ieee80211_set_default_mgmt_key(sdata, idx);
241 spin_unlock_irqrestore(&sdata->local->key_lock, flags);
242}
243
Johannes Berg3b967662008-04-08 17:56:52 +0200244
245static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
246 struct sta_info *sta,
247 struct ieee80211_key *old,
248 struct ieee80211_key *new)
249{
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200250 int idx, defkey, defmgmtkey;
Johannes Berg3b967662008-04-08 17:56:52 +0200251
252 if (new)
253 list_add(&new->list, &sdata->key_list);
254
255 if (sta) {
256 rcu_assign_pointer(sta->key, new);
257 } else {
258 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
259
260 if (old)
261 idx = old->conf.keyidx;
262 else
263 idx = new->conf.keyidx;
264
265 defkey = old && sdata->default_key == old;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200266 defmgmtkey = old && sdata->default_mgmt_key == old;
Johannes Berg3b967662008-04-08 17:56:52 +0200267
268 if (defkey && !new)
269 __ieee80211_set_default_key(sdata, -1);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200270 if (defmgmtkey && !new)
271 __ieee80211_set_default_mgmt_key(sdata, -1);
Johannes Berg3b967662008-04-08 17:56:52 +0200272
273 rcu_assign_pointer(sdata->keys[idx], new);
274 if (defkey && new)
275 __ieee80211_set_default_key(sdata, new->conf.keyidx);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200276 if (defmgmtkey && new)
277 __ieee80211_set_default_mgmt_key(sdata,
278 new->conf.keyidx);
Johannes Berg3b967662008-04-08 17:56:52 +0200279 }
280
281 if (old) {
282 /*
283 * We'll use an empty list to indicate that the key
284 * has already been removed.
285 */
286 list_del_init(&old->list);
287 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400288}
289
Johannes Bergdb4d1162008-02-25 16:27:45 +0100290struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
Johannes Berg11a843b2007-08-28 17:01:55 -0400291 int idx,
292 size_t key_len,
293 const u8 *key_data)
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200294{
295 struct ieee80211_key *key;
296
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200297 BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
Johannes Berg11a843b2007-08-28 17:01:55 -0400298
299 key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200300 if (!key)
301 return NULL;
Johannes Berg11a843b2007-08-28 17:01:55 -0400302
303 /*
304 * Default to software encryption; we'll later upload the
305 * key to the hardware if possible.
306 */
Johannes Berg11a843b2007-08-28 17:01:55 -0400307 key->conf.flags = 0;
308 key->flags = 0;
309
310 key->conf.alg = alg;
311 key->conf.keyidx = idx;
312 key->conf.keylen = key_len;
Felix Fietkau76708de2008-10-05 18:02:48 +0200313 switch (alg) {
314 case ALG_WEP:
315 key->conf.iv_len = WEP_IV_LEN;
316 key->conf.icv_len = WEP_ICV_LEN;
317 break;
318 case ALG_TKIP:
319 key->conf.iv_len = TKIP_IV_LEN;
320 key->conf.icv_len = TKIP_ICV_LEN;
321 break;
322 case ALG_CCMP:
323 key->conf.iv_len = CCMP_HDR_LEN;
324 key->conf.icv_len = CCMP_MIC_LEN;
325 break;
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200326 case ALG_AES_CMAC:
327 key->conf.iv_len = 0;
328 key->conf.icv_len = sizeof(struct ieee80211_mmie);
329 break;
Felix Fietkau76708de2008-10-05 18:02:48 +0200330 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400331 memcpy(key->conf.key, key_data, key_len);
Johannes Berge48618292008-02-27 13:39:00 +0100332 INIT_LIST_HEAD(&key->list);
Johannes Berg3b967662008-04-08 17:56:52 +0200333 INIT_LIST_HEAD(&key->todo);
Johannes Berg11a843b2007-08-28 17:01:55 -0400334
Johannes Berg11a843b2007-08-28 17:01:55 -0400335 if (alg == ALG_CCMP) {
336 /*
337 * Initialize AES key state here as an optimization so that
338 * it does not need to be initialized for every packet.
339 */
340 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
341 if (!key->u.ccmp.tfm) {
Johannes Berg3b967662008-04-08 17:56:52 +0200342 kfree(key);
Johannes Berg11a843b2007-08-28 17:01:55 -0400343 return NULL;
344 }
345 }
346
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200347 if (alg == ALG_AES_CMAC) {
348 /*
349 * Initialize AES key state here as an optimization so that
350 * it does not need to be initialized for every packet.
351 */
352 key->u.aes_cmac.tfm =
353 ieee80211_aes_cmac_key_setup(key_data);
354 if (!key->u.aes_cmac.tfm) {
355 kfree(key);
356 return NULL;
357 }
358 }
359
Johannes Bergdb4d1162008-02-25 16:27:45 +0100360 return key;
361}
Johannes Berg11a843b2007-08-28 17:01:55 -0400362
Johannes Bergdb4d1162008-02-25 16:27:45 +0100363void ieee80211_key_link(struct ieee80211_key *key,
364 struct ieee80211_sub_if_data *sdata,
365 struct sta_info *sta)
366{
367 struct ieee80211_key *old_key;
Johannes Berg3b967662008-04-08 17:56:52 +0200368 unsigned long flags;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100369 int idx;
370
Johannes Bergdb4d1162008-02-25 16:27:45 +0100371 BUG_ON(!sdata);
372 BUG_ON(!key);
373
374 idx = key->conf.keyidx;
375 key->local = sdata->local;
376 key->sdata = sdata;
377 key->sta = sta;
378
Johannes Berg11a843b2007-08-28 17:01:55 -0400379 if (sta) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400380 /*
381 * some hardware cannot handle TKIP with QoS, so
382 * we indicate whether QoS could be in use.
383 */
Johannes Berg07346f812008-05-03 01:02:02 +0200384 if (test_sta_flags(sta, WLAN_STA_WME))
Johannes Berg11a843b2007-08-28 17:01:55 -0400385 key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
Ivo van Doornc6adbd22008-04-17 21:11:18 +0200386
387 /*
388 * This key is for a specific sta interface,
389 * inform the driver that it should try to store
390 * this key as pairwise key.
391 */
392 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
Johannes Berg11a843b2007-08-28 17:01:55 -0400393 } else {
Johannes Berg05c914f2008-09-11 00:01:58 +0200394 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400395 struct sta_info *ap;
396
Johannes Berg3b967662008-04-08 17:56:52 +0200397 /*
398 * We're getting a sta pointer in,
399 * so must be under RCU read lock.
400 */
Johannes Bergd0709a62008-02-25 16:27:46 +0100401
Johannes Berg11a843b2007-08-28 17:01:55 -0400402 /* same here, the AP could be using QoS */
Johannes Berg46900292009-02-15 12:44:28 +0100403 ap = sta_info_get(key->local, key->sdata->u.mgd.bssid);
Johannes Berg11a843b2007-08-28 17:01:55 -0400404 if (ap) {
Johannes Berg07346f812008-05-03 01:02:02 +0200405 if (test_sta_flags(ap, WLAN_STA_WME))
Johannes Berg11a843b2007-08-28 17:01:55 -0400406 key->conf.flags |=
407 IEEE80211_KEY_FLAG_WMM_STA;
Johannes Berg11a843b2007-08-28 17:01:55 -0400408 }
409 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400410 }
411
Johannes Bergb16bd152008-04-11 21:40:35 +0200412 spin_lock_irqsave(&sdata->local->key_lock, flags);
Johannes Berg3b967662008-04-08 17:56:52 +0200413
Johannes Bergd4e46a32007-09-14 11:10:24 -0400414 if (sta)
Johannes Bergdb4d1162008-02-25 16:27:45 +0100415 old_key = sta->key;
Johannes Bergd4e46a32007-09-14 11:10:24 -0400416 else
Johannes Bergdb4d1162008-02-25 16:27:45 +0100417 old_key = sdata->keys[idx];
418
419 __ieee80211_key_replace(sdata, sta, old_key, key);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400420
Johannes Bergb16bd152008-04-11 21:40:35 +0200421 spin_unlock_irqrestore(&sdata->local->key_lock, flags);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400422
Johannes Berg3b967662008-04-08 17:56:52 +0200423 /* free old key later */
424 add_todo(old_key, KEY_FLAG_TODO_DELETE);
425
426 add_todo(key, KEY_FLAG_TODO_ADD_DEBUGFS);
Johannes Berge48618292008-02-27 13:39:00 +0100427 if (netif_running(sdata->dev))
Johannes Berg3a245762008-04-09 16:45:37 +0200428 add_todo(key, KEY_FLAG_TODO_HWACCEL_ADD);
429}
430
431static void __ieee80211_key_free(struct ieee80211_key *key)
432{
433 /*
434 * Replace key with nothingness if it was ever used.
435 */
436 if (key->sdata)
437 __ieee80211_key_replace(key->sdata, key->sta,
438 key, NULL);
439
440 add_todo(key, KEY_FLAG_TODO_DELETE);
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200441}
442
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200443void ieee80211_key_free(struct ieee80211_key *key)
444{
Johannes Berg3b967662008-04-08 17:56:52 +0200445 unsigned long flags;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100446
Johannes Berg8f371712007-08-28 17:01:54 -0400447 if (!key)
448 return;
449
Emmanuel Grumbach00eb7fe2008-06-26 12:13:46 +0300450 if (!key->sdata) {
451 /* The key has not been linked yet, simply free it
452 * and don't Oops */
453 if (key->conf.alg == ALG_CCMP)
454 ieee80211_aes_key_free(key->u.ccmp.tfm);
455 kfree(key);
456 return;
457 }
458
Johannes Bergb16bd152008-04-11 21:40:35 +0200459 spin_lock_irqsave(&key->sdata->local->key_lock, flags);
Johannes Berg3a245762008-04-09 16:45:37 +0200460 __ieee80211_key_free(key);
Johannes Bergb16bd152008-04-11 21:40:35 +0200461 spin_unlock_irqrestore(&key->sdata->local->key_lock, flags);
Johannes Berg3a245762008-04-09 16:45:37 +0200462}
Johannes Berg11a843b2007-08-28 17:01:55 -0400463
Johannes Berg3a245762008-04-09 16:45:37 +0200464/*
465 * To be safe against concurrent manipulations of the list (which shouldn't
466 * actually happen) we need to hold the spinlock. But under the spinlock we
467 * can't actually do much, so we defer processing to the todo list. Then run
468 * the todo list to be sure the operation and possibly previously pending
469 * operations are completed.
470 */
471static void ieee80211_todo_for_each_key(struct ieee80211_sub_if_data *sdata,
472 u32 todo_flags)
473{
474 struct ieee80211_key *key;
475 unsigned long flags;
476
477 might_sleep();
478
Johannes Bergb16bd152008-04-11 21:40:35 +0200479 spin_lock_irqsave(&sdata->local->key_lock, flags);
Johannes Berg3a245762008-04-09 16:45:37 +0200480 list_for_each_entry(key, &sdata->key_list, list)
481 add_todo(key, todo_flags);
Johannes Bergb16bd152008-04-11 21:40:35 +0200482 spin_unlock_irqrestore(&sdata->local->key_lock, flags);
Johannes Berg3a245762008-04-09 16:45:37 +0200483
484 ieee80211_key_todo();
Johannes Berg3b967662008-04-08 17:56:52 +0200485}
486
487void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
488{
Johannes Berg3a245762008-04-09 16:45:37 +0200489 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200490
491 if (WARN_ON(!netif_running(sdata->dev)))
492 return;
493
Johannes Berg3a245762008-04-09 16:45:37 +0200494 ieee80211_todo_for_each_key(sdata, KEY_FLAG_TODO_HWACCEL_ADD);
Johannes Berg3b967662008-04-08 17:56:52 +0200495}
496
497void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
498{
Johannes Berg3a245762008-04-09 16:45:37 +0200499 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200500
Johannes Berg3a245762008-04-09 16:45:37 +0200501 ieee80211_todo_for_each_key(sdata, KEY_FLAG_TODO_HWACCEL_REMOVE);
Johannes Berg3b967662008-04-08 17:56:52 +0200502}
503
Johannes Berg3a245762008-04-09 16:45:37 +0200504static void __ieee80211_key_destroy(struct ieee80211_key *key)
Johannes Berg3b967662008-04-08 17:56:52 +0200505{
506 if (!key)
507 return;
508
509 ieee80211_key_disable_hw_accel(key);
510
Johannes Berg8f371712007-08-28 17:01:54 -0400511 if (key->conf.alg == ALG_CCMP)
512 ieee80211_aes_key_free(key->u.ccmp.tfm);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200513 if (key->conf.alg == ALG_AES_CMAC)
514 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
Johannes Berg8f371712007-08-28 17:01:54 -0400515 ieee80211_debugfs_key_remove(key);
Johannes Berg11a843b2007-08-28 17:01:55 -0400516
Johannes Berg8f371712007-08-28 17:01:54 -0400517 kfree(key);
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200518}
Johannes Berg11a843b2007-08-28 17:01:55 -0400519
Johannes Berg3b967662008-04-08 17:56:52 +0200520static void __ieee80211_key_todo(void)
Johannes Berg11a843b2007-08-28 17:01:55 -0400521{
Johannes Berg3b967662008-04-08 17:56:52 +0200522 struct ieee80211_key *key;
523 bool work_done;
524 u32 todoflags;
Johannes Berg11a843b2007-08-28 17:01:55 -0400525
Johannes Berg3b967662008-04-08 17:56:52 +0200526 /*
527 * NB: sta_info_destroy relies on this!
528 */
529 synchronize_rcu();
Johannes Berg11a843b2007-08-28 17:01:55 -0400530
Johannes Berg3b967662008-04-08 17:56:52 +0200531 spin_lock(&todo_lock);
532 while (!list_empty(&todo_list)) {
533 key = list_first_entry(&todo_list, struct ieee80211_key, todo);
534 list_del_init(&key->todo);
535 todoflags = key->flags & (KEY_FLAG_TODO_ADD_DEBUGFS |
536 KEY_FLAG_TODO_DEFKEY |
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200537 KEY_FLAG_TODO_DEFMGMTKEY |
Johannes Berg3a245762008-04-09 16:45:37 +0200538 KEY_FLAG_TODO_HWACCEL_ADD |
539 KEY_FLAG_TODO_HWACCEL_REMOVE |
Johannes Berg3b967662008-04-08 17:56:52 +0200540 KEY_FLAG_TODO_DELETE);
541 key->flags &= ~todoflags;
542 spin_unlock(&todo_lock);
Johannes Berg11a843b2007-08-28 17:01:55 -0400543
Johannes Berg3b967662008-04-08 17:56:52 +0200544 work_done = false;
Johannes Berg11a843b2007-08-28 17:01:55 -0400545
Johannes Berg3b967662008-04-08 17:56:52 +0200546 if (todoflags & KEY_FLAG_TODO_ADD_DEBUGFS) {
547 ieee80211_debugfs_key_add(key);
548 work_done = true;
549 }
550 if (todoflags & KEY_FLAG_TODO_DEFKEY) {
551 ieee80211_debugfs_key_remove_default(key->sdata);
552 ieee80211_debugfs_key_add_default(key->sdata);
553 work_done = true;
554 }
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200555 if (todoflags & KEY_FLAG_TODO_DEFMGMTKEY) {
556 ieee80211_debugfs_key_remove_mgmt_default(key->sdata);
557 ieee80211_debugfs_key_add_mgmt_default(key->sdata);
558 work_done = true;
559 }
Johannes Berg3a245762008-04-09 16:45:37 +0200560 if (todoflags & KEY_FLAG_TODO_HWACCEL_ADD) {
Johannes Berg3b967662008-04-08 17:56:52 +0200561 ieee80211_key_enable_hw_accel(key);
562 work_done = true;
563 }
Johannes Berg3a245762008-04-09 16:45:37 +0200564 if (todoflags & KEY_FLAG_TODO_HWACCEL_REMOVE) {
565 ieee80211_key_disable_hw_accel(key);
566 work_done = true;
567 }
Johannes Berg3b967662008-04-08 17:56:52 +0200568 if (todoflags & KEY_FLAG_TODO_DELETE) {
Johannes Berg3a245762008-04-09 16:45:37 +0200569 __ieee80211_key_destroy(key);
Johannes Berg3b967662008-04-08 17:56:52 +0200570 work_done = true;
571 }
572
573 WARN_ON(!work_done);
574
575 spin_lock(&todo_lock);
Johannes Berg11a843b2007-08-28 17:01:55 -0400576 }
Johannes Berg3b967662008-04-08 17:56:52 +0200577 spin_unlock(&todo_lock);
578}
579
580void ieee80211_key_todo(void)
581{
582 ieee80211_key_lock();
583 __ieee80211_key_todo();
584 ieee80211_key_unlock();
Johannes Berg11a843b2007-08-28 17:01:55 -0400585}
586
587void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
588{
589 struct ieee80211_key *key, *tmp;
Johannes Berg3a245762008-04-09 16:45:37 +0200590 unsigned long flags;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100591
Johannes Berg3b967662008-04-08 17:56:52 +0200592 ieee80211_key_lock();
593
594 ieee80211_debugfs_key_remove_default(sdata);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200595 ieee80211_debugfs_key_remove_mgmt_default(sdata);
Johannes Berg11a843b2007-08-28 17:01:55 -0400596
Johannes Bergb16bd152008-04-11 21:40:35 +0200597 spin_lock_irqsave(&sdata->local->key_lock, flags);
Johannes Berg11a843b2007-08-28 17:01:55 -0400598 list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
Johannes Berg3a245762008-04-09 16:45:37 +0200599 __ieee80211_key_free(key);
Johannes Bergb16bd152008-04-11 21:40:35 +0200600 spin_unlock_irqrestore(&sdata->local->key_lock, flags);
Johannes Berg11a843b2007-08-28 17:01:55 -0400601
Johannes Berg3b967662008-04-08 17:56:52 +0200602 __ieee80211_key_todo();
Johannes Berg11a843b2007-08-28 17:01:55 -0400603
Johannes Berg3b967662008-04-08 17:56:52 +0200604 ieee80211_key_unlock();
Johannes Berg11a843b2007-08-28 17:01:55 -0400605}