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

/*
 * Event system
 * Also see comments in public header file and longer explanation below.
 *
 * 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"

/*
 * Each event has associated to it
 *  - an event type (see constants in public header)
 *  - an event context (see below)
 *  - the function to be called
 *  - a context (extra parameter to call the function with)
 *  - and the softmac struct
 *
 * The event context is private and can only be used from
 * within this module. Its meaning varies with the event
 * type:
 *  SCAN_FINISHED,
 *  DISASSOCIATED:	NULL
 *  ASSOCIATED,
 *  ASSOCIATE_FAILED,
 *  ASSOCIATE_TIMEOUT,
 *  AUTHENTICATED,
 *  AUTH_FAILED,
 *  AUTH_TIMEOUT:	a pointer to the network struct
 * ...
 * Code within this module can use the event context to be only
 * called when the event is true for that specific context
 * as per above table.
 * If the event context is NULL, then the notification is always called,
 * regardless of the event context. The event context is not passed to
 * the callback, it is assumed that the context suffices.
 *
 * You can also use the event context only by setting the event type
 * to -1 (private use only), in which case you'll be notified
 * whenever the event context matches.
 */

static char *event_descriptions[IEEE80211SOFTMAC_EVENT_LAST+1] = {
	NULL, /* scan finished */
	NULL, /* associated */
	"associating failed",
	"associating timed out",
	"authenticated",
	"authenticating failed",
	"authenticating timed out",
	"associating failed because no suitable network was found",
	NULL, /* disassociated */
};


static void
ieee80211softmac_notify_callback(struct work_struct *work)
{
	struct ieee80211softmac_event *pevent =
		container_of(work, struct ieee80211softmac_event, work.work);
	struct ieee80211softmac_event event = *pevent;
	kfree(pevent);
	
	event.fun(event.mac->dev, event.event_type, event.context);
}

int
ieee80211softmac_notify_internal(struct ieee80211softmac_device *mac,
	int event, void *event_context, notify_function_ptr fun, void *context, gfp_t gfp_mask)
{
	struct ieee80211softmac_event *eventptr;
	unsigned long flags;

	if (event < -1 || event > IEEE80211SOFTMAC_EVENT_LAST)
		return -ENOSYS;
	
	if (!fun)
		return -EINVAL;
	
	eventptr = kmalloc(sizeof(struct ieee80211softmac_event), gfp_mask);
	if (!eventptr)
		return -ENOMEM;
	
	eventptr->event_type = event;
	INIT_DELAYED_WORK(&eventptr->work, ieee80211softmac_notify_callback);
	eventptr->fun = fun;
	eventptr->context = context;
	eventptr->mac = mac;
	eventptr->event_context = event_context;

	spin_lock_irqsave(&mac->lock, flags);
	list_add(&eventptr->list, &mac->events);
	spin_unlock_irqrestore(&mac->lock, flags);

	return 0;
}

int
ieee80211softmac_notify_gfp(struct net_device *dev,
	int event, notify_function_ptr fun, void *context, gfp_t gfp_mask)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);

	if (event < 0 || event > IEEE80211SOFTMAC_EVENT_LAST)
		return -ENOSYS;
	
	return ieee80211softmac_notify_internal(mac, event, NULL, fun, context, gfp_mask);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_notify_gfp);

/* private -- calling all callbacks that were specified */
void
ieee80211softmac_call_events_locked(struct ieee80211softmac_device *mac, int event, void *event_ctx)
{
	struct ieee80211softmac_event *eventptr, *tmp;
	struct ieee80211softmac_network *network;
	
	if (event >= 0) {
		union iwreq_data wrqu;
		int we_event;
		char *msg = NULL;

		memset(&wrqu, '\0', sizeof (union iwreq_data));

		switch(event) {
		case IEEE80211SOFTMAC_EVENT_ASSOCIATED:
			network = (struct ieee80211softmac_network *)event_ctx;
			memcpy(wrqu.ap_addr.sa_data, &network->bssid[0], ETH_ALEN);
			/* fall through */
		case IEEE80211SOFTMAC_EVENT_DISASSOCIATED:
			wrqu.ap_addr.sa_family = ARPHRD_ETHER;
			we_event = SIOCGIWAP;
			break;
		case IEEE80211SOFTMAC_EVENT_SCAN_FINISHED:
			we_event = SIOCGIWSCAN;
			break;
		default:
			msg = event_descriptions[event];
			if (!msg)
				msg = "SOFTMAC EVENT BUG";
			wrqu.data.length = strlen(msg);
			we_event = IWEVCUSTOM;
			break;
		}
		wireless_send_event(mac->dev, we_event, &wrqu, msg);
	}

	if (!list_empty(&mac->events))
		list_for_each_entry_safe(eventptr, tmp, &mac->events, list) {
			if ((eventptr->event_type == event || eventptr->event_type == -1)
				&& (eventptr->event_context == NULL || eventptr->event_context == event_ctx)) {
				list_del(&eventptr->list);
				/* User may have subscribed to ANY event, so
				 * we tell them which event triggered it. */
				eventptr->event_type = event;
				schedule_delayed_work(&eventptr->work, 0);
			}
		}
}

