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
  30 struct net_device *alloc_ieee80211softmac(int sizeof_priv)
  31 {
  32         struct ieee80211softmac_device *softmac;
  33         struct net_device *dev;
  34
  35         dev = alloc_ieee80211(sizeof(struct ieee80211softmac_device) + sizeof_priv);
  36         softmac = ieee80211_priv(dev);
  37         softmac->dev = dev;
  38         softmac->ieee = netdev_priv(dev);
  39         spin_lock_init(&softmac->lock);
  40
  41         softmac->ieee->handle_auth = ieee80211softmac_auth_resp;
  42         softmac->ieee->handle_deauth = ieee80211softmac_deauth_resp;
  43         softmac->ieee->handle_assoc_response = ieee80211softmac_handle_assoc_response;
  44         softmac->ieee->handle_reassoc_request = ieee80211softmac_handle_reassoc_req;
  45         softmac->ieee->handle_disassoc = ieee80211softmac_handle_disassoc;
  46         softmac->scaninfo = NULL;
  47
  48         /* TODO: initialise all the other callbacks in the ieee struct
  49          *       (once they're written)
  50          */
  51
  52         INIT_LIST_HEAD(&softmac->auth_queue);
  53         INIT_LIST_HEAD(&softmac->network_list);
  54         INIT_LIST_HEAD(&softmac->events);
  55
  56         INIT_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work, softmac);
  57         INIT_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout, softmac);
  58         softmac->start_scan = ieee80211softmac_start_scan_implementation;
  59         softmac->wait_for_scan = ieee80211softmac_wait_for_scan_implementation;
  60         softmac->stop_scan = ieee80211softmac_stop_scan_implementation;
  61
  62         //TODO: The mcast rate has to be assigned dynamically somewhere (in scanning, association. Not sure...)
  63         //      It has to be set to the highest rate all stations in the current network can handle.
  64         softmac->txrates.mcast_rate = IEEE80211_CCK_RATE_1MB;
  65         softmac->txrates.mcast_fallback = IEEE80211_CCK_RATE_1MB;
  66         /* This is reassigned in ieee80211softmac_start to sane values. */
  67         softmac->txrates.default_rate = IEEE80211_CCK_RATE_1MB;
  68         softmac->txrates.default_fallback = IEEE80211_CCK_RATE_1MB;
  69
  70         /* to start with, we can't send anything ... */
  71         netif_carrier_off(dev);
  72
  73         return dev;
  74 }
  75 EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);
  76
  77 /* Clears the pending work queue items, stops all scans, etc. */
  78 void
  79 ieee80211softmac_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         /* Free all pending assoc work items */
  91         cancel_delayed_work(&sm->associnfo.work);
  92
  93         /* Free all pending scan work items */
  94         if(sm->scaninfo != NULL)
  95                 cancel_delayed_work(&sm->scaninfo->softmac_scan);
  96
  97         /* Free all pending auth work items */
  98         list_for_each_entry(authptr, &sm->auth_queue, list)
  99                 cancel_delayed_work(&authptr->work);
 100
 101         /* delete all pending event calls and work items */
 102         list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list)
 103                 cancel_delayed_work(&eventptr->work);
 104
 105         spin_unlock_irqrestore(&sm->lock, flags);
 106         flush_scheduled_work();
 107
 108         /* now we should be save and no longer need locking... */
 109         spin_lock_irqsave(&sm->lock, flags);
 110         /* Free all pending auth work items */
 111         list_for_each_entry_safe(authptr, authtmp, &sm->auth_queue, list) {
 112                 list_del(&authptr->list);
 113                 kfree(authptr);
 114         }
 115
 116         /* delete all pending event calls and work items */
 117         list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list) {
 118                 list_del(&eventptr->list);
 119                 kfree(eventptr);
 120         }
 121
 122         /* Free all networks */
 123         list_for_each_entry_safe(netptr, nettmp, &sm->network_list, list) {
 124                 ieee80211softmac_del_network_locked(sm, netptr);
 125                 if(netptr->challenge != NULL)
 126                         kfree(netptr->challenge);
 127                 kfree(netptr);
 128         }
 129
 130         spin_unlock_irqrestore(&sm->lock, flags);
 131 }
 132 EXPORT_SYMBOL_GPL(ieee80211softmac_clear_pending_work);
 133
 134 void free_ieee80211softmac(struct net_device *dev)
 135 {
 136         struct ieee80211softmac_device *sm = ieee80211_priv(dev);
 137         ieee80211softmac_clear_pending_work(sm);
 138         kfree(sm->scaninfo);
 139         kfree(sm->wpa.IE);
 140         free_ieee80211(dev);
 141 }
 142 EXPORT_SYMBOL_GPL(free_ieee80211softmac);
 143
 144 static void ieee80211softmac_start_check_rates(struct ieee80211softmac_device *mac)
 145 {
 146         struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
 147         /* I took out the sorting check, we're seperating by modulation now. */
 148         if (ri->count)
 149                 return;
 150         /* otherwise assume we hav'em all! */
 151         if (mac->ieee->modulation & IEEE80211_CCK_MODULATION) {
 152                 ri->rates[ri->count++] = IEEE80211_CCK_RATE_1MB;
 153                 ri->rates[ri->count++] = IEEE80211_CCK_RATE_2MB;
 154                 ri->rates[ri->count++] = IEEE80211_CCK_RATE_5MB;
 155                 ri->rates[ri->count++] = IEEE80211_CCK_RATE_11MB;
 156         }
 157         if (mac->ieee->modulation & IEEE80211_OFDM_MODULATION) {
 158                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_6MB;
 159                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_9MB;
 160                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_12MB;
 161                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_18MB;
 162                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_24MB;
 163                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_36MB;
 164                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_48MB;
 165                 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_54MB;
 166         }
 167 }
 168
 169 void ieee80211softmac_start(struct net_device *dev)
 170 {
 171         struct ieee80211softmac_device *mac = ieee80211_priv(dev);
 172         struct ieee80211_device *ieee = mac->ieee;
 173         u32 change = 0;
 174         struct ieee80211softmac_txrates oldrates;
 175
 176         ieee80211softmac_start_check_rates(mac);
 177
 178         /* TODO: We need some kind of state machine to lower the default rates
 179          *       if we loose too many packets.
 180          */
 181         /* Change the default txrate to the highest possible value.
 182          * The txrate machine will lower it, if it is too high.
 183          */
 184         if (mac->txrates_change)
 185                 oldrates = mac->txrates;
 186         if (ieee->modulation & IEEE80211_OFDM_MODULATION) {
 187                 mac->txrates.default_rate = IEEE80211_OFDM_RATE_54MB;
 188                 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
 189                 mac->txrates.default_fallback = IEEE80211_OFDM_RATE_24MB;
 190                 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
 191         } else if (ieee->modulation & IEEE80211_CCK_MODULATION) {
 192                 mac->txrates.default_rate = IEEE80211_CCK_RATE_11MB;
 193                 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
 194                 mac->txrates.default_fallback = IEEE80211_CCK_RATE_5MB;
 195                 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
 196         } else
 197                 assert(0);
 198         if (mac->txrates_change)
 199                 mac->txrates_change(dev, change, &oldrates);
 200 }
 201 EXPORT_SYMBOL_GPL(ieee80211softmac_start);
 202
 203 void ieee80211softmac_stop(struct net_device *dev)
 204 {
 205         struct ieee80211softmac_device *mac = ieee80211_priv(dev);
 206
 207         ieee80211softmac_clear_pending_work(mac);
 208 }
 209 EXPORT_SYMBOL_GPL(ieee80211softmac_stop);
 210
 211 void ieee80211softmac_set_rates(struct net_device *dev, u8 count, u8 *rates)
 212 {
 213         struct ieee80211softmac_device *mac = ieee80211_priv(dev);
 214         unsigned long flags;
 215
 216         spin_lock_irqsave(&mac->lock, flags);
 217         memcpy(mac->ratesinfo.rates, rates, count);
 218         mac->ratesinfo.count = count;
 219         spin_unlock_irqrestore(&mac->lock, flags);
 220 }
 221 EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);
 222
 223 static u8 raise_rate(struct ieee80211softmac_device *mac, u8 rate)
 224 {
 225         int i;
 226         struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
 227
 228         for (i=0; i<ri->count-1; i++) {
 229                 if (ri->rates[i] == rate)
 230                         return ri->rates[i+1];
 231         }
 232         /* I guess we can't go any higher... */
 233         return ri->rates[ri->count];
 234 }
 235
 236 u8 ieee80211softmac_lower_rate_delta(struct ieee80211softmac_device *mac, u8 rate, int delta)
 237 {
 238         int i;
 239         struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
 240
 241         for (i=delta; i<ri->count; i++) {
 242                 if (ri->rates[i] == rate)
 243                         return ri->rates[i-delta];
 244         }
 245         /* I guess we can't go any lower... */
 246         return ri->rates[0];
 247 }
 248
 249 static void ieee80211softmac_add_txrates_badness(struct ieee80211softmac_device *mac,
 250                                                  int amount)
 251 {
 252         struct ieee80211softmac_txrates oldrates;
 253         u8 default_rate = mac->txrates.default_rate;
 254         u8 default_fallback = mac->txrates.default_fallback;
 255         u32 changes = 0;
 256
 257         //TODO: This is highly experimental code.
 258         //      Maybe the dynamic rate selection does not work
 259         //      and it has to be removed again.
 260
 261 printk("badness %d\n", mac->txrate_badness);
 262         mac->txrate_badness += amount;
 263         if (mac->txrate_badness <= -1000) {
 264                 /* Very small badness. Try a faster bitrate. */
 265                 if (mac->txrates_change)
 266                         memcpy(&oldrates, &mac->txrates, sizeof(oldrates));
 267                 default_rate = raise_rate(mac, default_rate);
 268                 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
 269                 default_fallback = get_fallback_rate(mac, default_rate);
 270                 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
 271                 mac->txrate_badness = 0;
 272 printk("Bitrate raised to %u\n", default_rate);
 273         } else if (mac->txrate_badness >= 10000) {
 274                 /* Very high badness. Try a slower bitrate. */
 275                 if (mac->txrates_change)
 276                         memcpy(&oldrates, &mac->txrates, sizeof(oldrates));
 277                 default_rate = lower_rate(mac, default_rate);
 278                 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
 279                 default_fallback = get_fallback_rate(mac, default_rate);
 280                 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
 281                 mac->txrate_badness = 0;
 282 printk("Bitrate lowered to %u\n", default_rate);
 283         }
 284
 285         mac->txrates.default_rate = default_rate;
 286         mac->txrates.default_fallback = default_fallback;
 287
 288         if (changes && mac->txrates_change)
 289                 mac->txrates_change(mac->dev, changes, &oldrates);
 290 }
 291
 292 void ieee80211softmac_fragment_lost(struct net_device *dev,
 293                                     u16 wl_seq)
 294 {
 295         struct ieee80211softmac_device *mac = ieee80211_priv(dev);
 296         unsigned long flags;
 297
 298         spin_lock_irqsave(&mac->lock, flags);
 299         ieee80211softmac_add_txrates_badness(mac, 1000);
 300         //TODO
 301
 302         spin_unlock_irqrestore(&mac->lock, flags);
 303 }
 304 EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);
 305
 306 static int rate_cmp(const void *a_, const void *b_) {
 307         u8 *a, *b;
 308         a = (u8*)a_;
 309         b = (u8*)b_;
 310         return ((*a & ~IEEE80211_BASIC_RATE_MASK) - (*b & ~IEEE80211_BASIC_RATE_MASK));
 311 }
 312
 313 /* Allocate a softmac network struct and fill it from a network */
 314 struct ieee80211softmac_network *
 315 ieee80211softmac_create_network(struct ieee80211softmac_device *mac,
 316         struct ieee80211_network *net)
 317 {
 318         struct ieee80211softmac_network *softnet;
 319         softnet = kzalloc(sizeof(struct ieee80211softmac_network), GFP_ATOMIC);
 320         if(softnet == NULL)
 321                 return NULL;
 322         memcpy(softnet->bssid, net->bssid, ETH_ALEN);
 323         softnet->channel = net->channel;
 324         softnet->essid.len = net->ssid_len;
 325         memcpy(softnet->essid.data, net->ssid, softnet->essid.len);
 326
 327         /* copy rates over */
 328         softnet->supported_rates.count = net->rates_len;
 329         memcpy(&softnet->supported_rates.rates[0], net->rates, net->rates_len);
 330         memcpy(&softnet->supported_rates.rates[softnet->supported_rates.count], net->rates_ex, net->rates_ex_len);
 331         softnet->supported_rates.count += net->rates_ex_len;
 332         sort(softnet->supported_rates.rates, softnet->supported_rates.count, sizeof(softnet->supported_rates.rates[0]), rate_cmp, NULL);
 333
 334         softnet->capabilities = net->capability;
 335         return softnet;
 336 }
 337
 338
 339 /* Add a network to the list, while locked */
 340 void
 341 ieee80211softmac_add_network_locked(struct ieee80211softmac_device *mac,
 342         struct ieee80211softmac_network *add_net)
 343 {
 344         struct list_head *list_ptr;
 345         struct ieee80211softmac_network *softmac_net = NULL;
 346
 347         list_for_each(list_ptr, &mac->network_list) {
 348                 softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
 349                 if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
 350                         break;
 351                 else
 352                         softmac_net = NULL;
 353         }
 354         if(softmac_net == NULL)
 355                 list_add(&(add_net->list), &mac->network_list);
 356 }
 357
 358 /* Add a network to the list, with locking */
 359 void
 360 ieee80211softmac_add_network(struct ieee80211softmac_device *mac,
 361         struct ieee80211softmac_network *add_net)
 362 {
 363         unsigned long flags;
 364         spin_lock_irqsave(&mac->lock, flags);
 365         ieee80211softmac_add_network_locked(mac, add_net);
 366         spin_unlock_irqrestore(&mac->lock, flags);
 367 }
 368
 369
 370 /* Delete a network from the list, while locked*/
 371 void
 372 ieee80211softmac_del_network_locked(struct ieee80211softmac_device *mac,
 373         struct ieee80211softmac_network *del_net)
 374 {
 375         list_del(&(del_net->list));
 376 }
 377
 378 /* Delete a network from the list with locking */
 379 void
 380 ieee80211softmac_del_network(struct ieee80211softmac_device *mac,
 381         struct ieee80211softmac_network *del_net)
 382 {
 383         unsigned long flags;
 384         spin_lock_irqsave(&mac->lock, flags);
 385         ieee80211softmac_del_network_locked(mac, del_net);
 386         spin_unlock_irqrestore(&mac->lock, flags);
 387 }
 388
 389 /* Get a network from the list by MAC while locked */
 390 struct ieee80211softmac_network *
 391 ieee80211softmac_get_network_by_bssid_locked(struct ieee80211softmac_device *mac,
 392         u8 *bssid)
 393 {
 394         struct list_head *list_ptr;
 395         struct ieee80211softmac_network *softmac_net = NULL;
 396         list_for_each(list_ptr, &mac->network_list) {
 397                 softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
 398                 if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
 399                         break;
 400                 else
 401                         softmac_net = NULL;
 402         }
 403         return softmac_net;
 404 }
 405
 406 /* Get a network from the list by BSSID with locking */
 407 struct ieee80211softmac_network *
 408 ieee80211softmac_get_network_by_bssid(struct ieee80211softmac_device *mac,
 409         u8 *bssid)
 410 {
 411         unsigned long flags;
 412         struct ieee80211softmac_network *softmac_net;
 413
 414         spin_lock_irqsave(&mac->lock, flags);
 415         softmac_net = ieee80211softmac_get_network_by_bssid_locked(mac, bssid);
 416         spin_unlock_irqrestore(&mac->lock, flags);
 417         return softmac_net;
 418 }
 419
 420 /* Get a network from the list by ESSID while locked */
 421 struct ieee80211softmac_network *
 422 ieee80211softmac_get_network_by_essid_locked(struct ieee80211softmac_device *mac,
 423         struct ieee80211softmac_essid *essid)
 424 {
 425         struct list_head *list_ptr;
 426         struct ieee80211softmac_network *softmac_net = NULL;
 427
 428         list_for_each(list_ptr, &mac->network_list) {
 429                 softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
 430                 if (softmac_net->essid.len == essid->len &&
 431                         !memcmp(softmac_net->essid.data, essid->data, essid->len))
 432                         return softmac_net;
 433         }
 434         return NULL;
 435 }
 436
 437 /* Get a network from the list by ESSID with locking */
 438 struct ieee80211softmac_network *
 439 ieee80211softmac_get_network_by_essid(struct ieee80211softmac_device *mac,
 440         struct ieee80211softmac_essid *essid)
 441 {
 442         unsigned long flags;
 443         struct ieee80211softmac_network *softmac_net = NULL;
 444
 445         spin_lock_irqsave(&mac->lock, flags);
 446         softmac_net = ieee80211softmac_get_network_by_essid_locked(mac, essid);
 447         spin_unlock_irqrestore(&mac->lock, flags);
 448         return softmac_net;
 449 }
 450
 451 MODULE_LICENSE("GPL");
 452 MODULE_AUTHOR("Johannes Berg");
 453 MODULE_AUTHOR("Joseph Jezak");
 454 MODULE_AUTHOR("Larry Finger");
 455 MODULE_AUTHOR("Danny van Dyk");
 456 MODULE_AUTHOR("Michael Buesch");
 457 MODULE_DESCRIPTION("802.11 software MAC");