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/network/network_configuration_handler.h" 6 7 #include <string> 8 #include <vector> 9 10 #include "base/bind.h" 11 #include "base/format_macros.h" 12 #include "base/json/json_writer.h" 13 #include "base/logging.h" 14 #include "base/memory/ref_counted.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/stl_util.h" 17 #include "base/strings/stringprintf.h" 18 #include "base/values.h" 19 #include "chromeos/dbus/dbus_thread_manager.h" 20 #include "chromeos/dbus/shill_manager_client.h" 21 #include "chromeos/dbus/shill_profile_client.h" 22 #include "chromeos/dbus/shill_service_client.h" 23 #include "chromeos/network/network_event_log.h" 24 #include "chromeos/network/network_state.h" 25 #include "chromeos/network/network_state_handler.h" 26 #include "chromeos/network/shill_property_util.h" 27 #include "dbus/object_path.h" 28 #include "third_party/cros_system_api/dbus/service_constants.h" 29 30 namespace chromeos { 31 32 namespace { 33 34 // Strip surrounding "" from keys (if present). 35 std::string StripQuotations(const std::string& in_str) { 36 size_t len = in_str.length(); 37 if (len >= 2 && in_str[0] == '"' && in_str[len-1] == '"') 38 return in_str.substr(1, len-2); 39 return in_str; 40 } 41 42 void InvokeErrorCallback(const std::string& service_path, 43 const network_handler::ErrorCallback& error_callback, 44 const std::string& error_name) { 45 std::string error_msg = "Config Error: " + error_name; 46 NET_LOG_ERROR(error_msg, service_path); 47 network_handler::RunErrorCallback( 48 error_callback, service_path, error_name, error_msg); 49 } 50 51 void GetPropertiesCallback( 52 const network_handler::DictionaryResultCallback& callback, 53 const network_handler::ErrorCallback& error_callback, 54 const std::string& service_path, 55 DBusMethodCallStatus call_status, 56 const base::DictionaryValue& properties) { 57 if (call_status != DBUS_METHOD_CALL_SUCCESS) { 58 // Because network services are added and removed frequently, we will see 59 // failures regularly, so don't log these. 60 network_handler::RunErrorCallback(error_callback, 61 service_path, 62 network_handler::kDBusFailedError, 63 network_handler::kDBusFailedErrorMessage); 64 return; 65 } 66 if (callback.is_null()) 67 return; 68 69 // Get the correct name from WifiHex if necessary. 70 scoped_ptr<base::DictionaryValue> properties_copy(properties.DeepCopy()); 71 std::string name = 72 shill_property_util::GetNameFromProperties(service_path, properties); 73 if (!name.empty()) 74 properties_copy->SetStringWithoutPathExpansion(shill::kNameProperty, name); 75 callback.Run(service_path, *properties_copy.get()); 76 } 77 78 void SetNetworkProfileErrorCallback( 79 const std::string& service_path, 80 const std::string& profile_path, 81 const network_handler::ErrorCallback& error_callback, 82 const std::string& dbus_error_name, 83 const std::string& dbus_error_message) { 84 network_handler::ShillErrorCallbackFunction( 85 "Config.SetNetworkProfile Failed: " + profile_path, 86 service_path, error_callback, 87 dbus_error_name, dbus_error_message); 88 } 89 90 void LogConfigProperties(const std::string& desc, 91 const std::string& path, 92 const base::DictionaryValue& properties) { 93 for (base::DictionaryValue::Iterator iter(properties); 94 !iter.IsAtEnd(); iter.Advance()) { 95 std::string v = "******"; 96 if (!shill_property_util::IsPassphraseKey(iter.key())) 97 base::JSONWriter::Write(&iter.value(), &v); 98 NET_LOG_DEBUG(desc, path + "." + iter.key() + "=" + v); 99 } 100 } 101 102 } // namespace 103 104 // Helper class to request from Shill the profile entries associated with a 105 // Service and delete the service from each profile. Triggers either 106 // |callback| on success or |error_callback| on failure, and calls 107 // |handler|->ProfileEntryDeleterCompleted() on completion to delete itself. 108 class NetworkConfigurationHandler::ProfileEntryDeleter 109 : public base::SupportsWeakPtr<ProfileEntryDeleter> { 110 public: 111 ProfileEntryDeleter(NetworkConfigurationHandler* handler, 112 const std::string& service_path, 113 const base::Closure& callback, 114 const network_handler::ErrorCallback& error_callback) 115 : owner_(handler), 116 service_path_(service_path), 117 callback_(callback), 118 error_callback_(error_callback) { 119 } 120 121 void Run() { 122 DBusThreadManager::Get()->GetShillServiceClient()-> 123 GetLoadableProfileEntries( 124 dbus::ObjectPath(service_path_), 125 base::Bind(&ProfileEntryDeleter::GetProfileEntriesToDeleteCallback, 126 AsWeakPtr())); 127 } 128 129 private: 130 void GetProfileEntriesToDeleteCallback( 131 DBusMethodCallStatus call_status, 132 const base::DictionaryValue& profile_entries) { 133 if (call_status != DBUS_METHOD_CALL_SUCCESS) { 134 InvokeErrorCallback( 135 service_path_, error_callback_, "GetLoadableProfileEntriesFailed"); 136 owner_->ProfileEntryDeleterCompleted(service_path_); // Deletes this. 137 return; 138 } 139 140 for (base::DictionaryValue::Iterator iter(profile_entries); 141 !iter.IsAtEnd(); iter.Advance()) { 142 std::string profile_path = StripQuotations(iter.key()); 143 std::string entry_path; 144 iter.value().GetAsString(&entry_path); 145 if (profile_path.empty() || entry_path.empty()) { 146 NET_LOG_ERROR("Failed to parse Profile Entry", base::StringPrintf( 147 "%s: %s", profile_path.c_str(), entry_path.c_str())); 148 continue; 149 } 150 if (profile_delete_entries_.count(profile_path) != 0) { 151 NET_LOG_ERROR("Multiple Profile Entries", base::StringPrintf( 152 "%s: %s", profile_path.c_str(), entry_path.c_str())); 153 continue; 154 } 155 NET_LOG_DEBUG("Delete Profile Entry", base::StringPrintf( 156 "%s: %s", profile_path.c_str(), entry_path.c_str())); 157 profile_delete_entries_[profile_path] = entry_path; 158 DBusThreadManager::Get()->GetShillProfileClient()->DeleteEntry( 159 dbus::ObjectPath(profile_path), 160 entry_path, 161 base::Bind(&ProfileEntryDeleter::ProfileEntryDeletedCallback, 162 AsWeakPtr(), profile_path, entry_path), 163 base::Bind(&ProfileEntryDeleter::ShillErrorCallback, 164 AsWeakPtr(), profile_path, entry_path)); 165 } 166 } 167 168 void ProfileEntryDeletedCallback(const std::string& profile_path, 169 const std::string& entry) { 170 NET_LOG_DEBUG("Profile Entry Deleted", base::StringPrintf( 171 "%s: %s", profile_path.c_str(), entry.c_str())); 172 profile_delete_entries_.erase(profile_path); 173 if (!profile_delete_entries_.empty()) 174 return; 175 // Run the callback if this is the last pending deletion. 176 if (!callback_.is_null()) 177 callback_.Run(); 178 owner_->ProfileEntryDeleterCompleted(service_path_); // Deletes this. 179 } 180 181 void ShillErrorCallback(const std::string& profile_path, 182 const std::string& entry, 183 const std::string& dbus_error_name, 184 const std::string& dbus_error_message) { 185 // Any Shill Error triggers a failure / error. 186 network_handler::ShillErrorCallbackFunction( 187 "GetLoadableProfileEntries Failed", profile_path, error_callback_, 188 dbus_error_name, dbus_error_message); 189 // Delete this even if there are pending deletions; any callbacks will 190 // safely become no-ops (by invalidating the WeakPtrs). 191 owner_->ProfileEntryDeleterCompleted(service_path_); // Deletes this. 192 } 193 194 NetworkConfigurationHandler* owner_; // Unowned 195 std::string service_path_; 196 base::Closure callback_; 197 network_handler::ErrorCallback error_callback_; 198 199 // Map of pending profile entry deletions, indexed by profile path. 200 std::map<std::string, std::string> profile_delete_entries_; 201 202 DISALLOW_COPY_AND_ASSIGN(ProfileEntryDeleter); 203 }; 204 205 // NetworkConfigurationHandler 206 207 void NetworkConfigurationHandler::GetProperties( 208 const std::string& service_path, 209 const network_handler::DictionaryResultCallback& callback, 210 const network_handler::ErrorCallback& error_callback) const { 211 NET_LOG_USER("GetProperties", service_path); 212 DBusThreadManager::Get()->GetShillServiceClient()->GetProperties( 213 dbus::ObjectPath(service_path), 214 base::Bind(&GetPropertiesCallback, 215 callback, error_callback, service_path)); 216 } 217 218 void NetworkConfigurationHandler::SetProperties( 219 const std::string& service_path, 220 const base::DictionaryValue& properties, 221 const base::Closure& callback, 222 const network_handler::ErrorCallback& error_callback) { 223 if (properties.empty()) { 224 if (!callback.is_null()) 225 callback.Run(); 226 return; 227 } 228 NET_LOG_USER("SetProperties", service_path); 229 LogConfigProperties("SetProperty", service_path, properties); 230 231 DBusThreadManager::Get()->GetShillServiceClient()->SetProperties( 232 dbus::ObjectPath(service_path), 233 properties, 234 base::Bind(&NetworkConfigurationHandler::SetPropertiesSuccessCallback, 235 AsWeakPtr(), service_path, callback), 236 base::Bind(&NetworkConfigurationHandler::SetPropertiesErrorCallback, 237 AsWeakPtr(), service_path, error_callback)); 238 } 239 240 void NetworkConfigurationHandler::ClearProperties( 241 const std::string& service_path, 242 const std::vector<std::string>& names, 243 const base::Closure& callback, 244 const network_handler::ErrorCallback& error_callback) { 245 if (names.empty()) { 246 if (!callback.is_null()) 247 callback.Run(); 248 return; 249 } 250 NET_LOG_USER("ClearProperties", service_path); 251 for (std::vector<std::string>::const_iterator iter = names.begin(); 252 iter != names.end(); ++iter) { 253 NET_LOG_DEBUG("ClearProperty", service_path + "." + *iter); 254 } 255 DBusThreadManager::Get()->GetShillServiceClient()->ClearProperties( 256 dbus::ObjectPath(service_path), 257 names, 258 base::Bind(&NetworkConfigurationHandler::ClearPropertiesSuccessCallback, 259 AsWeakPtr(), service_path, names, callback), 260 base::Bind(&NetworkConfigurationHandler::ClearPropertiesErrorCallback, 261 AsWeakPtr(), service_path, error_callback)); 262 } 263 264 void NetworkConfigurationHandler::CreateConfiguration( 265 const base::DictionaryValue& properties, 266 const network_handler::StringResultCallback& callback, 267 const network_handler::ErrorCallback& error_callback) { 268 ShillManagerClient* manager = 269 DBusThreadManager::Get()->GetShillManagerClient(); 270 std::string type; 271 properties.GetStringWithoutPathExpansion(shill::kTypeProperty, &type); 272 DCHECK(!type.empty()); 273 if (NetworkTypePattern::Ethernet().MatchesType(type)) { 274 InvokeErrorCallback( 275 shill_property_util::GetNetworkIdFromProperties(properties), 276 error_callback, 277 "ConfigureServiceForProfile: Invalid type: " + type); 278 return; 279 } 280 281 NET_LOG_USER("CreateConfiguration: " + type, 282 shill_property_util::GetNetworkIdFromProperties(properties)); 283 LogConfigProperties("Configure", type, properties); 284 285 std::string profile; 286 properties.GetStringWithoutPathExpansion(shill::kProfileProperty, 287 &profile); 288 DCHECK(!profile.empty()); 289 manager->ConfigureServiceForProfile( 290 dbus::ObjectPath(profile), 291 properties, 292 base::Bind(&NetworkConfigurationHandler::RunCreateNetworkCallback, 293 AsWeakPtr(), 294 callback), 295 base::Bind(&network_handler::ShillErrorCallbackFunction, 296 "Config.CreateConfiguration Failed", 297 "", 298 error_callback)); 299 } 300 301 void NetworkConfigurationHandler::RemoveConfiguration( 302 const std::string& service_path, 303 const base::Closure& callback, 304 const network_handler::ErrorCallback& error_callback) { 305 // Service.Remove is not reliable. Instead, request the profile entries 306 // for the service and remove each entry. 307 if (ContainsKey(profile_entry_deleters_, service_path)) { 308 InvokeErrorCallback( 309 service_path, error_callback, "RemoveConfigurationInProgress"); 310 return; 311 } 312 313 NET_LOG_USER("Remove Configuration", service_path); 314 ProfileEntryDeleter* deleter = 315 new ProfileEntryDeleter(this, service_path, callback, error_callback); 316 profile_entry_deleters_[service_path] = deleter; 317 deleter->Run(); 318 } 319 320 void NetworkConfigurationHandler::SetNetworkProfile( 321 const std::string& service_path, 322 const std::string& profile_path, 323 const base::Closure& callback, 324 const network_handler::ErrorCallback& error_callback) { 325 NET_LOG_USER("SetNetworkProfile", service_path + ": " + profile_path); 326 base::StringValue profile_path_value(profile_path); 327 DBusThreadManager::Get()->GetShillServiceClient()->SetProperty( 328 dbus::ObjectPath(service_path), 329 shill::kProfileProperty, 330 profile_path_value, 331 callback, 332 base::Bind(&SetNetworkProfileErrorCallback, 333 service_path, profile_path, error_callback)); 334 } 335 336 // NetworkConfigurationHandler Private methods 337 338 NetworkConfigurationHandler::NetworkConfigurationHandler() 339 : network_state_handler_(NULL) { 340 } 341 342 NetworkConfigurationHandler::~NetworkConfigurationHandler() { 343 STLDeleteContainerPairSecondPointers( 344 profile_entry_deleters_.begin(), profile_entry_deleters_.end()); 345 } 346 347 void NetworkConfigurationHandler::Init( 348 NetworkStateHandler* network_state_handler) { 349 network_state_handler_ = network_state_handler; 350 } 351 352 void NetworkConfigurationHandler::RunCreateNetworkCallback( 353 const network_handler::StringResultCallback& callback, 354 const dbus::ObjectPath& service_path) { 355 if (!callback.is_null()) 356 callback.Run(service_path.value()); 357 // This may also get called when CreateConfiguration is used to update an 358 // existing configuration, so request a service update just in case. 359 // TODO(pneubeck): Separate 'Create' and 'Update' calls and only trigger 360 // this on an update. 361 network_state_handler_->RequestUpdateForNetwork(service_path.value()); 362 } 363 364 void NetworkConfigurationHandler::ProfileEntryDeleterCompleted( 365 const std::string& service_path) { 366 std::map<std::string, ProfileEntryDeleter*>::iterator iter = 367 profile_entry_deleters_.find(service_path); 368 DCHECK(iter != profile_entry_deleters_.end()); 369 delete iter->second; 370 profile_entry_deleters_.erase(iter); 371 } 372 373 void NetworkConfigurationHandler::SetPropertiesSuccessCallback( 374 const std::string& service_path, 375 const base::Closure& callback) { 376 if (!callback.is_null()) 377 callback.Run(); 378 network_state_handler_->RequestUpdateForNetwork(service_path); 379 } 380 381 void NetworkConfigurationHandler::SetPropertiesErrorCallback( 382 const std::string& service_path, 383 const network_handler::ErrorCallback& error_callback, 384 const std::string& dbus_error_name, 385 const std::string& dbus_error_message) { 386 network_handler::ShillErrorCallbackFunction( 387 "Config.SetProperties Failed", 388 service_path, error_callback, 389 dbus_error_name, dbus_error_message); 390 // Some properties may have changed so request an update regardless. 391 network_state_handler_->RequestUpdateForNetwork(service_path); 392 } 393 394 void NetworkConfigurationHandler::ClearPropertiesSuccessCallback( 395 const std::string& service_path, 396 const std::vector<std::string>& names, 397 const base::Closure& callback, 398 const base::ListValue& result) { 399 const std::string kClearPropertiesFailedError("Error.ClearPropertiesFailed"); 400 DCHECK(names.size() == result.GetSize()) 401 << "Incorrect result size from ClearProperties."; 402 403 for (size_t i = 0; i < result.GetSize(); ++i) { 404 bool success = false; 405 result.GetBoolean(i, &success); 406 if (!success) { 407 // If a property was cleared that has never been set, the clear will fail. 408 // We do not track which properties have been set, so just log the error. 409 NET_LOG_ERROR("ClearProperties Failed: " + names[i], service_path); 410 } 411 } 412 413 if (!callback.is_null()) 414 callback.Run(); 415 network_state_handler_->RequestUpdateForNetwork(service_path); 416 } 417 418 void NetworkConfigurationHandler::ClearPropertiesErrorCallback( 419 const std::string& service_path, 420 const network_handler::ErrorCallback& error_callback, 421 const std::string& dbus_error_name, 422 const std::string& dbus_error_message) { 423 network_handler::ShillErrorCallbackFunction( 424 "Config.ClearProperties Failed", 425 service_path, error_callback, 426 dbus_error_name, dbus_error_message); 427 // Some properties may have changed so request an update regardless. 428 network_state_handler_->RequestUpdateForNetwork(service_path); 429 } 430 431 // static 432 NetworkConfigurationHandler* NetworkConfigurationHandler::InitializeForTest( 433 NetworkStateHandler* network_state_handler) { 434 NetworkConfigurationHandler* handler = new NetworkConfigurationHandler(); 435 handler->Init(network_state_handler); 436 return handler; 437 } 438 439 } // namespace chromeos 440
