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