[IPV4]: ip_check_mc() annotations
[linux-2.6] / net / ieee80211 / ieee80211_crypt.c
1 /*
2  * Host AP crypto routines
3  *
4  * Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
5  * Portions Copyright (C) 2004, Intel Corporation <jketreno@linux.intel.com>
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. See README and COPYING for
10  * more details.
11  *
12  */
13
14 #include <linux/errno.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/slab.h>
18 #include <linux/string.h>
19 #include <net/ieee80211.h>
20
21 MODULE_AUTHOR("Jouni Malinen");
22 MODULE_DESCRIPTION("HostAP crypto");
23 MODULE_LICENSE("GPL");
24
25 struct ieee80211_crypto_alg {
26         struct list_head list;
27         struct ieee80211_crypto_ops *ops;
28 };
29
30 static LIST_HEAD(ieee80211_crypto_algs);
31 static DEFINE_SPINLOCK(ieee80211_crypto_lock);
32
33 void ieee80211_crypt_deinit_entries(struct ieee80211_device *ieee, int force)
34 {
35         struct ieee80211_crypt_data *entry, *next;
36         unsigned long flags;
37
38         spin_lock_irqsave(&ieee->lock, flags);
39         list_for_each_entry_safe(entry, next, &ieee->crypt_deinit_list, list) {
40                 if (atomic_read(&entry->refcnt) != 0 && !force)
41                         continue;
42
43                 list_del(&entry->list);
44
45                 if (entry->ops) {
46                         entry->ops->deinit(entry->priv);
47                         module_put(entry->ops->owner);
48                 }
49                 kfree(entry);
50         }
51         spin_unlock_irqrestore(&ieee->lock, flags);
52 }
53
54 /* After this, crypt_deinit_list won't accept new members */
55 void ieee80211_crypt_quiescing(struct ieee80211_device *ieee)
56 {
57         unsigned long flags;
58
59         spin_lock_irqsave(&ieee->lock, flags);
60         ieee->crypt_quiesced = 1;
61         spin_unlock_irqrestore(&ieee->lock, flags);
62 }
63
64 void ieee80211_crypt_deinit_handler(unsigned long data)
65 {
66         struct ieee80211_device *ieee = (struct ieee80211_device *)data;
67         unsigned long flags;
68
69         ieee80211_crypt_deinit_entries(ieee, 0);
70
71         spin_lock_irqsave(&ieee->lock, flags);
72         if (!list_empty(&ieee->crypt_deinit_list) && !ieee->crypt_quiesced) {
73                 printk(KERN_DEBUG "%s: entries remaining in delayed crypt "
74                        "deletion list\n", ieee->dev->name);
75                 ieee->crypt_deinit_timer.expires = jiffies + HZ;
76                 add_timer(&ieee->crypt_deinit_timer);
77         }
78         spin_unlock_irqrestore(&ieee->lock, flags);
79 }
80
81 void ieee80211_crypt_delayed_deinit(struct ieee80211_device *ieee,
82                                     struct ieee80211_crypt_data **crypt)
83 {
84         struct ieee80211_crypt_data *tmp;
85         unsigned long flags;
86
87         if (*crypt == NULL)
88                 return;
89
90         tmp = *crypt;
91         *crypt = NULL;
92
93         /* must not run ops->deinit() while there may be pending encrypt or
94          * decrypt operations. Use a list of delayed deinits to avoid needing
95          * locking. */
96
97         spin_lock_irqsave(&ieee->lock, flags);
98         if (!ieee->crypt_quiesced) {
99                 list_add(&tmp->list, &ieee->crypt_deinit_list);
100                 if (!timer_pending(&ieee->crypt_deinit_timer)) {
101                         ieee->crypt_deinit_timer.expires = jiffies + HZ;
102                         add_timer(&ieee->crypt_deinit_timer);
103                 }
104         }
105         spin_unlock_irqrestore(&ieee->lock, flags);
106 }
107
108 int ieee80211_register_crypto_ops(struct ieee80211_crypto_ops *ops)
109 {
110         unsigned long flags;
111         struct ieee80211_crypto_alg *alg;
112
113         alg = kzalloc(sizeof(*alg), GFP_KERNEL);
114         if (alg == NULL)
115                 return -ENOMEM;
116
117         alg->ops = ops;
118
119         spin_lock_irqsave(&ieee80211_crypto_lock, flags);
120         list_add(&alg->list, &ieee80211_crypto_algs);
121         spin_unlock_irqrestore(&ieee80211_crypto_lock, flags);
122
123         printk(KERN_DEBUG "ieee80211_crypt: registered algorithm '%s'\n",
124                ops->name);
125
126         return 0;
127 }
128
129 int ieee80211_unregister_crypto_ops(struct ieee80211_crypto_ops *ops)
130 {
131         struct ieee80211_crypto_alg *alg;
132         unsigned long flags;
133
134         spin_lock_irqsave(&ieee80211_crypto_lock, flags);
135         list_for_each_entry(alg, &ieee80211_crypto_algs, list) {
136                 if (alg->ops == ops)
137                         goto found;
138         }
139         spin_unlock_irqrestore(&ieee80211_crypto_lock, flags);
140         return -EINVAL;
141
142       found:
143         printk(KERN_DEBUG "ieee80211_crypt: unregistered algorithm "
144                "'%s'\n", ops->name);
145         list_del(&alg->list);
146         spin_unlock_irqrestore(&ieee80211_crypto_lock, flags);
147         kfree(alg);
148         return 0;
149 }
150
151 struct ieee80211_crypto_ops *ieee80211_get_crypto_ops(const char *name)
152 {
153         struct ieee80211_crypto_alg *alg;
154         unsigned long flags;
155
156         spin_lock_irqsave(&ieee80211_crypto_lock, flags);
157         list_for_each_entry(alg, &ieee80211_crypto_algs, list) {
158                 if (strcmp(alg->ops->name, name) == 0)
159                         goto found;
160         }
161         spin_unlock_irqrestore(&ieee80211_crypto_lock, flags);
162         return NULL;
163
164       found:
165         spin_unlock_irqrestore(&ieee80211_crypto_lock, flags);
166         return alg->ops;
167 }
168
169 static void *ieee80211_crypt_null_init(int keyidx)
170 {
171         return (void *)1;
172 }
173
174 static void ieee80211_crypt_null_deinit(void *priv)
175 {
176 }
177
178 static struct ieee80211_crypto_ops ieee80211_crypt_null = {
179         .name = "NULL",
180         .init = ieee80211_crypt_null_init,
181         .deinit = ieee80211_crypt_null_deinit,
182         .owner = THIS_MODULE,
183 };
184
185 static int __init ieee80211_crypto_init(void)
186 {
187         return ieee80211_register_crypto_ops(&ieee80211_crypt_null);
188 }
189
190 static void __exit ieee80211_crypto_deinit(void)
191 {
192         ieee80211_unregister_crypto_ops(&ieee80211_crypt_null);
193         BUG_ON(!list_empty(&ieee80211_crypto_algs));
194 }
195
196 EXPORT_SYMBOL(ieee80211_crypt_deinit_entries);
197 EXPORT_SYMBOL(ieee80211_crypt_deinit_handler);
198 EXPORT_SYMBOL(ieee80211_crypt_delayed_deinit);
199 EXPORT_SYMBOL(ieee80211_crypt_quiescing);
200
201 EXPORT_SYMBOL(ieee80211_register_crypto_ops);
202 EXPORT_SYMBOL(ieee80211_unregister_crypto_ops);
203 EXPORT_SYMBOL(ieee80211_get_crypto_ops);
204
205 module_init(ieee80211_crypto_init);
206 module_exit(ieee80211_crypto_deinit);