[deliverable/linux.git] / net / ieee80211 / softmac / ieee80211softmac_auth.c

/*
 * This file contains the softmac's authentication logic.
 *
 * Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
 *                          Joseph Jezak <josejx@gentoo.org>
 *                          Larry Finger <Larry.Finger@lwfinger.net>
 *                          Danny van Dyk <kugelfang@gentoo.org>
 *                          Michael Buesch <mbuesch@freenet.de>
 *
 * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called COPYING.
 */

#include "ieee80211softmac_priv.h"

static void ieee80211softmac_auth_queue(void *data);

/* Queues an auth request to the desired AP */
int
ieee80211softmac_auth_req(struct ieee80211softmac_device *mac, 
	struct ieee80211softmac_network *net)
{
	struct ieee80211softmac_auth_queue_item *auth;
	unsigned long flags;
	
	function_enter();
	
	if (net->authenticating)
		return 0;

	/* Add the network if it's not already added */
	ieee80211softmac_add_network(mac, net);

	dprintk(KERN_NOTICE PFX "Queueing Authentication Request to "MAC_FMT"\n", MAC_ARG(net->bssid));
	/* Queue the auth request */
	auth = (struct ieee80211softmac_auth_queue_item *)
		kmalloc(sizeof(struct ieee80211softmac_auth_queue_item), GFP_KERNEL);
	if(auth == NULL)
		return -ENOMEM;

	auth->net = net;
	auth->mac = mac;
	auth->retry = IEEE80211SOFTMAC_AUTH_RETRY_LIMIT;
	auth->state = IEEE80211SOFTMAC_AUTH_OPEN_REQUEST;
	INIT_WORK(&auth->work, &ieee80211softmac_auth_queue, (void *)auth);
	
	/* Lock (for list) */
	spin_lock_irqsave(&mac->lock, flags);

	/* add to list */
	list_add_tail(&auth->list, &mac->auth_queue);
	schedule_work(&auth->work);
	spin_unlock_irqrestore(&mac->lock, flags);
	
	return 0;
}


/* Sends an auth request to the desired AP and handles timeouts */
static void
ieee80211softmac_auth_queue(void *data)
{
	struct ieee80211softmac_device *mac;
	struct ieee80211softmac_auth_queue_item *auth;
	struct ieee80211softmac_network *net;
	unsigned long flags;

	function_enter();
	
	auth = (struct ieee80211softmac_auth_queue_item *)data;
	net = auth->net;
	mac = auth->mac;

	if(auth->retry > 0) {
		/* Switch to correct channel for this network */
		mac->set_channel(mac->dev, net->channel);
		
		/* Lock and set flags */
		spin_lock_irqsave(&mac->lock, flags);
		net->authenticated = 0;
		net->authenticating = 1;
		/* add a timeout call so we eventually give up waiting for an auth reply */
		schedule_delayed_work(&auth->work, IEEE80211SOFTMAC_AUTH_TIMEOUT);
		auth->retry--;
		spin_unlock_irqrestore(&mac->lock, flags);
		if (ieee80211softmac_send_mgt_frame(mac, auth->net, IEEE80211_STYPE_AUTH, auth->state))
			dprintk(KERN_NOTICE PFX "Sending Authentication Request to "MAC_FMT" failed (this shouldn't happen, wait for the timeout).\n", MAC_ARG(net->bssid));
		else
			dprintk(KERN_NOTICE PFX "Sent Authentication Request to "MAC_FMT".\n", MAC_ARG(net->bssid));
		return;
	}

	printkl(KERN_WARNING PFX "Authentication timed out with "MAC_FMT"\n", MAC_ARG(net->bssid));
	/* Remove this item from the queue */
	spin_lock_irqsave(&mac->lock, flags);
	ieee80211softmac_call_events_locked(mac, IEEE80211SOFTMAC_EVENT_AUTH_TIMEOUT, net);
	cancel_delayed_work(&auth->work); /* just to make sure... */
	list_del(&auth->list);
	spin_unlock_irqrestore(&mac->lock, flags);
	/* Free it */
	kfree(auth);
}

