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"
27 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
28 #define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
29 #define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
31 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
32 #define IEEE80211_IBSS_MERGE_DELAY 0x400000
33 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
35 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
38 static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data
*sdata
,
39 struct ieee80211_mgmt
*mgmt
,
42 u16 auth_alg
, auth_transaction
, status_code
;
47 auth_alg
= le16_to_cpu(mgmt
->u
.auth
.auth_alg
);
48 auth_transaction
= le16_to_cpu(mgmt
->u
.auth
.auth_transaction
);
49 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
52 * IEEE 802.11 standard does not require authentication in IBSS
53 * networks and most implementations do not seem to use it.
54 * However, try to reply to authentication attempts if someone
55 * has actually implemented this.
57 if (auth_alg
== WLAN_AUTH_OPEN
&& auth_transaction
== 1)
58 ieee80211_send_auth(sdata
, 2, WLAN_AUTH_OPEN
, NULL
, 0,
59 sdata
->u
.ibss
.bssid
, 0);
62 static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data
*sdata
,
63 const u8
*bssid
, const int beacon_int
,
64 struct ieee80211_channel
*chan
,
65 const size_t supp_rates_len
,
67 const u16 capability
, u64 tsf
)
69 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
70 struct ieee80211_local
*local
= sdata
->local
;
73 struct ieee80211_mgmt
*mgmt
;
75 struct ieee80211_supported_band
*sband
;
78 if (local
->ops
->reset_tsf
) {
79 /* Reset own TSF to allow time synchronization work. */
80 local
->ops
->reset_tsf(local_to_hw(local
));
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
);
318 } else if (local
&& local
->ops
&& local
->ops
->get_tsf
)
319 /* second best option: get current TSF */
320 rx_timestamp
= local
->ops
->get_tsf(local_to_hw(local
));
322 /* can't merge without knowing the TSF */
323 rx_timestamp
= -1LLU;
325 #ifdef CONFIG_MAC80211_IBSS_DEBUG
326 printk(KERN_DEBUG
"RX beacon SA=%pM BSSID="
327 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
328 mgmt
->sa
, mgmt
->bssid
,
329 (unsigned long long)rx_timestamp
,
330 (unsigned long long)beacon_timestamp
,
331 (unsigned long long)(rx_timestamp
- beacon_timestamp
),
335 /* give slow hardware some time to do the TSF sync */
336 if (rx_timestamp
< IEEE80211_IBSS_MERGE_DELAY
)
339 if (beacon_timestamp
> rx_timestamp
) {
340 #ifdef CONFIG_MAC80211_IBSS_DEBUG
341 printk(KERN_DEBUG
"%s: beacon TSF higher than "
342 "local TSF - IBSS merge with BSSID %pM\n",
343 sdata
->dev
->name
, mgmt
->bssid
);
345 ieee80211_sta_join_ibss(sdata
, bss
);
346 ieee80211_ibss_add_sta(sdata
, mgmt
->bssid
, mgmt
->sa
, supp_rates
);
350 ieee80211_rx_bss_put(local
, bss
);
354 * Add a new IBSS station, will also be called by the RX code when,
355 * in IBSS mode, receiving a frame from a yet-unknown station, hence
356 * must be callable in atomic context.
358 struct sta_info
*ieee80211_ibss_add_sta(struct ieee80211_sub_if_data
*sdata
,
359 u8
*bssid
,u8
*addr
, u32 supp_rates
)
361 struct ieee80211_local
*local
= sdata
->local
;
362 struct sta_info
*sta
;
363 int band
= local
->hw
.conf
.channel
->band
;
366 * XXX: Consider removing the least recently used entry and
367 * allow new one to be added.
369 if (local
->num_sta
>= IEEE80211_IBSS_MAX_STA_ENTRIES
) {
371 printk(KERN_DEBUG
"%s: No room for a new IBSS STA entry %pM\n",
372 sdata
->dev
->name
, addr
);
376 if (compare_ether_addr(bssid
, sdata
->u
.ibss
.bssid
))
379 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
380 printk(KERN_DEBUG
"%s: Adding new IBSS station %pM (dev=%s)\n",
381 wiphy_name(local
->hw
.wiphy
), addr
, sdata
->dev
->name
);
384 sta
= sta_info_alloc(sdata
, addr
, GFP_ATOMIC
);
388 set_sta_flags(sta
, WLAN_STA_AUTHORIZED
);
390 /* make sure mandatory rates are always added */
391 sta
->sta
.supp_rates
[band
] = supp_rates
|
392 ieee80211_mandatory_rates(local
, band
);
394 rate_control_rate_init(sta
);
396 if (sta_info_insert(sta
))
402 static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data
*sdata
)
404 struct ieee80211_local
*local
= sdata
->local
;
406 struct sta_info
*sta
;
410 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
411 if (sta
->sdata
== sdata
&&
412 time_after(sta
->last_rx
+ IEEE80211_IBSS_MERGE_INTERVAL
,
425 static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data
*sdata
)
427 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
429 mod_timer(&ifibss
->timer
,
430 round_jiffies(jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
));
432 ieee80211_sta_expire(sdata
, IEEE80211_IBSS_INACTIVITY_LIMIT
);
434 if (ieee80211_sta_active_ibss(sdata
))
437 if (ifibss
->fixed_channel
)
440 printk(KERN_DEBUG
"%s: No active IBSS STAs - trying to scan for other "
441 "IBSS networks with same SSID (merge)\n", sdata
->dev
->name
);
443 ieee80211_request_internal_scan(sdata
, ifibss
->ssid
, ifibss
->ssid_len
);
446 static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data
*sdata
)
448 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
449 struct ieee80211_local
*local
= sdata
->local
;
450 struct ieee80211_supported_band
*sband
;
453 u8 supp_rates
[IEEE80211_MAX_SUPP_RATES
];
457 if (ifibss
->fixed_bssid
) {
458 memcpy(bssid
, ifibss
->bssid
, ETH_ALEN
);
460 /* Generate random, not broadcast, locally administered BSSID. Mix in
461 * own MAC address to make sure that devices that do not have proper
462 * random number generator get different BSSID. */
463 get_random_bytes(bssid
, ETH_ALEN
);
464 for (i
= 0; i
< ETH_ALEN
; i
++)
465 bssid
[i
] ^= sdata
->dev
->dev_addr
[i
];
470 printk(KERN_DEBUG
"%s: Creating new IBSS network, BSSID %pM\n",
471 sdata
->dev
->name
, bssid
);
473 sband
= local
->hw
.wiphy
->bands
[ifibss
->channel
->band
];
475 capability
= WLAN_CAPABILITY_IBSS
;
477 if (sdata
->default_key
)
478 capability
|= WLAN_CAPABILITY_PRIVACY
;
480 sdata
->drop_unencrypted
= 0;
483 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
484 int rate
= sband
->bitrates
[i
].bitrate
;
485 *pos
++ = (u8
) (rate
/ 5);
488 __ieee80211_sta_join_ibss(sdata
, bssid
, sdata
->vif
.bss_conf
.beacon_int
,
489 ifibss
->channel
, sband
->n_bitrates
,
490 supp_rates
, capability
, 0);
493 static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data
*sdata
)
495 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
496 struct ieee80211_local
*local
= sdata
->local
;
497 struct ieee80211_bss
*bss
;
498 struct ieee80211_channel
*chan
= NULL
;
499 const u8
*bssid
= NULL
;
502 active_ibss
= ieee80211_sta_active_ibss(sdata
);
503 #ifdef CONFIG_MAC80211_IBSS_DEBUG
504 printk(KERN_DEBUG
"%s: sta_find_ibss (active_ibss=%d)\n",
505 sdata
->dev
->name
, active_ibss
);
506 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
511 if (ifibss
->fixed_bssid
)
512 bssid
= ifibss
->bssid
;
513 if (ifibss
->fixed_channel
)
514 chan
= ifibss
->channel
;
515 if (!is_zero_ether_addr(ifibss
->bssid
))
516 bssid
= ifibss
->bssid
;
517 bss
= (void *)cfg80211_get_bss(local
->hw
.wiphy
, chan
, bssid
,
518 ifibss
->ssid
, ifibss
->ssid_len
,
519 WLAN_CAPABILITY_IBSS
,
520 WLAN_CAPABILITY_IBSS
);
522 #ifdef CONFIG_MAC80211_IBSS_DEBUG
524 printk(KERN_DEBUG
" sta_find_ibss: selected %pM current "
525 "%pM\n", bss
->cbss
.bssid
, ifibss
->bssid
);
526 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
528 if (bss
&& memcmp(ifibss
->bssid
, bss
->cbss
.bssid
, ETH_ALEN
)) {
529 printk(KERN_DEBUG
"%s: Selected IBSS BSSID %pM"
530 " based on configured SSID\n",
531 sdata
->dev
->name
, bss
->cbss
.bssid
);
533 ieee80211_sta_join_ibss(sdata
, bss
);
534 ieee80211_rx_bss_put(local
, bss
);
537 ieee80211_rx_bss_put(local
, bss
);
539 #ifdef CONFIG_MAC80211_IBSS_DEBUG
540 printk(KERN_DEBUG
" did not try to join ibss\n");
541 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
543 /* Selected IBSS not found in current scan results - try to scan */
544 if (ifibss
->state
== IEEE80211_IBSS_MLME_JOINED
&&
545 !ieee80211_sta_active_ibss(sdata
)) {
546 mod_timer(&ifibss
->timer
,
547 round_jiffies(jiffies
+ IEEE80211_IBSS_MERGE_INTERVAL
));
548 } else if (time_after(jiffies
, ifibss
->last_scan_completed
+
549 IEEE80211_SCAN_INTERVAL
)) {
550 printk(KERN_DEBUG
"%s: Trigger new scan to find an IBSS to "
551 "join\n", sdata
->dev
->name
);
553 ieee80211_request_internal_scan(sdata
, ifibss
->ssid
,
555 } else if (ifibss
->state
!= IEEE80211_IBSS_MLME_JOINED
) {
556 int interval
= IEEE80211_SCAN_INTERVAL
;
558 if (time_after(jiffies
, ifibss
->ibss_join_req
+
559 IEEE80211_IBSS_JOIN_TIMEOUT
)) {
560 if (!(local
->oper_channel
->flags
& IEEE80211_CHAN_NO_IBSS
)) {
561 ieee80211_sta_create_ibss(sdata
);
564 printk(KERN_DEBUG
"%s: IBSS not allowed on"
565 " %d MHz\n", sdata
->dev
->name
,
566 local
->hw
.conf
.channel
->center_freq
);
568 /* No IBSS found - decrease scan interval and continue
570 interval
= IEEE80211_SCAN_INTERVAL_SLOW
;
573 ifibss
->state
= IEEE80211_IBSS_MLME_SEARCH
;
574 mod_timer(&ifibss
->timer
,
575 round_jiffies(jiffies
+ interval
));
579 static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data
*sdata
,
580 struct ieee80211_mgmt
*mgmt
,
583 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
584 struct ieee80211_local
*local
= sdata
->local
;
587 struct ieee80211_mgmt
*resp
;
590 if (ifibss
->state
!= IEEE80211_IBSS_MLME_JOINED
||
591 len
< 24 + 2 || !ifibss
->presp
)
594 if (local
->ops
->tx_last_beacon
)
595 tx_last_beacon
= local
->ops
->tx_last_beacon(local_to_hw(local
));
599 #ifdef CONFIG_MAC80211_IBSS_DEBUG
600 printk(KERN_DEBUG
"%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
601 " (tx_last_beacon=%d)\n",
602 sdata
->dev
->name
, mgmt
->sa
, mgmt
->da
,
603 mgmt
->bssid
, tx_last_beacon
);
604 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
609 if (memcmp(mgmt
->bssid
, ifibss
->bssid
, ETH_ALEN
) != 0 &&
610 memcmp(mgmt
->bssid
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) != 0)
613 end
= ((u8
*) mgmt
) + len
;
614 pos
= mgmt
->u
.probe_req
.variable
;
615 if (pos
[0] != WLAN_EID_SSID
||
616 pos
+ 2 + pos
[1] > end
) {
617 #ifdef CONFIG_MAC80211_IBSS_DEBUG
618 printk(KERN_DEBUG
"%s: Invalid SSID IE in ProbeReq "
620 sdata
->dev
->name
, mgmt
->sa
);
625 (pos
[1] != ifibss
->ssid_len
||
626 !memcmp(pos
+ 2, ifibss
->ssid
, ifibss
->ssid_len
))) {
627 /* Ignore ProbeReq for foreign SSID */
631 /* Reply with ProbeResp */
632 skb
= skb_copy(ifibss
->presp
, GFP_KERNEL
);
636 resp
= (struct ieee80211_mgmt
*) skb
->data
;
637 memcpy(resp
->da
, mgmt
->sa
, ETH_ALEN
);
638 #ifdef CONFIG_MAC80211_IBSS_DEBUG
639 printk(KERN_DEBUG
"%s: Sending ProbeResp to %pM\n",
640 sdata
->dev
->name
, resp
->da
);
641 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
642 ieee80211_tx_skb(sdata
, skb
, 0);
645 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data
*sdata
,
646 struct ieee80211_mgmt
*mgmt
,
648 struct ieee80211_rx_status
*rx_status
)
651 struct ieee802_11_elems elems
;
653 if (memcmp(mgmt
->da
, sdata
->dev
->dev_addr
, ETH_ALEN
))
654 return; /* ignore ProbeResp to foreign address */
656 baselen
= (u8
*) mgmt
->u
.probe_resp
.variable
- (u8
*) mgmt
;
660 ieee802_11_parse_elems(mgmt
->u
.probe_resp
.variable
, len
- baselen
,
663 ieee80211_rx_bss_info(sdata
, mgmt
, len
, rx_status
, &elems
, false);
666 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data
*sdata
,
667 struct ieee80211_mgmt
*mgmt
,
669 struct ieee80211_rx_status
*rx_status
)
672 struct ieee802_11_elems elems
;
674 /* Process beacon from the current BSS */
675 baselen
= (u8
*) mgmt
->u
.beacon
.variable
- (u8
*) mgmt
;
679 ieee802_11_parse_elems(mgmt
->u
.beacon
.variable
, len
- baselen
, &elems
);
681 ieee80211_rx_bss_info(sdata
, mgmt
, len
, rx_status
, &elems
, true);
684 static void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data
*sdata
,
687 struct ieee80211_rx_status
*rx_status
;
688 struct ieee80211_mgmt
*mgmt
;
691 rx_status
= (struct ieee80211_rx_status
*) skb
->cb
;
692 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
693 fc
= le16_to_cpu(mgmt
->frame_control
);
695 switch (fc
& IEEE80211_FCTL_STYPE
) {
696 case IEEE80211_STYPE_PROBE_REQ
:
697 ieee80211_rx_mgmt_probe_req(sdata
, mgmt
, skb
->len
);
699 case IEEE80211_STYPE_PROBE_RESP
:
700 ieee80211_rx_mgmt_probe_resp(sdata
, mgmt
, skb
->len
,
703 case IEEE80211_STYPE_BEACON
:
704 ieee80211_rx_mgmt_beacon(sdata
, mgmt
, skb
->len
,
707 case IEEE80211_STYPE_AUTH
:
708 ieee80211_rx_mgmt_auth_ibss(sdata
, mgmt
, skb
->len
);
715 static void ieee80211_ibss_work(struct work_struct
*work
)
717 struct ieee80211_sub_if_data
*sdata
=
718 container_of(work
, struct ieee80211_sub_if_data
, u
.ibss
.work
);
719 struct ieee80211_local
*local
= sdata
->local
;
720 struct ieee80211_if_ibss
*ifibss
;
723 if (!netif_running(sdata
->dev
))
726 if (local
->sw_scanning
|| local
->hw_scanning
)
729 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_ADHOC
))
731 ifibss
= &sdata
->u
.ibss
;
733 while ((skb
= skb_dequeue(&ifibss
->skb_queue
)))
734 ieee80211_ibss_rx_queued_mgmt(sdata
, skb
);
736 if (!test_and_clear_bit(IEEE80211_IBSS_REQ_RUN
, &ifibss
->request
))
739 switch (ifibss
->state
) {
740 case IEEE80211_IBSS_MLME_SEARCH
:
741 ieee80211_sta_find_ibss(sdata
);
743 case IEEE80211_IBSS_MLME_JOINED
:
744 ieee80211_sta_merge_ibss(sdata
);
752 static void ieee80211_ibss_timer(unsigned long data
)
754 struct ieee80211_sub_if_data
*sdata
=
755 (struct ieee80211_sub_if_data
*) data
;
756 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
757 struct ieee80211_local
*local
= sdata
->local
;
759 set_bit(IEEE80211_IBSS_REQ_RUN
, &ifibss
->request
);
760 queue_work(local
->hw
.workqueue
, &ifibss
->work
);
763 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data
*sdata
)
765 struct ieee80211_if_ibss
*ifibss
= &sdata
->u
.ibss
;
767 INIT_WORK(&ifibss
->work
, ieee80211_ibss_work
);
768 setup_timer(&ifibss
->timer
, ieee80211_ibss_timer
,
769 (unsigned long) sdata
);
770 skb_queue_head_init(&ifibss
->skb_queue
);
773 /* scan finished notification */
774 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local
*local
)
776 struct ieee80211_sub_if_data
*sdata
;
778 mutex_lock(&local
->iflist_mtx
);
779 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
780 if (!netif_running(sdata
->dev
))
782 if (sdata
->vif
.type
!= NL80211_IFTYPE_ADHOC
)
784 if (!sdata
->u
.ibss
.ssid_len
)
786 sdata
->u
.ibss
.last_scan_completed
= jiffies
;
787 ieee80211_sta_find_ibss(sdata
);
789 mutex_unlock(&local
->iflist_mtx
);
793 ieee80211_ibss_rx_mgmt(struct ieee80211_sub_if_data
*sdata
, struct sk_buff
*skb
,
794 struct ieee80211_rx_status
*rx_status
)
796 struct ieee80211_local
*local
= sdata
->local
;
797 struct ieee80211_mgmt
*mgmt
;
801 return RX_DROP_MONITOR
;
803 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
804 fc
= le16_to_cpu(mgmt
->frame_control
);
806 switch (fc
& IEEE80211_FCTL_STYPE
) {
807 case IEEE80211_STYPE_PROBE_RESP
:
808 case IEEE80211_STYPE_BEACON
:
809 memcpy(skb
->cb
, rx_status
, sizeof(*rx_status
));
810 case IEEE80211_STYPE_PROBE_REQ
:
811 case IEEE80211_STYPE_AUTH
:
812 skb_queue_tail(&sdata
->u
.ibss
.skb_queue
, skb
);
813 queue_work(local
->hw
.workqueue
, &sdata
->u
.ibss
.work
);
817 return RX_DROP_MONITOR
;
820 int ieee80211_ibss_join(struct ieee80211_sub_if_data
*sdata
,
821 struct cfg80211_ibss_params
*params
)
826 memcpy(sdata
->u
.ibss
.bssid
, params
->bssid
, ETH_ALEN
);
827 sdata
->u
.ibss
.fixed_bssid
= true;
829 sdata
->u
.ibss
.fixed_bssid
= false;
831 sdata
->vif
.bss_conf
.beacon_int
= params
->beacon_interval
;
833 sdata
->u
.ibss
.channel
= params
->channel
;
834 sdata
->u
.ibss
.fixed_channel
= params
->channel_fixed
;
837 sdata
->u
.ibss
.ie
= kmemdup(params
->ie
, params
->ie_len
,
839 if (sdata
->u
.ibss
.ie
)
840 sdata
->u
.ibss
.ie_len
= params
->ie_len
;
843 skb
= dev_alloc_skb(sdata
->local
->hw
.extra_tx_headroom
+
847 4 /* IBSS params */ +
852 sdata
->u
.ibss
.skb
= skb
;
853 sdata
->u
.ibss
.state
= IEEE80211_IBSS_MLME_SEARCH
;
854 sdata
->u
.ibss
.ibss_join_req
= jiffies
;
856 memcpy(sdata
->u
.ibss
.ssid
, params
->ssid
, IEEE80211_MAX_SSID_LEN
);
859 * The ssid_len setting below is used to see whether
860 * we are active, and we need all other settings
861 * before that may get visible.
865 sdata
->u
.ibss
.ssid_len
= params
->ssid_len
;
867 set_bit(IEEE80211_IBSS_REQ_RUN
, &sdata
->u
.ibss
.request
);
868 queue_work(sdata
->local
->hw
.workqueue
, &sdata
->u
.ibss
.work
);
873 int ieee80211_ibss_leave(struct ieee80211_sub_if_data
*sdata
)
877 del_timer_sync(&sdata
->u
.ibss
.timer
);
878 clear_bit(IEEE80211_IBSS_REQ_RUN
, &sdata
->u
.ibss
.request
);
879 cancel_work_sync(&sdata
->u
.ibss
.work
);
880 clear_bit(IEEE80211_IBSS_REQ_RUN
, &sdata
->u
.ibss
.request
);
882 sta_info_flush(sdata
->local
, sdata
);
885 kfree(sdata
->u
.ibss
.ie
);
886 skb
= sdata
->u
.ibss
.presp
;
887 rcu_assign_pointer(sdata
->u
.ibss
.presp
, NULL
);
888 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_BEACON_ENABLED
);
892 skb_queue_purge(&sdata
->u
.ibss
.skb_queue
);
893 memset(sdata
->u
.ibss
.bssid
, 0, ETH_ALEN
);