[GitHub/mt8127/android_kernel_alcatel_ttab.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/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/wireless.h>
#include <linux/etherdevice.h>
#include <asm/uaccess.h>
#include <net/arp.h>

#include <net/ieee80211.h>

#define DRV_DESCRIPTION "802.11 data/management/control stack"
#define DRV_NAME        "ieee80211"
#define DRV_VERSION	IEEE80211_VERSION
#define DRV_COPYRIGHT   "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"

MODULE_VERSION(DRV_VERSION);
MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_AUTHOR(DRV_COPYRIGHT);
MODULE_LICENSE("GPL");

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

	ieee->networks =
	    kzalloc(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;
	}

	return 0;
}

void ieee80211_network_reset(struct ieee80211_network *network)
{
	if (!network)
		return;

	if (network->ibss_dfs) {
		kfree(network->ibss_dfs);
		network->ibss_dfs = NULL;
	}
}

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

	if (!ieee->networks)
		return;

	for (i = 0; i < MAX_NETWORK_COUNT; i++)
		if (ieee->networks[i].ibss_dfs)
			kfree(ieee->networks[i].ibss_dfs);

	kfree(ieee->networks);
	ieee->networks = NULL;
}

static 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);
}

static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
{
	if ((new_mtu < 68) || (new_mtu > IEEE80211_DATA_LEN))
		return -EINVAL;
	dev->mtu = new_mtu;
	return 0;
}

static struct net_device_stats *ieee80211_generic_get_stats(
	struct net_device *dev)
{
	struct ieee80211_device *ieee = netdev_priv(dev);
	return &ieee->stats;
}

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;
	dev->change_mtu = ieee80211_change_mtu;

	/* Drivers are free to override this if the generic implementation
	 * does not meet their needs. */
	dev->get_stats = ieee80211_generic_get_stats;

	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->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;
static 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);
}
#endif				/* CONFIG_IEEE80211_DEBUG */

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

	ieee80211_debug_level = debug;
	ieee80211_proc = proc_mkdir(DRV_NAME, 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;
#endif				/* CONFIG_IEEE80211_DEBUG */

	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");

	return 0;
}

static void __exit ieee80211_exit(void)
{
#ifdef CONFIG_IEEE80211_DEBUG
	if (ieee80211_proc) {
		remove_proc_entry("debug_level", ieee80211_proc);
		remove_proc_entry(DRV_NAME, proc_net);
		ieee80211_proc = NULL;
	}
#endif				/* CONFIG_IEEE80211_DEBUG */
}

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

module_exit(ieee80211_exit);
module_init(ieee80211_init);

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>
b453872c JG	34	#include <linux/errno.h>
	35	#include <linux/if_arp.h>
	36	#include <linux/in6.h>
	37	#include <linux/in.h>
	38	#include <linux/ip.h>
	39	#include <linux/kernel.h>
	40	#include <linux/module.h>
	41	#include <linux/netdevice.h>
b453872c JG	42	#include <linux/proc_fs.h>
	43	#include <linux/skbuff.h>
	44	#include <linux/slab.h>
	45	#include <linux/tcp.h>
	46	#include <linux/types.h>
b453872c JG	47	#include <linux/wireless.h>
	48	#include <linux/etherdevice.h>
	49	#include <asm/uaccess.h>
	50	#include <net/arp.h>
	51
	52	#include <net/ieee80211.h>
	53
31696160 JK	54	#define DRV_DESCRIPTION "802.11 data/management/control stack"
	55	#define DRV_NAME "ieee80211"
	56	#define DRV_VERSION IEEE80211_VERSION
	57	#define DRV_COPYRIGHT "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"
	58
	59	MODULE_VERSION(DRV_VERSION);
	60	MODULE_DESCRIPTION(DRV_DESCRIPTION);
	61	MODULE_AUTHOR(DRV_COPYRIGHT);
b453872c JG	62	MODULE_LICENSE("GPL");
b453872c JG	63
858119e1	64	static int ieee80211_networks_allocate(struct ieee80211_device *ieee)
b453872c JG	65	{
	66	if (ieee->networks)
	67	return 0;
	68
0edd5b44	69	ieee->networks =
571d6eee	70	kzalloc(MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
0edd5b44	71	GFP_KERNEL);
b453872c JG	72	if (!ieee->networks) {
	73	printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
	74	ieee->dev->name);
	75	return -ENOMEM;
	76	}
	77
b453872c JG	78	return 0;
	79	}
	80
15f38598 ZY	81	void ieee80211_network_reset(struct ieee80211_network *network)
	82	{
	83	if (!network)
	84	return;
	85
	86	if (network->ibss_dfs) {
	87	kfree(network->ibss_dfs);
	88	network->ibss_dfs = NULL;
	89	}
	90	}
	91
