ibss.c revision fb03c5eb8c0bbf4561cb5aa72e0a9546e9574661
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, 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_INIT_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 void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata, 279 struct ieee80211_mgmt *mgmt, 280 size_t len, 281 struct ieee80211_rx_status *rx_status, 282 struct ieee802_11_elems *elems, 283 bool beacon) 284{ 285 struct ieee80211_local *local = sdata->local; 286 int freq; 287 struct cfg80211_bss *cbss; 288 struct ieee80211_bss *bss; 289 struct sta_info *sta; 290 struct ieee80211_channel *channel; 291 u64 beacon_timestamp, rx_timestamp; 292 u32 supp_rates = 0; 293 enum ieee80211_band band = rx_status->band; 294 struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band]; 295 bool rates_updated = false; 296 297 if (elems->ds_params && elems->ds_params_len == 1) 298 freq = ieee80211_channel_to_frequency(elems->ds_params[0], 299 band); 300 else 301 freq = rx_status->freq; 302 303 channel = ieee80211_get_channel(local->hw.wiphy, freq); 304 305 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 306 return; 307 308 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && 309 memcmp(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN) == 0) { 310 311 rcu_read_lock(); 312 sta = sta_info_get(sdata, mgmt->sa); 313 314 if (elems->supp_rates) { 315 supp_rates = ieee80211_sta_get_rates(local, elems, 316 band); 317 if (sta) { 318 u32 prev_rates; 319 320 prev_rates = sta->sta.supp_rates[band]; 321 /* make sure mandatory rates are always added */ 322 sta->sta.supp_rates[band] = supp_rates | 323 ieee80211_mandatory_rates(local, band); 324 325 if (sta->sta.supp_rates[band] != prev_rates) { 326#ifdef CONFIG_MAC80211_IBSS_DEBUG 327 printk(KERN_DEBUG 328 "%s: updated supp_rates set " 329 "for %pM based on beacon" 330 "/probe_resp (0x%x -> 0x%x)\n", 331 sdata->name, sta->sta.addr, 332 prev_rates, 333 sta->sta.supp_rates[band]); 334#endif 335 rates_updated = true; 336 } 337 } else 338 sta = ieee80211_ibss_add_sta(sdata, mgmt->bssid, 339 mgmt->sa, supp_rates, 340 GFP_ATOMIC); 341 } 342 343 if (sta && elems->wmm_info) 344 set_sta_flag(sta, WLAN_STA_WME); 345 346 if (sta && elems->ht_info_elem && elems->ht_cap_elem && 347 sdata->u.ibss.channel_type != NL80211_CHAN_NO_HT) { 348 /* we both use HT */ 349 struct ieee80211_sta_ht_cap sta_ht_cap_new; 350 enum nl80211_channel_type channel_type = 351 ieee80211_ht_info_to_channel_type( 352 elems->ht_info_elem); 353 354 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband, 355 elems->ht_cap_elem, 356 &sta_ht_cap_new); 357 358 /* 359 * fall back to HT20 if we don't use or use 360 * the other extension channel 361 */ 362 if ((channel_type == NL80211_CHAN_HT40MINUS || 363 channel_type == NL80211_CHAN_HT40PLUS) && 364 channel_type != sdata->u.ibss.channel_type) 365 sta_ht_cap_new.cap &= 366 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; 367 368 if (memcmp(&sta->sta.ht_cap, &sta_ht_cap_new, 369 sizeof(sta_ht_cap_new))) { 370 memcpy(&sta->sta.ht_cap, &sta_ht_cap_new, 371 sizeof(sta_ht_cap_new)); 372 rates_updated = true; 373 } 374 } 375 376 if (sta && rates_updated) 377 rate_control_rate_init(sta); 378 379 rcu_read_unlock(); 380 } 381 382 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems, 383 channel, beacon); 384 if (!bss) 385 return; 386 387 cbss = container_of((void *)bss, struct cfg80211_bss, priv); 388 389 /* was just updated in ieee80211_bss_info_update */ 390 beacon_timestamp = cbss->tsf; 391 392 /* check if we need to merge IBSS */ 393 394 /* we use a fixed BSSID */ 395 if (sdata->u.ibss.fixed_bssid) 396 goto put_bss; 397 398 /* not an IBSS */ 399 if (!(cbss->capability & WLAN_CAPABILITY_IBSS)) 400 goto put_bss; 401 402 /* different channel */ 403 if (cbss->channel != local->oper_channel) 404 goto put_bss; 405 406 /* different SSID */ 407 if (elems->ssid_len != sdata->u.ibss.ssid_len || 408 memcmp(elems->ssid, sdata->u.ibss.ssid, 409 sdata->u.ibss.ssid_len)) 410 goto put_bss; 411 412 /* same BSSID */ 413 if (memcmp(cbss->bssid, sdata->u.ibss.bssid, ETH_ALEN) == 0) 414 goto put_bss; 415 416 if (rx_status->flag & RX_FLAG_MACTIME_MPDU) { 417 /* 418 * For correct IBSS merging we need mactime; since mactime is 419 * defined as the time the first data symbol of the frame hits 420 * the PHY, and the timestamp of the beacon is defined as "the 421 * time that the data symbol containing the first bit of the 422 * timestamp is transmitted to the PHY plus the transmitting 423 * STA's delays through its local PHY from the MAC-PHY 424 * interface to its interface with the WM" (802.11 11.1.2) 425 * - equals the time this bit arrives at the receiver - we have 426 * to take into account the offset between the two. 427 * 428 * E.g. at 1 MBit that means mactime is 192 usec earlier 429 * (=24 bytes * 8 usecs/byte) than the beacon timestamp. 430 */ 431 int rate; 432 433 if (rx_status->flag & RX_FLAG_HT) 434 rate = 65; /* TODO: HT rates */ 435 else 436 rate = local->hw.wiphy->bands[band]-> 437 bitrates[rx_status->rate_idx].bitrate; 438 439 rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate); 440 } else { 441 /* 442 * second best option: get current TSF 443 * (will return -1 if not supported) 444 */ 445 rx_timestamp = drv_get_tsf(local, sdata); 446 } 447 448#ifdef CONFIG_MAC80211_IBSS_DEBUG 449 printk(KERN_DEBUG "RX beacon SA=%pM BSSID=" 450 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n", 451 mgmt->sa, mgmt->bssid, 452 (unsigned long long)rx_timestamp, 453 (unsigned long long)beacon_timestamp, 454 (unsigned long long)(rx_timestamp - beacon_timestamp), 455 jiffies); 456#endif 457 458 if (beacon_timestamp > rx_timestamp) { 459#ifdef CONFIG_MAC80211_IBSS_DEBUG 460 printk(KERN_DEBUG "%s: beacon TSF higher than " 461 "local TSF - IBSS merge with BSSID %pM\n", 462 sdata->name, mgmt->bssid); 463#endif 464 ieee80211_sta_join_ibss(sdata, bss); 465 supp_rates = ieee80211_sta_get_rates(local, elems, band); 466 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, 467 supp_rates, GFP_KERNEL); 468 } 469 470 put_bss: 471 ieee80211_rx_bss_put(local, bss); 472} 473 474/* 475 * Add a new IBSS station, will also be called by the RX code when, 476 * in IBSS mode, receiving a frame from a yet-unknown station, hence 477 * must be callable in atomic context. 478 */ 479struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata, 480 u8 *bssid, u8 *addr, u32 supp_rates, 481 gfp_t gfp) 482{ 483 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 484 struct ieee80211_local *local = sdata->local; 485 struct sta_info *sta; 486 int band = local->hw.conf.channel->band; 487 488 /* 489 * XXX: Consider removing the least recently used entry and 490 * allow new one to be added. 491 */ 492 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) { 493 if (net_ratelimit()) 494 printk(KERN_DEBUG "%s: No room for a new IBSS STA entry %pM\n", 495 sdata->name, addr); 496 return NULL; 497 } 498 499 if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH) 500 return NULL; 501 502 if (compare_ether_addr(bssid, sdata->u.ibss.bssid)) 503 return NULL; 504 505#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 506 wiphy_debug(local->hw.wiphy, "Adding new IBSS station %pM (dev=%s)\n", 507 addr, sdata->name); 508#endif 509 510 sta = sta_info_alloc(sdata, addr, gfp); 511 if (!sta) 512 return NULL; 513 514 sta->last_rx = jiffies; 515 set_sta_flag(sta, WLAN_STA_AUTHORIZED); 516 517 /* make sure mandatory rates are always added */ 518 sta->sta.supp_rates[band] = supp_rates | 519 ieee80211_mandatory_rates(local, band); 520 521 rate_control_rate_init(sta); 522 523 /* If it fails, maybe we raced another insertion? */ 524 if (sta_info_insert(sta)) 525 return sta_info_get(sdata, addr); 526 return sta; 527} 528 529static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata) 530{ 531 struct ieee80211_local *local = sdata->local; 532 int active = 0; 533 struct sta_info *sta; 534 535 lockdep_assert_held(&sdata->u.ibss.mtx); 536 537 rcu_read_lock(); 538 539 list_for_each_entry_rcu(sta, &local->sta_list, list) { 540 if (sta->sdata == sdata && 541 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL, 542 jiffies)) { 543 active++; 544 break; 545 } 546 } 547 548 rcu_read_unlock(); 549 550 return active; 551} 552 553/* 554 * This function is called with state == IEEE80211_IBSS_MLME_JOINED 555 */ 556 557static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata) 558{ 559 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 560 561 lockdep_assert_held(&ifibss->mtx); 562 563 mod_timer(&ifibss->timer, 564 round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL)); 565 566 ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT); 567 568 if (time_before(jiffies, ifibss->last_scan_completed + 569 IEEE80211_IBSS_MERGE_INTERVAL)) 570 return; 571 572 if (ieee80211_sta_active_ibss(sdata)) 573 return; 574 575 if (ifibss->fixed_channel) 576 return; 577 578 printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other " 579 "IBSS networks with same SSID (merge)\n", sdata->name); 580 581 ieee80211_request_internal_scan(sdata, 582 ifibss->ssid, ifibss->ssid_len, 583 ifibss->fixed_channel ? ifibss->channel : NULL); 584} 585 586static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata) 587{ 588 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 589 u8 bssid[ETH_ALEN]; 590 u16 capability; 591 int i; 592 593 lockdep_assert_held(&ifibss->mtx); 594 595 if (ifibss->fixed_bssid) { 596 memcpy(bssid, ifibss->bssid, ETH_ALEN); 597 } else { 598 /* Generate random, not broadcast, locally administered BSSID. Mix in 599 * own MAC address to make sure that devices that do not have proper 600 * random number generator get different BSSID. */ 601 get_random_bytes(bssid, ETH_ALEN); 602 for (i = 0; i < ETH_ALEN; i++) 603 bssid[i] ^= sdata->vif.addr[i]; 604 bssid[0] &= ~0x01; 605 bssid[0] |= 0x02; 606 } 607 608 printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n", 609 sdata->name, bssid); 610 611 capability = WLAN_CAPABILITY_IBSS; 612 613 if (ifibss->privacy) 614 capability |= WLAN_CAPABILITY_PRIVACY; 615 else 616 sdata->drop_unencrypted = 0; 617 618 __ieee80211_sta_join_ibss(sdata, bssid, sdata->vif.bss_conf.beacon_int, 619 ifibss->channel, ifibss->basic_rates, 620 capability, 0); 621} 622 623/* 624 * This function is called with state == IEEE80211_IBSS_MLME_SEARCH 625 */ 626 627static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata) 628{ 629 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 630 struct ieee80211_local *local = sdata->local; 631 struct cfg80211_bss *cbss; 632 struct ieee80211_channel *chan = NULL; 633 const u8 *bssid = NULL; 634 int active_ibss; 635 u16 capability; 636 637 lockdep_assert_held(&ifibss->mtx); 638 639 active_ibss = ieee80211_sta_active_ibss(sdata); 640#ifdef CONFIG_MAC80211_IBSS_DEBUG 641 printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n", 642 sdata->name, active_ibss); 643#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 644 645 if (active_ibss) 646 return; 647 648 capability = WLAN_CAPABILITY_IBSS; 649 if (ifibss->privacy) 650 capability |= WLAN_CAPABILITY_PRIVACY; 651 if (ifibss->fixed_bssid) 652 bssid = ifibss->bssid; 653 if (ifibss->fixed_channel) 654 chan = ifibss->channel; 655 if (!is_zero_ether_addr(ifibss->bssid)) 656 bssid = ifibss->bssid; 657 cbss = cfg80211_get_bss(local->hw.wiphy, chan, bssid, 658 ifibss->ssid, ifibss->ssid_len, 659 WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_PRIVACY, 660 capability); 661 662 if (cbss) { 663 struct ieee80211_bss *bss; 664 665 bss = (void *)cbss->priv; 666#ifdef CONFIG_MAC80211_IBSS_DEBUG 667 printk(KERN_DEBUG " sta_find_ibss: selected %pM current " 668 "%pM\n", cbss->bssid, ifibss->bssid); 669#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 670 671 printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM" 672 " based on configured SSID\n", 673 sdata->name, cbss->bssid); 674 675 ieee80211_sta_join_ibss(sdata, bss); 676 ieee80211_rx_bss_put(local, bss); 677 return; 678 } 679 680#ifdef CONFIG_MAC80211_IBSS_DEBUG 681 printk(KERN_DEBUG " did not try to join ibss\n"); 682#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 683 684 /* Selected IBSS not found in current scan results - try to scan */ 685 if (time_after(jiffies, ifibss->last_scan_completed + 686 IEEE80211_SCAN_INTERVAL)) { 687 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to " 688 "join\n", sdata->name); 689 690 ieee80211_request_internal_scan(sdata, 691 ifibss->ssid, ifibss->ssid_len, 692 ifibss->fixed_channel ? ifibss->channel : NULL); 693 } else { 694 int interval = IEEE80211_SCAN_INTERVAL; 695 696 if (time_after(jiffies, ifibss->ibss_join_req + 697 IEEE80211_IBSS_JOIN_TIMEOUT)) { 698 if (!(local->oper_channel->flags & IEEE80211_CHAN_NO_IBSS)) { 699 ieee80211_sta_create_ibss(sdata); 700 return; 701 } 702 printk(KERN_DEBUG "%s: IBSS not allowed on" 703 " %d MHz\n", sdata->name, 704 local->hw.conf.channel->center_freq); 705 706 /* No IBSS found - decrease scan interval and continue 707 * scanning. */ 708 interval = IEEE80211_SCAN_INTERVAL_SLOW; 709 } 710 711 mod_timer(&ifibss->timer, 712 round_jiffies(jiffies + interval)); 713 } 714} 715 716static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata, 717 struct sk_buff *req) 718{ 719 struct ieee80211_mgmt *mgmt = (void *)req->data; 720 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 721 struct ieee80211_local *local = sdata->local; 722 int tx_last_beacon, len = req->len; 723 struct sk_buff *skb; 724 struct ieee80211_mgmt *resp; 725 struct sk_buff *presp; 726 u8 *pos, *end; 727 728 lockdep_assert_held(&ifibss->mtx); 729 730 presp = rcu_dereference_protected(ifibss->presp, 731 lockdep_is_held(&ifibss->mtx)); 732 733 if (ifibss->state != IEEE80211_IBSS_MLME_JOINED || 734 len < 24 + 2 || !presp) 735 return; 736 737 tx_last_beacon = drv_tx_last_beacon(local); 738 739#ifdef CONFIG_MAC80211_IBSS_DEBUG 740 printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM" 741 " (tx_last_beacon=%d)\n", 742 sdata->name, mgmt->sa, mgmt->da, 743 mgmt->bssid, tx_last_beacon); 744#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 745 746 if (!tx_last_beacon && is_multicast_ether_addr(mgmt->da)) 747 return; 748 749 if (memcmp(mgmt->bssid, ifibss->bssid, ETH_ALEN) != 0 && 750 memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0) 751 return; 752 753 end = ((u8 *) mgmt) + len; 754 pos = mgmt->u.probe_req.variable; 755 if (pos[0] != WLAN_EID_SSID || 756 pos + 2 + pos[1] > end) { 757#ifdef CONFIG_MAC80211_IBSS_DEBUG 758 printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq " 759 "from %pM\n", 760 sdata->name, mgmt->sa); 761#endif 762 return; 763 } 764 if (pos[1] != 0 && 765 (pos[1] != ifibss->ssid_len || 766 memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len))) { 767 /* Ignore ProbeReq for foreign SSID */ 768 return; 769 } 770 771 /* Reply with ProbeResp */ 772 skb = skb_copy(presp, GFP_KERNEL); 773 if (!skb) 774 return; 775 776 resp = (struct ieee80211_mgmt *) skb->data; 777 memcpy(resp->da, mgmt->sa, ETH_ALEN); 778#ifdef CONFIG_MAC80211_IBSS_DEBUG 779 printk(KERN_DEBUG "%s: Sending ProbeResp to %pM\n", 780 sdata->name, resp->da); 781#endif /* CONFIG_MAC80211_IBSS_DEBUG */ 782 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 783 ieee80211_tx_skb(sdata, skb); 784} 785 786static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata, 787 struct ieee80211_mgmt *mgmt, 788 size_t len, 789 struct ieee80211_rx_status *rx_status) 790{ 791 size_t baselen; 792 struct ieee802_11_elems elems; 793 794 if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN)) 795 return; /* ignore ProbeResp to foreign address */ 796 797 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 798 if (baselen > len) 799 return; 800 801 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 802 &elems); 803 804 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false); 805} 806 807static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata, 808 struct ieee80211_mgmt *mgmt, 809 size_t len, 810 struct ieee80211_rx_status *rx_status) 811{ 812 size_t baselen; 813 struct ieee802_11_elems elems; 814 815 /* Process beacon from the current BSS */ 816 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt; 817 if (baselen > len) 818 return; 819 820 ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems); 821 822 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, true); 823} 824 825void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 826 struct sk_buff *skb) 827{ 828 struct ieee80211_rx_status *rx_status; 829 struct ieee80211_mgmt *mgmt; 830 u16 fc; 831 832 rx_status = IEEE80211_SKB_RXCB(skb); 833 mgmt = (struct ieee80211_mgmt *) skb->data; 834 fc = le16_to_cpu(mgmt->frame_control); 835 836 mutex_lock(&sdata->u.ibss.mtx); 837 838 if (!sdata->u.ibss.ssid_len) 839 goto mgmt_out; /* not ready to merge yet */ 840 841 switch (fc & IEEE80211_FCTL_STYPE) { 842 case IEEE80211_STYPE_PROBE_REQ: 843 ieee80211_rx_mgmt_probe_req(sdata, skb); 844 break; 845 case IEEE80211_STYPE_PROBE_RESP: 846 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, 847 rx_status); 848 break; 849 case IEEE80211_STYPE_BEACON: 850 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, 851 rx_status); 852 break; 853 case IEEE80211_STYPE_AUTH: 854 ieee80211_rx_mgmt_auth_ibss(sdata, mgmt, skb->len); 855 break; 856 } 857 858 mgmt_out: 859 mutex_unlock(&sdata->u.ibss.mtx); 860} 861 862void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata) 863{ 864 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 865 866 mutex_lock(&ifibss->mtx); 867 868 /* 869 * Work could be scheduled after scan or similar 870 * when we aren't even joined (or trying) with a 871 * network. 872 */ 873 if (!ifibss->ssid_len) 874 goto out; 875 876 switch (ifibss->state) { 877 case IEEE80211_IBSS_MLME_SEARCH: 878 ieee80211_sta_find_ibss(sdata); 879 break; 880 case IEEE80211_IBSS_MLME_JOINED: 881 ieee80211_sta_merge_ibss(sdata); 882 break; 883 default: 884 WARN_ON(1); 885 break; 886 } 887 888 out: 889 mutex_unlock(&ifibss->mtx); 890} 891 892static void ieee80211_ibss_timer(unsigned long data) 893{ 894 struct ieee80211_sub_if_data *sdata = 895 (struct ieee80211_sub_if_data *) data; 896 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 897 struct ieee80211_local *local = sdata->local; 898 899 if (local->quiescing) { 900 ifibss->timer_running = true; 901 return; 902 } 903 904 ieee80211_queue_work(&local->hw, &sdata->work); 905} 906 907#ifdef CONFIG_PM 908void ieee80211_ibss_quiesce(struct ieee80211_sub_if_data *sdata) 909{ 910 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 911 912 if (del_timer_sync(&ifibss->timer)) 913 ifibss->timer_running = true; 914} 915 916void ieee80211_ibss_restart(struct ieee80211_sub_if_data *sdata) 917{ 918 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 919 920 if (ifibss->timer_running) { 921 add_timer(&ifibss->timer); 922 ifibss->timer_running = false; 923 } 924} 925#endif 926 927void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata) 928{ 929 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 930 931 setup_timer(&ifibss->timer, ieee80211_ibss_timer, 932 (unsigned long) sdata); 933 mutex_init(&ifibss->mtx); 934} 935 936/* scan finished notification */ 937void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local) 938{ 939 struct ieee80211_sub_if_data *sdata; 940 941 mutex_lock(&local->iflist_mtx); 942 list_for_each_entry(sdata, &local->interfaces, list) { 943 if (!ieee80211_sdata_running(sdata)) 944 continue; 945 if (sdata->vif.type != NL80211_IFTYPE_ADHOC) 946 continue; 947 sdata->u.ibss.last_scan_completed = jiffies; 948 ieee80211_queue_work(&local->hw, &sdata->work); 949 } 950 mutex_unlock(&local->iflist_mtx); 951} 952 953int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata, 954 struct cfg80211_ibss_params *params) 955{ 956 struct sk_buff *skb; 957 u32 changed = 0; 958 959 skb = dev_alloc_skb(sdata->local->hw.extra_tx_headroom + 960 sizeof(struct ieee80211_hdr_3addr) + 961 12 /* struct ieee80211_mgmt.u.beacon */ + 962 2 + IEEE80211_MAX_SSID_LEN /* max SSID */ + 963 2 + 8 /* max Supported Rates */ + 964 3 /* max DS params */ + 965 4 /* IBSS params */ + 966 2 + (IEEE80211_MAX_SUPP_RATES - 8) + 967 2 + sizeof(struct ieee80211_ht_cap) + 968 2 + sizeof(struct ieee80211_ht_info) + 969 params->ie_len); 970 if (!skb) 971 return -ENOMEM; 972 973 mutex_lock(&sdata->u.ibss.mtx); 974 975 if (params->bssid) { 976 memcpy(sdata->u.ibss.bssid, params->bssid, ETH_ALEN); 977 sdata->u.ibss.fixed_bssid = true; 978 } else 979 sdata->u.ibss.fixed_bssid = false; 980 981 sdata->u.ibss.privacy = params->privacy; 982 sdata->u.ibss.basic_rates = params->basic_rates; 983 memcpy(sdata->vif.bss_conf.mcast_rate, params->mcast_rate, 984 sizeof(params->mcast_rate)); 985 986 sdata->vif.bss_conf.beacon_int = params->beacon_interval; 987 988 sdata->u.ibss.channel = params->channel; 989 sdata->u.ibss.channel_type = params->channel_type; 990 sdata->u.ibss.fixed_channel = params->channel_fixed; 991 992 /* fix ourselves to that channel now already */ 993 if (params->channel_fixed) { 994 sdata->local->oper_channel = params->channel; 995 if (!ieee80211_set_channel_type(sdata->local, sdata, 996 params->channel_type)) { 997 mutex_unlock(&sdata->u.ibss.mtx); 998 return -EINVAL; 999 } 1000 } 1001 1002 if (params->ie) { 1003 sdata->u.ibss.ie = kmemdup(params->ie, params->ie_len, 1004 GFP_KERNEL); 1005 if (sdata->u.ibss.ie) 1006 sdata->u.ibss.ie_len = params->ie_len; 1007 } 1008 1009 sdata->u.ibss.skb = skb; 1010 sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH; 1011 sdata->u.ibss.ibss_join_req = jiffies; 1012 1013 memcpy(sdata->u.ibss.ssid, params->ssid, IEEE80211_MAX_SSID_LEN); 1014 sdata->u.ibss.ssid_len = params->ssid_len; 1015 1016 mutex_unlock(&sdata->u.ibss.mtx); 1017 1018 mutex_lock(&sdata->local->mtx); 1019 ieee80211_recalc_idle(sdata->local); 1020 mutex_unlock(&sdata->local->mtx); 1021 1022 /* 1023 * 802.11n-2009 9.13.3.1: In an IBSS, the HT Protection field is 1024 * reserved, but an HT STA shall protect HT transmissions as though 1025 * the HT Protection field were set to non-HT mixed mode. 1026 * 1027 * In an IBSS, the RIFS Mode field of the HT Operation element is 1028 * also reserved, but an HT STA shall operate as though this field 1029 * were set to 1. 1030 */ 1031 1032 sdata->vif.bss_conf.ht_operation_mode |= 1033 IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED 1034 | IEEE80211_HT_PARAM_RIFS_MODE; 1035 1036 changed |= BSS_CHANGED_HT; 1037 ieee80211_bss_info_change_notify(sdata, changed); 1038 1039 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 1040 1041 return 0; 1042} 1043 1044int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata) 1045{ 1046 struct sk_buff *skb; 1047 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss; 1048 struct ieee80211_local *local = sdata->local; 1049 struct cfg80211_bss *cbss; 1050 u16 capability; 1051 int active_ibss; 1052 1053 mutex_lock(&sdata->u.ibss.mtx); 1054 1055 sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH; 1056 memset(sdata->u.ibss.bssid, 0, ETH_ALEN); 1057 sdata->u.ibss.ssid_len = 0; 1058 1059 active_ibss = ieee80211_sta_active_ibss(sdata); 1060 1061 if (!active_ibss && !is_zero_ether_addr(ifibss->bssid)) { 1062 capability = WLAN_CAPABILITY_IBSS; 1063 1064 if (ifibss->privacy) 1065 capability |= WLAN_CAPABILITY_PRIVACY; 1066 1067 cbss = cfg80211_get_bss(local->hw.wiphy, ifibss->channel, 1068 ifibss->bssid, ifibss->ssid, 1069 ifibss->ssid_len, WLAN_CAPABILITY_IBSS | 1070 WLAN_CAPABILITY_PRIVACY, 1071 capability); 1072 1073 if (cbss) { 1074 cfg80211_unlink_bss(local->hw.wiphy, cbss); 1075 cfg80211_put_bss(cbss); 1076 } 1077 } 1078 1079 sta_info_flush(sdata->local, sdata); 1080 netif_carrier_off(sdata->dev); 1081 1082 /* remove beacon */ 1083 kfree(sdata->u.ibss.ie); 1084 skb = rcu_dereference_protected(sdata->u.ibss.presp, 1085 lockdep_is_held(&sdata->u.ibss.mtx)); 1086 RCU_INIT_POINTER(sdata->u.ibss.presp, NULL); 1087 sdata->vif.bss_conf.ibss_joined = false; 1088 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED | 1089 BSS_CHANGED_IBSS); 1090 synchronize_rcu(); 1091 kfree_skb(skb); 1092 1093 skb_queue_purge(&sdata->skb_queue); 1094 1095 del_timer_sync(&sdata->u.ibss.timer); 1096 1097 mutex_unlock(&sdata->u.ibss.mtx); 1098 1099 mutex_lock(&local->mtx); 1100 ieee80211_recalc_idle(sdata->local); 1101 mutex_unlock(&local->mtx); 1102 1103 return 0; 1104} 1105