wpa_supplicant/bgscan_learn.c

   1 /*
   2  * WPA Supplicant - background scan and roaming module: learn
   3  * Copyright (c) 2009-2010, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "eloop.h"
  19 #include "list.h"
  20 #include "common/ieee802_11_defs.h"
  21 #include "drivers/driver.h"
  22 #include "config_ssid.h"
  23 #include "wpa_supplicant_i.h"
  24 #include "driver_i.h"
  25 #include "scan.h"
  26 #include "bgscan.h"
  27
  28 struct bgscan_learn_bss {
  29         struct dl_list list;
  30         u8 bssid[ETH_ALEN];
  31         int freq;
  32 };
  33
  34 struct bgscan_learn_data {
  35         struct wpa_supplicant *wpa_s;
  36         const struct wpa_ssid *ssid;
  37         int scan_interval;
  38         int signal_threshold;
  39         int short_interval; /* use if signal < threshold */
  40         int long_interval; /* use if signal > threshold */
  41         struct os_time last_bgscan;
  42         char *fname;
  43         struct dl_list bss;
  44         int *supp_freqs;
  45         int probe_idx;
  46 };
  47
  48
  49 static struct bgscan_learn_bss * bgscan_learn_get_bss(
  50         struct bgscan_learn_data *data, const u8 *bssid)
  51 {
  52         struct bgscan_learn_bss *bss;
  53
  54         dl_list_for_each(bss, &data->bss, struct bgscan_learn_bss, list) {
  55                 if (os_memcmp(bss->bssid, bssid, ETH_ALEN) == 0)
  56                         return bss;
  57         }
  58         return NULL;
  59 }
  60
  61
  62 static int bgscan_learn_load(struct bgscan_learn_data *data)
  63 {
  64         FILE *f;
  65         char buf[128];
  66
  67         if (data->fname == NULL)
  68                 return 0;
  69
  70         f = fopen(data->fname, "r");
  71         if (f == NULL)
  72                 return 0;
  73
  74         wpa_printf(MSG_DEBUG, "bgscan learn: Loading data from %s",
  75                    data->fname);
  76
  77         if (fgets(buf, sizeof(buf), f) == NULL ||
  78             os_strncmp(buf, "wpa_supplicant-bgscan-learn\n", 28) != 0) {
  79                 wpa_printf(MSG_INFO, "bgscan learn: Invalid data file %s",
  80                            data->fname);
  81                 fclose(f);
  82                 return -1;
  83         }
  84
  85         while (fgets(buf, sizeof(buf), f)) {
  86                 if (os_strncmp(buf, "BSS ", 4) == 0) {
  87                         struct bgscan_learn_bss *bss;
  88                         bss = os_zalloc(sizeof(*bss));
  89                         if (!bss)
  90                                 continue;
  91                         if (hwaddr_aton(buf + 4, bss->bssid) < 0) {
  92                                 os_free(bss);
  93                                 continue;
  94                         }
  95                         bss->freq = atoi(buf + 4 + 18);
  96                         dl_list_add(&data->bss, &bss->list);
  97                         wpa_printf(MSG_DEBUG, "bgscan learn: Loaded BSS "
  98                                    "entry: " MACSTR " freq=%d",
  99                                    MAC2STR(bss->bssid), bss->freq);
 100                 }
 101         }
 102
 103         fclose(f);
 104         return 0;
 105 }
 106
 107
 108 static void bgscan_learn_save(struct bgscan_learn_data *data)
 109 {
 110         FILE *f;
 111         struct bgscan_learn_bss *bss;
 112
 113         if (data->fname == NULL)
 114                 return;
 115
 116         wpa_printf(MSG_DEBUG, "bgscan learn: Saving data to %s",
 117                    data->fname);
 118
 119         f = fopen(data->fname, "w");
 120         if (f == NULL)
 121                 return;
 122         fprintf(f, "wpa_supplicant-bgscan-learn\n");
 123
 124         dl_list_for_each(bss, &data->bss, struct bgscan_learn_bss, list) {
 125                 fprintf(f, "BSS " MACSTR " %d\n",
 126                         MAC2STR(bss->bssid), bss->freq);
 127         }
 128
 129         fclose(f);
 130 }
 131
 132
 133 static int in_array(int *array, int val)
 134 {
 135         int i;
 136
 137         if (array == NULL)
 138                 return 0;
 139
 140         for (i = 0; array[i]; i++) {
 141                 if (array[i] == val)
 142                         return 1;
 143         }
 144
 145         return 0;
 146 }
 147
 148
 149 static int * bgscan_learn_get_freqs(struct bgscan_learn_data *data,
 150                                     size_t *count)
 151 {
 152         struct bgscan_learn_bss *bss;
 153         int *freqs = NULL, *n;
 154
 155         *count = 0;
 156
 157         dl_list_for_each(bss, &data->bss, struct bgscan_learn_bss, list) {
 158                 if (in_array(freqs, bss->freq))
 159                         continue;
 160                 n = os_realloc(freqs, (*count + 2) * sizeof(int));
 161                 if (n == NULL)
 162                         return freqs;
 163                 freqs = n;
 164                 freqs[*count] = bss->freq;
 165                 (*count)++;
 166                 freqs[*count] = 0;
 167         }
 168
 169         return freqs;
 170 }
 171
 172
 173 static int * bgscan_learn_get_probe_freq(struct bgscan_learn_data *data,
 174                                          int *freqs, size_t count)
 175 {
 176         int idx, *n;
 177
 178         if (data->supp_freqs == NULL)
 179                 return freqs;
 180
 181         idx = data->probe_idx + 1;
 182         while (idx != data->probe_idx) {
 183                 if (data->supp_freqs[idx] == 0)
 184                         idx = 0;
 185                 if (!in_array(freqs, data->supp_freqs[idx])) {
 186                         wpa_printf(MSG_DEBUG, "bgscan learn: Probe new freq "
 187                                    "%u", data->supp_freqs[idx]);
 188                         data->probe_idx = idx;
 189                         n = os_realloc(freqs, (count + 2) * sizeof(int));
 190                         if (n == NULL)
 191                                 return freqs;
 192                         freqs = n;
 193                         freqs[count] = data->supp_freqs[idx];
 194                         count++;
 195                         freqs[count] = 0;
 196                         break;
 197                 }
 198
 199                 idx++;
 200         }
 201
 202         return freqs;
 203 }
 204
 205
 206 static void bgscan_learn_timeout(void *eloop_ctx, void *timeout_ctx)
 207 {
 208         struct bgscan_learn_data *data = eloop_ctx;
 209         struct wpa_supplicant *wpa_s = data->wpa_s;
 210         struct wpa_driver_scan_params params;
 211         int *freqs = NULL;
 212         size_t count, i;
 213         char msg[100], *pos;
 214
 215         os_memset(&params, 0, sizeof(params));
 216         params.num_ssids = 1;
 217         params.ssids[0].ssid = data->ssid->ssid;
 218         params.ssids[0].ssid_len = data->ssid->ssid_len;
 219         if (data->ssid->scan_freq)
 220                 params.freqs = data->ssid->scan_freq;
 221         else {
 222                 freqs = bgscan_learn_get_freqs(data, &count);
 223                 wpa_printf(MSG_DEBUG, "bgscan learn: BSSes in this ESS have "
 224                            "been seen on %u channels", (unsigned int) count);
 225                 freqs = bgscan_learn_get_probe_freq(data, freqs, count);
 226
 227                 msg[0] = '\0';
 228                 pos = msg;
 229                 for (i = 0; freqs && freqs[i]; i++) {
 230                         int ret;
 231                         ret = os_snprintf(pos, msg + sizeof(msg) - pos, " %d",
 232                                           freqs[i]);
 233                         if (ret < 0 || ret >= msg + sizeof(msg) - pos)
 234                                 break;
 235                         pos += ret;
 236                 }
 237                 pos[0] = '\0';
 238                 wpa_printf(MSG_DEBUG, "bgscan learn: Scanning frequencies:%s",
 239                            msg);
 240                 params.freqs = freqs;
 241         }
 242
 243         wpa_printf(MSG_DEBUG, "bgscan learn: Request a background scan");
 244         if (wpa_supplicant_trigger_scan(wpa_s, &params)) {
 245                 wpa_printf(MSG_DEBUG, "bgscan learn: Failed to trigger scan");
 246                 eloop_register_timeout(data->scan_interval, 0,
 247                                        bgscan_learn_timeout, data, NULL);
 248         } else
 249                 os_get_time(&data->last_bgscan);
 250         os_free(freqs);
 251 }
 252
 253
 254 static int bgscan_learn_get_params(struct bgscan_learn_data *data,
 255                                    const char *params)
 256 {
 257         const char *pos;
 258
 259         if (params == NULL)
 260                 return 0;
 261
 262         data->short_interval = atoi(params);
 263
 264         pos = os_strchr(params, ':');
 265         if (pos == NULL)
 266                 return 0;
 267         pos++;
 268         data->signal_threshold = atoi(pos);
 269         pos = os_strchr(pos, ':');
 270         if (pos == NULL) {
 271                 wpa_printf(MSG_ERROR, "bgscan learn: Missing scan interval "
 272                            "for high signal");
 273                 return -1;
 274         }
 275         pos++;
 276         data->long_interval = atoi(pos);
 277         pos = os_strchr(pos, ':');
 278         if (pos) {
 279                 pos++;
 280                 data->fname = os_strdup(pos);
 281         }
 282
 283         return 0;
 284 }
 285
 286
 287 static int * bgscan_learn_get_supp_freqs(struct wpa_supplicant *wpa_s)
 288 {
 289         struct hostapd_hw_modes *modes;
 290         u16 num_modes, flags;
 291         int i, j, *freqs = NULL, *n;
 292         size_t count = 0;
 293
 294         modes = wpa_drv_get_hw_feature_data(wpa_s, &num_modes, &flags);
 295         if (!modes)
 296                 return NULL;
 297
 298         for (i = 0; i < num_modes; i++) {
 299                 for (j = 0; j < modes[i].num_channels; j++) {
 300                         if (modes[i].channels[j].flag & HOSTAPD_CHAN_DISABLED)
 301                                 continue;
 302                         n = os_realloc(freqs, (count + 2) * sizeof(int));
 303                         if (!n)
 304                                 continue;
 305
 306                         freqs = n;
 307                         freqs[count] = modes[i].channels[j].freq;
 308                         count++;
 309                         freqs[count] = 0;
 310                 }
 311                 os_free(modes[i].channels);
 312                 os_free(modes[i].rates);
 313         }
 314         os_free(modes);
 315
 316         return freqs;
 317 }
 318
 319
 320 static void * bgscan_learn_init(struct wpa_supplicant *wpa_s,
 321                                 const char *params,
 322                                 const struct wpa_ssid *ssid)
 323 {
 324         struct bgscan_learn_data *data;
 325
 326         data = os_zalloc(sizeof(*data));
 327         if (data == NULL)
 328                 return NULL;
 329         dl_list_init(&data->bss);
 330         data->wpa_s = wpa_s;
 331         data->ssid = ssid;
 332         if (bgscan_learn_get_params(data, params) < 0) {
 333                 os_free(data->fname);
 334                 os_free(data);
 335                 return NULL;
 336         }
 337         if (data->short_interval <= 0)
 338                 data->short_interval = 30;
 339         if (data->long_interval <= 0)
 340                 data->long_interval = 30;
 341
 342         if (bgscan_learn_load(data) < 0) {
 343                 os_free(data->fname);
 344                 os_free(data);
 345                 return NULL;
 346         }
 347
 348         wpa_printf(MSG_DEBUG, "bgscan learn: Signal strength threshold %d  "
 349                    "Short bgscan interval %d  Long bgscan interval %d",
 350                    data->signal_threshold, data->short_interval,
 351                    data->long_interval);
 352
 353         if (data->signal_threshold &&
 354             wpa_drv_signal_monitor(wpa_s, data->signal_threshold, 4) < 0) {
 355                 wpa_printf(MSG_ERROR, "bgscan learn: Failed to enable "
 356                            "signal strength monitoring");
 357         }
 358
 359         data->supp_freqs = bgscan_learn_get_supp_freqs(wpa_s);
 360         data->scan_interval = data->short_interval;
 361         eloop_register_timeout(data->scan_interval, 0, bgscan_learn_timeout,
 362                                data, NULL);
 363         return data;
 364 }
 365
 366
 367 static void bgscan_learn_deinit(void *priv)
 368 {
 369         struct bgscan_learn_data *data = priv;
 370         struct bgscan_learn_bss *bss, *n;
 371
 372         bgscan_learn_save(data);
 373         eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 374         if (data->signal_threshold)
 375                 wpa_drv_signal_monitor(data->wpa_s, 0, 0);
 376         os_free(data->fname);
 377         dl_list_for_each_safe(bss, n, &data->bss, struct bgscan_learn_bss,
 378                               list) {
 379                 dl_list_del(&bss->list);
 380                 os_free(bss);
 381         }
 382         os_free(data->supp_freqs);
 383         os_free(data);
 384 }
 385
 386
 387 static int bgscan_learn_bss_match(struct bgscan_learn_data *data,
 388                                   struct wpa_scan_res *bss)
 389 {
 390         const u8 *ie;
 391
 392         ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
 393         if (ie == NULL)
 394                 return 0;
 395
 396         if (data->ssid->ssid_len != ie[1] ||
 397             os_memcmp(data->ssid->ssid, ie + 2, ie[1]) != 0)
 398                 return 0; /* SSID mismatch */
 399
 400         return 1;
 401 }
 402
 403
 404 static int bgscan_learn_notify_scan(void *priv,
 405                                     struct wpa_scan_results *scan_res)
 406 {
 407         struct bgscan_learn_data *data = priv;
 408         size_t i;
 409
 410         wpa_printf(MSG_DEBUG, "bgscan learn: scan result notification");
 411
 412         eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 413         eloop_register_timeout(data->scan_interval, 0, bgscan_learn_timeout,
 414                                data, NULL);
 415
 416         for (i = 0; i < scan_res->num; i++) {
 417                 struct wpa_scan_res *res = scan_res->res[i];
 418                 struct bgscan_learn_bss *bss;
 419
 420                 if (!bgscan_learn_bss_match(data, res))
 421                         continue;
 422                 bss = bgscan_learn_get_bss(data, res->bssid);
 423                 if (bss && bss->freq != res->freq) {
 424                         wpa_printf(MSG_DEBUG, "bgscan learn: Update BSS "
 425                            MACSTR " freq %d -> %d",
 426                                    MAC2STR(res->bssid), bss->freq, res->freq);
 427                         bss->freq = res->freq;
 428                 } else if (!bss) {
 429                         wpa_printf(MSG_DEBUG, "bgscan learn: Add BSS " MACSTR
 430                                    " freq=%d", MAC2STR(res->bssid), res->freq);
 431                         bss = os_zalloc(sizeof(*bss));
 432                         if (!bss)
 433                                 continue;
 434                         os_memcpy(bss->bssid, res->bssid, ETH_ALEN);
 435                         bss->freq = res->freq;
 436                         dl_list_add(&data->bss, &bss->list);
 437                 }
 438         }
 439
 440         /*
 441          * A more advanced bgscan could process scan results internally, select
 442          * the BSS and request roam if needed. This sample uses the existing
 443          * BSS/ESS selection routine. Change this to return 1 if selection is
 444          * done inside the bgscan module.
 445          */
 446
 447         return 0;
 448 }
 449
 450
 451 static void bgscan_learn_notify_beacon_loss(void *priv)
 452 {
 453         wpa_printf(MSG_DEBUG, "bgscan learn: beacon loss");
 454         /* TODO: speed up background scanning */
 455 }
 456
 457
 458 static void bgscan_learn_notify_signal_change(void *priv, int above)
 459 {
 460         struct bgscan_learn_data *data = priv;
 461
 462         if (data->short_interval == data->long_interval ||
 463             data->signal_threshold == 0)
 464                 return;
 465
 466         wpa_printf(MSG_DEBUG, "bgscan learn: signal level changed "
 467                    "(above=%d)", above);
 468         if (data->scan_interval == data->long_interval && !above) {
 469                 wpa_printf(MSG_DEBUG, "bgscan learn: Trigger immediate scan "
 470                            "and start using short bgscan interval");
 471                 data->scan_interval = data->short_interval;
 472                 eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 473                 eloop_register_timeout(0, 0, bgscan_learn_timeout, data,
 474                                        NULL);
 475         } else if (data->scan_interval == data->short_interval && above) {
 476                 wpa_printf(MSG_DEBUG, "bgscan learn: Start using long bgscan "
 477                            "interval");
 478                 data->scan_interval = data->long_interval;
 479                 eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 480                 eloop_register_timeout(data->scan_interval, 0,
 481                                        bgscan_learn_timeout, data, NULL);
 482         } else if (!above) {
 483                 struct os_time now;
 484                 /*
 485                  * Signal dropped further 4 dB. Request a new scan if we have
 486                  * not yet scanned in a while.
 487                  */
 488                 os_get_time(&now);
 489                 if (now.sec > data->last_bgscan.sec + 10) {
 490                         wpa_printf(MSG_DEBUG, "bgscan learn: Trigger "
 491                                    "immediate scan");
 492                         eloop_cancel_timeout(bgscan_learn_timeout, data,
 493                                              NULL);
 494                         eloop_register_timeout(0, 0, bgscan_learn_timeout,
 495                                                data, NULL);
 496                 }
 497         }
 498 }
 499
 500
 501 const struct bgscan_ops bgscan_learn_ops = {
 502         .name = "learn",
 503         .init = bgscan_learn_init,
 504         .deinit = bgscan_learn_deinit,
 505         .notify_scan = bgscan_learn_notify_scan,
 506         .notify_beacon_loss = bgscan_learn_notify_beacon_loss,
 507         .notify_signal_change = bgscan_learn_notify_signal_change,
 508 };