/* Handle the auth response from the AP
 * This should be registered with ieee80211 as handle_auth 
 */
int 
ieee80211softmac_auth_resp(struct net_device *dev, struct ieee80211_auth *auth)
{	

	struct list_head *list_ptr;
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	struct ieee80211softmac_auth_queue_item *aq = NULL;
	struct ieee80211softmac_network *net = NULL;
	unsigned long flags;
	u8 * data;
	
	function_enter();
	
	/* Find correct auth queue item */
	spin_lock_irqsave(&mac->lock, flags);
	list_for_each(list_ptr, &mac->auth_queue) {
		aq = list_entry(list_ptr, struct ieee80211softmac_auth_queue_item, list);
		net = aq->net;
		if (!memcmp(net->bssid, auth->header.addr2, ETH_ALEN))
			break;
		else
			aq = NULL;
	}
	spin_unlock_irqrestore(&mac->lock, flags);
	
	/* Make sure that we've got an auth queue item for this request */
	if(aq == NULL)
	{
		printkl(KERN_DEBUG PFX "Authentication response received from "MAC_FMT" but no queue item exists.\n", MAC_ARG(auth->header.addr2));
		/* Error #? */
		return -1;
	}			
	
	/* Check for out of order authentication */
	if(!net->authenticating)
	{
		printkl(KERN_DEBUG PFX "Authentication response received from "MAC_FMT" but did not request authentication.\n",MAC_ARG(auth->header.addr2));
		return -1;
	}

	/* Parse the auth packet */
	switch(auth->algorithm) {
	case WLAN_AUTH_OPEN:
		/* Check the status code of the response */

		switch(auth->status) {
		case WLAN_STATUS_SUCCESS:
			/* Update the status to Authenticated */
			spin_lock_irqsave(&mac->lock, flags);
		        net->authenticating = 0;
			net->authenticated = 1;
			spin_unlock_irqrestore(&mac->lock, flags);
			
			/* Send event */
			printkl(KERN_NOTICE PFX "Open Authentication completed with "MAC_FMT"\n", MAC_ARG(net->bssid));
			ieee80211softmac_call_events(mac, IEEE80211SOFTMAC_EVENT_AUTHENTICATED, net);
			break;
		default:
			/* Lock and reset flags */
			spin_lock_irqsave(&mac->lock, flags);
			net->authenticated = 0;
			net->authenticating = 0;
			spin_unlock_irqrestore(&mac->lock, flags);
			
			printkl(KERN_NOTICE PFX "Open Authentication with "MAC_FMT" failed, error code: %i\n", 
				MAC_ARG(net->bssid), le16_to_cpup(&auth->status));
			/* Count the error? */
			break;
		}
		goto free_aq;
		break;
	case WLAN_AUTH_SHARED_KEY:
		/* Figure out where we are in the process */
		switch(auth->transaction) {
		case IEEE80211SOFTMAC_AUTH_SHARED_CHALLENGE:
			/* Check to make sure we have a challenge IE */
			data = (u8 *)auth->info_element;
			if(*data++ != MFIE_TYPE_CHALLENGE){
				printkl(KERN_NOTICE PFX "Shared Key Authentication failed due to a missing challenge.\n");
				break;	
			}
			/* Save the challenge */
			spin_lock_irqsave(&mac->lock, flags);
			net->challenge_len = *data++; 	
			if(net->challenge_len > WLAN_AUTH_CHALLENGE_LEN)
				net->challenge_len = WLAN_AUTH_CHALLENGE_LEN;
			if(net->challenge != NULL)
				kfree(net->challenge);
			net->challenge = kmalloc(net->challenge_len, GFP_ATOMIC);
			memcpy(net->challenge, data, net->challenge_len);
			aq->state = IEEE80211SOFTMAC_AUTH_SHARED_RESPONSE; 
			spin_unlock_irqrestore(&mac->lock, flags);

			/* Switch to correct channel for this network */
			mac->set_channel(mac->dev, net->channel);
			
			/* Send our response (How to encrypt?) */
			ieee80211softmac_send_mgt_frame(mac, aq->net, IEEE80211_STYPE_AUTH, aq->state);
			break;
		case IEEE80211SOFTMAC_AUTH_SHARED_PASS:
			/* Check the status code of the response */
			switch(auth->status) {
			case WLAN_STATUS_SUCCESS:
				/* Update the status to Authenticated */	
				spin_lock_irqsave(&mac->lock, flags);
				net->authenticating = 0;
				net->authenticated = 1;
				spin_unlock_irqrestore(&mac->lock, flags);
				printkl(KERN_NOTICE PFX "Shared Key Authentication completed with "MAC_FMT"\n", 
					MAC_ARG(net->bssid));
				break;
			default:
				printkl(KERN_NOTICE PFX "Shared Key Authentication with "MAC_FMT" failed, error code: %i\n", 
					MAC_ARG(net->bssid), le16_to_cpup(&auth->status));
				/* Lock and reset flags */
				spin_lock_irqsave(&mac->lock, flags);
 				net->authenticating = 0;
 				net->authenticated = 0;
				spin_unlock_irqrestore(&mac->lock, flags);
				/* Count the error? */
				break;
			}
			goto free_aq;
			break;
		default:
			printkl(KERN_WARNING PFX "Unhandled Authentication Step: %i\n", auth->transaction);
			break;
		}
		goto free_aq;
		break;
	default:
		/* ERROR */	
		goto free_aq;
		break;
	}
	return 0;
free_aq:
	/* Cancel the timeout */
	spin_lock_irqsave(&mac->lock, flags);
	cancel_delayed_work(&aq->work);
	/* Remove this item from the queue */
	list_del(&aq->list);
	spin_unlock_irqrestore(&mac->lock, flags);

	/* Free it */
	kfree(aq);
	return 0;
}

