[linux.git] / net / wireless / lib80211.c

/*
 * lib80211 -- common bits for IEEE802.11 drivers
 *
 * Copyright(c) 2008 John W. Linville <[email protected]>
 *
 * Portions copied from old ieee80211 component, w/ original copyright
 * notices below:
 *
 * Host AP crypto routines
 *
 * Copyright (c) 2002-2003, Jouni Malinen <[email protected]>
 * Portions Copyright (C) 2004, Intel Corporation <[email protected]>
 *
 */

#include <linux/module.h>
#include <linux/ctype.h>
#include <linux/ieee80211.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/string.h>

#include <net/lib80211.h>

#define DRV_NAME        "lib80211"

#define DRV_DESCRIPTION	"common routines for IEEE802.11 drivers"

MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_AUTHOR("John W. Linville <[email protected]>");
MODULE_LICENSE("GPL");

struct lib80211_crypto_alg {
	struct list_head list;
	struct lib80211_crypto_ops *ops;
};

static LIST_HEAD(lib80211_crypto_algs);
static DEFINE_SPINLOCK(lib80211_crypto_lock);

const char *print_ssid(char *buf, const char *ssid, u8 ssid_len)
{
	const char *s = ssid;
	char *d = buf;

	ssid_len = min_t(u8, ssid_len, IEEE80211_MAX_SSID_LEN);
	while (ssid_len--) {
		if (isprint(*s)) {
			*d++ = *s++;
			continue;
		}

		*d++ = '\\';
		if (*s == '\0')
			*d++ = '0';
		else if (*s == '\n')
			*d++ = 'n';
		else if (*s == '\r')
			*d++ = 'r';
		else if (*s == '\t')
			*d++ = 't';
		else if (*s == '\\')
			*d++ = '\\';
		else
			d += snprintf(d, 3, "%03o", *s);
		s++;
	}
	*d = '\0';
	return buf;
}
EXPORT_SYMBOL(print_ssid);

int lib80211_crypt_info_init(struct lib80211_crypt_info *info, char *name,
				spinlock_t *lock)
{
	memset(info, 0, sizeof(*info));

	info->name = name;
	info->lock = lock;

	INIT_LIST_HEAD(&info->crypt_deinit_list);
	setup_timer(&info->crypt_deinit_timer, lib80211_crypt_deinit_handler,
			(unsigned long)info);

	return 0;
}
EXPORT_SYMBOL(lib80211_crypt_info_init);

void lib80211_crypt_info_free(struct lib80211_crypt_info *info)
{
	int i;

        lib80211_crypt_quiescing(info);
        del_timer_sync(&info->crypt_deinit_timer);
        lib80211_crypt_deinit_entries(info, 1);

        for (i = 0; i < NUM_WEP_KEYS; i++) {
                struct lib80211_crypt_data *crypt = info->crypt[i];
                if (crypt) {
                        if (crypt->ops) {
                                crypt->ops->deinit(crypt->priv);
                                module_put(crypt->ops->owner);
                        }
                        kfree(crypt);
                        info->crypt[i] = NULL;
                }
        }
}
EXPORT_SYMBOL(lib80211_crypt_info_free);

void lib80211_crypt_deinit_entries(struct lib80211_crypt_info *info, int force)
{
	struct lib80211_crypt_data *entry, *next;
	unsigned long flags;

	spin_lock_irqsave(info->lock, flags);
	list_for_each_entry_safe(entry, next, &info->crypt_deinit_list, list) {
		if (atomic_read(&entry->refcnt) != 0 && !force)
			continue;

		list_del(&entry->list);

		if (entry->ops) {
			entry->ops->deinit(entry->priv);
			module_put(entry->ops->owner);
		}
		kfree(entry);
	}
	spin_unlock_irqrestore(info->lock, flags);
}
EXPORT_SYMBOL(lib80211_crypt_deinit_entries);

/* After this, crypt_deinit_list won't accept new members */
void lib80211_crypt_quiescing(struct lib80211_crypt_info *info)
{
	unsigned long flags;

	spin_lock_irqsave(info->lock, flags);
	info->crypt_quiesced = 1;
	spin_unlock_irqrestore(info->lock, flags);
}
EXPORT_SYMBOL(lib80211_crypt_quiescing);

