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); 287