/*
 * Handle deauthorization
 */
static void
ieee80211softmac_deauth_from_net(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_network *net)
{
	struct ieee80211softmac_auth_queue_item *aq = NULL;
	struct list_head *list_ptr;
	unsigned long flags;

	function_enter();
	
	/* Lock and reset status flags */
	spin_lock_irqsave(&mac->lock, flags);
	net->authenticating = 0;
	net->authenticated = 0;
	
	/* Find correct auth queue item, if it exists */
	list_for_each(list_ptr, &mac->auth_queue) {
		aq = list_entry(list_ptr, struct ieee80211softmac_auth_queue_item, list);
		if (!memcmp(net->bssid, aq->net->bssid, ETH_ALEN))
			break;
		else
			aq = NULL;
	}
	
	/* Cancel pending work */
	if(aq != NULL)
		/* Not entirely safe?  What about running work? */
		cancel_delayed_work(&aq->work);

	/* Free our network ref */
	ieee80211softmac_del_network_locked(mac, net);
	if(net->challenge != NULL)
		kfree(net->challenge);
	kfree(net);
	
	/* can't transmit data right now... */
	netif_carrier_off(mac->dev);
	/* let's try to re-associate */
	schedule_work(&mac->associnfo.work);
	spin_unlock_irqrestore(&mac->lock, flags);
}

/* 
 * Sends a deauth request to the desired AP
 */
int 
ieee80211softmac_deauth_req(struct ieee80211softmac_device *mac, 
	struct ieee80211softmac_network *net, int reason)
{
	int ret;
	
	function_enter();

	/* Make sure the network is authenticated */
	if (!net->authenticated)
	{
		printkl(KERN_DEBUG PFX "Can't send deauthentication packet, network is not authenticated.\n");
		/* Error okay? */
		return -EPERM;
	}
	
	/* Send the de-auth packet */
	if((ret = ieee80211softmac_send_mgt_frame(mac, net, IEEE80211_STYPE_DEAUTH, reason)))
		return ret;
	
	ieee80211softmac_deauth_from_net(mac, net);
	return 0;
}
 
