net/ieee80211/softmac/ieee80211softmac_module.c

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