void lib80211_crypt_deinit_handler(unsigned long data)
{
	struct lib80211_crypt_info *info = (struct lib80211_crypt_info *)data;
	unsigned long flags;

	lib80211_crypt_deinit_entries(info, 0);

	spin_lock_irqsave(info->lock, flags);
	if (!list_empty(&info->crypt_deinit_list) && !info->crypt_quiesced) {
		printk(KERN_DEBUG "%s: entries remaining in delayed crypt "
		       "deletion list\n", info->name);
		info->crypt_deinit_timer.expires = jiffies + HZ;
		add_timer(&info->crypt_deinit_timer);
	}
	spin_unlock_irqrestore(info->lock, flags);
}
EXPORT_SYMBOL(lib80211_crypt_deinit_handler);

void lib80211_crypt_delayed_deinit(struct lib80211_crypt_info *info,
				    struct lib80211_crypt_data **crypt)
{
	struct lib80211_crypt_data *tmp;
	unsigned long flags;

	if (*crypt == NULL)
		return;

	tmp = *crypt;
	*crypt = NULL;

	/* must not run ops->deinit() while there may be pending encrypt or
	 * decrypt operations. Use a list of delayed deinits to avoid needing
	 * locking. */

	spin_lock_irqsave(info->lock, flags);
	if (!info->crypt_quiesced) {
		list_add(&tmp->list, &info->crypt_deinit_list);
		if (!timer_pending(&info->crypt_deinit_timer)) {
			info->crypt_deinit_timer.expires = jiffies + HZ;
			add_timer(&info->crypt_deinit_timer);
		}
	}
	spin_unlock_irqrestore(info->lock, flags);
}
EXPORT_SYMBOL(lib80211_crypt_delayed_deinit);

int lib80211_register_crypto_ops(struct lib80211_crypto_ops *ops)
{
	unsigned long flags;
	struct lib80211_crypto_alg *alg;

	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
	if (alg == NULL)
		return -ENOMEM;

	alg->ops = ops;

	spin_lock_irqsave(&lib80211_crypto_lock, flags);
	list_add(&alg->list, &lib80211_crypto_algs);
	spin_unlock_irqrestore(&lib80211_crypto_lock, flags);

	printk(KERN_DEBUG "lib80211_crypt: registered algorithm '%s'\n",
	       ops->name);

	return 0;
}
EXPORT_SYMBOL(lib80211_register_crypto_ops);

int lib80211_unregister_crypto_ops(struct lib80211_crypto_ops *ops)
{
	struct lib80211_crypto_alg *alg;
	unsigned long flags;

	spin_lock_irqsave(&lib80211_crypto_lock, flags);
	list_for_each_entry(alg, &lib80211_crypto_algs, list) {
		if (alg->ops == ops)
			goto found;
	}
	spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
	return -EINVAL;

      found:
	printk(KERN_DEBUG "lib80211_crypt: unregistered algorithm "
	       "'%s'\n", ops->name);
	list_del(&alg->list);
	spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
	kfree(alg);
	return 0;
}
EXPORT_SYMBOL(lib80211_unregister_crypto_ops);

struct lib80211_crypto_ops *lib80211_get_crypto_ops(const char *name)
{
	struct lib80211_crypto_alg *alg;
	unsigned long flags;

	spin_lock_irqsave(&lib80211_crypto_lock, flags);
	list_for_each_entry(alg, &lib80211_crypto_algs, list) {
		if (strcmp(alg->ops->name, name) == 0)
			goto found;
	}
	spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
	return NULL;

      found:
	spin_unlock_irqrestore(&lib80211_crypto_lock, flags);
	return alg->ops;
}
EXPORT_SYMBOL(lib80211_get_crypto_ops);

static void *lib80211_crypt_null_init(int keyidx)
{
	return (void *)1;
}

static void lib80211_crypt_null_deinit(void *priv)
{
}

static struct lib80211_crypto_ops lib80211_crypt_null = {
	.name = "NULL",
	.init = lib80211_crypt_null_init,
	.deinit = lib80211_crypt_null_deinit,
	.owner = THIS_MODULE,
};

static int __init lib80211_init(void)
{
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION "\n");
	return lib80211_register_crypto_ops(&lib80211_crypt_null);
}

static void __exit lib80211_exit(void)
{
	lib80211_unregister_crypto_ops(&lib80211_crypt_null);
	BUG_ON(!list_empty(&lib80211_crypto_algs));
}

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