1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chromeos/dbus/shill_service_client.h" 6 7 #include "base/bind.h" 8 #include "base/memory/weak_ptr.h" 9 #include "base/message_loop/message_loop.h" 10 #include "base/stl_util.h" 11 #include "base/values.h" 12 #include "chromeos/dbus/shill_property_changed_observer.h" 13 #include "chromeos/network/network_event_log.h" 14 #include "dbus/bus.h" 15 #include "dbus/message.h" 16 #include "dbus/object_proxy.h" 17 #include "third_party/cros_system_api/dbus/service_constants.h" 18 19 namespace chromeos { 20 21 namespace { 22 23 #ifndef DBUS_ERROR_UNKNOWN_OBJECT 24 // The linux_chromeos ASAN builder has an older version of dbus-protocol.h 25 // so make sure this is defined. 26 #define DBUS_ERROR_UNKNOWN_OBJECT "org.freedesktop.DBus.Error.UnknownObject" 27 #endif 28 29 // Error callback for GetProperties. 30 void OnGetDictionaryError( 31 const std::string& method_name, 32 const dbus::ObjectPath& service_path, 33 const ShillServiceClient::DictionaryValueCallback& callback, 34 const std::string& error_name, 35 const std::string& error_message) { 36 const std::string log_string = 37 "Failed to call org.chromium.shill.Service." + method_name + 38 " for: " + service_path.value() + ": " + 39 error_name + ": " + error_message; 40 41 // Suppress ERROR messages for UnknownMethod/Object" since this can 42 // happen under normal conditions. See crbug.com/130660 and crbug.com/222210. 43 if (error_name == DBUS_ERROR_UNKNOWN_METHOD || 44 error_name == DBUS_ERROR_UNKNOWN_OBJECT) 45 VLOG(1) << log_string; 46 else 47 LOG(ERROR) << log_string; 48 49 base::DictionaryValue empty_dictionary; 50 callback.Run(DBUS_METHOD_CALL_FAILURE, empty_dictionary); 51 } 52 53 // The ShillServiceClient implementation. 54 class ShillServiceClientImpl : public ShillServiceClient { 55 public: 56 explicit ShillServiceClientImpl() 57 : bus_(NULL), 58 weak_ptr_factory_(this) { 59 } 60 61 virtual ~ShillServiceClientImpl() { 62 for (HelperMap::iterator iter = helpers_.begin(); 63 iter != helpers_.end(); ++iter) { 64 ShillClientHelper* helper = iter->second; 65 bus_->RemoveObjectProxy(shill::kFlimflamServiceName, 66 helper->object_proxy()->object_path(), 67 base::Bind(&base::DoNothing)); 68 delete helper; 69 } 70 } 71 72 virtual void AddPropertyChangedObserver( 73 const dbus::ObjectPath& service_path, 74 ShillPropertyChangedObserver* observer) OVERRIDE { 75 GetHelper(service_path)->AddPropertyChangedObserver(observer); 76 } 77 78 virtual void RemovePropertyChangedObserver( 79 const dbus::ObjectPath& service_path, 80 ShillPropertyChangedObserver* observer) OVERRIDE { 81 GetHelper(service_path)->RemovePropertyChangedObserver(observer); 82 } 83 84 virtual void GetProperties(const dbus::ObjectPath& service_path, 85 const DictionaryValueCallback& callback) OVERRIDE { 86 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 87 shill::kGetPropertiesFunction); 88 GetHelper(service_path)->CallDictionaryValueMethodWithErrorCallback( 89 &method_call, 90 base::Bind(callback, DBUS_METHOD_CALL_SUCCESS), 91 base::Bind(&OnGetDictionaryError, "GetProperties", 92 service_path, callback)); 93 } 94 95 virtual void SetProperty(const dbus::ObjectPath& service_path, 96 const std::string& name, 97 const base::Value& value, 98 const base::Closure& callback, 99 const ErrorCallback& error_callback) OVERRIDE { 100 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 101 shill::kSetPropertyFunction); 102 dbus::MessageWriter writer(&method_call); 103 writer.AppendString(name); 104 ShillClientHelper::AppendValueDataAsVariant(&writer, value); 105 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 106 callback, 107 error_callback); 108 } 109 110 virtual void SetProperties(const dbus::ObjectPath& service_path, 111 const base::DictionaryValue& properties, 112 const base::Closure& callback, 113 const ErrorCallback& error_callback) OVERRIDE { 114 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 115 shill::kSetPropertiesFunction); 116 dbus::MessageWriter writer(&method_call); 117 ShillClientHelper::AppendServicePropertiesDictionary(&writer, properties); 118 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 119 callback, 120 error_callback); 121 } 122 123 virtual void ClearProperty(const dbus::ObjectPath& service_path, 124 const std::string& name, 125 const base::Closure& callback, 126 const ErrorCallback& error_callback) OVERRIDE { 127 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 128 shill::kClearPropertyFunction); 129 dbus::MessageWriter writer(&method_call); 130 writer.AppendString(name); 131 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 132 callback, 133 error_callback); 134 } 135 136 137 virtual void ClearProperties(const dbus::ObjectPath& service_path, 138 const std::vector<std::string>& names, 139 const ListValueCallback& callback, 140 const ErrorCallback& error_callback) OVERRIDE { 141 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 142 shill::kClearPropertiesFunction); 143 dbus::MessageWriter writer(&method_call); 144 writer.AppendArrayOfStrings(names); 145 GetHelper(service_path)->CallListValueMethodWithErrorCallback( 146 &method_call, 147 callback, 148 error_callback); 149 } 150 151 virtual void Connect(const dbus::ObjectPath& service_path, 152 const base::Closure& callback, 153 const ErrorCallback& error_callback) OVERRIDE { 154 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 155 shill::kConnectFunction); 156 GetHelper(service_path)->CallVoidMethodWithErrorCallback( 157 &method_call, callback, error_callback); 158 } 159 160 virtual void Disconnect(const dbus::ObjectPath& service_path, 161 const base::Closure& callback, 162 const ErrorCallback& error_callback) OVERRIDE { 163 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 164 shill::kDisconnectFunction); 165 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 166 callback, 167 error_callback); 168 } 169 170 virtual void Remove(const dbus::ObjectPath& service_path, 171 const base::Closure& callback, 172 const ErrorCallback& error_callback) OVERRIDE { 173 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 174 shill::kRemoveServiceFunction); 175 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 176 callback, 177 error_callback); 178 } 179 180 virtual void ActivateCellularModem( 181 const dbus::ObjectPath& service_path, 182 const std::string& carrier, 183 const base::Closure& callback, 184 const ErrorCallback& error_callback) OVERRIDE { 185 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 186 shill::kActivateCellularModemFunction); 187 dbus::MessageWriter writer(&method_call); 188 writer.AppendString(carrier); 189 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 190 callback, 191 error_callback); 192 } 193 194 virtual void CompleteCellularActivation( 195 const dbus::ObjectPath& service_path, 196 const base::Closure& callback, 197 const ErrorCallback& error_callback) OVERRIDE { 198 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 199 shill::kCompleteCellularActivationFunction); 200 dbus::MessageWriter writer(&method_call); 201 GetHelper(service_path)->CallVoidMethodWithErrorCallback(&method_call, 202 callback, 203 error_callback); 204 } 205 206 virtual void GetLoadableProfileEntries( 207 const dbus::ObjectPath& service_path, 208 const DictionaryValueCallback& callback) OVERRIDE { 209 dbus::MethodCall method_call(shill::kFlimflamServiceInterface, 210 shill::kGetLoadableProfileEntriesFunction); 211 GetHelper(service_path)->CallDictionaryValueMethodWithErrorCallback( 212 &method_call, 213 base::Bind(callback, DBUS_METHOD_CALL_SUCCESS), 214 base::Bind(&OnGetDictionaryError, "GetLoadableProfileEntries", 215 service_path, callback)); 216 } 217 218 virtual ShillServiceClient::TestInterface* GetTestInterface() OVERRIDE { 219 return NULL; 220 } 221 222 protected: 223 virtual void Init(dbus::Bus* bus) OVERRIDE { 224 bus_ = bus; 225 } 226 227 private: 228 typedef std::map<std::string, ShillClientHelper*> HelperMap; 229 230 // Returns the corresponding ShillClientHelper for the profile. 231 ShillClientHelper* GetHelper(const dbus::ObjectPath& service_path) { 232 HelperMap::iterator it = helpers_.find(service_path.value()); 233 if (it != helpers_.end()) 234 return it->second; 235 236 // There is no helper for the profile, create it. 237 NET_LOG_DEBUG("AddShillClientHelper", service_path.value()); 238 dbus::ObjectProxy* object_proxy = 239 bus_->GetObjectProxy(shill::kFlimflamServiceName, service_path); 240 ShillClientHelper* helper = new ShillClientHelper(object_proxy); 241 helper->SetReleasedCallback( 242 base::Bind(&ShillServiceClientImpl::NotifyReleased, 243 weak_ptr_factory_.GetWeakPtr())); 244 helper->MonitorPropertyChanged(shill::kFlimflamServiceInterface); 245 helpers_.insert(HelperMap::value_type(service_path.value(), helper)); 246 return helper; 247 } 248 249 void NotifyReleased(ShillClientHelper* helper) { 250 // New Shill Service DBus objects are created relatively frequently, so 251 // remove them when they become inactive (no observers and no active method 252 // calls). 253 dbus::ObjectPath object_path = helper->object_proxy()->object_path(); 254 // Make sure we don't release the proxy used by ShillManagerClient ("/"). 255 // This shouldn't ever happen, but might if a bug in the code requests 256 // a service with path "/", or a bug in Shill passes "/" as a service path. 257 // Either way this would cause an invalid memory access in 258 // ShillManagerClient, see crbug.com/324849. 259 if (object_path == dbus::ObjectPath(shill::kFlimflamServicePath)) { 260 NET_LOG_ERROR("ShillServiceClient service has invalid path", 261 shill::kFlimflamServicePath); 262 return; 263 } 264 NET_LOG_DEBUG("RemoveShillClientHelper", object_path.value()); 265 bus_->RemoveObjectProxy(shill::kFlimflamServiceName, 266 object_path, base::Bind(&base::DoNothing)); 267 helpers_.erase(object_path.value()); 268 delete helper; 269 } 270 271 dbus::Bus* bus_; 272 HelperMap helpers_; 273 base::WeakPtrFactory<ShillServiceClientImpl> weak_ptr_factory_; 274 275 DISALLOW_COPY_AND_ASSIGN(ShillServiceClientImpl); 276 }; 277 278 } // namespace 279 280 ShillServiceClient::ShillServiceClient() {} 281 282 ShillServiceClient::~ShillServiceClient() {} 283 284 // static 285 ShillServiceClient* ShillServiceClient::Create() { 286 return new ShillServiceClientImpl(); 287 } 288 289 } // namespace chromeos 290