b453872c JG	92	static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
b453872c JG	93	{
15f38598 ZY	94	int i;
15f38598 ZY	95
b453872c JG	96	if (!ieee->networks)
b453872c JG	97	return;
15f38598 ZY	98
	99	for (i = 0; i < MAX_NETWORK_COUNT; i++)
	100	if (ieee->networks[i].ibss_dfs)
	101	kfree(ieee->networks[i].ibss_dfs);
	102
b453872c JG	103	kfree(ieee->networks);
	104	ieee->networks = NULL;
	105	}
	106
858119e1	107	static void ieee80211_networks_initialize(struct ieee80211_device *ieee)
b453872c JG	108	{
	109	int i;
	110
	111	INIT_LIST_HEAD(&ieee->network_free_list);
	112	INIT_LIST_HEAD(&ieee->network_list);
	113	for (i = 0; i < MAX_NETWORK_COUNT; i++)
0edd5b44 JG	114	list_add_tail(&ieee->networks[i].list,
0edd5b44 JG	115	&ieee->network_free_list);
b453872c JG	116	}
b453872c JG	117
42a4cf95 MC	118	static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
	119	{
	120	if ((new_mtu < 68) \|\| (new_mtu > IEEE80211_DATA_LEN))
	121	return -EINVAL;
	122	dev->mtu = new_mtu;
	123	return 0;
	124	}
	125
718cc4ca DD	126	static struct net_device_stats *ieee80211_generic_get_stats(
	127	struct net_device *dev)
	128	{
	129	struct ieee80211_device *ieee = netdev_priv(dev);
	130	return &ieee->stats;
	131	}
	132
b453872c JG	133	struct net_device *alloc_ieee80211(int sizeof_priv)
	134	{
	135	struct ieee80211_device *ieee;
	136	struct net_device *dev;
	137	int err;
	138
	139	IEEE80211_DEBUG_INFO("Initializing...\n");
	140
	141	dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
	142	if (!dev) {
	143	IEEE80211_ERROR("Unable to network device.\n");
	144	goto failed;
	145	}
	146	ieee = netdev_priv(dev);
	147	dev->hard_start_xmit = ieee80211_xmit;
42a4cf95	148	dev->change_mtu = ieee80211_change_mtu;
b453872c	149
718cc4ca DD	150	/* Drivers are free to override this if the generic implementation
	151	* does not meet their needs. */
	152	dev->get_stats = ieee80211_generic_get_stats;
	153
b453872c JG	154	ieee->dev = dev;
	155
	156	err = ieee80211_networks_allocate(ieee);
	157	if (err) {
0edd5b44	158	IEEE80211_ERROR("Unable to allocate beacon storage: %d\n", err);
b453872c JG	159	goto failed;
	160	}
	161	ieee80211_networks_initialize(ieee);
	162
	163	/* Default fragmentation threshold is maximum payload size */
	164	ieee->fts = DEFAULT_FTS;
3cdd00c5	165	ieee->rts = DEFAULT_FTS;
b453872c JG	166	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
	167	ieee->open_wep = 1;
	168
	169	/* Default to enabling full open WEP with host based encrypt/decrypt */
	170	ieee->host_encrypt = 1;
	171	ieee->host_decrypt = 1;
ccd0fda3 JK	172	ieee->host_mc_decrypt = 1;
ccd0fda3 JK	173
1264fc04 JK	174	/* Host fragementation in Open mode. Default is enabled.
	175	* Note: host fragmentation is always enabled if host encryption
	176	* is enabled. For cards can do hardware encryption, they must do
	177	* hardware fragmentation as well. So we don't need a variable
	178	* like host_enc_frag. */
	179	ieee->host_open_frag = 1;
0edd5b44	180	ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
b453872c JG	181
	182	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	183	init_timer(&ieee->crypt_deinit_timer);
	184	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	185	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
0ad0c3c6	186	ieee->crypt_quiesced = 0;
b453872c JG	187
	188	spin_lock_init(&ieee->lock);
	189
0edd5b44	190	ieee->wpa_enabled = 0;
0edd5b44 JG	191	ieee->drop_unencrypted = 0;
0edd5b44 JG	192	ieee->privacy_invoked = 0;
b453872c JG	193
	194	return dev;
	195
0edd5b44	196	failed:
b453872c JG	197	if (dev)
	198	free_netdev(dev);
	199	return NULL;
	200	}
	201
b453872c JG	202	void free_ieee80211(struct net_device *dev)
	203	{
	204	struct ieee80211_device *ieee = netdev_priv(dev);
	205
	206	int i;
	207
0ad0c3c6	208	ieee80211_crypt_quiescing(ieee);
b453872c JG	209	del_timer_sync(&ieee->crypt_deinit_timer);
	210	ieee80211_crypt_deinit_entries(ieee, 1);
	211
	212	for (i = 0; i < WEP_KEYS; i++) {
	213	struct ieee80211_crypt_data *crypt = ieee->crypt[i];
	214	if (crypt) {
	215	if (crypt->ops) {
	216	crypt->ops->deinit(crypt->priv);
	217	module_put(crypt->ops->owner);
	218	}
	219	kfree(crypt);
	220	ieee->crypt[i] = NULL;
	221	}
	222	}
	223
	224	ieee80211_networks_free(ieee);
	225	free_netdev(dev);
	226	}
	227
	228	#ifdef CONFIG_IEEE80211_DEBUG
	229
	230	static int debug = 0;
	231	u32 ieee80211_debug_level = 0;
