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