1 //
2 // Copyright (C) 2012 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "shill/wifi/wifi.h"
18 
19 #include <linux/if.h>
20 #include <linux/netlink.h>  // Needs typedefs from sys/socket.h.
21 #include <netinet/ether.h>
22 #include <sys/socket.h>
23 
24 #include <map>
25 #include <string>
26 #include <vector>
27 
28 #include <base/files/file_util.h>
29 #include <base/memory/ref_counted.h>
30 #include <base/strings/string_number_conversions.h>
31 #include <base/strings/string_split.h>
32 #include <base/strings/string_util.h>
33 #include <base/strings/stringprintf.h>
34 #if defined(__ANDROID__)
35 #include <dbus/service_constants.h>
36 #else
37 #include <chromeos/dbus/service_constants.h>
38 #endif  // __ANDROID__
39 
40 #include "shill/dhcp/mock_dhcp_config.h"
41 #include "shill/dhcp/mock_dhcp_provider.h"
42 #include "shill/error.h"
43 #include "shill/event_dispatcher.h"
44 #include "shill/geolocation_info.h"
45 #include "shill/ip_address_store.h"
46 #include "shill/key_value_store.h"
47 #include "shill/logging.h"
48 #include "shill/manager.h"
49 #include "shill/mock_adaptors.h"
50 #include "shill/mock_device.h"
51 #include "shill/mock_device_info.h"
52 #include "shill/mock_eap_credentials.h"
53 #include "shill/mock_event_dispatcher.h"
54 #include "shill/mock_ipconfig.h"
55 #include "shill/mock_link_monitor.h"
56 #include "shill/mock_log.h"
57 #include "shill/mock_manager.h"
58 #include "shill/mock_metrics.h"
59 #include "shill/mock_profile.h"
60 #include "shill/mock_store.h"
61 #include "shill/net/ieee80211.h"
62 #include "shill/net/ip_address.h"
63 #include "shill/net/mock_netlink_manager.h"
64 #include "shill/net/mock_rtnl_handler.h"
65 #include "shill/net/mock_time.h"
66 #include "shill/net/netlink_message_matchers.h"
67 #include "shill/net/netlink_packet.h"
68 #include "shill/net/nl80211_attribute.h"
69 #include "shill/net/nl80211_message.h"
70 #include "shill/nice_mock_control.h"
71 #include "shill/property_store_unittest.h"
72 #include "shill/supplicant/mock_supplicant_bss_proxy.h"
73 #include "shill/supplicant/mock_supplicant_eap_state_handler.h"
74 #include "shill/supplicant/mock_supplicant_interface_proxy.h"
75 #include "shill/supplicant/mock_supplicant_network_proxy.h"
76 #include "shill/supplicant/mock_supplicant_process_proxy.h"
77 #include "shill/supplicant/wpa_supplicant.h"
78 #include "shill/technology.h"
79 #include "shill/test_event_dispatcher.h"
80 #include "shill/testing.h"
81 #include "shill/wifi/mock_mac80211_monitor.h"
82 #include "shill/wifi/mock_scan_session.h"
83 #include "shill/wifi/mock_tdls_manager.h"
84 #include "shill/wifi/mock_wake_on_wifi.h"
85 #include "shill/wifi/mock_wifi_provider.h"
86 #include "shill/wifi/mock_wifi_service.h"
87 #include "shill/wifi/scan_session.h"
88 #include "shill/wifi/wake_on_wifi.h"
89 #include "shill/wifi/wifi_endpoint.h"
90 #include "shill/wifi/wifi_service.h"
91 
92 using base::FilePath;
93 using base::StringPrintf;
94 using std::map;
95 using std::set;
96 using std::string;
97 using std::unique_ptr;
98 using std::vector;
99 using ::testing::_;
100 using ::testing::AnyNumber;
101 using ::testing::AtLeast;
102 using ::testing::ContainsRegex;
103 using ::testing::DefaultValue;
104 using ::testing::DoAll;
105 using ::testing::EndsWith;
106 using ::testing::HasSubstr;
107 using ::testing::InSequence;
108 using ::testing::Invoke;
109 using ::testing::InvokeWithoutArgs;
110 using ::testing::MakeMatcher;
111 using ::testing::Matcher;
112 using ::testing::MatcherInterface;
113 using ::testing::MatchResultListener;
114 using ::testing::Mock;
115 using ::testing::NiceMock;
116 using ::testing::NotNull;
117 using ::testing::Ref;
118 using ::testing::Return;
119 using ::testing::ReturnNew;
120 using ::testing::ReturnRef;
121 using ::testing::SaveArg;
122 using ::testing::SetArgumentPointee;
123 using ::testing::StrEq;
124 using ::testing::StrictMock;
125 using ::testing::Test;
126 using ::testing::Values;
127 
128 namespace shill {
129 
130 namespace {
131 
132 const uint16_t kNl80211FamilyId = 0x13;
133 const uint16_t kRandomScanFrequency1 = 5600;
134 const uint16_t kRandomScanFrequency2 = 5560;
135 const uint16_t kRandomScanFrequency3 = 2422;
136 const int kInterfaceIndex = 1234;
137 
138 // Bytes representing a NL80211_CMD_NEW_WIPHY message reporting the WiFi
139 // capabilities of a NIC with wiphy index |kNewWiphyNlMsg_WiphyIndex| which
140 // supports operating bands with the frequencies specified in
141 // |kNewWiphyNlMsg_UniqueFrequencies|.
142 const uint8_t kNewWiphyNlMsg[] = {
143     0x68, 0x0c, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
144     0xf6, 0x31, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00,
145     0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x02, 0x00, 0x70, 0x68, 0x79, 0x30,
146     0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x2e, 0x00, 0x01, 0x00, 0x00, 0x00,
147     0x05, 0x00, 0x3d, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x3e, 0x00,
148     0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x3f, 0x00, 0xff, 0xff, 0xff, 0xff,
149     0x08, 0x00, 0x40, 0x00, 0xff, 0xff, 0xff, 0xff, 0x05, 0x00, 0x59, 0x00,
150     0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x00, 0x00,
151     0x05, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x38, 0x00,
152     0xd1, 0x08, 0x00, 0x00, 0x06, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00,
153     0x05, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x68, 0x00,
154     0x04, 0x00, 0x8b, 0x00, 0x04, 0x00, 0x8c, 0x00, 0x18, 0x00, 0x39, 0x00,
155     0x01, 0xac, 0x0f, 0x00, 0x05, 0xac, 0x0f, 0x00, 0x02, 0xac, 0x0f, 0x00,
156     0x04, 0xac, 0x0f, 0x00, 0x06, 0xac, 0x0f, 0x00, 0x05, 0x00, 0x56, 0x00,
157     0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x66, 0x00, 0x08, 0x00, 0x71, 0x00,
158     0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x72, 0x00, 0x03, 0x00, 0x00, 0x00,
159     0x08, 0x00, 0x69, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x6a, 0x00,
160     0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x20, 0x00, 0x04, 0x00, 0x01, 0x00,
161     0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
162     0x04, 0x00, 0x05, 0x00, 0x04, 0x00, 0x06, 0x00, 0x04, 0x00, 0x08, 0x00,
163     0x04, 0x00, 0x09, 0x00, 0x50, 0x05, 0x16, 0x00, 0xf8, 0x01, 0x00, 0x00,
164     0x14, 0x00, 0x03, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
165     0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x04, 0x00,
166     0xef, 0x11, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00,
167     0x05, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0x28, 0x01, 0x01, 0x00,
168     0x14, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x6c, 0x09, 0x00, 0x00,
169     0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00,
170     0x08, 0x00, 0x01, 0x00, 0x71, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00,
171     0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x08, 0x00, 0x01, 0x00,
172     0x76, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00,
173     0x14, 0x00, 0x03, 0x00, 0x08, 0x00, 0x01, 0x00, 0x7b, 0x09, 0x00, 0x00,
174     0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x04, 0x00,
175     0x08, 0x00, 0x01, 0x00, 0x80, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00,
176     0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x05, 0x00, 0x08, 0x00, 0x01, 0x00,
177     0x85, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00,
178     0x14, 0x00, 0x06, 0x00, 0x08, 0x00, 0x01, 0x00, 0x8a, 0x09, 0x00, 0x00,
179     0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x07, 0x00,
180     0x08, 0x00, 0x01, 0x00, 0x8f, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00,
181     0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x08, 0x00, 0x08, 0x00, 0x01, 0x00,
182     0x94, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00,
183     0x14, 0x00, 0x09, 0x00, 0x08, 0x00, 0x01, 0x00, 0x99, 0x09, 0x00, 0x00,
184     0x08, 0x00, 0x06, 0x00, 0x6c, 0x07, 0x00, 0x00, 0x14, 0x00, 0x0a, 0x00,
185     0x08, 0x00, 0x01, 0x00, 0x9e, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00,
186     0x6c, 0x07, 0x00, 0x00, 0x18, 0x00, 0x0b, 0x00, 0x08, 0x00, 0x01, 0x00,
187     0xa3, 0x09, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x08, 0x00, 0x06, 0x00,
188     0x6c, 0x07, 0x00, 0x00, 0x18, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00,
189     0xa8, 0x09, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x08, 0x00, 0x06, 0x00,
190     0x6c, 0x07, 0x00, 0x00, 0x18, 0x00, 0x0d, 0x00, 0x08, 0x00, 0x01, 0x00,
191     0xb4, 0x09, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x08, 0x00, 0x06, 0x00,
192     0xd0, 0x07, 0x00, 0x00, 0xa0, 0x00, 0x02, 0x00, 0x0c, 0x00, 0x00, 0x00,
193     0x08, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x10, 0x00, 0x01, 0x00,
194     0x08, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00,
195     0x10, 0x00, 0x02, 0x00, 0x08, 0x00, 0x01, 0x00, 0x37, 0x00, 0x00, 0x00,
196     0x04, 0x00, 0x02, 0x00, 0x10, 0x00, 0x03, 0x00, 0x08, 0x00, 0x01, 0x00,
197     0x6e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x0c, 0x00, 0x04, 0x00,
198     0x08, 0x00, 0x01, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x05, 0x00,
199     0x08, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00,
200     0x08, 0x00, 0x01, 0x00, 0x78, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00,
201     0x08, 0x00, 0x01, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00,
202     0x08, 0x00, 0x01, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x09, 0x00,
203     0x08, 0x00, 0x01, 0x00, 0x68, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x0a, 0x00,
204     0x08, 0x00, 0x01, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x0b, 0x00,
205     0x08, 0x00, 0x01, 0x00, 0x1c, 0x02, 0x00, 0x00, 0x54, 0x03, 0x01, 0x00,
206     0x14, 0x00, 0x03, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
207     0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x04, 0x00,
208     0xef, 0x11, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00,
209     0x05, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0xc0, 0x02, 0x01, 0x00,
210     0x14, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x3c, 0x14, 0x00, 0x00,
211     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x1c, 0x00, 0x01, 0x00,
212     0x08, 0x00, 0x01, 0x00, 0x50, 0x14, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
213     0x04, 0x00, 0x04, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
214     0x14, 0x00, 0x02, 0x00, 0x08, 0x00, 0x01, 0x00, 0x64, 0x14, 0x00, 0x00,
215     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x14, 0x00, 0x03, 0x00,
216     0x08, 0x00, 0x01, 0x00, 0x78, 0x14, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00,
217     0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x01, 0x00,
218     0x8c, 0x14, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
219     0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
220     0x20, 0x00, 0x05, 0x00, 0x08, 0x00, 0x01, 0x00, 0xa0, 0x14, 0x00, 0x00,
221     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00,
222     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x06, 0x00,
223     0x08, 0x00, 0x01, 0x00, 0xb4, 0x14, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
224     0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00,
225     0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x07, 0x00, 0x08, 0x00, 0x01, 0x00,
226     0xc8, 0x14, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
227     0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
228     0x20, 0x00, 0x08, 0x00, 0x08, 0x00, 0x01, 0x00, 0x7c, 0x15, 0x00, 0x00,
229     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00,
230     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x09, 0x00,
231     0x08, 0x00, 0x01, 0x00, 0x90, 0x15, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
232     0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00,
233     0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x0a, 0x00, 0x08, 0x00, 0x01, 0x00,
234     0xa4, 0x15, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
235     0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
236     0x20, 0x00, 0x0b, 0x00, 0x08, 0x00, 0x01, 0x00, 0xb8, 0x15, 0x00, 0x00,
237     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00,
238     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x0c, 0x00,
239     0x08, 0x00, 0x01, 0x00, 0xcc, 0x15, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
240     0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00,
241     0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x0d, 0x00, 0x08, 0x00, 0x01, 0x00,
242     0xe0, 0x15, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
243     0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
244     0x20, 0x00, 0x0e, 0x00, 0x08, 0x00, 0x01, 0x00, 0xf4, 0x15, 0x00, 0x00,
245     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00,
246     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x0f, 0x00,
247     0x08, 0x00, 0x01, 0x00, 0x08, 0x16, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
248     0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00,
249     0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x10, 0x00, 0x08, 0x00, 0x01, 0x00,
250     0x1c, 0x16, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
251     0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
252     0x20, 0x00, 0x11, 0x00, 0x08, 0x00, 0x01, 0x00, 0x30, 0x16, 0x00, 0x00,
253     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00,
254     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x20, 0x00, 0x12, 0x00,
255     0x08, 0x00, 0x01, 0x00, 0x44, 0x16, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
256     0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00,
257     0xd0, 0x07, 0x00, 0x00, 0x14, 0x00, 0x13, 0x00, 0x08, 0x00, 0x01, 0x00,
258     0x71, 0x16, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
259     0x1c, 0x00, 0x14, 0x00, 0x08, 0x00, 0x01, 0x00, 0x85, 0x16, 0x00, 0x00,
260     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x08, 0x00, 0x06, 0x00,
261     0xd0, 0x07, 0x00, 0x00, 0x1c, 0x00, 0x15, 0x00, 0x08, 0x00, 0x01, 0x00,
262     0x99, 0x16, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
263     0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00, 0x1c, 0x00, 0x16, 0x00,
264     0x08, 0x00, 0x01, 0x00, 0xad, 0x16, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00,
265     0x04, 0x00, 0x04, 0x00, 0x08, 0x00, 0x06, 0x00, 0xd0, 0x07, 0x00, 0x00,
266     0x1c, 0x00, 0x17, 0x00, 0x08, 0x00, 0x01, 0x00, 0xc1, 0x16, 0x00, 0x00,
267     0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x08, 0x00, 0x06, 0x00,
268     0xd0, 0x07, 0x00, 0x00, 0x64, 0x00, 0x02, 0x00, 0x0c, 0x00, 0x00, 0x00,
269     0x08, 0x00, 0x01, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00,
270     0x08, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x02, 0x00,
271     0x08, 0x00, 0x01, 0x00, 0x78, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x03, 0x00,
272     0x08, 0x00, 0x01, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x04, 0x00,
273     0x08, 0x00, 0x01, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x05, 0x00,
274     0x08, 0x00, 0x01, 0x00, 0x68, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00,
275     0x08, 0x00, 0x01, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00,
276     0x08, 0x00, 0x01, 0x00, 0x1c, 0x02, 0x00, 0x00, 0xd4, 0x00, 0x32, 0x00,
277     0x08, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00,
278     0x06, 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x00, 0x00,
279     0x08, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00,
280     0x13, 0x00, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00, 0x19, 0x00, 0x00, 0x00,
281     0x08, 0x00, 0x07, 0x00, 0x25, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00,
282     0x26, 0x00, 0x00, 0x00, 0x08, 0x00, 0x09, 0x00, 0x27, 0x00, 0x00, 0x00,
283     0x08, 0x00, 0x0a, 0x00, 0x28, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0b, 0x00,
284     0x2b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x37, 0x00, 0x00, 0x00,
285     0x08, 0x00, 0x0d, 0x00, 0x39, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0e, 0x00,
286     0x3b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0f, 0x00, 0x43, 0x00, 0x00, 0x00,
287     0x08, 0x00, 0x10, 0x00, 0x31, 0x00, 0x00, 0x00, 0x08, 0x00, 0x11, 0x00,
288     0x41, 0x00, 0x00, 0x00, 0x08, 0x00, 0x12, 0x00, 0x42, 0x00, 0x00, 0x00,
289     0x08, 0x00, 0x13, 0x00, 0x52, 0x00, 0x00, 0x00, 0x08, 0x00, 0x14, 0x00,
290     0x51, 0x00, 0x00, 0x00, 0x08, 0x00, 0x15, 0x00, 0x54, 0x00, 0x00, 0x00,
291     0x08, 0x00, 0x16, 0x00, 0x57, 0x00, 0x00, 0x00, 0x08, 0x00, 0x17, 0x00,
292     0x55, 0x00, 0x00, 0x00, 0x08, 0x00, 0x18, 0x00, 0x2d, 0x00, 0x00, 0x00,
293     0x08, 0x00, 0x19, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x08, 0x00, 0x1a, 0x00,
294     0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x6f, 0x00, 0x88, 0x13, 0x00, 0x00,
295     0x04, 0x00, 0x6c, 0x00, 0xac, 0x03, 0x63, 0x00, 0x04, 0x00, 0x00, 0x00,
296     0x84, 0x00, 0x01, 0x00, 0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
297     0x06, 0x00, 0x65, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
298     0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00,
299     0x06, 0x00, 0x65, 0x00, 0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
300     0x50, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00,
301     0x06, 0x00, 0x65, 0x00, 0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
302     0x80, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00,
303     0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
304     0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00,
305     0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
306     0xe0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00,
307     0x84, 0x00, 0x02, 0x00, 0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
308     0x06, 0x00, 0x65, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
309     0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00,
310     0x06, 0x00, 0x65, 0x00, 0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
311     0x50, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00,
312     0x06, 0x00, 0x65, 0x00, 0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
313     0x80, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00,
314     0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
315     0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00,
316     0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
317     0xe0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00,
318     0x84, 0x00, 0x03, 0x00, 0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
319     0x06, 0x00, 0x65, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
320     0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00,
321     0x06, 0x00, 0x65, 0x00, 0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
322     0x50, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00,
323     0x06, 0x00, 0x65, 0x00, 0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
324     0x80, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00,
325     0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
326     0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00,
327     0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
328     0xe0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00,
329     0x84, 0x00, 0x04, 0x00, 0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
330     0x06, 0x00, 0x65, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
331     0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00,
332     0x06, 0x00, 0x65, 0x00, 0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
333     0x50, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00,
334     0x06, 0x00, 0x65, 0x00, 0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
335     0x80, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00,
336     0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
337     0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00,
338     0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
339     0xe0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00,
340     0x04, 0x00, 0x05, 0x00, 0x04, 0x00, 0x06, 0x00, 0x84, 0x00, 0x07, 0x00,
341     0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
342     0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x20, 0x00, 0x00, 0x00,
343     0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
344     0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x50, 0x00, 0x00, 0x00,
345     0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
346     0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x80, 0x00, 0x00, 0x00,
347     0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
348     0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xb0, 0x00, 0x00, 0x00,
349     0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
350     0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xe0, 0x00, 0x00, 0x00,
351     0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x84, 0x00, 0x08, 0x00,
352     0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
353     0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x20, 0x00, 0x00, 0x00,
354     0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
355     0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x50, 0x00, 0x00, 0x00,
356     0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
357     0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x80, 0x00, 0x00, 0x00,
358     0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
359     0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xb0, 0x00, 0x00, 0x00,
360     0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
361     0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xe0, 0x00, 0x00, 0x00,
362     0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x84, 0x00, 0x09, 0x00,
363     0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
364     0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x20, 0x00, 0x00, 0x00,
365     0x06, 0x00, 0x65, 0x00, 0x30, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
366     0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x50, 0x00, 0x00, 0x00,
367     0x06, 0x00, 0x65, 0x00, 0x60, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
368     0x70, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x80, 0x00, 0x00, 0x00,
369     0x06, 0x00, 0x65, 0x00, 0x90, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
370     0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xb0, 0x00, 0x00, 0x00,
371     0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
372     0xd0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xe0, 0x00, 0x00, 0x00,
373     0x06, 0x00, 0x65, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x14, 0x01, 0x64, 0x00,
374     0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x06, 0x00, 0x65, 0x00,
375     0xd0, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, 0x06, 0x00, 0x65, 0x00,
376     0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00,
377     0x3c, 0x00, 0x03, 0x00, 0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
378     0x06, 0x00, 0x65, 0x00, 0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
379     0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00,
380     0x06, 0x00, 0x65, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
381     0xc0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00,
382     0x3c, 0x00, 0x04, 0x00, 0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00,
383     0x06, 0x00, 0x65, 0x00, 0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
384     0x40, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00,
385     0x06, 0x00, 0x65, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
386     0xc0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00,
387     0x04, 0x00, 0x05, 0x00, 0x04, 0x00, 0x06, 0x00, 0x1c, 0x00, 0x07, 0x00,
388     0x06, 0x00, 0x65, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
389     0xc0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00,
390     0x14, 0x00, 0x08, 0x00, 0x06, 0x00, 0x65, 0x00, 0x40, 0x00, 0x00, 0x00,
391     0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x09, 0x00,
392     0x06, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
393     0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0x40, 0x00, 0x00, 0x00,
394     0x06, 0x00, 0x65, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00,
395     0xb0, 0x00, 0x00, 0x00, 0x06, 0x00, 0x65, 0x00, 0xc0, 0x00, 0x00, 0x00,
396     0x06, 0x00, 0x65, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x79, 0x00,
397     0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x06, 0x00, 0x50, 0x00, 0x78, 0x00,
398     0x4c, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00, 0x1c, 0x00, 0x01, 0x00,
399     0x08, 0x00, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0x02, 0x00,
400     0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x05, 0x00, 0x04, 0x00, 0x08, 0x00,
401     0x18, 0x00, 0x02, 0x00, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
402     0x0c, 0x00, 0x02, 0x00, 0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x09, 0x00,
403     0x08, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00,
404     0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x8f, 0x00, 0x03, 0x00, 0x00, 0x00,
405     0x1e, 0x00, 0x94, 0x00, 0x42, 0x08, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff,
406     0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
407     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
408 const uint32_t kNewWiphyNlMsg_WiphyIndex = 2;
409 const int kNewWiphyNlMsg_Nl80211AttrWiphyOffset = 4;
410 const uint16_t kNewWiphyNlMsg_UniqueFrequencies[] = {
411     2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457,
412     2462, 2467, 2472, 2484, 5180, 5200, 5220, 5240, 5260, 5280,
413     5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640,
414     5660, 5680, 5700, 5745, 5765, 5785, 5805, 5825};
415 
416 const uint32_t kScanTriggerMsgWiphyIndex = 0;
417 const uint8_t kActiveScanTriggerNlMsg[] = {
418     0x44, 0x01, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419     0x00, 0x00, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00,
420     0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
421     0x0c, 0x00, 0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
422     0x08, 0x00, 0x2d, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x2c, 0x00,
423     0x08, 0x00, 0x00, 0x00, 0x6c, 0x09, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00,
424     0x71, 0x09, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00, 0x76, 0x09, 0x00, 0x00,
425     0x08, 0x00, 0x03, 0x00, 0x7b, 0x09, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00,
426     0x80, 0x09, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x85, 0x09, 0x00, 0x00,
427     0x08, 0x00, 0x06, 0x00, 0x8a, 0x09, 0x00, 0x00, 0x08, 0x00, 0x07, 0x00,
428     0x8f, 0x09, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x94, 0x09, 0x00, 0x00,
429     0x08, 0x00, 0x09, 0x00, 0x99, 0x09, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00,
430     0x9e, 0x09, 0x00, 0x00, 0x08, 0x00, 0x0b, 0x00, 0x3c, 0x14, 0x00, 0x00,
431     0x08, 0x00, 0x0c, 0x00, 0x50, 0x14, 0x00, 0x00, 0x08, 0x00, 0x0d, 0x00,
432     0x64, 0x14, 0x00, 0x00, 0x08, 0x00, 0x0e, 0x00, 0x78, 0x14, 0x00, 0x00,
433     0x08, 0x00, 0x0f, 0x00, 0x8c, 0x14, 0x00, 0x00, 0x08, 0x00, 0x10, 0x00,
434     0xa0, 0x14, 0x00, 0x00, 0x08, 0x00, 0x11, 0x00, 0xb4, 0x14, 0x00, 0x00,
435     0x08, 0x00, 0x12, 0x00, 0xc8, 0x14, 0x00, 0x00, 0x08, 0x00, 0x13, 0x00,
436     0x7c, 0x15, 0x00, 0x00, 0x08, 0x00, 0x14, 0x00, 0x90, 0x15, 0x00, 0x00,
437     0x08, 0x00, 0x15, 0x00, 0xa4, 0x15, 0x00, 0x00, 0x08, 0x00, 0x16, 0x00,
438     0xb8, 0x15, 0x00, 0x00, 0x08, 0x00, 0x17, 0x00, 0xcc, 0x15, 0x00, 0x00,
439     0x08, 0x00, 0x18, 0x00, 0x1c, 0x16, 0x00, 0x00, 0x08, 0x00, 0x19, 0x00,
440     0x30, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1a, 0x00, 0x44, 0x16, 0x00, 0x00,
441     0x08, 0x00, 0x1b, 0x00, 0x58, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1c, 0x00,
442     0x71, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1d, 0x00, 0x85, 0x16, 0x00, 0x00,
443     0x08, 0x00, 0x1e, 0x00, 0x99, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1f, 0x00,
444     0xad, 0x16, 0x00, 0x00, 0x08, 0x00, 0x20, 0x00, 0xc1, 0x16, 0x00, 0x00};
445 
446 const uint8_t kPassiveScanTriggerNlMsg[] = {
447     0x40, 0x01, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
448     0x00, 0x00, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00,
449     0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
450     0x0c, 0x00, 0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
451     0x04, 0x00, 0x2d, 0x00, 0x0c, 0x01, 0x2c, 0x00, 0x08, 0x00, 0x00, 0x00,
452     0x6c, 0x09, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x71, 0x09, 0x00, 0x00,
453     0x08, 0x00, 0x02, 0x00, 0x76, 0x09, 0x00, 0x00, 0x08, 0x00, 0x03, 0x00,
454     0x7b, 0x09, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x80, 0x09, 0x00, 0x00,
455     0x08, 0x00, 0x05, 0x00, 0x85, 0x09, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00,
456     0x8a, 0x09, 0x00, 0x00, 0x08, 0x00, 0x07, 0x00, 0x8f, 0x09, 0x00, 0x00,
457     0x08, 0x00, 0x08, 0x00, 0x94, 0x09, 0x00, 0x00, 0x08, 0x00, 0x09, 0x00,
458     0x99, 0x09, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x9e, 0x09, 0x00, 0x00,
459     0x08, 0x00, 0x0b, 0x00, 0x3c, 0x14, 0x00, 0x00, 0x08, 0x00, 0x0c, 0x00,
460     0x50, 0x14, 0x00, 0x00, 0x08, 0x00, 0x0d, 0x00, 0x64, 0x14, 0x00, 0x00,
461     0x08, 0x00, 0x0e, 0x00, 0x78, 0x14, 0x00, 0x00, 0x08, 0x00, 0x0f, 0x00,
462     0x8c, 0x14, 0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0xa0, 0x14, 0x00, 0x00,
463     0x08, 0x00, 0x11, 0x00, 0xb4, 0x14, 0x00, 0x00, 0x08, 0x00, 0x12, 0x00,
464     0xc8, 0x14, 0x00, 0x00, 0x08, 0x00, 0x13, 0x00, 0x7c, 0x15, 0x00, 0x00,
465     0x08, 0x00, 0x14, 0x00, 0x90, 0x15, 0x00, 0x00, 0x08, 0x00, 0x15, 0x00,
466     0xa4, 0x15, 0x00, 0x00, 0x08, 0x00, 0x16, 0x00, 0xb8, 0x15, 0x00, 0x00,
467     0x08, 0x00, 0x17, 0x00, 0xcc, 0x15, 0x00, 0x00, 0x08, 0x00, 0x18, 0x00,
468     0x1c, 0x16, 0x00, 0x00, 0x08, 0x00, 0x19, 0x00, 0x30, 0x16, 0x00, 0x00,
469     0x08, 0x00, 0x1a, 0x00, 0x44, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1b, 0x00,
470     0x58, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1c, 0x00, 0x71, 0x16, 0x00, 0x00,
471     0x08, 0x00, 0x1d, 0x00, 0x85, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1e, 0x00,
472     0x99, 0x16, 0x00, 0x00, 0x08, 0x00, 0x1f, 0x00, 0xad, 0x16, 0x00, 0x00,
473     0x08, 0x00, 0x20, 0x00, 0xc1, 0x16, 0x00, 0x00};
474 
475 }  // namespace
476 
477 class WiFiPropertyTest : public PropertyStoreTest {
478  public:
WiFiPropertyTest()479   WiFiPropertyTest()
480       : metrics_(nullptr),
481         device_(
482             new WiFi(control_interface(), dispatcher(), &metrics_,
483                      manager(), "wifi", "", kInterfaceIndex)) {
484   }
~WiFiPropertyTest()485   virtual ~WiFiPropertyTest() {}
486 
487  protected:
488   MockMetrics metrics_;
489   WiFiRefPtr device_;
490 };
491 
TEST_F(WiFiPropertyTest,Contains)492 TEST_F(WiFiPropertyTest, Contains) {
493   EXPECT_TRUE(device_->store().Contains(kNameProperty));
494   EXPECT_FALSE(device_->store().Contains(""));
495 }
496 
TEST_F(WiFiPropertyTest,SetProperty)497 TEST_F(WiFiPropertyTest, SetProperty) {
498   {
499     Error error;
500     EXPECT_TRUE(device_->mutable_store()->SetAnyProperty(
501         kBgscanSignalThresholdProperty, PropertyStoreTest::kInt32V, &error));
502   }
503   {
504     Error error;
505     EXPECT_TRUE(device_->mutable_store()->SetAnyProperty(
506         kScanIntervalProperty, PropertyStoreTest::kUint16V, &error));
507   }
508   // Ensure that an attempt to write a R/O property returns InvalidArgs error.
509   {
510     Error error;
511     EXPECT_FALSE(device_->mutable_store()->SetAnyProperty(
512         kScanningProperty, PropertyStoreTest::kBoolV, &error));
513     ASSERT_TRUE(error.IsFailure());
514     EXPECT_EQ(Error::kInvalidArguments, error.type());
515   }
516 
517   {
518     Error error;
519     EXPECT_TRUE(device_->mutable_store()->SetAnyProperty(
520         kBgscanMethodProperty,
521         brillo::Any(string(WPASupplicant::kNetworkBgscanMethodSimple)),
522         &error));
523   }
524 
525   {
526     Error error;
527     EXPECT_FALSE(device_->mutable_store()->SetAnyProperty(
528         kBgscanMethodProperty,
529         brillo::Any(string("not a real scan method")),
530         &error));
531   }
532 }
533 
TEST_F(WiFiPropertyTest,BgscanMethodProperty)534 TEST_F(WiFiPropertyTest, BgscanMethodProperty) {
535   EXPECT_NE(WPASupplicant::kNetworkBgscanMethodLearn,
536             WiFi::kDefaultBgscanMethod);
537   EXPECT_TRUE(device_->bgscan_method_.empty());
538 
539   string method;
540   Error unused_error;
541   EXPECT_TRUE(device_->store().GetStringProperty(
542       kBgscanMethodProperty, &method, &unused_error));
543   EXPECT_EQ(WiFi::kDefaultBgscanMethod, method);
544   EXPECT_EQ(WPASupplicant::kNetworkBgscanMethodSimple, method);
545 
546   Error error;
547   EXPECT_TRUE(device_->mutable_store()->SetAnyProperty(
548       kBgscanMethodProperty,
549       brillo::Any(string(WPASupplicant::kNetworkBgscanMethodLearn)),
550       &error));
551   EXPECT_EQ(WPASupplicant::kNetworkBgscanMethodLearn, device_->bgscan_method_);
552   EXPECT_TRUE(device_->store().GetStringProperty(
553       kBgscanMethodProperty, &method, &unused_error));
554   EXPECT_EQ(WPASupplicant::kNetworkBgscanMethodLearn, method);
555 
556   EXPECT_TRUE(device_->mutable_store()->ClearProperty(
557       kBgscanMethodProperty, &error));
558   EXPECT_TRUE(device_->store().GetStringProperty(
559       kBgscanMethodProperty, &method, &unused_error));
560   EXPECT_EQ(WiFi::kDefaultBgscanMethod, method);
561   EXPECT_TRUE(device_->bgscan_method_.empty());
562 }
563 
564 MATCHER_P(EndpointMatch, endpoint, "") {
565   return
566       arg->ssid() == endpoint->ssid() &&
567       arg->network_mode() == endpoint->network_mode() &&
568       arg->security_mode() == endpoint->security_mode();
569 }
570 
571 
572 class WiFiObjectTest : public ::testing::TestWithParam<string> {
573  public:
574   // Note: When this constructor is called (via the initialization lists in the
575   // constructors of WiFiMainTest and WiFiTimerTest), |dispatcher| will point to
576   // an uninitialized EventDispatcher. Any functions (including constructors in
577   // the initialization list) that use the message loop should not be called in
578   // this constructor, since the delayed initialization of the message loop can
579   // cause concurrency-related bugs. (See crbug.com/509138 for an example.)
WiFiObjectTest(EventDispatcher * dispatcher)580   explicit WiFiObjectTest(EventDispatcher* dispatcher)
581       : event_dispatcher_(dispatcher),
582         metrics_(nullptr),
583         manager_(&control_interface_, nullptr, &metrics_),
584         device_info_(&control_interface_, dispatcher, &metrics_, &manager_),
585         wifi_(new WiFi(&control_interface_, dispatcher, &metrics_, &manager_,
586                        kDeviceName, kDeviceAddress, kInterfaceIndex)),
587         bss_counter_(0),
588         mac80211_monitor_(new StrictMock<MockMac80211Monitor>(
589             dispatcher, kDeviceName, WiFi::kStuckQueueLengthThreshold,
590             base::Closure(), &metrics_)),
591         supplicant_process_proxy_(new NiceMock<MockSupplicantProcessProxy>()),
592         supplicant_bss_proxy_(new NiceMock<MockSupplicantBSSProxy>()),
593         dhcp_config_(new MockDHCPConfig(&control_interface_, kDeviceName)),
594         adaptor_(new DeviceMockAdaptor()),
595         eap_state_handler_(new NiceMock<MockSupplicantEAPStateHandler>()),
596         supplicant_interface_proxy_(
597             new NiceMock<MockSupplicantInterfaceProxy>()),
598         supplicant_network_proxy_(new NiceMock<MockSupplicantNetworkProxy>()) {
599     wifi_->mac80211_monitor_.reset(mac80211_monitor_);
600     wifi_->supplicant_process_proxy_.reset(supplicant_process_proxy_);
601     InstallMockScanSession();
602     ON_CALL(*supplicant_process_proxy_, CreateInterface(_, _))
603         .WillByDefault(DoAll(SetArgumentPointee<1>(string("/default/path")),
604                              Return(true)));
605     ON_CALL(*supplicant_process_proxy_, GetInterface(_, _))
606         .WillByDefault(DoAll(SetArgumentPointee<1>(string("/default/path")),
607                              Return(true)));
608     ON_CALL(*supplicant_interface_proxy_.get(), AddNetwork(_, _))
609         .WillByDefault(DoAll(SetArgumentPointee<1>(string("/default/path")),
610                              Return(true)));
611     ON_CALL(*supplicant_interface_proxy_.get(), Disconnect())
612         .WillByDefault(Return(true));
613     ON_CALL(*supplicant_interface_proxy_.get(), RemoveNetwork(_))
614         .WillByDefault(Return(true));
615     ON_CALL(*supplicant_interface_proxy_.get(), Scan(_))
616         .WillByDefault(Return(true));
617     ON_CALL(*supplicant_network_proxy_.get(), SetEnabled(_))
618         .WillByDefault(Return(true));
619 
620     EXPECT_CALL(*mac80211_monitor_, UpdateConnectedState(_))
621         .Times(AnyNumber());
622 
623     ON_CALL(dhcp_provider_, CreateIPv4Config(_, _, _, _))
624         .WillByDefault(Return(dhcp_config_));
625     ON_CALL(*dhcp_config_.get(), RequestIP()).WillByDefault(Return(true));
626     ON_CALL(*manager(), IsSuspending()).WillByDefault(Return(false));
627 
628     ON_CALL(control_interface_, CreateSupplicantInterfaceProxy(_, _))
629         .WillByDefault(ReturnAndReleasePointee(&supplicant_interface_proxy_));
630     ON_CALL(control_interface_, CreateSupplicantBSSProxy(_, _))
631         .WillByDefault(ReturnAndReleasePointee(&supplicant_bss_proxy_));
632     ON_CALL(control_interface_, CreateSupplicantNetworkProxy(_))
633         .WillByDefault(ReturnAndReleasePointee(&supplicant_network_proxy_));
634     Nl80211Message::SetMessageType(kNl80211FamilyId);
635 
636     // Transfers ownership.
637     wifi_->eap_state_handler_.reset(eap_state_handler_);
638 
639     wifi_->provider_ = &wifi_provider_;
640     wifi_->time_ = &time_;
641     wifi_->netlink_manager_ = &netlink_manager_;
642     wifi_->progressive_scan_enabled_ = true;
643     wifi_->adaptor_.reset(adaptor_);  // Transfers ownership.
644 
645     // The following is only useful when a real |ScanSession| is used; it is
646     // ignored by |MockScanSession|.
647     wifi_->all_scan_frequencies_.insert(kRandomScanFrequency1);
648     wifi_->all_scan_frequencies_.insert(kRandomScanFrequency2);
649     wifi_->all_scan_frequencies_.insert(kRandomScanFrequency3);
650   }
651 
SetUp()652   virtual void SetUp() {
653     // EnableScopes... so that we can EXPECT_CALL for scoped log messages.
654     ScopeLogger::GetInstance()->EnableScopesByName("wifi");
655     ScopeLogger::GetInstance()->set_verbose_level(3);
656     static_cast<Device*>(wifi_.get())->rtnl_handler_ = &rtnl_handler_;
657     wifi_->set_dhcp_provider(&dhcp_provider_);
658     ON_CALL(manager_, device_info()).WillByDefault(Return(&device_info_));
659     EXPECT_CALL(manager_, UpdateEnabledTechnologies()).Times(AnyNumber());
660     EXPECT_CALL(*supplicant_bss_proxy_, Die()).Times(AnyNumber());
661     // Must be called here instead of in the constructor so that the destructor
662     // of SimpleAlarmTimer will not be invoked before the EventDispatcher is
663     // properly constructed (crbug.com/509138).
664     InstallMockWakeOnWiFi();
665   }
666 
TearDown()667   virtual void TearDown() {
668     EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(_))
669         .WillRepeatedly(Return(nullptr));
670     wifi_->SelectService(nullptr);
671     if (supplicant_bss_proxy_.get()) {
672       EXPECT_CALL(*supplicant_bss_proxy_, Die());
673     }
674     EXPECT_CALL(*mac80211_monitor_, Stop());
675     // must Stop WiFi instance, to clear its list of services.
676     // otherwise, the WiFi instance will not be deleted. (because
677     // services reference a WiFi instance, creating a cycle.)
678     wifi_->Stop(nullptr, ResultCallback());
679     wifi_->set_dhcp_provider(nullptr);
680     // Reset scope logging, to avoid interfering with other tests.
681     ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
682     ScopeLogger::GetInstance()->set_verbose_level(0);
683   }
684 
685   // Needs to be public since it is called via Invoke().
StopWiFi()686   void StopWiFi() {
687     EXPECT_CALL(*mac80211_monitor_, Stop());
688     wifi_->SetEnabled(false);  // Stop(nullptr, ResultCallback());
689   }
690 
ResetPendingService()691   void ResetPendingService() {
692     SetPendingService(nullptr);
693   }
694 
GetScanFrequencyCount() const695   size_t GetScanFrequencyCount() const {
696     return wifi_->all_scan_frequencies_.size();
697   }
698 
SetScanSize(int min,int max)699   void SetScanSize(int min, int max) {
700     wifi_->min_frequencies_to_scan_ = min;
701     wifi_->max_frequencies_to_scan_ = max;
702   }
703 
704   // This clears WiFi::scan_session_, thereby allowing WiFi::Scan to create a
705   // real scan session.
ClearScanSession()706   void ClearScanSession() {
707     wifi_->scan_session_.reset();
708   }
709 
IsScanSessionNull()710   bool IsScanSessionNull() {
711     return !wifi_->scan_session_;
712   }
713 
InstallMockScanSession()714   void InstallMockScanSession() {
715     WiFiProvider::FrequencyCountList previous_frequencies;
716     set<uint16_t> available_frequencies;
717     ScanSession::FractionList fractions;
718     ScanSession::OnScanFailed null_callback;
719     scan_session_ = new MockScanSession(&netlink_manager_,
720                                         event_dispatcher_,
721                                         previous_frequencies,
722                                         available_frequencies,
723                                         0,
724                                         fractions,
725                                         0,
726                                         0,
727                                         null_callback,
728                                         nullptr);
729     wifi_->scan_session_.reset(scan_session_);
730   }
731 
InstallMockWakeOnWiFi()732   void InstallMockWakeOnWiFi() {
733     wake_on_wifi_ = new MockWakeOnWiFi(&netlink_manager_, event_dispatcher_,
734                                        &metrics_);
735     wifi_->wake_on_wifi_.reset(wake_on_wifi_);
736   }
737 
738   // Or DisableProgressiveScan()...
EnableFullScan()739   void EnableFullScan() {
740     wifi_->progressive_scan_enabled_ = false;
741   }
742 
OnTriggerScanResponse(const Nl80211Message & message)743   void OnTriggerScanResponse(const Nl80211Message& message) {
744     wifi_->scan_session_->OnTriggerScanResponse(message);
745   }
746 
SetScanState(WiFi::ScanState new_state,WiFi::ScanMethod new_method,const char * reason)747   void SetScanState(WiFi::ScanState new_state,
748                     WiFi::ScanMethod new_method,
749                     const char* reason) {
750     wifi_->SetScanState(new_state, new_method, reason);
751   }
752 
VerifyScanState(WiFi::ScanState state,WiFi::ScanMethod method) const753   void VerifyScanState(WiFi::ScanState state, WiFi::ScanMethod method) const {
754     EXPECT_EQ(state, wifi_->scan_state_);
755     EXPECT_EQ(method, wifi_->scan_method_);
756   }
757 
SetRoamThresholdMember(uint16_t threshold)758   void SetRoamThresholdMember(uint16_t threshold) {
759     wifi_->roam_threshold_db_ = threshold;
760   }
761 
SetRoamThreshold(uint16_t threshold)762   bool SetRoamThreshold(uint16_t threshold) {
763     return wifi_->SetRoamThreshold(threshold, nullptr);
764   }
765 
GetRoamThreshold() const766   uint16_t GetRoamThreshold() const {
767     return wifi_->GetRoamThreshold(nullptr);
768   }
769 
770  protected:
771   typedef scoped_refptr<MockWiFiService> MockWiFiServiceRefPtr;
772 
773   // Simulate the course of events when the last endpoint of a service is
774   // removed.
775   class EndpointRemovalHandler {
776    public:
EndpointRemovalHandler(WiFiRefPtr wifi,const WiFiServiceRefPtr & service)777     EndpointRemovalHandler(WiFiRefPtr wifi, const WiFiServiceRefPtr& service)
778         : wifi_(wifi), service_(service) {}
~EndpointRemovalHandler()779     virtual ~EndpointRemovalHandler() {}
780 
OnEndpointRemoved(const WiFiEndpointConstRefPtr & endpoint)781     WiFiServiceRefPtr OnEndpointRemoved(
782         const WiFiEndpointConstRefPtr& endpoint) {
783       wifi_->DisassociateFromService(service_);
784       return service_;
785     }
786 
787    private:
788     WiFiRefPtr wifi_;
789     WiFiServiceRefPtr service_;
790   };
791 
MakeEndpointRemovalHandler(const WiFiServiceRefPtr & service)792   EndpointRemovalHandler* MakeEndpointRemovalHandler(
793       const WiFiServiceRefPtr& service) {
794     return new EndpointRemovalHandler(wifi_, service);
795   }
CancelScanTimer()796   void CancelScanTimer() {
797     wifi_->scan_timer_callback_.Cancel();
798   }
799   // This function creates a new endpoint with a mode set to |mode|.  We
800   // synthesize new |path| and |bssid| values, since we don't really care
801   // what they are for unit tests.  If "use_ssid" is true, we used the
802   // passed-in ssid, otherwise we create a synthesized value for it as well.
MakeNewEndpoint(const char * mode,bool use_ssid,string * ssid,string * path,string * bssid)803   WiFiEndpointRefPtr MakeNewEndpoint(const char* mode,
804                                      bool use_ssid,
805                                      string* ssid,
806                                      string* path,
807                                      string* bssid) {
808     bss_counter_++;
809     if (!use_ssid) {
810       *ssid = StringPrintf("ssid%d", bss_counter_);
811     }
812     *path = StringPrintf("/interface/bss%d", bss_counter_);
813     *bssid = StringPrintf("00:00:00:00:00:%02x", bss_counter_);
814     WiFiEndpointRefPtr endpoint = MakeEndpointWithMode(*ssid, *bssid, mode);
815     EXPECT_CALL(wifi_provider_,
816                 OnEndpointAdded(EndpointMatch(endpoint))).Times(1);
817     return endpoint;
818   }
MakeEndpoint(const string & ssid,const string & bssid)819   WiFiEndpointRefPtr MakeEndpoint(const string& ssid, const string& bssid) {
820     return MakeEndpointWithMode(ssid, bssid, kNetworkModeInfrastructure);
821   }
MakeEndpointWithMode(const string & ssid,const string & bssid,const string & mode)822   WiFiEndpointRefPtr MakeEndpointWithMode(
823       const string& ssid, const string& bssid, const string& mode) {
824     return WiFiEndpoint::MakeOpenEndpoint(
825         &control_interface_, nullptr, ssid, bssid, mode, 0, 0);
826   }
MakeMockServiceWithSSID(vector<uint8_t> ssid,const std::string & security)827   MockWiFiServiceRefPtr MakeMockServiceWithSSID(
828       vector<uint8_t> ssid, const std::string& security) {
829     return new NiceMock<MockWiFiService>(
830         &control_interface_,
831         event_dispatcher_,
832         &metrics_,
833         &manager_,
834         &wifi_provider_,
835         ssid,
836         kModeManaged,
837         security,
838         false);
839   }
MakeMockService(const std::string & security)840   MockWiFiServiceRefPtr MakeMockService(const std::string& security) {
841     return MakeMockServiceWithSSID(vector<uint8_t>(1, 'a'), security);
842   }
MakeNewEndpointAndService(int16_t signal_strength,uint16_t frequency,const char * mode,WiFiEndpointRefPtr * endpoint_ptr,MockWiFiServiceRefPtr * service_ptr)843   string MakeNewEndpointAndService(int16_t signal_strength,
844                                    uint16_t frequency,
845                                    const char* mode,
846                                    WiFiEndpointRefPtr* endpoint_ptr,
847                                    MockWiFiServiceRefPtr* service_ptr) {
848     string ssid;
849     string path;
850     string bssid;
851     WiFiEndpointRefPtr endpoint =
852         MakeNewEndpoint(mode, false, &ssid, &path, &bssid);
853     MockWiFiServiceRefPtr service =
854         MakeMockServiceWithSSID(endpoint->ssid(), endpoint->security_mode());
855     EXPECT_CALL(wifi_provider_, FindServiceForEndpoint(EndpointMatch(endpoint)))
856         .WillRepeatedly(Return(service));
857     ON_CALL(*service, GetEndpointCount()).WillByDefault(Return(1));
858     ReportBSS(path, ssid, bssid, signal_strength, frequency, mode);
859     if (service_ptr) {
860       *service_ptr = service;
861     }
862     if (endpoint_ptr) {
863       *endpoint_ptr = endpoint;
864     }
865     return path;
866   }
AddEndpointToService(WiFiServiceRefPtr service,int16_t signal_strength,uint16_t frequency,const char * mode,WiFiEndpointRefPtr * endpoint_ptr)867   string AddEndpointToService(
868       WiFiServiceRefPtr service,
869       int16_t signal_strength,
870       uint16_t frequency,
871       const char* mode,
872       WiFiEndpointRefPtr* endpoint_ptr) {
873     string ssid(service->ssid().begin(), service->ssid().end());
874     string path;
875     string bssid;
876     WiFiEndpointRefPtr endpoint =
877         MakeNewEndpoint(mode, true, &ssid, &path, &bssid);
878     EXPECT_CALL(wifi_provider_, FindServiceForEndpoint(EndpointMatch(endpoint)))
879         .WillRepeatedly(Return(service));
880     ReportBSS(path, ssid, bssid, signal_strength, frequency, mode);
881     if (endpoint_ptr) {
882       *endpoint_ptr = endpoint;
883     }
884     return path;
885   }
InitiateConnect(WiFiServiceRefPtr service)886   void InitiateConnect(WiFiServiceRefPtr service) {
887     wifi_->ConnectTo(service.get());
888   }
InitiateDisconnect(WiFiServiceRefPtr service)889   void InitiateDisconnect(WiFiServiceRefPtr service) {
890     wifi_->DisconnectFrom(service.get());
891   }
InitiateDisconnectIfActive(WiFiServiceRefPtr service)892   void InitiateDisconnectIfActive(WiFiServiceRefPtr service) {
893     wifi_->DisconnectFromIfActive(service.get());
894   }
SetupConnectingService(const string & network_path,WiFiEndpointRefPtr * endpoint_ptr,string * bss_path_ptr)895   MockWiFiServiceRefPtr SetupConnectingService(
896       const string& network_path,
897       WiFiEndpointRefPtr* endpoint_ptr,
898       string* bss_path_ptr) {
899     MockWiFiServiceRefPtr service;
900     WiFiEndpointRefPtr endpoint;
901     string bss_path(MakeNewEndpointAndService(
902         0, 0, kNetworkModeAdHoc, &endpoint, &service));
903     if (!network_path.empty()) {
904       EXPECT_CALL(*service, GetSupplicantConfigurationParameters());
905       EXPECT_CALL(*GetSupplicantInterfaceProxy(), AddNetwork(_, _))
906           .WillOnce(DoAll(SetArgumentPointee<1>(network_path), Return(true)));
907       EXPECT_CALL(*GetSupplicantInterfaceProxy(),
908                   SetHT40Enable(network_path, true));
909       EXPECT_CALL(*GetSupplicantInterfaceProxy(), SelectNetwork(network_path));
910     }
911     EXPECT_CALL(*service, SetState(Service::kStateAssociating));
912     InitiateConnect(service);
913     Mock::VerifyAndClearExpectations(service.get());
914     EXPECT_FALSE(GetPendingTimeout().IsCancelled());
915     if (endpoint_ptr) {
916       *endpoint_ptr = endpoint;
917     }
918     if (bss_path_ptr) {
919       *bss_path_ptr = bss_path;
920     }
921     return service;
922   }
923 
SetupConnectedService(const string & network_path,WiFiEndpointRefPtr * endpoint_ptr,string * bss_path_ptr)924   MockWiFiServiceRefPtr SetupConnectedService(
925       const string& network_path,
926       WiFiEndpointRefPtr* endpoint_ptr,
927       string* bss_path_ptr) {
928     WiFiEndpointRefPtr endpoint;
929     string bss_path;
930     MockWiFiServiceRefPtr service =
931         SetupConnectingService(network_path, &endpoint, &bss_path);
932     if (endpoint_ptr) {
933       *endpoint_ptr = endpoint;
934     }
935     if (bss_path_ptr) {
936       *bss_path_ptr = bss_path;
937     }
938     EXPECT_CALL(*service, NotifyCurrentEndpoint(EndpointMatch(endpoint)));
939     ReportCurrentBSSChanged(bss_path);
940     EXPECT_TRUE(GetPendingTimeout().IsCancelled());
941     Mock::VerifyAndClearExpectations(service.get());
942 
943     EXPECT_CALL(*service, SetState(Service::kStateConfiguring));
944     EXPECT_CALL(*service, ResetSuspectedCredentialFailures());
945     EXPECT_CALL(*dhcp_provider(), CreateIPv4Config(_, _, _, _))
946         .Times(AnyNumber());
947     EXPECT_CALL(*dhcp_config_.get(), RequestIP()).Times(AnyNumber());
948     EXPECT_CALL(wifi_provider_, IncrementConnectCount(_));
949     ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
950     Mock::VerifyAndClearExpectations(service.get());
951 
952     EXPECT_EQ(service, GetCurrentService());
953     return service;
954   }
955 
FireScanTimer()956   void FireScanTimer() {
957     wifi_->ScanTimerHandler();
958   }
TriggerScan(WiFi::ScanMethod method)959   void TriggerScan(WiFi::ScanMethod method) {
960     if (method == WiFi::kScanMethodFull) {
961       wifi_->Scan(Device::kFullScan, nullptr, __func__);
962     } else {
963       wifi_->Scan(Device::kProgressiveScan, nullptr, __func__);
964     }
965   }
GetCurrentService()966   const WiFiServiceRefPtr& GetCurrentService() {
967     return wifi_->current_service_;
968   }
SetCurrentService(const WiFiServiceRefPtr & service)969   void SetCurrentService(const WiFiServiceRefPtr& service) {
970     wifi_->current_service_ = service;
971   }
GetEndpointMap()972   const WiFi::EndpointMap& GetEndpointMap() {
973     return wifi_->endpoint_by_rpcid_;
974   }
GetPendingService()975   const WiFiServiceRefPtr& GetPendingService() {
976     return wifi_->pending_service_;
977   }
GetPendingTimeout()978   const base::CancelableClosure& GetPendingTimeout() {
979     return wifi_->pending_timeout_callback_;
980   }
GetReconnectTimeoutCallback()981   const base::CancelableClosure& GetReconnectTimeoutCallback() {
982     return wifi_->reconnect_timeout_callback_;
983   }
GetSelectedService()984   const ServiceRefPtr& GetSelectedService() {
985     return wifi_->selected_service();
986   }
GetSupplicantBSS()987   const string& GetSupplicantBSS() {
988     return wifi_->supplicant_bss_;
989   }
SetSupplicantBSS(const string & bss)990   void SetSupplicantBSS(const string& bss) {
991     wifi_->supplicant_bss_ = bss;
992   }
GetReconnectTimeoutSeconds()993   int GetReconnectTimeoutSeconds() {
994     return WiFi::kReconnectTimeoutSeconds;
995   }
GetScanTimer()996   const base::CancelableClosure& GetScanTimer() {
997     return wifi_->scan_timer_callback_;
998   }
999   // note: the tests need the proxies referenced by WiFi (not the
1000   // proxies instantiated by WiFiObjectTest), to ensure that WiFi
1001   // sets up its proxies correctly.
GetSupplicantProcessProxy()1002   SupplicantProcessProxyInterface* GetSupplicantProcessProxy() {
1003     return wifi_->supplicant_process_proxy_.get();
1004   }
GetSupplicantInterfaceProxyFromWiFi()1005   MockSupplicantInterfaceProxy* GetSupplicantInterfaceProxyFromWiFi() {
1006     return static_cast<MockSupplicantInterfaceProxy*>(
1007         wifi_->supplicant_interface_proxy_.get());
1008   }
1009   // This function returns the supplicant interface proxy whether
1010   // or not we have passed the instantiated object to the WiFi instance
1011   // from WiFiObjectTest, so tests don't need to worry about when they
1012   // set expectations relative to StartWiFi().
GetSupplicantInterfaceProxy()1013   MockSupplicantInterfaceProxy* GetSupplicantInterfaceProxy() {
1014     MockSupplicantInterfaceProxy* proxy = GetSupplicantInterfaceProxyFromWiFi();
1015     return proxy ? proxy : supplicant_interface_proxy_.get();
1016   }
GetSupplicantState()1017   const string& GetSupplicantState() {
1018     return wifi_->supplicant_state_;
1019   }
GetSupplicantDisconnectReason()1020   int GetSupplicantDisconnectReason() {
1021     return wifi_->supplicant_disconnect_reason_;
1022   }
ClearCachedCredentials(const WiFiService * service)1023   void ClearCachedCredentials(const WiFiService* service) {
1024     return wifi_->ClearCachedCredentials(service);
1025   }
NotifyEndpointChanged(const WiFiEndpointConstRefPtr & endpoint)1026   void NotifyEndpointChanged(const WiFiEndpointConstRefPtr& endpoint) {
1027     wifi_->NotifyEndpointChanged(endpoint);
1028   }
RemoveNetwork(const string & network)1029   bool RemoveNetwork(const string& network) {
1030     return wifi_->RemoveNetwork(network);
1031   }
1032   KeyValueStore CreateBSSProperties(const string& ssid,
1033                                     const string& bssid,
1034                                     int16_t signal_strength,
1035                                     uint16_t frequency,
1036                                     const char* mode);
1037   void RemoveBSS(const string& bss_path);
1038   void ReportBSS(const string& bss_path,
1039                  const string& ssid,
1040                  const string& bssid,
1041                  int16_t signal_strength,
1042                  uint16_t frequency,
1043                  const char* mode);
ReportIPConfigComplete()1044   void ReportIPConfigComplete() {
1045     wifi_->OnIPConfigUpdated(dhcp_config_, true);
1046   }
ReportIPConfigCompleteGatewayArpReceived()1047   void ReportIPConfigCompleteGatewayArpReceived() {
1048     wifi_->OnIPConfigUpdated(dhcp_config_, false);
1049   }
1050 
1051   // Calls the delayed version of the BSS methods.
BSSAdded(const string & bss_path,const KeyValueStore & properties)1052   void BSSAdded(const string& bss_path,
1053                 const KeyValueStore& properties) {
1054     wifi_->BSSAdded(bss_path, properties);
1055   }
BSSRemoved(const string & bss_path)1056   void BSSRemoved(const string& bss_path) {
1057     wifi_->BSSRemoved(bss_path);
1058   }
1059 
ReportIPv6ConfigComplete()1060   void ReportIPv6ConfigComplete() {
1061     wifi_->OnIPv6ConfigUpdated();
1062   }
ReportIPConfigFailure()1063   void ReportIPConfigFailure() {
1064     wifi_->OnIPConfigFailure();
1065   }
ReportConnected()1066   void ReportConnected() {
1067     wifi_->OnConnected();
1068   }
ReportLinkUp()1069   void ReportLinkUp() {
1070     wifi_->LinkEvent(IFF_LOWER_UP, IFF_LOWER_UP);
1071   }
ScanDone(const bool & success)1072   void ScanDone(const bool& success) {
1073     wifi_->ScanDone(success);
1074   }
ReportScanFailed()1075   void ReportScanFailed() {
1076     wifi_->ScanFailedTask();
1077   }
ReportScanDone()1078   void ReportScanDone() {
1079     // Eliminate |scan_session| so |ScanDoneTask| doesn't launch another scan.
1080     wifi_->scan_session_.reset();
1081     wifi_->ScanDoneTask();
1082     // Make a new |scan_session| so that future scanning is done with the mock.
1083     InstallMockScanSession();
1084   }
ReportScanDoneKeepScanSession()1085   void ReportScanDoneKeepScanSession() {
1086     wifi_->ScanDoneTask();
1087   }
ReportCurrentBSSChanged(const string & new_bss)1088   void ReportCurrentBSSChanged(const string& new_bss) {
1089     wifi_->CurrentBSSChanged(new_bss);
1090   }
ReportStateChanged(const string & new_state)1091   void ReportStateChanged(const string& new_state) {
1092     wifi_->StateChanged(new_state);
1093   }
ReportDisconnectReasonChanged(int reason)1094   void ReportDisconnectReasonChanged(int reason) {
1095     wifi_->DisconnectReasonChanged(reason);
1096   }
ReportWiFiDebugScopeChanged(bool enabled)1097   void ReportWiFiDebugScopeChanged(bool enabled) {
1098     wifi_->OnWiFiDebugScopeChanged(enabled);
1099   }
RequestStationInfo()1100   void RequestStationInfo() {
1101     wifi_->RequestStationInfo();
1102   }
ReportReceivedStationInfo(const Nl80211Message & nl80211_message)1103   void ReportReceivedStationInfo(const Nl80211Message& nl80211_message) {
1104     wifi_->OnReceivedStationInfo(nl80211_message);
1105   }
GetLinkStatistics()1106   KeyValueStore GetLinkStatistics() {
1107     return wifi_->GetLinkStatistics(nullptr);
1108   }
SetPendingService(const WiFiServiceRefPtr & service)1109   void SetPendingService(const WiFiServiceRefPtr& service) {
1110     wifi_->SetPendingService(service);
1111   }
SetServiceNetworkRpcId(const WiFiServiceRefPtr & service,const string & rpcid)1112   void SetServiceNetworkRpcId(
1113       const WiFiServiceRefPtr& service, const string& rpcid) {
1114     wifi_->rpcid_by_service_[service.get()] = rpcid;
1115   }
RpcIdByServiceIsEmpty()1116   bool RpcIdByServiceIsEmpty() {
1117     return wifi_->rpcid_by_service_.empty();
1118   }
SetScanInterval(uint16_t interval_seconds,Error * error)1119   bool SetScanInterval(uint16_t interval_seconds, Error* error) {
1120     return wifi_->SetScanInterval(interval_seconds, error);
1121   }
GetScanInterval()1122   uint16_t GetScanInterval() {
1123     return wifi_->GetScanInterval(nullptr);
1124   }
StartWiFi(bool supplicant_present)1125   void StartWiFi(bool supplicant_present) {
1126     EXPECT_CALL(netlink_manager_, SubscribeToEvents(
1127         Nl80211Message::kMessageTypeString,
1128         NetlinkManager::kEventTypeConfig));
1129     EXPECT_CALL(netlink_manager_, SubscribeToEvents(
1130         Nl80211Message::kMessageTypeString,
1131         NetlinkManager::kEventTypeScan));
1132     EXPECT_CALL(netlink_manager_, SubscribeToEvents(
1133         Nl80211Message::kMessageTypeString,
1134         NetlinkManager::kEventTypeRegulatory));
1135     EXPECT_CALL(netlink_manager_, SubscribeToEvents(
1136         Nl80211Message::kMessageTypeString,
1137         NetlinkManager::kEventTypeMlme));
1138     EXPECT_CALL(netlink_manager_, SendNl80211Message(
1139         IsNl80211Command(kNl80211FamilyId, NL80211_CMD_GET_WIPHY), _, _, _));
1140 
1141     wifi_->supplicant_present_ = supplicant_present;
1142     wifi_->SetEnabled(true);  // Start(nullptr, ResultCallback());
1143     if (supplicant_present)
1144       // Mimic the callback from |supplicant_process_proxy_|.
1145       wifi_->OnSupplicantAppear();
1146   }
StartWiFi()1147   void StartWiFi() {
1148     StartWiFi(true);
1149   }
OnAfterResume()1150   void OnAfterResume() {
1151     EXPECT_CALL(*wake_on_wifi_, OnAfterResume());
1152     wifi_->OnAfterResume();
1153   }
OnBeforeSuspend()1154   void OnBeforeSuspend() {
1155     ResultCallback callback(
1156         base::Bind(&WiFiObjectTest::SuspendCallback, base::Unretained(this)));
1157     wifi_->OnBeforeSuspend(callback);
1158   }
OnDarkResume()1159   void OnDarkResume() {
1160     ResultCallback callback(
1161         base::Bind(&WiFiObjectTest::SuspendCallback, base::Unretained(this)));
1162     wifi_->OnDarkResume(callback);
1163   }
RemoveSupplicantNetworks()1164   void RemoveSupplicantNetworks() {
1165     wifi_->RemoveSupplicantNetworks();
1166   }
InitiateScan(Device::ScanType scan_type)1167   void InitiateScan(Device::ScanType scan_type) {
1168     wifi_->InitiateScan(scan_type);
1169   }
InitiateScanInDarkResume(const WiFi::FreqSet & freqs)1170   void InitiateScanInDarkResume(const WiFi::FreqSet& freqs) {
1171     wifi_->InitiateScanInDarkResume(freqs);
1172   }
TriggerPassiveScan(const WiFi::FreqSet & freqs)1173   void TriggerPassiveScan(const WiFi::FreqSet& freqs) {
1174     wifi_->TriggerPassiveScan(freqs);
1175   }
OnSupplicantAppear()1176   void OnSupplicantAppear() {
1177     wifi_->OnSupplicantAppear();
1178     EXPECT_TRUE(wifi_->supplicant_present_);
1179   }
OnSupplicantVanish()1180   void OnSupplicantVanish() {
1181     wifi_->OnSupplicantVanish();
1182     EXPECT_FALSE(wifi_->supplicant_present_);
1183   }
GetSupplicantPresent()1184   bool GetSupplicantPresent() {
1185     return wifi_->supplicant_present_;
1186   }
GetIsRoamingInProgress()1187   bool GetIsRoamingInProgress() {
1188     return wifi_->is_roaming_in_progress_;
1189   }
SetIPConfig(const IPConfigRefPtr & ipconfig)1190   void SetIPConfig(const IPConfigRefPtr& ipconfig) {
1191     return wifi_->set_ipconfig(ipconfig);
1192   }
SetBgscanMethod(const string & method)1193   bool SetBgscanMethod(const string& method) {
1194     Error error;
1195     return wifi_->mutable_store()->SetAnyProperty(kBgscanMethodProperty,
1196                                                   brillo::Any(method),
1197                                                   &error);
1198   }
1199 
AppendBgscan(WiFiService * service,KeyValueStore * service_params)1200   void AppendBgscan(WiFiService* service,
1201                     KeyValueStore* service_params) {
1202     wifi_->AppendBgscan(service, service_params);
1203   }
1204 
ReportCertification(const KeyValueStore & properties)1205   void ReportCertification(const KeyValueStore& properties) {
1206     wifi_->CertificationTask(properties);
1207   }
1208 
ReportEAPEvent(const string & status,const string & parameter)1209   void ReportEAPEvent(const string& status, const string& parameter) {
1210     wifi_->EAPEventTask(status, parameter);
1211   }
1212 
RestartFastScanAttempts()1213   void RestartFastScanAttempts() {
1214     wifi_->RestartFastScanAttempts();
1215   }
1216 
SetFastScansRemaining(int num)1217   void SetFastScansRemaining(int num) {
1218     wifi_->fast_scans_remaining_ = num;
1219   }
1220 
StartReconnectTimer()1221   void StartReconnectTimer() {
1222     wifi_->StartReconnectTimer();
1223   }
1224 
StopReconnectTimer()1225   void StopReconnectTimer() {
1226     wifi_->StopReconnectTimer();
1227   }
1228 
SetLinkMonitor(LinkMonitor * link_monitor)1229   void SetLinkMonitor(LinkMonitor* link_monitor) {
1230     wifi_->set_link_monitor(link_monitor);
1231   }
1232 
SuspectCredentials(const WiFiServiceRefPtr & service,Service::ConnectFailure * failure)1233   bool SuspectCredentials(const WiFiServiceRefPtr& service,
1234                           Service::ConnectFailure* failure) {
1235     return wifi_->SuspectCredentials(service, failure);
1236   }
1237 
OnLinkMonitorFailure()1238   void OnLinkMonitorFailure() {
1239     wifi_->OnLinkMonitorFailure();
1240   }
1241 
OnUnreliableLink()1242   void OnUnreliableLink() {
1243     wifi_->OnUnreliableLink();
1244   }
1245 
SetBgscanShortInterval(const uint16_t & interval,Error * error)1246   bool SetBgscanShortInterval(const uint16_t& interval, Error* error) {
1247     return wifi_->SetBgscanShortInterval(interval, error);
1248   }
1249 
SetBgscanSignalThreshold(const int32_t & threshold,Error * error)1250   bool SetBgscanSignalThreshold(const int32_t& threshold, Error* error) {
1251     return wifi_->SetBgscanSignalThreshold(threshold, error);
1252   }
1253 
SetTDLSManager(TDLSManager * tdls_manager)1254   void SetTDLSManager(TDLSManager* tdls_manager) {
1255     wifi_->tdls_manager_.reset(tdls_manager);
1256   }
1257 
TDLSDiscoverResponse(const string & peer_address)1258   void TDLSDiscoverResponse(const string& peer_address) {
1259     wifi_->TDLSDiscoverResponse(peer_address);
1260   }
1261 
PerformTDLSOperation(const string & operation,const string & peer,Error * error)1262   string PerformTDLSOperation(
1263       const string& operation, const string& peer, Error* error) {
1264     return wifi_->PerformTDLSOperation(operation, peer, error);
1265   }
1266 
TimeoutPendingConnection()1267   void TimeoutPendingConnection() {
1268     wifi_->PendingTimeoutHandler();
1269   }
1270 
OnNewWiphy(const Nl80211Message & new_wiphy_message)1271   void OnNewWiphy(const Nl80211Message& new_wiphy_message) {
1272     wifi_->OnNewWiphy(new_wiphy_message);
1273   }
1274 
IsConnectedToCurrentService()1275   bool IsConnectedToCurrentService() {
1276     return wifi_->IsConnectedToCurrentService();
1277   }
1278 
control_interface()1279   NiceMockControl* control_interface() {
1280     return &control_interface_;
1281   }
1282 
metrics()1283   MockMetrics* metrics() {
1284     return &metrics_;
1285   }
1286 
manager()1287   MockManager* manager() {
1288     return &manager_;
1289   }
1290 
device_info()1291   MockDeviceInfo* device_info() {
1292     return &device_info_;
1293   }
1294 
dhcp_provider()1295   MockDHCPProvider* dhcp_provider() {
1296     return &dhcp_provider_;
1297   }
1298 
wifi() const1299   const WiFiConstRefPtr wifi() const {
1300     return wifi_;
1301   }
1302 
wifi_provider()1303   MockWiFiProvider* wifi_provider() {
1304     return &wifi_provider_;
1305   }
1306 
mac80211_monitor()1307   MockMac80211Monitor* mac80211_monitor() {
1308     return mac80211_monitor_;
1309   }
1310 
ReportConnectedToServiceAfterWake()1311   void ReportConnectedToServiceAfterWake() {
1312     wifi_->ReportConnectedToServiceAfterWake();
1313   }
1314 
StartScanTimer()1315   void StartScanTimer() {
1316     wifi_->StartScanTimer();
1317   }
1318 
ParseWiphyIndex(const Nl80211Message & nl80211_message)1319   bool ParseWiphyIndex(const Nl80211Message& nl80211_message) {
1320     return wifi_->ParseWiphyIndex(nl80211_message);
1321   }
1322 
GetWiphyIndex()1323   uint32_t GetWiphyIndex() { return wifi_->wiphy_index_; }
1324 
SetWiphyIndex(uint32_t index)1325   void SetWiphyIndex(uint32_t index) { wifi_->wiphy_index_ = index; }
1326 
GetAllScanFrequencies()1327   std::set<uint16_t>* GetAllScanFrequencies() {
1328     return &wifi_->all_scan_frequencies_;
1329   }
1330 
OnScanStarted(const NetlinkMessage & netlink_message)1331   void OnScanStarted(const NetlinkMessage& netlink_message) {
1332     wifi_->OnScanStarted(netlink_message);
1333   }
1334 
ScanFailedCallbackIsCancelled()1335   bool ScanFailedCallbackIsCancelled() {
1336     return wifi_->scan_failed_callback_.IsCancelled();
1337   }
1338 
SetWiFiEnabled(bool enabled)1339   void SetWiFiEnabled(bool enabled) {
1340     wifi_->enabled_ = enabled;
1341   }
1342 
1343   MOCK_METHOD1(SuspendCallback, void(const Error& error));
1344 
1345   EventDispatcher* event_dispatcher_;
1346   MockScanSession* scan_session_;  // Owned by |wifi_|.
1347   MockWakeOnWiFi* wake_on_wifi_;  // Owned by |wifi_|.
1348   NiceMock<MockRTNLHandler> rtnl_handler_;
1349   MockTime time_;
1350 
1351  private:
1352   NiceMockControl control_interface_;
1353   MockMetrics metrics_;
1354   MockManager manager_;
1355   MockDeviceInfo device_info_;
1356   WiFiRefPtr wifi_;
1357   NiceMock<MockWiFiProvider> wifi_provider_;
1358   int bss_counter_;
1359   MockMac80211Monitor* mac80211_monitor_;  // Owned by |wifi_|.
1360 
1361   // protected fields interspersed between private fields, due to
1362   // initialization order
1363  protected:
1364   static const char kDeviceName[];
1365   static const char kDeviceAddress[];
1366   static const char kNetworkModeAdHoc[];
1367   static const char kNetworkModeInfrastructure[];
1368   static const char kBSSName[];
1369   static const char kSSIDName[];
1370   static const uint16_t kRoamThreshold;
1371 
1372   MockSupplicantProcessProxy* supplicant_process_proxy_;
1373   unique_ptr<MockSupplicantBSSProxy> supplicant_bss_proxy_;
1374   MockDHCPProvider dhcp_provider_;
1375   scoped_refptr<MockDHCPConfig> dhcp_config_;
1376 
1377   // These pointers track mock objects owned by the WiFi device instance
1378   // and manager so we can perform expectations against them.
1379   DeviceMockAdaptor* adaptor_;
1380   MockSupplicantEAPStateHandler* eap_state_handler_;
1381   MockNetlinkManager netlink_manager_;
1382 
1383  private:
1384   unique_ptr<MockSupplicantInterfaceProxy> supplicant_interface_proxy_;
1385   unique_ptr<MockSupplicantNetworkProxy> supplicant_network_proxy_;
1386 };
1387 
1388 const char WiFiObjectTest::kDeviceName[] = "wlan0";
1389 const char WiFiObjectTest::kDeviceAddress[] = "000102030405";
1390 const char WiFiObjectTest::kNetworkModeAdHoc[] = "ad-hoc";
1391 const char WiFiObjectTest::kNetworkModeInfrastructure[] = "infrastructure";
1392 const char WiFiObjectTest::kBSSName[] = "bss0";
1393 const char WiFiObjectTest::kSSIDName[] = "ssid0";
1394 const uint16_t WiFiObjectTest::kRoamThreshold = 32;  // Arbitrary value.
1395 
RemoveBSS(const string & bss_path)1396 void WiFiObjectTest::RemoveBSS(const string& bss_path) {
1397   wifi_->BSSRemovedTask(bss_path);
1398 }
1399 
CreateBSSProperties(const string & ssid,const string & bssid,int16_t signal_strength,uint16_t frequency,const char * mode)1400 KeyValueStore WiFiObjectTest::CreateBSSProperties(
1401     const string& ssid,
1402     const string& bssid,
1403     int16_t signal_strength,
1404     uint16_t frequency,
1405     const char* mode) {
1406   KeyValueStore bss_properties;
1407   bss_properties.SetUint8s("SSID", vector<uint8_t>(ssid.begin(), ssid.end()));
1408   {
1409     string bssid_nosep;
1410     vector<uint8_t> bssid_bytes;
1411     base::RemoveChars(bssid, ":", &bssid_nosep);
1412     base::HexStringToBytes(bssid_nosep, &bssid_bytes);
1413     bss_properties.SetUint8s("BSSID", bssid_bytes);
1414   }
1415   bss_properties.SetInt16(WPASupplicant::kBSSPropertySignal, signal_strength);
1416   bss_properties.SetUint16(WPASupplicant::kBSSPropertyFrequency, frequency);
1417   bss_properties.SetString(WPASupplicant::kBSSPropertyMode, mode);
1418 
1419   return bss_properties;
1420 }
1421 
ReportBSS(const string & bss_path,const string & ssid,const string & bssid,int16_t signal_strength,uint16_t frequency,const char * mode)1422 void WiFiObjectTest::ReportBSS(const string& bss_path,
1423                                const string& ssid,
1424                                const string& bssid,
1425                                int16_t signal_strength,
1426                                uint16_t frequency,
1427                                const char* mode) {
1428   wifi_->BSSAddedTask(
1429       bss_path,
1430       CreateBSSProperties(ssid, bssid, signal_strength, frequency, mode));
1431 }
1432 
1433 // Most of our tests involve using a real EventDispatcher object.
1434 class WiFiMainTest : public WiFiObjectTest {
1435  public:
WiFiMainTest()1436   WiFiMainTest() : WiFiObjectTest(&dispatcher_) {}
1437 
1438  protected:
1439   // A progressive scan requests one or more scans, each of which asks about a
1440   // different batch of frequencies/channels.
1441   enum WhichBatchOfProgressiveScan {
1442     kFirstProgressiveScanBatch,
1443     kOnlyFullScanBatch,
1444     kNotFirstProgressiveScanBatch
1445   };
StartScan(WiFi::ScanMethod method)1446   void StartScan(WiFi::ScanMethod method) {
1447     if (method == WiFi::kScanMethodFull) {
1448       EnableFullScan();
1449     }
1450     VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
1451     EXPECT_CALL(*adaptor_, EmitBoolChanged(kPoweredProperty, _)).
1452         Times(AnyNumber());
1453     // Using kFirstProgressiveScanBatch regardless of the method since
1454     // kFOnlyFullScanBatch does exactly the same thing.
1455     ExpectScanStart(method, false);
1456     StartWiFi();
1457     dispatcher_.DispatchPendingEvents();
1458     VerifyScanState(WiFi::kScanScanning, method);
1459   }
1460 
AttemptConnection(WiFi::ScanMethod method,WiFiEndpointRefPtr * endpoint,string * bss_path)1461   MockWiFiServiceRefPtr AttemptConnection(WiFi::ScanMethod method,
1462                                           WiFiEndpointRefPtr* endpoint,
1463                                           string* bss_path) {
1464     WiFiEndpointRefPtr dummy_endpoint;
1465     if (!endpoint) {
1466       endpoint = &dummy_endpoint;  // If caller doesn't care about endpoint.
1467     }
1468 
1469     string dummy_bss_path;
1470     if (!bss_path) {
1471       bss_path = &dummy_bss_path;  // If caller doesn't care about bss_path.
1472     }
1473 
1474     ExpectScanStop();
1475     ExpectConnecting();
1476     MockWiFiServiceRefPtr service =
1477         SetupConnectingService("", endpoint, bss_path);
1478     ReportScanDoneKeepScanSession();
1479     dispatcher_.DispatchPendingEvents();
1480     VerifyScanState(WiFi::kScanConnecting, method);
1481 
1482     return service;
1483   }
1484 
ExpectScanStart(WiFi::ScanMethod method,bool is_continued)1485   void ExpectScanStart(WiFi::ScanMethod method, bool is_continued) {
1486     if (method == WiFi::kScanMethodProgressive) {
1487       ASSERT_FALSE(IsScanSessionNull());
1488       EXPECT_CALL(*scan_session_, HasMoreFrequencies());
1489       EXPECT_CALL(*scan_session_, InitiateScan());
1490     } else {
1491       EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1492     }
1493     if (!is_continued) {
1494       EXPECT_CALL(*adaptor_, EmitBoolChanged(kScanningProperty,
1495                                              true));
1496       EXPECT_CALL(*metrics(), NotifyDeviceScanStarted(_));
1497     }
1498   }
1499 
1500   // Scanning can stop for any reason (including transitioning to connecting).
ExpectScanStop()1501   void ExpectScanStop() {
1502     EXPECT_CALL(*adaptor_, EmitBoolChanged(kScanningProperty, false));
1503   }
1504 
ExpectConnecting()1505   void ExpectConnecting() {
1506     EXPECT_CALL(*metrics(), NotifyDeviceScanFinished(_));
1507     EXPECT_CALL(*metrics(), NotifyDeviceConnectStarted(_, _));
1508   }
1509 
ExpectConnected()1510   void ExpectConnected() {
1511     EXPECT_CALL(*metrics(), NotifyDeviceConnectFinished(_));
1512     ExpectScanIdle();
1513   }
1514 
ExpectFoundNothing()1515   void ExpectFoundNothing() {
1516     EXPECT_CALL(*metrics(), NotifyDeviceScanFinished(_));
1517     EXPECT_CALL(*metrics(), ResetConnectTimer(_));
1518     ExpectScanIdle();
1519   }
1520 
ExpectScanIdle()1521   void ExpectScanIdle() {
1522     EXPECT_CALL(*metrics(), ResetScanTimer(_));
1523     EXPECT_CALL(*metrics(), ResetConnectTimer(_)).RetiresOnSaturation();
1524   }
1525 
1526   EventDispatcherForTest dispatcher_;
1527 };
1528 
TEST_F(WiFiMainTest,ProxiesSetUpDuringStart)1529 TEST_F(WiFiMainTest, ProxiesSetUpDuringStart) {
1530   EXPECT_EQ(nullptr, GetSupplicantInterfaceProxyFromWiFi());;
1531 
1532   StartWiFi();
1533   EXPECT_NE(nullptr, GetSupplicantInterfaceProxyFromWiFi());
1534 }
1535 
TEST_F(WiFiMainTest,SupplicantPresent)1536 TEST_F(WiFiMainTest, SupplicantPresent) {
1537   EXPECT_FALSE(GetSupplicantPresent());
1538 }
1539 
TEST_F(WiFiMainTest,RoamThresholdProperty)1540 TEST_F(WiFiMainTest, RoamThresholdProperty) {
1541   static const uint16_t kRoamThreshold16 = 16;
1542   static const uint16_t kRoamThreshold32 = 32;
1543 
1544   StartWiFi(false);  // No supplicant present.
1545   OnSupplicantAppear();
1546 
1547   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
1548               SetRoamThreshold(kRoamThreshold16));
1549   EXPECT_TRUE(SetRoamThreshold(kRoamThreshold16));
1550   EXPECT_EQ(GetRoamThreshold(), kRoamThreshold16);
1551 
1552   // Try a different number
1553   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
1554               SetRoamThreshold(kRoamThreshold32));
1555   EXPECT_TRUE(SetRoamThreshold(kRoamThreshold32));
1556   EXPECT_EQ(GetRoamThreshold(), kRoamThreshold32);
1557 
1558   // Do not set supplicant's roam threshold property immediately if the
1559   // current WiFi service has its own roam threshold property set.
1560   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
1561   service->roam_threshold_db_set_ = true;
1562   SetCurrentService(service);
1563   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetRoamThreshold(_)).Times(0);
1564   EXPECT_TRUE(SetRoamThreshold(kRoamThreshold16));
1565   EXPECT_EQ(kRoamThreshold16, GetRoamThreshold());
1566 }
1567 
TEST_F(WiFiMainTest,OnSupplicantAppearStarted)1568 TEST_F(WiFiMainTest, OnSupplicantAppearStarted) {
1569   EXPECT_EQ(nullptr, GetSupplicantInterfaceProxyFromWiFi());;
1570 
1571   StartWiFi(false);  // No supplicant present.
1572   EXPECT_EQ(nullptr, GetSupplicantInterfaceProxyFromWiFi());;
1573 
1574   SetRoamThresholdMember(kRoamThreshold);
1575   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveAllNetworks());
1576   EXPECT_CALL(*GetSupplicantInterfaceProxy(), FlushBSS(0));
1577   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetFastReauth(false));
1578   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetRoamThreshold(kRoamThreshold));
1579   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetScanInterval(_));
1580   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetDisableHighBitrates(true));
1581 
1582   OnSupplicantAppear();
1583   EXPECT_NE(nullptr, GetSupplicantInterfaceProxyFromWiFi());
1584 
1585   // If supplicant reappears while the device is started, the device should be
1586   // restarted.
1587   EXPECT_CALL(*manager(), DeregisterDevice(_));
1588   EXPECT_CALL(*manager(), RegisterDevice(_));
1589   OnSupplicantAppear();
1590 }
1591 
TEST_F(WiFiMainTest,OnSupplicantAppearStopped)1592 TEST_F(WiFiMainTest, OnSupplicantAppearStopped) {
1593   EXPECT_EQ(nullptr, GetSupplicantInterfaceProxyFromWiFi());
1594 
1595   OnSupplicantAppear();
1596   EXPECT_EQ(nullptr, GetSupplicantInterfaceProxyFromWiFi());
1597 
1598   // If supplicant reappears while the device is stopped, the device should not
1599   // be restarted.
1600   EXPECT_CALL(*manager(), DeregisterDevice(_)).Times(0);
1601   OnSupplicantAppear();
1602 }
1603 
TEST_F(WiFiMainTest,OnSupplicantVanishStarted)1604 TEST_F(WiFiMainTest, OnSupplicantVanishStarted) {
1605   EXPECT_EQ(nullptr, GetSupplicantInterfaceProxyFromWiFi());;
1606 
1607   StartWiFi();
1608   EXPECT_NE(nullptr, GetSupplicantInterfaceProxyFromWiFi());
1609   EXPECT_TRUE(GetSupplicantPresent());
1610 
1611   EXPECT_CALL(*manager(), DeregisterDevice(_));
1612   EXPECT_CALL(*manager(), RegisterDevice(_));
1613   OnSupplicantVanish();
1614 }
1615 
TEST_F(WiFiMainTest,OnSupplicantVanishStopped)1616 TEST_F(WiFiMainTest, OnSupplicantVanishStopped) {
1617   OnSupplicantAppear();
1618   EXPECT_TRUE(GetSupplicantPresent());
1619   EXPECT_CALL(*manager(), DeregisterDevice(_)).Times(0);
1620   OnSupplicantVanish();
1621 }
1622 
TEST_F(WiFiMainTest,OnSupplicantVanishedWhileConnected)1623 TEST_F(WiFiMainTest, OnSupplicantVanishedWhileConnected) {
1624   StartWiFi();
1625   WiFiEndpointRefPtr endpoint;
1626   WiFiServiceRefPtr service(
1627       SetupConnectedService("", &endpoint, nullptr));
1628   ScopedMockLog log;
1629   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
1630   EXPECT_CALL(log, Log(logging::LOG_ERROR, _,
1631                        EndsWith("silently resetting current_service_.")));
1632   EXPECT_CALL(*manager(), DeregisterDevice(_))
1633       .WillOnce(InvokeWithoutArgs(this, &WiFiObjectTest::StopWiFi));
1634   unique_ptr<EndpointRemovalHandler> handler(
1635       MakeEndpointRemovalHandler(service));
1636   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(endpoint)))
1637       .WillOnce(Invoke(handler.get(),
1638                 &EndpointRemovalHandler::OnEndpointRemoved));
1639   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect()).Times(0);
1640   EXPECT_CALL(*manager(), RegisterDevice(_));
1641   OnSupplicantVanish();
1642   EXPECT_EQ(nullptr, GetCurrentService());;
1643 }
1644 
TEST_F(WiFiMainTest,CleanStart_FullScan)1645 TEST_F(WiFiMainTest, CleanStart_FullScan) {
1646   EnableFullScan();
1647   EXPECT_CALL(*supplicant_process_proxy_, CreateInterface(_, _));
1648   EXPECT_CALL(*supplicant_process_proxy_, GetInterface(_, _))
1649       .Times(AnyNumber())
1650       .WillRepeatedly(Return(false));
1651   EXPECT_TRUE(GetScanTimer().IsCancelled());
1652   StartWiFi();
1653   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1654   dispatcher_.DispatchPendingEvents();
1655   EXPECT_FALSE(GetScanTimer().IsCancelled());
1656 }
1657 
TEST_F(WiFiMainTest,CleanStart)1658 TEST_F(WiFiMainTest, CleanStart) {
1659   EXPECT_CALL(*supplicant_process_proxy_, CreateInterface(_, _));
1660   EXPECT_CALL(*supplicant_process_proxy_, GetInterface(_, _))
1661       .Times(AnyNumber())
1662       .WillRepeatedly(Return(false));
1663   EXPECT_TRUE(GetScanTimer().IsCancelled());
1664   StartWiFi();
1665   EXPECT_CALL(*scan_session_, InitiateScan());
1666   dispatcher_.DispatchPendingEvents();
1667   EXPECT_FALSE(GetScanTimer().IsCancelled());
1668 }
1669 
TEST_F(WiFiMainTest,ClearCachedCredentials)1670 TEST_F(WiFiMainTest, ClearCachedCredentials) {
1671   StartWiFi();
1672   string network = "/test/path";
1673   WiFiServiceRefPtr service(SetupConnectedService(network, nullptr, nullptr));
1674   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(network));
1675   ClearCachedCredentials(service.get());
1676 }
1677 
TEST_F(WiFiMainTest,NotifyEndpointChanged)1678 TEST_F(WiFiMainTest, NotifyEndpointChanged) {
1679   WiFiEndpointRefPtr endpoint =
1680       MakeEndpointWithMode("ssid", "00:00:00:00:00:00", kNetworkModeAdHoc);
1681   EXPECT_CALL(*wifi_provider(), OnEndpointUpdated(EndpointMatch(endpoint)));
1682   NotifyEndpointChanged(endpoint);
1683 }
1684 
TEST_F(WiFiMainTest,RemoveNetwork)1685 TEST_F(WiFiMainTest, RemoveNetwork) {
1686   string network = "/test/path";
1687   StartWiFi();
1688   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(network))
1689       .WillOnce(Return(true));
1690   EXPECT_TRUE(RemoveNetwork(network));
1691 }
1692 
TEST_F(WiFiMainTest,UseArpGateway)1693 TEST_F(WiFiMainTest, UseArpGateway) {
1694   StartWiFi();
1695 
1696   // With no selected service.
1697   EXPECT_TRUE(wifi()->ShouldUseArpGateway());
1698   EXPECT_CALL(dhcp_provider_, CreateIPv4Config(kDeviceName, _, true, _))
1699       .WillOnce(Return(dhcp_config_));
1700   const_cast<WiFi*>(wifi().get())->AcquireIPConfig();
1701 
1702   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
1703   InitiateConnect(service);
1704 
1705   // Selected service that does not have a static IP address.
1706   EXPECT_CALL(*service, HasStaticIPAddress()).WillRepeatedly(Return(false));
1707   EXPECT_TRUE(wifi()->ShouldUseArpGateway());
1708   EXPECT_CALL(dhcp_provider_, CreateIPv4Config(kDeviceName, _, true, _))
1709       .WillOnce(Return(dhcp_config_));
1710   const_cast<WiFi*>(wifi().get())->AcquireIPConfig();
1711   Mock::VerifyAndClearExpectations(service.get());
1712 
1713   // Selected service that has a static IP address.
1714   EXPECT_CALL(*service, HasStaticIPAddress()).WillRepeatedly(Return(true));
1715   EXPECT_FALSE(wifi()->ShouldUseArpGateway());
1716   EXPECT_CALL(dhcp_provider_, CreateIPv4Config(kDeviceName, _, false, _))
1717       .WillOnce(Return(dhcp_config_));
1718   const_cast<WiFi*>(wifi().get())->AcquireIPConfig();
1719 }
1720 
TEST_F(WiFiMainTest,RemoveNetworkFailed)1721 TEST_F(WiFiMainTest, RemoveNetworkFailed) {
1722   string network = "/test/path";
1723   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(network))
1724       .WillRepeatedly(Return(false));
1725   StartWiFi();
1726   EXPECT_FALSE(RemoveNetwork(network));
1727 }
1728 
TEST_F(WiFiMainTest,Restart_FullScan)1729 TEST_F(WiFiMainTest, Restart_FullScan) {
1730   EnableFullScan();
1731   EXPECT_CALL(*supplicant_process_proxy_, CreateInterface(_, _))
1732       .Times(AnyNumber())
1733       .WillRepeatedly(Return(false));
1734   EXPECT_CALL(*supplicant_process_proxy_, GetInterface(_, _));
1735   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1736   StartWiFi();
1737   dispatcher_.DispatchPendingEvents();
1738 }
1739 
TEST_F(WiFiMainTest,Restart)1740 TEST_F(WiFiMainTest, Restart) {
1741   EXPECT_CALL(*supplicant_process_proxy_, CreateInterface(_, _))
1742       .Times(AnyNumber())
1743       .WillRepeatedly(Return(false));
1744   EXPECT_CALL(*scan_session_, InitiateScan());
1745   StartWiFi();
1746   dispatcher_.DispatchPendingEvents();
1747 }
1748 
TEST_F(WiFiMainTest,StartClearsState)1749 TEST_F(WiFiMainTest, StartClearsState) {
1750   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveAllNetworks());
1751   EXPECT_CALL(*GetSupplicantInterfaceProxy(), FlushBSS(_));
1752   StartWiFi();
1753 }
1754 
TEST_F(WiFiMainTest,NoScansWhileConnecting_FullScan)1755 TEST_F(WiFiMainTest, NoScansWhileConnecting_FullScan) {
1756   // Setup 'connecting' state.
1757   StartScan(WiFi::kScanMethodFull);
1758   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1759 
1760   ExpectScanStop();
1761   ExpectConnecting();
1762   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
1763   InitiateConnect(service);
1764   VerifyScanState(WiFi::kScanConnecting, WiFi::kScanMethodFull);
1765 
1766   // If we're connecting, we ignore scan requests and stay on channel.
1767   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
1768   TriggerScan(WiFi::kScanMethodFull);
1769   dispatcher_.DispatchPendingEvents();
1770   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1771   Mock::VerifyAndClearExpectations(service.get());
1772 
1773   // Terminate the scan.
1774   ExpectFoundNothing();
1775   TimeoutPendingConnection();
1776   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
1777 
1778   // Start a fresh scan.
1779   ExpectScanStart(WiFi::kScanMethodFull, false);
1780   TriggerScan(WiFi::kScanMethodFull);
1781   dispatcher_.DispatchPendingEvents();
1782   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1783   Mock::VerifyAndClearExpectations(service.get());
1784 
1785   // Similarly, ignore scans when our connected service is reconnecting.
1786   ExpectScanStop();
1787   ExpectScanIdle();
1788   SetPendingService(nullptr);
1789   SetCurrentService(service);
1790   EXPECT_CALL(*service, IsConnecting()).WillOnce(Return(true));
1791   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
1792   TriggerScan(WiFi::kScanMethodFull);
1793   dispatcher_.DispatchPendingEvents();
1794   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1795   Mock::VerifyAndClearExpectations(service.get());
1796 
1797   // But otherwise we'll honor the request.
1798   EXPECT_CALL(*service, IsConnecting()).Times(AtLeast(2)).
1799       WillRepeatedly(Return(false));
1800   ExpectScanStart(WiFi::kScanMethodFull, false);
1801   TriggerScan(WiFi::kScanMethodFull);
1802   dispatcher_.DispatchPendingEvents();
1803   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1804   Mock::VerifyAndClearExpectations(service.get());
1805 
1806   // Silence messages from the destructor.
1807   ExpectScanStop();
1808   ExpectScanIdle();
1809 }
1810 
TEST_F(WiFiMainTest,NoScansWhileConnecting)1811 TEST_F(WiFiMainTest, NoScansWhileConnecting) {
1812   // Setup 'connecting' state.
1813   StartScan(WiFi::kScanMethodProgressive);
1814   ExpectScanStop();
1815   ExpectConnecting();
1816   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
1817   InitiateConnect(service);
1818   VerifyScanState(WiFi::kScanConnecting, WiFi::kScanMethodProgressive);
1819 
1820   // If we're connecting, we ignore scan requests and stay on channel.
1821   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
1822   TriggerScan(WiFi::kScanMethodProgressive);
1823   dispatcher_.DispatchPendingEvents();
1824   Mock::VerifyAndClearExpectations(service.get());
1825   Mock::VerifyAndClearExpectations(scan_session_);
1826 
1827   // Terminate the scan.
1828   ExpectFoundNothing();
1829   TimeoutPendingConnection();
1830   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
1831 
1832   // Start a fresh scan.
1833   InstallMockScanSession();
1834   ExpectScanStart(WiFi::kScanMethodProgressive, false);
1835   TriggerScan(WiFi::kScanMethodProgressive);
1836   dispatcher_.DispatchPendingEvents();
1837   Mock::VerifyAndClearExpectations(service.get());
1838   Mock::VerifyAndClearExpectations(scan_session_);
1839 
1840   // Similarly, ignore scans when our connected service is reconnecting.
1841   ExpectScanStop();
1842   ExpectScanIdle();
1843   SetPendingService(nullptr);
1844   SetCurrentService(service);
1845   EXPECT_CALL(*service, IsConnecting()).WillOnce(Return(true));
1846   InstallMockScanSession();
1847   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
1848   TriggerScan(WiFi::kScanMethodProgressive);
1849   dispatcher_.DispatchPendingEvents();
1850   Mock::VerifyAndClearExpectations(service.get());
1851   Mock::VerifyAndClearExpectations(scan_session_);
1852 
1853   // Unlike Full scan, Progressive scan will reject attempts to scan while
1854   // we're connected.
1855   EXPECT_CALL(*service, IsConnecting()).WillOnce(Return(false));
1856   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
1857   TriggerScan(WiFi::kScanMethodProgressive);
1858   dispatcher_.DispatchPendingEvents();
1859   Mock::VerifyAndClearExpectations(service.get());
1860   Mock::VerifyAndClearExpectations(scan_session_);
1861 }
1862 
TEST_F(WiFiMainTest,ResetScanStateWhenScanFailed)1863 TEST_F(WiFiMainTest, ResetScanStateWhenScanFailed) {
1864   StartScan(WiFi::kScanMethodFull);
1865   ExpectScanStop();
1866   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodFull);
1867   ReportScanFailed();
1868   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
1869 }
1870 
TEST_F(WiFiMainTest,ResumeStartsScanWhenIdle_FullScan)1871 TEST_F(WiFiMainTest, ResumeStartsScanWhenIdle_FullScan) {
1872   EnableFullScan();
1873   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1874   StartWiFi();
1875   dispatcher_.DispatchPendingEvents();
1876   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1877   ReportScanDone();
1878   ASSERT_TRUE(wifi()->IsIdle());
1879   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1880   OnAfterResume();
1881   dispatcher_.DispatchPendingEvents();
1882 }
1883 
TEST_F(WiFiMainTest,ResumeStartsScanWhenIdle)1884 TEST_F(WiFiMainTest, ResumeStartsScanWhenIdle) {
1885   EXPECT_CALL(*scan_session_, InitiateScan());
1886   StartWiFi();
1887   dispatcher_.DispatchPendingEvents();
1888   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1889   ReportScanDone();
1890   ASSERT_TRUE(wifi()->IsIdle());
1891   dispatcher_.DispatchPendingEvents();
1892   OnAfterResume();
1893   EXPECT_NE(nullptr, scan_session_);;
1894   InstallMockScanSession();
1895   EXPECT_CALL(*scan_session_, InitiateScan());
1896   dispatcher_.DispatchPendingEvents();
1897 }
1898 
TEST_F(WiFiMainTest,ResumeDoesNotScanIfConnected)1899 TEST_F(WiFiMainTest, ResumeDoesNotScanIfConnected) {
1900   StartWiFi();
1901   dispatcher_.DispatchPendingEvents();
1902   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1903   ReportScanDone();
1904   CancelScanTimer();
1905   EXPECT_TRUE(GetScanTimer().IsCancelled());
1906   ASSERT_TRUE(wifi()->IsIdle());
1907   dispatcher_.DispatchPendingEvents();
1908   OnAfterResume();
1909   EXPECT_FALSE(GetScanTimer().IsCancelled());
1910   InstallMockScanSession();
1911   SetCurrentService(MakeMockService(kSecurityNone));
1912   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
1913   dispatcher_.DispatchPendingEvents();
1914 }
1915 
TEST_F(WiFiMainTest,SuspendDoesNotStartScan_FullScan)1916 TEST_F(WiFiMainTest, SuspendDoesNotStartScan_FullScan) {
1917   EnableFullScan();
1918   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1919   StartWiFi();
1920   dispatcher_.DispatchPendingEvents();
1921   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1922   ASSERT_TRUE(wifi()->IsIdle());
1923   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
1924   OnBeforeSuspend();
1925   dispatcher_.DispatchPendingEvents();
1926 }
1927 
TEST_F(WiFiMainTest,SuspendDoesNotStartScan)1928 TEST_F(WiFiMainTest, SuspendDoesNotStartScan) {
1929   EXPECT_CALL(*scan_session_, InitiateScan());
1930   StartWiFi();
1931   dispatcher_.DispatchPendingEvents();
1932   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1933   ASSERT_TRUE(wifi()->IsIdle());
1934   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
1935   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
1936   OnBeforeSuspend();
1937   dispatcher_.DispatchPendingEvents();
1938 }
1939 
TEST_F(WiFiMainTest,ResumeDoesNotStartScanWhenNotIdle_FullScan)1940 TEST_F(WiFiMainTest, ResumeDoesNotStartScanWhenNotIdle_FullScan) {
1941   EnableFullScan();
1942   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
1943   StartWiFi();
1944   dispatcher_.DispatchPendingEvents();
1945   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1946   WiFiServiceRefPtr service(
1947       SetupConnectedService("", nullptr, nullptr));
1948   EXPECT_FALSE(wifi()->IsIdle());
1949   ScopedMockLog log;
1950   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
1951   EXPECT_CALL(log, Log(_, _, EndsWith("already connecting or connected.")));
1952   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
1953   OnAfterResume();
1954   dispatcher_.DispatchPendingEvents();
1955 }
1956 
TEST_F(WiFiMainTest,ResumeDoesNotStartScanWhenNotIdle)1957 TEST_F(WiFiMainTest, ResumeDoesNotStartScanWhenNotIdle) {
1958   EXPECT_CALL(*scan_session_, InitiateScan());
1959   StartWiFi();
1960   dispatcher_.DispatchPendingEvents();
1961   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1962   WiFiServiceRefPtr service(
1963       SetupConnectedService("", nullptr, nullptr));
1964   EXPECT_FALSE(wifi()->IsIdle());
1965   ScopedMockLog log;
1966   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
1967   EXPECT_CALL(log, Log(_, _, EndsWith("already connecting or connected.")));
1968   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
1969   EXPECT_TRUE(IsScanSessionNull());
1970   OnAfterResume();
1971   dispatcher_.DispatchPendingEvents();
1972 }
1973 
TEST_F(WiFiMainTest,ResumeWithCurrentService)1974 TEST_F(WiFiMainTest, ResumeWithCurrentService) {
1975   StartWiFi();
1976   SetupConnectedService("", nullptr, nullptr);
1977 
1978   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetHT40Enable(_, true)).Times(1);
1979   OnAfterResume();
1980   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
1981 }
1982 
TEST_F(WiFiMainTest,ScanResults)1983 TEST_F(WiFiMainTest, ScanResults) {
1984   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(_)).Times(5);
1985   StartWiFi();
1986   ReportBSS("bss0", "ssid0", "00:00:00:00:00:00", 0, 0, kNetworkModeAdHoc);
1987   ReportBSS(
1988       "bss1", "ssid1", "00:00:00:00:00:01", 1, 0, kNetworkModeInfrastructure);
1989   ReportBSS(
1990       "bss2", "ssid2", "00:00:00:00:00:02", 2, 0, kNetworkModeInfrastructure);
1991   ReportBSS(
1992       "bss3", "ssid3", "00:00:00:00:00:03", 3, 0, kNetworkModeInfrastructure);
1993   const uint16_t frequency = 2412;
1994   ReportBSS("bss4", "ssid4", "00:00:00:00:00:04", 4, frequency,
1995             kNetworkModeAdHoc);
1996 
1997   const WiFi::EndpointMap& endpoints_by_rpcid = GetEndpointMap();
1998   EXPECT_EQ(5, endpoints_by_rpcid.size());
1999 
2000   WiFi::EndpointMap::const_iterator i;
2001   WiFiEndpointRefPtr endpoint;
2002   for (i = endpoints_by_rpcid.begin();
2003        i != endpoints_by_rpcid.end();
2004        ++i) {
2005     if (i->second->bssid_string() == "00:00:00:00:00:04")
2006       break;
2007   }
2008   ASSERT_TRUE(i != endpoints_by_rpcid.end());
2009   EXPECT_EQ(4, i->second->signal_strength());
2010   EXPECT_EQ(frequency, i->second->frequency());
2011   EXPECT_EQ("adhoc", i->second->network_mode());
2012 }
2013 
TEST_F(WiFiMainTest,ScanCompleted)2014 TEST_F(WiFiMainTest, ScanCompleted) {
2015   StartWiFi();
2016   WiFiEndpointRefPtr ap0 = MakeEndpointWithMode("ssid0", "00:00:00:00:00:00",
2017                                                 kNetworkModeAdHoc);
2018   WiFiEndpointRefPtr ap1 = MakeEndpoint("ssid1", "00:00:00:00:00:01");
2019   WiFiEndpointRefPtr ap2 = MakeEndpoint("ssid2", "00:00:00:00:00:02");
2020   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(EndpointMatch(ap0))).Times(1);
2021   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(EndpointMatch(ap1))).Times(1);
2022   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(EndpointMatch(ap2))).Times(1);
2023   ReportBSS("bss0", ap0->ssid_string(), ap0->bssid_string(), 0, 0,
2024             kNetworkModeAdHoc);
2025   ReportBSS("bss1", ap1->ssid_string(), ap1->bssid_string(), 0, 0,
2026             kNetworkModeInfrastructure);
2027   ReportBSS("bss2", ap2->ssid_string(), ap2->bssid_string(), 0, 0,
2028             kNetworkModeInfrastructure);
2029   manager()->set_suppress_autoconnect(true);
2030   ReportScanDone();
2031   EXPECT_FALSE(manager()->suppress_autoconnect());
2032   Mock::VerifyAndClearExpectations(wifi_provider());
2033 
2034   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(_)).Times(0);
2035 
2036   // BSSes with SSIDs that start with nullptr should be filtered.
2037   ReportBSS("bss3", string(1, 0), "00:00:00:00:00:03", 3, 0, kNetworkModeAdHoc);
2038 
2039   // BSSes with empty SSIDs should be filtered.
2040   ReportBSS("bss3", string(), "00:00:00:00:00:03", 3, 0, kNetworkModeAdHoc);
2041 }
2042 
TEST_F(WiFiMainTest,LoneBSSRemovedWhileConnected)2043 TEST_F(WiFiMainTest, LoneBSSRemovedWhileConnected) {
2044   StartWiFi();
2045   WiFiEndpointRefPtr endpoint;
2046   string bss_path;
2047   WiFiServiceRefPtr service(
2048       SetupConnectedService("", &endpoint, &bss_path));
2049   unique_ptr<EndpointRemovalHandler> handler(
2050       MakeEndpointRemovalHandler(service));
2051   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(endpoint)))
2052       .WillOnce(Invoke(handler.get(),
2053                 &EndpointRemovalHandler::OnEndpointRemoved));
2054   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2055   RemoveBSS(bss_path);
2056 }
2057 
TEST_F(WiFiMainTest,NonSolitaryBSSRemoved)2058 TEST_F(WiFiMainTest, NonSolitaryBSSRemoved) {
2059   StartWiFi();
2060   WiFiEndpointRefPtr endpoint;
2061   string bss_path;
2062   WiFiServiceRefPtr service(
2063       SetupConnectedService("", &endpoint, &bss_path));
2064   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(endpoint)))
2065       .WillOnce(Return(nullptr));
2066   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect()).Times(0);
2067   RemoveBSS(bss_path);
2068 }
2069 
TEST_F(WiFiMainTest,ReconnectPreservesDBusPath)2070 TEST_F(WiFiMainTest, ReconnectPreservesDBusPath) {
2071   StartWiFi();
2072   string kPath = "/test/path";
2073   MockWiFiServiceRefPtr service(SetupConnectedService(kPath, nullptr, nullptr));
2074 
2075   // Return the service to a connectable state.
2076   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2077   InitiateDisconnect(service);
2078   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2079 
2080   // Complete the disconnection by reporting a BSS change.
2081   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
2082 
2083   // A second connection attempt should remember the DBus path associated
2084   // with this service, and should not request new configuration parameters.
2085   EXPECT_CALL(*service, GetSupplicantConfigurationParameters()).Times(0);
2086   EXPECT_CALL(*GetSupplicantInterfaceProxy(), AddNetwork(_, _)).Times(0);
2087   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SelectNetwork(kPath));
2088   InitiateConnect(service);
2089 }
2090 
TEST_F(WiFiMainTest,DisconnectPendingService)2091 TEST_F(WiFiMainTest, DisconnectPendingService) {
2092   StartWiFi();
2093   MockWiFiServiceRefPtr service(
2094       SetupConnectingService("", nullptr, nullptr));
2095   EXPECT_TRUE(GetPendingService() == service.get());
2096   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2097   EXPECT_CALL(*service, SetFailure(_)).Times(0);
2098   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(AtLeast(1));
2099   service->set_expecting_disconnect(true);
2100   InitiateDisconnect(service);
2101   Mock::VerifyAndClearExpectations(service.get());
2102   EXPECT_EQ(nullptr, GetPendingService());;
2103 }
2104 
TEST_F(WiFiMainTest,DisconnectPendingServiceWithFailure)2105 TEST_F(WiFiMainTest, DisconnectPendingServiceWithFailure) {
2106   StartWiFi();
2107   MockWiFiServiceRefPtr service(
2108       SetupConnectingService("", nullptr, nullptr));
2109   EXPECT_TRUE(GetPendingService() == service.get());
2110   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2111   EXPECT_CALL(*service, SetFailure(Service::kFailureOutOfRange));
2112   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(AtLeast(1));
2113   InitiateDisconnect(service);
2114   Mock::VerifyAndClearExpectations(service.get());
2115   EXPECT_EQ(nullptr, GetPendingService());;
2116 }
2117 
TEST_F(WiFiMainTest,DisconnectPendingServiceWithCurrent)2118 TEST_F(WiFiMainTest, DisconnectPendingServiceWithCurrent) {
2119   StartWiFi();
2120   MockWiFiServiceRefPtr service0(
2121       SetupConnectedService("", nullptr, nullptr));
2122   EXPECT_EQ(service0, GetCurrentService());
2123   EXPECT_EQ(nullptr, GetPendingService().get());
2124 
2125   // We don't explicitly call Disconnect() while transitioning to a new
2126   // service.  Instead, we use the side-effect of SelectNetwork (verified in
2127   // SetupConnectingService).
2128   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect()).Times(0);
2129   MockWiFiServiceRefPtr service1(
2130       SetupConnectingService("/new/path", nullptr, nullptr));
2131   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2132 
2133   EXPECT_EQ(service0, GetCurrentService());
2134   EXPECT_EQ(service1, GetPendingService());
2135   EXPECT_CALL(*service1, SetState(Service::kStateIdle)).Times(AtLeast(1));
2136   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2137   InitiateDisconnect(service1);
2138   Mock::VerifyAndClearExpectations(service1.get());
2139 
2140   // |current_service_| will be unchanged until supplicant signals
2141   // that CurrentBSS has changed.
2142   EXPECT_EQ(service0, GetCurrentService());
2143   // |pending_service_| is updated immediately.
2144   EXPECT_EQ(nullptr, GetPendingService().get());
2145   EXPECT_TRUE(GetPendingTimeout().IsCancelled());
2146 }
2147 
TEST_F(WiFiMainTest,DisconnectCurrentService)2148 TEST_F(WiFiMainTest, DisconnectCurrentService) {
2149   StartWiFi();
2150   string kPath("/fake/path");
2151   MockWiFiServiceRefPtr service(SetupConnectedService(kPath, nullptr, nullptr));
2152   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2153   service->set_expecting_disconnect(true);
2154   InitiateDisconnect(service);
2155 
2156   // |current_service_| should not change until supplicant reports
2157   // a BSS change.
2158   EXPECT_EQ(service, GetCurrentService());
2159 
2160   // Expect that the entry associated with this network will be disabled.
2161   unique_ptr<MockSupplicantNetworkProxy> network_proxy(
2162       new MockSupplicantNetworkProxy());
2163   EXPECT_CALL(*control_interface(),
2164               CreateSupplicantNetworkProxy(kPath))
2165       .WillOnce(ReturnAndReleasePointee(&network_proxy));
2166   EXPECT_CALL(*network_proxy, SetEnabled(false)).WillOnce(Return(true));
2167   EXPECT_CALL(*eap_state_handler_, Reset());
2168   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(kPath)).Times(0);
2169   EXPECT_CALL(*service, SetFailure(_)).Times(0);
2170   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(AtLeast(1));
2171   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
2172   EXPECT_EQ(nullptr, GetCurrentService().get());
2173   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2174 }
2175 
TEST_F(WiFiMainTest,DisconnectCurrentServiceWithFailure)2176 TEST_F(WiFiMainTest, DisconnectCurrentServiceWithFailure) {
2177   StartWiFi();
2178   string kPath("/fake/path");
2179   MockWiFiServiceRefPtr service(SetupConnectedService(kPath, nullptr, nullptr));
2180   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2181   InitiateDisconnect(service);
2182 
2183   // |current_service_| should not change until supplicant reports
2184   // a BSS change.
2185   EXPECT_EQ(service, GetCurrentService());
2186 
2187   // Expect that the entry associated with this network will be disabled.
2188   unique_ptr<MockSupplicantNetworkProxy> network_proxy(
2189       new MockSupplicantNetworkProxy());
2190   EXPECT_CALL(*control_interface(),
2191               CreateSupplicantNetworkProxy(kPath))
2192       .WillOnce(ReturnAndReleasePointee(&network_proxy));
2193   EXPECT_CALL(*network_proxy, SetEnabled(false)).WillOnce(Return(true));
2194   EXPECT_CALL(*eap_state_handler_, Reset());
2195   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(kPath)).Times(0);
2196   EXPECT_CALL(*service, SetFailure(Service::kFailureOutOfRange));
2197   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(AtLeast(1));
2198   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
2199   EXPECT_EQ(nullptr, GetCurrentService().get());
2200   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2201 }
2202 
TEST_F(WiFiMainTest,DisconnectCurrentServiceWithErrors)2203 TEST_F(WiFiMainTest, DisconnectCurrentServiceWithErrors) {
2204   StartWiFi();
2205   string kPath("/fake/path");
2206   WiFiServiceRefPtr service(SetupConnectedService(kPath, nullptr, nullptr));
2207   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect())
2208       .WillOnce(Return(false));
2209   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(kPath)).Times(1);
2210   InitiateDisconnect(service);
2211 
2212   // We may sometimes fail to disconnect via supplicant, and we patch up some
2213   // state when this happens.
2214   EXPECT_EQ(nullptr, GetCurrentService().get());
2215   EXPECT_EQ(nullptr, GetSelectedService().get());
2216 }
2217 
TEST_F(WiFiMainTest,DisconnectCurrentServiceWithPending)2218 TEST_F(WiFiMainTest, DisconnectCurrentServiceWithPending) {
2219   StartWiFi();
2220   MockWiFiServiceRefPtr service0(SetupConnectedService("",
2221                                                        nullptr, nullptr));
2222   MockWiFiServiceRefPtr service1(SetupConnectingService("",
2223                                                         nullptr, nullptr));
2224   EXPECT_EQ(service0, GetCurrentService());
2225   EXPECT_EQ(service1, GetPendingService());
2226   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect()).Times(0);
2227   InitiateDisconnect(service0);
2228 
2229   EXPECT_EQ(service0, GetCurrentService());
2230   EXPECT_EQ(service1, GetPendingService());
2231   EXPECT_FALSE(GetPendingTimeout().IsCancelled());
2232 
2233   EXPECT_CALL(*service0, SetState(Service::kStateIdle)).Times(AtLeast(1));
2234   EXPECT_CALL(*service0, SetFailure(_)).Times(0);
2235   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
2236 }
2237 
TEST_F(WiFiMainTest,DisconnectCurrentServiceWhileRoaming)2238 TEST_F(WiFiMainTest, DisconnectCurrentServiceWhileRoaming) {
2239   StartWiFi();
2240   string kPath("/fake/path");
2241   WiFiServiceRefPtr service(SetupConnectedService(kPath, nullptr, nullptr));
2242 
2243   // As it roams to another AP, supplicant signals that it is in
2244   // the authenticating state.
2245   ReportStateChanged(WPASupplicant::kInterfaceStateAuthenticating);
2246 
2247   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2248   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(kPath));
2249   InitiateDisconnect(service);
2250 
2251   // Because the interface was not connected, we should have immediately
2252   // forced ourselves into a disconnected state.
2253   EXPECT_EQ(nullptr, GetCurrentService().get());
2254   EXPECT_EQ(nullptr, GetSelectedService().get());
2255 
2256   // Check calls before TearDown/dtor.
2257   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2258 }
2259 
TEST_F(WiFiMainTest,DisconnectWithWiFiServiceConnected)2260 TEST_F(WiFiMainTest, DisconnectWithWiFiServiceConnected) {
2261   StartWiFi();
2262   MockWiFiServiceRefPtr service0(SetupConnectedService("",
2263                                                        nullptr, nullptr));
2264   NiceScopedMockLog log;
2265   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
2266   ScopeLogger::GetInstance()->set_verbose_level(2);
2267   EXPECT_CALL(log, Log(_, _, ContainsRegex("DisconnectFromIfActive.*service")))
2268       .Times(1);
2269   EXPECT_CALL(log,
2270               Log(_, _, ContainsRegex("DisconnectFrom[^a-zA-Z].*service")))
2271       .Times(1);
2272   EXPECT_CALL(*service0, IsActive(_)).Times(0);
2273   InitiateDisconnectIfActive(service0);
2274 
2275   Mock::VerifyAndClearExpectations(&log);
2276   Mock::VerifyAndClearExpectations(service0.get());
2277   ScopeLogger::GetInstance()->set_verbose_level(0);
2278   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
2279 }
2280 
TEST_F(WiFiMainTest,DisconnectWithWiFiServiceIdle)2281 TEST_F(WiFiMainTest, DisconnectWithWiFiServiceIdle) {
2282   StartWiFi();
2283   MockWiFiServiceRefPtr service0(SetupConnectedService("",
2284                                                        nullptr, nullptr));
2285   InitiateDisconnectIfActive(service0);
2286   MockWiFiServiceRefPtr service1(SetupConnectedService("",
2287                                                        nullptr, nullptr));
2288   NiceScopedMockLog log;
2289   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
2290   ScopeLogger::GetInstance()->set_verbose_level(2);
2291   EXPECT_CALL(log, Log(_, _, ContainsRegex("DisconnectFromIfActive.*service")))
2292       .Times(1);
2293   EXPECT_CALL(*service0, IsActive(_)).WillOnce(Return(false));
2294   EXPECT_CALL(log, Log(_, _, HasSubstr("is not active, no need"))).Times(1);
2295   EXPECT_CALL(log, Log(logging::LOG_WARNING, _,
2296                        ContainsRegex("In .*DisconnectFrom\\(.*\\):")))
2297       .Times(0);
2298   InitiateDisconnectIfActive(service0);
2299 
2300   Mock::VerifyAndClearExpectations(&log);
2301   Mock::VerifyAndClearExpectations(service0.get());
2302   ScopeLogger::GetInstance()->set_verbose_level(0);
2303   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
2304 }
2305 
TEST_F(WiFiMainTest,DisconnectWithWiFiServiceConnectedInError)2306 TEST_F(WiFiMainTest, DisconnectWithWiFiServiceConnectedInError) {
2307   StartWiFi();
2308   MockWiFiServiceRefPtr service0(SetupConnectedService("",
2309                                                        nullptr, nullptr));
2310   SetCurrentService(nullptr);
2311   ResetPendingService();
2312   NiceScopedMockLog log;
2313   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
2314   ScopeLogger::GetInstance()->set_verbose_level(2);
2315   EXPECT_CALL(log, Log(_, _, ContainsRegex("DisconnectFromIfActive.*service")))
2316       .Times(1);
2317   EXPECT_CALL(*service0, IsActive(_)).WillOnce(Return(true));
2318   EXPECT_CALL(log,
2319               Log(_, _, ContainsRegex("DisconnectFrom[^a-zA-Z].*service")))
2320       .Times(1);
2321   EXPECT_CALL(log, Log(logging::LOG_WARNING, _,
2322                        ContainsRegex("In .*DisconnectFrom\\(.*\\):"))).Times(1);
2323   InitiateDisconnectIfActive(service0);
2324 
2325   Mock::VerifyAndClearExpectations(&log);
2326   Mock::VerifyAndClearExpectations(service0.get());
2327   ScopeLogger::GetInstance()->set_verbose_level(0);
2328   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
2329 }
2330 
TEST_F(WiFiMainTest,TimeoutPendingServiceWithEndpoints)2331 TEST_F(WiFiMainTest, TimeoutPendingServiceWithEndpoints) {
2332   StartScan(WiFi::kScanMethodProgressive);
2333   const base::CancelableClosure& pending_timeout = GetPendingTimeout();
2334   EXPECT_TRUE(pending_timeout.IsCancelled());
2335   MockWiFiServiceRefPtr service = AttemptConnection(
2336       WiFi::kScanMethodProgressive, nullptr, nullptr);
2337 
2338   // Timeout the connection attempt.
2339   EXPECT_FALSE(pending_timeout.IsCancelled());
2340   EXPECT_EQ(service, GetPendingService());
2341   // Simulate a service with a wifi_ reference calling DisconnectFrom().
2342   EXPECT_CALL(*service,
2343               DisconnectWithFailure(Service::kFailureOutOfRange, _,
2344                                     HasSubstr("PendingTimeoutHandler")))
2345       .WillOnce(InvokeWithoutArgs(this, &WiFiObjectTest::ResetPendingService));
2346   EXPECT_CALL(*service, HasEndpoints()).Times(0);
2347   // DisconnectFrom() should not be called directly from WiFi.
2348   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(1);
2349   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect()).Times(0);
2350 
2351   // Innocuous redundant call to NotifyDeviceScanFinished.
2352   ExpectFoundNothing();
2353   EXPECT_CALL(*metrics(), NotifyDeviceConnectFinished(_)).Times(0);
2354   NiceScopedMockLog log;
2355   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
2356   ScopeLogger::GetInstance()->set_verbose_level(10);
2357   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
2358   EXPECT_CALL(log, Log(_, _,
2359                        HasSubstr("-> PROGRESSIVE_FINISHED_NOCONNECTION")));
2360   pending_timeout.callback().Run();
2361   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2362   // Service state should be idle, so it is connectable again.
2363   EXPECT_EQ(Service::kStateIdle, service->state());
2364   Mock::VerifyAndClearExpectations(service.get());
2365 
2366   ScopeLogger::GetInstance()->set_verbose_level(0);
2367   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
2368 }
2369 
TEST_F(WiFiMainTest,TimeoutPendingServiceWithoutEndpoints)2370 TEST_F(WiFiMainTest, TimeoutPendingServiceWithoutEndpoints) {
2371   StartWiFi();
2372   const base::CancelableClosure& pending_timeout = GetPendingTimeout();
2373   EXPECT_TRUE(pending_timeout.IsCancelled());
2374   MockWiFiServiceRefPtr service(
2375       SetupConnectingService("", nullptr, nullptr));
2376   EXPECT_FALSE(pending_timeout.IsCancelled());
2377   EXPECT_EQ(service, GetPendingService());
2378   // We expect the service to get a disconnect call, but in this scenario
2379   // the service does nothing.
2380   EXPECT_CALL(*service, DisconnectWithFailure(Service::kFailureOutOfRange,
2381                                               _,
2382                                               HasSubstr("PendingTimeoutHandler")));
2383   EXPECT_CALL(*service, HasEndpoints()).WillOnce(Return(false));
2384   // DisconnectFrom() should be called directly from WiFi.
2385   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(AtLeast(1));
2386   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2387   pending_timeout.callback().Run();
2388   EXPECT_EQ(nullptr, GetPendingService().get());
2389 }
2390 
TEST_F(WiFiMainTest,DisconnectInvalidService)2391 TEST_F(WiFiMainTest, DisconnectInvalidService) {
2392   StartWiFi();
2393   MockWiFiServiceRefPtr service;
2394   MakeNewEndpointAndService(0, 0, kNetworkModeAdHoc, nullptr, &service);
2395   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect()).Times(0);
2396   InitiateDisconnect(service);
2397 }
2398 
TEST_F(WiFiMainTest,DisconnectCurrentServiceFailure)2399 TEST_F(WiFiMainTest, DisconnectCurrentServiceFailure) {
2400   StartWiFi();
2401   string kPath("/fake/path");
2402   WiFiServiceRefPtr service(SetupConnectedService(kPath, nullptr, nullptr));
2403   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect())
2404       .WillRepeatedly(Return(false));
2405   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(kPath));
2406   InitiateDisconnect(service);
2407   EXPECT_EQ(nullptr, GetCurrentService().get());
2408 }
2409 
TEST_F(WiFiMainTest,Stop)2410 TEST_F(WiFiMainTest, Stop) {
2411   StartWiFi();
2412   WiFiEndpointRefPtr endpoint0;
2413   string kPath("/fake/path");
2414   WiFiServiceRefPtr service0(SetupConnectedService(kPath, &endpoint0, nullptr));
2415   WiFiEndpointRefPtr endpoint1;
2416   MakeNewEndpointAndService(0, 0, kNetworkModeAdHoc, &endpoint1, nullptr);
2417 
2418   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(endpoint0)))
2419       .WillOnce(Return(nullptr));
2420   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(endpoint1)))
2421       .WillOnce(Return(nullptr));
2422   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(kPath)).Times(1);
2423   StopWiFi();
2424   EXPECT_TRUE(GetScanTimer().IsCancelled());
2425   EXPECT_FALSE(wifi()->weak_ptr_factory_.HasWeakPtrs());
2426 }
2427 
TEST_F(WiFiMainTest,StopWhileConnected)2428 TEST_F(WiFiMainTest, StopWhileConnected) {
2429   StartWiFi();
2430   WiFiEndpointRefPtr endpoint;
2431   WiFiServiceRefPtr service(
2432       SetupConnectedService("", &endpoint, nullptr));
2433   unique_ptr<EndpointRemovalHandler> handler(
2434       MakeEndpointRemovalHandler(service));
2435   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(endpoint)))
2436       .WillOnce(Invoke(handler.get(),
2437                 &EndpointRemovalHandler::OnEndpointRemoved));
2438   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2439   StopWiFi();
2440   EXPECT_EQ(nullptr, GetCurrentService());;
2441 }
2442 
TEST_F(WiFiMainTest,ReconnectTimer)2443 TEST_F(WiFiMainTest, ReconnectTimer) {
2444   StartWiFi();
2445   MockWiFiServiceRefPtr service(
2446       SetupConnectedService("", nullptr, nullptr));
2447   EXPECT_CALL(*service, IsConnected()).WillRepeatedly(Return(true));
2448   EXPECT_TRUE(GetReconnectTimeoutCallback().IsCancelled());
2449   ReportStateChanged(WPASupplicant::kInterfaceStateDisconnected);
2450   EXPECT_FALSE(GetReconnectTimeoutCallback().IsCancelled());
2451   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
2452   EXPECT_TRUE(GetReconnectTimeoutCallback().IsCancelled());
2453   ReportStateChanged(WPASupplicant::kInterfaceStateDisconnected);
2454   EXPECT_FALSE(GetReconnectTimeoutCallback().IsCancelled());
2455   ReportCurrentBSSChanged(kBSSName);
2456   EXPECT_TRUE(GetReconnectTimeoutCallback().IsCancelled());
2457   ReportStateChanged(WPASupplicant::kInterfaceStateDisconnected);
2458   EXPECT_FALSE(GetReconnectTimeoutCallback().IsCancelled());
2459   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2460   GetReconnectTimeoutCallback().callback().Run();
2461   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2462   EXPECT_TRUE(GetReconnectTimeoutCallback().IsCancelled());
2463 }
2464 
2465 
2466 MATCHER_P(HasHiddenSSID_FullScan, ssid, "") {
2467   if (!arg.ContainsByteArrays(WPASupplicant::kPropertyScanSSIDs)) {
2468     return false;
2469   }
2470 
2471   ByteArrays ssids = arg.GetByteArrays(WPASupplicant::kPropertyScanSSIDs);
2472   // A valid Scan containing a single hidden SSID should contain
2473   // two SSID entries: one containing the SSID we are looking for,
2474   // and an empty entry, signifying that we also want to do a
2475   // broadcast probe request for all non-hidden APs as well.
2476   return ssids.size() == 2 && ssids[0] == ssid && ssids[1].empty();
2477 }
2478 
2479 MATCHER(HasNoHiddenSSID_FullScan, "") {
2480   return !arg.ContainsByteArrays(WPASupplicant::kPropertyScanSSIDs);
2481 }
2482 
TEST_F(WiFiMainTest,ScanHidden_FullScan)2483 TEST_F(WiFiMainTest, ScanHidden_FullScan) {
2484   EnableFullScan();
2485   vector<uint8_t>kSSID(1, 'a');
2486   ByteArrays ssids;
2487   ssids.push_back(kSSID);
2488 
2489   StartWiFi();
2490   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList()).WillOnce(Return(ssids));
2491   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
2492               Scan(HasHiddenSSID_FullScan(kSSID)));
2493   dispatcher_.DispatchPendingEvents();
2494 }
2495 
2496 // This test is slightly different from the test in scan_session_unittest.cc
2497 // because this tests the piece of WiFi that builds the SSID list.
TEST_F(WiFiMainTest,ScanHidden)2498 TEST_F(WiFiMainTest, ScanHidden) {
2499   // Clear the Mock ScanSession because hidden SSIDs are added when wifi
2500   // instantiates a new ScanSession (and it won't instantiate a new ScanSession
2501   // if there's already one there).
2502   ClearScanSession();
2503   vector<uint8_t>kSSID(1, 'a');
2504   ByteArrays ssids;
2505   ssids.push_back(kSSID);
2506 
2507   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList()).WillOnce(Return(ssids));
2508   StartWiFi();
2509   EXPECT_CALL(netlink_manager_,
2510               SendNl80211Message(HasHiddenSSID(kNl80211FamilyId), _, _, _));
2511   dispatcher_.DispatchPendingEvents();
2512 }
2513 
TEST_F(WiFiMainTest,ScanNoHidden_FullScan)2514 TEST_F(WiFiMainTest, ScanNoHidden_FullScan) {
2515   EnableFullScan();
2516   StartWiFi();
2517   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList())
2518       .WillOnce(Return(ByteArrays()));
2519   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(HasNoHiddenSSID_FullScan()));
2520   dispatcher_.DispatchPendingEvents();
2521 }
2522 
2523 // This test is slightly different from the test in scan_session_unittest.cc
2524 // because this tests the piece of WiFi that builds the SSID list.
TEST_F(WiFiMainTest,ScanNoHidden)2525 TEST_F(WiFiMainTest, ScanNoHidden) {
2526   // Clear the Mock ScanSession because hidden SSIDs are added when wifi
2527   // instantiates a new ScanSession (and it won't instantiate a new ScanSession
2528   // if there's already one there).
2529   ClearScanSession();
2530   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList())
2531       .WillOnce(Return(ByteArrays()));
2532   StartWiFi();
2533   EXPECT_CALL(netlink_manager_,
2534               SendNl80211Message(HasNoHiddenSSID(kNl80211FamilyId), _, _, _));
2535   dispatcher_.DispatchPendingEvents();
2536 }
2537 
TEST_F(WiFiMainTest,ScanWiFiDisabledAfterResume)2538 TEST_F(WiFiMainTest, ScanWiFiDisabledAfterResume) {
2539   ScopedMockLog log;
2540   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
2541   EXPECT_CALL(log, Log(_, _, EndsWith(
2542       "Ignoring scan request while device is not enabled."))).Times(1);
2543   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
2544   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
2545   StartWiFi();
2546   StopWiFi();
2547   // A scan is queued when WiFi resumes.
2548   OnAfterResume();
2549   dispatcher_.DispatchPendingEvents();
2550 }
2551 
TEST_F(WiFiMainTest,ScanRejected)2552 TEST_F(WiFiMainTest, ScanRejected) {
2553   StartWiFi();
2554   ReportScanDone();
2555   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2556 
2557   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_))
2558       .WillOnce(Return(false));
2559   TriggerScan(WiFi::kScanMethodFull);
2560   dispatcher_.DispatchPendingEvents();
2561   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2562 }
2563 
TEST_F(WiFiMainTest,ProgressiveScanFound)2564 TEST_F(WiFiMainTest, ProgressiveScanFound) {
2565   // Set min & max scan frequency count to 1 so each scan will be of a single
2566   // frequency.
2567   SetScanSize(1, 1);
2568 
2569   // Do the first scan (finds nothing).
2570   StartScan(WiFi::kScanMethodProgressive);
2571   EXPECT_CALL(*manager(), OnDeviceGeolocationInfoUpdated(_)).Times(0);
2572   ReportScanDoneKeepScanSession();
2573 
2574   // Do the second scan (connects afterwards).
2575   ExpectScanStart(WiFi::kScanMethodProgressive, true);
2576   dispatcher_.DispatchPendingEvents();
2577   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodProgressive);
2578   ReportScanDoneKeepScanSession();
2579 
2580   // Connect after second scan.
2581   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
2582   EXPECT_CALL(*metrics(), NotifyDeviceScanFinished(_));
2583   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
2584   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
2585   EXPECT_CALL(*adaptor_, EmitBoolChanged(kScanningProperty, false));
2586   SetPendingService(service);
2587 
2588   // Verify that the third scan aborts and there is no further scan.
2589   ScopedMockLog log;
2590   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
2591   EXPECT_CALL(log, Log(_, _, EndsWith(
2592       "Ignoring scan request while connecting to an AP."))).Times(1);
2593   dispatcher_.DispatchPendingEvents();
2594   VerifyScanState(WiFi::kScanConnecting, WiFi::kScanMethodProgressive);
2595 }
2596 
TEST_F(WiFiMainTest,ProgressiveScanNotFound)2597 TEST_F(WiFiMainTest, ProgressiveScanNotFound) {
2598   // Set min & max scan frequency count to 1 so each scan will be of a single
2599   // frequency.
2600   SetScanSize(1, 1);
2601 
2602   // This test never connects
2603   EXPECT_CALL(*metrics(), NotifyDeviceConnectStarted(_, _)).Times(0);
2604   EXPECT_CALL(*metrics(), NotifyDeviceConnectFinished(_)).Times(0);
2605 
2606   // Do the first scan (finds nothing).
2607   StartScan(WiFi::kScanMethodProgressive);
2608   ReportScanDoneKeepScanSession();
2609 
2610   // Do the second scan (finds nothing).
2611   ExpectScanStart(WiFi::kScanMethodProgressive, true);
2612   EXPECT_CALL(*manager(), OnDeviceGeolocationInfoUpdated(_)).Times(0);
2613   dispatcher_.DispatchPendingEvents();
2614   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodProgressive);
2615   ReportScanDoneKeepScanSession();
2616 
2617   // Do the third scan. After (simulated) exhausting of search frequencies,
2618   // verify that this scan uses supplicant rather than internal (progressive)
2619   // scan.
2620   EXPECT_CALL(*scan_session_, HasMoreFrequencies()).WillOnce(Return(false));
2621   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
2622   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
2623   dispatcher_.DispatchPendingEvents();
2624   VerifyScanState(WiFi::kScanScanning,
2625                   WiFi::kScanMethodProgressiveFinishedToFull);
2626 
2627   // And verify that ScanDone reports a complete scan (i.e., the
2628   // wifi_::scan_session_ has truly been cleared).
2629   ExpectScanStop();
2630   ExpectFoundNothing();
2631   ReportScanDoneKeepScanSession();
2632   dispatcher_.DispatchPendingEvents();  // Launch UpdateScanStateAfterScanDone
2633   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2634 }
2635 
TEST_F(WiFiMainTest,ProgressiveScanError)2636 TEST_F(WiFiMainTest, ProgressiveScanError) {
2637   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2638   ClearScanSession();  // Clear Mock ScanSession to get an actual ScanSession.
2639   StartWiFi();  // Posts |ProgressiveScanTask|.
2640 
2641   EXPECT_CALL(netlink_manager_, SendNl80211Message(
2642       IsNl80211Command(kNl80211FamilyId, NL80211_CMD_TRIGGER_SCAN), _, _, _));
2643   dispatcher_.DispatchPendingEvents();  // Executes |ProgressiveScanTask|.
2644 
2645   // Calls |WiFi::OnFailedProgressiveScan| which calls |ScanTask|
2646   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(1);
2647   NewScanResultsMessage not_supposed_to_get_this_message;
2648   OnTriggerScanResponse(not_supposed_to_get_this_message);
2649   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodProgressiveErrorToFull);
2650 
2651   EXPECT_TRUE(IsScanSessionNull());
2652 
2653   // Post and execute |UpdateScanStateAfterScanDone|.
2654   ReportScanDoneKeepScanSession();
2655   dispatcher_.DispatchPendingEvents();
2656   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2657 }
2658 
TEST_F(WiFiMainTest,InitialSupplicantState)2659 TEST_F(WiFiMainTest, InitialSupplicantState) {
2660   EXPECT_EQ(WiFi::kInterfaceStateUnknown, GetSupplicantState());
2661 }
2662 
TEST_F(WiFiMainTest,StateChangeNoService)2663 TEST_F(WiFiMainTest, StateChangeNoService) {
2664   // State change should succeed even if there is no pending Service.
2665   ReportStateChanged(WPASupplicant::kInterfaceStateScanning);
2666   EXPECT_EQ(WPASupplicant::kInterfaceStateScanning, GetSupplicantState());
2667 }
2668 
TEST_F(WiFiMainTest,StateChangeWithService)2669 TEST_F(WiFiMainTest, StateChangeWithService) {
2670   // Forward transition should trigger a Service state change.
2671   StartWiFi();
2672   dispatcher_.DispatchPendingEvents();
2673   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
2674   InitiateConnect(service);
2675   EXPECT_CALL(*service.get(), SetState(Service::kStateAssociating));
2676   ReportStateChanged(WPASupplicant::kInterfaceStateAssociated);
2677   // Verify expectations now, because WiFi may report other state changes
2678   // when WiFi is Stop()-ed (during TearDown()).
2679   Mock::VerifyAndClearExpectations(service.get());
2680   EXPECT_CALL(*service.get(), SetState(_)).Times(AnyNumber());
2681 }
2682 
TEST_F(WiFiMainTest,StateChangeBackwardsWithService)2683 TEST_F(WiFiMainTest, StateChangeBackwardsWithService) {
2684   // Some backwards transitions should not trigger a Service state change.
2685   // Supplicant state should still be updated, however.
2686   EXPECT_CALL(*dhcp_provider(), CreateIPv4Config(_, _, _, _))
2687       .Times(AnyNumber());
2688   EXPECT_CALL(*dhcp_config_.get(), RequestIP()).Times(AnyNumber());
2689   StartWiFi();
2690   dispatcher_.DispatchPendingEvents();
2691   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
2692   EXPECT_CALL(*service, SetState(Service::kStateAssociating));
2693   EXPECT_CALL(*service, SetState(Service::kStateConfiguring));
2694   EXPECT_CALL(*service, ResetSuspectedCredentialFailures());
2695   InitiateConnect(service);
2696   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
2697   ReportStateChanged(WPASupplicant::kInterfaceStateAuthenticating);
2698   EXPECT_EQ(WPASupplicant::kInterfaceStateAuthenticating,
2699             GetSupplicantState());
2700   // Verify expectations now, because WiFi may report other state changes
2701   // when WiFi is Stop()-ed (during TearDown()).
2702   Mock::VerifyAndClearExpectations(service.get());
2703   EXPECT_CALL(*service, SetState(_)).Times(AnyNumber());
2704 }
2705 
TEST_F(WiFiMainTest,ConnectToServiceWithoutRecentIssues)2706 TEST_F(WiFiMainTest, ConnectToServiceWithoutRecentIssues) {
2707   MockSupplicantProcessProxy* process_proxy = supplicant_process_proxy_;
2708   StartWiFi();
2709   dispatcher_.DispatchPendingEvents();
2710   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
2711   EXPECT_CALL(*process_proxy, GetDebugLevel(_)).Times(0);
2712   EXPECT_CALL(*process_proxy, SetDebugLevel(_)).Times(0);
2713   EXPECT_CALL(*service.get(), HasRecentConnectionIssues())
2714       .WillOnce(Return(false));
2715   InitiateConnect(service);
2716 }
2717 
TEST_F(WiFiMainTest,ConnectToServiceWithRecentIssues)2718 TEST_F(WiFiMainTest, ConnectToServiceWithRecentIssues) {
2719   // Turn of WiFi debugging, so the only reason we will turn on supplicant
2720   // debugging will be to debug a problematic connection.
2721   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
2722 
2723   MockSupplicantProcessProxy* process_proxy = supplicant_process_proxy_;
2724   StartWiFi();
2725   dispatcher_.DispatchPendingEvents();
2726   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
2727   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
2728       .WillOnce(
2729           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelInfo)),
2730                 Return(true)));
2731   EXPECT_CALL(*process_proxy, SetDebugLevel(WPASupplicant::kDebugLevelDebug))
2732       .Times(1);
2733   EXPECT_CALL(*service.get(), HasRecentConnectionIssues())
2734       .WillOnce(Return(true));
2735   InitiateConnect(service);
2736   Mock::VerifyAndClearExpectations(process_proxy);
2737 
2738   SetPendingService(nullptr);
2739   SetCurrentService(service);
2740 
2741   // When we disconnect from the troubled service, we should reduce the
2742   // level of supplicant debugging.
2743   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
2744       .WillOnce(
2745           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelDebug)),
2746                 Return(true)));
2747   EXPECT_CALL(*process_proxy, SetDebugLevel(WPASupplicant::kDebugLevelInfo))
2748       .Times(1);
2749   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
2750 }
2751 
TEST_F(WiFiMainTest,CurrentBSSChangeConnectedToDisconnected)2752 TEST_F(WiFiMainTest, CurrentBSSChangeConnectedToDisconnected) {
2753   StartWiFi();
2754   WiFiEndpointRefPtr endpoint;
2755   MockWiFiServiceRefPtr service =
2756       SetupConnectedService("", &endpoint, nullptr);
2757 
2758   EXPECT_CALL(*service, SetState(Service::kStateIdle)).Times(AtLeast(1));
2759   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
2760   EXPECT_EQ(nullptr, GetCurrentService().get());
2761   EXPECT_EQ(nullptr, GetPendingService().get());
2762   EXPECT_FALSE(GetIsRoamingInProgress());
2763 }
2764 
TEST_F(WiFiMainTest,CurrentBSSChangeConnectedToConnectedNewService)2765 TEST_F(WiFiMainTest, CurrentBSSChangeConnectedToConnectedNewService) {
2766   StartWiFi();
2767   MockWiFiServiceRefPtr service0 =
2768       SetupConnectedService("", nullptr, nullptr);
2769   MockWiFiServiceRefPtr service1;
2770   string bss_path1(MakeNewEndpointAndService(
2771       0, 0, kNetworkModeAdHoc, nullptr, &service1));
2772   EXPECT_EQ(service0.get(), GetCurrentService().get());
2773 
2774   // Note that we deliberately omit intermediate supplicant states
2775   // (e.g. kInterfaceStateAssociating), on the theory that they are
2776   // unreliable. Specifically, they may be quashed if the association
2777   // completes before supplicant flushes its changed properties.
2778   EXPECT_CALL(*service0, SetState(Service::kStateIdle)).Times(AtLeast(1));
2779   ReportCurrentBSSChanged(bss_path1);
2780   EXPECT_CALL(*service1, SetState(Service::kStateConfiguring));
2781   EXPECT_CALL(*service1, ResetSuspectedCredentialFailures());
2782   EXPECT_CALL(*wifi_provider(), IncrementConnectCount(_));
2783   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
2784   EXPECT_EQ(service1.get(), GetCurrentService().get());
2785   EXPECT_FALSE(GetIsRoamingInProgress());
2786   Mock::VerifyAndClearExpectations(service0.get());
2787   Mock::VerifyAndClearExpectations(service1.get());
2788 }
2789 
TEST_F(WiFiMainTest,CurrentBSSChangedUpdateServiceEndpoint)2790 TEST_F(WiFiMainTest, CurrentBSSChangedUpdateServiceEndpoint) {
2791   StartWiFi();
2792   dispatcher_.DispatchPendingEvents();
2793   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodProgressive);
2794 
2795   MockWiFiServiceRefPtr service =
2796       SetupConnectedService("", nullptr, nullptr);
2797   WiFiEndpointRefPtr endpoint;
2798   string bss_path =
2799       AddEndpointToService(service, 0, 0, kNetworkModeAdHoc, &endpoint);
2800   EXPECT_CALL(*service, NotifyCurrentEndpoint(EndpointMatch(endpoint)));
2801   ReportCurrentBSSChanged(bss_path);
2802   EXPECT_TRUE(GetIsRoamingInProgress());
2803   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
2804 
2805   // If we report a "completed" state change on a connected service after
2806   // wpa_supplicant has roamed, we should renew our IPConfig.
2807   scoped_refptr<MockIPConfig> ipconfig(
2808       new MockIPConfig(control_interface(), kDeviceName));
2809   SetIPConfig(ipconfig);
2810   EXPECT_CALL(*service, IsConnected()).WillOnce(Return(true));
2811   EXPECT_CALL(*ipconfig, RenewIP());
2812   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
2813   Mock::VerifyAndClearExpectations(ipconfig.get());
2814   EXPECT_FALSE(GetIsRoamingInProgress());
2815 }
2816 
TEST_F(WiFiMainTest,DisconnectReasonUpdated)2817 TEST_F(WiFiMainTest, DisconnectReasonUpdated) {
2818   ScopedMockLog log;
2819   int test_reason = 4;
2820   int test_reason_second = 0;
2821   EXPECT_CALL(*adaptor_, EmitBoolChanged(kPoweredProperty, _))
2822       .Times(AnyNumber());
2823   EXPECT_EQ(GetSupplicantDisconnectReason(), WiFi::kDefaultDisconnectReason);
2824   EXPECT_CALL(log,
2825               Log(logging::LOG_INFO, _, EndsWith(" DisconnectReason to 4")));
2826   ReportDisconnectReasonChanged(test_reason);
2827   EXPECT_EQ(GetSupplicantDisconnectReason(), test_reason);
2828   EXPECT_CALL(log,
2829               Log(logging::LOG_INFO, _, EndsWith("Reason to 0 (was 4)")));
2830   ReportDisconnectReasonChanged(test_reason_second);
2831   EXPECT_EQ(GetSupplicantDisconnectReason(), test_reason_second);
2832 }
2833 
TEST_F(WiFiMainTest,DisconnectReasonCleared)2834 TEST_F(WiFiMainTest, DisconnectReasonCleared) {
2835   int test_reason = 4;
2836   // Clearing the value for supplicant_disconnect_reason_ is done prior to any
2837   // early exits in the WiFi::StateChanged method.  This allows the value to be
2838   // checked without a mock pending or current service.
2839   ReportDisconnectReasonChanged(test_reason);
2840   EXPECT_EQ(wifi().get()->supplicant_disconnect_reason_, test_reason);
2841   ReportStateChanged(WPASupplicant::kInterfaceStateDisconnected);
2842   ReportStateChanged(WPASupplicant::kInterfaceStateAssociated);
2843   EXPECT_EQ(wifi().get()->supplicant_disconnect_reason_,
2844             WiFi::kDefaultDisconnectReason);
2845 }
2846 
TEST_F(WiFiMainTest,NewConnectPreemptsPending)2847 TEST_F(WiFiMainTest, NewConnectPreemptsPending) {
2848   StartWiFi();
2849   MockWiFiServiceRefPtr service0(
2850       SetupConnectingService("", nullptr, nullptr));
2851   EXPECT_EQ(service0.get(), GetPendingService().get());
2852   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
2853   MockWiFiServiceRefPtr service1(
2854       SetupConnectingService("", nullptr, nullptr));
2855   EXPECT_EQ(service1.get(), GetPendingService().get());
2856   EXPECT_EQ(nullptr, GetCurrentService().get());
2857 }
2858 
TEST_F(WiFiMainTest,ConnectedToUnintendedPreemptsPending)2859 TEST_F(WiFiMainTest, ConnectedToUnintendedPreemptsPending) {
2860   StartWiFi();
2861   string bss_path;
2862   // Connecting two different services back-to-back.
2863   MockWiFiServiceRefPtr unintended_service(
2864       SetupConnectingService("", nullptr, &bss_path));
2865   MockWiFiServiceRefPtr intended_service(
2866       SetupConnectingService("", nullptr, nullptr));
2867 
2868   // Verify the pending service.
2869   EXPECT_EQ(intended_service.get(), GetPendingService().get());
2870 
2871   // Connected to the unintended service (service0).
2872   ReportCurrentBSSChanged(bss_path);
2873 
2874   // Verify the pending service is disconnected, and the service state is back
2875   // to idle, so it is connectable again.
2876   EXPECT_EQ(nullptr, GetPendingService().get());
2877   EXPECT_EQ(nullptr, GetCurrentService().get());
2878   EXPECT_EQ(Service::kStateIdle, intended_service->state());
2879 }
2880 
TEST_F(WiFiMainTest,IsIdle)2881 TEST_F(WiFiMainTest, IsIdle) {
2882   StartWiFi();
2883   EXPECT_TRUE(wifi()->IsIdle());
2884   MockWiFiServiceRefPtr service(
2885       SetupConnectingService("", nullptr, nullptr));
2886   EXPECT_FALSE(wifi()->IsIdle());
2887 }
2888 
2889 MATCHER_P(WiFiAddedArgs, bgscan, "") {
2890   return arg.ContainsUint(WPASupplicant::kNetworkPropertyScanSSID) &&
2891       arg.ContainsUint(WPASupplicant::kNetworkPropertyDisableVHT) &&
2892       arg.ContainsString(WPASupplicant::kNetworkPropertyBgscan) == bgscan;
2893 }
2894 
TEST_F(WiFiMainTest,AddNetworkArgs)2895 TEST_F(WiFiMainTest, AddNetworkArgs) {
2896   StartWiFi();
2897   MockWiFiServiceRefPtr service;
2898   MakeNewEndpointAndService(0, 0, kNetworkModeAdHoc, nullptr, &service);
2899   EXPECT_CALL(*service, GetSupplicantConfigurationParameters());
2900   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
2901               AddNetwork(WiFiAddedArgs(true), _));
2902   EXPECT_TRUE(SetBgscanMethod(WPASupplicant::kNetworkBgscanMethodSimple));
2903   InitiateConnect(service);
2904 }
2905 
TEST_F(WiFiMainTest,AddNetworkArgsNoBgscan)2906 TEST_F(WiFiMainTest, AddNetworkArgsNoBgscan) {
2907   StartWiFi();
2908   MockWiFiServiceRefPtr service;
2909   MakeNewEndpointAndService(0, 0, kNetworkModeAdHoc, nullptr, &service);
2910   EXPECT_CALL(*service, GetSupplicantConfigurationParameters());
2911   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
2912               AddNetwork(WiFiAddedArgs(false), _));
2913   InitiateConnect(service);
2914 }
2915 
TEST_F(WiFiMainTest,AppendBgscan)2916 TEST_F(WiFiMainTest, AppendBgscan) {
2917   StartWiFi();
2918   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
2919   {
2920     // 1 endpoint, default bgscan method -- background scan disabled.
2921     KeyValueStore params;
2922     EXPECT_CALL(*service, GetEndpointCount()).WillOnce(Return(1));
2923     AppendBgscan(service.get(), &params);
2924     Mock::VerifyAndClearExpectations(service.get());
2925     EXPECT_FALSE(params.ContainsString(WPASupplicant::kNetworkPropertyBgscan));
2926   }
2927   {
2928     // 2 endpoints, default bgscan method -- background scan frequency reduced.
2929     KeyValueStore params;
2930     EXPECT_CALL(*service, GetEndpointCount()).WillOnce(Return(2));
2931     AppendBgscan(service.get(), &params);
2932     Mock::VerifyAndClearExpectations(service.get());
2933     string config_string;
2934     EXPECT_TRUE(params.ContainsString(WPASupplicant::kNetworkPropertyBgscan));
2935     config_string = params.GetString(WPASupplicant::kNetworkPropertyBgscan);
2936     vector<string> elements = base::SplitString(
2937         config_string, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
2938     ASSERT_EQ(4, elements.size());
2939     EXPECT_EQ(WiFi::kDefaultBgscanMethod, elements[0]);
2940     EXPECT_EQ(StringPrintf("%d", WiFi::kBackgroundScanIntervalSeconds),
2941               elements[3]);
2942   }
2943   {
2944     // Explicit bgscan method -- regular background scan frequency.
2945     EXPECT_TRUE(SetBgscanMethod(WPASupplicant::kNetworkBgscanMethodSimple));
2946     KeyValueStore params;
2947     EXPECT_CALL(*service, GetEndpointCount()).Times(0);
2948     AppendBgscan(service.get(), &params);
2949     Mock::VerifyAndClearExpectations(service.get());
2950     EXPECT_TRUE(params.ContainsString(WPASupplicant::kNetworkPropertyBgscan));
2951     string config_string =
2952         params.GetString(WPASupplicant::kNetworkPropertyBgscan);
2953     vector<string> elements = base::SplitString(
2954         config_string, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
2955     ASSERT_EQ(4, elements.size());
2956     EXPECT_EQ(StringPrintf("%d", WiFi::kDefaultScanIntervalSeconds),
2957               elements[3]);
2958   }
2959   {
2960     // No scan method, simply returns without appending properties
2961     EXPECT_TRUE(SetBgscanMethod(WPASupplicant::kNetworkBgscanMethodNone));
2962     KeyValueStore params;
2963     EXPECT_CALL(*service, GetEndpointCount()).Times(0);
2964     AppendBgscan(service.get(), &params);
2965     Mock::VerifyAndClearExpectations(service.get());
2966     string config_string;
2967     EXPECT_FALSE(params.ContainsString(WPASupplicant::kNetworkPropertyBgscan));
2968   }
2969 }
2970 
TEST_F(WiFiMainTest,StateAndIPIgnoreLinkEvent)2971 TEST_F(WiFiMainTest, StateAndIPIgnoreLinkEvent) {
2972   StartWiFi();
2973   MockWiFiServiceRefPtr service(
2974       SetupConnectingService("", nullptr, nullptr));
2975   EXPECT_CALL(*service.get(), SetState(_)).Times(0);
2976   EXPECT_CALL(*dhcp_config_.get(), RequestIP()).Times(0);
2977   ReportLinkUp();
2978 
2979   // Verify expectations now, because WiFi may cause |service| state
2980   // changes during TearDown().
2981   Mock::VerifyAndClearExpectations(service.get());
2982 }
2983 
TEST_F(WiFiMainTest,SupplicantCompletedAlreadyConnected)2984 TEST_F(WiFiMainTest, SupplicantCompletedAlreadyConnected) {
2985   StartWiFi();
2986   MockWiFiServiceRefPtr service(
2987       SetupConnectedService("", nullptr, nullptr));
2988   Mock::VerifyAndClearExpectations(dhcp_config_.get());
2989   EXPECT_CALL(*dhcp_config_.get(), RequestIP()).Times(0);
2990   // Simulate a rekeying event from the AP.  These show as transitions from
2991   // completed->completed from wpa_supplicant.
2992   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
2993   // When we get an IP, WiFi should enable high bitrates on the interface again.
2994   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
2995   EXPECT_CALL(*GetSupplicantInterfaceProxy(), EnableHighBitrates()).Times(1);
2996   EXPECT_CALL(*manager(), device_info()).WillOnce(Return(device_info()));
2997   ReportIPConfigComplete();
2998   // Similarly, rekeying events after we have an IP don't trigger L3
2999   // configuration.  However, we treat all transitions to completed as potential
3000   // reassociations, so we will reenable high rates again here.
3001   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
3002   EXPECT_CALL(*service, IsConnected()).WillOnce(Return(true));
3003   EXPECT_CALL(*GetSupplicantInterfaceProxy(), EnableHighBitrates()).Times(1);
3004   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
3005 }
3006 
TEST_F(WiFiMainTest,BSSAddedCreatesBSSProxy)3007 TEST_F(WiFiMainTest, BSSAddedCreatesBSSProxy) {
3008   // TODO(quiche): Consider using a factory for WiFiEndpoints, so that
3009   // we can test the interaction between WiFi and WiFiEndpoint. (Right
3010   // now, we're testing across multiple layers.)
3011   EXPECT_CALL(*supplicant_bss_proxy_, Die()).Times(AnyNumber());
3012   EXPECT_CALL(*control_interface(), CreateSupplicantBSSProxy(_, _));
3013   StartWiFi();
3014   ReportBSS("bss0", "ssid0", "00:00:00:00:00:00", 0, 0, kNetworkModeAdHoc);
3015 }
3016 
TEST_F(WiFiMainTest,BSSRemovedDestroysBSSProxy)3017 TEST_F(WiFiMainTest, BSSRemovedDestroysBSSProxy) {
3018   // TODO(quiche): As for BSSAddedCreatesBSSProxy, consider using a
3019   // factory for WiFiEndpoints.
3020   // Get the pointer before we transfer ownership.
3021   MockSupplicantBSSProxy* proxy = supplicant_bss_proxy_.get();
3022   EXPECT_CALL(*proxy, Die());
3023   StartWiFi();
3024   string bss_path(
3025       MakeNewEndpointAndService(0, 0, kNetworkModeAdHoc, nullptr, nullptr));
3026   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(_)).WillOnce(Return(nullptr));
3027   RemoveBSS(bss_path);
3028   // Check this now, to make sure RemoveBSS killed the proxy (rather
3029   // than TearDown).
3030   Mock::VerifyAndClearExpectations(proxy);
3031 }
3032 
TEST_F(WiFiMainTest,FlushBSSOnResume)3033 TEST_F(WiFiMainTest, FlushBSSOnResume) {
3034   const struct timeval resume_time = {1, 0};
3035   const struct timeval scan_done_time = {6, 0};
3036 
3037   StartWiFi();
3038 
3039   EXPECT_CALL(time_, GetTimeMonotonic(_))
3040       .WillOnce(DoAll(SetArgumentPointee<0>(resume_time), Return(0)))
3041       .WillOnce(DoAll(SetArgumentPointee<0>(scan_done_time), Return(0)));
3042   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
3043               FlushBSS(WiFi::kMaxBSSResumeAgeSeconds + 5));
3044   OnAfterResume();
3045   ReportScanDone();
3046 }
3047 
TEST_F(WiFiMainTest,CallWakeOnWiFi_OnScanDone)3048 TEST_F(WiFiMainTest, CallWakeOnWiFi_OnScanDone) {
3049   StartWiFi();
3050 
3051   // Call WakeOnWiFi::OnNoAutoConnetableServicesAfterScan if we find 0 auto-
3052   // connectable services.
3053   EXPECT_CALL(*wifi_provider(), NumAutoConnectableServices())
3054       .WillOnce(Return(0));
3055   EXPECT_TRUE(wifi()->IsIdle());
3056   EXPECT_CALL(*wake_on_wifi_, OnNoAutoConnectableServicesAfterScan(_, _, _));
3057   ReportScanDone();
3058 
3059   // If we have 1 or more auto-connectable services, do not call
3060   // WakeOnWiFi::OnNoAutoConnetableServicesAfterScan.
3061   EXPECT_CALL(*wifi_provider(), NumAutoConnectableServices())
3062       .WillOnce(Return(1));
3063   EXPECT_TRUE(wifi()->IsIdle());
3064   EXPECT_CALL(*wake_on_wifi_, OnNoAutoConnectableServicesAfterScan(_, _, _))
3065       .Times(0);
3066   ReportScanDone();
3067 
3068   // If the WiFi device is not Idle, do not call
3069   // WakeOnWiFi::OnNoAutoConnetableServicesAfterScan.
3070   SetCurrentService(MakeMockService(kSecurityWep));
3071   EXPECT_FALSE(wifi()->IsIdle());
3072   EXPECT_CALL(*wifi_provider(), NumAutoConnectableServices())
3073       .WillOnce(Return(0));
3074   EXPECT_CALL(*wake_on_wifi_, OnNoAutoConnectableServicesAfterScan(_, _, _))
3075       .Times(0);
3076   ReportScanDone();
3077 }
3078 
TEST_F(WiFiMainTest,ScanTimerIdle_FullScan)3079 TEST_F(WiFiMainTest, ScanTimerIdle_FullScan) {
3080   EnableFullScan();
3081   StartWiFi();
3082   dispatcher_.DispatchPendingEvents();
3083   ReportScanDone();
3084   CancelScanTimer();
3085   EXPECT_TRUE(GetScanTimer().IsCancelled());
3086 
3087   EXPECT_CALL(*manager(), OnDeviceGeolocationInfoUpdated(_));
3088   dispatcher_.DispatchPendingEvents();
3089   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_));
3090   FireScanTimer();
3091   dispatcher_.DispatchPendingEvents();
3092   EXPECT_FALSE(GetScanTimer().IsCancelled());  // Automatically re-armed.
3093 }
3094 
TEST_F(WiFiMainTest,ScanTimerIdle)3095 TEST_F(WiFiMainTest, ScanTimerIdle) {
3096   StartWiFi();
3097   dispatcher_.DispatchPendingEvents();
3098   ReportScanDone();
3099   CancelScanTimer();
3100   EXPECT_TRUE(GetScanTimer().IsCancelled());
3101   dispatcher_.DispatchPendingEvents();
3102   InstallMockScanSession();
3103   EXPECT_CALL(*scan_session_, InitiateScan());
3104   FireScanTimer();
3105   dispatcher_.DispatchPendingEvents();
3106   EXPECT_FALSE(GetScanTimer().IsCancelled());  // Automatically re-armed.
3107 }
3108 
TEST_F(WiFiMainTest,ScanTimerScanning)3109 TEST_F(WiFiMainTest, ScanTimerScanning) {
3110   StartWiFi();
3111   dispatcher_.DispatchPendingEvents();
3112   CancelScanTimer();
3113   EXPECT_TRUE(GetScanTimer().IsCancelled());
3114 
3115   // Should not call Scan, since we're already scanning.
3116   // (Scanning is triggered by StartWiFi.)
3117   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
3118   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
3119   FireScanTimer();
3120   dispatcher_.DispatchPendingEvents();
3121   EXPECT_FALSE(GetScanTimer().IsCancelled());  // Automatically re-armed.
3122 }
3123 
TEST_F(WiFiMainTest,ScanTimerConnecting)3124 TEST_F(WiFiMainTest, ScanTimerConnecting) {
3125   StartWiFi();
3126   dispatcher_.DispatchPendingEvents();
3127   MockWiFiServiceRefPtr service =
3128       SetupConnectingService("", nullptr, nullptr);
3129   CancelScanTimer();
3130   EXPECT_TRUE(GetScanTimer().IsCancelled());
3131 
3132   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
3133   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
3134   FireScanTimer();
3135   dispatcher_.DispatchPendingEvents();
3136   EXPECT_FALSE(GetScanTimer().IsCancelled());  // Automatically re-armed.
3137 }
3138 
TEST_F(WiFiMainTest,ScanTimerSuspending)3139 TEST_F(WiFiMainTest, ScanTimerSuspending) {
3140   EnableFullScan();
3141   StartWiFi();
3142   dispatcher_.DispatchPendingEvents();
3143   ReportScanDone();
3144   CancelScanTimer();
3145   EXPECT_TRUE(GetScanTimer().IsCancelled());
3146 
3147   EXPECT_CALL(*manager(), OnDeviceGeolocationInfoUpdated(_));
3148   dispatcher_.DispatchPendingEvents();
3149   EXPECT_CALL(*manager(), IsSuspending()).WillOnce(Return(true));
3150   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
3151   FireScanTimer();
3152   dispatcher_.DispatchPendingEvents();
3153   EXPECT_TRUE(GetScanTimer().IsCancelled());  // Do not re-arm.
3154 }
3155 
TEST_F(WiFiMainTest,ScanTimerReconfigured)3156 TEST_F(WiFiMainTest, ScanTimerReconfigured) {
3157   StartWiFi();
3158   CancelScanTimer();
3159   EXPECT_TRUE(GetScanTimer().IsCancelled());
3160 
3161   SetScanInterval(1, nullptr);
3162   EXPECT_FALSE(GetScanTimer().IsCancelled());
3163 }
3164 
TEST_F(WiFiMainTest,ScanTimerResetOnScanDone)3165 TEST_F(WiFiMainTest, ScanTimerResetOnScanDone) {
3166   StartWiFi();
3167   CancelScanTimer();
3168   EXPECT_TRUE(GetScanTimer().IsCancelled());
3169 
3170   ReportScanDone();
3171   EXPECT_FALSE(GetScanTimer().IsCancelled());
3172 }
3173 
TEST_F(WiFiMainTest,ScanTimerStopOnZeroInterval)3174 TEST_F(WiFiMainTest, ScanTimerStopOnZeroInterval) {
3175   StartWiFi();
3176   EXPECT_FALSE(GetScanTimer().IsCancelled());
3177 
3178   SetScanInterval(0, nullptr);
3179   EXPECT_TRUE(GetScanTimer().IsCancelled());
3180 }
3181 
TEST_F(WiFiMainTest,ScanOnDisconnectWithHidden_FullScan)3182 TEST_F(WiFiMainTest, ScanOnDisconnectWithHidden_FullScan) {
3183   EnableFullScan();
3184   StartWiFi();
3185   dispatcher_.DispatchPendingEvents();
3186   SetupConnectedService("", nullptr, nullptr);
3187   vector<uint8_t>kSSID(1, 'a');
3188   ByteArrays ssids;
3189   ssids.push_back(kSSID);
3190   ExpectScanIdle();
3191   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList())
3192       .WillRepeatedly(Return(ssids));
3193   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
3194               Scan(HasHiddenSSID_FullScan(kSSID)));
3195   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
3196   dispatcher_.DispatchPendingEvents();
3197 }
3198 
TEST_F(WiFiMainTest,ScanOnDisconnectWithHidden)3199 TEST_F(WiFiMainTest, ScanOnDisconnectWithHidden) {
3200   StartWiFi();
3201   dispatcher_.DispatchPendingEvents();
3202   ReportScanDone();
3203   SetupConnectedService("", nullptr, nullptr);
3204   InstallMockScanSession();
3205   vector<uint8_t>kSSID(1, 'a');
3206   ByteArrays ssids;
3207   ssids.push_back(kSSID);
3208   ExpectScanIdle();
3209   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList())
3210       .WillRepeatedly(Return(ssids));
3211   EXPECT_CALL(*scan_session_, InitiateScan());
3212   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
3213   dispatcher_.DispatchPendingEvents();
3214 }
3215 
TEST_F(WiFiMainTest,NoScanOnDisconnectWithoutHidden)3216 TEST_F(WiFiMainTest, NoScanOnDisconnectWithoutHidden) {
3217   StartWiFi();
3218   dispatcher_.DispatchPendingEvents();
3219   SetupConnectedService("", nullptr, nullptr);
3220   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
3221   EXPECT_TRUE(IsScanSessionNull());
3222   EXPECT_CALL(*wifi_provider(), GetHiddenSSIDList())
3223       .WillRepeatedly(Return(ByteArrays()));
3224   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
3225   dispatcher_.DispatchPendingEvents();
3226 }
3227 
TEST_F(WiFiMainTest,LinkMonitorFailure)3228 TEST_F(WiFiMainTest, LinkMonitorFailure) {
3229   ScopedMockLog log;
3230   auto link_monitor = new StrictMock<MockLinkMonitor>();
3231   StartWiFi();
3232   SetLinkMonitor(link_monitor);
3233   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
3234   EXPECT_CALL(*link_monitor, IsGatewayFound())
3235       .WillOnce(Return(false))
3236       .WillRepeatedly(Return(true));
3237 
3238   // We never had an ARP reply during this connection, so we assume
3239   // the problem is gateway, rather than link.
3240   EXPECT_CALL(log, Log(logging::LOG_INFO, _,
3241                        EndsWith("gateway was never found."))).Times(1);
3242   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Reattach()).Times(0);
3243   OnLinkMonitorFailure();
3244   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
3245 
3246   // No supplicant, so we can't Reattach.
3247   OnSupplicantVanish();
3248   EXPECT_CALL(log, Log(logging::LOG_ERROR, _,
3249                        EndsWith("Cannot reassociate."))).Times(1);
3250   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Reattach()).Times(0);
3251   OnLinkMonitorFailure();
3252   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
3253 
3254   // Normal case: call Reattach.
3255   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
3256   SetCurrentService(service);
3257   OnSupplicantAppear();
3258   EXPECT_CALL(log, Log(logging::LOG_INFO, _,
3259                        EndsWith("Called Reattach()."))).Times(1);
3260   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Reattach())
3261       .WillOnce(Return(true));
3262   OnLinkMonitorFailure();
3263   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
3264 
3265   // Service is unreliable, skip reassociate attempt.
3266   service->set_unreliable(true);
3267   EXPECT_CALL(log, Log(logging::LOG_INFO, _,
3268                        EndsWith("skipping reassociate attempt."))).Times(1);
3269   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Reattach()).Times(0);
3270   OnLinkMonitorFailure();
3271   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
3272 }
3273 
TEST_F(WiFiMainTest,UnreliableLink)3274 TEST_F(WiFiMainTest, UnreliableLink) {
3275   StartWiFi();
3276   SetupConnectedService("", nullptr, nullptr);
3277 
3278   EXPECT_CALL(*GetSupplicantInterfaceProxy(), SetHT40Enable(_, false)).Times(1);
3279   OnUnreliableLink();
3280   Mock::VerifyAndClearExpectations(GetSupplicantInterfaceProxy());
3281 }
3282 
TEST_F(WiFiMainTest,SuspectCredentialsOpen)3283 TEST_F(WiFiMainTest, SuspectCredentialsOpen) {
3284   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
3285   EXPECT_CALL(*service, AddSuspectedCredentialFailure()).Times(0);
3286   EXPECT_FALSE(SuspectCredentials(service, nullptr));
3287 }
3288 
TEST_F(WiFiMainTest,SuspectCredentialsWPA)3289 TEST_F(WiFiMainTest, SuspectCredentialsWPA) {
3290   MockWiFiServiceRefPtr service = MakeMockService(kSecurityWpa);
3291   ReportStateChanged(WPASupplicant::kInterfaceState4WayHandshake);
3292   EXPECT_CALL(*service, AddSuspectedCredentialFailure())
3293       .WillOnce(Return(false))
3294       .WillOnce(Return(true));
3295   EXPECT_FALSE(SuspectCredentials(service, nullptr));
3296   Service::ConnectFailure failure;
3297   EXPECT_TRUE(SuspectCredentials(service, &failure));
3298   EXPECT_EQ(Service::kFailureBadPassphrase, failure);
3299 }
3300 
TEST_F(WiFiMainTest,SuspectCredentialsWEP)3301 TEST_F(WiFiMainTest, SuspectCredentialsWEP) {
3302   StartWiFi();
3303   dispatcher_.DispatchPendingEvents();
3304   MockWiFiServiceRefPtr service = MakeMockService(kSecurityWep);
3305   ExpectConnecting();
3306   InitiateConnect(service);
3307   SetCurrentService(service);
3308 
3309   // These expectations are very much like SetupConnectedService except
3310   // that we verify that ResetSupsectCredentialFailures() is not called
3311   // on the service just because supplicant entered the Completed state.
3312   EXPECT_CALL(*service, SetState(Service::kStateConfiguring));
3313   EXPECT_CALL(*service, ResetSuspectedCredentialFailures()).Times(0);
3314   EXPECT_CALL(*dhcp_provider(), CreateIPv4Config(_, _, _, _))
3315       .Times(AnyNumber());
3316   EXPECT_CALL(*dhcp_config_.get(), RequestIP()).Times(AnyNumber());
3317   EXPECT_CALL(*manager(), device_info()).WillRepeatedly(Return(device_info()));
3318   EXPECT_CALL(*device_info(), GetByteCounts(_, _, _))
3319       .WillOnce(DoAll(SetArgumentPointee<2>(0LL), Return(true)));
3320   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
3321 
3322   Mock::VerifyAndClearExpectations(device_info());
3323   Mock::VerifyAndClearExpectations(service.get());
3324 
3325   // Successful connect.
3326   EXPECT_CALL(*GetSupplicantInterfaceProxy(), EnableHighBitrates()).Times(1);
3327   EXPECT_CALL(*service, ResetSuspectedCredentialFailures());
3328   ReportConnected();
3329 
3330   EXPECT_CALL(*device_info(), GetByteCounts(_, _, _))
3331       .WillOnce(DoAll(SetArgumentPointee<2>(1LL), Return(true)))
3332       .WillOnce(DoAll(SetArgumentPointee<2>(0LL), Return(true)))
3333       .WillOnce(DoAll(SetArgumentPointee<2>(0LL), Return(true)));
3334 
3335   // If there was an increased byte-count while we were timing out DHCP,
3336   // this should be considered a DHCP failure and not a credential failure.
3337   EXPECT_CALL(*service, ResetSuspectedCredentialFailures()).Times(0);
3338   EXPECT_CALL(*service, DisconnectWithFailure(Service::kFailureDHCP,
3339                                               _,
3340                                               HasSubstr("OnIPConfigFailure")));
3341   ReportIPConfigFailure();
3342   Mock::VerifyAndClearExpectations(service.get());
3343 
3344   // Connection failed during DHCP but service does not (yet) believe this is
3345   // due to a passphrase issue.
3346   EXPECT_CALL(*service, AddSuspectedCredentialFailure())
3347       .WillOnce(Return(false));
3348   EXPECT_CALL(*service, DisconnectWithFailure(Service::kFailureDHCP,
3349                                               _,
3350                                               HasSubstr("OnIPConfigFailure")));
3351   ReportIPConfigFailure();
3352   Mock::VerifyAndClearExpectations(service.get());
3353 
3354   // Connection failed during DHCP and service believes this is due to a
3355   // passphrase issue.
3356   EXPECT_CALL(*service, AddSuspectedCredentialFailure())
3357       .WillOnce(Return(true));
3358   EXPECT_CALL(*service,
3359               DisconnectWithFailure(Service::kFailureBadPassphrase,
3360                                     _,
3361                                     HasSubstr("OnIPConfigFailure")));
3362   ReportIPConfigFailure();
3363 }
3364 
TEST_F(WiFiMainTest,SuspectCredentialsEAPInProgress)3365 TEST_F(WiFiMainTest, SuspectCredentialsEAPInProgress) {
3366   MockWiFiServiceRefPtr service = MakeMockService(kSecurity8021x);
3367   EXPECT_CALL(*eap_state_handler_, is_eap_in_progress())
3368       .WillOnce(Return(false))
3369       .WillOnce(Return(true))
3370       .WillOnce(Return(false))
3371       .WillOnce(Return(true));
3372   EXPECT_CALL(*service, AddSuspectedCredentialFailure()).Times(0);
3373   EXPECT_FALSE(SuspectCredentials(service, nullptr));
3374   Mock::VerifyAndClearExpectations(service.get());
3375 
3376   EXPECT_CALL(*service, AddSuspectedCredentialFailure()).WillOnce(Return(true));
3377   Service::ConnectFailure failure;
3378   EXPECT_TRUE(SuspectCredentials(service, &failure));
3379   EXPECT_EQ(Service::kFailureEAPAuthentication, failure);
3380   Mock::VerifyAndClearExpectations(service.get());
3381 
3382   EXPECT_CALL(*service, AddSuspectedCredentialFailure()).Times(0);
3383   EXPECT_FALSE(SuspectCredentials(service, nullptr));
3384   Mock::VerifyAndClearExpectations(service.get());
3385 
3386   EXPECT_CALL(*service, AddSuspectedCredentialFailure())
3387       .WillOnce(Return(false));
3388   EXPECT_FALSE(SuspectCredentials(service, nullptr));
3389 }
3390 
TEST_F(WiFiMainTest,SuspectCredentialsYieldFailureWPA)3391 TEST_F(WiFiMainTest, SuspectCredentialsYieldFailureWPA) {
3392   MockWiFiServiceRefPtr service = MakeMockService(kSecurityWpa);
3393   SetPendingService(service);
3394   ReportStateChanged(WPASupplicant::kInterfaceState4WayHandshake);
3395 
3396   ExpectScanIdle();
3397   EXPECT_CALL(*service, AddSuspectedCredentialFailure()).WillOnce(Return(true));
3398   EXPECT_CALL(*service, SetFailure(Service::kFailureBadPassphrase));
3399   EXPECT_CALL(*service, SetState(Service::kStateIdle));
3400   ScopedMockLog log;
3401   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
3402   EXPECT_CALL(log, Log(logging::LOG_ERROR, _, EndsWith(kErrorBadPassphrase)));
3403   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
3404 }
3405 
TEST_F(WiFiMainTest,SuspectCredentialsYieldFailureEAP)3406 TEST_F(WiFiMainTest, SuspectCredentialsYieldFailureEAP) {
3407   MockWiFiServiceRefPtr service = MakeMockService(kSecurity8021x);
3408   SetCurrentService(service);
3409 
3410   ScopedMockLog log;
3411   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
3412   EXPECT_CALL(*service, SetState(Service::kStateIdle));
3413   // Ensure that we retrieve is_eap_in_progress() before resetting the
3414   // EAP handler's state.
3415   InSequence seq;
3416   EXPECT_CALL(*eap_state_handler_, is_eap_in_progress())
3417       .WillOnce(Return(true));
3418   EXPECT_CALL(*service, AddSuspectedCredentialFailure()).WillOnce(Return(true));
3419   EXPECT_CALL(*service, SetFailure(Service::kFailureEAPAuthentication));
3420   EXPECT_CALL(log, Log(logging::LOG_ERROR, _,
3421                        EndsWith(kErrorEapAuthenticationFailed)));
3422   EXPECT_CALL(*eap_state_handler_, Reset());
3423   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
3424 }
3425 
TEST_F(WiFiMainTest,ReportConnectedToServiceAfterWake_CallsWakeOnWiFi)3426 TEST_F(WiFiMainTest, ReportConnectedToServiceAfterWake_CallsWakeOnWiFi) {
3427   EXPECT_CALL(*wake_on_wifi_,
3428               ReportConnectedToServiceAfterWake(IsConnectedToCurrentService()));
3429   ReportConnectedToServiceAfterWake();
3430 }
3431 
3432 // Scanning tests will use a mock of the event dispatcher instead of a real
3433 // one.
3434 class WiFiTimerTest : public WiFiObjectTest {
3435  public:
WiFiTimerTest()3436   WiFiTimerTest() : WiFiObjectTest(&mock_dispatcher_) {}
3437 
3438  protected:
3439   void ExpectInitialScanSequence();
3440 
3441   StrictMock<MockEventDispatcher> mock_dispatcher_;
3442 };
3443 
ExpectInitialScanSequence()3444 void WiFiTimerTest::ExpectInitialScanSequence() {
3445   // Choose a number of iterations some multiple higher than the fast scan
3446   // count.
3447   const int kScanTimes = WiFi::kNumFastScanAttempts * 4;
3448 
3449   // Each time we call FireScanTimer() below, WiFi will post a task to actually
3450   // run Scan() on the wpa_supplicant proxy.
3451   EXPECT_CALL(mock_dispatcher_, PostTask(_))
3452       .Times(kScanTimes);
3453   {
3454     InSequence seq;
3455     // The scans immediately after the initial scan should happen at the short
3456     // interval.  If we add the initial scan (not invoked in this function) to
3457     // the ones in the expectation below, we get WiFi::kNumFastScanAttempts at
3458     // the fast scan interval.
3459     EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3460         _, WiFi::kFastScanIntervalSeconds * 1000))
3461         .Times(WiFi::kNumFastScanAttempts - 1);
3462 
3463     // After this, the WiFi device should use the normal scan interval.
3464     EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3465         _, GetScanInterval() * 1000))
3466         .Times(kScanTimes - WiFi::kNumFastScanAttempts + 1);
3467 
3468     for (int i = 0; i < kScanTimes; i++) {
3469       FireScanTimer();
3470     }
3471   }
3472 }
3473 
TEST_F(WiFiTimerTest,FastRescan)3474 TEST_F(WiFiTimerTest, FastRescan) {
3475   // This is to cover calls to PostDelayedTask by WakeOnWiFi::StartMetricsTimer.
3476   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(AnyNumber());
3477   // This PostTask is a result of the call to Scan(nullptr), and is meant to
3478   // post a task to call Scan() on the wpa_supplicant proxy immediately.
3479   EXPECT_CALL(mock_dispatcher_, PostTask(_));
3480   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3481       _, WiFi::kFastScanIntervalSeconds * 1000));
3482   StartWiFi();
3483 
3484   ExpectInitialScanSequence();
3485 
3486   // If we end up disconnecting, the sequence should repeat.
3487   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3488       _, WiFi::kFastScanIntervalSeconds * 1000));
3489   RestartFastScanAttempts();
3490 
3491   ExpectInitialScanSequence();
3492 }
3493 
TEST_F(WiFiTimerTest,ReconnectTimer)3494 TEST_F(WiFiTimerTest, ReconnectTimer) {
3495   EXPECT_CALL(mock_dispatcher_, PostTask(_)).Times(AnyNumber());
3496   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(AnyNumber());
3497   StartWiFi();
3498   SetupConnectedService("", nullptr, nullptr);
3499   Mock::VerifyAndClearExpectations(&mock_dispatcher_);
3500 
3501   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3502       _, GetReconnectTimeoutSeconds() * 1000)).Times(1);
3503   StartReconnectTimer();
3504   Mock::VerifyAndClearExpectations(&mock_dispatcher_);
3505   StopReconnectTimer();
3506 
3507   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3508       _, GetReconnectTimeoutSeconds() * 1000)).Times(1);
3509   StartReconnectTimer();
3510   Mock::VerifyAndClearExpectations(&mock_dispatcher_);
3511   GetReconnectTimeoutCallback().callback().Run();
3512 
3513   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3514       _, GetReconnectTimeoutSeconds() * 1000)).Times(1);
3515   StartReconnectTimer();
3516   Mock::VerifyAndClearExpectations(&mock_dispatcher_);
3517 
3518   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3519       _, GetReconnectTimeoutSeconds() * 1000)).Times(0);
3520   StartReconnectTimer();
3521 }
3522 
TEST_F(WiFiTimerTest,RequestStationInfo)3523 TEST_F(WiFiTimerTest, RequestStationInfo) {
3524   EXPECT_CALL(mock_dispatcher_, PostTask(_)).Times(AnyNumber());
3525   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(AnyNumber());
3526 
3527   // Setup a connected service here while we have the expectations above set.
3528   StartWiFi();
3529   MockWiFiServiceRefPtr service =
3530       SetupConnectedService("", nullptr, nullptr);
3531   string connected_bss = GetSupplicantBSS();
3532   Mock::VerifyAndClearExpectations(&mock_dispatcher_);
3533 
3534   EXPECT_CALL(netlink_manager_, SendNl80211Message(_, _, _, _)).Times(0);
3535   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(0);
3536   NiceScopedMockLog log;
3537 
3538   // There is no current_service_.
3539   EXPECT_CALL(log, Log(_, _, HasSubstr("we are not connected")));
3540   SetCurrentService(nullptr);
3541   RequestStationInfo();
3542 
3543   // current_service_ is not connected.
3544   EXPECT_CALL(*service, IsConnected()).WillOnce(Return(false));
3545   SetCurrentService(service);
3546   EXPECT_CALL(log, Log(_, _, HasSubstr("we are not connected")));
3547   RequestStationInfo();
3548 
3549   // Endpoint does not exist in endpoint_by_rpcid_.
3550   EXPECT_CALL(*service, IsConnected()).WillRepeatedly(Return(true));
3551   SetSupplicantBSS("/some/path/that/does/not/exist/in/endpoint_by_rpcid");
3552   EXPECT_CALL(log, Log(_, _, HasSubstr(
3553       "Can't get endpoint for current supplicant BSS")));
3554   RequestStationInfo();
3555   Mock::VerifyAndClearExpectations(&netlink_manager_);
3556   Mock::VerifyAndClearExpectations(&mock_dispatcher_);
3557 
3558   // We successfully trigger a request to get the station and start a timer
3559   // for the next call.
3560   EXPECT_CALL(netlink_manager_, SendNl80211Message(
3561       IsNl80211Command(kNl80211FamilyId, NL80211_CMD_GET_STATION), _, _, _));
3562   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(
3563       _, WiFi::kRequestStationInfoPeriodSeconds * 1000));
3564   SetSupplicantBSS(connected_bss);
3565   RequestStationInfo();
3566 
3567   // Now test that a properly formatted New Station message updates strength.
3568   NewStationMessage new_station;
3569   new_station.attributes()->CreateRawAttribute(NL80211_ATTR_MAC, "BSSID");
3570 
3571   // Confirm that up until now no link statistics exist.
3572   KeyValueStore link_statistics = GetLinkStatistics();
3573   EXPECT_TRUE(link_statistics.IsEmpty());
3574 
3575   // Use a reference to the endpoint instance in the WiFi device instead of
3576   // the copy returned by SetupConnectedService().
3577   WiFiEndpointRefPtr endpoint = GetEndpointMap().begin()->second;
3578   new_station.attributes()->SetRawAttributeValue(
3579       NL80211_ATTR_MAC, ByteString::CreateFromHexString(endpoint->bssid_hex()));
3580   new_station.attributes()->CreateNestedAttribute(
3581       NL80211_ATTR_STA_INFO, "Station Info");
3582   AttributeListRefPtr station_info;
3583   new_station.attributes()->GetNestedAttributeList(
3584       NL80211_ATTR_STA_INFO, &station_info);
3585   station_info->CreateU8Attribute(NL80211_STA_INFO_SIGNAL, "Signal");
3586   const int kSignalValue = -20;
3587   station_info->SetU8AttributeValue(NL80211_STA_INFO_SIGNAL, kSignalValue);
3588   station_info->CreateU8Attribute(NL80211_STA_INFO_SIGNAL_AVG, "SignalAverage");
3589   const int kSignalAvgValue = -40;
3590   station_info->SetU8AttributeValue(NL80211_STA_INFO_SIGNAL_AVG,
3591                                     kSignalAvgValue);
3592   station_info->CreateU32Attribute(NL80211_STA_INFO_INACTIVE_TIME,
3593                                    "InactiveTime");
3594   const int32_t kInactiveTime = 100;
3595   station_info->SetU32AttributeValue(NL80211_STA_INFO_INACTIVE_TIME,
3596                                      kInactiveTime);
3597   station_info->CreateU32Attribute(NL80211_STA_INFO_RX_PACKETS,
3598                                    "ReceivedSuccesses");
3599   const int32_t kReceiveSuccesses = 200;
3600   station_info->SetU32AttributeValue(NL80211_STA_INFO_RX_PACKETS,
3601                                      kReceiveSuccesses);
3602   station_info->CreateU32Attribute(NL80211_STA_INFO_TX_FAILED,
3603                                    "TransmitFailed");
3604   const int32_t kTransmitFailed = 300;
3605   station_info->SetU32AttributeValue(NL80211_STA_INFO_TX_FAILED,
3606                                      kTransmitFailed);
3607   station_info->CreateU32Attribute(NL80211_STA_INFO_TX_PACKETS,
3608                                    "TransmitSuccesses");
3609   const int32_t kTransmitSuccesses = 400;
3610   station_info->SetU32AttributeValue(NL80211_STA_INFO_TX_PACKETS,
3611                                      kTransmitSuccesses);
3612   station_info->CreateU32Attribute(NL80211_STA_INFO_TX_RETRIES,
3613                                    "TransmitRetries");
3614   const int32_t kTransmitRetries = 500;
3615   station_info->SetU32AttributeValue(NL80211_STA_INFO_TX_RETRIES,
3616                                      kTransmitRetries);
3617   station_info->CreateNestedAttribute(NL80211_STA_INFO_TX_BITRATE,
3618                                       "Bitrate Info");
3619 
3620   // Embed transmit bitrate info within the station info element.
3621   AttributeListRefPtr bitrate_info;
3622   station_info->GetNestedAttributeList(
3623       NL80211_STA_INFO_TX_BITRATE, &bitrate_info);
3624   bitrate_info->CreateU16Attribute(NL80211_RATE_INFO_BITRATE, "Bitrate");
3625   const int16_t kBitrate = 6005;
3626   bitrate_info->SetU16AttributeValue(NL80211_RATE_INFO_BITRATE, kBitrate);
3627   bitrate_info->CreateU8Attribute(NL80211_RATE_INFO_MCS, "MCS");
3628   const int16_t kMCS = 7;
3629   bitrate_info->SetU8AttributeValue(NL80211_RATE_INFO_MCS, kMCS);
3630   bitrate_info->CreateFlagAttribute(NL80211_RATE_INFO_40_MHZ_WIDTH, "HT40");
3631   bitrate_info->SetFlagAttributeValue(NL80211_RATE_INFO_40_MHZ_WIDTH, true);
3632   bitrate_info->CreateFlagAttribute(NL80211_RATE_INFO_SHORT_GI, "SGI");
3633   bitrate_info->SetFlagAttributeValue(NL80211_RATE_INFO_SHORT_GI, false);
3634   station_info->SetNestedAttributeHasAValue(NL80211_STA_INFO_TX_BITRATE);
3635 
3636   new_station.attributes()->SetNestedAttributeHasAValue(NL80211_ATTR_STA_INFO);
3637 
3638   EXPECT_NE(kSignalValue, endpoint->signal_strength());
3639   EXPECT_CALL(*wifi_provider(), OnEndpointUpdated(EndpointMatch(endpoint)));
3640   EXPECT_CALL(*metrics(), NotifyWifiTxBitrate(kBitrate/10));
3641   AttributeListConstRefPtr station_info_prime;
3642   ReportReceivedStationInfo(new_station);
3643   EXPECT_EQ(kSignalValue, endpoint->signal_strength());
3644 
3645   link_statistics = GetLinkStatistics();
3646   ASSERT_FALSE(link_statistics.IsEmpty());
3647   ASSERT_TRUE(link_statistics.ContainsInt(kLastReceiveSignalDbmProperty));
3648   EXPECT_EQ(kSignalValue,
3649             link_statistics.GetInt(kLastReceiveSignalDbmProperty));
3650   ASSERT_TRUE(link_statistics.ContainsInt(kAverageReceiveSignalDbmProperty));
3651   EXPECT_EQ(kSignalAvgValue,
3652             link_statistics.GetInt(kAverageReceiveSignalDbmProperty));
3653   ASSERT_TRUE(link_statistics.ContainsUint(kInactiveTimeMillisecondsProperty));
3654   EXPECT_EQ(kInactiveTime,
3655             link_statistics.GetUint(kInactiveTimeMillisecondsProperty));
3656   ASSERT_TRUE(link_statistics.ContainsUint(kPacketReceiveSuccessesProperty));
3657   EXPECT_EQ(kReceiveSuccesses,
3658             link_statistics.GetUint(kPacketReceiveSuccessesProperty));
3659   ASSERT_TRUE(link_statistics.ContainsUint(kPacketTransmitFailuresProperty));
3660   EXPECT_EQ(kTransmitFailed,
3661             link_statistics.GetUint(kPacketTransmitFailuresProperty));
3662   ASSERT_TRUE(link_statistics.ContainsUint(kPacketTransmitSuccessesProperty));
3663   EXPECT_EQ(kTransmitSuccesses,
3664             link_statistics.GetUint(kPacketTransmitSuccessesProperty));
3665   ASSERT_TRUE(link_statistics.ContainsUint(kTransmitRetriesProperty));
3666   EXPECT_EQ(kTransmitRetries,
3667             link_statistics.GetUint(kTransmitRetriesProperty));
3668   EXPECT_EQ(StringPrintf("%d.%d MBit/s MCS %d 40MHz",
3669                          kBitrate / 10, kBitrate % 10, kMCS),
3670             link_statistics.LookupString(kTransmitBitrateProperty, ""));
3671 
3672   // New station info with VHT rate parameters.
3673   NewStationMessage new_vht_station;
3674   new_vht_station.attributes()->CreateRawAttribute(NL80211_ATTR_MAC, "BSSID");
3675 
3676   new_vht_station.attributes()->SetRawAttributeValue(
3677       NL80211_ATTR_MAC, ByteString::CreateFromHexString(endpoint->bssid_hex()));
3678   new_vht_station.attributes()->CreateNestedAttribute(
3679       NL80211_ATTR_STA_INFO, "Station Info");
3680   new_vht_station.attributes()->GetNestedAttributeList(
3681       NL80211_ATTR_STA_INFO, &station_info);
3682   station_info->CreateU8Attribute(NL80211_STA_INFO_SIGNAL, "Signal");
3683   station_info->SetU8AttributeValue(NL80211_STA_INFO_SIGNAL, kSignalValue);
3684   station_info->CreateNestedAttribute(NL80211_STA_INFO_TX_BITRATE,
3685                                       "Bitrate Info");
3686 
3687   // Embed transmit VHT bitrate info within the station info element.
3688   station_info->GetNestedAttributeList(
3689       NL80211_STA_INFO_TX_BITRATE, &bitrate_info);
3690   bitrate_info->CreateU32Attribute(NL80211_RATE_INFO_BITRATE32, "Bitrate32");
3691   const int32_t kVhtBitrate = 70000;
3692   bitrate_info->SetU32AttributeValue(NL80211_RATE_INFO_BITRATE32, kVhtBitrate);
3693   bitrate_info->CreateU8Attribute(NL80211_RATE_INFO_VHT_MCS, "VHT-MCS");
3694   const int8_t kVhtMCS = 7;
3695   bitrate_info->SetU8AttributeValue(NL80211_RATE_INFO_VHT_MCS, kVhtMCS);
3696   bitrate_info->CreateU8Attribute(NL80211_RATE_INFO_VHT_NSS, "VHT-NSS");
3697   const int8_t kVhtNSS = 1;
3698   bitrate_info->SetU8AttributeValue(NL80211_RATE_INFO_VHT_NSS, kVhtNSS);
3699   bitrate_info->CreateFlagAttribute(NL80211_RATE_INFO_80_MHZ_WIDTH, "VHT80");
3700   bitrate_info->SetFlagAttributeValue(NL80211_RATE_INFO_80_MHZ_WIDTH, true);
3701   bitrate_info->CreateFlagAttribute(NL80211_RATE_INFO_SHORT_GI, "SGI");
3702   bitrate_info->SetFlagAttributeValue(NL80211_RATE_INFO_SHORT_GI, false);
3703   station_info->SetNestedAttributeHasAValue(NL80211_STA_INFO_TX_BITRATE);
3704 
3705   new_vht_station.attributes()->SetNestedAttributeHasAValue(
3706       NL80211_ATTR_STA_INFO);
3707 
3708   EXPECT_CALL(*metrics(), NotifyWifiTxBitrate(kVhtBitrate/10));
3709 
3710   ReportReceivedStationInfo(new_vht_station);
3711 
3712   link_statistics = GetLinkStatistics();
3713   EXPECT_EQ(StringPrintf("%d.%d MBit/s VHT-MCS %d 80MHz VHT-NSS %d",
3714                          kVhtBitrate / 10, kVhtBitrate % 10, kVhtMCS, kVhtNSS),
3715             link_statistics.LookupString(kTransmitBitrateProperty, ""));
3716 }
3717 
TEST_F(WiFiTimerTest,ResumeDispatchesConnectivityReportTask)3718 TEST_F(WiFiTimerTest, ResumeDispatchesConnectivityReportTask) {
3719   EXPECT_CALL(mock_dispatcher_, PostTask(_)).Times(AnyNumber());
3720   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(AnyNumber());
3721   StartWiFi();
3722   SetupConnectedService("", nullptr, nullptr);
3723   EXPECT_CALL(
3724       mock_dispatcher_,
3725       PostDelayedTask(_, WiFi::kPostWakeConnectivityReportDelayMilliseconds));
3726   OnAfterResume();
3727 }
3728 
TEST_F(WiFiTimerTest,StartScanTimer_ReturnsImmediately)3729 TEST_F(WiFiTimerTest, StartScanTimer_ReturnsImmediately) {
3730   Error e;
3731   // Return immediately if scan interval is 0.
3732   SetScanInterval(0, &e);
3733   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, _)).Times(0);
3734   StartScanTimer();
3735 }
3736 
TEST_F(WiFiTimerTest,StartScanTimer_HaveFastScansRemaining)3737 TEST_F(WiFiTimerTest, StartScanTimer_HaveFastScansRemaining) {
3738   Error e;
3739   const int scan_interval = 10;
3740   SetScanInterval(scan_interval, &e);
3741   SetFastScansRemaining(1);
3742   EXPECT_CALL(mock_dispatcher_,
3743               PostDelayedTask(_, WiFi::kFastScanIntervalSeconds * 1000));
3744   StartScanTimer();
3745 }
3746 
TEST_F(WiFiTimerTest,StartScanTimer_NoFastScansRemaining)3747 TEST_F(WiFiTimerTest, StartScanTimer_NoFastScansRemaining) {
3748   Error e;
3749   const int scan_interval = 10;
3750   SetScanInterval(scan_interval, &e);
3751   SetFastScansRemaining(0);
3752   EXPECT_CALL(mock_dispatcher_, PostDelayedTask(_, scan_interval * 1000));
3753   StartScanTimer();
3754 }
3755 
TEST_F(WiFiMainTest,EAPCertification)3756 TEST_F(WiFiMainTest, EAPCertification) {
3757   MockWiFiServiceRefPtr service = MakeMockService(kSecurity8021x);
3758   EXPECT_CALL(*service, AddEAPCertification(_, _)).Times(0);
3759 
3760   ScopedMockLog log;
3761   EXPECT_CALL(log, Log(logging::LOG_ERROR, _, EndsWith("no current service.")));
3762   KeyValueStore args;
3763   ReportCertification(args);
3764   Mock::VerifyAndClearExpectations(&log);
3765 
3766   SetCurrentService(service);
3767   EXPECT_CALL(log, Log(logging::LOG_ERROR, _, EndsWith("no depth parameter.")));
3768   ReportCertification(args);
3769   Mock::VerifyAndClearExpectations(&log);
3770 
3771   const uint32_t kDepth = 123;
3772   args.SetUint(WPASupplicant::kInterfacePropertyDepth, kDepth);
3773 
3774   EXPECT_CALL(log,
3775               Log(logging::LOG_ERROR, _, EndsWith("no subject parameter.")));
3776   ReportCertification(args);
3777   Mock::VerifyAndClearExpectations(&log);
3778 
3779   const string kSubject("subject");
3780   args.SetString(WPASupplicant::kInterfacePropertySubject, kSubject);
3781   EXPECT_CALL(*service, AddEAPCertification(kSubject, kDepth)).Times(1);
3782   ReportCertification(args);
3783 }
3784 
TEST_F(WiFiTimerTest,ScanDoneDispatchesTasks)3785 TEST_F(WiFiTimerTest, ScanDoneDispatchesTasks) {
3786   // Dispatch WiFi::ScanFailedTask if scan failed.
3787   EXPECT_TRUE(ScanFailedCallbackIsCancelled());
3788   EXPECT_CALL(mock_dispatcher_,
3789               PostDelayedTask(_, WiFi::kPostScanFailedDelayMilliseconds));
3790   ScanDone(false);
3791   EXPECT_FALSE(ScanFailedCallbackIsCancelled());
3792 
3793   // Dispatch WiFi::ScanDoneTask if scan succeeded, and cancel the scan failed
3794   // callback if has been dispatched.
3795   EXPECT_CALL(mock_dispatcher_, PostTask(_));
3796   ScanDone(true);
3797   EXPECT_TRUE(ScanFailedCallbackIsCancelled());
3798 }
3799 
TEST_F(WiFiMainTest,EAPEvent)3800 TEST_F(WiFiMainTest, EAPEvent) {
3801   StartWiFi();
3802   ScopedMockLog log;
3803   EXPECT_CALL(log, Log(logging::LOG_ERROR, _, EndsWith("no current service.")));
3804   EXPECT_CALL(*eap_state_handler_, ParseStatus(_, _, _)).Times(0);
3805   const string kEAPStatus("eap-status");
3806   const string kEAPParameter("eap-parameter");
3807   ReportEAPEvent(kEAPStatus, kEAPParameter);
3808   Mock::VerifyAndClearExpectations(&log);
3809   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
3810 
3811   MockWiFiServiceRefPtr service = MakeMockService(kSecurity8021x);
3812   EXPECT_CALL(*service, SetFailure(_)).Times(0);
3813   EXPECT_CALL(*eap_state_handler_, ParseStatus(kEAPStatus, kEAPParameter, _));
3814   SetCurrentService(service);
3815   ReportEAPEvent(kEAPStatus, kEAPParameter);
3816   Mock::VerifyAndClearExpectations(service.get());
3817   Mock::VerifyAndClearExpectations(eap_state_handler_);
3818 
3819   EXPECT_CALL(*eap_state_handler_, ParseStatus(kEAPStatus, kEAPParameter, _))
3820       .WillOnce(DoAll(SetArgumentPointee<2>(Service::kFailureOutOfRange),
3821                 Return(false)));
3822   EXPECT_CALL(*service, DisconnectWithFailure(Service::kFailureOutOfRange,
3823                                               _,
3824                                               HasSubstr("EAPEventTask")));
3825   ReportEAPEvent(kEAPStatus, kEAPParameter);
3826 
3827   MockEapCredentials* eap = new MockEapCredentials();
3828   service->eap_.reset(eap);  // Passes ownership.
3829   const char kNetworkRpcId[] = "/service/network/rpcid";
3830   SetServiceNetworkRpcId(service, kNetworkRpcId);
3831   EXPECT_CALL(*eap_state_handler_, ParseStatus(kEAPStatus, kEAPParameter, _))
3832       .WillOnce(DoAll(SetArgumentPointee<2>(Service::kFailurePinMissing),
3833                 Return(false)));
3834   // We need a real string object since it will be returned by reference below.
3835   const string kEmptyPin;
3836   EXPECT_CALL(*eap, pin()).WillOnce(ReturnRef(kEmptyPin));
3837   EXPECT_CALL(*service, DisconnectWithFailure(Service::kFailurePinMissing,
3838                                               _,
3839                                               HasSubstr("EAPEventTask")));
3840   ReportEAPEvent(kEAPStatus, kEAPParameter);
3841 
3842   EXPECT_CALL(*eap_state_handler_, ParseStatus(kEAPStatus, kEAPParameter, _))
3843       .WillOnce(DoAll(SetArgumentPointee<2>(Service::kFailurePinMissing),
3844                 Return(false)));
3845   // We need a real string object since it will be returned by reference below.
3846   const string kPin("000000");
3847   EXPECT_CALL(*eap, pin()).WillOnce(ReturnRef(kPin));
3848   EXPECT_CALL(*service, DisconnectWithFailure(_, _, _)).Times(0);
3849   EXPECT_CALL(*GetSupplicantInterfaceProxy(),
3850               NetworkReply(StrEq(kNetworkRpcId),
3851                            StrEq(WPASupplicant::kEAPRequestedParameterPIN),
3852                            Ref(kPin)));
3853   ReportEAPEvent(kEAPStatus, kEAPParameter);
3854 }
3855 
TEST_F(WiFiMainTest,PendingScanDoesNotCrashAfterStop)3856 TEST_F(WiFiMainTest, PendingScanDoesNotCrashAfterStop) {
3857   // Scan is one task that should be skipped after Stop. Others are
3858   // skipped by the same mechanism (invalidating weak pointers), so we
3859   // don't test them individually.
3860   //
3861   // Note that we can't test behavior by setting expectations on the
3862   // supplicant_interface_proxy_, since that is destroyed when we StopWiFi().
3863   StartWiFi();
3864   StopWiFi();
3865   dispatcher_.DispatchPendingEvents();
3866 }
3867 
3868 struct BSS {
3869   string bsspath;
3870   string ssid;
3871   string bssid;
3872   int16_t signal_strength;
3873   uint16_t frequency;
3874   const char* mode;
3875 };
3876 
TEST_F(WiFiMainTest,GetGeolocationObjects)3877 TEST_F(WiFiMainTest, GetGeolocationObjects) {
3878   BSS bsses[] = {
3879     {"bssid1", "ssid1", "00:00:00:00:00:00", 5, Metrics::kWiFiFrequency2412,
3880      kNetworkModeInfrastructure},
3881     {"bssid2", "ssid2", "01:00:00:00:00:00", 30, Metrics::kWiFiFrequency5170,
3882      kNetworkModeInfrastructure},
3883     // Same SSID but different BSSID is an additional geolocation object.
3884     {"bssid3", "ssid1", "02:00:00:00:00:00", 100, 0,
3885      kNetworkModeInfrastructure}
3886   };
3887   StartWiFi();
3888   vector<GeolocationInfo> objects;
3889   EXPECT_EQ(objects.size(), 0);
3890 
3891   for (size_t i = 0; i < arraysize(bsses); ++i) {
3892     ReportBSS(bsses[i].bsspath, bsses[i].ssid, bsses[i].bssid,
3893               bsses[i].signal_strength, bsses[i].frequency, bsses[i].mode);
3894     objects = wifi()->GetGeolocationObjects();
3895     EXPECT_EQ(objects.size(), i + 1);
3896 
3897     GeolocationInfo expected_info;
3898     expected_info.AddField(kGeoMacAddressProperty, bsses[i].bssid);
3899     expected_info.AddField(kGeoSignalStrengthProperty,
3900                            StringPrintf("%d", bsses[i].signal_strength));
3901     expected_info.AddField(kGeoChannelProperty, StringPrintf(
3902         "%d", Metrics::WiFiFrequencyToChannel(bsses[i].frequency)));
3903     EXPECT_TRUE(objects[i].Equals(expected_info));
3904   }
3905 }
3906 
TEST_F(WiFiMainTest,SetSupplicantDebugLevel)3907 TEST_F(WiFiMainTest, SetSupplicantDebugLevel) {
3908   MockSupplicantProcessProxy* process_proxy = supplicant_process_proxy_;
3909 
3910   // With WiFi not yet started, nothing interesting (including a crash) should
3911   // happen.
3912   EXPECT_CALL(*process_proxy, GetDebugLevel(_)).Times(0);
3913   EXPECT_CALL(*process_proxy, SetDebugLevel(_)).Times(0);
3914   ReportWiFiDebugScopeChanged(true);
3915 
3916   // This unit test turns on WiFi debugging, so when we start WiFi, we should
3917   // check but not set the debug level if we return the "debug" level.
3918   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
3919       .WillOnce(
3920           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelDebug)),
3921                 Return(true)));
3922   EXPECT_CALL(*process_proxy, SetDebugLevel(_)).Times(0);
3923   StartWiFi();
3924   Mock::VerifyAndClearExpectations(process_proxy);
3925 
3926   // If WiFi debugging is toggled and wpa_supplicant reports debugging
3927   // is set to some unmanaged level, WiFi should leave it alone.
3928   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
3929       .WillOnce(
3930           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelError)),
3931                 Return(true)))
3932       .WillOnce(
3933           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelError)),
3934                 Return(true)))
3935       .WillOnce(
3936           DoAll(SetArgumentPointee<0>(
3937                     string(WPASupplicant::kDebugLevelExcessive)),
3938                 Return(true)))
3939       .WillOnce(
3940           DoAll(SetArgumentPointee<0>(
3941                     string(WPASupplicant::kDebugLevelExcessive)),
3942                 Return(true)))
3943       .WillOnce(
3944           DoAll(SetArgumentPointee<0>(
3945                     string(WPASupplicant::kDebugLevelMsgDump)),
3946                 Return(true)))
3947       .WillOnce(
3948           DoAll(SetArgumentPointee<0>(
3949                     string(WPASupplicant::kDebugLevelMsgDump)),
3950                 Return(true)))
3951       .WillOnce(
3952           DoAll(SetArgumentPointee<0>(
3953                     string(WPASupplicant::kDebugLevelWarning)),
3954                 Return(true)))
3955       .WillOnce(
3956           DoAll(SetArgumentPointee<0>(
3957                     string(WPASupplicant::kDebugLevelWarning)),
3958                 Return(true)));
3959   EXPECT_CALL(*process_proxy, SetDebugLevel(_)).Times(0);
3960   ReportWiFiDebugScopeChanged(true);
3961   ReportWiFiDebugScopeChanged(false);
3962   ReportWiFiDebugScopeChanged(true);
3963   ReportWiFiDebugScopeChanged(false);
3964   ReportWiFiDebugScopeChanged(true);
3965   ReportWiFiDebugScopeChanged(false);
3966   ReportWiFiDebugScopeChanged(true);
3967   ReportWiFiDebugScopeChanged(false);
3968   Mock::VerifyAndClearExpectations(process_proxy);
3969 
3970   // If WiFi debugging is turned off and wpa_supplicant reports debugging
3971   // is turned on, WiFi should turn supplicant debugging off.
3972   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
3973       .WillOnce(
3974           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelDebug)),
3975                 Return(true)));
3976   EXPECT_CALL(*process_proxy, SetDebugLevel(WPASupplicant::kDebugLevelInfo))
3977       .Times(1);
3978   ReportWiFiDebugScopeChanged(false);
3979   Mock::VerifyAndClearExpectations(process_proxy);
3980 
3981   // If WiFi debugging is turned on and wpa_supplicant reports debugging
3982   // is turned off, WiFi should turn supplicant debugging on.
3983   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
3984       .WillOnce(
3985           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelInfo)),
3986                 Return(true)));
3987   EXPECT_CALL(*process_proxy, SetDebugLevel(WPASupplicant::kDebugLevelDebug))
3988       .Times(1);
3989   ReportWiFiDebugScopeChanged(true);
3990   Mock::VerifyAndClearExpectations(process_proxy);
3991 
3992   // If WiFi debugging is already in the correct state, it should not be
3993   // changed.
3994   EXPECT_CALL(*process_proxy, GetDebugLevel(_))
3995       .WillOnce(
3996           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelDebug)),
3997                 Return(true)))
3998       .WillOnce(
3999           DoAll(SetArgumentPointee<0>(string(WPASupplicant::kDebugLevelInfo)),
4000                 Return(true)));
4001   EXPECT_CALL(*process_proxy, SetDebugLevel(_)).Times(0);
4002   ReportWiFiDebugScopeChanged(true);
4003   ReportWiFiDebugScopeChanged(false);
4004 
4005   // After WiFi is stopped, we shouldn't be calling the proxy.
4006   EXPECT_CALL(*process_proxy, GetDebugLevel(_)).Times(0);
4007   EXPECT_CALL(*process_proxy, SetDebugLevel(_)).Times(0);
4008   StopWiFi();
4009   ReportWiFiDebugScopeChanged(true);
4010   ReportWiFiDebugScopeChanged(false);
4011 }
4012 
TEST_F(WiFiMainTest,LogSSID)4013 TEST_F(WiFiMainTest, LogSSID) {
4014   EXPECT_EQ("[SSID=]", WiFi::LogSSID(""));
4015   EXPECT_EQ("[SSID=foo\\x5b\\x09\\x5dbar]", WiFi::LogSSID("foo[\t]bar"));
4016 }
4017 
4018 // Custom property setters should return false, and make no changes, if
4019 // the new value is the same as the old value.
TEST_F(WiFiMainTest,CustomSetterNoopChange)4020 TEST_F(WiFiMainTest, CustomSetterNoopChange) {
4021   // SetBgscanShortInterval
4022   {
4023     Error error;
4024     static const uint16_t kKnownScanInterval = 4;
4025     // Set to known value.
4026     EXPECT_TRUE(SetBgscanShortInterval(kKnownScanInterval, &error));
4027     EXPECT_TRUE(error.IsSuccess());
4028     // Set to same value.
4029     EXPECT_FALSE(SetBgscanShortInterval(kKnownScanInterval, &error));
4030     EXPECT_TRUE(error.IsSuccess());
4031   }
4032 
4033   // SetBgscanSignalThreshold
4034   {
4035     Error error;
4036     static const int32_t kKnownSignalThreshold = 4;
4037     // Set to known value.
4038     EXPECT_TRUE(SetBgscanSignalThreshold(kKnownSignalThreshold, &error));
4039     EXPECT_TRUE(error.IsSuccess());
4040     // Set to same value.
4041     EXPECT_FALSE(SetBgscanSignalThreshold(kKnownSignalThreshold, &error));
4042     EXPECT_TRUE(error.IsSuccess());
4043   }
4044 
4045   // SetScanInterval
4046   {
4047     Error error;
4048     EXPECT_FALSE(SetScanInterval(GetScanInterval(), &error));
4049     EXPECT_TRUE(error.IsSuccess());
4050   }
4051 }
4052 
4053 // The following tests check the scan_state_ / scan_method_ state machine.
4054 
TEST_F(WiFiMainTest,FullScanFindsNothing)4055 TEST_F(WiFiMainTest, FullScanFindsNothing) {
4056   StartScan(WiFi::kScanMethodFull);
4057   ReportScanDone();
4058   ExpectScanStop();
4059   ExpectFoundNothing();
4060   NiceScopedMockLog log;
4061   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4062   ScopeLogger::GetInstance()->set_verbose_level(10);
4063   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4064   EXPECT_CALL(log, Log(_, _, HasSubstr("FULL_NOCONNECTION ->")));
4065   EXPECT_CALL(*manager(), OnDeviceGeolocationInfoUpdated(_));
4066   dispatcher_.DispatchPendingEvents();  // Launch UpdateScanStateAfterScanDone
4067   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4068 
4069   ScopeLogger::GetInstance()->set_verbose_level(0);
4070   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4071 }
4072 
TEST_F(WiFiMainTest,FullScanConnectingToConnected)4073 TEST_F(WiFiMainTest, FullScanConnectingToConnected) {
4074   StartScan(WiFi::kScanMethodFull);
4075   WiFiEndpointRefPtr endpoint;
4076   string bss_path;
4077   MockWiFiServiceRefPtr service = AttemptConnection(WiFi::kScanMethodFull,
4078                                                     &endpoint,
4079                                                     &bss_path);
4080 
4081   // Complete the connection.
4082   ExpectConnected();
4083   EXPECT_CALL(*service, NotifyCurrentEndpoint(EndpointMatch(endpoint)));
4084   NiceScopedMockLog log;
4085   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4086   ScopeLogger::GetInstance()->set_verbose_level(10);
4087   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4088   EXPECT_CALL(log, Log(_, _, HasSubstr("-> FULL_CONNECTED")));
4089   ReportCurrentBSSChanged(bss_path);
4090   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4091 
4092   ScopeLogger::GetInstance()->set_verbose_level(0);
4093   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4094 }
4095 
TEST_F(WiFiMainTest,ProgressiveScanConnectingToConnected)4096 TEST_F(WiFiMainTest, ProgressiveScanConnectingToConnected) {
4097   StartScan(WiFi::kScanMethodProgressive);
4098   WiFiEndpointRefPtr endpoint;
4099   string bss_path;
4100   MockWiFiServiceRefPtr service = AttemptConnection(
4101       WiFi::kScanMethodProgressive, &endpoint, &bss_path);
4102 
4103   // Complete the connection.
4104   ExpectConnected();
4105   EXPECT_CALL(*service, NotifyCurrentEndpoint(EndpointMatch(endpoint)));
4106   NiceScopedMockLog log;
4107   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4108   ScopeLogger::GetInstance()->set_verbose_level(10);
4109   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4110   EXPECT_CALL(log, Log(_, _, HasSubstr("-> PROGRESSIVE_CONNECTED")));
4111   ReportCurrentBSSChanged(bss_path);
4112   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4113 
4114   ScopeLogger::GetInstance()->set_verbose_level(0);
4115   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4116 }
4117 
TEST_F(WiFiMainTest,ProgressiveScanConnectingToNotFound)4118 TEST_F(WiFiMainTest, ProgressiveScanConnectingToNotFound) {
4119   StartScan(WiFi::kScanMethodProgressive);
4120   WiFiEndpointRefPtr endpoint;
4121   MockWiFiServiceRefPtr service = AttemptConnection(
4122       WiFi::kScanMethodProgressive, &endpoint, nullptr);
4123 
4124   // Simulate connection timeout.
4125   ExpectFoundNothing();
4126   EXPECT_CALL(*service,
4127               NotifyCurrentEndpoint(EndpointMatch(endpoint))).Times(0);
4128   NiceScopedMockLog log;
4129   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4130   ScopeLogger::GetInstance()->set_verbose_level(10);
4131   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4132   EXPECT_CALL(log,
4133               Log(_, _, HasSubstr("-> PROGRESSIVE_FINISHED_NOCONNECTION")));
4134   EXPECT_CALL(*metrics(), NotifyDeviceConnectFinished(_)).Times(0);
4135   TimeoutPendingConnection();
4136   ScopeLogger::GetInstance()->set_verbose_level(0);
4137   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4138   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4139 }
4140 
TEST_F(WiFiMainTest,ScanStateUma)4141 TEST_F(WiFiMainTest, ScanStateUma) {
4142   EXPECT_CALL(*metrics(), SendEnumToUMA(Metrics::kMetricScanResult, _, _)).
4143       Times(0);
4144   EXPECT_CALL(*metrics(), NotifyDeviceScanStarted(_));
4145   SetScanState(WiFi::kScanScanning, WiFi::kScanMethodProgressive, __func__);
4146 
4147   EXPECT_CALL(*metrics(), NotifyDeviceScanFinished(_));
4148   EXPECT_CALL(*metrics(), NotifyDeviceConnectStarted(_, _));
4149   SetScanState(WiFi::kScanConnecting, WiFi::kScanMethodProgressive, __func__);
4150 
4151   ExpectScanIdle();  // After connected.
4152   EXPECT_CALL(*metrics(), NotifyDeviceConnectFinished(_));
4153   EXPECT_CALL(*metrics(), SendEnumToUMA(Metrics::kMetricScanResult, _, _));
4154   SetScanState(WiFi::kScanConnected, WiFi::kScanMethodProgressive, __func__);
4155 }
4156 
TEST_F(WiFiMainTest,ScanStateNotScanningNoUma)4157 TEST_F(WiFiMainTest, ScanStateNotScanningNoUma) {
4158   EXPECT_CALL(*metrics(), NotifyDeviceScanStarted(_)).Times(0);
4159   EXPECT_CALL(*metrics(), NotifyDeviceConnectStarted(_, _));
4160   SetScanState(WiFi::kScanConnecting, WiFi::kScanMethodNone, __func__);
4161 
4162   ExpectScanIdle();  // After connected.
4163   EXPECT_CALL(*metrics(), NotifyDeviceConnectFinished(_));
4164   EXPECT_CALL(*metrics(), SendEnumToUMA(Metrics::kMetricScanResult, _, _)).
4165       Times(0);
4166   SetScanState(WiFi::kScanConnected, WiFi::kScanMethodNone, __func__);
4167 }
4168 
TEST_F(WiFiMainTest,ConnectToServiceNotPending)4169 TEST_F(WiFiMainTest, ConnectToServiceNotPending) {
4170   // Test for SetPendingService(nullptr), condition a)
4171   // |ConnectTo|->|DisconnectFrom|.
4172   StartScan(WiFi::kScanMethodProgressive);
4173 
4174   // Setup pending service.
4175   ExpectScanStop();
4176   ExpectConnecting();
4177   MockWiFiServiceRefPtr service_pending(
4178       SetupConnectingService("", nullptr, nullptr));
4179   EXPECT_EQ(service_pending.get(), GetPendingService().get());
4180 
4181   // ConnectTo a different service than the pending one.
4182   ExpectConnecting();
4183   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Disconnect());
4184   NiceScopedMockLog log;
4185   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4186   ScopeLogger::GetInstance()->set_verbose_level(10);
4187   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4188   EXPECT_CALL(log, Log(_, _, HasSubstr("-> TRANSITION_TO_CONNECTING")));
4189   EXPECT_CALL(log, Log(_, _, HasSubstr("-> PROGRESSIVE_CONNECTING")));
4190   MockWiFiServiceRefPtr service_connecting(
4191       SetupConnectingService("", nullptr, nullptr));
4192   ScopeLogger::GetInstance()->set_verbose_level(0);
4193   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4194   EXPECT_EQ(service_connecting.get(), GetPendingService().get());
4195   EXPECT_EQ(nullptr, GetCurrentService().get());
4196   VerifyScanState(WiFi::kScanConnecting, WiFi::kScanMethodProgressive);
4197 
4198   ExpectScanIdle();  // To silence messages from the destructor.
4199 }
4200 
TEST_F(WiFiMainTest,ConnectToWithError)4201 TEST_F(WiFiMainTest, ConnectToWithError) {
4202   StartScan(WiFi::kScanMethodProgressive);
4203 
4204   ExpectScanIdle();
4205   EXPECT_CALL(*GetSupplicantInterfaceProxy(), AddNetwork(_, _)).
4206       WillOnce(Return(false));
4207   EXPECT_CALL(*metrics(), NotifyDeviceScanFinished(_)).Times(0);
4208   EXPECT_CALL(*metrics(), SendEnumToUMA(Metrics::kMetricScanResult, _, _)).
4209       Times(0);
4210   EXPECT_CALL(*adaptor_, EmitBoolChanged(kScanningProperty, false));
4211   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
4212   EXPECT_CALL(*service, GetSupplicantConfigurationParameters());
4213   InitiateConnect(service);
4214   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4215   EXPECT_TRUE(IsScanSessionNull());
4216 }
4217 
TEST_F(WiFiMainTest,ScanStateHandleDisconnect)4218 TEST_F(WiFiMainTest, ScanStateHandleDisconnect) {
4219   // Test for SetPendingService(nullptr), condition d) Disconnect while
4220   // scanning.
4221 
4222   // Start scanning.
4223   StartScan(WiFi::kScanMethodProgressive);
4224 
4225   // Set the pending service.
4226   ReportScanDoneKeepScanSession();
4227   ExpectScanStop();
4228   ExpectConnecting();
4229   MockWiFiServiceRefPtr service = MakeMockService(kSecurityNone);
4230   SetPendingService(service);
4231   VerifyScanState(WiFi::kScanConnecting, WiFi::kScanMethodProgressive);
4232 
4233   // Disconnect from the pending service.
4234   ExpectScanIdle();
4235   EXPECT_CALL(*metrics(), NotifyDeviceScanFinished(_)).Times(0);
4236   EXPECT_CALL(*metrics(), SendEnumToUMA(Metrics::kMetricScanResult, _, _)).
4237       Times(0);
4238   ReportCurrentBSSChanged(WPASupplicant::kCurrentBSSNull);
4239   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4240 }
4241 
TEST_F(WiFiMainTest,ConnectWhileNotScanning)4242 TEST_F(WiFiMainTest, ConnectWhileNotScanning) {
4243   // Setup WiFi but terminate scan.
4244   EXPECT_CALL(*adaptor_, EmitBoolChanged(kPoweredProperty, _)).
4245       Times(AnyNumber());
4246 
4247   ExpectScanStart(WiFi::kScanMethodProgressive, false);
4248   StartWiFi();
4249   dispatcher_.DispatchPendingEvents();
4250 
4251   ExpectScanStop();
4252   ExpectFoundNothing();
4253   ReportScanDone();
4254   dispatcher_.DispatchPendingEvents();
4255   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4256 
4257   // Connecting.
4258   ExpectConnecting();
4259   EXPECT_CALL(*metrics(), NotifyDeviceScanStarted(_)).Times(0);
4260   WiFiEndpointRefPtr endpoint;
4261   string bss_path;
4262   NiceScopedMockLog log;
4263   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4264   ScopeLogger::GetInstance()->set_verbose_level(10);
4265   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4266   EXPECT_CALL(log, Log(_, _, HasSubstr("-> TRANSITION_TO_CONNECTING"))).
4267       Times(0);
4268   EXPECT_CALL(log, Log(_, _, HasSubstr("-> CONNECTING (not scan related)")));
4269   MockWiFiServiceRefPtr service =
4270       SetupConnectingService("", &endpoint, &bss_path);
4271 
4272   // Connected.
4273   ExpectConnected();
4274   EXPECT_CALL(log, Log(_, _, HasSubstr("-> CONNECTED (not scan related")));
4275   ReportCurrentBSSChanged(bss_path);
4276   ScopeLogger::GetInstance()->set_verbose_level(0);
4277   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4278   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4279 }
4280 
TEST_F(WiFiMainTest,BackgroundScan)4281 TEST_F(WiFiMainTest, BackgroundScan) {
4282   StartWiFi();
4283   SetupConnectedService("", nullptr, nullptr);
4284   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4285 
4286   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(1);
4287   TriggerScan(WiFi::kScanMethodFull);
4288   dispatcher_.DispatchPendingEvents();
4289   VerifyScanState(WiFi::kScanBackgroundScanning, WiFi::kScanMethodFull);
4290 
4291   ReportScanDone();
4292   EXPECT_CALL(*manager(), OnDeviceGeolocationInfoUpdated(_));
4293   dispatcher_.DispatchPendingEvents();  // Launch UpdateScanStateAfterScanDone
4294   VerifyScanState(WiFi::kScanIdle, WiFi::kScanMethodNone);
4295 }
4296 
TEST_F(WiFiMainTest,ProgressiveScanDuringFull)4297 TEST_F(WiFiMainTest, ProgressiveScanDuringFull) {
4298   StartScan(WiFi::kScanMethodFull);
4299 
4300   // Now, try to slam-in a progressive scan.
4301   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
4302   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
4303   TriggerScan(WiFi::kScanMethodProgressive);
4304   dispatcher_.DispatchPendingEvents();
4305   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodFull);
4306 
4307   // And, for the destructor.
4308   ExpectScanStop();
4309   ExpectScanIdle();
4310 }
4311 
TEST_F(WiFiMainTest,FullScanDuringProgressive)4312 TEST_F(WiFiMainTest, FullScanDuringProgressive) {
4313   StartScan(WiFi::kScanMethodProgressive);
4314 
4315   // Now, try to slam-in a full scan.
4316   EXPECT_CALL(*scan_session_, InitiateScan()).Times(0);
4317   EXPECT_CALL(*GetSupplicantInterfaceProxy(), Scan(_)).Times(0);
4318   TriggerScan(WiFi::kScanMethodFull);
4319   dispatcher_.DispatchPendingEvents();
4320   VerifyScanState(WiFi::kScanScanning, WiFi::kScanMethodProgressive);
4321 
4322   // And, for the destructor.
4323   ExpectScanStop();
4324   ExpectScanIdle();
4325 }
4326 
TEST_F(WiFiMainTest,TDLSDiscoverResponse)4327 TEST_F(WiFiMainTest, TDLSDiscoverResponse) {
4328   const char kPeer[] = "peer";
4329   MockTDLSManager* tdls_manager = new StrictMock<MockTDLSManager>();
4330   SetTDLSManager(tdls_manager);
4331 
4332   EXPECT_CALL(*tdls_manager, OnDiscoverResponseReceived(kPeer));
4333   TDLSDiscoverResponse(kPeer);
4334   Mock::VerifyAndClearExpectations(tdls_manager);
4335 }
4336 
TEST_F(WiFiMainTest,PerformTDLSOperation)4337 TEST_F(WiFiMainTest, PerformTDLSOperation) {
4338   const char kPeerMac[] = "00:11:22:33:44:55";
4339   MockTDLSManager* tdls_manager = new StrictMock<MockTDLSManager>();
4340   SetTDLSManager(tdls_manager);
4341 
4342   Error error;
4343   // No address resolution is performed since MAC address is provided.
4344   EXPECT_CALL(*tdls_manager,
4345               PerformOperation(kPeerMac, kTDLSStatusOperation, &error))
4346       .WillOnce(Return(kTDLSConnectedState));
4347   EXPECT_EQ(kTDLSConnectedState,
4348             PerformTDLSOperation(kTDLSStatusOperation, kPeerMac, &error));
4349   EXPECT_TRUE(error.IsSuccess());
4350 }
4351 
TEST_F(WiFiMainTest,OnNewWiphy)4352 TEST_F(WiFiMainTest, OnNewWiphy) {
4353   NewWiphyMessage new_wiphy_message;
4354   NetlinkPacket packet(kNewWiphyNlMsg, sizeof(kNewWiphyNlMsg));
4355   new_wiphy_message.InitFromPacket(&packet, NetlinkMessage::MessageContext());
4356   EXPECT_CALL(*mac80211_monitor(), Start(_));
4357   EXPECT_CALL(*wake_on_wifi_, ParseWakeOnWiFiCapabilities(_));
4358   EXPECT_CALL(*wake_on_wifi_, OnWiphyIndexReceived(kNewWiphyNlMsg_WiphyIndex));
4359   GetAllScanFrequencies()->clear();
4360   OnNewWiphy(new_wiphy_message);
4361   EXPECT_EQ(arraysize(kNewWiphyNlMsg_UniqueFrequencies),
4362             GetAllScanFrequencies()->size());
4363   for (uint16_t freq : kNewWiphyNlMsg_UniqueFrequencies) {
4364     EXPECT_TRUE(GetAllScanFrequencies()->find(freq) !=
4365                 GetAllScanFrequencies()->end());
4366   }
4367 }
4368 
TEST_F(WiFiMainTest,StateChangedUpdatesMac80211Monitor)4369 TEST_F(WiFiMainTest, StateChangedUpdatesMac80211Monitor) {
4370   EXPECT_CALL(*mac80211_monitor(), UpdateConnectedState(true)).Times(2);
4371   ReportStateChanged(WPASupplicant::kInterfaceStateCompleted);
4372   ReportStateChanged(WPASupplicant::kInterfaceState4WayHandshake);
4373 
4374   EXPECT_CALL(*mac80211_monitor(), UpdateConnectedState(false));
4375   ReportStateChanged(WPASupplicant::kInterfaceStateAssociating);
4376 }
4377 
TEST_F(WiFiMainTest,OnIPConfigUpdated_InvokesOnConnectedAndReachable)4378 TEST_F(WiFiMainTest, OnIPConfigUpdated_InvokesOnConnectedAndReachable) {
4379   ScopedMockLog log;
4380   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4381   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4382   ScopeLogger::GetInstance()->set_verbose_level(3);
4383   EXPECT_CALL(log, Log(_, _, HasSubstr("IPv4 DHCP lease obtained")));
4384   EXPECT_CALL(*wake_on_wifi_, OnConnectedAndReachable(_, _));
4385   EXPECT_CALL(*manager(), device_info()).WillOnce(Return(device_info()));
4386   ReportIPConfigComplete();
4387 
4388   // We should not call WakeOnWiFi::OnConnectedAndReachable if we are not
4389   // actually connected to a service.
4390   SetCurrentService(nullptr);
4391   EXPECT_CALL(*wake_on_wifi_, OnConnectedAndReachable(_, _)).Times(0);
4392   ReportIPv6ConfigComplete();
4393 
4394   // If we are actually connected to a service when our IPv6 configuration is
4395   // updated, we should call WakeOnWiFi::OnConnectedAndReachable.
4396   MockWiFiServiceRefPtr service = MakeMockService(kSecurity8021x);
4397   EXPECT_CALL(*service, IsConnected()).WillOnce(Return(true));
4398   SetCurrentService(service);
4399   EXPECT_CALL(log, Log(_, _, HasSubstr("IPv6 configuration obtained")));
4400   EXPECT_CALL(*wake_on_wifi_, OnConnectedAndReachable(_, _));
4401   ReportIPv6ConfigComplete();
4402 
4403   // Do not call WakeOnWiFi::OnConnectedAndReachable if the IP config update was
4404   // triggered by a gateway ARP.
4405   EXPECT_CALL(log, Log(_, _, HasSubstr("Gateway ARP received")));
4406   EXPECT_CALL(*wake_on_wifi_, OnConnectedAndReachable(_, _)).Times(0);
4407   ReportIPConfigCompleteGatewayArpReceived();
4408 
4409   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4410   ScopeLogger::GetInstance()->set_verbose_level(0);
4411 }
4412 
TEST_F(WiFiMainTest,OnBeforeSuspend_CallsWakeOnWiFi)4413 TEST_F(WiFiMainTest, OnBeforeSuspend_CallsWakeOnWiFi) {
4414   SetWiFiEnabled(true);
4415   EXPECT_CALL(
4416       *wake_on_wifi_,
4417       OnBeforeSuspend(IsConnectedToCurrentService(), _, _, _, _, _, _));
4418   EXPECT_CALL(*this, SuspendCallback(_)).Times(0);
4419   OnBeforeSuspend();
4420 
4421   SetWiFiEnabled(false);
4422   EXPECT_CALL(*wake_on_wifi_,
4423               OnBeforeSuspend(IsConnectedToCurrentService(), _, _, _, _, _, _))
4424       .Times(0);
4425   EXPECT_CALL(*this, SuspendCallback(ErrorTypeIs(Error::kSuccess)));
4426   OnBeforeSuspend();
4427 }
4428 
TEST_F(WiFiMainTest,OnDarkResume_CallsWakeOnWiFi)4429 TEST_F(WiFiMainTest, OnDarkResume_CallsWakeOnWiFi) {
4430   SetWiFiEnabled(true);
4431   EXPECT_CALL(*wake_on_wifi_,
4432               OnDarkResume(IsConnectedToCurrentService(), _, _, _, _, _));
4433   EXPECT_CALL(*this, SuspendCallback(_)).Times(0);
4434   OnDarkResume();
4435 
4436   SetWiFiEnabled(false);
4437   EXPECT_CALL(*wake_on_wifi_,
4438               OnDarkResume(IsConnectedToCurrentService(), _, _, _, _, _))
4439       .Times(0);
4440   EXPECT_CALL(*this, SuspendCallback(ErrorTypeIs(Error::kSuccess)));
4441   OnDarkResume();
4442 }
4443 
TEST_F(WiFiMainTest,RemoveSupplicantNetworks)4444 TEST_F(WiFiMainTest, RemoveSupplicantNetworks) {
4445   StartWiFi();
4446   MockWiFiServiceRefPtr service1 = MakeMockService(kSecurity8021x);
4447   MockWiFiServiceRefPtr service2 = MakeMockService(kSecurity8021x);
4448   const char kNetworkRpcId1[] = "/service/network/rpcid1";
4449   const char kNetworkRpcId2[] = "/service/network/rpcid2";
4450   string path1(kNetworkRpcId1);
4451   string path2(kNetworkRpcId2);
4452   SetServiceNetworkRpcId(service1, kNetworkRpcId1);
4453   SetServiceNetworkRpcId(service2, kNetworkRpcId2);
4454   ASSERT_FALSE(RpcIdByServiceIsEmpty());
4455   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(path1));
4456   EXPECT_CALL(*GetSupplicantInterfaceProxy(), RemoveNetwork(path2));
4457   RemoveSupplicantNetworks();
4458   ASSERT_TRUE(RpcIdByServiceIsEmpty());
4459 }
4460 
TEST_F(WiFiMainTest,InitiateScan_Idle)4461 TEST_F(WiFiMainTest, InitiateScan_Idle) {
4462   ScopedMockLog log;
4463   Device::ScanType scan_type = Device::kFullScan;
4464   ASSERT_TRUE(wifi()->IsIdle());
4465   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4466   EXPECT_CALL(log, Log(_, _, ContainsRegex("Scan.* \\[full\\]")));
4467   InitiateScan(scan_type);
4468 
4469   scan_type = Device::kProgressiveScan;
4470   ASSERT_TRUE(wifi()->IsIdle());
4471   EXPECT_CALL(log, Log(_, _, ContainsRegex("Scan.* \\[progressive\\]")));
4472   InitiateScan(scan_type);
4473 }
4474 
TEST_F(WiFiMainTest,InitiateScan_NotIdle)4475 TEST_F(WiFiMainTest, InitiateScan_NotIdle) {
4476   const Device::ScanType scan_type = Device::kFullScan;
4477   ScopedMockLog log;
4478   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4479   ScopeLogger::GetInstance()->set_verbose_level(1);
4480   MockWiFiServiceRefPtr service = MakeMockService(kSecurityWpa);
4481   SetPendingService(service);
4482   EXPECT_FALSE(wifi()->IsIdle());
4483   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4484   EXPECT_CALL(
4485       log,
4486       Log(_, _, HasSubstr("skipping scan, already connecting or connected.")));
4487   InitiateScan(scan_type);
4488   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4489   ScopeLogger::GetInstance()->set_verbose_level(0);
4490 }
4491 
TEST_F(WiFiMainTest,InitiateScanInDarkResume_Idle)4492 TEST_F(WiFiMainTest, InitiateScanInDarkResume_Idle) {
4493   const WiFi::FreqSet freqs;
4494   StartWiFi();
4495   manager()->set_suppress_autoconnect(false);
4496   ASSERT_TRUE(wifi()->IsIdle());
4497   EXPECT_CALL(netlink_manager_,
4498               SendNl80211Message(IsNl80211Command(kNl80211FamilyId,
4499                                                   TriggerScanMessage::kCommand),
4500                                  _, _, _));
4501   EXPECT_CALL(*GetSupplicantInterfaceProxy(), FlushBSS(0));
4502   InitiateScanInDarkResume(freqs);
4503   EXPECT_TRUE(manager()->suppress_autoconnect());
4504 }
4505 
TEST_F(WiFiMainTest,InitiateScanInDarkResume_NotIdle)4506 TEST_F(WiFiMainTest, InitiateScanInDarkResume_NotIdle) {
4507   const WiFi::FreqSet freqs;
4508   ScopedMockLog log;
4509   MockWiFiServiceRefPtr service = MakeMockService(kSecurityWpa);
4510   SetPendingService(service);
4511   manager()->set_suppress_autoconnect(false);
4512   EXPECT_FALSE(wifi()->IsIdle());
4513   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4514   EXPECT_CALL(
4515       log,
4516       Log(_, _, HasSubstr("skipping scan, already connecting or connected.")));
4517   EXPECT_CALL(netlink_manager_,
4518               SendNl80211Message(IsNl80211Command(kNl80211FamilyId,
4519                                                   TriggerScanMessage::kCommand),
4520                                  _, _, _)).Times(0);
4521   EXPECT_CALL(*GetSupplicantInterfaceProxy(), FlushBSS(_)).Times(0);
4522   InitiateScanInDarkResume(freqs);
4523   EXPECT_FALSE(manager()->suppress_autoconnect());
4524 }
4525 
TEST_F(WiFiMainTest,TriggerPassiveScan_NoResults)4526 TEST_F(WiFiMainTest, TriggerPassiveScan_NoResults) {
4527   ScopedMockLog log;
4528   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4529   ScopeLogger::GetInstance()->set_verbose_level(3);
4530   const WiFi::FreqSet freqs;
4531   EXPECT_CALL(netlink_manager_,
4532               SendNl80211Message(IsNl80211Command(kNl80211FamilyId,
4533                                                   TriggerScanMessage::kCommand),
4534                                  _, _, _));
4535   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4536   EXPECT_CALL(log, Log(_, _, HasSubstr("Scanning on specific channels")))
4537       .Times(0);
4538   TriggerPassiveScan(freqs);
4539   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4540   ScopeLogger::GetInstance()->set_verbose_level(0);
4541 }
4542 
TEST_F(WiFiMainTest,TriggerPassiveScan_HasResults)4543 TEST_F(WiFiMainTest, TriggerPassiveScan_HasResults) {
4544   ScopedMockLog log;
4545   ScopeLogger::GetInstance()->EnableScopesByName("wifi");
4546   ScopeLogger::GetInstance()->set_verbose_level(3);
4547   const WiFi::FreqSet freqs = {1};
4548   EXPECT_CALL(netlink_manager_,
4549               SendNl80211Message(IsNl80211Command(kNl80211FamilyId,
4550                                                   TriggerScanMessage::kCommand),
4551                                  _, _, _));
4552   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4553   EXPECT_CALL(log, Log(_, _, HasSubstr("Scanning on specific channels")))
4554       .Times(1);
4555   TriggerPassiveScan(freqs);
4556   ScopeLogger::GetInstance()->EnableScopesByName("-wifi");
4557   ScopeLogger::GetInstance()->set_verbose_level(0);
4558 }
4559 
TEST_F(WiFiMainTest,PendingScanEvents)4560 TEST_F(WiFiMainTest, PendingScanEvents) {
4561   // This test essentially performs ReportBSS(), but ensures that the
4562   // WiFi object successfully dispatches events in order.
4563   StartWiFi();
4564   BSSAdded(
4565       "bss0",
4566       CreateBSSProperties("ssid0", "00:00:00:00:00:00", 0, 0,
4567                           kNetworkModeInfrastructure));
4568   BSSAdded(
4569       "bss1",
4570       CreateBSSProperties("ssid1", "00:00:00:00:00:01", 0, 0,
4571                           kNetworkModeInfrastructure));
4572   BSSRemoved("bss0");
4573   BSSAdded(
4574       "bss2",
4575       CreateBSSProperties("ssid2", "00:00:00:00:00:02", 0, 0,
4576                           kNetworkModeInfrastructure));
4577 
4578   WiFiEndpointRefPtr ap0 = MakeEndpoint("ssid0", "00:00:00:00:00:00");
4579   WiFiEndpointRefPtr ap1 = MakeEndpoint("ssid1", "00:00:00:00:00:01");
4580   WiFiEndpointRefPtr ap2 = MakeEndpoint("ssid2", "00:00:00:00:00:02");
4581 
4582   InSequence seq;
4583   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(EndpointMatch(ap0)));
4584   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(EndpointMatch(ap1)));
4585   WiFiServiceRefPtr null_service;
4586   EXPECT_CALL(*wifi_provider(), OnEndpointRemoved(EndpointMatch(ap0)))
4587       .WillOnce(Return(null_service));
4588   EXPECT_CALL(*wifi_provider(), OnEndpointAdded(EndpointMatch(ap2)));
4589   dispatcher_.DispatchPendingEvents();
4590   Mock::VerifyAndClearExpectations(wifi_provider());
4591 
4592   const WiFi::EndpointMap& endpoints_by_rpcid = GetEndpointMap();
4593   EXPECT_EQ(2, endpoints_by_rpcid.size());
4594 }
4595 
TEST_F(WiFiMainTest,ParseWiphyIndex_Success)4596 TEST_F(WiFiMainTest, ParseWiphyIndex_Success) {
4597   // Verify that the wiphy index in kNewWiphyNlMsg is parsed, and that the flag
4598   // for having the wiphy index is set by ParseWiphyIndex.
4599   EXPECT_EQ(GetWiphyIndex(), WiFi::kDefaultWiphyIndex);
4600   NewWiphyMessage msg;
4601   NetlinkPacket packet(kNewWiphyNlMsg, sizeof(kNewWiphyNlMsg));
4602   msg.InitFromPacket(&packet, NetlinkMessage::MessageContext());
4603   EXPECT_TRUE(ParseWiphyIndex(msg));
4604   EXPECT_EQ(GetWiphyIndex(), kNewWiphyNlMsg_WiphyIndex);
4605 }
4606 
TEST_F(WiFiMainTest,ParseWiphyIndex_Failure)4607 TEST_F(WiFiMainTest, ParseWiphyIndex_Failure) {
4608   ScopedMockLog log;
4609   // Change the NL80211_ATTR_WIPHY U32 attribute to the NL80211_ATTR_WIPHY_FREQ
4610   // U32 attribute, so that this message no longer contains a wiphy_index to be
4611   // parsed.
4612   NewWiphyMessage msg;
4613   MutableNetlinkPacket packet(kNewWiphyNlMsg, sizeof(kNewWiphyNlMsg));
4614   struct nlattr* nl80211_attr_wiphy = reinterpret_cast<struct nlattr*>(
4615       &packet.GetMutablePayload()->GetData()[
4616           kNewWiphyNlMsg_Nl80211AttrWiphyOffset]);
4617   nl80211_attr_wiphy->nla_type = NL80211_ATTR_WIPHY_FREQ;
4618   msg.InitFromPacket(&packet, NetlinkMessage::MessageContext());
4619   EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
4620   EXPECT_CALL(log, Log(logging::LOG_ERROR, _,
4621                        "NL80211_CMD_NEW_WIPHY had no NL80211_ATTR_WIPHY"));
4622   EXPECT_FALSE(ParseWiphyIndex(msg));
4623   EXPECT_CALL(*wake_on_wifi_, OnWiphyIndexReceived(_)).Times(0);
4624 }
4625 
TEST_F(WiFiMainTest,OnScanStarted_ActiveScan)4626 TEST_F(WiFiMainTest, OnScanStarted_ActiveScan) {
4627   SetWiphyIndex(kScanTriggerMsgWiphyIndex);
4628   TriggerScanMessage msg;
4629   NetlinkPacket packet(
4630       kActiveScanTriggerNlMsg, sizeof(kActiveScanTriggerNlMsg));
4631   msg.InitFromPacket(&packet, NetlinkMessage::MessageContext());
4632   EXPECT_CALL(*wake_on_wifi_, OnScanStarted(true));
4633   OnScanStarted(msg);
4634 }
4635 
TEST_F(WiFiMainTest,OnScanStarted_PassiveScan)4636 TEST_F(WiFiMainTest, OnScanStarted_PassiveScan) {
4637   SetWiphyIndex(kScanTriggerMsgWiphyIndex);
4638   TriggerScanMessage msg;
4639   NetlinkPacket packet(
4640       kPassiveScanTriggerNlMsg, sizeof(kPassiveScanTriggerNlMsg));
4641   msg.InitFromPacket(&packet, NetlinkMessage::MessageContext());
4642   EXPECT_CALL(*wake_on_wifi_, OnScanStarted(false));
4643   OnScanStarted(msg);
4644 }
4645 
4646 }  // namespace shill
4647