/*
 * This should be registered with ieee80211 as handle_deauth
 */
int 
ieee80211softmac_deauth_resp(struct net_device *dev, struct ieee80211_auth *auth)
{
	
	struct ieee80211softmac_network *net = NULL;
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	
	function_enter();
	
	if (!auth) {
		dprintk("deauth without deauth packet. eek!\n");
		return 0;
	}

	net = ieee80211softmac_get_network_by_bssid(mac, auth->header.addr2);
	
	if (net == NULL) {
		printkl(KERN_DEBUG PFX "Received deauthentication packet from "MAC_FMT", but that network is unknown.\n",
			MAC_ARG(auth->header.addr2));
		return 0;
	}

	/* Make sure the network is authenticated */
	if(!net->authenticated)
	{
		printkl(KERN_DEBUG PFX "Can't perform deauthentication, network is not authenticated.\n");
		/* Error okay? */
		return -EPERM;
	}

	ieee80211softmac_deauth_from_net(mac, net);
	return 0;
}
Commit	Line	Data
4855d25b JB	1	/*
	2	* This file contains the softmac's authentication logic.
	3	*
79859051 JB	4	* Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
	5	* Joseph Jezak <josejx@gentoo.org>
	6	* Larry Finger <Larry.Finger@lwfinger.net>
	7	* Danny van Dyk <kugelfang@gentoo.org>
	8	* Michael Buesch <mbuesch@freenet.de>
4855d25b JB	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of version 2 of the GNU General Public License as
	12	* published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	17	* more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	22	*
	23	* The full GNU General Public License is included in this distribution in the
	24	* file called COPYING.
	25	*/
	26
