[linux-2.6-block.git] / net / ieee80211 / ieee80211_module.c

/*******************************************************************************

  Copyright(c) 2004 Intel Corporation. All rights reserved.

  Portions of this file are based on the WEP enablement code provided by the
  Host AP project hostap-drivers v0.1.3
  Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
  <jkmaline@cc.hut.fi>
  Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  The full GNU General Public License is included in this distribution in the
  file called LICENSE.

  Contact Information:
  James P. Ketrenos <ipw2100-admin@linux.intel.com>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include <linux/compiler.h>
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/if_arp.h>
#include <linux/in6.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/tcp.h>
#include <linux/types.h>
#include <linux/version.h>
#include <linux/wireless.h>
#include <linux/etherdevice.h>
#include <asm/uaccess.h>
#include <net/arp.h>

#include <net/ieee80211.h>

MODULE_DESCRIPTION("802.11 data/management/control stack");
MODULE_AUTHOR
    ("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
MODULE_LICENSE("GPL");

#define DRV_NAME "ieee80211"

static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
{
	if (ieee->networks)
		return 0;

	ieee->networks =
	    kmalloc(MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
		    GFP_KERNEL);
	if (!ieee->networks) {
		printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
		       ieee->dev->name);
		return -ENOMEM;
	}

	memset(ieee->networks, 0,
	       MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));

	return 0;
}

static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
{
	if (!ieee->networks)
		return;
	kfree(ieee->networks);
	ieee->networks = NULL;
}

static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
{
	int i;

	INIT_LIST_HEAD(&ieee->network_free_list);
	INIT_LIST_HEAD(&ieee->network_list);
	for (i = 0; i < MAX_NETWORK_COUNT; i++)
		list_add_tail(&ieee->networks[i].list,
			      &ieee->network_free_list);
}

struct net_device *alloc_ieee80211(int sizeof_priv)
{
	struct ieee80211_device *ieee;
	struct net_device *dev;
	int err;

	IEEE80211_DEBUG_INFO("Initializing...\n");

	dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
	if (!dev) {
		IEEE80211_ERROR("Unable to network device.\n");
		goto failed;
	}
	ieee = netdev_priv(dev);
	dev->hard_start_xmit = ieee80211_xmit;

	ieee->dev = dev;

	err = ieee80211_networks_allocate(ieee);
	if (err) {
		IEEE80211_ERROR("Unable to allocate beacon storage: %d\n", err);
		goto failed;
	}
	ieee80211_networks_initialize(ieee);

	/* Default fragmentation threshold is maximum payload size */
	ieee->fts = DEFAULT_FTS;
	ieee->rts = DEFAULT_FTS;
	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
	ieee->open_wep = 1;

	/* Default to enabling full open WEP with host based encrypt/decrypt */
	ieee->host_encrypt = 1;
	ieee->host_decrypt = 1;
	/* Host fragementation in Open mode. Default is enabled.
	 * Note: host fragmentation is always enabled if host encryption
	 * is enabled. For cards can do hardware encryption, they must do
	 * hardware fragmentation as well. So we don't need a variable
	 * like host_enc_frag. */
	ieee->host_open_frag = 1;
	ieee->ieee802_1x = 1;	/* Default to supporting 802.1x */

	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	init_timer(&ieee->crypt_deinit_timer);
	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
	ieee->crypt_quiesced = 0;

	spin_lock_init(&ieee->lock);

	ieee->wpa_enabled = 0;
	ieee->tkip_countermeasures = 0;
	ieee->drop_unencrypted = 0;
	ieee->privacy_invoked = 0;

	return dev;

      failed:
	if (dev)
		free_netdev(dev);
	return NULL;
}

void free_ieee80211(struct net_device *dev)
{
	struct ieee80211_device *ieee = netdev_priv(dev);

	int i;

	ieee80211_crypt_quiescing(ieee);
	del_timer_sync(&ieee->crypt_deinit_timer);
	ieee80211_crypt_deinit_entries(ieee, 1);

	for (i = 0; i < WEP_KEYS; i++) {
		struct ieee80211_crypt_data *crypt = ieee->crypt[i];
		if (crypt) {
			if (crypt->ops) {
				crypt->ops->deinit(crypt->priv);
				module_put(crypt->ops->owner);
			}
			kfree(crypt);
			ieee->crypt[i] = NULL;
		}
	}

	ieee80211_networks_free(ieee);
	free_netdev(dev);
}

