1/*
2 * Contains some basic softmac functions along with module registration code etc.
3 *
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>
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
27#include "ieee80211softmac_priv.h"
28#include <linux/sort.h>
29#include <linux/etherdevice.h>
30
31struct net_device *alloc_ieee80211softmac(int sizeof_priv)
32{
33	struct ieee80211softmac_device *softmac;
34	struct net_device *dev;
35
36	dev = alloc_ieee80211(sizeof(*softmac) + sizeof_priv);
37	if (!dev)
38		return NULL;
39
40	softmac = ieee80211_priv(dev);
41	softmac->dev = dev;
42	softmac->ieee = netdev_priv(dev);
43	spin_lock_init(&softmac->lock);
44
45	softmac->ieee->handle_auth = ieee80211softmac_auth_resp;
46	softmac->ieee->handle_deauth = ieee80211softmac_deauth_resp;
47	softmac->ieee->handle_assoc_response = ieee80211softmac_handle_assoc_response;
48	softmac->ieee->handle_reassoc_request = ieee80211softmac_handle_reassoc_req;
49	softmac->ieee->handle_disassoc = ieee80211softmac_handle_disassoc;
50	softmac->ieee->handle_beacon = ieee80211softmac_handle_beacon;
51	softmac->scaninfo = NULL;
52
53	softmac->associnfo.scan_retry = IEEE80211SOFTMAC_ASSOC_SCAN_RETRY_LIMIT;
54
55	/* TODO: initialise all the other callbacks in the ieee struct
56	 *	 (once they're written)
57	 */
58
59	INIT_LIST_HEAD(&softmac->auth_queue);
60	INIT_LIST_HEAD(&softmac->network_list);
61	INIT_LIST_HEAD(&softmac->events);
62
63	mutex_init(&softmac->associnfo.mutex);
64	INIT_DELAYED_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work);
65	INIT_DELAYED_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout);
66	softmac->start_scan = ieee80211softmac_start_scan_implementation;
67	softmac->wait_for_scan = ieee80211softmac_wait_for_scan_implementation;
68	softmac->stop_scan = ieee80211softmac_stop_scan_implementation;
69
70	/* to start with, we can't send anything ... */
71	netif_carrier_off(dev);
72
73	return dev;
74}
75EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);
76
77/* Clears the pending work queue items, stops all scans, etc. */
78void
79ieee80211softmac_clear_pending_work(struct ieee80211softmac_device *sm)
80{
81	unsigned long flags;
82	struct ieee80211softmac_event *eventptr, *eventtmp;
83	struct ieee80211softmac_auth_queue_item *authptr, *authtmp;
84	struct ieee80211softmac_network *netptr, *nettmp;
85
86	ieee80211softmac_stop_scan(sm);
87	ieee80211softmac_wait_for_scan(sm);
88
89	spin_lock_irqsave(&sm->lock, flags);
90	sm->running = 0;
91
92	/* Free all pending assoc work items */
93	cancel_delayed_work(&sm->associnfo.work);
94
95	/* Free all pending scan work items */
96	if(sm->scaninfo != NULL)
97		cancel_delayed_work(&sm->scaninfo->softmac_scan);
98
99	/* Free all pending auth work items */
100	list_for_each_entry(authptr, &sm->auth_queue, list)
101		cancel_delayed_work(&authptr->work);
102
103	/* delete all pending event calls and work items */
104	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list)
105		cancel_delayed_work(&eventptr->work);
106
107	spin_unlock_irqrestore(&sm->lock, flags);
108	flush_scheduled_work();
109
110	/* now we should be save and no longer need locking... */
111	spin_lock_irqsave(&sm->lock, flags);
112	/* Free all pending auth work items */
113	list_for_each_entry_safe(authptr, authtmp, &sm->auth_queue, list) {
114		list_del(&authptr->list);
115		kfree(authptr);
116	}
117
118	/* delete all pending event calls and work items */
119	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list) {
120		list_del(&eventptr->list);
121		kfree(eventptr);
122	}
123
124	/* Free all networks */
125	list_for_each_entry_safe(netptr, nettmp, &sm->network_list, list) {
126		ieee80211softmac_del_network_locked(sm, netptr);
127		if(netptr->challenge != NULL)
128			kfree(netptr->challenge);
129		kfree(netptr);
130	}
131
132	spin_unlock_irqrestore(&sm->lock, flags);
133}
134EXPORT_SYMBOL_GPL(ieee80211softmac_clear_pending_work);
135
136void free_ieee80211softmac(struct net_device *dev)
137{
138	struct ieee80211softmac_device *sm = ieee80211_priv(dev);
139	ieee80211softmac_clear_pending_work(sm);
140	kfree(sm->scaninfo);
141	kfree(sm->wpa.IE);
142	free_ieee80211(dev);
143}
144EXPORT_SYMBOL_GPL(free_ieee80211softmac);
145
146static void ieee80211softmac_start_check_rates(struct ieee80211softmac_device *mac)
147{
148	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
149	/* I took out the sorting check, we're seperating by modulation now. */
150	if (ri->count)
151		return;
152	/* otherwise assume we hav'em all! */
153	if (mac->ieee->modulation & IEEE80211_CCK_MODULATION) {
154		ri->rates[ri->count++] = IEEE80211_CCK_RATE_1MB;
155		ri->rates[ri->count++] = IEEE80211_CCK_RATE_2MB;
156		ri->rates[ri->count++] = IEEE80211_CCK_RATE_5MB;
157		ri->rates[ri->count++] = IEEE80211_CCK_RATE_11MB;
158	}
159	if (mac->ieee->modulation & IEEE80211_OFDM_MODULATION) {
160		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_6MB;
161		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_9MB;
162		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_12MB;
163		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_18MB;
164		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_24MB;
165		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_36MB;
166		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_48MB;
167		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_54MB;
168	}
169}
170
171int ieee80211softmac_ratesinfo_rate_supported(struct ieee80211softmac_ratesinfo *ri, u8 rate)
172{
173	int search;
174	u8 search_rate;
175
176	for (search = 0; search < ri->count; search++) {
177		search_rate = ri->rates[search];
178		search_rate &= ~IEEE80211_BASIC_RATE_MASK;
179		if (rate == search_rate)
180			return 1;
181	}
182
183	return 0;
184}
185
186u8 ieee80211softmac_highest_supported_rate(struct ieee80211softmac_device *mac,
187	struct ieee80211softmac_ratesinfo *ri, int basic_only)
188{
189	u8 user_rate = mac->txrates.user_rate;
190	int i;
191
192	if (ri->count == 0)
193		return IEEE80211_CCK_RATE_1MB;
194
195	for (i = ri->count - 1; i >= 0; i--) {
196		u8 rate = ri->rates[i];
197		if (basic_only && !(rate & IEEE80211_BASIC_RATE_MASK))
198			continue;
199		rate &= ~IEEE80211_BASIC_RATE_MASK;
200		if (rate > user_rate)
201			continue;
202		if (ieee80211softmac_ratesinfo_rate_supported(&mac->ratesinfo, rate))
203			return rate;
204	}
205
206	/* If we haven't found a suitable rate by now, just trust the user */
207	return user_rate;
208}
209EXPORT_SYMBOL_GPL(ieee80211softmac_highest_supported_rate);
210
211void ieee80211softmac_process_erp(struct ieee80211softmac_device *mac,
212	u8 erp_value)
213{
214	int use_protection;
215	int short_preamble;
216	u32 changes = 0;
217
218	/* Barker preamble mode */
219	short_preamble = ((erp_value & WLAN_ERP_BARKER_PREAMBLE) == 0
220			  && mac->associnfo.short_preamble_available) ? 1 : 0;
221
222	/* Protection needed? */
223	use_protection = (erp_value & WLAN_ERP_USE_PROTECTION) != 0;
224
225	if (mac->bssinfo.short_preamble != short_preamble) {
226		changes |= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
227		mac->bssinfo.short_preamble = short_preamble;
228	}
229
230	if (mac->bssinfo.use_protection != use_protection) {
231		changes |= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
232		mac->bssinfo.use_protection = use_protection;
233	}
234
235	if (mac->bssinfo_change && changes)
236		mac->bssinfo_change(mac->dev, changes);
237}
238
239void ieee80211softmac_recalc_txrates(struct ieee80211softmac_device *mac)
240{
241	struct ieee80211softmac_txrates *txrates = &mac->txrates;
242	u32 change = 0;
243
244	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
245	txrates->default_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 0);
246
247	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
248	txrates->default_fallback = lower_rate(mac, txrates->default_rate);
249
250	change |= IEEE80211SOFTMAC_TXRATECHG_MCAST;
251	txrates->mcast_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 1);
252
253	if (mac->txrates_change)
254		mac->txrates_change(mac->dev, change);
255
256}
257
258void ieee80211softmac_init_bss(struct ieee80211softmac_device *mac)
259{
260	struct ieee80211_device *ieee = mac->ieee;
261	u32 change = 0;
262	struct ieee80211softmac_txrates *txrates = &mac->txrates;
263	struct ieee80211softmac_bss_info *bssinfo = &mac->bssinfo;
264
265	/* TODO: We need some kind of state machine to lower the default rates
266	 *       if we loose too many packets.
267	 */
268	/* Change the default txrate to the highest possible value.
269	 * The txrate machine will lower it, if it is too high.
270	 */
271	if (ieee->modulation & IEEE80211_OFDM_MODULATION)
272		txrates->user_rate = IEEE80211_OFDM_RATE_24MB;
273	else
274		txrates->user_rate = IEEE80211_CCK_RATE_11MB;
275
276	txrates->default_rate = IEEE80211_CCK_RATE_1MB;
277	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
278
279	txrates->default_fallback = IEEE80211_CCK_RATE_1MB;
280	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
281
282	txrates->mcast_rate = IEEE80211_CCK_RATE_1MB;
283	change |= IEEE80211SOFTMAC_TXRATECHG_MCAST;
284
285	txrates->mgt_mcast_rate = IEEE80211_CCK_RATE_1MB;
286	change |= IEEE80211SOFTMAC_TXRATECHG_MGT_MCAST;
287
288	if (mac->txrates_change)
289		mac->txrates_change(mac->dev, change);
290
291	change = 0;
292
293	bssinfo->supported_rates.count = 0;
294	memset(bssinfo->supported_rates.rates, 0,
295		sizeof(bssinfo->supported_rates.rates));
296	change |= IEEE80211SOFTMAC_BSSINFOCHG_RATES;
297
298	bssinfo->short_preamble = 0;
299	change |= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
300
301	bssinfo->use_protection = 0;
302	change |= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
303
304	if (mac->bssinfo_change)
305		mac->bssinfo_change(mac->dev, change);
306
307	mac->running = 1;
308}
309
310void ieee80211softmac_start(struct net_device *dev)
311{
312	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
313
314	ieee80211softmac_start_check_rates(mac);
315	ieee80211softmac_init_bss(mac);
316}
317EXPORT_SYMBOL_GPL(ieee80211softmac_start);
318
319void ieee80211softmac_stop(struct net_device *dev)
320{
321	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
322
323	ieee80211softmac_clear_pending_work(mac);
324}
325EXPORT_SYMBOL_GPL(ieee80211softmac_stop);
326
327void ieee80211softmac_set_rates(struct net_device *dev, u8 count, u8 *rates)
328{
329	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
330	unsigned long flags;
331
332	spin_lock_irqsave(&mac->lock, flags);
333	memcpy(mac->ratesinfo.rates, rates, count);
334	mac->ratesinfo.count = count;
335	spin_unlock_irqrestore(&mac->lock, flags);
336}
337EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);
338
339static u8 raise_rate(struct ieee80211softmac_device *mac, u8 rate)
340{
341	int i;
342	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
343
344	for (i=0; i<ri->count-1; i++) {
345		if (ri->rates[i] == rate)
346			return ri->rates[i+1];
347	}
348	/* I guess we can't go any higher... */
349	return ri->rates[ri->count];
350}
351
352u8 ieee80211softmac_lower_rate_delta(struct ieee80211softmac_device *mac, u8 rate, int delta)
353{
354	int i;
355	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
356
357	for (i=delta; i<ri->count; i++) {
358		if (ri->rates[i] == rate)
359			return ri->rates[i-delta];
360	}
361	/* I guess we can't go any lower... */
362	return ri->rates[0];
363}
364
365static void ieee80211softmac_add_txrates_badness(struct ieee80211softmac_device *mac,
366						 int amount)
367{
368	u8 default_rate = mac->txrates.default_rate;
369	u8 default_fallback = mac->txrates.default_fallback;
370	u32 changes = 0;
371
372	//TODO: This is highly experimental code.
373	//      Maybe the dynamic rate selection does not work
374	//      and it has to be removed again.
375
376printk("badness %d\n", mac->txrate_badness);
377	mac->txrate_badness += amount;
378	if (mac->txrate_badness <= -1000) {
379		/* Very small badness. Try a faster bitrate. */
380		default_rate = raise_rate(mac, default_rate);
381		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
382		default_fallback = get_fallback_rate(mac, default_rate);
383		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
384		mac->txrate_badness = 0;
385printk("Bitrate raised to %u\n", default_rate);
386	} else if (mac->txrate_badness >= 10000) {
387		/* Very high badness. Try a slower bitrate. */
388		default_rate = lower_rate(mac, default_rate);
389		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
390		default_fallback = get_fallback_rate(mac, default_rate);
391		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
392		mac->txrate_badness = 0;
393printk("Bitrate lowered to %u\n", default_rate);
394	}
395
396	mac->txrates.default_rate = default_rate;
397	mac->txrates.default_fallback = default_fallback;
398
399	if (changes && mac->txrates_change)
400		mac->txrates_change(mac->dev, changes);
401}
402
403void ieee80211softmac_fragment_lost(struct net_device *dev,
404				    u16 wl_seq)
405{
406	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
407	unsigned long flags;
408
409	spin_lock_irqsave(&mac->lock, flags);
410	ieee80211softmac_add_txrates_badness(mac, 1000);
411	//TODO
412
413	spin_unlock_irqrestore(&mac->lock, flags);
414}
415EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);
416
417static int rate_cmp(const void *a_, const void *b_) {
418	u8 *a, *b;
419	a = (u8*)a_;
420	b = (u8*)b_;
421	return ((*a & ~IEEE80211_BASIC_RATE_MASK) - (*b & ~IEEE80211_BASIC_RATE_MASK));
422}
423
424/* Allocate a softmac network struct and fill it from a network */
425struct ieee80211softmac_network *
426ieee80211softmac_create_network(struct ieee80211softmac_device *mac,
427	struct ieee80211_network *net)
428{
429	struct ieee80211softmac_network *softnet;
430	softnet = kzalloc(sizeof(struct ieee80211softmac_network), GFP_ATOMIC);
431	if(softnet == NULL)
432		return NULL;
433	memcpy(softnet->bssid, net->bssid, ETH_ALEN);
434	softnet->channel = net->channel;
435	softnet->essid.len = net->ssid_len;
436	memcpy(softnet->essid.data, net->ssid, softnet->essid.len);
437
438	/* copy rates over */
439	softnet->supported_rates.count = net->rates_len;
440	memcpy(&softnet->supported_rates.rates[0], net->rates, net->rates_len);
441	memcpy(&softnet->supported_rates.rates[softnet->supported_rates.count], net->rates_ex, net->rates_ex_len);
442	softnet->supported_rates.count += net->rates_ex_len;
443	sort(softnet->supported_rates.rates, softnet->supported_rates.count, sizeof(softnet->supported_rates.rates[0]), rate_cmp, NULL);
444
445	/* we save the ERP value because it is needed at association time, and
446	 * many AP's do not include an ERP IE in the association response. */
447	softnet->erp_value = net->erp_value;
448
449	softnet->capabilities = net->capability;
450	return softnet;
451}
452
453
454/* Add a network to the list, while locked */
455void
456ieee80211softmac_add_network_locked(struct ieee80211softmac_device *mac,
457	struct ieee80211softmac_network *add_net)
458{
459	struct list_head *list_ptr;
460	struct ieee80211softmac_network *softmac_net = NULL;
461
462	list_for_each(list_ptr, &mac->network_list) {
463		softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
464		if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
465			break;
466		else
467			softmac_net = NULL;
468	}
469	if(softmac_net == NULL)
470		list_add(&(add_net->list), &mac->network_list);
471}
472
473/* Add a network to the list, with locking */
474void
475ieee80211softmac_add_network(struct ieee80211softmac_device *mac,
476	struct ieee80211softmac_network *add_net)
477{
478	unsigned long flags;
479	spin_lock_irqsave(&mac->lock, flags);
480	ieee80211softmac_add_network_locked(mac, add_net);
481	spin_unlock_irqrestore(&mac->lock, flags);
482}
483
484
485/* Delete a network from the list, while locked*/
486void
487ieee80211softmac_del_network_locked(struct ieee80211softmac_device *mac,
488	struct ieee80211softmac_network *del_net)
489{
490	list_del(&(del_net->list));
491}
492
493/* Delete a network from the list with locking */
494void
495ieee80211softmac_del_network(struct ieee80211softmac_device *mac,
496	struct ieee80211softmac_network *del_net)
497{
498	unsigned long flags;
499	spin_lock_irqsave(&mac->lock, flags);
500	ieee80211softmac_del_network_locked(mac, del_net);
501	spin_unlock_irqrestore(&mac->lock, flags);
502}
503
504/* Get a network from the list by MAC while locked */
505struct ieee80211softmac_network *
506ieee80211softmac_get_network_by_bssid_locked(struct ieee80211softmac_device *mac,
507	u8 *bssid)
508{
509	struct list_head *list_ptr;
510	struct ieee80211softmac_network *softmac_net = NULL;
511	list_for_each(list_ptr, &mac->network_list) {
512		softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
513		if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
514			break;
515		else
516			softmac_net = NULL;
517	}
518	return softmac_net;
519}
520
521/* Get a network from the list by BSSID with locking */
522struct ieee80211softmac_network *
523ieee80211softmac_get_network_by_bssid(struct ieee80211softmac_device *mac,
524	u8 *bssid)
525{
526	unsigned long flags;
527	struct ieee80211softmac_network *softmac_net;
528
529	spin_lock_irqsave(&mac->lock, flags);
530	softmac_net = ieee80211softmac_get_network_by_bssid_locked(mac, bssid);
531	spin_unlock_irqrestore(&mac->lock, flags);
532	return softmac_net;
533}
534
535/* Get a network from the list by ESSID while locked */
536struct ieee80211softmac_network *
537ieee80211softmac_get_network_by_essid_locked(struct ieee80211softmac_device *mac,
538	struct ieee80211softmac_essid *essid)
539{
540	struct list_head *list_ptr;
541	struct ieee80211softmac_network *softmac_net = NULL;
542
543	list_for_each(list_ptr, &mac->network_list) {
544		softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
545		if (softmac_net->essid.len == essid->len &&
546			!memcmp(softmac_net->essid.data, essid->data, essid->len))
547			return softmac_net;
548	}
549	return NULL;
550}
551
552/* Get a network from the list by ESSID with locking */
553struct ieee80211softmac_network *
554ieee80211softmac_get_network_by_essid(struct ieee80211softmac_device *mac,
555	struct ieee80211softmac_essid *essid)
556{
557	unsigned long flags;
558	struct ieee80211softmac_network *softmac_net = NULL;
559
560	spin_lock_irqsave(&mac->lock, flags);
561	softmac_net = ieee80211softmac_get_network_by_essid_locked(mac, essid);
562	spin_unlock_irqrestore(&mac->lock, flags);
563	return softmac_net;
564}
565
566MODULE_LICENSE("GPL");
567MODULE_AUTHOR("Johannes Berg");
568MODULE_AUTHOR("Joseph Jezak");
569MODULE_AUTHOR("Larry Finger");
570MODULE_AUTHOR("Danny van Dyk");
571MODULE_AUTHOR("Michael Buesch");
572MODULE_DESCRIPTION("802.11 software MAC");
573