mac80211: Don't squash error codes in key setup functions
[linux-2.6.git] / 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 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  *
39  * All key operations are protected internally.
40  *
41  * 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
44  * functions. This means that sta_info_destroy() must remove the key
45  * which waits for an RCU grace period.
46  */
47
48 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
49
50 static void assert_key_lock(struct ieee80211_local *local)
51 {
52         WARN_ON(!mutex_is_locked(&local->key_mtx));
53 }
54
55 static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
56 {
57         if (key->sta)
58                 return &key->sta->sta;
59
60         return NULL;
61 }
62
63 static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
64 {
65         struct ieee80211_sub_if_data *sdata;
66         struct ieee80211_sta *sta;
67         int ret;
68
69         might_sleep();
70
71         if (!key->local->ops->set_key)
72                 return;
73
74         assert_key_lock(key->local);
75
76         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);
83
84         ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
85
86         if (!ret)
87                 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 "
91                        "(%d, %pM) to hardware (%d)\n",
92                        wiphy_name(key->local->hw.wiphy),
93                        key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
94 }
95
96 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
97 {
98         struct ieee80211_sub_if_data *sdata;
99         struct ieee80211_sta *sta;
100         int ret;
101
102         might_sleep();
103
104         if (!key || !key->local->ops->set_key)
105                 return;
106
107         assert_key_lock(key->local);
108
109         if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
110                 return;
111
112         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);
119
120         ret = drv_set_key(key->local, DISABLE_KEY, sdata,
121                           sta, &key->conf);
122
123         if (ret)
124                 printk(KERN_ERR "mac80211-%s: failed to remove key "
125                        "(%d, %pM) from hardware (%d)\n",
126                        wiphy_name(key->local->hw.wiphy),
127                        key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
128
129         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
130 }
131
132 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
133                                         int idx)
134 {
135         struct ieee80211_key *key = NULL;
136
137         assert_key_lock(sdata->local);
138
139         if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
140                 key = sdata->keys[idx];
141
142         rcu_assign_pointer(sdata->default_key, key);
143
144         if (key) {
145                 ieee80211_debugfs_key_remove_default(key->sdata);
146                 ieee80211_debugfs_key_add_default(key->sdata);
147         }
148 }
149
150 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx)
151 {
152         mutex_lock(&sdata->local->key_mtx);
153         __ieee80211_set_default_key(sdata, idx);
154         mutex_unlock(&sdata->local->key_mtx);
155 }
156
157 static void
158 __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
159 {
160         struct ieee80211_key *key = NULL;
161
162         assert_key_lock(sdata->local);
163
164         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
170         if (key) {
171                 ieee80211_debugfs_key_remove_mgmt_default(key->sdata);
172                 ieee80211_debugfs_key_add_mgmt_default(key->sdata);
173         }
174 }
175
176 void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
177                                     int idx)
178 {
179         mutex_lock(&sdata->local->key_mtx);
180         __ieee80211_set_default_mgmt_key(sdata, idx);
181         mutex_unlock(&sdata->local->key_mtx);
182 }
183
184
185 static 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 {
190         int idx, defkey, defmgmtkey;
191
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;
206                 defmgmtkey = old && sdata->default_mgmt_key == old;
207
208                 if (defkey && !new)
209                         __ieee80211_set_default_key(sdata, -1);
210                 if (defmgmtkey && !new)
211                         __ieee80211_set_default_mgmt_key(sdata, -1);
212
213                 rcu_assign_pointer(sdata->keys[idx], new);
214                 if (defkey && new)
215                         __ieee80211_set_default_key(sdata, new->conf.keyidx);
216                 if (defmgmtkey && new)
217                         __ieee80211_set_default_mgmt_key(sdata,
218                                                          new->conf.keyidx);
219         }
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         }
228 }
229
230 struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg,
231                                           int idx,
232                                           size_t key_len,
233                                           const u8 *key_data,
234                                           size_t seq_len, const u8 *seq)
235 {
236         struct ieee80211_key *key;
237         int i, j, err;
238
239         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
240
241         key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
242         if (!key)
243                 return ERR_PTR(-ENOMEM);
244
245         /*
246          * Default to software encryption; we'll later upload the
247          * key to the hardware if possible.
248          */
249         key->conf.flags = 0;
250         key->flags = 0;
251
252         key->conf.alg = alg;
253         key->conf.keyidx = idx;
254         key->conf.keylen = key_len;
255         switch (alg) {
256         case ALG_WEP:
257                 key->conf.iv_len = WEP_IV_LEN;
258                 key->conf.icv_len = WEP_ICV_LEN;
259                 break;
260         case ALG_TKIP:
261                 key->conf.iv_len = TKIP_IV_LEN;
262                 key->conf.icv_len = TKIP_ICV_LEN;
263                 if (seq) {
264                         for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
265                                 key->u.tkip.rx[i].iv32 =
266                                         get_unaligned_le32(&seq[2]);
267                                 key->u.tkip.rx[i].iv16 =
268                                         get_unaligned_le16(seq);
269                         }
270                 }
271                 break;
272         case ALG_CCMP:
273                 key->conf.iv_len = CCMP_HDR_LEN;
274                 key->conf.icv_len = CCMP_MIC_LEN;
275                 if (seq) {
276                         for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
277                                 for (j = 0; j < CCMP_PN_LEN; j++)
278                                         key->u.ccmp.rx_pn[i][j] =
279                                                 seq[CCMP_PN_LEN - j - 1];
280                 }
281                 break;
282         case ALG_AES_CMAC:
283                 key->conf.iv_len = 0;
284                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
285                 if (seq)
286                         for (j = 0; j < 6; j++)
287                                 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
288                 break;
289         }
290         memcpy(key->conf.key, key_data, key_len);
291         INIT_LIST_HEAD(&key->list);
292
293         if (alg == ALG_CCMP) {
294                 /*
295                  * Initialize AES key state here as an optimization so that
296                  * it does not need to be initialized for every packet.
297                  */
298                 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
299                 if (IS_ERR(key->u.ccmp.tfm)) {
300                         err = PTR_ERR(key->u.ccmp.tfm);
301                         kfree(key);
302                         key = ERR_PTR(err);
303                 }
304         }
305
306         if (alg == ALG_AES_CMAC) {
307                 /*
308                  * Initialize AES key state here as an optimization so that
309                  * it does not need to be initialized for every packet.
310                  */
311                 key->u.aes_cmac.tfm =
312                         ieee80211_aes_cmac_key_setup(key_data);
313                 if (IS_ERR(key->u.aes_cmac.tfm)) {
314                         err = PTR_ERR(key->u.aes_cmac.tfm);
315                         kfree(key);
316                         key = ERR_PTR(err);
317                 }
318         }
319
320         return key;
321 }
322
323 static void __ieee80211_key_destroy(struct ieee80211_key *key)
324 {
325         if (!key)
326                 return;
327
328         if (key->local)
329                 ieee80211_key_disable_hw_accel(key);
330
331         if (key->conf.alg == ALG_CCMP)
332                 ieee80211_aes_key_free(key->u.ccmp.tfm);
333         if (key->conf.alg == ALG_AES_CMAC)
334                 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
335         if (key->local)
336                 ieee80211_debugfs_key_remove(key);
337
338         kfree(key);
339 }
340
341 void ieee80211_key_link(struct ieee80211_key *key,
342                         struct ieee80211_sub_if_data *sdata,
343                         struct sta_info *sta)
344 {
345         struct ieee80211_key *old_key;
346         int idx;
347
348         BUG_ON(!sdata);
349         BUG_ON(!key);
350
351         idx = key->conf.keyidx;
352         key->local = sdata->local;
353         key->sdata = sdata;
354         key->sta = sta;
355
356         if (sta) {
357                 /*
358                  * some hardware cannot handle TKIP with QoS, so
359                  * we indicate whether QoS could be in use.
360                  */
361                 if (test_sta_flags(sta, WLAN_STA_WME))
362                         key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
363
364                 /*
365                  * This key is for a specific sta interface,
366                  * inform the driver that it should try to store
367                  * this key as pairwise key.
368                  */
369                 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
370         } else {
371                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
372                         struct sta_info *ap;
373
374                         /*
375                          * We're getting a sta pointer in,
376                          * so must be under RCU read lock.
377                          */
378
379                         /* same here, the AP could be using QoS */
380                         ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
381                         if (ap) {
382                                 if (test_sta_flags(ap, WLAN_STA_WME))
383                                         key->conf.flags |=
384                                                 IEEE80211_KEY_FLAG_WMM_STA;
385                         }
386                 }
387         }
388
389         mutex_lock(&sdata->local->key_mtx);
390
391         if (sta)
392                 old_key = sta->key;
393         else
394                 old_key = sdata->keys[idx];
395
396         __ieee80211_key_replace(sdata, sta, old_key, key);
397         __ieee80211_key_destroy(old_key);
398
399         ieee80211_debugfs_key_add(key);
400
401         ieee80211_key_enable_hw_accel(key);
402
403         mutex_unlock(&sdata->local->key_mtx);
404 }
405
406 static void __ieee80211_key_free(struct ieee80211_key *key)
407 {
408         /*
409          * Replace key with nothingness if it was ever used.
410          */
411         if (key->sdata)
412                 __ieee80211_key_replace(key->sdata, key->sta,
413                                         key, NULL);
414         __ieee80211_key_destroy(key);
415 }
416
417 void ieee80211_key_free(struct ieee80211_local *local,
418                         struct ieee80211_key *key)
419 {
420         if (!key)
421                 return;
422
423         mutex_lock(&local->key_mtx);
424         __ieee80211_key_free(key);
425         mutex_unlock(&local->key_mtx);
426 }
427
428 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
429 {
430         struct ieee80211_key *key;
431
432         ASSERT_RTNL();
433
434         if (WARN_ON(!ieee80211_sdata_running(sdata)))
435                 return;
436
437         mutex_lock(&sdata->local->key_mtx);
438
439         list_for_each_entry(key, &sdata->key_list, list)
440                 ieee80211_key_enable_hw_accel(key);
441
442         mutex_unlock(&sdata->local->key_mtx);
443 }
444
445 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
446 {
447         struct ieee80211_key *key;
448
449         ASSERT_RTNL();
450
451         mutex_lock(&sdata->local->key_mtx);
452
453         list_for_each_entry(key, &sdata->key_list, list)
454                 ieee80211_key_disable_hw_accel(key);
455
456         mutex_unlock(&sdata->local->key_mtx);
457 }
458
459 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
460 {
461         struct ieee80211_key *key, *tmp;
462
463         mutex_lock(&sdata->local->key_mtx);
464
465         ieee80211_debugfs_key_remove_default(sdata);
466         ieee80211_debugfs_key_remove_mgmt_default(sdata);
467
468         list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
469                 __ieee80211_key_free(key);
470
471         mutex_unlock(&sdata->local->key_mtx);
472 }