bgscan_simple.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236
  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. #include "includes.h"
  15. #include "common.h"
  16. #include "eloop.h"
  17. #include "drivers/driver.h"
  18. #include "config_ssid.h"
  19. #include "wpa_supplicant_i.h"
  20. #include "driver_i.h"
  21. #include "scan.h"
  22. #include "bgscan.h"
  23. struct bgscan_simple_data {
  24. struct wpa_supplicant *wpa_s;
  25. const struct wpa_ssid *ssid;
  26. int scan_interval;
  27. int signal_threshold;
  28. int short_interval; /* use if signal < threshold */
  29. int long_interval; /* use if signal > threshold */
  30. struct os_time last_bgscan;
  31. };
  32. static void bgscan_simple_timeout(void *eloop_ctx, void *timeout_ctx)
  33. {
  34. struct bgscan_simple_data *data = eloop_ctx;
  35. struct wpa_supplicant *wpa_s = data->wpa_s;
  36. struct wpa_driver_scan_params params;
  37. os_memset(&params, 0, sizeof(params));
  38. params.num_ssids = 1;
  39. params.ssids[0].ssid = data->ssid->ssid;
  40. params.ssids[0].ssid_len = data->ssid->ssid_len;
  41. params.freqs = data->ssid->scan_freq;
  42. /*
  43. * A more advanced bgscan module would learn about most like channels
  44. * over time and request scans only for some channels (probing others
  45. * every now and then) to reduce effect on the data connection.
  46. */
  47. wpa_printf(MSG_DEBUG, "bgscan simple: Request a background scan");
  48. if (wpa_supplicant_trigger_scan(wpa_s, &params)) {
  49. wpa_printf(MSG_DEBUG, "bgscan simple: Failed to trigger scan");
  50. eloop_register_timeout(data->scan_interval, 0,
  51. bgscan_simple_timeout, data, NULL);
  52. } else
  53. os_get_time(&data->last_bgscan);
  54. }
  55. static int bgscan_simple_get_params(struct bgscan_simple_data *data,
  56. const char *params)
  57. {
  58. const char *pos;
  59. if (params == NULL)
  60. return 0;
  61. data->short_interval = atoi(params);
  62. pos = os_strchr(params, ':');
  63. if (pos == NULL)
  64. return 0;
  65. pos++;
  66. data->signal_threshold = atoi(pos);
  67. pos = os_strchr(pos, ':');
  68. if (pos == NULL) {
  69. wpa_printf(MSG_ERROR, "bgscan simple: Missing scan interval "
  70. "for high signal");
  71. return -1;
  72. }
  73. pos++;
  74. data->long_interval = atoi(pos);
  75. return 0;
  76. }
  77. static void * bgscan_simple_init(struct wpa_supplicant *wpa_s,
  78. const char *params,
  79. const struct wpa_ssid *ssid)
  80. {
  81. struct bgscan_simple_data *data;
  82. data = os_zalloc(sizeof(*data));
  83. if (data == NULL)
  84. return NULL;
  85. data->wpa_s = wpa_s;
  86. data->ssid = ssid;
  87. if (bgscan_simple_get_params(data, params) < 0) {
  88. os_free(data);
  89. return NULL;
  90. }
  91. if (data->short_interval <= 0)
  92. data->short_interval = 30;
  93. if (data->long_interval <= 0)
  94. data->long_interval = 30;
  95. wpa_printf(MSG_DEBUG, "bgscan simple: Signal strength threshold %d "
  96. "Short bgscan interval %d Long bgscan interval %d",
  97. data->signal_threshold, data->short_interval,
  98. data->long_interval);
  99. if (data->signal_threshold &&
  100. wpa_drv_signal_monitor(wpa_s, data->signal_threshold, 4) < 0) {
  101. wpa_printf(MSG_ERROR, "bgscan simple: Failed to enable "
  102. "signal strength monitoring");
  103. }
  104. data->scan_interval = data->short_interval;
  105. eloop_register_timeout(data->scan_interval, 0, bgscan_simple_timeout,
  106. data, NULL);
  107. /*
  108. * This function is called immediately after an association, so it is
  109. * reasonable to assume that a scan was completed recently. This makes
  110. * us skip an immediate new scan in cases where the current signal
  111. * level is below the bgscan threshold.
  112. */
  113. os_get_time(&data->last_bgscan);
  114. return data;
  115. }
  116. static void bgscan_simple_deinit(void *priv)
  117. {
  118. struct bgscan_simple_data *data = priv;
  119. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  120. if (data->signal_threshold)
  121. wpa_drv_signal_monitor(data->wpa_s, 0, 0);
  122. os_free(data);
  123. }
  124. static int bgscan_simple_notify_scan(void *priv,
  125. struct wpa_scan_results *scan_res)
  126. {
  127. struct bgscan_simple_data *data = priv;
  128. wpa_printf(MSG_DEBUG, "bgscan simple: scan result notification");
  129. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  130. eloop_register_timeout(data->scan_interval, 0, bgscan_simple_timeout,
  131. data, NULL);
  132. /*
  133. * A more advanced bgscan could process scan results internally, select
  134. * the BSS and request roam if needed. This sample uses the existing
  135. * BSS/ESS selection routine. Change this to return 1 if selection is
  136. * done inside the bgscan module.
  137. */
  138. return 0;
  139. }
  140. static void bgscan_simple_notify_beacon_loss(void *priv)
  141. {
  142. wpa_printf(MSG_DEBUG, "bgscan simple: beacon loss");
  143. /* TODO: speed up background scanning */
  144. }
  145. static void bgscan_simple_notify_signal_change(void *priv, int above,
  146. int current_signal,
  147. int current_noise,
  148. int current_txrate)
  149. {
  150. struct bgscan_simple_data *data = priv;
  151. int scan = 0;
  152. struct os_time now;
  153. if (data->short_interval == data->long_interval ||
  154. data->signal_threshold == 0)
  155. return;
  156. wpa_printf(MSG_DEBUG, "bgscan simple: signal level changed "
  157. "(above=%d current_signal=%d current_noise=%d "
  158. "current_txrate=%d))", above, current_signal,
  159. current_noise, current_txrate);
  160. if (data->scan_interval == data->long_interval && !above) {
  161. wpa_printf(MSG_DEBUG, "bgscan simple: Start using short "
  162. "bgscan interval");
  163. data->scan_interval = data->short_interval;
  164. os_get_time(&now);
  165. if (now.sec > data->last_bgscan.sec + 1)
  166. scan = 1;
  167. } else if (data->scan_interval == data->short_interval && above) {
  168. wpa_printf(MSG_DEBUG, "bgscan simple: Start using long bgscan "
  169. "interval");
  170. data->scan_interval = data->long_interval;
  171. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  172. eloop_register_timeout(data->scan_interval, 0,
  173. bgscan_simple_timeout, data, NULL);
  174. } else if (!above) {
  175. /*
  176. * Signal dropped further 4 dB. Request a new scan if we have
  177. * not yet scanned in a while.
  178. */
  179. os_get_time(&now);
  180. if (now.sec > data->last_bgscan.sec + 10)
  181. scan = 1;
  182. }
  183. if (scan) {
  184. wpa_printf(MSG_DEBUG, "bgscan simple: Trigger immediate scan");
  185. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  186. eloop_register_timeout(0, 0, bgscan_simple_timeout, data,
  187. NULL);
  188. }
  189. }
  190. const struct bgscan_ops bgscan_simple_ops = {
  191. .name = "simple",
  192. .init = bgscan_simple_init,
  193. .deinit = bgscan_simple_deinit,
  194. .notify_scan = bgscan_simple_notify_scan,
  195. .notify_beacon_loss = bgscan_simple_notify_beacon_loss,
  196. .notify_signal_change = bgscan_simple_notify_signal_change,
  197. };