cfg80211: Use capability info to detect mesh beacons.
[linux-2.6.git] / net / wireless / lib80211.c
1 /*
2  * lib80211 -- common bits for IEEE802.11 drivers
3  *
4  * Copyright(c) 2008 John W. Linville <linville@tuxdriver.com>
5  *
6  * Portions copied from old ieee80211 component, w/ original copyright
7  * notices below:
8  *
9  * Host AP crypto routines
10  *
11  * Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
12  * Portions Copyright (C) 2004, Intel Corporation <jketreno@linux.intel.com>
13  *
14  */
15
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18 #include <linux/module.h>
19 #include <linux/ctype.h>
20 #include <linux/ieee80211.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
25
26 #include <net/lib80211.h>
27
28 #define DRV_NAME        "lib80211"
29
30 #define DRV_DESCRIPTION "common routines for IEEE802.11 drivers"
31
32 MODULE_DESCRIPTION(DRV_DESCRIPTION);
33 MODULE_AUTHOR("John W. Linville <linville@tuxdriver.com>");
34 MODULE_LICENSE("GPL");
35
36 struct lib80211_crypto_alg {
37         struct list_head list;
38         struct lib80211_crypto_ops *ops;
39 };
40
41 static LIST_HEAD(lib80211_crypto_algs);
42 static DEFINE_SPINLOCK(lib80211_crypto_lock);
43
44 const char *print_ssid(char *buf, const char *ssid, u8 ssid_len)
45 {
46         const char *s = ssid;
47         char *d = buf;
48
49         ssid_len = min_t(u8, ssid_len, IEEE80211_MAX_SSID_LEN);
50         while (ssid_len--) {
51                 if (isprint(*s)) {
52                         *d++ = *s++;
53                         continue;
54                 }
55
56                 *d++ = '\\';
57                 if (*s == '\0')
58                         *d++ = '0';
59                 else if (*s == '\n')
60                         *d++ = 'n';
61                 else if (*s == '\r')
62                         *d++ = 'r';
63                 else if (*s == '\t')
64                         *d++ = 't';
65                 else if (*s == '\\')
66                         *d++ = '\\';
67                 else
68                         d += snprintf(d, 3, "%03o", *s);
69                 s++;
70         }
71         *d = '\0';
72         return buf;
73 }
74 EXPORT_SYMBOL(print_ssid);
75
76 int lib80211_crypt_info_init(struct lib80211_crypt_info *info, char *name,
77                                 spinlock_t *lock)
78 {
79         memset(info, 0, sizeof(*info));
80
81         info->name = name;
82         info->lock = lock;
83
84         INIT_LIST_HEAD(&info->crypt_deinit_list);
85         setup_timer(&info->crypt_deinit_timer, lib80211_crypt_deinit_handler,
86                         (unsigned long)info);
87
88         return 0;
89 }
90 EXPORT_SYMBOL(lib80211_crypt_info_init);
91
92 void lib80211_crypt_info_free(struct lib80211_crypt_info *info)
93 {
94         int i;
95
96         lib80211_crypt_quiescing(info);
97         del_timer_sync(&info->crypt_deinit_timer);
98         lib80211_crypt_deinit_entries(info, 1);
99
100         for (i = 0; i < NUM_WEP_KEYS; i++) {
101                 struct lib80211_crypt_data *crypt = info->crypt[i];
102                 if (crypt) {
103                         if (crypt->ops) {
104                                 crypt->ops->deinit(crypt->priv);
105                                 module_put(crypt->ops->owner);
106                         }
107                         kfree(crypt);
108                         info->crypt[i] = NULL;
109                 }
110         }
111 }
112 EXPORT_SYMBOL(lib80211_crypt_info_free);
113
114 void lib80211_crypt_deinit_entries(struct lib80211_crypt_info *info, int force)
115 {
116         struct lib80211_crypt_data *entry, *next;
117         unsigned long flags;
118
119         spin_lock_irqsave(info->lock, flags);
120         list_for_each_entry_safe(entry, next, &info->crypt_deinit_list, list) {
121                 if (atomic_read(&entry->refcnt) != 0 && !force)
122                         continue;
123
124                 list_del(&entry->list);
125
126                 if (entry->ops) {
127                         entry->ops->deinit(entry->priv);
128                         module_put(entry->ops->owner);
129                 }
130                 kfree(entry);
131         }
132         spin_unlock_irqrestore(info->lock, flags);
133 }
134 EXPORT_SYMBOL(lib80211_crypt_deinit_entries);
135
136 /* After this, crypt_deinit_list won't accept new members */
137 void lib80211_crypt_quiescing(struct lib80211_crypt_info *info)
138 {
139         unsigned long flags;
140
141         spin_lock_irqsave(info->lock, flags);
142         info->crypt_quiesced = 1;
143         spin_unlock_irqrestore(info->lock, flags);
144 }
145 EXPORT_SYMBOL(lib80211_crypt_quiescing);
146
147 void lib80211_crypt_deinit_handler(unsigned long data)
148 {
149         struct lib80211_crypt_info *info = (struct lib80211_crypt_info *)data;
150         unsigned long flags;
151
152         lib80211_crypt_deinit_entries(info, 0);
153
154         spin_lock_irqsave(info->lock, flags);
155         if (!list_empty(&info->crypt_deinit_list) && !info->crypt_quiesced) {
156                 printk(KERN_DEBUG "%s: entries remaining in delayed crypt "
157                        "deletion list\n", info->name);
158                 info->crypt_deinit_timer.expires = jiffies + HZ;
159                 add_timer(&info->crypt_deinit_timer);
160         }
161         spin_unlock_irqrestore(info->lock, flags);
162 }
163 EXPORT_SYMBOL(lib80211_crypt_deinit_handler);
164
165 void lib80211_crypt_delayed_deinit(struct lib80211_crypt_info *info,
166                                     struct lib80211_crypt_data **crypt)
167 {
168         struct lib80211_crypt_data *tmp;
169         unsigned long flags;
170
171         if (*crypt == NULL)
172                 return;
173
174         tmp = *crypt;
175         *crypt = NULL;
176
177         /* must not run ops->deinit() while there may be pending encrypt or
178          * decrypt operations. Use a list of delayed deinits to avoid needing
179          * locking. */
180
181         spin_lock_irqsave(info->lock, flags);
182         if (!info->crypt_quiesced) {
183                 list_add(&tmp->list, &info->crypt_deinit_list);
184                 if (!timer_pending(&info->crypt_deinit_timer)) {
185                         info->crypt_deinit_timer.expires = jiffies + HZ;
186                         add_timer(&info->crypt_deinit_timer);
187                 }
188         }
189         spin_unlock_irqrestore(info->lock, flags);
190 }
191 EXPORT_SYMBOL(lib80211_crypt_delayed_deinit);
192
193 int lib80211_register_crypto_ops(struct lib80211_crypto_ops *ops)
194 {
195         unsigned long flags;
196         struct lib80211_crypto_alg *alg;
197
198         alg = kzalloc(sizeof(*alg), GFP_KERNEL);
199         if (alg == NULL)
200                 return -ENOMEM;
201
202         alg->ops = ops;
203
204         spin_lock_irqsave(&lib80211_crypto_lock, flags);
205         list_add(&alg->list, &lib80211_crypto_algs);
206         spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
207
208         printk(KERN_DEBUG "lib80211_crypt: registered algorithm '%s'\n",
209                ops->name);
210
211         return 0;
212 }
213 EXPORT_SYMBOL(lib80211_register_crypto_ops);
214
215 int lib80211_unregister_crypto_ops(struct lib80211_crypto_ops *ops)
216 {
217         struct lib80211_crypto_alg *alg;
218         unsigned long flags;
219
220         spin_lock_irqsave(&lib80211_crypto_lock, flags);
221         list_for_each_entry(alg, &lib80211_crypto_algs, list) {
222                 if (alg->ops == ops)
223                         goto found;
224         }
225         spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
226         return -EINVAL;
227
228       found:
229         printk(KERN_DEBUG "lib80211_crypt: unregistered algorithm '%s'\n",
230                ops->name);
231         list_del(&alg->list);
232         spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
233         kfree(alg);
234         return 0;
235 }
236 EXPORT_SYMBOL(lib80211_unregister_crypto_ops);
237
238 struct lib80211_crypto_ops *lib80211_get_crypto_ops(const char *name)
239 {
240         struct lib80211_crypto_alg *alg;
241         unsigned long flags;
242
243         spin_lock_irqsave(&lib80211_crypto_lock, flags);
244         list_for_each_entry(alg, &lib80211_crypto_algs, list) {
245                 if (strcmp(alg->ops->name, name) == 0)
246                         goto found;
247         }
248         spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
249         return NULL;
250
251       found:
252         spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
253         return alg->ops;
254 }
255 EXPORT_SYMBOL(lib80211_get_crypto_ops);
256
257 static void *lib80211_crypt_null_init(int keyidx)
258 {
259         return (void *)1;
260 }
261
262 static void lib80211_crypt_null_deinit(void *priv)
263 {
264 }
265
266 static struct lib80211_crypto_ops lib80211_crypt_null = {
267         .name = "NULL",
268         .init = lib80211_crypt_null_init,
269         .deinit = lib80211_crypt_null_deinit,
270         .owner = THIS_MODULE,
271 };
272
273 static int __init lib80211_init(void)
274 {
275         pr_info(DRV_DESCRIPTION "\n");
276         return lib80211_register_crypto_ops(&lib80211_crypt_null);
277 }
278
279 static void __exit lib80211_exit(void)
280 {
281         lib80211_unregister_crypto_ops(&lib80211_crypt_null);
282         BUG_ON(!list_empty(&lib80211_crypto_algs));
283 }
284
285 module_init(lib80211_init);
286 module_exit(lib80211_exit);