1 //
2 // Copyright (C) 2015 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/dbus/chromeos_supplicant_interface_proxy.h"
18 
19 #include <string>
20 
21 #include <base/bind.h>
22 
23 #include "shill/logging.h"
24 #include "shill/supplicant/supplicant_event_delegate_interface.h"
25 #include "shill/supplicant/wpa_supplicant.h"
26 
27 using std::string;
28 
29 namespace shill {
30 
31 namespace Logging {
32 static auto kModuleLogScope = ScopeLogger::kDBus;
ObjectID(const dbus::ObjectPath * p)33 static string ObjectID(const dbus::ObjectPath* p) { return p->value(); }
34 }
35 
36 const char ChromeosSupplicantInterfaceProxy::kInterfaceName[] =
37     "fi.w1.wpa_supplicant1.Interface";
38 const char ChromeosSupplicantInterfaceProxy::kPropertyDisableHighBitrates[] =
39     "DisableHighBitrates";
40 const char ChromeosSupplicantInterfaceProxy::kPropertyFastReauth[] =
41     "FastReauth";
42 const char ChromeosSupplicantInterfaceProxy::kPropertyRoamThreshold[] =
43     "RoamThreshold";
44 const char ChromeosSupplicantInterfaceProxy::kPropertyScan[] = "Scan";
45 const char ChromeosSupplicantInterfaceProxy::kPropertyScanInterval[] =
46     "ScanInterval";
47 const char ChromeosSupplicantInterfaceProxy::kPropertySchedScan[] = "SchedScan";
48 
PropertySet(dbus::ObjectProxy * object_proxy,const std::string & interface_name,const PropertyChangedCallback & callback)49 ChromeosSupplicantInterfaceProxy::PropertySet::PropertySet(
50     dbus::ObjectProxy* object_proxy,
51     const std::string& interface_name,
52     const PropertyChangedCallback& callback)
53     : dbus::PropertySet(object_proxy, interface_name, callback) {
54   RegisterProperty(kPropertyDisableHighBitrates, &disable_high_bitrates);
55   RegisterProperty(kPropertyFastReauth, &fast_reauth);
56   RegisterProperty(kPropertyRoamThreshold, &roam_threshold);
57   RegisterProperty(kPropertyScan, &scan);
58   RegisterProperty(kPropertyScanInterval, &scan_interval);
59   RegisterProperty(kPropertySchedScan, &sched_scan);
60 }
61 
ChromeosSupplicantInterfaceProxy(const scoped_refptr<dbus::Bus> & bus,const std::string & object_path,SupplicantEventDelegateInterface * delegate)62 ChromeosSupplicantInterfaceProxy::ChromeosSupplicantInterfaceProxy(
63     const scoped_refptr<dbus::Bus>& bus,
64     const std::string& object_path,
65     SupplicantEventDelegateInterface* delegate)
66     : interface_proxy_(
67           new fi::w1::wpa_supplicant1::InterfaceProxy(
68               bus,
69               WPASupplicant::kDBusAddr,
70               dbus::ObjectPath(object_path))),
71       delegate_(delegate) {
72   // Register properites.
73   properties_.reset(
74       new PropertySet(
75           interface_proxy_->GetObjectProxy(),
76           kInterfaceName,
77           base::Bind(&ChromeosSupplicantInterfaceProxy::OnPropertyChanged,
78                      weak_factory_.GetWeakPtr())));
79 
80   // Register signal handlers.
81   dbus::ObjectProxy::OnConnectedCallback on_connected_callback =
82       base::Bind(&ChromeosSupplicantInterfaceProxy::OnSignalConnected,
83                  weak_factory_.GetWeakPtr());
84   interface_proxy_->RegisterScanDoneSignalHandler(
85       base::Bind(&ChromeosSupplicantInterfaceProxy::ScanDone,
86                  weak_factory_.GetWeakPtr()),
87       on_connected_callback);
88   interface_proxy_->RegisterBSSAddedSignalHandler(
89       base::Bind(&ChromeosSupplicantInterfaceProxy::BSSAdded,
90                  weak_factory_.GetWeakPtr()),
91       on_connected_callback);
92   interface_proxy_->RegisterBSSRemovedSignalHandler(
93       base::Bind(&ChromeosSupplicantInterfaceProxy::BSSRemoved,
94                  weak_factory_.GetWeakPtr()),
95       on_connected_callback);
96   interface_proxy_->RegisterBlobAddedSignalHandler(
97       base::Bind(&ChromeosSupplicantInterfaceProxy::BlobAdded,
98                  weak_factory_.GetWeakPtr()),
99       on_connected_callback);
100   interface_proxy_->RegisterBlobRemovedSignalHandler(
101       base::Bind(&ChromeosSupplicantInterfaceProxy::BlobRemoved,
102                  weak_factory_.GetWeakPtr()),
103       on_connected_callback);
104   interface_proxy_->RegisterCertificationSignalHandler(
105       base::Bind(&ChromeosSupplicantInterfaceProxy::Certification,
106                  weak_factory_.GetWeakPtr()),
107       on_connected_callback);
108   interface_proxy_->RegisterEAPSignalHandler(
109       base::Bind(&ChromeosSupplicantInterfaceProxy::EAP,
110                  weak_factory_.GetWeakPtr()),
111       on_connected_callback);
112   interface_proxy_->RegisterNetworkAddedSignalHandler(
113       base::Bind(&ChromeosSupplicantInterfaceProxy::NetworkAdded,
114                  weak_factory_.GetWeakPtr()),
115       on_connected_callback);
116   interface_proxy_->RegisterNetworkRemovedSignalHandler(
117       base::Bind(&ChromeosSupplicantInterfaceProxy::NetworkRemoved,
118                  weak_factory_.GetWeakPtr()),
119       on_connected_callback);
120   interface_proxy_->RegisterNetworkSelectedSignalHandler(
121       base::Bind(&ChromeosSupplicantInterfaceProxy::NetworkSelected,
122                  weak_factory_.GetWeakPtr()),
123       on_connected_callback);
124   interface_proxy_->RegisterPropertiesChangedSignalHandler(
125       base::Bind(&ChromeosSupplicantInterfaceProxy::PropertiesChanged,
126                  weak_factory_.GetWeakPtr()),
127       on_connected_callback);
128   interface_proxy_->RegisterTDLSDiscoverResponseSignalHandler(
129       base::Bind(&ChromeosSupplicantInterfaceProxy::TDLSDiscoverResponse,
130                  weak_factory_.GetWeakPtr()),
131       on_connected_callback);
132 
133   // Connect property signals and initialize cached values. Based on
134   // recommendations from src/dbus/property.h.
135   properties_->ConnectSignals();
136   properties_->GetAll();
137 }
138 
~ChromeosSupplicantInterfaceProxy()139 ChromeosSupplicantInterfaceProxy::~ChromeosSupplicantInterfaceProxy() {
140   interface_proxy_->ReleaseObjectProxy(base::Bind(&base::DoNothing));
141 }
142 
AddNetwork(const KeyValueStore & args,string * network)143 bool ChromeosSupplicantInterfaceProxy::AddNetwork(const KeyValueStore& args,
144                                                   string* network) {
145   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
146   brillo::VariantDictionary dict;
147   KeyValueStore::ConvertToVariantDictionary(args, &dict);
148   dbus::ObjectPath path;
149   brillo::ErrorPtr error;
150   if (!interface_proxy_->AddNetwork(dict, &path, &error)) {
151     LOG(ERROR) << "Failed to add network: "
152                << error->GetCode() << " " << error->GetMessage();
153     return false;
154   }
155   *network = path.value();
156   return true;
157 }
158 
EnableHighBitrates()159 bool ChromeosSupplicantInterfaceProxy::EnableHighBitrates() {
160   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
161 #if !defined(__ANDROID__)
162   brillo::ErrorPtr error;
163   if (!interface_proxy_->EnableHighBitrates(&error)) {
164     LOG(ERROR) << "Failed to enable high bitrates: "
165                << error->GetCode() << " " << error->GetMessage();
166     return false;
167   }
168 #endif  // __ANDROID__
169   return true;
170 }
171 
EAPLogoff()172 bool ChromeosSupplicantInterfaceProxy::EAPLogoff() {
173   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
174   brillo::ErrorPtr error;
175   if (!interface_proxy_->EAPLogoff(&error)) {
176     LOG(ERROR) << "Failed to EPA logoff "
177                << error->GetCode() << " " << error->GetMessage();
178     return false;
179   }
180   return true;
181 }
182 
EAPLogon()183 bool ChromeosSupplicantInterfaceProxy::EAPLogon() {
184   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
185   brillo::ErrorPtr error;
186   if (!interface_proxy_->EAPLogon(&error)) {
187     LOG(ERROR) << "Failed to EAP logon: "
188                << error->GetCode() << " " << error->GetMessage();
189     return false;
190   }
191   return true;
192 }
193 
Disconnect()194 bool ChromeosSupplicantInterfaceProxy::Disconnect() {
195   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
196   brillo::ErrorPtr error;
197   if (!interface_proxy_->Disconnect(&error)) {
198     LOG(ERROR) << "Failed to disconnect: "
199                << error->GetCode() << " " << error->GetMessage();
200     return false;
201   }
202   return true;
203 }
204 
FlushBSS(const uint32_t & age)205 bool ChromeosSupplicantInterfaceProxy::FlushBSS(const uint32_t& age) {
206   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
207   brillo::ErrorPtr error;
208   if (!interface_proxy_->FlushBSS(age, &error)) {
209     LOG(ERROR) << "Failed to flush BSS: "
210                << error->GetCode() << " " << error->GetMessage();
211     return false;
212   }
213   return true;
214 }
215 
NetworkReply(const string & network,const string & field,const string & value)216 bool ChromeosSupplicantInterfaceProxy::NetworkReply(const string& network,
217                                                     const string& field,
218                                                     const string& value) {
219   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__
220       << " network: " << network << " field: " << field << " value: " << value;
221   brillo::ErrorPtr error;
222   if (!interface_proxy_->NetworkReply(dbus::ObjectPath(network),
223                                       field,
224                                       value,
225                                       &error)) {
226     LOG(ERROR) << "Failed to network reply: "
227                << error->GetCode() << " " << error->GetMessage();
228     return false;
229   }
230   return true;
231 }
232 
Roam(const string & addr)233 bool ChromeosSupplicantInterfaceProxy::Roam(const string& addr) {
234   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
235 #if !defined(__ANDROID__)
236   brillo::ErrorPtr error;
237   if (!interface_proxy_->Roam(addr, &error)) {
238     LOG(ERROR) << "Failed to Roam: "
239                << error->GetCode() << " " << error->GetMessage();
240     return false;
241   }
242 #endif  // __ANDROID__
243   return true;
244 }
245 
Reassociate()246 bool ChromeosSupplicantInterfaceProxy::Reassociate() {
247   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
248   brillo::ErrorPtr error;
249   if (!interface_proxy_->Reassociate(&error)) {
250     LOG(ERROR) << "Failed to reassociate: "
251                << error->GetCode() << " " << error->GetMessage();
252     return false;
253   }
254   return true;
255 }
256 
Reattach()257 bool ChromeosSupplicantInterfaceProxy::Reattach() {
258   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
259   brillo::ErrorPtr error;
260   if (!interface_proxy_->Reattach(&error)) {
261     LOG(ERROR) << "Failed to reattach: "
262                << error->GetCode() << " " << error->GetMessage();
263     return false;
264   }
265   return true;
266 }
267 
RemoveAllNetworks()268 bool ChromeosSupplicantInterfaceProxy::RemoveAllNetworks() {
269   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
270   brillo::ErrorPtr error;
271   if (!interface_proxy_->RemoveAllNetworks(&error)) {
272     LOG(ERROR) << "Failed to remove all networks: "
273                << error->GetCode() << " " << error->GetMessage();
274     return false;
275   }
276   return true;
277 }
278 
RemoveNetwork(const string & network)279 bool ChromeosSupplicantInterfaceProxy::RemoveNetwork(const string& network) {
280   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << network;
281   brillo::ErrorPtr error;
282   if (!interface_proxy_->RemoveNetwork(dbus::ObjectPath(network),
283                                        &error)) {
284     LOG(ERROR) << "Failed to remove network: "
285                << error->GetCode() << " " << error->GetMessage();
286     // RemoveNetwork can fail with three different errors.
287     //
288     // If RemoveNetwork fails with a NetworkUnknown error, supplicant has
289     // already removed the network object, so return true as if
290     // RemoveNetwork removes the network object successfully.
291     //
292     // As shill always passes a valid network object path, RemoveNetwork
293     // should not fail with an InvalidArgs error. Return false in such case
294     // as something weird may have happened. Similarly, return false in case
295     // of an UnknownError.
296     if (error->GetCode() != WPASupplicant::kErrorNetworkUnknown) {
297       return false;
298     }
299   }
300   return true;
301 }
302 
Scan(const KeyValueStore & args)303 bool ChromeosSupplicantInterfaceProxy::Scan(const KeyValueStore& args) {
304   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
305   brillo::VariantDictionary dict;
306   KeyValueStore::ConvertToVariantDictionary(args, &dict);
307   brillo::ErrorPtr error;
308   if (!interface_proxy_->Scan(dict, &error)) {
309     LOG(ERROR) << "Failed to scan: "
310                << error->GetCode() << " " << error->GetMessage();
311     return false;
312   }
313   return true;
314 }
315 
SelectNetwork(const string & network)316 bool ChromeosSupplicantInterfaceProxy::SelectNetwork(const string& network) {
317   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << network;
318   brillo::ErrorPtr error;
319   if (!interface_proxy_->SelectNetwork(dbus::ObjectPath(network), &error)) {
320     LOG(ERROR) << "Failed to select network: "
321                << error->GetCode() << " " << error->GetMessage();
322     return false;
323   }
324   return true;
325 }
326 
SetHT40Enable(const string & network,bool enable)327 bool ChromeosSupplicantInterfaceProxy::SetHT40Enable(const string& network,
328                                                      bool enable) {
329   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__
330       << " network: " << network << " enable: " << enable;
331 #if defined(__ANDROID__)
332   brillo::ErrorPtr error;
333   if (!interface_proxy_->SetHT40Enable(dbus::ObjectPath(network),
334                                        enable,
335                                        &error)) {
336     LOG(ERROR) << "Failed to set HT40 enable: "
337                << error->GetCode() << " " << error->GetMessage();
338     return false;
339   }
340 #endif  // __ANDROID__
341   return true;
342 }
343 
TDLSDiscover(const string & peer)344 bool ChromeosSupplicantInterfaceProxy::TDLSDiscover(const string& peer) {
345   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << peer;
346   brillo::ErrorPtr error;
347   if (!interface_proxy_->TDLSDiscover(peer, &error)) {
348     LOG(ERROR) << "Failed to perform TDLS discover: "
349                << error->GetCode() << " " << error->GetMessage();
350     return false;
351   }
352   return true;
353 }
354 
TDLSSetup(const string & peer)355 bool ChromeosSupplicantInterfaceProxy::TDLSSetup(const string& peer) {
356   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << peer;
357   brillo::ErrorPtr error;
358   if (!interface_proxy_->TDLSSetup(peer, &error)) {
359     LOG(ERROR) << "Failed to perform TDLS setup: "
360                << error->GetCode() << " " << error->GetMessage();
361     return false;
362   }
363   return true;
364 }
365 
TDLSStatus(const string & peer,string * status)366 bool ChromeosSupplicantInterfaceProxy::TDLSStatus(const string& peer,
367                                                   string* status) {
368   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << peer;
369   brillo::ErrorPtr error;
370   if (!interface_proxy_->TDLSStatus(peer, status, &error)) {
371     LOG(ERROR) << "Failed to retrieve TDLS status: "
372                << error->GetCode() << " " << error->GetMessage();
373     return false;
374   }
375   return true;
376 }
377 
TDLSTeardown(const string & peer)378 bool ChromeosSupplicantInterfaceProxy::TDLSTeardown(const string& peer) {
379   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << peer;
380   brillo::ErrorPtr error;
381   if (!interface_proxy_->TDLSTeardown(peer, &error)) {
382     LOG(ERROR) << "Failed to perform TDLS teardown: "
383                << error->GetCode() << " " << error->GetMessage();
384     return false;
385   }
386   return true;
387 }
388 
SetFastReauth(bool enabled)389 bool ChromeosSupplicantInterfaceProxy::SetFastReauth(bool enabled) {
390   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << enabled;
391 #if !defined(__ANDROID__)
392   if (!properties_->fast_reauth.SetAndBlock(enabled)) {
393     LOG(ERROR) << __func__ << " failed: " << enabled;
394     return false;
395   }
396 #endif  // __ANDROID__
397   return true;
398 }
399 
SetRoamThreshold(uint16_t threshold)400 bool ChromeosSupplicantInterfaceProxy::SetRoamThreshold(uint16_t threshold) {
401   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << threshold;
402 #if !defined(__ANDROID__)
403   if (!properties_->roam_threshold.SetAndBlock(threshold)) {
404     LOG(ERROR) << __func__ << " failed: " << threshold;
405     return false;
406   }
407 #endif  // __ANDROID__
408   return true;
409 }
410 
SetScanInterval(int32_t scan_interval)411 bool ChromeosSupplicantInterfaceProxy::SetScanInterval(int32_t scan_interval) {
412   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": "
413       << scan_interval;
414 #if !defined(__ANDROID__)
415   if (!properties_->scan_interval.SetAndBlock(scan_interval)) {
416     LOG(ERROR) << __func__ << " failed: " << scan_interval;
417     return false;
418   }
419 #endif  // __ANDROID__
420   return true;
421 }
422 
SetDisableHighBitrates(bool disable_high_bitrates)423 bool ChromeosSupplicantInterfaceProxy::SetDisableHighBitrates(
424     bool disable_high_bitrates) {
425   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": "
426       << disable_high_bitrates;
427 #if !defined(__ANDROID__)
428   if (!properties_->disable_high_bitrates.SetAndBlock(disable_high_bitrates)) {
429     LOG(ERROR) << __func__ << " failed: " << disable_high_bitrates;
430     return false;
431   }
432 #endif  // __ANDROID__
433   return true;
434 }
435 
SetSchedScan(bool enable)436 bool ChromeosSupplicantInterfaceProxy::SetSchedScan(bool enable) {
437   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << enable;
438 #if !defined(__ANDROID__)
439   if (!properties_->sched_scan.SetAndBlock(enable)) {
440     LOG(ERROR) << __func__ << " failed: " << enable;
441     return false;
442   }
443 #endif  // __ANDROID__
444   return true;
445 }
446 
SetScan(bool enable)447 bool ChromeosSupplicantInterfaceProxy::SetScan(bool enable) {
448   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << enable;
449 #if !defined(__ANDROID__)
450   if (!properties_->scan.SetAndBlock(enable)) {
451     LOG(ERROR) << __func__ << " failed: " << enable;
452     return false;
453   }
454 #endif  // __ANDROID__
455   return true;
456 }
457 
BlobAdded(const string &)458 void ChromeosSupplicantInterfaceProxy::BlobAdded(const string& /*blobname*/) {
459   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
460   // XXX
461 }
462 
BlobRemoved(const string &)463 void ChromeosSupplicantInterfaceProxy::BlobRemoved(const string& /*blobname*/) {
464   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
465   // XXX
466 }
467 
BSSAdded(const dbus::ObjectPath & BSS,const brillo::VariantDictionary & properties)468 void ChromeosSupplicantInterfaceProxy::BSSAdded(
469     const dbus::ObjectPath& BSS,
470     const brillo::VariantDictionary& properties) {
471   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
472   KeyValueStore store;
473   KeyValueStore::ConvertFromVariantDictionary(properties, &store);
474   delegate_->BSSAdded(BSS.value(), store);
475 }
476 
Certification(const brillo::VariantDictionary & properties)477 void ChromeosSupplicantInterfaceProxy::Certification(
478     const brillo::VariantDictionary& properties) {
479   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
480   KeyValueStore store;
481   KeyValueStore::ConvertFromVariantDictionary(properties, &store);
482   delegate_->Certification(store);
483 }
484 
EAP(const string & status,const string & parameter)485 void ChromeosSupplicantInterfaceProxy::EAP(
486     const string& status, const string& parameter) {
487   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": status "
488       << status << ", parameter " << parameter;
489   delegate_->EAPEvent(status, parameter);
490 }
491 
BSSRemoved(const dbus::ObjectPath & BSS)492 void ChromeosSupplicantInterfaceProxy::BSSRemoved(const dbus::ObjectPath& BSS) {
493   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
494   delegate_->BSSRemoved(BSS.value());
495 }
496 
NetworkAdded(const dbus::ObjectPath &,const brillo::VariantDictionary &)497 void ChromeosSupplicantInterfaceProxy::NetworkAdded(
498     const dbus::ObjectPath& /*network*/,
499     const brillo::VariantDictionary& /*properties*/) {
500   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
501   // XXX
502 }
503 
NetworkRemoved(const dbus::ObjectPath &)504 void ChromeosSupplicantInterfaceProxy::NetworkRemoved(
505     const dbus::ObjectPath& /*network*/) {
506   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
507   // TODO(quiche): Pass this up to the delegate, so that it can clean its
508   // rpcid_by_service_ map. crbug.com/207648
509 }
510 
NetworkSelected(const dbus::ObjectPath &)511 void ChromeosSupplicantInterfaceProxy::NetworkSelected(
512     const dbus::ObjectPath& /*network*/) {
513   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
514   // XXX
515 }
516 
PropertiesChanged(const brillo::VariantDictionary & properties)517 void ChromeosSupplicantInterfaceProxy::PropertiesChanged(
518     const brillo::VariantDictionary& properties) {
519   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__;
520   KeyValueStore store;
521   KeyValueStore::ConvertFromVariantDictionary(properties, &store);
522   delegate_->PropertiesChanged(store);
523 }
524 
ScanDone(bool success)525 void ChromeosSupplicantInterfaceProxy::ScanDone(bool success) {
526   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": " << success;
527   delegate_->ScanDone(success);
528 }
529 
TDLSDiscoverResponse(const std::string & peer_address)530 void ChromeosSupplicantInterfaceProxy::TDLSDiscoverResponse(
531     const std::string& peer_address) {
532   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": "
533       << peer_address;
534   delegate_->TDLSDiscoverResponse(peer_address);
535 }
536 
OnPropertyChanged(const std::string & property_name)537 void ChromeosSupplicantInterfaceProxy::OnPropertyChanged(
538     const std::string& property_name) {
539   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__ << ": "
540       << property_name;
541 }
542 
OnSignalConnected(const string & interface_name,const string & signal_name,bool success)543 void ChromeosSupplicantInterfaceProxy::OnSignalConnected(
544     const string& interface_name, const string& signal_name, bool success) {
545   SLOG(&interface_proxy_->GetObjectPath(), 2) << __func__
546       << "interface: " << interface_name << " signal: " << signal_name
547       << "success: " << success;
548   if (!success) {
549     LOG(ERROR) << "Failed to connect signal " << signal_name
550         << " to interface " << interface_name;
551   }
552 }
553 
554 }  // namespace shill
555