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