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 };
  45
  46
  47 static struct bgscan_learn_bss * bgscan_learn_get_bss(
  48         struct bgscan_learn_data *data, const u8 *bssid)
  49 {
  50         struct bgscan_learn_bss *bss;
  51
  52         dl_list_for_each(bss, &data->bss, struct bgscan_learn_bss, list) {
  53                 if (os_memcmp(bss->bssid, bssid, ETH_ALEN) == 0)
  54                         return bss;
  55         }
  56         return NULL;
  57 }
  58
  59
  60 static int bgscan_learn_load(struct bgscan_learn_data *data)
  61 {
  62         FILE *f;
  63         char buf[128];
  64
  65         if (data->fname == NULL)
  66                 return 0;
  67
  68         f = fopen(data->fname, "r");
  69         if (f == NULL)
  70                 return 0;
  71
  72         wpa_printf(MSG_DEBUG, "bgscan learn: Loading data from %s",
  73                    data->fname);
  74
  75         if (fgets(buf, sizeof(buf), f) == NULL ||
  76             os_strncmp(buf, "wpa_supplicant-bgscan-learn\n", 28) != 0) {
  77                 wpa_printf(MSG_INFO, "bgscan learn: Invalid data file %s",
  78                            data->fname);
  79                 fclose(f);
  80                 return -1;
  81         }
  82
  83         while (fgets(buf, sizeof(buf), f)) {
  84                 if (os_strncmp(buf, "BSS ", 4) == 0) {
  85                         struct bgscan_learn_bss *bss;
  86                         bss = os_zalloc(sizeof(*bss));
  87                         if (!bss)
  88                                 continue;
  89                         if (hwaddr_aton(buf + 4, bss->bssid) < 0) {
  90                                 os_free(bss);
  91                                 continue;
  92                         }
  93                         bss->freq = atoi(buf + 4 + 18);
  94                         dl_list_add(&data->bss, &bss->list);
  95                         wpa_printf(MSG_DEBUG, "bgscan learn: Loaded BSS "
  96                                    "entry: " MACSTR " freq=%d",
  97                                    MAC2STR(bss->bssid), bss->freq);
  98                 }
  99         }
 100
 101         fclose(f);
 102         return 0;
 103 }
 104
 105
 106 static void bgscan_learn_save(struct bgscan_learn_data *data)
 107 {
 108         FILE *f;
 109         struct bgscan_learn_bss *bss;
 110
 111         if (data->fname == NULL)
 112                 return;
 113
 114         wpa_printf(MSG_DEBUG, "bgscan learn: Saving data to %s",
 115                    data->fname);
 116
 117         f = fopen(data->fname, "w");
 118         if (f == NULL)
 119                 return;
 120         fprintf(f, "wpa_supplicant-bgscan-learn\n");
 121
 122         dl_list_for_each(bss, &data->bss, struct bgscan_learn_bss, list) {
 123                 fprintf(f, "BSS " MACSTR " %d\n",
 124                         MAC2STR(bss->bssid), bss->freq);
 125         }
 126
 127         fclose(f);
 128 }
 129
 130
 131 static int in_array(int *array, int val)
 132 {
 133         int i;
 134
 135         if (array == NULL)
 136                 return 0;
 137
 138         for (i = 0; array[i]; i++) {
 139                 if (array[i] == val)
 140                         return 1;
 141         }
 142
 143         return 0;
 144 }
 145
 146
 147 static int * bgscan_learn_get_freqs(struct bgscan_learn_data *data,
 148                                     size_t *count)
 149 {
 150         struct bgscan_learn_bss *bss;
 151         int *freqs = NULL, *n;
 152
 153         *count = 0;
 154
 155         dl_list_for_each(bss, &data->bss, struct bgscan_learn_bss, list) {
 156                 if (in_array(freqs, bss->freq))
 157                         continue;
 158                 n = os_realloc(freqs, (*count + 2) * sizeof(int));
 159                 if (n == NULL)
 160                         return freqs;
 161                 freqs = n;
 162                 freqs[*count] = bss->freq;
 163                 (*count)++;
 164                 freqs[*count] = 0;
 165         }
 166
 167         return freqs;
 168 }
 169
 170
 171 static void bgscan_learn_timeout(void *eloop_ctx, void *timeout_ctx)
 172 {
 173         struct bgscan_learn_data *data = eloop_ctx;
 174         struct wpa_supplicant *wpa_s = data->wpa_s;
 175         struct wpa_driver_scan_params params;
 176         int *freqs = NULL;
 177         size_t count;
 178
 179         os_memset(&params, 0, sizeof(params));
 180         params.num_ssids = 1;
 181         params.ssids[0].ssid = data->ssid->ssid;
 182         params.ssids[0].ssid_len = data->ssid->ssid_len;
 183         if (data->ssid->scan_freq)
 184                 params.freqs = data->ssid->scan_freq;
 185         else {
 186                 freqs = bgscan_learn_get_freqs(data, &count);
 187                 wpa_printf(MSG_DEBUG, "bgscan learn: BSSes in this ESS have "
 188                            "been seen on %u channels", (unsigned int) count);
 189                 /*
 190                  * TODO: add other frequencies (rotate through one or couple at
 191                  * a time, etc., to find APs from new channels)
 192                  */
 193                 params.freqs = freqs;
 194         }
 195
 196         wpa_printf(MSG_DEBUG, "bgscan learn: Request a background scan");
 197         if (wpa_supplicant_trigger_scan(wpa_s, &params)) {
 198                 wpa_printf(MSG_DEBUG, "bgscan learn: Failed to trigger scan");
 199                 eloop_register_timeout(data->scan_interval, 0,
 200                                        bgscan_learn_timeout, data, NULL);
 201         } else
 202                 os_get_time(&data->last_bgscan);
 203         os_free(freqs);
 204 }
 205
 206
 207 static int bgscan_learn_get_params(struct bgscan_learn_data *data,
 208                                    const char *params)
 209 {
 210         const char *pos;
 211
 212         if (params == NULL)
 213                 return 0;
 214
 215         data->short_interval = atoi(params);
 216
 217         pos = os_strchr(params, ':');
 218         if (pos == NULL)
 219                 return 0;
 220         pos++;
 221         data->signal_threshold = atoi(pos);
 222         pos = os_strchr(pos, ':');
 223         if (pos == NULL) {
 224                 wpa_printf(MSG_ERROR, "bgscan learn: Missing scan interval "
 225                            "for high signal");
 226                 return -1;
 227         }
 228         pos++;
 229         data->long_interval = atoi(pos);
 230         pos = os_strchr(pos, ':');
 231         if (pos) {
 232                 pos++;
 233                 data->fname = os_strdup(pos);
 234         }
 235
 236         return 0;
 237 }
 238
 239
 240 static void * bgscan_learn_init(struct wpa_supplicant *wpa_s,
 241                                 const char *params,
 242                                 const struct wpa_ssid *ssid)
 243 {
 244         struct bgscan_learn_data *data;
 245
 246         data = os_zalloc(sizeof(*data));
 247         if (data == NULL)
 248                 return NULL;
 249         dl_list_init(&data->bss);
 250         data->wpa_s = wpa_s;
 251         data->ssid = ssid;
 252         if (bgscan_learn_get_params(data, params) < 0) {
 253                 os_free(data->fname);
 254                 os_free(data);
 255                 return NULL;
 256         }
 257         if (data->short_interval <= 0)
 258                 data->short_interval = 30;
 259         if (data->long_interval <= 0)
 260                 data->long_interval = 30;
 261
 262         if (bgscan_learn_load(data) < 0) {
 263                 os_free(data->fname);
 264                 os_free(data);
 265                 return NULL;
 266         }
 267
 268         wpa_printf(MSG_DEBUG, "bgscan learn: Signal strength threshold %d  "
 269                    "Short bgscan interval %d  Long bgscan interval %d",
 270                    data->signal_threshold, data->short_interval,
 271                    data->long_interval);
 272
 273         if (data->signal_threshold &&
 274             wpa_drv_signal_monitor(wpa_s, data->signal_threshold, 4) < 0) {
 275                 wpa_printf(MSG_ERROR, "bgscan learn: Failed to enable "
 276                            "signal strength monitoring");
 277         }
 278
 279         data->scan_interval = data->short_interval;
 280         eloop_register_timeout(data->scan_interval, 0, bgscan_learn_timeout,
 281                                data, NULL);
 282         return data;
 283 }
 284
 285
 286 static void bgscan_learn_deinit(void *priv)
 287 {
 288         struct bgscan_learn_data *data = priv;
 289         struct bgscan_learn_bss *bss, *n;
 290
 291         bgscan_learn_save(data);
 292         eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 293         if (data->signal_threshold)
 294                 wpa_drv_signal_monitor(data->wpa_s, 0, 0);
 295         os_free(data->fname);
 296         dl_list_for_each_safe(bss, n, &data->bss, struct bgscan_learn_bss,
 297                               list) {
 298                 dl_list_del(&bss->list);
 299                 os_free(bss);
 300         }
 301         os_free(data);
 302 }
 303
 304
 305 static int bgscan_learn_bss_match(struct bgscan_learn_data *data,
 306                                   struct wpa_scan_res *bss)
 307 {
 308         const u8 *ie;
 309
 310         ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
 311         if (ie == NULL)
 312                 return 0;
 313
 314         if (data->ssid->ssid_len != ie[1] ||
 315             os_memcmp(data->ssid->ssid, ie + 2, ie[1]) != 0)
 316                 return 0; /* SSID mismatch */
 317
 318         return 1;
 319 }
 320
 321
 322 static int bgscan_learn_notify_scan(void *priv,
 323                                     struct wpa_scan_results *scan_res)
 324 {
 325         struct bgscan_learn_data *data = priv;
 326         size_t i;
 327
 328         wpa_printf(MSG_DEBUG, "bgscan learn: scan result notification");
 329
 330         eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 331         eloop_register_timeout(data->scan_interval, 0, bgscan_learn_timeout,
 332                                data, NULL);
 333
 334         for (i = 0; i < scan_res->num; i++) {
 335                 struct wpa_scan_res *res = scan_res->res[i];
 336                 struct bgscan_learn_bss *bss;
 337
 338                 if (!bgscan_learn_bss_match(data, res))
 339                         continue;
 340                 bss = bgscan_learn_get_bss(data, res->bssid);
 341                 if (bss && bss->freq != res->freq) {
 342                         wpa_printf(MSG_DEBUG, "bgscan learn: Update BSS "
 343                            MACSTR " freq %d -> %d",
 344                                    MAC2STR(res->bssid), bss->freq, res->freq);
 345                         bss->freq = res->freq;
 346                 } else if (!bss) {
 347                         wpa_printf(MSG_DEBUG, "bgscan learn: Add BSS " MACSTR
 348                                    " freq=%d", MAC2STR(res->bssid), res->freq);
 349                         bss = os_zalloc(sizeof(*bss));
 350                         if (!bss)
 351                                 continue;
 352                         os_memcpy(bss->bssid, res->bssid, ETH_ALEN);
 353                         bss->freq = res->freq;
 354                         dl_list_add(&data->bss, &bss->list);
 355                 }
 356         }
 357
 358         /*
 359          * A more advanced bgscan could process scan results internally, select
 360          * the BSS and request roam if needed. This sample uses the existing
 361          * BSS/ESS selection routine. Change this to return 1 if selection is
 362          * done inside the bgscan module.
 363          */
 364
 365         return 0;
 366 }
 367
 368
 369 static void bgscan_learn_notify_beacon_loss(void *priv)
 370 {
 371         wpa_printf(MSG_DEBUG, "bgscan learn: beacon loss");
 372         /* TODO: speed up background scanning */
 373 }
 374
 375
 376 static void bgscan_learn_notify_signal_change(void *priv, int above)
 377 {
 378         struct bgscan_learn_data *data = priv;
 379
 380         if (data->short_interval == data->long_interval ||
 381             data->signal_threshold == 0)
 382                 return;
 383
 384         wpa_printf(MSG_DEBUG, "bgscan learn: signal level changed "
 385                    "(above=%d)", above);
 386         if (data->scan_interval == data->long_interval && !above) {
 387                 wpa_printf(MSG_DEBUG, "bgscan learn: Trigger immediate scan "
 388                            "and start using short bgscan interval");
 389                 data->scan_interval = data->short_interval;
 390                 eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 391                 eloop_register_timeout(0, 0, bgscan_learn_timeout, data,
 392                                        NULL);
 393         } else if (data->scan_interval == data->short_interval && above) {
 394                 wpa_printf(MSG_DEBUG, "bgscan learn: Start using long bgscan "
 395                            "interval");
 396                 data->scan_interval = data->long_interval;
 397                 eloop_cancel_timeout(bgscan_learn_timeout, data, NULL);
 398                 eloop_register_timeout(data->scan_interval, 0,
 399                                        bgscan_learn_timeout, data, NULL);
 400         } else if (!above) {
 401                 struct os_time now;
 402                 /*
 403                  * Signal dropped further 4 dB. Request a new scan if we have
 404                  * not yet scanned in a while.
 405                  */
 406                 os_get_time(&now);
 407                 if (now.sec > data->last_bgscan.sec + 10) {
 408                         wpa_printf(MSG_DEBUG, "bgscan learn: Trigger "
 409                                    "immediate scan");
 410                         eloop_cancel_timeout(bgscan_learn_timeout, data,
 411                                              NULL);
 412                         eloop_register_timeout(0, 0, bgscan_learn_timeout,
 413                                                data, NULL);
 414                 }
 415         }
 416 }
 417
 418
 419 const struct bgscan_ops bgscan_learn_ops = {
 420         .name = "learn",
 421         .init = bgscan_learn_init,
 422         .deinit = bgscan_learn_deinit,
 423         .notify_scan = bgscan_learn_notify_scan,
 424         .notify_beacon_loss = bgscan_learn_notify_beacon_loss,
 425         .notify_signal_change = bgscan_learn_notify_signal_change,
 426 };