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>
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.
15 #include <linux/delay.h>
16 #include <linux/if_ether.h>
17 #include <linux/skbuff.h>
18 #include <linux/if_arp.h>
19 #include <linux/etherdevice.h>
20 #include <linux/rtnetlink.h>
21 #include <net/mac80211.h>
22 #include <asm/unaligned.h>
24 #include "ieee80211_i.h"
25 #include "driver-ops.h"
28 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
29 #define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
30 #define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
32 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
33 #define IEEE80211_IBSS_MERGE_DELAY 0x400000
34 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
36 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
39 static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data
*sdata
,
40 struct ieee80211_mgmt
*mgmt
,
43 u16 auth_alg
, auth_transaction
, status_code
;
48 auth_alg
= le16_to_cpu(mgmt
->u
.auth
.auth_alg
);
49 auth_transaction
= le16_to_cpu(mgmt
->u
.auth
.auth_transaction
);
50 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
53 * IEEE 802.11 standard does not require authentication in IBSS
54 * networks and most implementations do not seem to use it.
55 * However, try to reply to authentication attempts if someone
56 * has actually implemented this.
58 if (auth_alg
== WLAN_AUTH_OPEN
&& auth_transaction
== 1)
59 ieee80211_send_auth(sdata
, 2, WLAN_AUTH_OPEN
, NULL
, 0,
60 sdata
->u
.ibss
.bssid
, 0);
63 static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data
*sdata
,
64 const u8
*bssid
, const int beacon_int
,
65 struct ieee80211_channel
*chan
,
66 const size_t supp_rates_len
,
68 const u16 capability
, u64 tsf
)
70 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
71 struct ieee80211_local
*local
= sdata
->local
;
74 struct ieee80211_mgmt
*mgmt
;
76 struct ieee80211_supported_band
*sband
;
80 /* Reset own TSF to allow time synchronization work. */
84 rcu_assign_pointer(ifibss
->presp
, NULL
);
86 skb
->data
= skb
->head
;
88 skb_reset_tail_pointer(skb
);
89 skb_reserve(skb
, sdata
->local
->hw
.extra_tx_headroom
);
91 if (memcmp(ifibss
->bssid
, bssid
, ETH_ALEN
))
92 sta_info_flush(sdata
->local
, sdata
);
94 memcpy(ifibss
->bssid
, bssid
, ETH_ALEN
);
96 sdata
->drop_unencrypted
= capability
& WLAN_CAPABILITY_PRIVACY
? 1 : 0;
98 local
->oper_channel
= chan
;
99 local
->oper_channel_type
= NL80211_CHAN_NO_HT
;
100 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
);
102 sband
= local
->hw
.wiphy
->bands
[chan
->band
];
104 /* Build IBSS probe response */
105 mgmt
= (void *) skb_put(skb
, 24 + sizeof(mgmt
->u
.beacon
));
106 memset(mgmt
, 0, 24 + sizeof(mgmt
->u
.beacon
));
107 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
108 IEEE80211_STYPE_PROBE_RESP
);
109 memset(mgmt
->da
, 0xff, ETH_ALEN
);
110 memcpy(mgmt
->sa
, sdata
->dev
->dev_addr
, ETH_ALEN
);
111 memcpy(mgmt
->bssid
, ifibss
->bssid
, ETH_ALEN
);
112 mgmt
->u
.beacon
.beacon_int
= cpu_to_le16(beacon_int
);
113 mgmt
->u
.beacon
.timestamp
= cpu_to_le64(tsf
);
114 mgmt
->u
.beacon
.capab_info
= cpu_to_le16(capability
);
116 pos
= skb_put(skb
, 2 + ifibss
->ssid_len
);
117 *pos
++ = WLAN_EID_SSID
;
118 *pos
++ = ifibss
->ssid_len
;
119 memcpy(pos
, ifibss
->ssid
, ifibss
->ssid_len
);
121 rates
= supp_rates_len
;
124 pos
= skb_put(skb
, 2 + rates
);
125 *pos
++ = WLAN_EID_SUPP_RATES
;
127 memcpy(pos
, supp_rates
, rates
);
129 if (sband
->band
== IEEE80211_BAND_2GHZ
) {
130 pos
= skb_put(skb
, 2 + 1);
131 *pos
++ = WLAN_EID_DS_PARAMS
;
133 *pos
++ = ieee80211_frequency_to_channel(chan
->center_freq
);
136 pos
= skb_put(skb
, 2 + 2);
137 *pos
++ = WLAN_EID_IBSS_PARAMS
;
139 /* FIX: set ATIM window based on scan results */
143 if (supp_rates_len
> 8) {
144 rates
= supp_rates_len
- 8;
145 pos
= skb_put(skb
, 2 + rates
);
146 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
148 memcpy(pos
, &supp_rates
[8], rates
);
152 memcpy(skb_put(skb
, ifibss
->ie_len
),
153 ifibss
->ie
, ifibss
->ie_len
);
155 rcu_assign_pointer(ifibss
->presp
, skb
);
157 sdata
->vif
.bss_conf
.beacon_int
= beacon_int
;
158 bss_change
= BSS_CHANGED_BEACON_INT
;
159 bss_change
|= ieee80211_reset_erp_info(sdata
);
160 bss_change
|= BSS_CHANGED_BSSID
;
161 bss_change
|= BSS_CHANGED_BEACON
;
162 bss_change
|= BSS_CHANGED_BEACON_ENABLED
;
163 ieee80211_bss_info_change_notify(sdata
, bss_change
);
166 for (i
= 0; i
< supp_rates_len
; i
++) {
167 int bitrate
= (supp_rates
[i
] & 0x7f) * 5;
168 for (j
= 0; j
< sband
->n_bitrates
; j
++)
169 if (sband
->bitrates
[j
].bitrate
== bitrate
)
173 ieee80211_sta_def_wmm_params(sdata
, supp_rates_len
, supp_rates
);
175 ifibss
->state
= IEEE80211_IBSS_MLME_JOINED
;
176 mod_timer(&ifibss
->timer
,
177 round_jiffies(jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
));
179 cfg80211_inform_bss_frame(local
->hw
.wiphy
, local
->hw
.conf
.channel
,
180 mgmt
, skb
->len
, 0, GFP_KERNEL
);
181 cfg80211_ibss_joined(sdata
->dev
, ifibss
->bssid
, GFP_KERNEL
);
184 static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data
*sdata
,
185 struct ieee80211_bss
*bss
)
187 u16 beacon_int
= bss
->cbss
.beacon_interval
;
192 __ieee80211_sta_join_ibss(sdata
, bss
->cbss
.bssid
,
195 bss
->supp_rates_len
, bss
->supp_rates
,
196 bss
->cbss
.capability
,
200 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data
*sdata
,
201 struct ieee80211_mgmt
*mgmt
,
203 struct ieee80211_rx_status
*rx_status
,
204 struct ieee802_11_elems
*elems
,
207 struct ieee80211_local
*local
= sdata
->local
;
209 struct ieee80211_bss
*bss
;
210 struct sta_info
*sta
;
211 struct ieee80211_channel
*channel
;
212 u64 beacon_timestamp
, rx_timestamp
;
214 enum ieee80211_band band
= rx_status
->band
;
216 if (elems
->ds_params
&& elems
->ds_params_len
== 1)
217 freq
= ieee80211_channel_to_frequency(elems
->ds_params
[0]);
219 freq
= rx_status
->freq
;
221 channel
= ieee80211_get_channel(local
->hw
.wiphy
, freq
);
223 if (!channel
|| channel
->flags
& IEEE80211_CHAN_DISABLED
)
226 if (sdata
->vif
.type
== NL80211_IFTYPE_ADHOC
&& elems
->supp_rates
&&
227 memcmp(mgmt
->bssid
, sdata
->u
.ibss
.bssid
, ETH_ALEN
) == 0) {
228 supp_rates
= ieee80211_sta_get_rates(local
, elems
, band
);
232 sta
= sta_info_get(local
, mgmt
->sa
);
236 prev_rates
= sta
->sta
.supp_rates
[band
];
237 /* make sure mandatory rates are always added */
238 sta
->sta
.supp_rates
[band
] = supp_rates
|
239 ieee80211_mandatory_rates(local
, band
);
241 #ifdef CONFIG_MAC80211_IBSS_DEBUG
242 if (sta
->sta
.supp_rates
[band
] != prev_rates
)
243 printk(KERN_DEBUG
"%s: updated supp_rates set "
244 "for %pM based on beacon info (0x%llx | "
245 "0x%llx -> 0x%llx)\n",
248 (unsigned long long) prev_rates
,
249 (unsigned long long) supp_rates
,
250 (unsigned long long) sta
->sta
.supp_rates
[band
]);
253 ieee80211_ibss_add_sta(sdata
, mgmt
->bssid
, mgmt
->sa
, supp_rates
);
258 bss
= ieee80211_bss_info_update(local
, rx_status
, mgmt
, len
, elems
,
263 /* was just updated in ieee80211_bss_info_update */
264 beacon_timestamp
= bss
->cbss
.tsf
;
266 /* check if we need to merge IBSS */
268 /* merge only on beacons (???) */
272 /* we use a fixed BSSID */
273 if (sdata
->u
.ibss
.bssid
)
277 if (!(bss
->cbss
.capability
& WLAN_CAPABILITY_IBSS
))
280 /* different channel */
281 if (bss
->cbss
.channel
!= local
->oper_channel
)
285 if (elems
->ssid_len
!= sdata
->u
.ibss
.ssid_len
||
286 memcmp(elems
->ssid
, sdata
->u
.ibss
.ssid
,
287 sdata
->u
.ibss
.ssid_len
))
291 if (memcmp(bss
->cbss
.bssid
, sdata
->u
.ibss
.bssid
, ETH_ALEN
) == 0)
294 if (rx_status
->flag
& RX_FLAG_TSFT
) {
296 * For correct IBSS merging we need mactime; since mactime is
297 * defined as the time the first data symbol of the frame hits
298 * the PHY, and the timestamp of the beacon is defined as "the
299 * time that the data symbol containing the first bit of the
300 * timestamp is transmitted to the PHY plus the transmitting
301 * STA's delays through its local PHY from the MAC-PHY
302 * interface to its interface with the WM" (802.11 11.1.2)
303 * - equals the time this bit arrives at the receiver - we have
304 * to take into account the offset between the two.
306 * E.g. at 1 MBit that means mactime is 192 usec earlier
307 * (=24 bytes * 8 usecs/byte) than the beacon timestamp.
311 if (rx_status
->flag
& RX_FLAG_HT
)
312 rate
= 65; /* TODO: HT rates */
314 rate
= local
->hw
.wiphy
->bands
[band
]->
315 bitrates
[rx_status
->rate_idx
].bitrate
;
317 rx_timestamp
= rx_status
->mactime
+ (24 * 8 * 10 / rate
);
320 * second best option: get current TSF
321 * (will return -1 if not supported)
323 rx_timestamp
= drv_get_tsf(local
);
326 #ifdef CONFIG_MAC80211_IBSS_DEBUG
327 printk(KERN_DEBUG
"RX beacon SA=%pM BSSID="
328 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
329 mgmt
->sa
, mgmt
->bssid
,
330 (unsigned long long)rx_timestamp
,
331 (unsigned long long)beacon_timestamp
,
332 (unsigned long long)(rx_timestamp
- beacon_timestamp
),
336 /* give slow hardware some time to do the TSF sync */
337 if (rx_timestamp
< IEEE80211_IBSS_MERGE_DELAY
)
340 if (beacon_timestamp
> rx_timestamp
) {
341 #ifdef CONFIG_MAC80211_IBSS_DEBUG
342 printk(KERN_DEBUG
"%s: beacon TSF higher than "
343 "local TSF - IBSS merge with BSSID %pM\n",
344 sdata
->dev
->name
, mgmt
->bssid
);
346 ieee80211_sta_join_ibss(sdata
, bss
);
347 ieee80211_ibss_add_sta(sdata
, mgmt
->bssid
, mgmt
->sa
, supp_rates
);
351 ieee80211_rx_bss_put(local
, bss
);
355 * Add a new IBSS station, will also be called by the RX code when,
356 * in IBSS mode, receiving a frame from a yet-unknown station, hence
357 * must be callable in atomic context.
359 struct sta_info
*ieee80211_ibss_add_sta(struct ieee80211_sub_if_data
*sdata
,
360 u8
*bssid
,u8
*addr
, u32 supp_rates
)
362 struct ieee80211_local
*local
= sdata
->local
;
363 struct sta_info
*sta
;
364 int band
= local
->hw
.conf
.channel
->band
;
367 * XXX: Consider removing the least recently used entry and
368 * allow new one to be added.
370 if (local
->num_sta
>= IEEE80211_IBSS_MAX_STA_ENTRIES
) {
372 printk(KERN_DEBUG
"%s: No room for a new IBSS STA entry %pM\n",
373 sdata
->dev
->name
, addr
);
377 if (compare_ether_addr(bssid
, sdata
->u
.ibss
.bssid
))
380 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
381 printk(KERN_DEBUG
"%s: Adding new IBSS station %pM (dev=%s)\n",
382 wiphy_name(local
->hw
.wiphy
), addr
, sdata
->dev
->name
);
385 sta
= sta_info_alloc(sdata
, addr
, GFP_ATOMIC
);
389 set_sta_flags(sta
, WLAN_STA_AUTHORIZED
);
391 /* make sure mandatory rates are always added */
392 sta
->sta
.supp_rates
[band
] = supp_rates
|
393 ieee80211_mandatory_rates(local
, band
);
395 rate_control_rate_init(sta
);
397 if (sta_info_insert(sta
))
403 static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data
*sdata
)
405 struct ieee80211_local
*local
= sdata
->local
;
407 struct sta_info
*sta
;
411 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
412 if (sta
->sdata
== sdata
&&
413 time_after(sta
->last_rx
+ IEEE80211_IBSS_MERGE_INTERVAL
,
426 static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data
*sdata
)
428 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
430 mod_timer(&ifibss
->timer
,
431 round_jiffies(jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
));
433 ieee80211_sta_expire(sdata
, IEEE80211_IBSS_INACTIVITY_LIMIT
);
435 if (ieee80211_sta_active_ibss(sdata
))
438 if (ifibss
->fixed_channel
)
441 printk(KERN_DEBUG
"%s: No active IBSS STAs - trying to scan for other "
442 "IBSS networks with same SSID (merge)\n", sdata
->dev
->name
);
444 ieee80211_request_internal_scan(sdata
, ifibss
->ssid
, ifibss
->ssid_len
);
447 static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data
*sdata
)
449 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
450 struct ieee80211_local
*local
= sdata
->local
;
451 struct ieee80211_supported_band
*sband
;
454 u8 supp_rates
[IEEE80211_MAX_SUPP_RATES
];
458 if (ifibss
->fixed_bssid
) {
459 memcpy(bssid
, ifibss
->bssid
, ETH_ALEN
);
461 /* Generate random, not broadcast, locally administered BSSID. Mix in
462 * own MAC address to make sure that devices that do not have proper
463 * random number generator get different BSSID. */
464 get_random_bytes(bssid
, ETH_ALEN
);
465 for (i
= 0; i
< ETH_ALEN
; i
++)
466 bssid
[i
] ^= sdata
->dev
->dev_addr
[i
];
471 printk(KERN_DEBUG
"%s: Creating new IBSS network, BSSID %pM\n",
472 sdata
->dev
->name
, bssid
);
474 sband
= local
->hw
.wiphy
->bands
[ifibss
->channel
->band
];
476 capability
= WLAN_CAPABILITY_IBSS
;
478 if (sdata
->default_key
)
479 capability
|= WLAN_CAPABILITY_PRIVACY
;
481 sdata
->drop_unencrypted
= 0;
484 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
485 int rate
= sband
->bitrates
[i
].bitrate
;
486 *pos
++ = (u8
) (rate
/ 5);
489 __ieee80211_sta_join_ibss(sdata
, bssid
, sdata
->vif
.bss_conf
.beacon_int
,
490 ifibss
->channel
, sband
->n_bitrates
,
491 supp_rates
, capability
, 0);
494 static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data
*sdata
)
496 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
497 struct ieee80211_local
*local
= sdata
->local
;
498 struct ieee80211_bss
*bss
;
499 struct ieee80211_channel
*chan
= NULL
;
500 const u8
*bssid
= NULL
;
504 active_ibss
= ieee80211_sta_active_ibss(sdata
);
505 #ifdef CONFIG_MAC80211_IBSS_DEBUG
506 printk(KERN_DEBUG
"%s: sta_find_ibss (active_ibss=%d)\n",
507 sdata
->dev
->name
, active_ibss
);
508 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
513 capability
= WLAN_CAPABILITY_IBSS
;
514 if (sdata
->default_key
)
515 capability
|= WLAN_CAPABILITY_PRIVACY
;
517 if (ifibss
->fixed_bssid
)
518 bssid
= ifibss
->bssid
;
519 if (ifibss
->fixed_channel
)
520 chan
= ifibss
->channel
;
521 if (!is_zero_ether_addr(ifibss
->bssid
))
522 bssid
= ifibss
->bssid
;
523 bss
= (void *)cfg80211_get_bss(local
->hw
.wiphy
, chan
, bssid
,
524 ifibss
->ssid
, ifibss
->ssid_len
,
526 WLAN_CAPABILITY_IBSS
|
527 WLAN_CAPABILITY_PRIVACY
);
529 #ifdef CONFIG_MAC80211_IBSS_DEBUG
531 printk(KERN_DEBUG
" sta_find_ibss: selected %pM current "
532 "%pM\n", bss
->cbss
.bssid
, ifibss
->bssid
);
533 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
535 if (bss
&& memcmp(ifibss
->bssid
, bss
->cbss
.bssid
, ETH_ALEN
)) {
536 printk(KERN_DEBUG
"%s: Selected IBSS BSSID %pM"
537 " based on configured SSID\n",
538 sdata
->dev
->name
, bss
->cbss
.bssid
);
540 ieee80211_sta_join_ibss(sdata
, bss
);
541 ieee80211_rx_bss_put(local
, bss
);
544 ieee80211_rx_bss_put(local
, bss
);
546 #ifdef CONFIG_MAC80211_IBSS_DEBUG
547 printk(KERN_DEBUG
" did not try to join ibss\n");
548 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
550 /* Selected IBSS not found in current scan results - try to scan */
551 if (ifibss
->state
== IEEE80211_IBSS_MLME_JOINED
&&
552 !ieee80211_sta_active_ibss(sdata
)) {
553 mod_timer(&ifibss
->timer
,
554 round_jiffies(jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
));
555 } else if (time_after(jiffies
, ifibss
->last_scan_completed
+
556 IEEE80211_SCAN_INTERVAL
)) {
557 printk(KERN_DEBUG
"%s: Trigger new scan to find an IBSS to "
558 "join\n", sdata
->dev
->name
);
560 ieee80211_request_internal_scan(sdata
, ifibss
->ssid
,
562 } else if (ifibss
->state
!= IEEE80211_IBSS_MLME_JOINED
) {
563 int interval
= IEEE80211_SCAN_INTERVAL
;
565 if (time_after(jiffies
, ifibss
->ibss_join_req
+
566 IEEE80211_IBSS_JOIN_TIMEOUT
)) {
567 if (!(local
->oper_channel
->flags
& IEEE80211_CHAN_NO_IBSS
)) {
568 ieee80211_sta_create_ibss(sdata
);
571 printk(KERN_DEBUG
"%s: IBSS not allowed on"
572 " %d MHz\n", sdata
->dev
->name
,
573 local
->hw
.conf
.channel
->center_freq
);
575 /* No IBSS found - decrease scan interval and continue
577 interval
= IEEE80211_SCAN_INTERVAL_SLOW
;
580 ifibss
->state
= IEEE80211_IBSS_MLME_SEARCH
;
581 mod_timer(&ifibss
->timer
,
582 round_jiffies(jiffies
+ interval
));
586 static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data
*sdata
,
587 struct ieee80211_mgmt
*mgmt
,
590 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
591 struct ieee80211_local
*local
= sdata
->local
;
594 struct ieee80211_mgmt
*resp
;
597 if (ifibss
->state
!= IEEE80211_IBSS_MLME_JOINED
||
598 len
< 24 + 2 || !ifibss
->presp
)
601 tx_last_beacon
= drv_tx_last_beacon(local
);
603 #ifdef CONFIG_MAC80211_IBSS_DEBUG
604 printk(KERN_DEBUG
"%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
605 " (tx_last_beacon=%d)\n",
606 sdata
->dev
->name
, mgmt
->sa
, mgmt
->da
,
607 mgmt
->bssid
, tx_last_beacon
);
608 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
613 if (memcmp(mgmt
->bssid
, ifibss
->bssid
, ETH_ALEN
) != 0 &&
614 memcmp(mgmt
->bssid
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) != 0)
617 end
= ((u8
*) mgmt
) + len
;
618 pos
= mgmt
->u
.probe_req
.variable
;
619 if (pos
[0] != WLAN_EID_SSID
||
620 pos
+ 2 + pos
[1] > end
) {
621 #ifdef CONFIG_MAC80211_IBSS_DEBUG
622 printk(KERN_DEBUG
"%s: Invalid SSID IE in ProbeReq "
624 sdata
->dev
->name
, mgmt
->sa
);
629 (pos
[1] != ifibss
->ssid_len
||
630 !memcmp(pos
+ 2, ifibss
->ssid
, ifibss
->ssid_len
))) {
631 /* Ignore ProbeReq for foreign SSID */
635 /* Reply with ProbeResp */
636 skb
= skb_copy(ifibss
->presp
, GFP_KERNEL
);
640 resp
= (struct ieee80211_mgmt
*) skb
->data
;
641 memcpy(resp
->da
, mgmt
->sa
, ETH_ALEN
);
642 #ifdef CONFIG_MAC80211_IBSS_DEBUG
643 printk(KERN_DEBUG
"%s: Sending ProbeResp to %pM\n",
644 sdata
->dev
->name
, resp
->da
);
645 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
646 ieee80211_tx_skb(sdata
, skb
, 0);
649 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data
*sdata
,
650 struct ieee80211_mgmt
*mgmt
,
652 struct ieee80211_rx_status
*rx_status
)
655 struct ieee802_11_elems elems
;
657 if (memcmp(mgmt
->da
, sdata
->dev
->dev_addr
, ETH_ALEN
))
658 return; /* ignore ProbeResp to foreign address */
660 baselen
= (u8
*) mgmt
->u
.probe_resp
.variable
- (u8
*) mgmt
;
664 ieee802_11_parse_elems(mgmt
->u
.probe_resp
.variable
, len
- baselen
,
667 ieee80211_rx_bss_info(sdata
, mgmt
, len
, rx_status
, &elems
, false);
670 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data
*sdata
,
671 struct ieee80211_mgmt
*mgmt
,
673 struct ieee80211_rx_status
*rx_status
)
676 struct ieee802_11_elems elems
;
678 /* Process beacon from the current BSS */
679 baselen
= (u8
*) mgmt
->u
.beacon
.variable
- (u8
*) mgmt
;
683 ieee802_11_parse_elems(mgmt
->u
.beacon
.variable
, len
- baselen
, &elems
);
685 ieee80211_rx_bss_info(sdata
, mgmt
, len
, rx_status
, &elems
, true);
688 static void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data
*sdata
,
691 struct ieee80211_rx_status
*rx_status
;
692 struct ieee80211_mgmt
*mgmt
;
695 rx_status
= (struct ieee80211_rx_status
*) skb
->cb
;
696 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
697 fc
= le16_to_cpu(mgmt
->frame_control
);
699 switch (fc
& IEEE80211_FCTL_STYPE
) {
700 case IEEE80211_STYPE_PROBE_REQ
:
701 ieee80211_rx_mgmt_probe_req(sdata
, mgmt
, skb
->len
);
703 case IEEE80211_STYPE_PROBE_RESP
:
704 ieee80211_rx_mgmt_probe_resp(sdata
, mgmt
, skb
->len
,
707 case IEEE80211_STYPE_BEACON
:
708 ieee80211_rx_mgmt_beacon(sdata
, mgmt
, skb
->len
,
711 case IEEE80211_STYPE_AUTH
:
712 ieee80211_rx_mgmt_auth_ibss(sdata
, mgmt
, skb
->len
);
719 static void ieee80211_ibss_work(struct work_struct
*work
)
721 struct ieee80211_sub_if_data
*sdata
=
722 container_of(work
, struct ieee80211_sub_if_data
, u
.ibss
.work
);
723 struct ieee80211_local
*local
= sdata
->local
;
724 struct ieee80211_if_ibss
*ifibss
;
727 if (!netif_running(sdata
->dev
))
730 if (local
->sw_scanning
|| local
->hw_scanning
)
733 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_ADHOC
))
735 ifibss
= &sdata
->u
.ibss
;
737 while ((skb
= skb_dequeue(&ifibss
->skb_queue
)))
738 ieee80211_ibss_rx_queued_mgmt(sdata
, skb
);
740 if (!test_and_clear_bit(IEEE80211_IBSS_REQ_RUN
, &ifibss
->request
))
743 switch (ifibss
->state
) {
744 case IEEE80211_IBSS_MLME_SEARCH
:
745 ieee80211_sta_find_ibss(sdata
);
747 case IEEE80211_IBSS_MLME_JOINED
:
748 ieee80211_sta_merge_ibss(sdata
);
756 static void ieee80211_ibss_timer(unsigned long data
)
758 struct ieee80211_sub_if_data
*sdata
=
759 (struct ieee80211_sub_if_data
*) data
;
760 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
761 struct ieee80211_local
*local
= sdata
->local
;
763 set_bit(IEEE80211_IBSS_REQ_RUN
, &ifibss
->request
);
764 queue_work(local
->hw
.workqueue
, &ifibss
->work
);
767 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data
*sdata
)
769 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
771 INIT_WORK(&ifibss
->work
, ieee80211_ibss_work
);
772 setup_timer(&ifibss
->timer
, ieee80211_ibss_timer
,
773 (unsigned long) sdata
);
774 skb_queue_head_init(&ifibss
->skb_queue
);
777 /* scan finished notification */
778 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local
*local
)
780 struct ieee80211_sub_if_data
*sdata
;
782 mutex_lock(&local
->iflist_mtx
);
783 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
784 if (!netif_running(sdata
->dev
))
786 if (sdata
->vif
.type
!= NL80211_IFTYPE_ADHOC
)
788 if (!sdata
->u
.ibss
.ssid_len
)
790 sdata
->u
.ibss
.last_scan_completed
= jiffies
;
791 ieee80211_sta_find_ibss(sdata
);
793 mutex_unlock(&local
->iflist_mtx
);
797 ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data
*sdata
, struct sk_buff
*skb
,
798 struct ieee80211_rx_status
*rx_status
)
800 struct ieee80211_local
*local
= sdata
->local
;
801 struct ieee80211_mgmt
*mgmt
;
805 return RX_DROP_MONITOR
;
807 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
808 fc
= le16_to_cpu(mgmt
->frame_control
);
810 switch (fc
& IEEE80211_FCTL_STYPE
) {
811 case IEEE80211_STYPE_PROBE_RESP
:
812 case IEEE80211_STYPE_BEACON
:
813 memcpy(skb
->cb
, rx_status
, sizeof(*rx_status
));
814 case IEEE80211_STYPE_PROBE_REQ
:
815 case IEEE80211_STYPE_AUTH
:
816 skb_queue_tail(&sdata
->u
.ibss
.skb_queue
, skb
);
817 queue_work(local
->hw
.workqueue
, &sdata
->u
.ibss
.work
);
821 return RX_DROP_MONITOR
;
824 int ieee80211_ibss_join(struct ieee80211_sub_if_data
*sdata
,
825 struct cfg80211_ibss_params
*params
)
830 memcpy(sdata
->u
.ibss
.bssid
, params
->bssid
, ETH_ALEN
);
831 sdata
->u
.ibss
.fixed_bssid
= true;
833 sdata
->u
.ibss
.fixed_bssid
= false;
835 sdata
->vif
.bss_conf
.beacon_int
= params
->beacon_interval
;
837 sdata
->u
.ibss
.channel
= params
->channel
;
838 sdata
->u
.ibss
.fixed_channel
= params
->channel_fixed
;
841 sdata
->u
.ibss
.ie
= kmemdup(params
->ie
, params
->ie_len
,
843 if (sdata
->u
.ibss
.ie
)
844 sdata
->u
.ibss
.ie_len
= params
->ie_len
;
847 skb
= dev_alloc_skb(sdata
->local
->hw
.extra_tx_headroom
+
851 4 /* IBSS params */ +
856 sdata
->u
.ibss
.skb
= skb
;
857 sdata
->u
.ibss
.state
= IEEE80211_IBSS_MLME_SEARCH
;
858 sdata
->u
.ibss
.ibss_join_req
= jiffies
;
860 memcpy(sdata
->u
.ibss
.ssid
, params
->ssid
, IEEE80211_MAX_SSID_LEN
);
863 * The ssid_len setting below is used to see whether
864 * we are active, and we need all other settings
865 * before that may get visible.
869 sdata
->u
.ibss
.ssid_len
= params
->ssid_len
;
871 ieee80211_recalc_idle(sdata
->local
);
873 set_bit(IEEE80211_IBSS_REQ_RUN
, &sdata
->u
.ibss
.request
);
874 queue_work(sdata
->local
->hw
.workqueue
, &sdata
->u
.ibss
.work
);
879 int ieee80211_ibss_leave(struct ieee80211_sub_if_data
*sdata
)
883 del_timer_sync(&sdata
->u
.ibss
.timer
);
884 clear_bit(IEEE80211_IBSS_REQ_RUN
, &sdata
->u
.ibss
.request
);
885 cancel_work_sync(&sdata
->u
.ibss
.work
);
886 clear_bit(IEEE80211_IBSS_REQ_RUN
, &sdata
->u
.ibss
.request
);
888 sta_info_flush(sdata
->local
, sdata
);
891 kfree(sdata
->u
.ibss
.ie
);
892 skb
= sdata
->u
.ibss
.presp
;
893 rcu_assign_pointer(sdata
->u
.ibss
.presp
, NULL
);
894 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON_ENABLED
);
898 skb_queue_purge(&sdata
->u
.ibss
.skb_queue
);
899 memset(sdata
->u
.ibss
.bssid
, 0, ETH_ALEN
);
900 sdata
->u
.ibss
.ssid_len
= 0;
902 ieee80211_recalc_idle(sdata
->local
);