This source file includes following definitions.
- ieee80211_crypt_deinit_entries
- ieee80211_crypt_deinit_handler
- ieee80211_crypt_delayed_deinit
- ieee80211_register_crypto_ops
- ieee80211_unregister_crypto_ops
- ieee80211_get_crypto_ops
- ieee80211_crypt_null_init
- ieee80211_crypt_null_deinit
- ieee80211_crypto_init
- ieee80211_crypto_deinit
1
2
3
4
5
6
7
8
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/slab.h>
12 #include <linux/string.h>
13 #include <linux/errno.h>
14
15 #include "ieee80211.h"
16
17 MODULE_AUTHOR("Jouni Malinen");
18 MODULE_DESCRIPTION("HostAP crypto");
19 MODULE_LICENSE("GPL");
20
21 struct ieee80211_crypto_alg {
22 struct list_head list;
23 struct ieee80211_crypto_ops *ops;
24 };
25
26
27 struct ieee80211_crypto {
28 struct list_head algs;
29 spinlock_t lock;
30 };
31
32 static struct ieee80211_crypto *hcrypt;
33
34 void ieee80211_crypt_deinit_entries(struct ieee80211_device *ieee,
35 int force)
36 {
37 struct list_head *ptr, *n;
38 struct ieee80211_crypt_data *entry;
39
40 for (ptr = ieee->crypt_deinit_list.next, n = ptr->next;
41 ptr != &ieee->crypt_deinit_list; ptr = n, n = ptr->next) {
42 entry = list_entry(ptr, struct ieee80211_crypt_data, list);
43
44 if (atomic_read(&entry->refcnt) != 0 && !force)
45 continue;
46
47 list_del(ptr);
48
49 if (entry->ops)
50 entry->ops->deinit(entry->priv);
51 kfree(entry);
52 }
53 }
54
55 void ieee80211_crypt_deinit_handler(struct timer_list *t)
56 {
57 struct ieee80211_device *ieee = from_timer(ieee, t, crypt_deinit_timer);
58 unsigned long flags;
59
60 spin_lock_irqsave(&ieee->lock, flags);
61 ieee80211_crypt_deinit_entries(ieee, 0);
62 if (!list_empty(&ieee->crypt_deinit_list)) {
63 netdev_dbg(ieee->dev, "%s: entries remaining in delayed crypt deletion list\n",
64 ieee->dev->name);
65 ieee->crypt_deinit_timer.expires = jiffies + HZ;
66 add_timer(&ieee->crypt_deinit_timer);
67 }
68 spin_unlock_irqrestore(&ieee->lock, flags);
69
70 }
71
72 void ieee80211_crypt_delayed_deinit(struct ieee80211_device *ieee,
73 struct ieee80211_crypt_data **crypt)
74 {
75 struct ieee80211_crypt_data *tmp;
76 unsigned long flags;
77
78 if (!(*crypt))
79 return;
80
81 tmp = *crypt;
82 *crypt = NULL;
83
84
85
86
87
88
89 spin_lock_irqsave(&ieee->lock, flags);
90 list_add(&tmp->list, &ieee->crypt_deinit_list);
91 if (!timer_pending(&ieee->crypt_deinit_timer)) {
92 ieee->crypt_deinit_timer.expires = jiffies + HZ;
93 add_timer(&ieee->crypt_deinit_timer);
94 }
95 spin_unlock_irqrestore(&ieee->lock, flags);
96 }
97
98 int ieee80211_register_crypto_ops(struct ieee80211_crypto_ops *ops)
99 {
100 unsigned long flags;
101 struct ieee80211_crypto_alg *alg;
102
103 if (!hcrypt)
104 return -1;
105
106 alg = kzalloc(sizeof(*alg), GFP_KERNEL);
107 if (!alg)
108 return -ENOMEM;
109
110 alg->ops = ops;
111
112 spin_lock_irqsave(&hcrypt->lock, flags);
113 list_add(&alg->list, &hcrypt->algs);
114 spin_unlock_irqrestore(&hcrypt->lock, flags);
115
116 pr_debug("ieee80211_crypt: registered algorithm '%s'\n",
117 ops->name);
118
119 return 0;
120 }
121
122 int ieee80211_unregister_crypto_ops(struct ieee80211_crypto_ops *ops)
123 {
124 unsigned long flags;
125 struct list_head *ptr;
126 struct ieee80211_crypto_alg *del_alg = NULL;
127
128 if (!hcrypt)
129 return -1;
130
131 spin_lock_irqsave(&hcrypt->lock, flags);
132 for (ptr = hcrypt->algs.next; ptr != &hcrypt->algs; ptr = ptr->next) {
133 struct ieee80211_crypto_alg *alg =
134 (struct ieee80211_crypto_alg *)ptr;
135 if (alg->ops == ops) {
136 list_del(&alg->list);
137 del_alg = alg;
138 break;
139 }
140 }
141 spin_unlock_irqrestore(&hcrypt->lock, flags);
142
143 if (del_alg) {
144 pr_debug("ieee80211_crypt: unregistered algorithm '%s'\n",
145 ops->name);
146 kfree(del_alg);
147 }
148
149 return del_alg ? 0 : -1;
150 }
151
152
153 struct ieee80211_crypto_ops *ieee80211_get_crypto_ops(const char *name)
154 {
155 unsigned long flags;
156 struct list_head *ptr;
157 struct ieee80211_crypto_alg *found_alg = NULL;
158
159 if (!hcrypt)
160 return NULL;
161
162 spin_lock_irqsave(&hcrypt->lock, flags);
163 for (ptr = hcrypt->algs.next; ptr != &hcrypt->algs; ptr = ptr->next) {
164 struct ieee80211_crypto_alg *alg =
165 (struct ieee80211_crypto_alg *)ptr;
166 if (strcmp(alg->ops->name, name) == 0) {
167 found_alg = alg;
168 break;
169 }
170 }
171 spin_unlock_irqrestore(&hcrypt->lock, flags);
172
173 if (found_alg)
174 return found_alg->ops;
175 return NULL;
176 }
177
178
179 static void *ieee80211_crypt_null_init(int keyidx) { return (void *)1; }
180 static void ieee80211_crypt_null_deinit(void *priv) {}
181
182 static struct ieee80211_crypto_ops ieee80211_crypt_null = {
183 .name = "NULL",
184 .init = ieee80211_crypt_null_init,
185 .deinit = ieee80211_crypt_null_deinit,
186 .encrypt_mpdu = NULL,
187 .decrypt_mpdu = NULL,
188 .encrypt_msdu = NULL,
189 .decrypt_msdu = NULL,
190 .set_key = NULL,
191 .get_key = NULL,
192 .extra_prefix_len = 0,
193 .extra_postfix_len = 0,
194 .owner = THIS_MODULE,
195 };
196
197 int __init ieee80211_crypto_init(void)
198 {
199 int ret = -ENOMEM;
200
201 hcrypt = kzalloc(sizeof(*hcrypt), GFP_KERNEL);
202 if (!hcrypt)
203 goto out;
204
205 INIT_LIST_HEAD(&hcrypt->algs);
206 spin_lock_init(&hcrypt->lock);
207
208 ret = ieee80211_register_crypto_ops(&ieee80211_crypt_null);
209 if (ret < 0) {
210 kfree(hcrypt);
211 hcrypt = NULL;
212 }
213 out:
214 return ret;
215 }
216
217 void __exit ieee80211_crypto_deinit(void)
218 {
219 struct list_head *ptr, *n;
220
221 if (!hcrypt)
222 return;
223
224 for (ptr = hcrypt->algs.next, n = ptr->next; ptr != &hcrypt->algs;
225 ptr = n, n = ptr->next) {
226 struct ieee80211_crypto_alg *alg =
227 (struct ieee80211_crypto_alg *)ptr;
228 list_del(ptr);
229 pr_debug("ieee80211_crypt: unregistered algorithm '%s' (deinit)\n",
230 alg->ops->name);
231 kfree(alg);
232 }
233
234 kfree(hcrypt);
235 }