bgscan_simple.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219
  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. return data;
  108. }
  109. static void bgscan_simple_deinit(void *priv)
  110. {
  111. struct bgscan_simple_data *data = priv;
  112. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  113. if (data->signal_threshold)
  114. wpa_drv_signal_monitor(data->wpa_s, 0, 0);
  115. os_free(data);
  116. }
  117. static int bgscan_simple_notify_scan(void *priv)
  118. {
  119. struct bgscan_simple_data *data = priv;
  120. wpa_printf(MSG_DEBUG, "bgscan simple: scan result notification");
  121. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  122. eloop_register_timeout(data->scan_interval, 0, bgscan_simple_timeout,
  123. data, NULL);
  124. /*
  125. * A more advanced bgscan could process scan results internally, select
  126. * the BSS and request roam if needed. This sample uses the existing
  127. * BSS/ESS selection routine. Change this to return 1 if selection is
  128. * done inside the bgscan module.
  129. */
  130. return 0;
  131. }
  132. static void bgscan_simple_notify_beacon_loss(void *priv)
  133. {
  134. wpa_printf(MSG_DEBUG, "bgscan simple: beacon loss");
  135. /* TODO: speed up background scanning */
  136. }
  137. static void bgscan_simple_notify_signal_change(void *priv, int above)
  138. {
  139. struct bgscan_simple_data *data = priv;
  140. if (data->short_interval == data->long_interval ||
  141. data->signal_threshold == 0)
  142. return;
  143. wpa_printf(MSG_DEBUG, "bgscan simple: signal level changed "
  144. "(above=%d)", above);
  145. if (data->scan_interval == data->long_interval && !above) {
  146. wpa_printf(MSG_DEBUG, "bgscan simple: Trigger immediate scan "
  147. "and start using short bgscan interval");
  148. data->scan_interval = data->short_interval;
  149. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  150. eloop_register_timeout(0, 0, bgscan_simple_timeout, data,
  151. NULL);
  152. } else if (data->scan_interval == data->short_interval && above) {
  153. wpa_printf(MSG_DEBUG, "bgscan simple: Start using long bgscan "
  154. "interval");
  155. data->scan_interval = data->long_interval;
  156. eloop_cancel_timeout(bgscan_simple_timeout, data, NULL);
  157. eloop_register_timeout(data->scan_interval, 0,
  158. bgscan_simple_timeout, data, NULL);
  159. } else if (!above) {
  160. struct os_time now;
  161. /*
  162. * Signal dropped further 4 dB. Request a new scan if we have
  163. * not yet scanned in a while.
  164. */
  165. os_get_time(&now);
  166. if (now.sec > data->last_bgscan.sec + 10) {
  167. wpa_printf(MSG_DEBUG, "bgscan simple: Trigger "
  168. "immediate scan");
  169. eloop_cancel_timeout(bgscan_simple_timeout, data,
  170. NULL);
  171. eloop_register_timeout(0, 0, bgscan_simple_timeout,
  172. data, NULL);
  173. }
  174. }
  175. }
  176. const struct bgscan_ops bgscan_simple_ops = {
  177. .name = "simple",
  178. .init = bgscan_simple_init,
  179. .deinit = bgscan_simple_deinit,
  180. .notify_scan = bgscan_simple_notify_scan,
  181. .notify_beacon_loss = bgscan_simple_notify_beacon_loss,
  182. .notify_signal_change = bgscan_simple_notify_signal_change,
  183. };