#ifdef CONFIG_IEEE80211_DEBUG

static int debug = 0;
u32 ieee80211_debug_level = 0;
struct proc_dir_entry *ieee80211_proc = NULL;

static int show_debug_level(char *page, char **start, off_t offset,
			    int count, int *eof, void *data)
{
	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
}

static int store_debug_level(struct file *file, const char __user * buffer,
			     unsigned long count, void *data)
{
	char buf[] = "0x00000000\n";
	unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
	unsigned long val;

	if (copy_from_user(buf, buffer, len))
		return count;
	buf[len] = 0;
	if (sscanf(buf, "%li", &val) != 1)
		printk(KERN_INFO DRV_NAME
		       ": %s is not in hex or decimal form.\n", buf);
	else
		ieee80211_debug_level = val;

	return strnlen(buf, len);
}

static int __init ieee80211_init(void)
{
	struct proc_dir_entry *e;

	ieee80211_debug_level = debug;
	ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
	if (ieee80211_proc == NULL) {
		IEEE80211_ERROR("Unable to create " DRV_NAME
				" proc directory\n");
		return -EIO;
	}
	e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
			      ieee80211_proc);
	if (!e) {
		remove_proc_entry(DRV_NAME, proc_net);
		ieee80211_proc = NULL;
		return -EIO;
	}
	e->read_proc = show_debug_level;
	e->write_proc = store_debug_level;
	e->data = NULL;

	return 0;
}

static void __exit ieee80211_exit(void)
{
	if (ieee80211_proc) {
		remove_proc_entry("debug_level", ieee80211_proc);
		remove_proc_entry(DRV_NAME, proc_net);
		ieee80211_proc = NULL;
	}
}

#include <linux/moduleparam.h>
module_param(debug, int, 0444);
MODULE_PARM_DESC(debug, "debug output mask");

module_exit(ieee80211_exit);
module_init(ieee80211_init);
#endif

const char *escape_essid(const char *essid, u8 essid_len)
{
	static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
	const char *s = essid;
	char *d = escaped;

	if (ieee80211_is_empty_essid(essid, essid_len)) {
		memcpy(escaped, "<hidden>", sizeof("<hidden>"));
		return escaped;
	}

	essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
	while (essid_len--) {
		if (*s == '\0') {
			*d++ = '\\';
			*d++ = '0';
			s++;
		} else {
			*d++ = *s++;
		}
	}
	*d = '\0';
	return escaped;
}

EXPORT_SYMBOL(alloc_ieee80211);
EXPORT_SYMBOL(free_ieee80211);
EXPORT_SYMBOL(escape_essid);
Commit	Line	Data
b453872c JG	1	/*******************************************************************************
	2
	3	Copyright(c) 2004 Intel Corporation. All rights reserved.
	4
	5	Portions of this file are based on the WEP enablement code provided by the
	6	Host AP project hostap-drivers v0.1.3
	7	Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
	8	<jkmaline@cc.hut.fi>
	9	Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
	10
	11	This program is free software; you can redistribute it and/or modify it
	12	under the terms of version 2 of the GNU General Public License as
	13	published by the Free Software Foundation.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	17	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	18	more details.
	19
	20	You should have received a copy of the GNU General Public License along with
	21	this program; if not, write to the Free Software Foundation, Inc., 59
	22	Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	23
	24	The full GNU General Public License is included in this distribution in the
	25	file called LICENSE.
	26
	27	Contact Information:
	28	James P. Ketrenos <ipw2100-admin@linux.intel.com>
	29	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	30
	31	*******************************************************************************/
	32
	33	#include <linux/compiler.h>
	34	#include <linux/config.h>
	35	#include <linux/errno.h>
	36	#include <linux/if_arp.h>
	37	#include <linux/in6.h>
	38	#include <linux/in.h>
	39	#include <linux/ip.h>
	40	#include <linux/kernel.h>
	41	#include <linux/module.h>
	42	#include <linux/netdevice.h>