void
ieee80211softmac_call_events(struct ieee80211softmac_device *mac, int event, void *event_ctx)
{
	unsigned long flags;

	spin_lock_irqsave(&mac->lock, flags);
	ieee80211softmac_call_events_locked(mac, event, event_ctx);

	spin_unlock_irqrestore(&mac->lock, flags);
}
Commit	Line	Data
370121e5 JB	1	/*
370121e5 JB	2	* Event system
4855d25b JB	3	* Also see comments in public header file and longer explanation below.
4855d25b JB	4	*
79859051 JB	5	* Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
	6	* Joseph Jezak <josejx@gentoo.org>
	7	* Larry Finger <Larry.Finger@lwfinger.net>
	8	* Danny van Dyk <kugelfang@gentoo.org>
	9	* Michael Buesch <mbuesch@freenet.de>
4855d25b JB	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.
370121e5	19	*
4855d25b JB	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	23	*
	24	* The full GNU General Public License is included in this distribution in the
	25	* file called COPYING.
	26	*/
	27
	28	#include "ieee80211softmac_priv.h"
	29
	30	/*
370121e5 JB	31	* Each event has associated to it
	32	* - an event type (see constants in public header)
	33	* - an event context (see below)
	34	* - the function to be called
	35	* - a context (extra parameter to call the function with)
	36	* - and the softmac struct
	37	*
	38	* The event context is private and can only be used from
	39	* within this module. Its meaning varies with the event
	40	* type:
921a91ef JB	41	* SCAN_FINISHED,
921a91ef JB	42	* DISASSOCIATED: NULL
370121e5 JB	43	* ASSOCIATED,
	44	* ASSOCIATE_FAILED,
	45	* ASSOCIATE_TIMEOUT,
	46	* AUTHENTICATED,
	47	* AUTH_FAILED,
	48	* AUTH_TIMEOUT: a pointer to the network struct
	49	* ...
	50	* Code within this module can use the event context to be only
	51	* called when the event is true for that specific context
	52	* as per above table.
	53	* If the event context is NULL, then the notification is always called,
	54	* regardless of the event context. The event context is not passed to
	55	* the callback, it is assumed that the context suffices.
	56	*
	57	* You can also use the event context only by setting the event type
	58	* to -1 (private use only), in which case you'll be notified
	59	* whenever the event context matches.
	60	*/
	61
	62	static char *event_descriptions[IEEE80211SOFTMAC_EVENT_LAST+1] = {
921a91ef JB	63	NULL, /* scan finished */
921a91ef JB	64	NULL, /* associated */
370121e5 JB	65	"associating failed",
	66	"associating timed out",
	67	"authenticated",
	68	"authenticating failed",
	69	"authenticating timed out",
	70	"associating failed because no suitable network was found",
921a91ef	71	NULL, /* disassociated */
370121e5 JB	72	};
	73
	74
	75	static void
