ibss.c revision f1249700f563b5dc541afa7e54a2d93fdffc1fb6
1/* 2 * IBSS mode implementation 3 * Copyright 2003-2008, Jouni Malinen <j@w1.fi> 4 * Copyright 2004, Instant802 Networks, Inc. 5 * Copyright 2005, Devicescape Software, Inc. 6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net> 8 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14 15#include <linux/delay.h> 16#include <linux/slab.h> 17#include <linux/if_ether.h> 18#include <linux/skbuff.h> 19#include <linux/if_arp.h> 20#include <linux/etherdevice.h> 21#include <linux/rtnetlink.h> 22#include <net/mac80211.h> 23#include <asm/unaligned.h> 24 25#include "ieee80211_i.h" 26#include "driver-ops.h" 27#include "rate.h" 28 29#define IEEE80211_SCAN_INTERVAL (2 * HZ) 30#define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ) 31#define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ) 32 33#define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ) 34#define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ) 35 36#define IEEE80211_IBSS_MAX_STA_ENTRIES 128 37 38 39static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata, 40 struct ieee80211_mgmt *mgmt, 41 size_t len) 42{ 43 u16 auth_alg, auth_transaction; 44 45 lockdep_assert_held(&sdata->u.ibss.mtx); 46 47 if (len < 24 + 6) 48 return; 49 50 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg); 51 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction); 52 53 /* 54 * IEEE 802.11 standard does not require authentication in IBSS 55 * networks and most implementations do not seem to use it. 56 * However, try to reply to authentication attempts if someone 57 * has actually implemented this. 58 */ 59 if (auth_alg == WLAN_AUTH_OPEN && auth_transaction == 1) 60 ieee80211_send_auth(sdata, 2, WLAN_AUTH_OPEN, NULL, 0, mgmt->sa, 61 sdata->u.ibss.bssid, NULL, 0, 0); 62} 63 64static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata, 65 const u8 *bssid, const int beacon_int, 66 struct ieee80211_channel *chan, 67 const u32 basic_rates, 68 const u16 capability, u64 tsf) 69{ 70 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 71 struct ieee80211_local *local = sdata->local; 72 int rates, i; 73 struct sk_buff *skb; 74 struct ieee80211_mgmt *mgmt; 75 u8 *pos; 76 struct ieee80211_supported_band *sband; 77 struct cfg80211_bss *bss; 78 u32 bss_change; 79 u8 supp_rates[IEEE80211_MAX_SUPP_RATES]; 80 enum nl80211_channel_type channel_type; 81 82 lockdep_assert_held(&ifibss->mtx); 83 84 /* Reset own TSF to allow time synchronization work. */ 85 drv_reset_tsf(local, sdata); 86 87 skb = ifibss->skb; 88 RCU_INIT_POINTER(ifibss->presp, NULL); 89 synchronize_rcu(); 90 skb->data = skb->head; 91 skb->len = 0; 92 skb_reset_tail_pointer(skb); 93 skb_reserve(skb, sdata->local->hw.extra_tx_headroom); 94 95 if (memcmp(ifibss->bssid, bssid, ETH_ALEN)) 96 sta_info_flush(sdata->local, sdata); 97 98 /* if merging, indicate to driver that we leave the old IBSS */ 99 if (sdata->vif.bss_conf.ibss_joined) { 100 sdata->vif.bss_conf.ibss_joined = false; 101 netif_carrier_off(sdata->dev); 102 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IBSS); 103 } 104 105 memcpy(ifibss->bssid, bssid, ETH_ALEN); 106 107 sdata->drop_unencrypted = capability & WLAN_CAPABILITY_PRIVACY ? 1 : 0; 108 109 channel_type = ifibss->channel_type; 110 if (channel_type > NL80211_CHAN_HT20 && 111 !cfg80211_can_beacon_sec_chan(local->hw.wiphy, chan, channel_type)) 112 channel_type = NL80211_CHAN_HT20; 113 if (!ieee80211_set_channel_type(local, sdata, channel_type)) { 114 /* can only fail due to HT40+/- mismatch */ 115 channel_type = NL80211_CHAN_HT20; 116 WARN_ON(!ieee80211_set_channel_type(local, sdata, 117 NL80211_CHAN_HT20)); 118 } 119 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL); 120 121 sband = local->hw.wiphy->bands[chan->band]; 122 123 /* build supported rates array */ 124 pos = supp_rates; 125 for (i = 0; i < sband->n_bitrates; i++) { 126 int rate = sband->bitrates[i].bitrate; 127 u8 basic = 0; 128 if (basic_rates & BIT(i)) 129 basic = 0x80; 130 *pos++ = basic | (u8) (rate / 5); 131 } 132 133 /* Build IBSS probe response */ 134 mgmt = (void *) skb_put(skb, 24 + sizeof(mgmt->u.beacon)); 135 memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon)); 136 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 137 IEEE80211_STYPE_PROBE_RESP); 138 memset(mgmt->da, 0xff, ETH_ALEN); 139 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 140 memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN); 141 mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_int); 142 mgmt->u.beacon.timestamp = cpu_to_le64(tsf); 143 mgmt->u.beacon.capab_info = cpu_to_le16(capability); 144 145 pos = skb_put(skb, 2 + ifibss->ssid_len); 146 *pos++ = WLAN_EID_SSID; 147 *pos++ = ifibss->ssid_len; 148 memcpy(pos, ifibss->ssid, ifibss->ssid_len); 149 150 rates = sband->n_bitrates; 151 if (rates > 8) 152 rates = 8; 153 pos = skb_put(skb, 2 + rates); 154 *pos++ = WLAN_EID_SUPP_RATES; 155 *pos++ = rates; 156 memcpy(pos, supp_rates, rates); 157 158 if (sband->band == IEEE80211_BAND_2GHZ) { 159 pos = skb_put(skb, 2 + 1); 160 *pos++ = WLAN_EID_DS_PARAMS; 161 *pos++ = 1; 162 *pos++ = ieee80211_frequency_to_channel(chan->center_freq); 163 } 164 165 pos = skb_put(skb, 2 + 2); 166 *pos++ = WLAN_EID_IBSS_PARAMS; 167 *pos++ = 2; 168 /* FIX: set ATIM window based on scan results */ 169 *pos++ = 0; 170 *pos++ = 0; 171 172 if (sband->n_bitrates > 8) { 173 rates = sband->n_bitrates - 8; 174 pos = skb_put(skb, 2 + rates); 175 *pos++ = WLAN_EID_EXT_SUPP_RATES; 176 *pos++ = rates; 177 memcpy(pos, &supp_rates[8], rates); 178 } 179 180 if (ifibss->ie_len) 181 memcpy(skb_put(skb, ifibss->ie_len), 182 ifibss->ie, ifibss->ie_len); 183 184 /* add HT capability and information IEs */ 185 if (channel_type && sband->ht_cap.ht_supported) { 186 pos = skb_put(skb, 4 + 187 sizeof(struct ieee80211_ht_cap) + 188 sizeof(struct ieee80211_ht_info)); 189 pos = ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, 190 sband->ht_cap.cap); 191 pos = ieee80211_ie_build_ht_info(pos, 192 &sband->ht_cap, 193 chan, 194 channel_type); 195 } 196 197 if (local->hw.queues >= 4) { 198 pos = skb_put(skb, 9); 199 *pos++ = WLAN_EID_VENDOR_SPECIFIC; 200 *pos++ = 7; /* len */ 201 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */ 202 *pos++ = 0x50; 203 *pos++ = 0xf2; 204 *pos++ = 2; /* WME */ 205 *pos++ = 0; /* WME info */ 206 *pos++ = 1; /* WME ver */ 207 *pos++ = 0; /* U-APSD no in use */ 208 } 209 210 rcu_assign_pointer(ifibss->presp, skb); 211 212 sdata->vif.bss_conf.beacon_int = beacon_int; 213 sdata->vif.bss_conf.basic_rates = basic_rates; 214 bss_change = BSS_CHANGED_BEACON_INT; 215 bss_change |= ieee80211_reset_erp_info(sdata); 216 bss_change |= BSS_CHANGED_BSSID; 217 bss_change |= BSS_CHANGED_BEACON; 218 bss_change |= BSS_CHANGED_BEACON_ENABLED; 219 bss_change |= BSS_CHANGED_BASIC_RATES; 220 bss_change |= BSS_CHANGED_HT; 221 bss_change |= BSS_CHANGED_IBSS; 222 sdata->vif.bss_conf.ibss_joined = true; 223 ieee80211_bss_info_change_notify(sdata, bss_change); 224 225 ieee80211_sta_def_wmm_params(sdata, sband->n_bitrates, supp_rates); 226 227 ifibss->state = IEEE80211_IBSS_MLME_JOINED; 228 mod_timer(&ifibss->timer, 229 round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL)); 230 231 bss = cfg80211_inform_bss_frame(local->hw.wiphy, local->hw.conf.channel, 232 mgmt, skb->len, 0, GFP_KERNEL); 233 cfg80211_put_bss(bss); 234 netif_carrier_on(sdata->dev); 235 cfg80211_ibss_joined(sdata->dev, ifibss->bssid, GFP_KERNEL); 236} 237 238static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata, 239 struct ieee80211_bss *bss) 240{ 241 struct cfg80211_bss *cbss = 242 container_of((void *)bss, struct cfg80211_bss, priv); 243 struct ieee80211_supported_band *sband; 244 u32 basic_rates; 245 int i, j; 246 u16 beacon_int = cbss->beacon_interval; 247 248 lockdep_assert_held(&sdata->u.ibss.mtx); 249 250 if (beacon_int < 10) 251 beacon_int = 10; 252 253 sband = sdata->local->hw.wiphy->bands[cbss->channel->band]; 254 255 basic_rates = 0; 256 257 for (i = 0; i < bss->supp_rates_len; i++) { 258 int rate = (bss->supp_rates[i] & 0x7f) * 5; 259 bool is_basic = !!(bss->supp_rates[i] & 0x80); 260 261 for (j = 0; j < sband->n_bitrates; j++) { 262 if (sband->bitrates[j].bitrate == rate) { 263 if (is_basic) 264 basic_rates |= BIT(j); 265 break; 266 } 267 } 268 } 269 270 __ieee80211_sta_join_ibss(sdata, cbss->bssid, 271 beacon_int, 272 cbss->channel, 273 basic_rates, 274 cbss->capability, 275 cbss->tsf); 276} 277 278static struct sta_info *ieee80211_ibss_finish_sta(struct sta_info *sta) 279 __acquires(RCU) 280{ 281 struct ieee80211_sub_if_data *sdata = sta->sdata; 282 u8 addr[ETH_ALEN]; 283 284 memcpy(addr, sta->sta.addr, ETH_ALEN); 285 286#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 287 wiphy_debug(sdata->local->hw.wiphy, 288 "Adding new IBSS station %pM (dev=%s)\n", 289 addr, sdata->name); 290#endif 291 292 sta_info_move_state(sta, IEEE80211_STA_AUTH); 293 sta_info_move_state(sta, IEEE80211_STA_ASSOC); 294 sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED); 295 296 rate_control_rate_init(sta); 297 298 /* If it fails, maybe we raced another insertion? */ 299 if (sta_info_insert_rcu(sta)) 300 return sta_info_get(sdata, addr); 301 return sta; 302} 303 304static struct sta_info * 305ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata, 306 const u8 *bssid, const u8 *addr, 307 u32 supp_rates) 308 __acquires(RCU) 309{ 310 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 311 struct ieee80211_local *local = sdata->local; 312 struct sta_info *sta; 313 int band = local->hw.conf.channel->band; 314 315 /* 316 * XXX: Consider removing the least recently used entry and 317 * allow new one to be added. 318 */ 319 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) { 320 if (net_ratelimit()) 321 printk(KERN_DEBUG "%s: No room for a new IBSS STA entry %pM\n", 322 sdata->name, addr); 323 rcu_read_lock(); 324 return NULL; 325 } 326 327 if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH) { 328 rcu_read_lock(); 329 return NULL; 330 } 331 332 if (compare_ether_addr(bssid, sdata->u.ibss.bssid)) { 333 rcu_read_lock(); 334 return NULL; 335 } 336 337 sta = sta_info_alloc(sdata, addr, GFP_KERNEL); 338 if (!sta) { 339 rcu_read_lock(); 340 return NULL; 341 } 342 343 sta->last_rx = jiffies; 344 345 /* make sure mandatory rates are always added */ 346 sta->sta.supp_rates[band] = supp_rates | 347 ieee80211_mandatory_rates(local, band); 348 349 return ieee80211_ibss_finish_sta(sta); 350} 351 352static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata, 353 struct ieee80211_mgmt *mgmt, 354 size_t len, 355 struct ieee80211_rx_status *rx_status, 356 struct ieee802_11_elems *elems, 357 bool beacon) 358{ 359 struct ieee80211_local *local = sdata->local; 360 int freq; 361 struct cfg80211_bss *cbss; 362 struct ieee80211_bss *bss; 363 struct sta_info *sta; 364 struct ieee80211_channel *channel; 365 u64 beacon_timestamp, rx_timestamp; 366 u32 supp_rates = 0; 367 enum ieee80211_band band = rx_status->band; 368 struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band]; 369 bool rates_updated = false; 370 371 if (elems->ds_params && elems->ds_params_len == 1) 372 freq = ieee80211_channel_to_frequency(elems->ds_params[0], 373 band); 374 else 375 freq = rx_status->freq; 376 377 channel = ieee80211_get_channel(local->hw.wiphy, freq); 378 379 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 380 return; 381 382 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && 383 memcmp(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN) == 0) { 384 385 rcu_read_lock(); 386 sta = sta_info_get(sdata, mgmt->sa); 387 388 if (elems->supp_rates) { 389 supp_rates = ieee80211_sta_get_rates(local, elems, 390 band); 391 if (sta) { 392 u32 prev_rates; 393 394 prev_rates = sta->sta.supp_rates[band]; 395 /* make sure mandatory rates are always added */ 396 sta->sta.supp_rates[band] = supp_rates | 397 ieee80211_mandatory_rates(local, band); 398 399 if (sta->sta.supp_rates[band] != prev_rates) { 400#ifdef CONFIG_MAC80211_IBSS_DEBUG 401 printk(KERN_DEBUG 402 "%s: updated supp_rates set " 403 "for %pM based on beacon" 404 "/probe_resp (0x%x -> 0x%x)\n", 405 sdata->name, sta->sta.addr, 406 prev_rates, 407 sta->sta.supp_rates[band]); 408#endif 409 rates_updated = true; 410 } 411 } else { 412 rcu_read_unlock(); 413 sta = ieee80211_ibss_add_sta(sdata, mgmt->bssid, 414 mgmt->sa, supp_rates); 415 } 416 } 417 418 if (sta && elems->wmm_info) 419 set_sta_flag(sta, WLAN_STA_WME); 420 421 if (sta && elems->ht_info_elem && elems->ht_cap_elem && 422 sdata->u.ibss.channel_type != NL80211_CHAN_NO_HT) { 423 /* we both use HT */ 424 struct ieee80211_sta_ht_cap sta_ht_cap_new; 425 enum nl80211_channel_type channel_type = 426 ieee80211_ht_info_to_channel_type( 427 elems->ht_info_elem); 428 429 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband, 430 elems->ht_cap_elem, 431 &sta_ht_cap_new); 432 433 /* 434 * fall back to HT20 if we don't use or use 435 * the other extension channel 436 */ 437 if ((channel_type == NL80211_CHAN_HT40MINUS || 438 channel_type == NL80211_CHAN_HT40PLUS) && 439 channel_type != sdata->u.ibss.channel_type) 440 sta_ht_cap_new.cap &= 441 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; 442 443 if (memcmp(&sta->sta.ht_cap, &sta_ht_cap_new, 444 sizeof(sta_ht_cap_new))) { 445 memcpy(&sta->sta.ht_cap, &sta_ht_cap_new, 446 sizeof(sta_ht_cap_new)); 447 rates_updated = true; 448 } 449 } 450 451 if (sta && rates_updated) 452 rate_control_rate_init(sta); 453 454 rcu_read_unlock(); 455 } 456 457 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems, 458 channel, beacon); 459 if (!bss) 460 return; 461 462 cbss = container_of((void *)bss, struct cfg80211_bss, priv); 463 464 /* was just updated in ieee80211_bss_info_update */ 465 beacon_timestamp = cbss->tsf; 466 467 /* check if we need to merge IBSS */ 468 469 /* we use a fixed BSSID */ 470 if (sdata->u.ibss.fixed_bssid) 471 goto put_bss; 472 473 /* not an IBSS */ 474 if (!(cbss->capability & WLAN_CAPABILITY_IBSS)) 475 goto put_bss; 476 477 /* different channel */ 478 if (cbss->channel != local->oper_channel) 479 goto put_bss; 480 481 /* different SSID */ 482 if (elems->ssid_len != sdata->u.ibss.ssid_len || 483 memcmp(elems->ssid, sdata->u.ibss.ssid, 484 sdata->u.ibss.ssid_len)) 485 goto put_bss; 486 487 /* same BSSID */ 488 if (memcmp(cbss->bssid, sdata->u.ibss.bssid, ETH_ALEN) == 0) 489 goto put_bss; 490 491 if (rx_status->flag & RX_FLAG_MACTIME_MPDU) { 492 /* 493 * For correct IBSS merging we need mactime; since mactime is 494 * defined as the time the first data symbol of the frame hits 495 * the PHY, and the timestamp of the beacon is defined as "the 496 * time that the data symbol containing the first bit of the 497 * timestamp is transmitted to the PHY plus the transmitting 498 * STA's delays through its local PHY from the MAC-PHY 499 * interface to its interface with the WM" (802.11 11.1.2) 500 * - equals the time this bit arrives at the receiver - we have 501 * to take into account the offset between the two. 502 * 503 * E.g. at 1 MBit that means mactime is 192 usec earlier 504 * (=24 bytes * 8 usecs/byte) than the beacon timestamp. 505 */ 506 int rate; 507 508 if (rx_status->flag & RX_FLAG_HT) 509 rate = 65; /* TODO: HT rates */ 510 else 511 rate = local->hw.wiphy->bands[band]-> 512 bitrates[rx_status->rate_idx].bitrate; 513 514 rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate); 515 } else { 516 /* 517 * second best option: get current TSF 518 * (will return -1 if not supported) 519 */ 520 rx_timestamp = drv_get_tsf(local, sdata); 521 } 522 523#ifdef CONFIG_MAC80211_IBSS_DEBUG 524 printk(KERN_DEBUG "RX beacon SA=%pM BSSID=" 525 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n", 526 mgmt->sa, mgmt->bssid, 527 (unsigned long long)rx_timestamp, 528 (unsigned long long)beacon_timestamp, 529 (unsigned long long)(rx_timestamp - beacon_timestamp), 530 jiffies); 531#endif 532 533 if (beacon_timestamp > rx_timestamp) { 534#ifdef CONFIG_MAC80211_IBSS_DEBUG 535 printk(KERN_DEBUG "%s: beacon TSF higher than " 536 "local TSF - IBSS merge with BSSID %pM\n", 537 sdata->name, mgmt->bssid); 538#endif 539 ieee80211_sta_join_ibss(sdata, bss); 540 supp_rates = ieee80211_sta_get_rates(local, elems, band); 541 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, 542 supp_rates); 543 rcu_read_unlock(); 544 } 545 546 put_bss: 547 ieee80211_rx_bss_put(local, bss); 548} 549 550void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata, 551 const u8 *bssid, const u8 *addr, 552 u32 supp_rates) 553{ 554 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 555 struct ieee80211_local *local = sdata->local; 556 struct sta_info *sta; 557 int band = local->hw.conf.channel->band; 558 559 /* 560 * XXX: Consider removing the least recently used entry and 561 * allow new one to be added. 562 */ 563 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) { 564 if (net_ratelimit()) 565 printk(KERN_DEBUG "%s: No room for a new IBSS STA entry %pM\n", 566 sdata->name, addr); 567 return; 568 } 569 570 if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH) 571 return; 572 573 if (compare_ether_addr(bssid, sdata->u.ibss.bssid)) 574 return; 575 576 sta = sta_info_alloc(sdata, addr, GFP_ATOMIC); 577 if (!sta) 578 return; 579 580 sta->last_rx = jiffies; 581 582 /* make sure mandatory rates are always added */ 583 sta->sta.supp_rates[band] = supp_rates | 584 ieee80211_mandatory_rates(local, band); 585 586 spin_lock(&ifibss->incomplete_lock); 587 list_add(&sta->list, &ifibss->incomplete_stations); 588 spin_unlock(&ifibss->incomplete_lock); 589 ieee80211_queue_work(&local->hw, &sdata->work); 590} 591 592static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata) 593{ 594 struct ieee80211_local *local = sdata->local; 595 int active = 0; 596 struct sta_info *sta; 597 598 lockdep_assert_held(&sdata->u.ibss.mtx); 599 600 rcu_read_lock(); 601 602 list_for_each_entry_rcu(sta, &local->sta_list, list) { 603 if (sta->sdata == sdata && 604 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL, 605 jiffies)) { 606 active++; 607 break; 608 } 609 } 610 611 rcu_read_unlock(); 612 613 return active; 614} 615 616/* 617 * This function is called with state == IEEE80211_IBSS_MLME_JOINED 618 */ 619 620static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata) 621{ 622 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 623 624 lockdep_assert_held(&ifibss->mtx); 625 626 mod_timer(&ifibss->timer, 627 round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL)); 628 629 ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT); 630 631 if (time_before(jiffies, ifibss->last_scan_completed + 632 IEEE80211_IBSS_MERGE_INTERVAL)) 633 return; 634 635 if (ieee80211_sta_active_ibss(sdata)) 636 return; 637 638 if (ifibss->fixed_channel) 639 return; 640 641 printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other " 642 "IBSS networks with same SSID (merge)\n", sdata->name); 643 644 ieee80211_request_internal_scan(sdata, 645 ifibss->ssid, ifibss->ssid_len, NULL); 646} 647 648static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata) 649{ 650 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 651 u8 bssid[ETH_ALEN]; 652 u16 capability; 653 int i; 654 655 lockdep_assert_held(&ifibss->mtx); 656 657 if (ifibss->fixed_bssid) { 658 memcpy(bssid, ifibss->bssid, ETH_ALEN); 659 } else { 660 /* Generate random, not broadcast, locally administered BSSID. Mix in 661 * own MAC address to make sure that devices that do not have proper 662 * random number generator get different BSSID. */ 663 get_random_bytes(bssid, ETH_ALEN); 664 for (i = 0; i < ETH_ALEN; i++) 665 bssid[i] ^= sdata->vif.addr[i]; 666 bssid[0] &= ~0x01; 667 bssid[0] |= 0x02; 668 } 669 670 printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n", 671 sdata->name, bssid); 672 673 capability = WLAN_CAPABILITY_IBSS; 674 675 if (ifibss->privacy) 676 capability |= WLAN_CAPABILITY_PRIVACY; 677 else 678 sdata->drop_unencrypted = 0; 679 680 __ieee80211_sta_join_ibss(sdata, bssid, sdata->vif.bss_conf.beacon_int, 681 ifibss->channel, ifibss->basic_rates, 682 capability, 0); 683} 684 685/* 686 * This function is called with state == IEEE80211_IBSS_MLME_SEARCH 687 */ 688 689static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata) 690{ 691 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 692 struct ieee80211_local *local = sdata->local; 693 struct cfg80211_bss *cbss; 694 struct ieee80211_channel *chan = NULL; 695 const u8 *bssid = NULL; 696 int active_ibss; 697 u16 capability; 698 699 lockdep_assert_held(&ifibss->mtx); 700 701 active_ibss = ieee80211_sta_active_ibss(sdata); 702#ifdef CONFIG_MAC80211_IBSS_DEBUG 703 printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n", 704 sdata->name, active_ibss); 705#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 706 707 if (active_ibss) 708 return; 709 710 capability = WLAN_CAPABILITY_IBSS; 711 if (ifibss->privacy) 712 capability |= WLAN_CAPABILITY_PRIVACY; 713 if (ifibss->fixed_bssid) 714 bssid = ifibss->bssid; 715 if (ifibss->fixed_channel) 716 chan = ifibss->channel; 717 if (!is_zero_ether_addr(ifibss->bssid)) 718 bssid = ifibss->bssid; 719 cbss = cfg80211_get_bss(local->hw.wiphy, chan, bssid, 720 ifibss->ssid, ifibss->ssid_len, 721 WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_PRIVACY, 722 capability); 723 724 if (cbss) { 725 struct ieee80211_bss *bss; 726 727 bss = (void *)cbss->priv; 728#ifdef CONFIG_MAC80211_IBSS_DEBUG 729 printk(KERN_DEBUG " sta_find_ibss: selected %pM current " 730 "%pM\n", cbss->bssid, ifibss->bssid); 731#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 732 733 printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM" 734 " based on configured SSID\n", 735 sdata->name, cbss->bssid); 736 737 ieee80211_sta_join_ibss(sdata, bss); 738 ieee80211_rx_bss_put(local, bss); 739 return; 740 } 741 742#ifdef CONFIG_MAC80211_IBSS_DEBUG 743 printk(KERN_DEBUG " did not try to join ibss\n"); 744#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 745 746 /* Selected IBSS not found in current scan results - try to scan */ 747 if (time_after(jiffies, ifibss->last_scan_completed + 748 IEEE80211_SCAN_INTERVAL)) { 749 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to " 750 "join\n", sdata->name); 751 752 ieee80211_request_internal_scan(sdata, 753 ifibss->ssid, ifibss->ssid_len, 754 ifibss->fixed_channel ? ifibss->channel : NULL); 755 } else { 756 int interval = IEEE80211_SCAN_INTERVAL; 757 758 if (time_after(jiffies, ifibss->ibss_join_req + 759 IEEE80211_IBSS_JOIN_TIMEOUT)) { 760 if (!(local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS)) { 761 ieee80211_sta_create_ibss(sdata); 762 return; 763 } 764 printk(KERN_DEBUG "%s: IBSS not allowed on" 765 " %d MHz\n", sdata->name, 766 local->hw.conf.channel->center_freq); 767 768 /* No IBSS found - decrease scan interval and continue 769 * scanning. */ 770 interval = IEEE80211_SCAN_INTERVAL_SLOW; 771 } 772 773 mod_timer(&ifibss->timer, 774 round_jiffies(jiffies + interval)); 775 } 776} 777 778static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata, 779 struct sk_buff *req) 780{ 781 struct ieee80211_mgmt *mgmt = (void *)req->data; 782 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 783 struct ieee80211_local *local = sdata->local; 784 int tx_last_beacon, len = req->len; 785 struct sk_buff *skb; 786 struct ieee80211_mgmt *resp; 787 struct sk_buff *presp; 788 u8 *pos, *end; 789 790 lockdep_assert_held(&ifibss->mtx); 791 792 presp = rcu_dereference_protected(ifibss->presp, 793 lockdep_is_held(&ifibss->mtx)); 794 795 if (ifibss->state != IEEE80211_IBSS_MLME_JOINED || 796 len < 24 + 2 || !presp) 797 return; 798 799 tx_last_beacon = drv_tx_last_beacon(local); 800 801#ifdef CONFIG_MAC80211_IBSS_DEBUG 802 printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM" 803 " (tx_last_beacon=%d)\n", 804 sdata->name, mgmt->sa, mgmt->da, 805 mgmt->bssid, tx_last_beacon); 806#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 807 808 if (!tx_last_beacon && is_multicast_ether_addr(mgmt->da)) 809 return; 810 811 if (memcmp(mgmt->bssid, ifibss->bssid, ETH_ALEN) != 0 && 812 memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0) 813 return; 814 815 end = ((u8 *) mgmt) + len; 816 pos = mgmt->u.probe_req.variable; 817 if (pos[0] != WLAN_EID_SSID || 818 pos + 2 + pos[1] > end) { 819#ifdef CONFIG_MAC80211_IBSS_DEBUG 820 printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq " 821 "from %pM\n", 822 sdata->name, mgmt->sa); 823#endif 824 return; 825 } 826 if (pos[1] != 0 && 827 (pos[1] != ifibss->ssid_len || 828 memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len))) { 829 /* Ignore ProbeReq for foreign SSID */ 830 return; 831 } 832 833 /* Reply with ProbeResp */ 834 skb = skb_copy(presp, GFP_KERNEL); 835 if (!skb) 836 return; 837 838 resp = (struct ieee80211_mgmt *) skb->data; 839 memcpy(resp->da, mgmt->sa, ETH_ALEN); 840#ifdef CONFIG_MAC80211_IBSS_DEBUG 841 printk(KERN_DEBUG "%s: Sending ProbeResp to %pM\n", 842 sdata->name, resp->da); 843#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 844 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 845 ieee80211_tx_skb(sdata, skb); 846} 847 848static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata, 849 struct ieee80211_mgmt *mgmt, 850 size_t len, 851 struct ieee80211_rx_status *rx_status) 852{ 853 size_t baselen; 854 struct ieee802_11_elems elems; 855 856 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 857 if (baselen > len) 858 return; 859 860 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 861 &elems); 862 863 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false); 864} 865 866static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata, 867 struct ieee80211_mgmt *mgmt, 868 size_t len, 869 struct ieee80211_rx_status *rx_status) 870{ 871 size_t baselen; 872 struct ieee802_11_elems elems; 873 874 /* Process beacon from the current BSS */ 875 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt; 876 if (baselen > len) 877 return; 878 879 ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems); 880 881 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, true); 882} 883 884void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 885 struct sk_buff *skb) 886{ 887 struct ieee80211_rx_status *rx_status; 888 struct ieee80211_mgmt *mgmt; 889 u16 fc; 890 891 rx_status = IEEE80211_SKB_RXCB(skb); 892 mgmt = (struct ieee80211_mgmt *) skb->data; 893 fc = le16_to_cpu(mgmt->frame_control); 894 895 mutex_lock(&sdata->u.ibss.mtx); 896 897 if (!sdata->u.ibss.ssid_len) 898 goto mgmt_out; /* not ready to merge yet */ 899 900 switch (fc & IEEE80211_FCTL_STYPE) { 901 case IEEE80211_STYPE_PROBE_REQ: 902 ieee80211_rx_mgmt_probe_req(sdata, skb); 903 break; 904 case IEEE80211_STYPE_PROBE_RESP: 905 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, 906 rx_status); 907 break; 908 case IEEE80211_STYPE_BEACON: 909 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, 910 rx_status); 911 break; 912 case IEEE80211_STYPE_AUTH: 913 ieee80211_rx_mgmt_auth_ibss(sdata, mgmt, skb->len); 914 break; 915 } 916 917 mgmt_out: 918 mutex_unlock(&sdata->u.ibss.mtx); 919} 920 921void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata) 922{ 923 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 924 struct sta_info *sta; 925 926 mutex_lock(&ifibss->mtx); 927 928 /* 929 * Work could be scheduled after scan or similar 930 * when we aren't even joined (or trying) with a 931 * network. 932 */ 933 if (!ifibss->ssid_len) 934 goto out; 935 936 spin_lock_bh(&ifibss->incomplete_lock); 937 while (!list_empty(&ifibss->incomplete_stations)) { 938 sta = list_first_entry(&ifibss->incomplete_stations, 939 struct sta_info, list); 940 list_del(&sta->list); 941 spin_unlock_bh(&ifibss->incomplete_lock); 942 943 ieee80211_ibss_finish_sta(sta); 944 rcu_read_unlock(); 945 spin_lock_bh(&ifibss->incomplete_lock); 946 } 947 spin_unlock_bh(&ifibss->incomplete_lock); 948 949 switch (ifibss->state) { 950 case IEEE80211_IBSS_MLME_SEARCH: 951 ieee80211_sta_find_ibss(sdata); 952 break; 953 case IEEE80211_IBSS_MLME_JOINED: 954 ieee80211_sta_merge_ibss(sdata); 955 break; 956 default: 957 WARN_ON(1); 958 break; 959 } 960 961 out: 962 mutex_unlock(&ifibss->mtx); 963} 964 965static void ieee80211_ibss_timer(unsigned long data) 966{ 967 struct ieee80211_sub_if_data *sdata = 968 (struct ieee80211_sub_if_data *) data; 969 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 970 struct ieee80211_local *local = sdata->local; 971 972 if (local->quiescing) { 973 ifibss->timer_running = true; 974 return; 975 } 976 977 ieee80211_queue_work(&local->hw, &sdata->work); 978} 979 980#ifdef CONFIG_PM 981void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata) 982{ 983 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 984 985 if (del_timer_sync(&ifibss->timer)) 986 ifibss->timer_running = true; 987} 988 989void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata) 990{ 991 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 992 993 if (ifibss->timer_running) { 994 add_timer(&ifibss->timer); 995 ifibss->timer_running = false; 996 } 997} 998#endif 999 1000void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata) 1001{ 1002 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 1003 1004 setup_timer(&ifibss->timer, ieee80211_ibss_timer, 1005 (unsigned long) sdata); 1006 mutex_init(&ifibss->mtx); 1007 INIT_LIST_HEAD(&ifibss->incomplete_stations); 1008 spin_lock_init(&ifibss->incomplete_lock); 1009} 1010 1011/* scan finished notification */ 1012void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local) 1013{ 1014 struct ieee80211_sub_if_data *sdata; 1015 1016 mutex_lock(&local->iflist_mtx); 1017 list_for_each_entry(sdata, &local->interfaces, list) { 1018 if (!ieee80211_sdata_running(sdata)) 1019 continue; 1020 if (sdata->vif.type != NL80211_IFTYPE_ADHOC) 1021 continue; 1022 sdata->u.ibss.last_scan_completed = jiffies; 1023 ieee80211_queue_work(&local->hw, &sdata->work); 1024 } 1025 mutex_unlock(&local->iflist_mtx); 1026} 1027 1028int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata, 1029 struct cfg80211_ibss_params *params) 1030{ 1031 struct sk_buff *skb; 1032 u32 changed = 0; 1033 1034 skb = dev_alloc_skb(sdata->local->hw.extra_tx_headroom + 1035 sizeof(struct ieee80211_hdr_3addr) + 1036 12 /* struct ieee80211_mgmt.u.beacon */ + 1037 2 + IEEE80211_MAX_SSID_LEN /* max SSID */ + 1038 2 + 8 /* max Supported Rates */ + 1039 3 /* max DS params */ + 1040 4 /* IBSS params */ + 1041 2 + (IEEE80211_MAX_SUPP_RATES - 8) + 1042 2 + sizeof(struct ieee80211_ht_cap) + 1043 2 + sizeof(struct ieee80211_ht_info) + 1044 params->ie_len); 1045 if (!skb) 1046 return -ENOMEM; 1047 1048 mutex_lock(&sdata->u.ibss.mtx); 1049 1050 if (params->bssid) { 1051 memcpy(sdata->u.ibss.bssid, params->bssid, ETH_ALEN); 1052 sdata->u.ibss.fixed_bssid = true; 1053 } else 1054 sdata->u.ibss.fixed_bssid = false; 1055 1056 sdata->u.ibss.privacy = params->privacy; 1057 sdata->u.ibss.basic_rates = params->basic_rates; 1058 memcpy(sdata->vif.bss_conf.mcast_rate, params->mcast_rate, 1059 sizeof(params->mcast_rate)); 1060 1061 sdata->vif.bss_conf.beacon_int = params->beacon_interval; 1062 1063 sdata->u.ibss.channel = params->channel; 1064 sdata->u.ibss.channel_type = params->channel_type; 1065 sdata->u.ibss.fixed_channel = params->channel_fixed; 1066 1067 /* fix ourselves to that channel now already */ 1068 if (params->channel_fixed) { 1069 sdata->local->oper_channel = params->channel; 1070 if (!ieee80211_set_channel_type(sdata->local, sdata, 1071 params->channel_type)) { 1072 mutex_unlock(&sdata->u.ibss.mtx); 1073 kfree_skb(skb); 1074 return -EINVAL; 1075 } 1076 } 1077 1078 if (params->ie) { 1079 sdata->u.ibss.ie = kmemdup(params->ie, params->ie_len, 1080 GFP_KERNEL); 1081 if (sdata->u.ibss.ie) 1082 sdata->u.ibss.ie_len = params->ie_len; 1083 } 1084 1085 sdata->u.ibss.skb = skb; 1086 sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH; 1087 sdata->u.ibss.ibss_join_req = jiffies; 1088 1089 memcpy(sdata->u.ibss.ssid, params->ssid, IEEE80211_MAX_SSID_LEN); 1090 sdata->u.ibss.ssid_len = params->ssid_len; 1091 1092 mutex_unlock(&sdata->u.ibss.mtx); 1093 1094 mutex_lock(&sdata->local->mtx); 1095 ieee80211_recalc_idle(sdata->local); 1096 mutex_unlock(&sdata->local->mtx); 1097 1098 /* 1099 * 802.11n-2009 9.13.3.1: In an IBSS, the HT Protection field is 1100 * reserved, but an HT STA shall protect HT transmissions as though 1101 * the HT Protection field were set to non-HT mixed mode. 1102 * 1103 * In an IBSS, the RIFS Mode field of the HT Operation element is 1104 * also reserved, but an HT STA shall operate as though this field 1105 * were set to 1. 1106 */ 1107 1108 sdata->vif.bss_conf.ht_operation_mode |= 1109 IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED 1110 | IEEE80211_HT_PARAM_RIFS_MODE; 1111 1112 changed |= BSS_CHANGED_HT; 1113 ieee80211_bss_info_change_notify(sdata, changed); 1114 1115 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 1116 1117 return 0; 1118} 1119 1120int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata) 1121{ 1122 struct sk_buff *skb; 1123 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 1124 struct ieee80211_local *local = sdata->local; 1125 struct cfg80211_bss *cbss; 1126 u16 capability; 1127 int active_ibss; 1128 struct sta_info *sta; 1129 1130 mutex_lock(&sdata->u.ibss.mtx); 1131 1132 sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH; 1133 memset(sdata->u.ibss.bssid, 0, ETH_ALEN); 1134 sdata->u.ibss.ssid_len = 0; 1135 1136 active_ibss = ieee80211_sta_active_ibss(sdata); 1137 1138 if (!active_ibss && !is_zero_ether_addr(ifibss->bssid)) { 1139 capability = WLAN_CAPABILITY_IBSS; 1140 1141 if (ifibss->privacy) 1142 capability |= WLAN_CAPABILITY_PRIVACY; 1143 1144 cbss = cfg80211_get_bss(local->hw.wiphy, ifibss->channel, 1145 ifibss->bssid, ifibss->ssid, 1146 ifibss->ssid_len, WLAN_CAPABILITY_IBSS | 1147 WLAN_CAPABILITY_PRIVACY, 1148 capability); 1149 1150 if (cbss) { 1151 cfg80211_unlink_bss(local->hw.wiphy, cbss); 1152 cfg80211_put_bss(cbss); 1153 } 1154 } 1155 1156 sta_info_flush(sdata->local, sdata); 1157 1158 spin_lock_bh(&ifibss->incomplete_lock); 1159 while (!list_empty(&ifibss->incomplete_stations)) { 1160 sta = list_first_entry(&ifibss->incomplete_stations, 1161 struct sta_info, list); 1162 list_del(&sta->list); 1163 spin_unlock_bh(&ifibss->incomplete_lock); 1164 1165 sta_info_free(local, sta); 1166 spin_lock_bh(&ifibss->incomplete_lock); 1167 } 1168 spin_unlock_bh(&ifibss->incomplete_lock); 1169 1170 netif_carrier_off(sdata->dev); 1171 1172 /* remove beacon */ 1173 kfree(sdata->u.ibss.ie); 1174 skb = rcu_dereference_protected(sdata->u.ibss.presp, 1175 lockdep_is_held(&sdata->u.ibss.mtx)); 1176 RCU_INIT_POINTER(sdata->u.ibss.presp, NULL); 1177 sdata->vif.bss_conf.ibss_joined = false; 1178 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED | 1179 BSS_CHANGED_IBSS); 1180 synchronize_rcu(); 1181 kfree_skb(skb); 1182 1183 skb_queue_purge(&sdata->skb_queue); 1184 1185 del_timer_sync(&sdata->u.ibss.timer); 1186 1187 mutex_unlock(&sdata->u.ibss.mtx); 1188 1189 mutex_lock(&local->mtx); 1190 ieee80211_recalc_idle(sdata->local); 1191 mutex_unlock(&local->mtx); 1192 1193 return 0; 1194} 1195