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