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

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