b7cffb02	232	static struct proc_dir_entry *ieee80211_proc = NULL;
b453872c JG	233
	234	static int show_debug_level(char page, char *start, off_t offset,
	235	int count, int eof, void data)
	236	{
	237	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
	238	}
	239
0edd5b44	240	static int store_debug_level(struct file file, const char __user buffer,
b453872c JG	241	unsigned long count, void *data)
b453872c JG	242	{
262d8e46 JK	243	char buf[] = "0x00000000\n";
262d8e46 JK	244	unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
b453872c JG	245	unsigned long val;
b453872c JG	246
262d8e46	247	if (copy_from_user(buf, buffer, len))
b453872c	248	return count;
262d8e46 JK	249	buf[len] = 0;
262d8e46 JK	250	if (sscanf(buf, "%li", &val) != 1)
b453872c JG	251	printk(KERN_INFO DRV_NAME
	252	": %s is not in hex or decimal form.\n", buf);
	253	else
	254	ieee80211_debug_level = val;
	255
262d8e46	256	return strnlen(buf, len);
b453872c	257	}
31696160	258	#endif /* CONFIG_IEEE80211_DEBUG */
b453872c JG	259
	260	static int __init ieee80211_init(void)
	261	{
31696160	262	#ifdef CONFIG_IEEE80211_DEBUG
b453872c JG	263	struct proc_dir_entry *e;
	264
	265	ieee80211_debug_level = debug;
66600221	266	ieee80211_proc = proc_mkdir(DRV_NAME, proc_net);
b453872c JG	267	if (ieee80211_proc == NULL) {
	268	IEEE80211_ERROR("Unable to create " DRV_NAME
	269	" proc directory\n");
	270	return -EIO;
	271	}
	272	e = create_proc_entry("debug_level", S_IFREG \| S_IRUGO \| S_IWUSR,
	273	ieee80211_proc);
	274	if (!e) {
	275	remove_proc_entry(DRV_NAME, proc_net);
	276	ieee80211_proc = NULL;
	277	return -EIO;
	278	}
	279	e->read_proc = show_debug_level;
	280	e->write_proc = store_debug_level;
	281	e->data = NULL;
31696160 JK	282	#endif /* CONFIG_IEEE80211_DEBUG */
	283
	284	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	285	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
b453872c JG	286
	287	return 0;
	288	}
	289
	290	static void __exit ieee80211_exit(void)
	291	{
31696160	292	#ifdef CONFIG_IEEE80211_DEBUG
b453872c JG	293	if (ieee80211_proc) {
	294	remove_proc_entry("debug_level", ieee80211_proc);
	295	remove_proc_entry(DRV_NAME, proc_net);
	296	ieee80211_proc = NULL;
	297	}
31696160	298	#endif /* CONFIG_IEEE80211_DEBUG */
b453872c JG	299	}
b453872c JG	300
31696160	301	#ifdef CONFIG_IEEE80211_DEBUG
b453872c JG	302	#include <linux/moduleparam.h>
	303	module_param(debug, int, 0444);
	304	MODULE_PARM_DESC(debug, "debug output mask");
31696160	305	#endif /* CONFIG_IEEE80211_DEBUG */
b453872c	306
b453872c JG	307	module_exit(ieee80211_exit);
b453872c JG	308	module_init(ieee80211_init);
b453872c	309
0edd5b44 JG	310	const char escape_essid(const char essid, u8 essid_len)
0edd5b44 JG	311	{
e88187ee JB	312	static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
	313	const char *s = essid;
	314	char *d = escaped;
	315
	316	if (ieee80211_is_empty_essid(essid, essid_len)) {
	317	memcpy(escaped, "<hidden>", sizeof("<hidden>"));
	318	return escaped;
	319	}
	320
0edd5b44	321	essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
e88187ee JB	322	while (essid_len--) {
	323	if (*s == '\0') {
	324	*d++ = '\\';
	325	*d++ = '0';
	326	s++;
	327	} else {
	328	d++ = s++;
	329	}
	330	}
	331	*d = '\0';
	332	return escaped;
	333	}
	334
b453872c JG	335	EXPORT_SYMBOL(alloc_ieee80211);
b453872c JG	336	EXPORT_SYMBOL(free_ieee80211);
e88187ee	337	EXPORT_SYMBOL(escape_essid);