blob: 9ea690330dccefce81629652b1170be6e1ede03e [file] [log] [blame]
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001/*
2 * BSS table
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08003 * Copyright (c) 2009-2012, Jouni Malinen <j@w1.fi>
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004 *
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08005 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07007 */
8
9#include "utils/includes.h"
10
11#include "utils/common.h"
12#include "utils/eloop.h"
13#include "common/ieee802_11_defs.h"
14#include "drivers/driver.h"
15#include "wpa_supplicant_i.h"
16#include "config.h"
17#include "notify.h"
18#include "scan.h"
19#include "bss.h"
20
21
22/**
23 * WPA_BSS_EXPIRATION_PERIOD - Period of expiration run in seconds
24 */
25#define WPA_BSS_EXPIRATION_PERIOD 10
26
27#define WPA_BSS_FREQ_CHANGED_FLAG BIT(0)
28#define WPA_BSS_SIGNAL_CHANGED_FLAG BIT(1)
29#define WPA_BSS_PRIVACY_CHANGED_FLAG BIT(2)
30#define WPA_BSS_MODE_CHANGED_FLAG BIT(3)
31#define WPA_BSS_WPAIE_CHANGED_FLAG BIT(4)
32#define WPA_BSS_RSNIE_CHANGED_FLAG BIT(5)
33#define WPA_BSS_WPS_CHANGED_FLAG BIT(6)
34#define WPA_BSS_RATES_CHANGED_FLAG BIT(7)
35#define WPA_BSS_IES_CHANGED_FLAG BIT(8)
36
37
Dmitry Shmidt4530cfd2012-09-09 15:20:40 -070038static void wpa_bss_set_hessid(struct wpa_bss *bss)
39{
40#ifdef CONFIG_INTERWORKING
41 const u8 *ie = wpa_bss_get_ie(bss, WLAN_EID_INTERWORKING);
42 if (ie == NULL || (ie[1] != 7 && ie[1] != 9)) {
43 os_memset(bss->hessid, 0, ETH_ALEN);
44 return;
45 }
46 if (ie[1] == 7)
47 os_memcpy(bss->hessid, ie + 3, ETH_ALEN);
48 else
49 os_memcpy(bss->hessid, ie + 5, ETH_ALEN);
50#endif /* CONFIG_INTERWORKING */
51}
52
53
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080054/**
55 * wpa_bss_anqp_alloc - Allocate ANQP data structure for a BSS entry
56 * Returns: Allocated ANQP data structure or %NULL on failure
57 *
58 * The allocated ANQP data structure has its users count set to 1. It may be
59 * shared by multiple BSS entries and each shared entry is freed with
60 * wpa_bss_anqp_free().
61 */
Dmitry Shmidt4530cfd2012-09-09 15:20:40 -070062struct wpa_bss_anqp * wpa_bss_anqp_alloc(void)
63{
64 struct wpa_bss_anqp *anqp;
65 anqp = os_zalloc(sizeof(*anqp));
66 if (anqp == NULL)
67 return NULL;
68 anqp->users = 1;
69 return anqp;
70}
71
72
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080073/**
74 * wpa_bss_anqp_clone - Clone an ANQP data structure
75 * @anqp: ANQP data structure from wpa_bss_anqp_alloc()
76 * Returns: Cloned ANQP data structure or %NULL on failure
77 */
Dmitry Shmidtd5e49232012-12-03 15:08:10 -080078static struct wpa_bss_anqp * wpa_bss_anqp_clone(struct wpa_bss_anqp *anqp)
79{
80 struct wpa_bss_anqp *n;
81
82 n = os_zalloc(sizeof(*n));
83 if (n == NULL)
84 return NULL;
85
86#define ANQP_DUP(f) if (anqp->f) n->f = wpabuf_dup(anqp->f)
87#ifdef CONFIG_INTERWORKING
88 ANQP_DUP(venue_name);
89 ANQP_DUP(network_auth_type);
90 ANQP_DUP(roaming_consortium);
91 ANQP_DUP(ip_addr_type_availability);
92 ANQP_DUP(nai_realm);
93 ANQP_DUP(anqp_3gpp);
94 ANQP_DUP(domain_name);
95#endif /* CONFIG_INTERWORKING */
96#ifdef CONFIG_HS20
97 ANQP_DUP(hs20_operator_friendly_name);
98 ANQP_DUP(hs20_wan_metrics);
99 ANQP_DUP(hs20_connection_capability);
100 ANQP_DUP(hs20_operating_class);
101#endif /* CONFIG_HS20 */
102#undef ANQP_DUP
103
104 return n;
105}
106
107
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800108/**
109 * wpa_bss_anqp_unshare_alloc - Unshare ANQP data (if shared) in a BSS entry
110 * @bss: BSS entry
111 * Returns: 0 on success, -1 on failure
112 *
113 * This function ensures the specific BSS entry has an ANQP data structure that
114 * is not shared with any other BSS entry.
115 */
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800116int wpa_bss_anqp_unshare_alloc(struct wpa_bss *bss)
117{
118 struct wpa_bss_anqp *anqp;
119
120 if (bss->anqp && bss->anqp->users > 1) {
121 /* allocated, but shared - clone an unshared copy */
122 anqp = wpa_bss_anqp_clone(bss->anqp);
123 if (anqp == NULL)
124 return -1;
125 anqp->users = 1;
126 bss->anqp->users--;
127 bss->anqp = anqp;
128 return 0;
129 }
130
131 if (bss->anqp)
132 return 0; /* already allocated and not shared */
133
134 /* not allocated - allocate a new storage area */
135 bss->anqp = wpa_bss_anqp_alloc();
136 return bss->anqp ? 0 : -1;
137}
138
139
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800140/**
141 * wpa_bss_anqp_free - Free an ANQP data structure
142 * @anqp: ANQP data structure from wpa_bss_anqp_alloc() or wpa_bss_anqp_clone()
143 */
Dmitry Shmidt4530cfd2012-09-09 15:20:40 -0700144static void wpa_bss_anqp_free(struct wpa_bss_anqp *anqp)
145{
146 if (anqp == NULL)
147 return;
148
149 anqp->users--;
150 if (anqp->users > 0) {
151 /* Another BSS entry holds a pointer to this ANQP info */
152 return;
153 }
154
155#ifdef CONFIG_INTERWORKING
156 wpabuf_free(anqp->venue_name);
157 wpabuf_free(anqp->network_auth_type);
158 wpabuf_free(anqp->roaming_consortium);
159 wpabuf_free(anqp->ip_addr_type_availability);
160 wpabuf_free(anqp->nai_realm);
161 wpabuf_free(anqp->anqp_3gpp);
162 wpabuf_free(anqp->domain_name);
163#endif /* CONFIG_INTERWORKING */
164#ifdef CONFIG_HS20
165 wpabuf_free(anqp->hs20_operator_friendly_name);
166 wpabuf_free(anqp->hs20_wan_metrics);
167 wpabuf_free(anqp->hs20_connection_capability);
168 wpabuf_free(anqp->hs20_operating_class);
169#endif /* CONFIG_HS20 */
170
171 os_free(anqp);
172}
173
174
Dmitry Shmidt04949592012-07-19 12:16:46 -0700175static void wpa_bss_remove(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
176 const char *reason)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700177{
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700178 if (wpa_s->last_scan_res) {
179 unsigned int i;
180 for (i = 0; i < wpa_s->last_scan_res_used; i++) {
181 if (wpa_s->last_scan_res[i] == bss) {
182 os_memmove(&wpa_s->last_scan_res[i],
183 &wpa_s->last_scan_res[i + 1],
184 (wpa_s->last_scan_res_used - i - 1)
185 * sizeof(struct wpa_bss *));
186 wpa_s->last_scan_res_used--;
187 break;
188 }
189 }
190 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700191 dl_list_del(&bss->list);
192 dl_list_del(&bss->list_id);
193 wpa_s->num_bss--;
194 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Remove id %u BSSID " MACSTR
Dmitry Shmidt04949592012-07-19 12:16:46 -0700195 " SSID '%s' due to %s", bss->id, MAC2STR(bss->bssid),
196 wpa_ssid_txt(bss->ssid, bss->ssid_len), reason);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700197 wpas_notify_bss_removed(wpa_s, bss->bssid, bss->id);
Dmitry Shmidt4530cfd2012-09-09 15:20:40 -0700198 wpa_bss_anqp_free(bss->anqp);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700199 os_free(bss);
200}
201
202
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800203/**
204 * wpa_bss_get - Fetch a BSS table entry based on BSSID and SSID
205 * @wpa_s: Pointer to wpa_supplicant data
206 * @bssid: BSSID
207 * @ssid: SSID
208 * @ssid_len: Length of @ssid
209 * Returns: Pointer to the BSS entry or %NULL if not found
210 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700211struct wpa_bss * wpa_bss_get(struct wpa_supplicant *wpa_s, const u8 *bssid,
212 const u8 *ssid, size_t ssid_len)
213{
214 struct wpa_bss *bss;
Dmitry Shmidt04949592012-07-19 12:16:46 -0700215 if (!wpa_supplicant_filter_bssid_match(wpa_s, bssid))
216 return NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700217 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
218 if (os_memcmp(bss->bssid, bssid, ETH_ALEN) == 0 &&
219 bss->ssid_len == ssid_len &&
220 os_memcmp(bss->ssid, ssid, ssid_len) == 0)
221 return bss;
222 }
223 return NULL;
224}
225
226
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800227static void calculate_update_time(const struct os_reltime *fetch_time,
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700228 unsigned int age_ms,
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800229 struct os_reltime *update_time)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700230{
231 os_time_t usec;
232
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700233 update_time->sec = fetch_time->sec;
234 update_time->usec = fetch_time->usec;
235 update_time->sec -= age_ms / 1000;
236 usec = (age_ms % 1000) * 1000;
237 if (update_time->usec < usec) {
238 update_time->sec--;
239 update_time->usec += 1000000;
240 }
241 update_time->usec -= usec;
242}
243
244
245static void wpa_bss_copy_res(struct wpa_bss *dst, struct wpa_scan_res *src,
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800246 struct os_reltime *fetch_time)
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700247{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700248 dst->flags = src->flags;
249 os_memcpy(dst->bssid, src->bssid, ETH_ALEN);
250 dst->freq = src->freq;
251 dst->beacon_int = src->beacon_int;
252 dst->caps = src->caps;
253 dst->qual = src->qual;
254 dst->noise = src->noise;
255 dst->level = src->level;
256 dst->tsf = src->tsf;
257
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700258 calculate_update_time(fetch_time, src->age, &dst->last_update);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700259}
260
261
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800262static int wpa_bss_known(struct wpa_supplicant *wpa_s, struct wpa_bss *bss)
263{
264 struct wpa_ssid *ssid;
265
266 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
267 if (ssid->ssid == NULL || ssid->ssid_len == 0)
268 continue;
269 if (ssid->ssid_len == bss->ssid_len &&
270 os_memcmp(ssid->ssid, bss->ssid, ssid->ssid_len) == 0)
271 return 1;
272 }
273
274 return 0;
275}
276
277
Dmitry Shmidt04949592012-07-19 12:16:46 -0700278static int wpa_bss_in_use(struct wpa_supplicant *wpa_s, struct wpa_bss *bss)
279{
280 return bss == wpa_s->current_bss ||
281 os_memcmp(bss->bssid, wpa_s->bssid, ETH_ALEN) == 0 ||
282 os_memcmp(bss->bssid, wpa_s->pending_bssid, ETH_ALEN) == 0;
283}
284
285
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800286static int wpa_bss_remove_oldest_unknown(struct wpa_supplicant *wpa_s)
287{
288 struct wpa_bss *bss;
289
290 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
291 if (!wpa_bss_known(wpa_s, bss)) {
Dmitry Shmidt04949592012-07-19 12:16:46 -0700292 wpa_bss_remove(wpa_s, bss, __func__);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800293 return 0;
294 }
295 }
296
297 return -1;
298}
299
300
Dmitry Shmidt04949592012-07-19 12:16:46 -0700301static int wpa_bss_remove_oldest(struct wpa_supplicant *wpa_s)
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800302{
Dmitry Shmidt04949592012-07-19 12:16:46 -0700303 struct wpa_bss *bss;
304
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800305 /*
306 * Remove the oldest entry that does not match with any configured
307 * network.
308 */
309 if (wpa_bss_remove_oldest_unknown(wpa_s) == 0)
Dmitry Shmidt04949592012-07-19 12:16:46 -0700310 return 0;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800311
312 /*
Dmitry Shmidt04949592012-07-19 12:16:46 -0700313 * Remove the oldest entry that isn't currently in use.
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800314 */
Dmitry Shmidt04949592012-07-19 12:16:46 -0700315 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
316 if (!wpa_bss_in_use(wpa_s, bss)) {
317 wpa_bss_remove(wpa_s, bss, __func__);
318 return 0;
319 }
320 }
321
322 return -1;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800323}
324
325
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700326static struct wpa_bss * wpa_bss_add(struct wpa_supplicant *wpa_s,
327 const u8 *ssid, size_t ssid_len,
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800328 struct wpa_scan_res *res,
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800329 struct os_reltime *fetch_time)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700330{
331 struct wpa_bss *bss;
332
333 bss = os_zalloc(sizeof(*bss) + res->ie_len + res->beacon_ie_len);
334 if (bss == NULL)
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700335 return NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700336 bss->id = wpa_s->bss_next_id++;
337 bss->last_update_idx = wpa_s->bss_update_idx;
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800338 wpa_bss_copy_res(bss, res, fetch_time);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700339 os_memcpy(bss->ssid, ssid, ssid_len);
340 bss->ssid_len = ssid_len;
341 bss->ie_len = res->ie_len;
342 bss->beacon_ie_len = res->beacon_ie_len;
343 os_memcpy(bss + 1, res + 1, res->ie_len + res->beacon_ie_len);
Dmitry Shmidt4530cfd2012-09-09 15:20:40 -0700344 wpa_bss_set_hessid(bss);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700345
Jouni Malinen7a6c8302013-09-27 15:47:09 +0300346 if (wpa_s->num_bss + 1 > wpa_s->conf->bss_max_count &&
347 wpa_bss_remove_oldest(wpa_s) != 0) {
348 wpa_printf(MSG_ERROR, "Increasing the MAX BSS count to %d "
349 "because all BSSes are in use. We should normally "
350 "not get here!", (int) wpa_s->num_bss + 1);
351 wpa_s->conf->bss_max_count = wpa_s->num_bss + 1;
352 }
353
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700354 dl_list_add_tail(&wpa_s->bss, &bss->list);
355 dl_list_add_tail(&wpa_s->bss_id, &bss->list_id);
356 wpa_s->num_bss++;
357 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Add new id %u BSSID " MACSTR
358 " SSID '%s'",
359 bss->id, MAC2STR(bss->bssid), wpa_ssid_txt(ssid, ssid_len));
360 wpas_notify_bss_added(wpa_s, bss->bssid, bss->id);
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700361 return bss;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700362}
363
364
365static int are_ies_equal(const struct wpa_bss *old,
366 const struct wpa_scan_res *new, u32 ie)
367{
368 const u8 *old_ie, *new_ie;
369 struct wpabuf *old_ie_buff = NULL;
370 struct wpabuf *new_ie_buff = NULL;
371 int new_ie_len, old_ie_len, ret, is_multi;
372
373 switch (ie) {
374 case WPA_IE_VENDOR_TYPE:
375 old_ie = wpa_bss_get_vendor_ie(old, ie);
376 new_ie = wpa_scan_get_vendor_ie(new, ie);
377 is_multi = 0;
378 break;
379 case WPS_IE_VENDOR_TYPE:
380 old_ie_buff = wpa_bss_get_vendor_ie_multi(old, ie);
381 new_ie_buff = wpa_scan_get_vendor_ie_multi(new, ie);
382 is_multi = 1;
383 break;
384 case WLAN_EID_RSN:
385 case WLAN_EID_SUPP_RATES:
386 case WLAN_EID_EXT_SUPP_RATES:
387 old_ie = wpa_bss_get_ie(old, ie);
388 new_ie = wpa_scan_get_ie(new, ie);
389 is_multi = 0;
390 break;
391 default:
392 wpa_printf(MSG_DEBUG, "bss: %s: cannot compare IEs", __func__);
393 return 0;
394 }
395
396 if (is_multi) {
397 /* in case of multiple IEs stored in buffer */
398 old_ie = old_ie_buff ? wpabuf_head_u8(old_ie_buff) : NULL;
399 new_ie = new_ie_buff ? wpabuf_head_u8(new_ie_buff) : NULL;
400 old_ie_len = old_ie_buff ? wpabuf_len(old_ie_buff) : 0;
401 new_ie_len = new_ie_buff ? wpabuf_len(new_ie_buff) : 0;
402 } else {
403 /* in case of single IE */
404 old_ie_len = old_ie ? old_ie[1] + 2 : 0;
405 new_ie_len = new_ie ? new_ie[1] + 2 : 0;
406 }
407
408 if (!old_ie || !new_ie)
409 ret = !old_ie && !new_ie;
410 else
411 ret = (old_ie_len == new_ie_len &&
412 os_memcmp(old_ie, new_ie, old_ie_len) == 0);
413
414 wpabuf_free(old_ie_buff);
415 wpabuf_free(new_ie_buff);
416
417 return ret;
418}
419
420
421static u32 wpa_bss_compare_res(const struct wpa_bss *old,
422 const struct wpa_scan_res *new)
423{
424 u32 changes = 0;
425 int caps_diff = old->caps ^ new->caps;
426
427 if (old->freq != new->freq)
428 changes |= WPA_BSS_FREQ_CHANGED_FLAG;
429
430 if (old->level != new->level)
431 changes |= WPA_BSS_SIGNAL_CHANGED_FLAG;
432
433 if (caps_diff & IEEE80211_CAP_PRIVACY)
434 changes |= WPA_BSS_PRIVACY_CHANGED_FLAG;
435
436 if (caps_diff & IEEE80211_CAP_IBSS)
437 changes |= WPA_BSS_MODE_CHANGED_FLAG;
438
439 if (old->ie_len == new->ie_len &&
440 os_memcmp(old + 1, new + 1, old->ie_len) == 0)
441 return changes;
442 changes |= WPA_BSS_IES_CHANGED_FLAG;
443
444 if (!are_ies_equal(old, new, WPA_IE_VENDOR_TYPE))
445 changes |= WPA_BSS_WPAIE_CHANGED_FLAG;
446
447 if (!are_ies_equal(old, new, WLAN_EID_RSN))
448 changes |= WPA_BSS_RSNIE_CHANGED_FLAG;
449
450 if (!are_ies_equal(old, new, WPS_IE_VENDOR_TYPE))
451 changes |= WPA_BSS_WPS_CHANGED_FLAG;
452
453 if (!are_ies_equal(old, new, WLAN_EID_SUPP_RATES) ||
454 !are_ies_equal(old, new, WLAN_EID_EXT_SUPP_RATES))
455 changes |= WPA_BSS_RATES_CHANGED_FLAG;
456
457 return changes;
458}
459
460
461static void notify_bss_changes(struct wpa_supplicant *wpa_s, u32 changes,
462 const struct wpa_bss *bss)
463{
464 if (changes & WPA_BSS_FREQ_CHANGED_FLAG)
465 wpas_notify_bss_freq_changed(wpa_s, bss->id);
466
467 if (changes & WPA_BSS_SIGNAL_CHANGED_FLAG)
468 wpas_notify_bss_signal_changed(wpa_s, bss->id);
469
470 if (changes & WPA_BSS_PRIVACY_CHANGED_FLAG)
471 wpas_notify_bss_privacy_changed(wpa_s, bss->id);
472
473 if (changes & WPA_BSS_MODE_CHANGED_FLAG)
474 wpas_notify_bss_mode_changed(wpa_s, bss->id);
475
476 if (changes & WPA_BSS_WPAIE_CHANGED_FLAG)
477 wpas_notify_bss_wpaie_changed(wpa_s, bss->id);
478
479 if (changes & WPA_BSS_RSNIE_CHANGED_FLAG)
480 wpas_notify_bss_rsnie_changed(wpa_s, bss->id);
481
482 if (changes & WPA_BSS_WPS_CHANGED_FLAG)
483 wpas_notify_bss_wps_changed(wpa_s, bss->id);
484
485 if (changes & WPA_BSS_IES_CHANGED_FLAG)
486 wpas_notify_bss_ies_changed(wpa_s, bss->id);
487
488 if (changes & WPA_BSS_RATES_CHANGED_FLAG)
489 wpas_notify_bss_rates_changed(wpa_s, bss->id);
490}
491
492
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700493static struct wpa_bss *
494wpa_bss_update(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800495 struct wpa_scan_res *res, struct os_reltime *fetch_time)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700496{
497 u32 changes;
498
499 changes = wpa_bss_compare_res(bss, res);
500 bss->scan_miss_count = 0;
501 bss->last_update_idx = wpa_s->bss_update_idx;
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800502 wpa_bss_copy_res(bss, res, fetch_time);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700503 /* Move the entry to the end of the list */
504 dl_list_del(&bss->list);
Dmitry Shmidt96571392013-10-14 12:54:46 -0700505#ifdef CONFIG_P2P
506 if (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) &&
507 !wpa_scan_get_vendor_ie(res, P2P_IE_VENDOR_TYPE)) {
508 /*
509 * This can happen when non-P2P station interface runs a scan
510 * without P2P IE in the Probe Request frame. P2P GO would reply
511 * to that with a Probe Response that does not include P2P IE.
512 * Do not update the IEs in this BSS entry to avoid such loss of
513 * information that may be needed for P2P operations to
514 * determine group information.
515 */
516 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Do not update scan IEs for "
517 MACSTR " since that would remove P2P IE information",
518 MAC2STR(bss->bssid));
519 } else
520#endif /* CONFIG_P2P */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700521 if (bss->ie_len + bss->beacon_ie_len >=
522 res->ie_len + res->beacon_ie_len) {
523 os_memcpy(bss + 1, res + 1, res->ie_len + res->beacon_ie_len);
524 bss->ie_len = res->ie_len;
525 bss->beacon_ie_len = res->beacon_ie_len;
526 } else {
527 struct wpa_bss *nbss;
528 struct dl_list *prev = bss->list_id.prev;
529 dl_list_del(&bss->list_id);
530 nbss = os_realloc(bss, sizeof(*bss) + res->ie_len +
531 res->beacon_ie_len);
532 if (nbss) {
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700533 unsigned int i;
534 for (i = 0; i < wpa_s->last_scan_res_used; i++) {
535 if (wpa_s->last_scan_res[i] == bss) {
536 wpa_s->last_scan_res[i] = nbss;
537 break;
538 }
539 }
Dmitry Shmidt04949592012-07-19 12:16:46 -0700540 if (wpa_s->current_bss == bss)
541 wpa_s->current_bss = nbss;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700542 bss = nbss;
543 os_memcpy(bss + 1, res + 1,
544 res->ie_len + res->beacon_ie_len);
545 bss->ie_len = res->ie_len;
546 bss->beacon_ie_len = res->beacon_ie_len;
547 }
548 dl_list_add(prev, &bss->list_id);
549 }
Dmitry Shmidt4530cfd2012-09-09 15:20:40 -0700550 if (changes & WPA_BSS_IES_CHANGED_FLAG)
551 wpa_bss_set_hessid(bss);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700552 dl_list_add_tail(&wpa_s->bss, &bss->list);
553
554 notify_bss_changes(wpa_s, changes, bss);
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700555
556 return bss;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700557}
558
559
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800560/**
561 * wpa_bss_update_start - Start a BSS table update from scan results
562 * @wpa_s: Pointer to wpa_supplicant data
563 *
564 * This function is called at the start of each BSS table update round for new
565 * scan results. The actual scan result entries are indicated with calls to
566 * wpa_bss_update_scan_res() and the update round is finished with a call to
567 * wpa_bss_update_end().
568 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700569void wpa_bss_update_start(struct wpa_supplicant *wpa_s)
570{
571 wpa_s->bss_update_idx++;
572 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Start scan result update %u",
573 wpa_s->bss_update_idx);
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700574 wpa_s->last_scan_res_used = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700575}
576
577
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800578/**
579 * wpa_bss_update_scan_res - Update a BSS table entry based on a scan result
580 * @wpa_s: Pointer to wpa_supplicant data
581 * @res: Scan result
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800582 * @fetch_time: Time when the result was fetched from the driver
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800583 *
584 * This function updates a BSS table entry (or adds one) based on a scan result.
585 * This is called separately for each scan result between the calls to
586 * wpa_bss_update_start() and wpa_bss_update_end().
587 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700588void wpa_bss_update_scan_res(struct wpa_supplicant *wpa_s,
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800589 struct wpa_scan_res *res,
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800590 struct os_reltime *fetch_time)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700591{
592 const u8 *ssid, *p2p;
593 struct wpa_bss *bss;
594
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700595 if (wpa_s->conf->ignore_old_scan_res) {
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800596 struct os_reltime update;
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700597 calculate_update_time(fetch_time, res->age, &update);
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800598 if (os_reltime_before(&update, &wpa_s->scan_trigger_time)) {
599 struct os_reltime age;
600 os_reltime_sub(&wpa_s->scan_trigger_time, &update,
601 &age);
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700602 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Ignore driver BSS "
603 "table entry that is %u.%06u seconds older "
604 "than our scan trigger",
605 (unsigned int) age.sec,
606 (unsigned int) age.usec);
607 return;
608 }
609 }
610
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700611 ssid = wpa_scan_get_ie(res, WLAN_EID_SSID);
612 if (ssid == NULL) {
613 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: No SSID IE included for "
614 MACSTR, MAC2STR(res->bssid));
615 return;
616 }
617 if (ssid[1] > 32) {
618 wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Too long SSID IE included for "
619 MACSTR, MAC2STR(res->bssid));
620 return;
621 }
622
623 p2p = wpa_scan_get_vendor_ie(res, P2P_IE_VENDOR_TYPE);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700624#ifdef CONFIG_P2P
625 if (p2p == NULL &&
626 wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
627 /*
628 * If it's a P2P specific interface, then don't update
629 * the scan result without a P2P IE.
630 */
631 wpa_printf(MSG_DEBUG, "BSS: No P2P IE - skipping BSS " MACSTR
632 " update for P2P interface", MAC2STR(res->bssid));
633 return;
634 }
635#endif /* CONFIG_P2P */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700636 if (p2p && ssid[1] == P2P_WILDCARD_SSID_LEN &&
637 os_memcmp(ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) == 0)
638 return; /* Skip P2P listen discovery results here */
639
640 /* TODO: add option for ignoring BSSes we are not interested in
641 * (to save memory) */
642 bss = wpa_bss_get(wpa_s, res->bssid, ssid + 2, ssid[1]);
643 if (bss == NULL)
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800644 bss = wpa_bss_add(wpa_s, ssid + 2, ssid[1], res, fetch_time);
Dmitry Shmidt56052862013-10-04 10:23:25 -0700645 else {
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800646 bss = wpa_bss_update(wpa_s, bss, res, fetch_time);
Dmitry Shmidt56052862013-10-04 10:23:25 -0700647 if (wpa_s->last_scan_res) {
648 unsigned int i;
649 for (i = 0; i < wpa_s->last_scan_res_used; i++) {
650 if (bss == wpa_s->last_scan_res[i]) {
651 /* Already in the list */
652 return;
653 }
654 }
655 }
656 }
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700657
658 if (bss == NULL)
659 return;
660 if (wpa_s->last_scan_res_used >= wpa_s->last_scan_res_size) {
661 struct wpa_bss **n;
662 unsigned int siz;
663 if (wpa_s->last_scan_res_size == 0)
664 siz = 32;
665 else
666 siz = wpa_s->last_scan_res_size * 2;
667 n = os_realloc_array(wpa_s->last_scan_res, siz,
668 sizeof(struct wpa_bss *));
669 if (n == NULL)
670 return;
671 wpa_s->last_scan_res = n;
672 wpa_s->last_scan_res_size = siz;
673 }
674
675 wpa_s->last_scan_res[wpa_s->last_scan_res_used++] = bss;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700676}
677
678
679static int wpa_bss_included_in_scan(const struct wpa_bss *bss,
680 const struct scan_info *info)
681{
682 int found;
683 size_t i;
684
685 if (info == NULL)
686 return 1;
687
688 if (info->num_freqs) {
689 found = 0;
690 for (i = 0; i < info->num_freqs; i++) {
691 if (bss->freq == info->freqs[i]) {
692 found = 1;
693 break;
694 }
695 }
696 if (!found)
697 return 0;
698 }
699
700 if (info->num_ssids) {
701 found = 0;
702 for (i = 0; i < info->num_ssids; i++) {
703 const struct wpa_driver_scan_ssid *s = &info->ssids[i];
704 if ((s->ssid == NULL || s->ssid_len == 0) ||
705 (s->ssid_len == bss->ssid_len &&
706 os_memcmp(s->ssid, bss->ssid, bss->ssid_len) ==
707 0)) {
708 found = 1;
709 break;
710 }
711 }
712 if (!found)
713 return 0;
714 }
715
716 return 1;
717}
718
719
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800720/**
721 * wpa_bss_update_end - End a BSS table update from scan results
722 * @wpa_s: Pointer to wpa_supplicant data
723 * @info: Information about scan parameters
724 * @new_scan: Whether this update round was based on a new scan
725 *
726 * This function is called at the end of each BSS table update round for new
727 * scan results. The start of the update was indicated with a call to
728 * wpa_bss_update_start().
729 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700730void wpa_bss_update_end(struct wpa_supplicant *wpa_s, struct scan_info *info,
731 int new_scan)
732{
733 struct wpa_bss *bss, *n;
734
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800735 os_get_reltime(&wpa_s->last_scan);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700736 if (!new_scan)
737 return; /* do not expire entries without new scan */
738
739 dl_list_for_each_safe(bss, n, &wpa_s->bss, struct wpa_bss, list) {
740 if (wpa_bss_in_use(wpa_s, bss))
741 continue;
742 if (!wpa_bss_included_in_scan(bss, info))
743 continue; /* expire only BSSes that were scanned */
744 if (bss->last_update_idx < wpa_s->bss_update_idx)
745 bss->scan_miss_count++;
746 if (bss->scan_miss_count >=
747 wpa_s->conf->bss_expiration_scan_count) {
Dmitry Shmidt04949592012-07-19 12:16:46 -0700748 wpa_bss_remove(wpa_s, bss, "no match in scan");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700749 }
750 }
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700751
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800752 wpa_printf(MSG_DEBUG, "BSS: last_scan_res_used=%u/%u",
753 wpa_s->last_scan_res_used, wpa_s->last_scan_res_size);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700754}
755
756
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800757/**
758 * wpa_bss_flush_by_age - Flush old BSS entries
759 * @wpa_s: Pointer to wpa_supplicant data
760 * @age: Maximum entry age in seconds
761 *
762 * Remove BSS entries that have not been updated during the last @age seconds.
763 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700764void wpa_bss_flush_by_age(struct wpa_supplicant *wpa_s, int age)
765{
766 struct wpa_bss *bss, *n;
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800767 struct os_reltime t;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700768
769 if (dl_list_empty(&wpa_s->bss))
770 return;
771
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800772 os_get_reltime(&t);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700773 t.sec -= age;
774
775 dl_list_for_each_safe(bss, n, &wpa_s->bss, struct wpa_bss, list) {
776 if (wpa_bss_in_use(wpa_s, bss))
777 continue;
778
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800779 if (os_reltime_before(&bss->last_update, &t)) {
Dmitry Shmidt04949592012-07-19 12:16:46 -0700780 wpa_bss_remove(wpa_s, bss, __func__);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700781 } else
782 break;
783 }
784}
785
786
787static void wpa_bss_timeout(void *eloop_ctx, void *timeout_ctx)
788{
789 struct wpa_supplicant *wpa_s = eloop_ctx;
790
791 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
792 eloop_register_timeout(WPA_BSS_EXPIRATION_PERIOD, 0,
793 wpa_bss_timeout, wpa_s, NULL);
794}
795
796
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800797/**
798 * wpa_bss_init - Initialize BSS table
799 * @wpa_s: Pointer to wpa_supplicant data
800 * Returns: 0 on success, -1 on failure
801 *
802 * This prepares BSS table lists and timer for periodic updates. The BSS table
803 * is deinitialized with wpa_bss_deinit() once not needed anymore.
804 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700805int wpa_bss_init(struct wpa_supplicant *wpa_s)
806{
807 dl_list_init(&wpa_s->bss);
808 dl_list_init(&wpa_s->bss_id);
809 eloop_register_timeout(WPA_BSS_EXPIRATION_PERIOD, 0,
810 wpa_bss_timeout, wpa_s, NULL);
811 return 0;
812}
813
814
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800815/**
816 * wpa_bss_flush - Flush all unused BSS entries
817 * @wpa_s: Pointer to wpa_supplicant data
818 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700819void wpa_bss_flush(struct wpa_supplicant *wpa_s)
820{
821 struct wpa_bss *bss, *n;
822
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800823 wpa_s->clear_driver_scan_cache = 1;
824
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700825 if (wpa_s->bss.next == NULL)
826 return; /* BSS table not yet initialized */
827
828 dl_list_for_each_safe(bss, n, &wpa_s->bss, struct wpa_bss, list) {
829 if (wpa_bss_in_use(wpa_s, bss))
830 continue;
Dmitry Shmidt04949592012-07-19 12:16:46 -0700831 wpa_bss_remove(wpa_s, bss, __func__);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700832 }
833}
834
835
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800836/**
837 * wpa_bss_deinit - Deinitialize BSS table
838 * @wpa_s: Pointer to wpa_supplicant data
839 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700840void wpa_bss_deinit(struct wpa_supplicant *wpa_s)
841{
842 eloop_cancel_timeout(wpa_bss_timeout, wpa_s, NULL);
843 wpa_bss_flush(wpa_s);
844}
845
846
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800847/**
848 * wpa_bss_get_bssid - Fetch a BSS table entry based on BSSID
849 * @wpa_s: Pointer to wpa_supplicant data
850 * @bssid: BSSID
851 * Returns: Pointer to the BSS entry or %NULL if not found
852 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700853struct wpa_bss * wpa_bss_get_bssid(struct wpa_supplicant *wpa_s,
854 const u8 *bssid)
855{
856 struct wpa_bss *bss;
Dmitry Shmidt04949592012-07-19 12:16:46 -0700857 if (!wpa_supplicant_filter_bssid_match(wpa_s, bssid))
858 return NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700859 dl_list_for_each_reverse(bss, &wpa_s->bss, struct wpa_bss, list) {
860 if (os_memcmp(bss->bssid, bssid, ETH_ALEN) == 0)
861 return bss;
862 }
863 return NULL;
864}
865
866
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700867/**
868 * wpa_bss_get_bssid_latest - Fetch the latest BSS table entry based on BSSID
869 * @wpa_s: Pointer to wpa_supplicant data
870 * @bssid: BSSID
871 * Returns: Pointer to the BSS entry or %NULL if not found
872 *
873 * This function is like wpa_bss_get_bssid(), but full BSS table is iterated to
874 * find the entry that has the most recent update. This can help in finding the
875 * correct entry in cases where the SSID of the AP may have changed recently
876 * (e.g., in WPS reconfiguration cases).
877 */
878struct wpa_bss * wpa_bss_get_bssid_latest(struct wpa_supplicant *wpa_s,
879 const u8 *bssid)
880{
881 struct wpa_bss *bss, *found = NULL;
882 if (!wpa_supplicant_filter_bssid_match(wpa_s, bssid))
883 return NULL;
884 dl_list_for_each_reverse(bss, &wpa_s->bss, struct wpa_bss, list) {
885 if (os_memcmp(bss->bssid, bssid, ETH_ALEN) != 0)
886 continue;
887 if (found == NULL ||
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800888 os_reltime_before(&found->last_update, &bss->last_update))
Dmitry Shmidt444d5672013-04-01 13:08:44 -0700889 found = bss;
890 }
891 return found;
892}
893
894
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -0800895#ifdef CONFIG_P2P
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800896/**
897 * wpa_bss_get_p2p_dev_addr - Fetch a BSS table entry based on P2P Device Addr
898 * @wpa_s: Pointer to wpa_supplicant data
899 * @dev_addr: P2P Device Address of the GO
900 * Returns: Pointer to the BSS entry or %NULL if not found
901 */
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -0800902struct wpa_bss * wpa_bss_get_p2p_dev_addr(struct wpa_supplicant *wpa_s,
903 const u8 *dev_addr)
904{
905 struct wpa_bss *bss;
906 dl_list_for_each_reverse(bss, &wpa_s->bss, struct wpa_bss, list) {
907 u8 addr[ETH_ALEN];
908 if (p2p_parse_dev_addr((const u8 *) (bss + 1), bss->ie_len,
909 addr) == 0 &&
910 os_memcmp(addr, dev_addr, ETH_ALEN) == 0)
911 return bss;
912 }
913 return NULL;
914}
915#endif /* CONFIG_P2P */
916
917
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800918/**
919 * wpa_bss_get_id - Fetch a BSS table entry based on identifier
920 * @wpa_s: Pointer to wpa_supplicant data
921 * @id: Unique identifier (struct wpa_bss::id) assigned for the entry
922 * Returns: Pointer to the BSS entry or %NULL if not found
923 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700924struct wpa_bss * wpa_bss_get_id(struct wpa_supplicant *wpa_s, unsigned int id)
925{
926 struct wpa_bss *bss;
927 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
928 if (bss->id == id)
929 return bss;
930 }
931 return NULL;
932}
933
934
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800935/**
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800936 * wpa_bss_get_id_range - Fetch a BSS table entry based on identifier range
937 * @wpa_s: Pointer to wpa_supplicant data
938 * @idf: Smallest allowed identifier assigned for the entry
939 * @idf: Largest allowed identifier assigned for the entry
940 * Returns: Pointer to the BSS entry or %NULL if not found
941 *
942 * This function is similar to wpa_bss_get_id() but allows a BSS entry with the
943 * smallest id value to be fetched within the specified range without the
944 * caller having to know the exact id.
945 */
946struct wpa_bss * wpa_bss_get_id_range(struct wpa_supplicant *wpa_s,
947 unsigned int idf, unsigned int idl)
948{
949 struct wpa_bss *bss;
950 dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
951 if (bss->id >= idf && bss->id <= idl)
952 return bss;
953 }
954 return NULL;
955}
956
957
958/**
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800959 * wpa_bss_get_ie - Fetch a specified information element from a BSS entry
960 * @bss: BSS table entry
961 * @ie: Information element identitifier (WLAN_EID_*)
962 * Returns: Pointer to the information element (id field) or %NULL if not found
963 *
964 * This function returns the first matching information element in the BSS
965 * entry.
966 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700967const u8 * wpa_bss_get_ie(const struct wpa_bss *bss, u8 ie)
968{
969 const u8 *end, *pos;
970
971 pos = (const u8 *) (bss + 1);
972 end = pos + bss->ie_len;
973
974 while (pos + 1 < end) {
975 if (pos + 2 + pos[1] > end)
976 break;
977 if (pos[0] == ie)
978 return pos;
979 pos += 2 + pos[1];
980 }
981
982 return NULL;
983}
984
985
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800986/**
987 * wpa_bss_get_vendor_ie - Fetch a vendor information element from a BSS entry
988 * @bss: BSS table entry
989 * @vendor_type: Vendor type (four octets starting the IE payload)
990 * Returns: Pointer to the information element (id field) or %NULL if not found
991 *
992 * This function returns the first matching information element in the BSS
993 * entry.
994 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700995const u8 * wpa_bss_get_vendor_ie(const struct wpa_bss *bss, u32 vendor_type)
996{
997 const u8 *end, *pos;
998
999 pos = (const u8 *) (bss + 1);
1000 end = pos + bss->ie_len;
1001
1002 while (pos + 1 < end) {
1003 if (pos + 2 + pos[1] > end)
1004 break;
1005 if (pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
1006 vendor_type == WPA_GET_BE32(&pos[2]))
1007 return pos;
1008 pos += 2 + pos[1];
1009 }
1010
1011 return NULL;
1012}
1013
1014
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001015/**
Dmitry Shmidt96571392013-10-14 12:54:46 -07001016 * wpa_bss_get_vendor_ie_beacon - Fetch a vendor information from a BSS entry
1017 * @bss: BSS table entry
1018 * @vendor_type: Vendor type (four octets starting the IE payload)
1019 * Returns: Pointer to the information element (id field) or %NULL if not found
1020 *
1021 * This function returns the first matching information element in the BSS
1022 * entry.
1023 *
1024 * This function is like wpa_bss_get_vendor_ie(), but uses IE buffer only
1025 * from Beacon frames instead of either Beacon or Probe Response frames.
1026 */
1027const u8 * wpa_bss_get_vendor_ie_beacon(const struct wpa_bss *bss,
1028 u32 vendor_type)
1029{
1030 const u8 *end, *pos;
1031
1032 if (bss->beacon_ie_len == 0)
1033 return NULL;
1034
1035 pos = (const u8 *) (bss + 1);
1036 pos += bss->ie_len;
1037 end = pos + bss->beacon_ie_len;
1038
1039 while (pos + 1 < end) {
1040 if (pos + 2 + pos[1] > end)
1041 break;
1042 if (pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
1043 vendor_type == WPA_GET_BE32(&pos[2]))
1044 return pos;
1045 pos += 2 + pos[1];
1046 }
1047
1048 return NULL;
1049}
1050
1051
1052/**
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001053 * wpa_bss_get_vendor_ie_multi - Fetch vendor IE data from a BSS entry
1054 * @bss: BSS table entry
1055 * @vendor_type: Vendor type (four octets starting the IE payload)
1056 * Returns: Pointer to the information element payload or %NULL if not found
1057 *
1058 * This function returns concatenated payload of possibly fragmented vendor
1059 * specific information elements in the BSS entry. The caller is responsible for
1060 * freeing the returned buffer.
1061 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001062struct wpabuf * wpa_bss_get_vendor_ie_multi(const struct wpa_bss *bss,
1063 u32 vendor_type)
1064{
1065 struct wpabuf *buf;
1066 const u8 *end, *pos;
1067
1068 buf = wpabuf_alloc(bss->ie_len);
1069 if (buf == NULL)
1070 return NULL;
1071
1072 pos = (const u8 *) (bss + 1);
1073 end = pos + bss->ie_len;
1074
1075 while (pos + 1 < end) {
1076 if (pos + 2 + pos[1] > end)
1077 break;
1078 if (pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
1079 vendor_type == WPA_GET_BE32(&pos[2]))
1080 wpabuf_put_data(buf, pos + 2 + 4, pos[1] - 4);
1081 pos += 2 + pos[1];
1082 }
1083
1084 if (wpabuf_len(buf) == 0) {
1085 wpabuf_free(buf);
1086 buf = NULL;
1087 }
1088
1089 return buf;
1090}
1091
1092
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001093/**
1094 * wpa_bss_get_vendor_ie_multi_beacon - Fetch vendor IE data from a BSS entry
1095 * @bss: BSS table entry
1096 * @vendor_type: Vendor type (four octets starting the IE payload)
1097 * Returns: Pointer to the information element payload or %NULL if not found
1098 *
1099 * This function returns concatenated payload of possibly fragmented vendor
1100 * specific information elements in the BSS entry. The caller is responsible for
1101 * freeing the returned buffer.
1102 *
1103 * This function is like wpa_bss_get_vendor_ie_multi(), but uses IE buffer only
1104 * from Beacon frames instead of either Beacon or Probe Response frames.
1105 */
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -07001106struct wpabuf * wpa_bss_get_vendor_ie_multi_beacon(const struct wpa_bss *bss,
1107 u32 vendor_type)
1108{
1109 struct wpabuf *buf;
1110 const u8 *end, *pos;
1111
1112 buf = wpabuf_alloc(bss->beacon_ie_len);
1113 if (buf == NULL)
1114 return NULL;
1115
1116 pos = (const u8 *) (bss + 1);
1117 pos += bss->ie_len;
1118 end = pos + bss->beacon_ie_len;
1119
1120 while (pos + 1 < end) {
1121 if (pos + 2 + pos[1] > end)
1122 break;
1123 if (pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
1124 vendor_type == WPA_GET_BE32(&pos[2]))
1125 wpabuf_put_data(buf, pos + 2 + 4, pos[1] - 4);
1126 pos += 2 + pos[1];
1127 }
1128
1129 if (wpabuf_len(buf) == 0) {
1130 wpabuf_free(buf);
1131 buf = NULL;
1132 }
1133
1134 return buf;
1135}
1136
1137
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001138/**
1139 * wpa_bss_get_max_rate - Get maximum legacy TX rate supported in a BSS
1140 * @bss: BSS table entry
1141 * Returns: Maximum legacy rate in units of 500 kbps
1142 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001143int wpa_bss_get_max_rate(const struct wpa_bss *bss)
1144{
1145 int rate = 0;
1146 const u8 *ie;
1147 int i;
1148
1149 ie = wpa_bss_get_ie(bss, WLAN_EID_SUPP_RATES);
1150 for (i = 0; ie && i < ie[1]; i++) {
1151 if ((ie[i + 2] & 0x7f) > rate)
1152 rate = ie[i + 2] & 0x7f;
1153 }
1154
1155 ie = wpa_bss_get_ie(bss, WLAN_EID_EXT_SUPP_RATES);
1156 for (i = 0; ie && i < ie[1]; i++) {
1157 if ((ie[i + 2] & 0x7f) > rate)
1158 rate = ie[i + 2] & 0x7f;
1159 }
1160
1161 return rate;
1162}
1163
1164
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001165/**
1166 * wpa_bss_get_bit_rates - Get legacy TX rates supported in a BSS
1167 * @bss: BSS table entry
1168 * @rates: Buffer for returning a pointer to the rates list (units of 500 kbps)
1169 * Returns: number of legacy TX rates or -1 on failure
1170 *
1171 * The caller is responsible for freeing the returned buffer with os_free() in
1172 * case of success.
1173 */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001174int wpa_bss_get_bit_rates(const struct wpa_bss *bss, u8 **rates)
1175{
1176 const u8 *ie, *ie2;
1177 int i, j;
1178 unsigned int len;
1179 u8 *r;
1180
1181 ie = wpa_bss_get_ie(bss, WLAN_EID_SUPP_RATES);
1182 ie2 = wpa_bss_get_ie(bss, WLAN_EID_EXT_SUPP_RATES);
1183
1184 len = (ie ? ie[1] : 0) + (ie2 ? ie2[1] : 0);
1185
1186 r = os_malloc(len);
1187 if (!r)
1188 return -1;
1189
1190 for (i = 0; ie && i < ie[1]; i++)
1191 r[i] = ie[i + 2] & 0x7f;
1192
1193 for (j = 0; ie2 && j < ie2[1]; j++)
1194 r[i + j] = ie2[j + 2] & 0x7f;
1195
1196 *rates = r;
1197 return len;
1198}