wpa_supplicant/bgscan_simple.c

   1 /*
   2  * WPA Supplicant - background scan and roaming module: simple
   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 "drivers/driver.h"
  20 #include "config_ssid.h"
  21 #include "wpa_supplicant_i.h"
  22 #include "driver_i.h"
  23 #include "scan.h"
  24 #include "bgscan.h"
  25
  26 struct bgscan_simple_data {
  27         struct wpa_supplicant *wpa_s;
  28         const struct wpa_ssid *ssid;
  29         int scan_interval;
  30         int signal_threshold;
  31         int short_scan_count; /* counter for scans using short scan interval */
  32         int short_interval; /* use if signal < threshold */
  33         int long_interval; /* use if signal > threshold */
  34         struct os_time last_bgscan;
  35 };
  36
  37
  38 static void bgscan_simple_timeout(void *eloop_ctx, void *timeout_ctx)
  39 {
  40         struct bgscan_simple_data *data = eloop_ctx;
  41         struct wpa_supplicant *wpa_s = data->wpa_s;
  42         struct wpa_driver_scan_params params;
  43
  44         os_memset(&params, 0, sizeof(params));
  45         params.num_ssids = 1;
  46         params.ssids[0].ssid = data->ssid->ssid;
  47         params.ssids[0].ssid_len = data->ssid->ssid_len;
  48         params.freqs = data->ssid->scan_freq;
  49
  50         /*
  51          * A more advanced bgscan module would learn about most like channels
  52          * over time and request scans only for some channels (probing others
  53          * every now and then) to reduce effect on the data connection.
  54          */
  55
  56         wpa_printf(MSG_DEBUG, "bgscan simple: Request a background scan");
  57         if (wpa_supplicant_trigger_scan(wpa_s, &params)) {
  58                 wpa_printf(MSG_DEBUG, "bgscan simple: Failed to trigger scan");
  59                 eloop_register_timeout(data->scan_interval, 0,
  60                                        bgscan_simple_timeout, data, NULL);
  61         } else {
  62                 if (data->scan_interval == data->short_interval) {
  63                         data->short_scan_count++;
  64                         /*
  65                          * Spend at most the duration of a long scan interval
  66                          * scanning at the short scan interval. After that,
  67                          * revert to the long scan interval.
  68                          */
  69                         if (data->short_scan_count >
  70                             data->long_interval / data->short_interval + 1) {
  71                                 data->scan_interval = data->long_interval;
  72                                 wpa_printf(MSG_DEBUG, "bgscan simple: Backing "
  73                                            "off to long scan interval");
  74                         }
  75                 }
  76                 os_get_time(&data->last_bgscan);
  77         }
  78 }
  79
  80
  81 static int bgscan_simple_get_params(struct bgscan_simple_data *data,
  82                                     const char *params)
  83 {
  84         const char *pos;
  85
  86         if (params == NULL)
  87                 return 0;
  88
  89         data->short_interval = atoi(params);
  90
  91         pos = os_strchr(params, ':');
  92         if (pos == NULL)
  93                 return 0;
  94         pos++;
  95         data->signal_threshold = atoi(pos);
  96         pos = os_strchr(pos, ':');
  97         if (pos == NULL) {
  98                 wpa_printf(MSG_ERROR, "bgscan simple: Missing scan interval "
  99                            "for high signal");
 100                 return -1;
 101         }
 102         pos++;
 103         data->long_interval = atoi(pos);
 104
 105         return 0;
 106 }
 107
 108
 109 static void * bgscan_simple_init(struct wpa_supplicant *wpa_s,
 110                                  const char *params,
 111                                  const struct wpa_ssid *ssid)
 112 {
 113         struct bgscan_simple_data *data;
 114
 115         data = os_zalloc(sizeof(*data));
 116         if (data == NULL)
 117                 return NULL;
 118         data->wpa_s = wpa_s;
 119         data->ssid = ssid;
 120         if (bgscan_simple_get_params(data, params) < 0) {
 121                 os_free(data);
 122                 return NULL;
 123         }
 124         if (data->short_interval <= 0)
 125                 data->short_interval = 30;
 126         if (data->long_interval <= 0)
 127                 data->long_interval = 30;
 128
 129         wpa_printf(MSG_DEBUG, "bgscan simple: Signal strength threshold %d  "
 130                    "Short bgscan interval %d  Long bgscan interval %d",
 131                    data->signal_threshold, data->short_interval,
 132                    data->long_interval);
 133
 134         if (data->signal_threshold &&
 135             wpa_drv_signal_monitor(wpa_s, data->signal_threshold, 4) < 0) {
 136                 wpa_printf(MSG_ERROR, "bgscan simple: Failed to enable "
 137                            "signal strength monitoring");
 138         }
 139
 140         data->scan_interval = data->short_interval;
 141         if (data->signal_threshold) {
 142                 /* Poll for signal info to set initial scan interval */
 143                 struct wpa_signal_info siginfo;
 144                 if (wpa_drv_signal_poll(wpa_s, &siginfo) == 0 &&
 145                     siginfo.current_signal >= data->signal_threshold)
 146                         data->scan_interval = data->long_interval;
 147         }
 148         wpa_printf(MSG_DEBUG, "bgscan simple: Init scan interval: %d",
 149                    data->scan_interval);
 150         eloop_register_timeout(data->scan_interval, 0, bgscan_simple_timeout,
 151                                data, NULL);
 152
 153         /*
 154          * This function is called immediately after an association, so it is
 155          * reasonable to assume that a scan was completed recently. This makes
 156          * us skip an immediate new scan in cases where the current signal
 157          * level is below the bgscan threshold.
 158          */
 159         os_get_time(&data->last_bgscan);
 160
 161         return data;
 162 }
 163
 164
 165 static void bgscan_simple_deinit(void *priv)
 166 {
 167         struct bgscan_simple_data *data = priv;
 168         eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
 169         if (data->signal_threshold)
 170                 wpa_drv_signal_monitor(data->wpa_s, 0, 0);
 171         os_free(data);
 172 }
 173
 174
 175 static int bgscan_simple_notify_scan(void *priv,
 176                                      struct wpa_scan_results *scan_res)
 177 {
 178         struct bgscan_simple_data *data = priv;
 179
 180         wpa_printf(MSG_DEBUG, "bgscan simple: scan result notification");
 181
 182         eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
 183         eloop_register_timeout(data->scan_interval, 0, bgscan_simple_timeout,
 184                                data, NULL);
 185
 186         /*
 187          * A more advanced bgscan could process scan results internally, select
 188          * the BSS and request roam if needed. This sample uses the existing
 189          * BSS/ESS selection routine. Change this to return 1 if selection is
 190          * done inside the bgscan module.
 191          */
 192
 193         return 0;
 194 }
 195
 196
 197 static void bgscan_simple_notify_beacon_loss(void *priv)
 198 {
 199         wpa_printf(MSG_DEBUG, "bgscan simple: beacon loss");
 200         /* TODO: speed up background scanning */
 201 }
 202
 203
 204 static void bgscan_simple_notify_signal_change(void *priv, int above,
 205                                                int current_signal,
 206                                                int current_noise,
 207                                                int current_txrate)
 208 {
 209         struct bgscan_simple_data *data = priv;
 210         int scan = 0;
 211         struct os_time now;
 212
 213         if (data->short_interval == data->long_interval ||
 214             data->signal_threshold == 0)
 215                 return;
 216
 217         wpa_printf(MSG_DEBUG, "bgscan simple: signal level changed "
 218                    "(above=%d current_signal=%d current_noise=%d "
 219                    "current_txrate=%d))", above, current_signal,
 220                    current_noise, current_txrate);
 221         if (data->scan_interval == data->long_interval && !above) {
 222                 wpa_printf(MSG_DEBUG, "bgscan simple: Start using short "
 223                            "bgscan interval");
 224                 data->scan_interval = data->short_interval;
 225                 data->short_scan_count = 0;
 226                 os_get_time(&now);
 227                 if (now.sec > data->last_bgscan.sec + 1)
 228                         scan = 1;
 229                 else if (data->last_bgscan.sec + data->long_interval >
 230                          now.sec + data->scan_interval) {
 231                         /*
 232                          * Restart scan interval timer if currently scheduled
 233                          * scan is too far in the future.
 234                          */
 235                         eloop_cancel_timeout(bgscan_simple_timeout, data,
 236                                              NULL);
 237                         eloop_register_timeout(data->scan_interval, 0,
 238                                                bgscan_simple_timeout, data,
 239                                                NULL);
 240                 }
 241         } else if (data->scan_interval == data->short_interval && above) {
 242                 wpa_printf(MSG_DEBUG, "bgscan simple: Start using long bgscan "
 243                            "interval");
 244                 data->scan_interval = data->long_interval;
 245                 eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
 246                 eloop_register_timeout(data->scan_interval, 0,
 247                                        bgscan_simple_timeout, data, NULL);
 248         } else if (!above) {
 249                 /*
 250                  * Signal dropped further 4 dB. Request a new scan if we have
 251                  * not yet scanned in a while.
 252                  */
 253                 os_get_time(&now);
 254                 if (now.sec > data->last_bgscan.sec + 10)
 255                         scan = 1;
 256         }
 257
 258         if (scan) {
 259                 wpa_printf(MSG_DEBUG, "bgscan simple: Trigger immediate scan");
 260                 eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
 261                 eloop_register_timeout(0, 0, bgscan_simple_timeout, data,
 262                                        NULL);
 263         }
 264 }
 265
 266
 267 const struct bgscan_ops bgscan_simple_ops = {
 268         .name = "simple",
 269         .init = bgscan_simple_init,
 270         .deinit = bgscan_simple_deinit,
 271         .notify_scan = bgscan_simple_notify_scan,
 272         .notify_beacon_loss = bgscan_simple_notify_beacon_loss,
 273         .notify_signal_change = bgscan_simple_notify_signal_change,
 274 };