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