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(*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 }
  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         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 }
 134 EXPORT_SYMBOL_GPL(ieee80211softmac_clear_pending_work);
 135
 136 void 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 }
 144 EXPORT_SYMBOL_GPL(free_ieee80211softmac);
 145
 146 static 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
 171 int 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
 186 u8 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 }
 209 EXPORT_SYMBOL_GPL(ieee80211softmac_highest_supported_rate);
 210
 211 void 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
 239 void 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
 258 void 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
 310 void 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 }
 317 EXPORT_SYMBOL_GPL(ieee80211softmac_start);
 318
 319 void ieee80211softmac_stop(struct net_device *dev)
 320 {
 321         struct ieee80211softmac_device *mac = ieee80211_priv(dev);
 322
 323         ieee80211softmac_clear_pending_work(mac);
 324 }
 325 EXPORT_SYMBOL_GPL(ieee80211softmac_stop);
 326
 327 void 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 }
 337 EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);
 338
 339 static 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
 352 u8 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
 365 static 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
 376 printk("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;
 385 printk("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;
 393 printk("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
 403 void 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 }
 415 EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);
 416
 417 static 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 */
 425 struct ieee80211softmac_network *
 426 ieee80211softmac_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 */
 455 void
 456 ieee80211softmac_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 */
 474 void
 475 ieee80211softmac_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*/
 486 void
 487 ieee80211softmac_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 */
 494 void
 495 ieee80211softmac_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 */
 505 struct ieee80211softmac_network *
 506 ieee80211softmac_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 */
 522 struct ieee80211softmac_network *
 523 ieee80211softmac_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 */
 536 struct ieee80211softmac_network *
 537 ieee80211softmac_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 */
 553 struct ieee80211softmac_network *
 554 ieee80211softmac_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
 566 MODULE_LICENSE("GPL");
 567 MODULE_AUTHOR("Johannes Berg");
 568 MODULE_AUTHOR("Joseph Jezak");
 569 MODULE_AUTHOR("Larry Finger");
 570 MODULE_AUTHOR("Danny van Dyk");
 571 MODULE_AUTHOR("Michael Buesch");
 572 MODULE_DESCRIPTION("802.11 software MAC");