[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;

	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;

	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";
	char *p = (char *)buf;
	unsigned long val;

	if (count > sizeof(buf) - 1)
		count = sizeof(buf) - 1;

	if (copy_from_user(buf, buffer, count))
		return count;
	buf[count] = 0;
	/*
	 * what a FPOS...  What, sscanf(buf, "%i", &val) would be too
	 * scary?
	 */
	if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
		p++;
		if (p[0] == 'x' || p[0] == 'X')
			p++;
		val = simple_strtoul(p, &p, 16);
	} else
		val = simple_strtoul(p, &p, 10);
	if (p == buf)
		printk(KERN_INFO DRV_NAME
		       ": %s is not in hex or decimal form.\n", buf);
	else
		ieee80211_debug_level = val;

	return strlen(buf);
}

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