buffet/shill_client.cc - platform/system/weaved - Git at Google

 // Copyright 2015 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "buffet/shill_client.h"

 #include <set>

 #include <base/message_loop/message_loop.h>
 #include <base/stl_util.h>
 #include <brillo/any.h>
 #include <brillo/errors/error.h>
 #include <brillo/variant_dictionary.h>
 #include <dbus/shill/dbus-constants.h>
 #include <weave/enum_to_string.h>

 #include "buffet/ap_manager_client.h"
 #include "buffet/socket_stream.h"
 #include "buffet/weave_error_conversion.h"

 using brillo::Any;
 using brillo::VariantDictionary;
 using dbus::ObjectPath;
 using org::chromium::flimflam::DeviceProxy;
 using org::chromium::flimflam::ServiceProxy;
 using std::map;
 using std::set;
 using std::string;
 using std::vector;
 using weave::EnumToString;
 using weave::provider::Network;

 namespace buffet {

 namespace {

 void IgnoreDetachEvent() {}

 bool GetStateForService(ServiceProxy* service, string* state) {
   CHECK(service) << "|service| was nullptr in GetStateForService()";
   VariantDictionary properties;
   if (!service->GetProperties(&properties, nullptr)) {
     LOG(WARNING) << "Failed to read properties from service.";
     return false;
   }
   auto property_it = properties.find(shill::kStateProperty);
   if (property_it == properties.end()) {
     LOG(WARNING) << "No state found in service properties.";
     return false;
   }
   string new_state = property_it->second.TryGet<string>();
   if (new_state.empty()) {
     LOG(WARNING) << "Invalid state value.";
     return false;
   }
   *state = new_state;
   return true;
 }

 Network::State ShillServiceStateToNetworkState(const string& state) {
   // TODO(wiley) What does "unconfigured" mean in a world with multiple sets
   //             of WiFi credentials?
   // TODO(wiley) Detect disabled devices, update state appropriately.
   if ((state.compare(shill::kStateReady) == 0) ||
       (state.compare(shill::kStatePortal) == 0) ||
       (state.compare(shill::kStateOnline) == 0)) {
     return Network::State::kOnline;
   }
   if ((state.compare(shill::kStateAssociation) == 0) ||
       (state.compare(shill::kStateConfiguration) == 0)) {
     return Network::State::kConnecting;
   }
   if ((state.compare(shill::kStateFailure) == 0) ||
       (state.compare(shill::kStateActivationFailure) == 0)) {
     // TODO(wiley) Get error information off the service object.
     return Network::State::kError;
   }
   if ((state.compare(shill::kStateIdle) == 0) ||
       (state.compare(shill::kStateOffline) == 0) ||
       (state.compare(shill::kStateDisconnect) == 0)) {
     return Network::State::kOffline;
   }
   LOG(WARNING) << "Unknown state found: '" << state << "'";
   return Network::State::kOffline;
 }

 }  // namespace

 ShillClient::ShillClient(const scoped_refptr<dbus::Bus>& bus,
                          const set<string>& device_whitelist,
                          bool disable_xmpp)
     : bus_{bus},
       manager_proxy_{bus_},
       device_whitelist_{device_whitelist},
       disable_xmpp_{disable_xmpp},
       ap_manager_client_{new ApManagerClient(bus)} {
   manager_proxy_.RegisterPropertyChangedSignalHandler(
       base::Bind(&ShillClient::OnManagerPropertyChange,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ShillClient::OnManagerPropertyChangeRegistration,
                  weak_factory_.GetWeakPtr()));
   auto owner_changed_cb = base::Bind(&ShillClient::OnShillServiceOwnerChange,
                                      weak_factory_.GetWeakPtr());
   bus_->GetObjectProxy(shill::kFlimflamServiceName, ObjectPath{"/"})
       ->SetNameOwnerChangedCallback(owner_changed_cb);

   Init();
 }

 ShillClient::~ShillClient() {}

 void ShillClient::Init() {
   VLOG(2) << "ShillClient::Init();";
   CleanupConnectingService();
   devices_.clear();
   connectivity_state_ = Network::State::kOffline;
   VariantDictionary properties;
   if (!manager_proxy_.GetProperties(&properties, nullptr)) {
     LOG(ERROR) << "Unable to get properties from Manager, waiting for "
                   "Manager to come back online.";
     return;
   }
   auto it = properties.find(shill::kDevicesProperty);
   CHECK(it != properties.end()) << "shill should always publish a device list.";
   OnManagerPropertyChange(shill::kDevicesProperty, it->second);
 }

 void ShillClient::Connect(const string& ssid,
                           const string& passphrase,
                           const weave::DoneCallback& callback) {
   LOG(INFO) << "Connecting to WiFi network: " << ssid;
   if (connecting_service_) {
     weave::ErrorPtr error;
     weave::Error::AddTo(&error, FROM_HERE, "busy",
                         "Already connecting to WiFi network");
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::Passed(&error)));
     return;
   }
   CleanupConnectingService();
   VariantDictionary service_properties;
   service_properties[shill::kTypeProperty] = Any{string{shill::kTypeWifi}};
   service_properties[shill::kSSIDProperty] = Any{ssid};
   if (passphrase.empty()) {
     service_properties[shill::kSecurityProperty] = Any{shill::kSecurityNone};
   } else {
     service_properties[shill::kPassphraseProperty] = Any{passphrase};
     service_properties[shill::kSecurityProperty] = Any{shill::kSecurityPsk};
   }
   service_properties[shill::kSaveCredentialsProperty] = Any{true};
   service_properties[shill::kAutoConnectProperty] = Any{true};
   ObjectPath service_path;
   brillo::ErrorPtr brillo_error;
   if (!manager_proxy_.ConfigureService(service_properties, &service_path,
                                        &brillo_error) ||
       !manager_proxy_.RequestScan(shill::kTypeWifi, &brillo_error)) {
     weave::ErrorPtr weave_error;
     ConvertError(*brillo_error, &weave_error);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::Passed(&weave_error)));
     return;
   }
   connecting_service_.reset(new ServiceProxy{bus_, service_path});
   connecting_service_->Connect(nullptr);
   connect_done_callback_ = callback;
   connecting_service_->RegisterPropertyChangedSignalHandler(
       base::Bind(&ShillClient::OnServicePropertyChange,
                  weak_factory_.GetWeakPtr(), service_path),
       base::Bind(&ShillClient::OnServicePropertyChangeRegistration,
                  weak_factory_.GetWeakPtr(), service_path));
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&ShillClient::ConnectToServiceError,
                             weak_factory_.GetWeakPtr(), connecting_service_),
       base::TimeDelta::FromMinutes(1));
 }

 void ShillClient::ConnectToServiceError(
     std::shared_ptr<org::chromium::flimflam::ServiceProxy> connecting_service) {
   if (connecting_service != connecting_service_ ||
       connect_done_callback_.is_null()) {
     return;
   }
   std::string error = have_called_connect_ ? connecting_service_error_
                                            : shill::kErrorOutOfRange;
   if (error.empty())
     error = shill::kErrorInternal;
   OnErrorChangeForConnectingService(error);
 }

 Network::State ShillClient::GetConnectionState() const {
   return connectivity_state_;
 }

 void ShillClient::StartAccessPoint(const std::string& ssid) {
   LOG(INFO) << "Starting Soft AP: " << ssid;
   ap_manager_client_->Start(ssid);
 }

 void ShillClient::StopAccessPoint() {
   LOG(INFO) << "Stopping Soft AP";
   ap_manager_client_->Stop();
 }

 void ShillClient::AddConnectionChangedCallback(
     const ConnectionChangedCallback& listener) {
   connectivity_listeners_.push_back(listener);
 }

 bool ShillClient::IsMonitoredDevice(DeviceProxy* device) {
   if (device_whitelist_.empty()) {
     return true;
   }
   VariantDictionary device_properties;
   if (!device->GetProperties(&device_properties, nullptr)) {
     LOG(ERROR) << "Devices without properties aren't whitelisted.";
     return false;
   }
   auto it = device_properties.find(shill::kInterfaceProperty);
   if (it == device_properties.end()) {
     LOG(ERROR) << "Failed to find interface property in device properties.";
     return false;
   }
   return ContainsKey(device_whitelist_, it->second.TryGet<string>());
 }

 void ShillClient::OnShillServiceOwnerChange(const string& old_owner,
                                             const string& new_owner) {
   VLOG(1) << "Shill service owner name changed to '" << new_owner << "'";
   if (new_owner.empty()) {
     CleanupConnectingService();
     devices_.clear();
     connectivity_state_ = Network::State::kOffline;
   } else {
     Init();  // New service owner means shill reset!
   }
 }

 void ShillClient::OnManagerPropertyChangeRegistration(const string& interface,
                                                       const string& signal_name,
                                                       bool success) {
   VLOG(3) << "Registered ManagerPropertyChange handler.";
   CHECK(success) << "privetd requires Manager signals.";
   VariantDictionary properties;
   if (!manager_proxy_.GetProperties(&properties, nullptr)) {
     LOG(ERROR) << "Unable to get properties from Manager, waiting for "
                   "Manager to come back online.";
     return;
   }
   auto it = properties.find(shill::kDevicesProperty);
   CHECK(it != properties.end()) << "Shill should always publish a device list.";
   OnManagerPropertyChange(shill::kDevicesProperty, it->second);
 }

 void ShillClient::OnManagerPropertyChange(const string& property_name,
                                           const Any& property_value) {
   if (property_name != shill::kDevicesProperty) {
     return;
   }
   bool update_connectivity = false;
   VLOG(3) << "Manager's device list has changed.";
   // We're going to remove every device we haven't seen in the update.
   set<ObjectPath> device_paths_to_remove;
   for (const auto& kv : devices_) {
     device_paths_to_remove.insert(kv.first);
   }
   for (const auto& device_path : property_value.TryGet<vector<ObjectPath>>()) {
     if (!device_path.IsValid()) {
       LOG(ERROR) << "Ignoring invalid device path in Manager's device list.";
       return;
     }
     auto it = devices_.find(device_path);
     if (it != devices_.end()) {
       // Found an existing proxy.  Since the whitelist never changes,
       // this still a valid device.
       device_paths_to_remove.erase(device_path);
       continue;
     }
     std::unique_ptr<DeviceProxy> device{new DeviceProxy{bus_, device_path}};
     if (!IsMonitoredDevice(device.get())) {
       continue;
     }
     VLOG(3) << "Creating device proxy at " << device_path.value();
     devices_[device_path].device = std::move(device);
     update_connectivity = true;
     devices_[device_path].device->RegisterPropertyChangedSignalHandler(
         base::Bind(&ShillClient::OnDevicePropertyChange,
                    weak_factory_.GetWeakPtr(), device_path),
         base::Bind(&ShillClient::OnDevicePropertyChangeRegistration,
                    weak_factory_.GetWeakPtr(), device_path));
   }
   // Clean up devices/services related to removed devices.
   for (const ObjectPath& device_path : device_paths_to_remove) {
     devices_.erase(device_path);
     update_connectivity = true;
   }

   if (update_connectivity)
     UpdateConnectivityState();
 }

 void ShillClient::OnDevicePropertyChangeRegistration(
     const ObjectPath& device_path,
     const string& interface,
     const string& signal_name,
     bool success) {
   VLOG(3) << "Registered DevicePropertyChange handler.";
   auto it = devices_.find(device_path);
   if (it == devices_.end()) {
     return;
   }
   CHECK(success) << "Failed to subscribe to Device property changes.";
   DeviceProxy* device = it->second.device.get();
   VariantDictionary properties;
   if (!device->GetProperties(&properties, nullptr)) {
     LOG(WARNING) << "Failed to get device properties?";
     return;
   }
   auto prop_it = properties.find(shill::kSelectedServiceProperty);
   if (prop_it == properties.end()) {
     LOG(WARNING) << "Failed to get device's selected service?";
     return;
   }
   OnDevicePropertyChange(device_path, shill::kSelectedServiceProperty,
                          prop_it->second);
 }

 void ShillClient::OnDevicePropertyChange(const ObjectPath& device_path,
                                          const string& property_name,
                                          const Any& property_value) {
   // We only care about selected services anyway.
   if (property_name != shill::kSelectedServiceProperty) {
     return;
   }
   // If the device isn't our list of whitelisted devices, ignore it.
   auto it = devices_.find(device_path);
   if (it == devices_.end()) {
     return;
   }
   DeviceState& device_state = it->second;
   ObjectPath service_path{property_value.TryGet<ObjectPath>()};
   if (!service_path.IsValid()) {
     LOG(ERROR) << "Device at " << device_path.value()
                << " selected invalid service path.";
     return;
   }
   VLOG(3) << "Device at " << it->first.value() << " has selected service at "
           << service_path.value();
   bool removed_old_service{false};
   if (device_state.selected_service) {
     if (device_state.selected_service->GetObjectPath() == service_path) {
       return;  // Spurious update?
     }
     device_state.selected_service.reset();
     device_state.service_state = Network::State::kOffline;
     removed_old_service = true;
   }
   const bool reuse_connecting_service =
       service_path.value() != "/" && connecting_service_ &&
       connecting_service_->GetObjectPath() == service_path;
   if (reuse_connecting_service) {
     device_state.selected_service = connecting_service_;
     // When we reuse the connecting service, we need to make sure that our
     // cached state is correct.  Normally, we do this by relying reading the
     // state when our signal handlers finish registering, but this may have
     // happened long in the past for the connecting service.
     string state;
     if (GetStateForService(connecting_service_.get(), &state)) {
       device_state.service_state = ShillServiceStateToNetworkState(state);
     } else {
       LOG(WARNING) << "Failed to read properties from existing service "
                       "on selection.";
     }
   } else if (service_path.value() != "/") {
     // The device has selected a new service we haven't see before.
     device_state.selected_service =
         std::make_shared<ServiceProxy>(bus_, service_path);
     device_state.selected_service->RegisterPropertyChangedSignalHandler(
         base::Bind(&ShillClient::OnServicePropertyChange,
                    weak_factory_.GetWeakPtr(), service_path),
         base::Bind(&ShillClient::OnServicePropertyChangeRegistration,
                    weak_factory_.GetWeakPtr(), service_path));
   }

   if (reuse_connecting_service || removed_old_service) {
     UpdateConnectivityState();
   }
 }

 void ShillClient::OnServicePropertyChangeRegistration(const ObjectPath& path,
                                                       const string& interface,
                                                       const string& signal_name,
                                                       bool success) {
   VLOG(3) << "OnServicePropertyChangeRegistration(" << path.value() << ");";
   ServiceProxy* service{nullptr};
   if (connecting_service_ && connecting_service_->GetObjectPath() == path) {
     // Note that the connecting service might also be a selected service.
     service = connecting_service_.get();
     if (!success)
       CleanupConnectingService();
   } else {
     for (const auto& kv : devices_) {
       if (kv.second.selected_service &&
           kv.second.selected_service->GetObjectPath() == path) {
         service = kv.second.selected_service.get();
         break;
       }
     }
   }
   if (service == nullptr || !success) {
     return;  // A failure or success for a proxy we no longer care about.
   }
   VariantDictionary properties;
   if (!service->GetProperties(&properties, nullptr)) {
     return;
   }
   // Give ourselves property changed signals for the initial property
   // values.
   for (auto name : {shill::kStateProperty, shill::kSignalStrengthProperty,
                     shill::kErrorProperty}) {
     auto it = properties.find(name);
     if (it != properties.end())
       OnServicePropertyChange(path, name, it->second);
   }
 }

 void ShillClient::OnServicePropertyChange(const ObjectPath& service_path,
                                           const string& property_name,
                                           const Any& property_value) {
   VLOG(3) << "ServicePropertyChange(" << service_path.value() << ", "
           << property_name << ", ...);";

   bool is_connecting_service =
       connecting_service_ &&
       connecting_service_->GetObjectPath() == service_path;
   if (property_name == shill::kStateProperty) {
     const string state{property_value.TryGet<string>()};
     if (state.empty()) {
       VLOG(3) << "Invalid service state update.";
       return;
     }
     VLOG(3) << "New service state=" << state;
     OnStateChangeForSelectedService(service_path, state);
     if (is_connecting_service)
       OnStateChangeForConnectingService(state);
   } else if (property_name == shill::kSignalStrengthProperty) {
     VLOG(3) << "Signal strength=" << property_value.TryGet<uint8_t>();
     if (is_connecting_service)
       OnStrengthChangeForConnectingService(property_value.TryGet<uint8_t>());
   } else if (property_name == shill::kErrorProperty) {
     VLOG(3) << "Error=" << property_value.TryGet<std::string>();
     if (is_connecting_service)
       connecting_service_error_ = property_value.TryGet<std::string>();
   }
 }

 void ShillClient::OnStateChangeForConnectingService(const string& state) {
   switch (ShillServiceStateToNetworkState(state)) {
     case Network::State::kOnline: {
       auto callback = connect_done_callback_;
       connect_done_callback_.Reset();
       CleanupConnectingService();

       if (!callback.is_null())
         callback.Run(nullptr);
       break;
     }
     case Network::State::kError: {
       ConnectToServiceError(connecting_service_);
       break;
     }
     case Network::State::kOffline:
     case Network::State::kConnecting:
       break;
   }
 }

 void ShillClient::OnErrorChangeForConnectingService(const std::string& error) {
   if (error.empty())
     return;

   auto callback = connect_done_callback_;
   CleanupConnectingService();

   weave::ErrorPtr weave_error;
   weave::Error::AddTo(&weave_error, FROM_HERE, error,
                       "Failed to connect to WiFi network");

   if (!callback.is_null())
     callback.Run(std::move(weave_error));
 }

 void ShillClient::OnStrengthChangeForConnectingService(
     uint8_t signal_strength) {
   if (signal_strength == 0 || have_called_connect_) {
     return;
   }
   VLOG(1) << "Connecting service has signal. Calling Connect().";
   have_called_connect_ = true;
   // Failures here indicate that we've already connected,
   // or are connecting, or some other very unexciting thing.
   // Ignore all that, and rely on state changes to detect
   // connectivity.
   connecting_service_->Connect(nullptr);
 }

 void ShillClient::OnStateChangeForSelectedService(
     const ObjectPath& service_path,
     const string& state) {
   // Find the device/service pair responsible for this update
   VLOG(3) << "State for potentially selected service " << service_path.value()
           << " have changed to " << state;
   for (auto& kv : devices_) {
     if (kv.second.selected_service &&
         kv.second.selected_service->GetObjectPath() == service_path) {
       VLOG(3) << "Updated cached connection state for selected service.";
       kv.second.service_state = ShillServiceStateToNetworkState(state);
       UpdateConnectivityState();
       return;
     }
   }
 }

 void ShillClient::UpdateConnectivityState() {
   // Update the connectivity state of the device by picking the
   // state of the currently most connected selected service.
   Network::State new_connectivity_state{Network::State::kOffline};
   for (const auto& kv : devices_) {
     if (kv.second.service_state > new_connectivity_state) {
       new_connectivity_state = kv.second.service_state;
     }
   }
   VLOG(1) << "Connectivity changed: " << EnumToString(connectivity_state_)
           << " -> " << EnumToString(new_connectivity_state);
   // Notify listeners even if state changed to the same value. Listeners may
   // want to handle this event.
   connectivity_state_ = new_connectivity_state;
   // We may call UpdateConnectivityState whenever we mutate a data structure
   // such that our connectivity status could change.  However, we don't want
   // to allow people to call into ShillClient while some other operation is
   // underway.  Therefore, call our callbacks later, when we're in a good
   // state.
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&ShillClient::NotifyConnectivityListeners,
                             weak_factory_.GetWeakPtr(),
                             GetConnectionState() == Network::State::kOnline));
 }

 void ShillClient::NotifyConnectivityListeners(bool am_online) {
   VLOG(3) << "Notifying connectivity listeners that online=" << am_online;
   for (const auto& listener : connectivity_listeners_)
     listener.Run();
 }

 void ShillClient::CleanupConnectingService() {
   if (connecting_service_) {
     connecting_service_->ReleaseObjectProxy(base::Bind(&IgnoreDetachEvent));
     connecting_service_.reset();
   }
   connect_done_callback_.Reset();
   have_called_connect_ = false;
 }

 void ShillClient::OpenSslSocket(const std::string& host,
                                 uint16_t port,
                                 const OpenSslSocketCallback& callback) {
   if (disable_xmpp_)
     return;
   std::unique_ptr<weave::Stream> raw_stream{
       SocketStream::ConnectBlocking(host, port)};
   if (!raw_stream) {
     brillo::ErrorPtr error;
     brillo::errors::system::AddSystemError(&error, FROM_HERE, errno);
     weave::ErrorPtr weave_error;
     ConvertError(*error.get(), &weave_error);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, nullptr, base::Passed(&weave_error)));
     return;
   }

   SocketStream::TlsConnect(std::move(raw_stream), host, callback);
 }

 }  // namespace buffet
	// Copyright 2015 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "buffet/shill_client.h"

	#include <set>

	#include <base/message_loop/message_loop.h>
	#include <base/stl_util.h>
	#include <brillo/any.h>
	#include <brillo/errors/error.h>
	#include <brillo/variant_dictionary.h>
	#include <dbus/shill/dbus-constants.h>
	#include <weave/enum_to_string.h>

	#include "buffet/ap_manager_client.h"
	#include "buffet/socket_stream.h"
	#include "buffet/weave_error_conversion.h"

	using brillo::Any;
	using brillo::VariantDictionary;
	using dbus::ObjectPath;
	using org::chromium::flimflam::DeviceProxy;
	using org::chromium::flimflam::ServiceProxy;
	using std::map;
	using std::set;
	using std::string;
	using std::vector;
	using weave::EnumToString;
	using weave::provider::Network;

	namespace buffet {

	namespace {

	void IgnoreDetachEvent() {}

	bool GetStateForService(ServiceProxy* service, string* state) {
	CHECK(service) << "\|service\| was nullptr in GetStateForService()";
	VariantDictionary properties;
	if (!service->GetProperties(&properties, nullptr)) {
	LOG(WARNING) << "Failed to read properties from service.";
	return false;
	}
	auto property_it = properties.find(shill::kStateProperty);
	if (property_it == properties.end()) {
	LOG(WARNING) << "No state found in service properties.";
	return false;
	}
	string new_state = property_it->second.TryGet<string>();
	if (new_state.empty()) {
	LOG(WARNING) << "Invalid state value.";
	return false;
	}
	*state = new_state;
	return true;
	}

	Network::State ShillServiceStateToNetworkState(const string& state) {
	// TODO(wiley) What does "unconfigured" mean in a world with multiple sets
	// of WiFi credentials?
	// TODO(wiley) Detect disabled devices, update state appropriately.
	if ((state.compare(shill::kStateReady) == 0) \|\|
	(state.compare(shill::kStatePortal) == 0) \|\|
	(state.compare(shill::kStateOnline) == 0)) {
	return Network::State::kOnline;
	}
	if ((state.compare(shill::kStateAssociation) == 0) \|\|
	(state.compare(shill::kStateConfiguration) == 0)) {
	return Network::State::kConnecting;
	}
	if ((state.compare(shill::kStateFailure) == 0) \|\|
	(state.compare(shill::kStateActivationFailure) == 0)) {
	// TODO(wiley) Get error information off the service object.
	return Network::State::kError;
	}
	if ((state.compare(shill::kStateIdle) == 0) \|\|
	(state.compare(shill::kStateOffline) == 0) \|\|
	(state.compare(shill::kStateDisconnect) == 0)) {
	return Network::State::kOffline;
	}
	LOG(WARNING) << "Unknown state found: '" << state << "'";
	return Network::State::kOffline;
	}

	} // namespace

	ShillClient::ShillClient(const scoped_refptr<dbus::Bus>& bus,
	const set<string>& device_whitelist,
	bool disable_xmpp)
	: bus_{bus},
	manager_proxy_{bus_},
	device_whitelist_{device_whitelist},
	disable_xmpp_{disable_xmpp},
	ap_manager_client_{new ApManagerClient(bus)} {
	manager_proxy_.RegisterPropertyChangedSignalHandler(
	base::Bind(&ShillClient::OnManagerPropertyChange,
	weak_factory_.GetWeakPtr()),
	base::Bind(&ShillClient::OnManagerPropertyChangeRegistration,
	weak_factory_.GetWeakPtr()));
	auto owner_changed_cb = base::Bind(&ShillClient::OnShillServiceOwnerChange,
	weak_factory_.GetWeakPtr());
	bus_->GetObjectProxy(shill::kFlimflamServiceName, ObjectPath{"/"})
	->SetNameOwnerChangedCallback(owner_changed_cb);

	Init();
	}

	ShillClient::~ShillClient() {}

	void ShillClient::Init() {
	VLOG(2) << "ShillClient::Init();";
	CleanupConnectingService();
	devices_.clear();
	connectivity_state_ = Network::State::kOffline;
	VariantDictionary properties;
	if (!manager_proxy_.GetProperties(&properties, nullptr)) {
	LOG(ERROR) << "Unable to get properties from Manager, waiting for "
	"Manager to come back online.";
	return;
	}
	auto it = properties.find(shill::kDevicesProperty);
	CHECK(it != properties.end()) << "shill should always publish a device list.";
	OnManagerPropertyChange(shill::kDevicesProperty, it->second);
	}

	void ShillClient::Connect(const string& ssid,
	const string& passphrase,
	const weave::DoneCallback& callback) {
	LOG(INFO) << "Connecting to WiFi network: " << ssid;
	if (connecting_service_) {
	weave::ErrorPtr error;
	weave::Error::AddTo(&error, FROM_HERE, "busy",
	"Already connecting to WiFi network");
	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::Bind(callback, base::Passed(&error)));
	return;
	}
	CleanupConnectingService();
	VariantDictionary service_properties;
	service_properties[shill::kTypeProperty] = Any{string{shill::kTypeWifi}};
	service_properties[shill::kSSIDProperty] = Any{ssid};
	if (passphrase.empty()) {
	service_properties[shill::kSecurityProperty] = Any{shill::kSecurityNone};
	} else {
	service_properties[shill::kPassphraseProperty] = Any{passphrase};
	service_properties[shill::kSecurityProperty] = Any{shill::kSecurityPsk};
	}
	service_properties[shill::kSaveCredentialsProperty] = Any{true};
	service_properties[shill::kAutoConnectProperty] = Any{true};
	ObjectPath service_path;
	brillo::ErrorPtr brillo_error;
	if (!manager_proxy_.ConfigureService(service_properties, &service_path,
	&brillo_error) \|\|
	!manager_proxy_.RequestScan(shill::kTypeWifi, &brillo_error)) {
	weave::ErrorPtr weave_error;
	ConvertError(*brillo_error, &weave_error);
	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::Bind(callback, base::Passed(&weave_error)));
	return;
	}
	connecting_service_.reset(new ServiceProxy{bus_, service_path});
	connecting_service_->Connect(nullptr);
	connect_done_callback_ = callback;
	connecting_service_->RegisterPropertyChangedSignalHandler(
	base::Bind(&ShillClient::OnServicePropertyChange,
	weak_factory_.GetWeakPtr(), service_path),
	base::Bind(&ShillClient::OnServicePropertyChangeRegistration,
	weak_factory_.GetWeakPtr(), service_path));
	base::MessageLoop::current()->PostDelayedTask(
	FROM_HERE, base::Bind(&ShillClient::ConnectToServiceError,
	weak_factory_.GetWeakPtr(), connecting_service_),
	base::TimeDelta::FromMinutes(1));
	}

	void ShillClient::ConnectToServiceError(
	std::shared_ptr<org::chromium::flimflam::ServiceProxy> connecting_service) {
	if (connecting_service != connecting_service_ \|\|
	connect_done_callback_.is_null()) {
	return;
	}
	std::string error = have_called_connect_ ? connecting_service_error_
	: shill::kErrorOutOfRange;
	if (error.empty())
	error = shill::kErrorInternal;
	OnErrorChangeForConnectingService(error);
	}

	Network::State ShillClient::GetConnectionState() const {
	return connectivity_state_;
	}

	void ShillClient::StartAccessPoint(const std::string& ssid) {
	LOG(INFO) << "Starting Soft AP: " << ssid;
	ap_manager_client_->Start(ssid);
	}

	void ShillClient::StopAccessPoint() {
	LOG(INFO) << "Stopping Soft AP";
	ap_manager_client_->Stop();
	}

	void ShillClient::AddConnectionChangedCallback(
	const ConnectionChangedCallback& listener) {
	connectivity_listeners_.push_back(listener);
	}

	bool ShillClient::IsMonitoredDevice(DeviceProxy* device) {
	if (device_whitelist_.empty()) {
	return true;
	}
	VariantDictionary device_properties;
	if (!device->GetProperties(&device_properties, nullptr)) {
	LOG(ERROR) << "Devices without properties aren't whitelisted.";
	return false;
	}
	auto it = device_properties.find(shill::kInterfaceProperty);
	if (it == device_properties.end()) {
	LOG(ERROR) << "Failed to find interface property in device properties.";
	return false;
	}
	return ContainsKey(device_whitelist_, it->second.TryGet<string>());
	}

	void ShillClient::OnShillServiceOwnerChange(const string& old_owner,
	const string& new_owner) {
	VLOG(1) << "Shill service owner name changed to '" << new_owner << "'";
	if (new_owner.empty()) {
	CleanupConnectingService();
	devices_.clear();
	connectivity_state_ = Network::State::kOffline;
	} else {
	Init(); // New service owner means shill reset!
	}
	}

	void ShillClient::OnManagerPropertyChangeRegistration(const string& interface,
	const string& signal_name,
	bool success) {
	VLOG(3) << "Registered ManagerPropertyChange handler.";
	CHECK(success) << "privetd requires Manager signals.";
	VariantDictionary properties;
	if (!manager_proxy_.GetProperties(&properties, nullptr)) {
	LOG(ERROR) << "Unable to get properties from Manager, waiting for "
	"Manager to come back online.";
	return;
	}
	auto it = properties.find(shill::kDevicesProperty);
	CHECK(it != properties.end()) << "Shill should always publish a device list.";
	OnManagerPropertyChange(shill::kDevicesProperty, it->second);
	}

	void ShillClient::OnManagerPropertyChange(const string& property_name,
	const Any& property_value) {
	if (property_name != shill::kDevicesProperty) {
	return;
	}
	bool update_connectivity = false;
	VLOG(3) << "Manager's device list has changed.";
	// We're going to remove every device we haven't seen in the update.
	set<ObjectPath> device_paths_to_remove;
	for (const auto& kv : devices_) {
	device_paths_to_remove.insert(kv.first);
	}
	for (const auto& device_path : property_value.TryGet<vector<ObjectPath>>()) {
	if (!device_path.IsValid()) {
	LOG(ERROR) << "Ignoring invalid device path in Manager's device list.";
	return;
	}
	auto it = devices_.find(device_path);
	if (it != devices_.end()) {
	// Found an existing proxy. Since the whitelist never changes,
	// this still a valid device.
	device_paths_to_remove.erase(device_path);
	continue;
	}
	std::unique_ptr<DeviceProxy> device{new DeviceProxy{bus_, device_path}};
	if (!IsMonitoredDevice(device.get())) {
	continue;
	}
	VLOG(3) << "Creating device proxy at " << device_path.value();
	devices_[device_path].device = std::move(device);
	update_connectivity = true;
	devices_[device_path].device->RegisterPropertyChangedSignalHandler(
	base::Bind(&ShillClient::OnDevicePropertyChange,
	weak_factory_.GetWeakPtr(), device_path),
	base::Bind(&ShillClient::OnDevicePropertyChangeRegistration,
	weak_factory_.GetWeakPtr(), device_path));
	}
	// Clean up devices/services related to removed devices.
	for (const ObjectPath& device_path : device_paths_to_remove) {
	devices_.erase(device_path);
	update_connectivity = true;
	}

	if (update_connectivity)
	UpdateConnectivityState();
	}

	void ShillClient::OnDevicePropertyChangeRegistration(
	const ObjectPath& device_path,
	const string& interface,
	const string& signal_name,
	bool success) {
	VLOG(3) << "Registered DevicePropertyChange handler.";
	auto it = devices_.find(device_path);
	if (it == devices_.end()) {
	return;
	}
	CHECK(success) << "Failed to subscribe to Device property changes.";
	DeviceProxy* device = it->second.device.get();
	VariantDictionary properties;
	if (!device->GetProperties(&properties, nullptr)) {
	LOG(WARNING) << "Failed to get device properties?";
	return;
	}
	auto prop_it = properties.find(shill::kSelectedServiceProperty);
	if (prop_it == properties.end()) {
	LOG(WARNING) << "Failed to get device's selected service?";
	return;
	}
	OnDevicePropertyChange(device_path, shill::kSelectedServiceProperty,
	prop_it->second);
	}

	void ShillClient::OnDevicePropertyChange(const ObjectPath& device_path,
	const string& property_name,
	const Any& property_value) {
	// We only care about selected services anyway.
	if (property_name != shill::kSelectedServiceProperty) {
	return;
	}
	// If the device isn't our list of whitelisted devices, ignore it.
	auto it = devices_.find(device_path);
	if (it == devices_.end()) {
	return;
	}
	DeviceState& device_state = it->second;
	ObjectPath service_path{property_value.TryGet<ObjectPath>()};
	if (!service_path.IsValid()) {
	LOG(ERROR) << "Device at " << device_path.value()
	<< " selected invalid service path.";
	return;
	}
	VLOG(3) << "Device at " << it->first.value() << " has selected service at "
	<< service_path.value();
	bool removed_old_service{false};
	if (device_state.selected_service) {
	if (device_state.selected_service->GetObjectPath() == service_path) {
	return; // Spurious update?
	}
	device_state.selected_service.reset();
	device_state.service_state = Network::State::kOffline;
	removed_old_service = true;
	}
	const bool reuse_connecting_service =
	service_path.value() != "/" && connecting_service_ &&
	connecting_service_->GetObjectPath() == service_path;
	if (reuse_connecting_service) {
	device_state.selected_service = connecting_service_;
	// When we reuse the connecting service, we need to make sure that our
	// cached state is correct. Normally, we do this by relying reading the
	// state when our signal handlers finish registering, but this may have
	// happened long in the past for the connecting service.
	string state;
	if (GetStateForService(connecting_service_.get(), &state)) {
	device_state.service_state = ShillServiceStateToNetworkState(state);
	} else {
	LOG(WARNING) << "Failed to read properties from existing service "
	"on selection.";
	}
	} else if (service_path.value() != "/") {
	// The device has selected a new service we haven't see before.
	device_state.selected_service =
	std::make_shared<ServiceProxy>(bus_, service_path);
	device_state.selected_service->RegisterPropertyChangedSignalHandler(
	base::Bind(&ShillClient::OnServicePropertyChange,
	weak_factory_.GetWeakPtr(), service_path),
	base::Bind(&ShillClient::OnServicePropertyChangeRegistration,
	weak_factory_.GetWeakPtr(), service_path));
	}

	if (reuse_connecting_service \|\| removed_old_service) {
	UpdateConnectivityState();
	}
	}

	void ShillClient::OnServicePropertyChangeRegistration(const ObjectPath& path,
	const string& interface,
	const string& signal_name,
	bool success) {
	VLOG(3) << "OnServicePropertyChangeRegistration(" << path.value() << ");";
	ServiceProxy* service{nullptr};
	if (connecting_service_ && connecting_service_->GetObjectPath() == path) {
	// Note that the connecting service might also be a selected service.
	service = connecting_service_.get();
	if (!success)
	CleanupConnectingService();
	} else {
	for (const auto& kv : devices_) {
	if (kv.second.selected_service &&
	kv.second.selected_service->GetObjectPath() == path) {
	service = kv.second.selected_service.get();
	break;
	}
	}
	}
	if (service == nullptr \|\| !success) {
	return; // A failure or success for a proxy we no longer care about.
	}
	VariantDictionary properties;
	if (!service->GetProperties(&properties, nullptr)) {
	return;
	}
	// Give ourselves property changed signals for the initial property
	// values.
	for (auto name : {shill::kStateProperty, shill::kSignalStrengthProperty,
	shill::kErrorProperty}) {
	auto it = properties.find(name);
	if (it != properties.end())
	OnServicePropertyChange(path, name, it->second);
	}
	}

	void ShillClient::OnServicePropertyChange(const ObjectPath& service_path,
	const string& property_name,
	const Any& property_value) {
	VLOG(3) << "ServicePropertyChange(" << service_path.value() << ", "
	<< property_name << ", ...);";

	bool is_connecting_service =
	connecting_service_ &&
	connecting_service_->GetObjectPath() == service_path;
	if (property_name == shill::kStateProperty) {
	const string state{property_value.TryGet<string>()};
	if (state.empty()) {
	VLOG(3) << "Invalid service state update.";
	return;
	}
	VLOG(3) << "New service state=" << state;
	OnStateChangeForSelectedService(service_path, state);
	if (is_connecting_service)
	OnStateChangeForConnectingService(state);
	} else if (property_name == shill::kSignalStrengthProperty) {
	VLOG(3) << "Signal strength=" << property_value.TryGet<uint8_t>();
	if (is_connecting_service)
	OnStrengthChangeForConnectingService(property_value.TryGet<uint8_t>());
	} else if (property_name == shill::kErrorProperty) {
	VLOG(3) << "Error=" << property_value.TryGet<std::string>();
	if (is_connecting_service)
	connecting_service_error_ = property_value.TryGet<std::string>();
	}
	}

	void ShillClient::OnStateChangeForConnectingService(const string& state) {
	switch (ShillServiceStateToNetworkState(state)) {
	case Network::State::kOnline: {
	auto callback = connect_done_callback_;
	connect_done_callback_.Reset();
	CleanupConnectingService();

	if (!callback.is_null())
	callback.Run(nullptr);
	break;
	}
	case Network::State::kError: {
	ConnectToServiceError(connecting_service_);
	break;
	}
	case Network::State::kOffline:
	case Network::State::kConnecting:
	break;
	}
	}

	void ShillClient::OnErrorChangeForConnectingService(const std::string& error) {
	if (error.empty())
	return;

	auto callback = connect_done_callback_;
	CleanupConnectingService();

	weave::ErrorPtr weave_error;
	weave::Error::AddTo(&weave_error, FROM_HERE, error,
	"Failed to connect to WiFi network");

	if (!callback.is_null())
	callback.Run(std::move(weave_error));
	}

	void ShillClient::OnStrengthChangeForConnectingService(
	uint8_t signal_strength) {
	if (signal_strength == 0 \|\| have_called_connect_) {
	return;
	}
	VLOG(1) << "Connecting service has signal. Calling Connect().";
	have_called_connect_ = true;
	// Failures here indicate that we've already connected,
	// or are connecting, or some other very unexciting thing.
	// Ignore all that, and rely on state changes to detect
	// connectivity.
	connecting_service_->Connect(nullptr);
	}

	void ShillClient::OnStateChangeForSelectedService(
	const ObjectPath& service_path,
	const string& state) {
	// Find the device/service pair responsible for this update
	VLOG(3) << "State for potentially selected service " << service_path.value()
	<< " have changed to " << state;
	for (auto& kv : devices_) {
	if (kv.second.selected_service &&
	kv.second.selected_service->GetObjectPath() == service_path) {
	VLOG(3) << "Updated cached connection state for selected service.";
	kv.second.service_state = ShillServiceStateToNetworkState(state);
	UpdateConnectivityState();
	return;
	}
	}
	}

	void ShillClient::UpdateConnectivityState() {
	// Update the connectivity state of the device by picking the
	// state of the currently most connected selected service.
	Network::State new_connectivity_state{Network::State::kOffline};
	for (const auto& kv : devices_) {
	if (kv.second.service_state > new_connectivity_state) {
	new_connectivity_state = kv.second.service_state;
	}
	}
	VLOG(1) << "Connectivity changed: " << EnumToString(connectivity_state_)
	<< " -> " << EnumToString(new_connectivity_state);
	// Notify listeners even if state changed to the same value. Listeners may
	// want to handle this event.
	connectivity_state_ = new_connectivity_state;
	// We may call UpdateConnectivityState whenever we mutate a data structure
	// such that our connectivity status could change. However, we don't want
	// to allow people to call into ShillClient while some other operation is
	// underway. Therefore, call our callbacks later, when we're in a good
	// state.
	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::Bind(&ShillClient::NotifyConnectivityListeners,
	weak_factory_.GetWeakPtr(),
	GetConnectionState() == Network::State::kOnline));
	}

	void ShillClient::NotifyConnectivityListeners(bool am_online) {
	VLOG(3) << "Notifying connectivity listeners that online=" << am_online;
	for (const auto& listener : connectivity_listeners_)
	listener.Run();
	}

	void ShillClient::CleanupConnectingService() {
	if (connecting_service_) {
	connecting_service_->ReleaseObjectProxy(base::Bind(&IgnoreDetachEvent));
	connecting_service_.reset();
	}
	connect_done_callback_.Reset();
	have_called_connect_ = false;
	}

	void ShillClient::OpenSslSocket(const std::string& host,
	uint16_t port,
	const OpenSslSocketCallback& callback) {
	if (disable_xmpp_)
	return;
	std::unique_ptr<weave::Stream> raw_stream{
	SocketStream::ConnectBlocking(host, port)};
	if (!raw_stream) {
	brillo::ErrorPtr error;
	brillo::errors::system::AddSystemError(&error, FROM_HERE, errno);
	weave::ErrorPtr weave_error;
	ConvertError(*error.get(), &weave_error);
	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::Bind(callback, nullptr, base::Passed(&weave_error)));
	return;
	}

	SocketStream::TlsConnect(std::move(raw_stream), host, callback);
	}

	} // namespace buffet