b453872c JG	43	#include <linux/proc_fs.h>
	44	#include <linux/skbuff.h>
	45	#include <linux/slab.h>
	46	#include <linux/tcp.h>
	47	#include <linux/types.h>
	48	#include <linux/version.h>
	49	#include <linux/wireless.h>
	50	#include <linux/etherdevice.h>
	51	#include <asm/uaccess.h>
	52	#include <net/arp.h>
	53
	54	#include <net/ieee80211.h>
	55
	56	MODULE_DESCRIPTION("802.11 data/management/control stack");
0edd5b44 JG	57	MODULE_AUTHOR
0edd5b44 JG	58	("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
b453872c JG	59	MODULE_LICENSE("GPL");
	60
	61	#define DRV_NAME "ieee80211"
	62
	63	static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
	64	{
	65	if (ieee->networks)
	66	return 0;
	67
0edd5b44 JG	68	ieee->networks =
	69	kmalloc(MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
	70	GFP_KERNEL);
b453872c JG	71	if (!ieee->networks) {
	72	printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
	73	ieee->dev->name);
	74	return -ENOMEM;
	75	}
	76
	77	memset(ieee->networks, 0,
	78	MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));
	79
	80	return 0;
	81	}
	82
	83	static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
	84	{
	85	if (!ieee->networks)
	86	return;
	87	kfree(ieee->networks);
	88	ieee->networks = NULL;
	89	}
	90
	91	static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
	92	{
	93	int i;
	94
	95	INIT_LIST_HEAD(&ieee->network_free_list);
	96	INIT_LIST_HEAD(&ieee->network_list);
	97	for (i = 0; i < MAX_NETWORK_COUNT; i++)
0edd5b44 JG	98	list_add_tail(&ieee->networks[i].list,
0edd5b44 JG	99	&ieee->network_free_list);
b453872c JG	100	}
b453872c JG	101
b453872c JG	102	struct net_device *alloc_ieee80211(int sizeof_priv)
	103	{
	104	struct ieee80211_device *ieee;
	105	struct net_device *dev;
	106	int err;
	107
	108	IEEE80211_DEBUG_INFO("Initializing...\n");
	109
	110	dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
	111	if (!dev) {
	112	IEEE80211_ERROR("Unable to network device.\n");
	113	goto failed;
	114	}
	115	ieee = netdev_priv(dev);
	116	dev->hard_start_xmit = ieee80211_xmit;
	117
	118	ieee->dev = dev;
	119
	120	err = ieee80211_networks_allocate(ieee);
	121	if (err) {
0edd5b44	122	IEEE80211_ERROR("Unable to allocate beacon storage: %d\n", err);
b453872c JG	123	goto failed;
	124	}
	125	ieee80211_networks_initialize(ieee);
	126
	127	/* Default fragmentation threshold is maximum payload size */
	128	ieee->fts = DEFAULT_FTS;
3cdd00c5	129	ieee->rts = DEFAULT_FTS;
b453872c JG	130	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
	131	ieee->open_wep = 1;
	132
	133	/* Default to enabling full open WEP with host based encrypt/decrypt */
	134	ieee->host_encrypt = 1;
	135	ieee->host_decrypt = 1;
1264fc04 JK	136	/* Host fragementation in Open mode. Default is enabled.
	137	* Note: host fragmentation is always enabled if host encryption
	138	* is enabled. For cards can do hardware encryption, they must do
	139	* hardware fragmentation as well. So we don't need a variable
	140	* like host_enc_frag. */
	141	ieee->host_open_frag = 1;
0edd5b44	142	ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
b453872c JG	143
	144	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	145	init_timer(&ieee->crypt_deinit_timer);
	146	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	147	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
0ad0c3c6	148	ieee->crypt_quiesced = 0;
b453872c JG	149
	150	spin_lock_init(&ieee->lock);
	151
0edd5b44 JG	152	ieee->wpa_enabled = 0;
	153	ieee->tkip_countermeasures = 0;
	154	ieee->drop_unencrypted = 0;
	155	ieee->privacy_invoked = 0;
b453872c JG	156
	157	return dev;
	158
0edd5b44	159	failed:
b453872c JG	160	if (dev)
	161	free_netdev(dev);
	162	return NULL;
	163	}
	164
