[deliverable/linux.git] / net / ieee80211 / ieee80211_module.c

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

  Copyright(c) 2004-2005 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;
	ieee->host_mc_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	/*******************************************************************************
b453872c JG	2
ebeaddcc	3	Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
b453872c JG	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;
ccd0fda3 JK	136	ieee->host_mc_decrypt = 1;
ccd0fda3 JK	137
1264fc04 JK	138	/* Host fragementation in Open mode. Default is enabled.
	139	* Note: host fragmentation is always enabled if host encryption
	140	* is enabled. For cards can do hardware encryption, they must do
	141	* hardware fragmentation as well. So we don't need a variable
	142	* like host_enc_frag. */
	143	ieee->host_open_frag = 1;
0edd5b44	144	ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
b453872c JG	145
	146	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	147	init_timer(&ieee->crypt_deinit_timer);
	148	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	149	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
0ad0c3c6	150	ieee->crypt_quiesced = 0;
b453872c JG	151
	152	spin_lock_init(&ieee->lock);
	153
0edd5b44 JG	154	ieee->wpa_enabled = 0;
	155	ieee->tkip_countermeasures = 0;
	156	ieee->drop_unencrypted = 0;
	157	ieee->privacy_invoked = 0;
b453872c JG	158
	159	return dev;
	160
0edd5b44	161	failed:
b453872c JG	162	if (dev)
	163	free_netdev(dev);
	164	return NULL;
	165	}
	166
b453872c JG	167	void free_ieee80211(struct net_device *dev)
	168	{
	169	struct ieee80211_device *ieee = netdev_priv(dev);
	170
	171	int i;
	172
0ad0c3c6	173	ieee80211_crypt_quiescing(ieee);
b453872c JG	174	del_timer_sync(&ieee->crypt_deinit_timer);
	175	ieee80211_crypt_deinit_entries(ieee, 1);
	176
	177	for (i = 0; i < WEP_KEYS; i++) {
	178	struct ieee80211_crypt_data *crypt = ieee->crypt[i];
	179	if (crypt) {
	180	if (crypt->ops) {
	181	crypt->ops->deinit(crypt->priv);
	182	module_put(crypt->ops->owner);
	183	}
	184	kfree(crypt);
	185	ieee->crypt[i] = NULL;
	186	}
	187	}
	188
	189	ieee80211_networks_free(ieee);
	190	free_netdev(dev);
	191	}
	192
	193	#ifdef CONFIG_IEEE80211_DEBUG
	194
	195	static int debug = 0;
	196	u32 ieee80211_debug_level = 0;
	197	struct proc_dir_entry *ieee80211_proc = NULL;
	198
	199	static int show_debug_level(char page, char *start, off_t offset,
	200	int count, int eof, void data)
	201	{
	202	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
	203	}
	204
0edd5b44	205	static int store_debug_level(struct file file, const char __user buffer,
b453872c JG	206	unsigned long count, void *data)
b453872c JG	207	{
262d8e46 JK	208	char buf[] = "0x00000000\n";
262d8e46 JK	209	unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
b453872c JG	210	unsigned long val;
b453872c JG	211
262d8e46	212	if (copy_from_user(buf, buffer, len))
b453872c	213	return count;
262d8e46 JK	214	buf[len] = 0;
262d8e46 JK	215	if (sscanf(buf, "%li", &val) != 1)
b453872c JG	216	printk(KERN_INFO DRV_NAME
	217	": %s is not in hex or decimal form.\n", buf);
	218	else
	219	ieee80211_debug_level = val;
	220
262d8e46	221	return strnlen(buf, len);
b453872c JG	222	}
	223
	224	static int __init ieee80211_init(void)
	225	{
	226	struct proc_dir_entry *e;
	227
	228	ieee80211_debug_level = debug;
	229	ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
	230	if (ieee80211_proc == NULL) {
	231	IEEE80211_ERROR("Unable to create " DRV_NAME
	232	" proc directory\n");
	233	return -EIO;
	234	}
	235	e = create_proc_entry("debug_level", S_IFREG \| S_IRUGO \| S_IWUSR,
	236	ieee80211_proc);
	237	if (!e) {
	238	remove_proc_entry(DRV_NAME, proc_net);
	239	ieee80211_proc = NULL;
	240	return -EIO;
	241	}
	242	e->read_proc = show_debug_level;
	243	e->write_proc = store_debug_level;
	244	e->data = NULL;
	245
	246	return 0;
	247	}
	248
	249	static void __exit ieee80211_exit(void)
	250	{
	251	if (ieee80211_proc) {
	252	remove_proc_entry("debug_level", ieee80211_proc);
	253	remove_proc_entry(DRV_NAME, proc_net);
	254	ieee80211_proc = NULL;
	255	}
	256	}
	257
	258	#include <linux/moduleparam.h>
	259	module_param(debug, int, 0444);
	260	MODULE_PARM_DESC(debug, "debug output mask");
	261
b453872c JG	262	module_exit(ieee80211_exit);
	263	module_init(ieee80211_init);
	264	#endif
	265
0edd5b44 JG	266	const char escape_essid(const char essid, u8 essid_len)
0edd5b44 JG	267	{
e88187ee JB	268	static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
	269	const char *s = essid;
	270	char *d = escaped;
	271
	272	if (ieee80211_is_empty_essid(essid, essid_len)) {
	273	memcpy(escaped, "<hidden>", sizeof("<hidden>"));
	274	return escaped;
	275	}
	276
0edd5b44	277	essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
e88187ee JB	278	while (essid_len--) {
	279	if (*s == '\0') {
	280	*d++ = '\\';
	281	*d++ = '0';
	282	s++;
	283	} else {
	284	d++ = s++;
	285	}
	286	}
	287	*d = '\0';
	288	return escaped;
	289	}
	290
b453872c JG	291	EXPORT_SYMBOL(alloc_ieee80211);
b453872c JG	292	EXPORT_SYMBOL(free_ieee80211);
e88187ee	293	EXPORT_SYMBOL(escape_essid);