c4028958	76	ieee80211softmac_notify_callback(struct work_struct *work)
370121e5	77	{
c4028958 DH	78	struct ieee80211softmac_event *pevent =
	79	container_of(work, struct ieee80211softmac_event, work.work);
	80	struct ieee80211softmac_event event = *pevent;
	81	kfree(pevent);
370121e5	82
6ae15df1	83	event.fun(event.mac->dev, event.event_type, event.context);
370121e5 JB	84	}
	85
	86	int
	87	ieee80211softmac_notify_internal(struct ieee80211softmac_device *mac,
	88	int event, void event_context, notify_function_ptr fun, void context, gfp_t gfp_mask)
	89	{
	90	struct ieee80211softmac_event *eventptr;
	91	unsigned long flags;
	92
	93	if (event < -1 \|\| event > IEEE80211SOFTMAC_EVENT_LAST)
	94	return -ENOSYS;
	95
	96	if (!fun)
	97	return -EINVAL;
	98
	99	eventptr = kmalloc(sizeof(struct ieee80211softmac_event), gfp_mask);
	100	if (!eventptr)
	101	return -ENOMEM;
	102
	103	eventptr->event_type = event;
c4028958	104	INIT_DELAYED_WORK(&eventptr->work, ieee80211softmac_notify_callback);
370121e5 JB	105	eventptr->fun = fun;
	106	eventptr->context = context;
	107	eventptr->mac = mac;
	108	eventptr->event_context = event_context;
	109
	110	spin_lock_irqsave(&mac->lock, flags);
	111	list_add(&eventptr->list, &mac->events);
	112	spin_unlock_irqrestore(&mac->lock, flags);
	113
	114	return 0;
	115	}
	116
	117	int
	118	ieee80211softmac_notify_gfp(struct net_device *dev,
	119	int event, notify_function_ptr fun, void *context, gfp_t gfp_mask)
	120	{
	121	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	122
	123	if (event < 0 \|\| event > IEEE80211SOFTMAC_EVENT_LAST)
	124	return -ENOSYS;
	125
	126	return ieee80211softmac_notify_internal(mac, event, NULL, fun, context, gfp_mask);
	127	}
	128	EXPORT_SYMBOL_GPL(ieee80211softmac_notify_gfp);
	129
	130	/* private -- calling all callbacks that were specified */
	131	void
	132	ieee80211softmac_call_events_locked(struct ieee80211softmac_device mac, int event, void event_ctx)
	133	{
	134	struct ieee80211softmac_event eventptr, tmp;
feeeaa87	135	struct ieee80211softmac_network *network;
370121e5 JB	136
370121e5 JB	137	if (event >= 0) {
feeeaa87 JB	138	union iwreq_data wrqu;
	139	int we_event;
	140	char *msg = NULL;
	141
921a91ef JB	142	memset(&wrqu, '\0', sizeof (union iwreq_data));
921a91ef JB	143
feeeaa87 JB	144	switch(event) {
	145	case IEEE80211SOFTMAC_EVENT_ASSOCIATED:
	146	network = (struct ieee80211softmac_network *)event_ctx;
feeeaa87	147	memcpy(wrqu.ap_addr.sa_data, &network->bssid[0], ETH_ALEN);
921a91ef	148	/* fall through */
feeeaa87	149	case IEEE80211SOFTMAC_EVENT_DISASSOCIATED:
feeeaa87 JB	150	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
	151	we_event = SIOCGIWAP;
	152	break;
6788a07f	153	case IEEE80211SOFTMAC_EVENT_SCAN_FINISHED:
6788a07f JB	154	we_event = SIOCGIWSCAN;
6788a07f JB	155	break;
feeeaa87 JB	156	default:
feeeaa87 JB	157	msg = event_descriptions[event];
921a91ef JB	158	if (!msg)
921a91ef JB	159	msg = "SOFTMAC EVENT BUG";
feeeaa87 JB	160	wrqu.data.length = strlen(msg);
	161	we_event = IWEVCUSTOM;
	162	break;
	163	}
	164	wireless_send_event(mac->dev, we_event, &wrqu, msg);
370121e5 JB	165	}
	166
	167	if (!list_empty(&mac->events))
	168	list_for_each_entry_safe(eventptr, tmp, &mac->events, list) {
	169	if ((eventptr->event_type == event \|\| eventptr->event_type == -1)
	170	&& (eventptr->event_context == NULL \|\| eventptr->event_context == event_ctx)) {
	171	list_del(&eventptr->list);
6ae15df1 DD	172	/* User may have subscribed to ANY event, so
	173	* we tell them which event triggered it. */
	174	eventptr->event_type = event;
c4028958	175	schedule_delayed_work(&eventptr->work, 0);
370121e5 JB	176	}
	177	}
	178	}
	179
	180	void
	181	ieee80211softmac_call_events(struct ieee80211softmac_device mac, int event, void event_ctx)
	182	{
	183	unsigned long flags;
	184
	185	spin_lock_irqsave(&mac->lock, flags);
	186	ieee80211softmac_call_events_locked(mac, event, event_ctx);
	187
	188	spin_unlock_irqrestore(&mac->lock, flags);
	189	}