b453872c JG	165	void free_ieee80211(struct net_device *dev)
	166	{
	167	struct ieee80211_device *ieee = netdev_priv(dev);
	168
	169	int i;
	170
0ad0c3c6	171	ieee80211_crypt_quiescing(ieee);
b453872c JG	172	del_timer_sync(&ieee->crypt_deinit_timer);
	173	ieee80211_crypt_deinit_entries(ieee, 1);
	174
	175	for (i = 0; i < WEP_KEYS; i++) {
	176	struct ieee80211_crypt_data *crypt = ieee->crypt[i];
	177	if (crypt) {
	178	if (crypt->ops) {
	179	crypt->ops->deinit(crypt->priv);
	180	module_put(crypt->ops->owner);
	181	}
	182	kfree(crypt);
	183	ieee->crypt[i] = NULL;
	184	}
	185	}
	186
	187	ieee80211_networks_free(ieee);
	188	free_netdev(dev);
	189	}
	190
	191	#ifdef CONFIG_IEEE80211_DEBUG
	192
	193	static int debug = 0;
	194	u32 ieee80211_debug_level = 0;
	195	struct proc_dir_entry *ieee80211_proc = NULL;
	196
	197	static int show_debug_level(char page, char *start, off_t offset,
	198	int count, int eof, void data)
	199	{
	200	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
	201	}
	202
0edd5b44	203	static int store_debug_level(struct file file, const char __user buffer,
b453872c JG	204	unsigned long count, void *data)
b453872c JG	205	{
262d8e46 JK	206	char buf[] = "0x00000000\n";
262d8e46 JK	207	unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
b453872c JG	208	unsigned long val;
b453872c JG	209
262d8e46	210	if (copy_from_user(buf, buffer, len))
b453872c	211	return count;
262d8e46 JK	212	buf[len] = 0;
262d8e46 JK	213	if (sscanf(buf, "%li", &val) != 1)
b453872c JG	214	printk(KERN_INFO DRV_NAME
	215	": %s is not in hex or decimal form.\n", buf);
	216	else
	217	ieee80211_debug_level = val;
	218
262d8e46	219	return strnlen(buf, len);
b453872c JG	220	}
	221
	222	static int __init ieee80211_init(void)
	223	{
	224	struct proc_dir_entry *e;
	225
	226	ieee80211_debug_level = debug;
	227	ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
	228	if (ieee80211_proc == NULL) {
	229	IEEE80211_ERROR("Unable to create " DRV_NAME
	230	" proc directory\n");
	231	return -EIO;
	232	}
	233	e = create_proc_entry("debug_level", S_IFREG \| S_IRUGO \| S_IWUSR,
	234	ieee80211_proc);
	235	if (!e) {
	236	remove_proc_entry(DRV_NAME, proc_net);
	237	ieee80211_proc = NULL;
	238	return -EIO;
	239	}
	240	e->read_proc = show_debug_level;
	241	e->write_proc = store_debug_level;
	242	e->data = NULL;
	243
	244	return 0;
	245	}
	246
	247	static void __exit ieee80211_exit(void)
	248	{
	249	if (ieee80211_proc) {
	250	remove_proc_entry("debug_level", ieee80211_proc);
	251	remove_proc_entry(DRV_NAME, proc_net);
	252	ieee80211_proc = NULL;
	253	}
	254	}
	255
	256	#include <linux/moduleparam.h>
	257	module_param(debug, int, 0444);
	258	MODULE_PARM_DESC(debug, "debug output mask");
	259
b453872c JG	260	module_exit(ieee80211_exit);
	261	module_init(ieee80211_init);
	262	#endif
	263
0edd5b44 JG	264	const char escape_essid(const char essid, u8 essid_len)
0edd5b44 JG	265	{
e88187ee JB	266	static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
	267	const char *s = essid;
	268	char *d = escaped;
	269
	270	if (ieee80211_is_empty_essid(essid, essid_len)) {
	271	memcpy(escaped, "<hidden>", sizeof("<hidden>"));
	272	return escaped;
	273	}
	274
0edd5b44	275	essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
e88187ee JB	276	while (essid_len--) {
	277	if (*s == '\0') {
	278	*d++ = '\\';
	279	*d++ = '0';
	280	s++;
	281	} else {
	282	d++ = s++;
	283	}
	284	}
	285	*d = '\0';
	286	return escaped;
	287	}
	288
b453872c JG	289	EXPORT_SYMBOL(alloc_ieee80211);
b453872c JG	290	EXPORT_SYMBOL(free_ieee80211);
e88187ee	291	EXPORT_SYMBOL(escape_essid);