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 static void lib80211_crypt_deinit_entries(struct lib80211_crypt_info *info, 45 int force); 46 static void lib80211_crypt_quiescing(struct lib80211_crypt_info *info); 47 static void lib80211_crypt_deinit_handler(unsigned long data); 48 49 int lib80211_crypt_info_init(struct lib80211_crypt_info *info, char *name, 50 spinlock_t *lock) 51 { 52 memset(info, 0, sizeof(*info)); 53 54 info->name = name; 55 info->lock = lock; 56 57 INIT_LIST_HEAD(&info->crypt_deinit_list); 58 setup_timer(&info->crypt_deinit_timer, lib80211_crypt_deinit_handler, 59 (unsigned long)info); 60 61 return 0; 62 } 63 EXPORT_SYMBOL(lib80211_crypt_info_init); 64 65 void lib80211_crypt_info_free(struct lib80211_crypt_info *info) 66 { 67 int i; 68 69 lib80211_crypt_quiescing(info); 70 del_timer_sync(&info->crypt_deinit_timer); 71 lib80211_crypt_deinit_entries(info, 1); 72 73 for (i = 0; i < NUM_WEP_KEYS; i++) { 74 struct lib80211_crypt_data *crypt = info->crypt[i]; 75 if (crypt) { 76 if (crypt->ops) { 77 crypt->ops->deinit(crypt->priv); 78 module_put(crypt->ops->owner); 79 } 80 kfree(crypt); 81 info->crypt[i] = NULL; 82 } 83 } 84 } 85 EXPORT_SYMBOL(lib80211_crypt_info_free); 86 87 static void lib80211_crypt_deinit_entries(struct lib80211_crypt_info *info, 88 int force) 89 { 90 struct lib80211_crypt_data *entry, *next; 91 unsigned long flags; 92 93 spin_lock_irqsave(info->lock, flags); 94 list_for_each_entry_safe(entry, next, &info->crypt_deinit_list, list) { 95 if (atomic_read(&entry->refcnt) != 0 && !force) 96 continue; 97 98 list_del(&entry->list); 99 100 if (entry->ops) { 101 entry->ops->deinit(entry->priv); 102 module_put(entry->ops->owner); 103 } 104 kfree(entry); 105 } 106 spin_unlock_irqrestore(info->lock, flags); 107 } 108 109 /* After this, crypt_deinit_list won't accept new members */ 110 static void lib80211_crypt_quiescing(struct lib80211_crypt_info *info) 111 { 112 unsigned long flags; 113 114 spin_lock_irqsave(info->lock, flags); 115 info->crypt_quiesced = 1; 116 spin_unlock_irqrestore(info->lock, flags); 117 } 118 119 static void lib80211_crypt_deinit_handler(unsigned long data) 120 { 121 struct lib80211_crypt_info *info = (struct lib80211_crypt_info *)data; 122 unsigned long flags; 123 124 lib80211_crypt_deinit_entries(info, 0); 125 126 spin_lock_irqsave(info->lock, flags); 127 if (!list_empty(&info->crypt_deinit_list) && !info->crypt_quiesced) { 128 printk(KERN_DEBUG "%s: entries remaining in delayed crypt " 129 "deletion list\n", info->name); 130 info->crypt_deinit_timer.expires = jiffies + HZ; 131 add_timer(&info->crypt_deinit_timer); 132 } 133 spin_unlock_irqrestore(info->lock, flags); 134 } 135 136 void lib80211_crypt_delayed_deinit(struct lib80211_crypt_info *info, 137 struct lib80211_crypt_data **crypt) 138 { 139 struct lib80211_crypt_data *tmp; 140 unsigned long flags; 141 142 if (*crypt == NULL) 143 return; 144 145 tmp = *crypt; 146 *crypt = NULL; 147 148 /* must not run ops->deinit() while there may be pending encrypt or 149 * decrypt operations. Use a list of delayed deinits to avoid needing 150 * locking. */ 151 152 spin_lock_irqsave(info->lock, flags); 153 if (!info->crypt_quiesced) { 154 list_add(&tmp->list, &info->crypt_deinit_list); 155 if (!timer_pending(&info->crypt_deinit_timer)) { 156 info->crypt_deinit_timer.expires = jiffies + HZ; 157 add_timer(&info->crypt_deinit_timer); 158 } 159 } 160 spin_unlock_irqrestore(info->lock, flags); 161 } 162 EXPORT_SYMBOL(lib80211_crypt_delayed_deinit); 163 164 int lib80211_register_crypto_ops(struct lib80211_crypto_ops *ops) 165 { 166 unsigned long flags; 167 struct lib80211_crypto_alg *alg; 168 169 alg = kzalloc(sizeof(*alg), GFP_KERNEL); 170 if (alg == NULL) 171 return -ENOMEM; 172 173 alg->ops = ops; 174 175 spin_lock_irqsave(&lib80211_crypto_lock, flags); 176 list_add(&alg->list, &lib80211_crypto_algs); 177 spin_unlock_irqrestore(&lib80211_crypto_lock, flags); 178 179 printk(KERN_DEBUG "lib80211_crypt: registered algorithm '%s'\n", 180 ops->name); 181 182 return 0; 183 } 184 EXPORT_SYMBOL(lib80211_register_crypto_ops); 185 186 int lib80211_unregister_crypto_ops(struct lib80211_crypto_ops *ops) 187 { 188 struct lib80211_crypto_alg *alg; 189 unsigned long flags; 190 191 spin_lock_irqsave(&lib80211_crypto_lock, flags); 192 list_for_each_entry(alg, &lib80211_crypto_algs, list) { 193 if (alg->ops == ops) 194 goto found; 195 } 196 spin_unlock_irqrestore(&lib80211_crypto_lock, flags); 197 return -EINVAL; 198 199 found: 200 printk(KERN_DEBUG "lib80211_crypt: unregistered algorithm '%s'\n", 201 ops->name); 202 list_del(&alg->list); 203 spin_unlock_irqrestore(&lib80211_crypto_lock, flags); 204 kfree(alg); 205 return 0; 206 } 207 EXPORT_SYMBOL(lib80211_unregister_crypto_ops); 208 209 struct lib80211_crypto_ops *lib80211_get_crypto_ops(const char *name) 210 { 211 struct lib80211_crypto_alg *alg; 212 unsigned long flags; 213 214 spin_lock_irqsave(&lib80211_crypto_lock, flags); 215 list_for_each_entry(alg, &lib80211_crypto_algs, list) { 216 if (strcmp(alg->ops->name, name) == 0) 217 goto found; 218 } 219 spin_unlock_irqrestore(&lib80211_crypto_lock, flags); 220 return NULL; 221 222 found: 223 spin_unlock_irqrestore(&lib80211_crypto_lock, flags); 224 return alg->ops; 225 } 226 EXPORT_SYMBOL(lib80211_get_crypto_ops); 227 228 static void *lib80211_crypt_null_init(int keyidx) 229 { 230 return (void *)1; 231 } 232 233 static void lib80211_crypt_null_deinit(void *priv) 234 { 235 } 236 237 static struct lib80211_crypto_ops lib80211_crypt_null = { 238 .name = "NULL", 239 .init = lib80211_crypt_null_init, 240 .deinit = lib80211_crypt_null_deinit, 241 .owner = THIS_MODULE, 242 }; 243 244 static int __init lib80211_init(void) 245 { 246 pr_info(DRV_DESCRIPTION "\n"); 247 return lib80211_register_crypto_ops(&lib80211_crypt_null); 248 } 249 250 static void __exit lib80211_exit(void) 251 { 252 lib80211_unregister_crypto_ops(&lib80211_crypt_null); 253 BUG_ON(!list_empty(&lib80211_crypto_algs)); 254 } 255 256 module_init(lib80211_init); 257 module_exit(lib80211_exit); 258