370121e5 JB	27	#include "ieee80211softmac_priv.h"
	28
	29	static void ieee80211softmac_auth_queue(void *data);
	30
	31	/* Queues an auth request to the desired AP */
	32	int
	33	ieee80211softmac_auth_req(struct ieee80211softmac_device *mac,
	34	struct ieee80211softmac_network *net)
	35	{
	36	struct ieee80211softmac_auth_queue_item *auth;
	37	unsigned long flags;
	38
	39	function_enter();
	40
	41	if (net->authenticating)
	42	return 0;
	43
	44	/* Add the network if it's not already added */
	45	ieee80211softmac_add_network(mac, net);
	46
	47	dprintk(KERN_NOTICE PFX "Queueing Authentication Request to "MAC_FMT"\n", MAC_ARG(net->bssid));
	48	/* Queue the auth request */
	49	auth = (struct ieee80211softmac_auth_queue_item *)
	50	kmalloc(sizeof(struct ieee80211softmac_auth_queue_item), GFP_KERNEL);
	51	if(auth == NULL)
	52	return -ENOMEM;
	53
	54	auth->net = net;
	55	auth->mac = mac;
	56	auth->retry = IEEE80211SOFTMAC_AUTH_RETRY_LIMIT;
	57	auth->state = IEEE80211SOFTMAC_AUTH_OPEN_REQUEST;
	58	INIT_WORK(&auth->work, &ieee80211softmac_auth_queue, (void *)auth);
	59
	60	/* Lock (for list) */
	61	spin_lock_irqsave(&mac->lock, flags);
	62
	63	/* add to list */
	64	list_add_tail(&auth->list, &mac->auth_queue);
5c4df6da	65	schedule_work(&auth->work);
370121e5 JB	66	spin_unlock_irqrestore(&mac->lock, flags);
	67
	68	return 0;
	69	}
	70
	71
	72	/* Sends an auth request to the desired AP and handles timeouts */
	73	static void
	74	ieee80211softmac_auth_queue(void *data)
	75	{
	76	struct ieee80211softmac_device *mac;
	77	struct ieee80211softmac_auth_queue_item *auth;
	78	struct ieee80211softmac_network *net;
	79	unsigned long flags;
	80
	81	function_enter();
	82
	83	auth = (struct ieee80211softmac_auth_queue_item *)data;
	84	net = auth->net;
	85	mac = auth->mac;
	86
	87	if(auth->retry > 0) {
	88	/* Switch to correct channel for this network */
	89	mac->set_channel(mac->dev, net->channel);
	90
	91	/* Lock and set flags */
	92	spin_lock_irqsave(&mac->lock, flags);
	93	net->authenticated = 0;
	94	net->authenticating = 1;
	95	/* add a timeout call so we eventually give up waiting for an auth reply */
5c4df6da	96	schedule_delayed_work(&auth->work, IEEE80211SOFTMAC_AUTH_TIMEOUT);
370121e5 JB	97	auth->retry--;
	98	spin_unlock_irqrestore(&mac->lock, flags);
	99	if (ieee80211softmac_send_mgt_frame(mac, auth->net, IEEE80211_STYPE_AUTH, auth->state))
	100	dprintk(KERN_NOTICE PFX "Sending Authentication Request to "MAC_FMT" failed (this shouldn't happen, wait for the timeout).\n", MAC_ARG(net->bssid));
	101	else
	102	dprintk(KERN_NOTICE PFX "Sent Authentication Request to "MAC_FMT".\n", MAC_ARG(net->bssid));
	103	return;
	104	}
	105
	106	printkl(KERN_WARNING PFX "Authentication timed out with "MAC_FMT"\n", MAC_ARG(net->bssid));
	107	/* Remove this item from the queue */
	108	spin_lock_irqsave(&mac->lock, flags);
	109	ieee80211softmac_call_events_locked(mac, IEEE80211SOFTMAC_EVENT_AUTH_TIMEOUT, net);
	110	cancel_delayed_work(&auth->work); /* just to make sure... */
	111	list_del(&auth->list);
	112	spin_unlock_irqrestore(&mac->lock, flags);
	113	/* Free it */
	114	kfree(auth);
	115	}
	116
	117	/* Handle the auth response from the AP
	118	* This should be registered with ieee80211 as handle_auth
	119	*/
	120	int
	121	ieee80211softmac_auth_resp(struct net_device dev, struct ieee80211_auth auth)
	122	{
	123
	124	struct list_head *list_ptr;
	125	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	126	struct ieee80211softmac_auth_queue_item *aq = NULL;
	127	struct ieee80211softmac_network *net = NULL;
	128	unsigned long flags;
	129	u8 * data;
	130
	131	function_enter();
	132
	133	/* Find correct auth queue item */
	134	spin_lock_irqsave(&mac->lock, flags);
	135	list_for_each(list_ptr, &mac->auth_queue) {
	136	aq = list_entry(list_ptr, struct ieee80211softmac_auth_queue_item, list);
	137	net = aq->net;
	138	if (!memcmp(net->bssid, auth->header.addr2, ETH_ALEN))
	139	break;
	140	else
	141	aq = NULL;
	142	}
	143	spin_unlock_irqrestore(&mac->lock, flags);
	144
	145	/* Make sure that we've got an auth queue item for this request */
	146	if(aq == NULL)
	147	{
	148	printkl(KERN_DEBUG PFX "Authentication response received from "MAC_FMT" but no queue item exists.\n", MAC_ARG(auth->header.addr2));
	149	/* Error #? */
	150	return -1;
	151	}
	152
	153	/* Check for out of order authentication */
	154	if(!net->authenticating)
	155	{
	156	printkl(KERN_DEBUG PFX "Authentication response received from "MAC_FMT" but did not request authentication.\n",MAC_ARG(auth->header.addr2));
	157	return -1;
	158	}
	159
	160	/* Parse the auth packet */
161	switch(auth->algorithm) {
162	case WLAN_AUTH_OPEN:
163	/* Check the status code of the response */
164
165	switch(auth->status) {
166	case WLAN_STATUS_SUCCESS:
167	/* Update the status to Authenticated */
168	spin_lock_irqsave(&mac->lock, flags);
169	net->authenticating = 0;
170	net->authenticated = 1;
171	spin_unlock_irqrestore(&mac->lock, flags);
172
173	/* Send event */
174	printkl(KERN_NOTICE PFX "Open Authentication completed with "MAC_FMT"\n", MAC_ARG(net->bssid));
175	ieee80211softmac_call_events(mac, IEEE80211SOFTMAC_EVENT_AUTHENTICATED, net);
176	break;
177	default:
178	/* Lock and reset flags */
179	spin_lock_irqsave(&mac->lock, flags);
180	net->authenticated = 0;
181	net->authenticating = 0;
182	spin_unlock_irqrestore(&mac->lock, flags);
183
184	printkl(KERN_NOTICE PFX "Open Authentication with "MAC_FMT" failed, error code: %i\n",
185	MAC_ARG(net->bssid), le16_to_cpup(&auth->status));
186	/* Count the error? */
187	break;
188	}
189	goto free_aq;
190	break;
191	case WLAN_AUTH_SHARED_KEY:
192	/* Figure out where we are in the process */
193	switch(auth->transaction) {
194	case IEEE80211SOFTMAC_AUTH_SHARED_CHALLENGE:
195	/* Check to make sure we have a challenge IE */
196	data = (u8 *)auth->info_element;
197	if(*data++ != MFIE_TYPE_CHALLENGE){
198	printkl(KERN_NOTICE PFX "Shared Key Authentication failed due to a missing challenge.\n");
199	break;
200	}
201	/* Save the challenge */
202	spin_lock_irqsave(&mac->lock, flags);
203	net->challenge_len = *data++;
204	if(net->challenge_len > WLAN_AUTH_CHALLENGE_LEN)
205	net->challenge_len = WLAN_AUTH_CHALLENGE_LEN;
206	if(net->challenge != NULL)
207	kfree(net->challenge);
208	net->challenge = kmalloc(net->challenge_len, GFP_ATOMIC);
209	memcpy(net->challenge, data, net->challenge_len);
210	aq->state = IEEE80211SOFTMAC_AUTH_SHARED_RESPONSE;
211	spin_unlock_irqrestore(&mac->lock, flags);
212
213	/* Switch to correct channel for this network */
214	mac->set_channel(mac->dev, net->channel);
215
216	/* Send our response (How to encrypt?) */
217	ieee80211softmac_send_mgt_frame(mac, aq->net, IEEE80211_STYPE_AUTH, aq->state);
218	break;
219	case IEEE80211SOFTMAC_AUTH_SHARED_PASS:
220	/* Check the status code of the response */
221	switch(auth->status) {
222	case WLAN_STATUS_SUCCESS:
223	/* Update the status to Authenticated */
224	spin_lock_irqsave(&mac->lock, flags);
225	net->authenticating = 0;
226	net->authenticated = 1;
227	spin_unlock_irqrestore(&mac->lock, flags);
228	printkl(KERN_NOTICE PFX "Shared Key Authentication completed with "MAC_FMT"\n",
229	MAC_ARG(net->bssid));
230	break;
231	default:
232	printkl(KERN_NOTICE PFX "Shared Key Authentication with "MAC_FMT" failed, error code: %i\n",
233	MAC_ARG(net->bssid), le16_to_cpup(&auth->status));
234	/* Lock and reset flags */
235	spin_lock_irqsave(&mac->lock, flags);
236	net->authenticating = 0;
237	net->authenticated = 0;
238	spin_unlock_irqrestore(&mac->lock, flags);
239	/* Count the error? */
240	break;
241	}
242	goto free_aq;
243	break;
244	default:
245	printkl(KERN_WARNING PFX "Unhandled Authentication Step: %i\n", auth->transaction);
246	break;
247	}
248	goto free_aq;
249	break;
250	default:
251	/* ERROR */
252	goto free_aq;
253	break;
254	}
255	return 0;
256	free_aq:
257	/* Cancel the timeout */
258	spin_lock_irqsave(&mac->lock, flags);
259	cancel_delayed_work(&aq->work);
260	/* Remove this item from the queue */
261	list_del(&aq->list);
262	spin_unlock_irqrestore(&mac->lock, flags);
263
264	/* Free it */
265	kfree(aq);
266	return 0;
267	}
268
269	/*
270	* Handle deauthorization
271	*/
714e1a51	272	static void
370121e5 JB	273	ieee80211softmac_deauth_from_net(struct ieee80211softmac_device *mac,
	274	struct ieee80211softmac_network *net)
	275	{
	276	struct ieee80211softmac_auth_queue_item *aq = NULL;
	277	struct list_head *list_ptr;
	278	unsigned long flags;
	279
	280	function_enter();
	281
	282	/* Lock and reset status flags */
	283	spin_lock_irqsave(&mac->lock, flags);
	284	net->authenticating = 0;
	285	net->authenticated = 0;
	286
	287	/* Find correct auth queue item, if it exists */
	288	list_for_each(list_ptr, &mac->auth_queue) {
	289	aq = list_entry(list_ptr, struct ieee80211softmac_auth_queue_item, list);
	290	if (!memcmp(net->bssid, aq->net->bssid, ETH_ALEN))
	291	break;
	292	else
	293	aq = NULL;
	294	}
	295
	296	/* Cancel pending work */
	297	if(aq != NULL)
	298	/* Not entirely safe? What about running work? */
	299	cancel_delayed_work(&aq->work);
	300
	301	/* Free our network ref */
	302	ieee80211softmac_del_network_locked(mac, net);
	303	if(net->challenge != NULL)
	304	kfree(net->challenge);
	305	kfree(net);
	306
2dd50801 JB	307	/* can't transmit data right now... */
2dd50801 JB	308	netif_carrier_off(mac->dev);
370121e5	309	/* let's try to re-associate */
5c4df6da	310	schedule_work(&mac->associnfo.work);
370121e5 JB	311	spin_unlock_irqrestore(&mac->lock, flags);
	312	}
	313
	314	/*
	315	* Sends a deauth request to the desired AP
	316	*/
	317	int
	318	ieee80211softmac_deauth_req(struct ieee80211softmac_device *mac,
	319	struct ieee80211softmac_network *net, int reason)
	320	{
	321	int ret;
	322
	323	function_enter();
	324
	325	/* Make sure the network is authenticated */
	326	if (!net->authenticated)
	327	{
	328	printkl(KERN_DEBUG PFX "Can't send deauthentication packet, network is not authenticated.\n");
	329	/* Error okay? */
	330	return -EPERM;
	331	}
	332
	333	/* Send the de-auth packet */
	334	if((ret = ieee80211softmac_send_mgt_frame(mac, net, IEEE80211_STYPE_DEAUTH, reason)))
	335	return ret;
	336
	337	ieee80211softmac_deauth_from_net(mac, net);
	338	return 0;
	339	}
	340
	341	/*
	342	* This should be registered with ieee80211 as handle_deauth
	343	*/
	344	int
	345	ieee80211softmac_deauth_resp(struct net_device dev, struct ieee80211_auth auth)
	346	{
	347
	348	struct ieee80211softmac_network *net = NULL;
	349	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	350
	351	function_enter();
	352
	353	if (!auth) {
	354	dprintk("deauth without deauth packet. eek!\n");
	355	return 0;
	356	}
	357
	358	net = ieee80211softmac_get_network_by_bssid(mac, auth->header.addr2);
	359
	360	if (net == NULL) {
f484d582	361	printkl(KERN_DEBUG PFX "Received deauthentication packet from "MAC_FMT", but that network is unknown.\n",
370121e5 JB	362	MAC_ARG(auth->header.addr2));
	363	return 0;
	364	}
	365
	366	/* Make sure the network is authenticated */
	367	if(!net->authenticated)
	368	{
	369	printkl(KERN_DEBUG PFX "Can't perform deauthentication, network is not authenticated.\n");
	370	/* Error okay? */
	371	return -EPERM;
	372	}
	373
	374	ieee80211softmac_deauth_from_net(mac, net);
	375	return 0;
	376	}