mukesh agrawal | 8a3188d | 2011-12-01 20:56:44 +0000 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Paul Stewart | b50f0b9 | 2011-05-16 16:31:42 -0700 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #ifndef SHILL_WIFI_ |
| 6 | #define SHILL_WIFI_ |
| 7 | |
Gary Morain | 22601da | 2012-03-16 10:48:39 -0700 | [diff] [blame] | 8 | // A WiFi device represents a wireless network interface implemented as an IEEE |
| 9 | // 802.11 station. An Access Point (AP) (or, more correctly, a Basic Service |
| 10 | // Set(BSS)) is represented by a WiFiEndpoint. An AP provides a WiFiService, |
| 11 | // which is the same concept as Extended Service Set (ESS) in 802.11, |
| 12 | // identified by an SSID. A WiFiService includes zero or more WiFiEndpoints |
| 13 | // that provide that service. |
| 14 | // |
| 15 | // A WiFi device interacts with a real device through WPA Supplicant. |
| 16 | // Wifi::Start() creates a connection to WPA Supplicant, represented by |
| 17 | // |supplicant_interface_proxy_|. [1] |
| 18 | // |
| 19 | // A WiFi device becomes aware of WiFiEndpoints through BSSAdded signals from |
| 20 | // WPA Supplicant, which identifies them by a "path". The WiFi object maintains |
| 21 | // an EndpointMap in |endpoint_by_rpcid_|, in which the key is the "path" and |
| 22 | // the value is a pointer to a WiFiEndpoint object. When a WiFiEndpoint is |
| 23 | // added, it is associated with a WiFiService. |
| 24 | // |
| 25 | // A WiFi device becomes aware of a WiFiService in three different ways. 1) |
| 26 | // When a WiFiEndpoint is added through the BSSAdded signal, the WiFiEndpoint is |
| 27 | // providing a service, and if that service is unknown to the WiFi device, it is |
| 28 | // added at that point. 2) The Manager can add a WiFiService by calling |
| 29 | // WiFi::GetService(). 3) Services are loaded from the profile through a call |
| 30 | // to WiFi::Load(). |
| 31 | // |
| 32 | // The WiFi device connects to a WiFiService, not a WiFiEndpoint, through WPA |
| 33 | // Supplicant. It is the job of WPA Supplicant to select a BSS (aka |
| 34 | // WiFiEndpoint) to connect to. The protocol for establishing a connection is |
| 35 | // as follows: |
| 36 | // |
| 37 | // 1. The WiFi device sends AddNetwork to WPA Supplicant, which returns a |
| 38 | // "network path" when done. |
| 39 | // |
| 40 | // 2. The WiFi device sends SelectNetwork, indicating the network path |
| 41 | // received in 1, to WPA Supplicant, which begins the process of associating |
| 42 | // with an AP in the ESS. At this point the WiFiService which is being |
| 43 | // connected is called the |pending_service_|. |
| 44 | // |
Paul Stewart | bc6e739 | 2012-05-24 07:07:48 -0700 | [diff] [blame] | 45 | // 3. During association to an EAP-TLS network, WPA Supplicant can send |
| 46 | // multiple "Certification" events, which provide information about the |
| 47 | // identity of the remote entity. |
| 48 | // |
| 49 | // 4. When association is complete, WPA Supplicant sends a PropertiesChanged |
| 50 | // signal to the WiFi device, indicating a change in the CurrentBSS. The |
| 51 | // WiFiService indicated by the new value of CurrentBSS is set as the |
| 52 | // |current_service_|, and |pending_service_| is (normally) cleared. |
Gary Morain | 22601da | 2012-03-16 10:48:39 -0700 | [diff] [blame] | 53 | // |
| 54 | // Some key things to notice are 1) WPA Supplicant does the work of selecting |
| 55 | // the AP (aka WiFiEndpoint) and it tells the WiFi device which AP it selected. |
| 56 | // 2) The process of connecting is asynchronous. There is a |current_service_| |
| 57 | // to which the WiFi device is presently using and a |pending_service_| to which |
| 58 | // the WiFi device has initiated a connection. |
| 59 | // |
| 60 | // A WiFi device is notified that an AP has gone away via the BSSRemoved signal. |
| 61 | // When the last WiFiEndpoint of a WiFiService is removed, the WiFiService |
| 62 | // itself is deleted. |
| 63 | // |
| 64 | // TODO(gmorain): Add explanation of hidden SSIDs. |
| 65 | // |
| 66 | // WPA Supplicant's PropertiesChanged signal communicates changes in the state |
| 67 | // of WPA Supplicant's current service. This state is stored in |
| 68 | // |supplicant_state_| and reflects WPA Supplicant's view of the state of the |
| 69 | // connection to an AP. Changes in this state sometimes cause state changes in |
| 70 | // the WiFiService to which a WiFi device is connected. For example, when WPA |
| 71 | // Supplicant signals the new state to be "completed", then the WiFiService |
| 72 | // state gets changed to "configuring". State change notifications are not |
| 73 | // reliable because WPA Supplicant may coalesce state changes in quick |
| 74 | // succession so that only the last of the changes is signaled. |
| 75 | // |
| 76 | // Notes: |
| 77 | // |
| 78 | // 1. Shill's definition of the interface is described in |
| 79 | // shill/dbus_bindings/supplicant-interface.xml, and the WPA Supplicant's |
| 80 | // description of the same interface is in |
| 81 | // third_party/wpa_supplicant/doc/dbus.doxygen. |
| 82 | |
mukesh agrawal | 5c05b29 | 2012-03-07 10:12:52 -0800 | [diff] [blame] | 83 | #include <time.h> |
| 84 | |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 85 | #include <map> |
Chris Masone | 46eaaf5 | 2011-05-24 13:08:30 -0700 | [diff] [blame] | 86 | #include <string> |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 87 | #include <vector> |
Chris Masone | 46eaaf5 | 2011-05-24 13:08:30 -0700 | [diff] [blame] | 88 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 89 | #include <base/callback_forward.h> |
mukesh agrawal | b66c646 | 2012-05-07 11:45:25 -0700 | [diff] [blame] | 90 | #include <base/cancelable_callback.h> |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 91 | #include <base/memory/weak_ptr.h> |
mukesh agrawal | af57195 | 2011-07-14 14:31:12 -0700 | [diff] [blame] | 92 | #include <dbus-c++/dbus.h> |
Paul Stewart | 6ab23a9 | 2011-11-09 17:17:47 -0800 | [diff] [blame] | 93 | #include <gtest/gtest_prod.h> // for FRIEND_TEST |
mukesh agrawal | af57195 | 2011-07-14 14:31:12 -0700 | [diff] [blame] | 94 | |
Darin Petkov | 2b8e44e | 2012-06-25 15:13:26 +0200 | [diff] [blame] | 95 | #include "shill/dbus_manager.h" |
Paul Stewart | b50f0b9 | 2011-05-16 16:31:42 -0700 | [diff] [blame] | 96 | #include "shill/device.h" |
Paul Stewart | 26b327e | 2011-10-19 11:38:09 -0700 | [diff] [blame] | 97 | #include "shill/event_dispatcher.h" |
Gary Morain | ac1bdb4 | 2012-02-16 17:42:29 -0800 | [diff] [blame] | 98 | #include "shill/power_manager.h" |
Chris Masone | 2b10554 | 2011-06-22 10:58:09 -0700 | [diff] [blame] | 99 | #include "shill/refptr_types.h" |
Paul Stewart | b50f0b9 | 2011-05-16 16:31:42 -0700 | [diff] [blame] | 100 | |
| 101 | namespace shill { |
| 102 | |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 103 | class Error; |
| 104 | class KeyValueStore; |
Darin Petkov | ab565bb | 2011-10-06 02:55:51 -0700 | [diff] [blame] | 105 | class ProxyFactory; |
mukesh agrawal | af57195 | 2011-07-14 14:31:12 -0700 | [diff] [blame] | 106 | class SupplicantInterfaceProxyInterface; |
| 107 | class SupplicantProcessProxyInterface; |
mukesh agrawal | 445e72c | 2011-06-22 11:13:50 -0700 | [diff] [blame] | 108 | class WiFiService; |
mukesh agrawal | b54601c | 2011-06-07 17:39:22 -0700 | [diff] [blame] | 109 | |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 110 | // WiFi class. Specialization of Device for WiFi. |
Paul Stewart | b50f0b9 | 2011-05-16 16:31:42 -0700 | [diff] [blame] | 111 | class WiFi : public Device { |
| 112 | public: |
Paul Stewart | f1ce5d2 | 2011-05-19 13:10:20 -0700 | [diff] [blame] | 113 | WiFi(ControlInterface *control_interface, |
| 114 | EventDispatcher *dispatcher, |
Thieu Le | 3426c8f | 2012-01-11 17:35:11 -0800 | [diff] [blame] | 115 | Metrics *metrics, |
Paul Stewart | f1ce5d2 | 2011-05-19 13:10:20 -0700 | [diff] [blame] | 116 | Manager *manager, |
Chris Masone | 626719f | 2011-08-18 16:58:48 -0700 | [diff] [blame] | 117 | const std::string &link, |
| 118 | const std::string &address, |
Paul Stewart | f1ce5d2 | 2011-05-19 13:10:20 -0700 | [diff] [blame] | 119 | int interface_index); |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 120 | virtual ~WiFi(); |
Darin Petkov | c086531 | 2011-09-16 15:31:20 -0700 | [diff] [blame] | 121 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 122 | virtual void Start(Error *error, const EnabledStateChangedCallback &callback); |
| 123 | virtual void Stop(Error *error, const EnabledStateChangedCallback &callback); |
Paul Stewart | a41e38d | 2011-11-11 07:47:29 -0800 | [diff] [blame] | 124 | virtual bool Load(StoreInterface *storage); |
Darin Petkov | c086531 | 2011-09-16 15:31:20 -0700 | [diff] [blame] | 125 | virtual void Scan(Error *error); |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 126 | |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 127 | // Called by SupplicantInterfaceProxy, in response to events from |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 128 | // wpa_supplicant. |
| 129 | void BSSAdded(const ::DBus::Path &BSS, |
Chris Masone | a82b711 | 2011-05-25 15:16:29 -0700 | [diff] [blame] | 130 | const std::map<std::string, ::DBus::Variant> &properties); |
mukesh agrawal | 261daca | 2011-12-02 18:56:56 +0000 | [diff] [blame] | 131 | void BSSRemoved(const ::DBus::Path &BSS); |
Paul Stewart | bc6e739 | 2012-05-24 07:07:48 -0700 | [diff] [blame] | 132 | void Certification(const std::map<std::string, ::DBus::Variant> &properties); |
mukesh agrawal | 7ec7131 | 2011-11-10 02:08:26 +0000 | [diff] [blame] | 133 | void PropertiesChanged( |
| 134 | const std::map<std::string, ::DBus::Variant> &properties); |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 135 | void ScanDone(); |
| 136 | |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 137 | // Called by WiFiService. |
mukesh agrawal | 6e27777 | 2011-09-29 15:04:23 -0700 | [diff] [blame] | 138 | virtual void ConnectTo( |
| 139 | WiFiService *service, |
mukesh agrawal | 6489632 | 2011-12-01 01:13:10 +0000 | [diff] [blame] | 140 | std::map<std::string, ::DBus::Variant> service_params); |
mukesh agrawal | 0ed0f2e | 2011-12-05 20:36:17 +0000 | [diff] [blame] | 141 | virtual void DisconnectFrom(WiFiService *service); |
mukesh agrawal | 8a3188d | 2011-12-01 20:56:44 +0000 | [diff] [blame] | 142 | virtual bool IsIdle() const; |
Paul Stewart | 66c8600 | 2012-01-30 18:00:52 -0800 | [diff] [blame] | 143 | virtual void ClearCachedCredentials(); |
mukesh agrawal | b54601c | 2011-06-07 17:39:22 -0700 | [diff] [blame] | 144 | |
mukesh agrawal | b20776f | 2012-02-10 16:00:36 -0800 | [diff] [blame] | 145 | // Called by WiFiEndpoint. |
| 146 | virtual void NotifyEndpointChanged(const WiFiEndpoint &endpoint); |
| 147 | |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 148 | // Called by Manager. |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 149 | virtual WiFiServiceRefPtr GetService(const KeyValueStore &args, Error *error); |
| 150 | |
mukesh agrawal | 16bc1b8 | 2012-02-09 18:38:26 -0800 | [diff] [blame] | 151 | // Utility, used by WiFiService and WiFiEndpoint. |
| 152 | // Replace non-ASCII characters with '?'. Return true if one or more |
| 153 | // characters were changed. |
| 154 | static bool SanitizeSSID(std::string *ssid); |
| 155 | |
Paul Stewart | b50f0b9 | 2011-05-16 16:31:42 -0700 | [diff] [blame] | 156 | private: |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 157 | friend class WiFiObjectTest; // access to supplicant_*_proxy_, link_up_ |
| 158 | friend class WiFiScanTest; // kNumFastScanAttempts, kFastScanIntervalSeconds |
Darin Petkov | 4a66cc5 | 2012-06-15 10:08:29 +0200 | [diff] [blame] | 159 | FRIEND_TEST(WiFiMainTest, AppendBgscan); |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 160 | FRIEND_TEST(WiFiMainTest, FlushBSSOnResume); // kMaxBSSResumeAgeSeconds |
mukesh agrawal | 7ec7131 | 2011-11-10 02:08:26 +0000 | [diff] [blame] | 161 | FRIEND_TEST(WiFiMainTest, InitialSupplicantState); // kInterfaceStateUnknown |
Thieu Le | e41a72d | 2012-02-06 20:46:51 +0000 | [diff] [blame] | 162 | FRIEND_TEST(WiFiMainTest, ScanResults); // EndpointMap |
mukesh agrawal | 165e614 | 2011-11-22 02:22:56 +0000 | [diff] [blame] | 163 | FRIEND_TEST(WiFiMainTest, ScanResultsWithUpdates); // EndpointMap |
mukesh agrawal | c4f368f | 2012-06-04 19:45:52 -0700 | [diff] [blame] | 164 | FRIEND_TEST(WiFiMainTest, Stop); // weak_ptr_factory_ |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 165 | FRIEND_TEST(WiFiMainTest, SuspectCredentialsOpen); // SuspectCredentials |
| 166 | FRIEND_TEST(WiFiMainTest, SuspectCredentialsWPANeverConnected); // as above |
| 167 | FRIEND_TEST(WiFiMainTest, SuspectCredentialsWPAPreviouslyConnected); // "" |
Darin Petkov | 4a66cc5 | 2012-06-15 10:08:29 +0200 | [diff] [blame] | 168 | FRIEND_TEST(WiFiPropertyTest, BgscanMethodProperty); // bgscan_method_ |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 169 | FRIEND_TEST(WiFiScanTest, FastRescan); // kFastScanIntervalSeconds |
Paul Stewart | 6ab23a9 | 2011-11-09 17:17:47 -0800 | [diff] [blame] | 170 | |
mukesh agrawal | b54601c | 2011-06-07 17:39:22 -0700 | [diff] [blame] | 171 | typedef std::map<const std::string, WiFiEndpointRefPtr> EndpointMap; |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 172 | typedef std::map<WiFiService *, std::string> ReverseServiceMap; |
mukesh agrawal | b54601c | 2011-06-07 17:39:22 -0700 | [diff] [blame] | 173 | |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 174 | static const char *kDefaultBgscanMethod; |
| 175 | static const uint16 kDefaultBgscanShortIntervalSeconds; |
| 176 | static const int32 kDefaultBgscanSignalThresholdDbm; |
| 177 | static const uint16 kDefaultScanIntervalSeconds; |
Darin Petkov | 4a66cc5 | 2012-06-15 10:08:29 +0200 | [diff] [blame] | 178 | static const uint16 kBackgroundScanIntervalSeconds; |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 179 | static const char kManagerErrorSSIDTooLong[]; |
| 180 | static const char kManagerErrorSSIDTooShort[]; |
| 181 | static const char kManagerErrorSSIDRequired[]; |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 182 | static const char kManagerErrorUnsupportedSecurityMode[]; |
mukesh agrawal | 7a4e400 | 2011-09-06 11:26:05 -0700 | [diff] [blame] | 183 | static const char kManagerErrorUnsupportedServiceMode[]; |
mukesh agrawal | 5c05b29 | 2012-03-07 10:12:52 -0800 | [diff] [blame] | 184 | static const time_t kMaxBSSResumeAgeSeconds; |
mukesh agrawal | 7ec7131 | 2011-11-10 02:08:26 +0000 | [diff] [blame] | 185 | static const char kInterfaceStateUnknown[]; |
mukesh agrawal | f202817 | 2012-03-13 14:20:22 -0700 | [diff] [blame] | 186 | // Delay between scans when supplicant finds "No suitable network". |
| 187 | static const time_t kRescanIntervalSeconds; |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 188 | // Number of times to quickly attempt a scan after startup / disconnect. |
| 189 | static const int kNumFastScanAttempts; |
| 190 | static const int kFastScanIntervalSeconds; |
Paul Stewart | 2b05e62 | 2012-07-13 20:38:44 -0700 | [diff] [blame] | 191 | static const int kPendingTimeoutSeconds; |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 192 | |
Darin Petkov | 4a66cc5 | 2012-06-15 10:08:29 +0200 | [diff] [blame] | 193 | void AppendBgscan(WiFiService *service, |
| 194 | std::map<std::string, DBus::Variant> *service_params) const; |
| 195 | std::string GetBgscanMethod(const int &argument, Error *error); |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 196 | uint16 GetBgscanShortInterval(Error */* error */) { |
| 197 | return bgscan_short_interval_seconds_; |
| 198 | } |
| 199 | int32 GetBgscanSignalThreshold(Error */* error */) { |
| 200 | return bgscan_signal_threshold_dbm_; |
| 201 | } |
| 202 | uint16 GetScanInterval(Error */* error */) { return scan_interval_seconds_; } |
Darin Petkov | 4a66cc5 | 2012-06-15 10:08:29 +0200 | [diff] [blame] | 203 | void SetBgscanMethod( |
| 204 | const int &argument, const std::string &method, Error *error); |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 205 | void SetBgscanShortInterval(const uint16 &seconds, Error *error); |
| 206 | void SetBgscanSignalThreshold(const int32 &dbm, Error *error); |
| 207 | void SetScanInterval(const uint16 &seconds, Error *error); |
Darin Petkov | 4a66cc5 | 2012-06-15 10:08:29 +0200 | [diff] [blame] | 208 | void ClearBgscanMethod(const int &argument, Error *error); |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 209 | |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 210 | WiFiServiceRefPtr CreateServiceForEndpoint( |
| 211 | const WiFiEndpoint &endpoint, bool hidden_ssid); |
| 212 | void CurrentBSSChanged(const ::DBus::Path &new_bss); |
Paul Stewart | 6ab23a9 | 2011-11-09 17:17:47 -0800 | [diff] [blame] | 213 | WiFiServiceRefPtr FindService(const std::vector<uint8_t> &ssid, |
| 214 | const std::string &mode, |
| 215 | const std::string &security) const; |
mukesh agrawal | 165e614 | 2011-11-22 02:22:56 +0000 | [diff] [blame] | 216 | WiFiServiceRefPtr FindServiceForEndpoint(const WiFiEndpoint &endpoint); |
Paul Stewart | ced6a0b | 2011-11-08 15:32:04 -0800 | [diff] [blame] | 217 | ByteArrays GetHiddenSSIDList(); |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 218 | void HandleDisconnect(); |
| 219 | void HandleRoam(const ::DBus::Path &new_bssid); |
Paul Stewart | a41e38d | 2011-11-11 07:47:29 -0800 | [diff] [blame] | 220 | // Create services for hidden networks stored in |storage|. Returns true |
| 221 | // if any were found, otherwise returns false. |
| 222 | bool LoadHiddenServices(StoreInterface *storage); |
mukesh agrawal | b4bc57d | 2011-12-07 01:07:47 +0000 | [diff] [blame] | 223 | void BSSAddedTask(const ::DBus::Path &BSS, |
| 224 | const std::map<std::string, ::DBus::Variant> &properties); |
| 225 | void BSSRemovedTask(const ::DBus::Path &BSS); |
Paul Stewart | 66c8600 | 2012-01-30 18:00:52 -0800 | [diff] [blame] | 226 | void ClearCachedCredentialsTask(); |
Paul Stewart | bc6e739 | 2012-05-24 07:07:48 -0700 | [diff] [blame] | 227 | void CertificationTask( |
| 228 | const std::map<std::string, ::DBus::Variant> &properties); |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 229 | void PropertiesChangedTask( |
| 230 | const std::map<std::string, ::DBus::Variant> &properties); |
mukesh agrawal | dc42bb3 | 2011-07-28 10:40:26 -0700 | [diff] [blame] | 231 | void ScanDoneTask(); |
mukesh agrawal | 3239932 | 2011-09-01 10:53:43 -0700 | [diff] [blame] | 232 | void ScanTask(); |
mukesh agrawal | 7ec7131 | 2011-11-10 02:08:26 +0000 | [diff] [blame] | 233 | void StateChanged(const std::string &new_state); |
mukesh agrawal | cf24a24 | 2012-05-21 16:46:11 -0700 | [diff] [blame] | 234 | // Heuristic check if a connection failure was due to bad credentials. |
| 235 | bool SuspectCredentials(const WiFiService &service) const; |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 236 | void HelpRegisterDerivedInt32( |
| 237 | PropertyStore *store, |
| 238 | const std::string &name, |
| 239 | int32(WiFi::*get)(Error *error), |
| 240 | void(WiFi::*set)(const int32 &value, Error *error)); |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 241 | void HelpRegisterDerivedUint16( |
| 242 | PropertyStore *store, |
| 243 | const std::string &name, |
| 244 | uint16(WiFi::*get)(Error *error), |
| 245 | void(WiFi::*set)(const uint16 &value, Error *error)); |
| 246 | |
Gary Morain | ac1bdb4 | 2012-02-16 17:42:29 -0800 | [diff] [blame] | 247 | // If this WiFi device is idle and |new_state| indicates a resume event, a |
| 248 | // scan is initiated. |
| 249 | void HandlePowerStateChange(PowerManager::SuspendState new_state); |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 250 | // Restart fast scanning after disconnection. |
| 251 | void RestartFastScanAttempts(); |
mukesh agrawal | b66c646 | 2012-05-07 11:45:25 -0700 | [diff] [blame] | 252 | // Schedules a scan attempt at time |scan_interval_seconds_| in the |
| 253 | // future. Cancels any currently pending scan timer. |
| 254 | void StartScanTimer(); |
| 255 | // Cancels any currently pending scan timer. |
| 256 | void StopScanTimer(); |
| 257 | // Initiates a scan, if idle. Reschedules the scan timer regardless. |
| 258 | void ScanTimerHandler(); |
Paul Stewart | 2b05e62 | 2012-07-13 20:38:44 -0700 | [diff] [blame] | 259 | // Starts a timer in order to limit the length of an attempt to |
| 260 | // connect to a pending network. |
| 261 | void StartPendingTimer(); |
| 262 | // Cancels any currently pending network timer. |
| 263 | void StopPendingTimer(); |
| 264 | // Aborts a pending network that is taking too long to connect. |
| 265 | void PendingTimeoutHandler(); |
| 266 | // Sets the current pending service. If the argument is non-NULL, |
| 267 | // the Pending timer is started and the associated service is set |
| 268 | // to "Associating", otherwise it is stopped. |
| 269 | void SetPendingService(const WiFiServiceRefPtr &service); |
Gary Morain | ac1bdb4 | 2012-02-16 17:42:29 -0800 | [diff] [blame] | 270 | |
Darin Petkov | 2b8e44e | 2012-06-25 15:13:26 +0200 | [diff] [blame] | 271 | void OnSupplicantAppear(const std::string &owner); |
| 272 | void OnSupplicantVanish(); |
| 273 | |
| 274 | void ConnectToSupplicant(); |
| 275 | |
| 276 | void Restart(); |
| 277 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 278 | base::WeakPtrFactory<WiFi> weak_ptr_factory_; |
| 279 | |
Darin Petkov | ab565bb | 2011-10-06 02:55:51 -0700 | [diff] [blame] | 280 | // Store cached copies of singletons for speed/ease of testing. |
| 281 | ProxyFactory *proxy_factory_; |
mukesh agrawal | 5c05b29 | 2012-03-07 10:12:52 -0800 | [diff] [blame] | 282 | Time *time_; |
Darin Petkov | ab565bb | 2011-10-06 02:55:51 -0700 | [diff] [blame] | 283 | |
Darin Petkov | 2b8e44e | 2012-06-25 15:13:26 +0200 | [diff] [blame] | 284 | DBusManager::CancelableAppearedCallback on_supplicant_appear_; |
| 285 | DBusManager::CancelableVanishedCallback on_supplicant_vanish_; |
| 286 | bool supplicant_present_; |
| 287 | |
mukesh agrawal | af57195 | 2011-07-14 14:31:12 -0700 | [diff] [blame] | 288 | scoped_ptr<SupplicantProcessProxyInterface> supplicant_process_proxy_; |
| 289 | scoped_ptr<SupplicantInterfaceProxyInterface> supplicant_interface_proxy_; |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 290 | // The rpcid used as the key is wpa_supplicant's D-Bus path for the |
| 291 | // Endpoint (BSS, in supplicant parlance). |
| 292 | EndpointMap endpoint_by_rpcid_; |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 293 | // Map from Services to the D-Bus path for the corresponding wpa_supplicant |
| 294 | // Network. |
| 295 | ReverseServiceMap rpcid_by_service_; |
mukesh agrawal | 1590839 | 2011-11-16 18:29:25 +0000 | [diff] [blame] | 296 | std::vector<WiFiServiceRefPtr> services_; |
| 297 | // The Service we are presently connected to. May be NULL is we're not |
| 298 | // not connected to any Service. |
| 299 | WiFiServiceRefPtr current_service_; |
| 300 | // The Service we're attempting to connect to. May be NULL if we're |
| 301 | // not attempting to connect to a new Service. If non-NULL, should |
| 302 | // be distinct from |current_service_|. (A service should not |
| 303 | // simultaneously be both pending, and current.) |
| 304 | WiFiServiceRefPtr pending_service_; |
| 305 | std::string supplicant_state_; |
| 306 | std::string supplicant_bss_; |
Paul Stewart | 66c8600 | 2012-01-30 18:00:52 -0800 | [diff] [blame] | 307 | // Signifies that ClearCachedCredentialsTask() is pending. |
| 308 | bool clear_cached_credentials_pending_; |
mukesh agrawal | 5c05b29 | 2012-03-07 10:12:52 -0800 | [diff] [blame] | 309 | // Indicates that we should flush supplicant's BSS cache after the |
| 310 | // next scan completes. |
| 311 | bool need_bss_flush_; |
| 312 | struct timeval resumed_at_; |
mukesh agrawal | b66c646 | 2012-05-07 11:45:25 -0700 | [diff] [blame] | 313 | // Executes when the (foreground) scan timer expires. Calls ScanTimerHandler. |
| 314 | base::CancelableClosure scan_timer_callback_; |
Paul Stewart | 2b05e62 | 2012-07-13 20:38:44 -0700 | [diff] [blame] | 315 | // Executes when a pending service connect timer expires. Calls |
| 316 | // PendingTimeoutHandler. |
| 317 | base::CancelableClosure pending_timeout_callback_; |
Paul Stewart | e369ece | 2012-05-22 09:11:03 -0700 | [diff] [blame] | 318 | // Number of remaining fast scans to be done during startup and disconnect. |
| 319 | int fast_scans_remaining_; |
mukesh agrawal | ab87ea4 | 2011-05-18 11:44:49 -0700 | [diff] [blame] | 320 | |
Chris Masone | 853b81b | 2011-06-24 14:11:41 -0700 | [diff] [blame] | 321 | // Properties |
| 322 | std::string bgscan_method_; |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 323 | uint16 bgscan_short_interval_seconds_; |
| 324 | int32 bgscan_signal_threshold_dbm_; |
Chris Masone | 853b81b | 2011-06-24 14:11:41 -0700 | [diff] [blame] | 325 | bool scan_pending_; |
mukesh agrawal | 4d0401c | 2012-01-06 16:05:31 -0800 | [diff] [blame] | 326 | uint16 scan_interval_seconds_; |
Chris Masone | 853b81b | 2011-06-24 14:11:41 -0700 | [diff] [blame] | 327 | |
Paul Stewart | b50f0b9 | 2011-05-16 16:31:42 -0700 | [diff] [blame] | 328 | DISALLOW_COPY_AND_ASSIGN(WiFi); |
| 329 | }; |
| 330 | |
| 331 | } // namespace shill |
| 332 | |
| 333 | #endif // SHILL_WIFI_ |