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