[GitHub/mt8127/android_kernel_alcatel_ttab.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->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->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;
	ieee->ieee802_1x = 1;

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