| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/extensions/api/networking_private/networking_private_api.h" |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/callback.h" |
| #include "base/command_line.h" |
| #include "base/json/json_reader.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/extensions/event_router.h" |
| #include "chrome/browser/extensions/extension_function_registry.h" |
| #include "chrome/browser/extensions/extension_system.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "chrome/common/extensions/api/networking_private.h" |
| |
| using extensions::EventRouter; |
| using extensions::ExtensionSystem; |
| namespace api = extensions::api::networking_private; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetPropertiesFunction |
| |
| |
| const char kNetworkingPrivateProperties[] = "NetworkingPrivateProperties"; |
| |
| struct NetworkingPrivatePropertiesData : base::SupportsUserData::Data { |
| explicit NetworkingPrivatePropertiesData(const base::DictionaryValue* prop) : |
| properties_(prop->DeepCopy()) { } |
| scoped_ptr<base::DictionaryValue> properties_; |
| }; |
| |
| NetworkingPrivateGetPropertiesFunction:: |
| ~NetworkingPrivateGetPropertiesFunction() { |
| } |
| |
| bool NetworkingPrivateGetPropertiesFunction::RunImpl() { |
| scoped_ptr<api::GetProperties::Params> params = |
| api::GetProperties::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| // If there are properties set by SetProperties function, use those. |
| NetworkingPrivatePropertiesData* stored_properties = |
| static_cast<NetworkingPrivatePropertiesData*>( |
| GetProfile()->GetUserData(kNetworkingPrivateProperties)); |
| if (stored_properties != NULL) { |
| SetResult(stored_properties->properties_.release()); |
| SendResponse(true); |
| return true; |
| } |
| |
| const std::string network_properties = |
| "{\"ConnectionState\":\"NotConnected\"," |
| "\"GUID\":\"stub_wifi2\"," |
| "\"Name\":\"wifi2_PSK\"," |
| "\"Type\":\"WiFi\"," |
| "\"WiFi\":{" |
| "\"Frequency\":5000," |
| "\"FrequencyList\":[2400,5000]," |
| "\"SSID\":\"wifi2_PSK\"," |
| "\"Security\":\"WPA-PSK\"," |
| "\"SignalStrength\":80}}"; |
| |
| if (params->network_guid == "nonexistent_path") { |
| error_ = "Error.DBusFailed"; |
| SendResponse(false); |
| } else { |
| SetResult(base::JSONReader::Read(network_properties)); |
| SendResponse(true); |
| } |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetManagedPropertiesFunction |
| |
| NetworkingPrivateGetManagedPropertiesFunction:: |
| ~NetworkingPrivateGetManagedPropertiesFunction() { |
| } |
| |
| bool NetworkingPrivateGetManagedPropertiesFunction::RunImpl() { |
| scoped_ptr<api::GetManagedProperties::Params> params = |
| api::GetManagedProperties::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| const std::string network_properties = |
| "{" |
| " \"ConnectionState\": {" |
| " \"Active\": \"NotConnected\"," |
| " \"Effective\": \"Unmanaged\"" |
| " }," |
| " \"GUID\": \"stub_wifi2\"," |
| " \"Name\": {" |
| " \"Active\": \"wifi2_PSK\"," |
| " \"Effective\": \"UserPolicy\"," |
| " \"UserPolicy\": \"My WiFi Network\"" |
| " }," |
| " \"Type\": {" |
| " \"Active\": \"WiFi\"," |
| " \"Effective\": \"UserPolicy\"," |
| " \"UserPolicy\": \"WiFi\"" |
| " }," |
| " \"WiFi\": {" |
| " \"AutoConnect\": {" |
| " \"Active\": false," |
| " \"UserEditable\": true" |
| " }," |
| " \"Frequency\" : {" |
| " \"Active\": 5000," |
| " \"Effective\": \"Unmanaged\"" |
| " }," |
| " \"FrequencyList\" : {" |
| " \"Active\": [2400, 5000]," |
| " \"Effective\": \"Unmanaged\"" |
| " }," |
| " \"Passphrase\": {" |
| " \"Effective\": \"UserSetting\"," |
| " \"UserEditable\": true," |
| " \"UserSetting\": \"FAKE_CREDENTIAL_VPaJDV9x\"" |
| " }," |
| " \"SSID\": {" |
| " \"Active\": \"wifi2_PSK\"," |
| " \"Effective\": \"UserPolicy\"," |
| " \"UserPolicy\": \"wifi2_PSK\"" |
| " }," |
| " \"Security\": {" |
| " \"Active\": \"WPA-PSK\"," |
| " \"Effective\": \"UserPolicy\"," |
| " \"UserPolicy\": \"WPA-PSK\"" |
| " }," |
| " \"SignalStrength\": {" |
| " \"Active\": 80," |
| " \"Effective\": \"Unmanaged\"" |
| " }" |
| " }" |
| "}"; |
| |
| SetResult(base::JSONReader::Read(network_properties)); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetStateFunction |
| |
| NetworkingPrivateGetStateFunction:: |
| ~NetworkingPrivateGetStateFunction() { |
| } |
| |
| bool NetworkingPrivateGetStateFunction::RunImpl() { |
| scoped_ptr<api::GetState::Params> params = |
| api::GetState::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| const std::string network_state = |
| "{" |
| " \"ConnectionState\": \"NotConnected\"," |
| " \"GUID\": \"stub_wifi2\"," |
| " \"Name\": \"wifi2_PSK\"," |
| " \"Type\": \"WiFi\"," |
| " \"WiFi\": {" |
| " \"Security\": \"WPA-PSK\"," |
| " \"SignalStrength\": 80" |
| " }" |
| "}"; |
| SetResult(base::JSONReader::Read(network_state)); |
| SendResponse(true); |
| return true; |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateSetPropertiesFunction |
| |
| NetworkingPrivateSetPropertiesFunction:: |
| ~NetworkingPrivateSetPropertiesFunction() { |
| } |
| |
| bool NetworkingPrivateSetPropertiesFunction::RunImpl() { |
| scoped_ptr<api::SetProperties::Params> params = |
| api::SetProperties::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| scoped_ptr<base::DictionaryValue> properties_dict( |
| params->properties.ToValue()); |
| |
| // Store properties_dict in profile to return from GetProperties. |
| GetProfile()->SetUserData( |
| kNetworkingPrivateProperties, |
| new NetworkingPrivatePropertiesData(properties_dict.get())); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateCreateNetworkFunction |
| |
| NetworkingPrivateCreateNetworkFunction:: |
| ~NetworkingPrivateCreateNetworkFunction() { |
| } |
| |
| bool NetworkingPrivateCreateNetworkFunction::RunImpl() { |
| scoped_ptr<api::CreateNetwork::Params> params = |
| api::CreateNetwork::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| |
| // Store properties_dict in profile to return from GetProperties. |
| scoped_ptr<base::DictionaryValue> properties_dict( |
| params->properties.ToValue()); |
| properties_dict->SetString("GUID", "fake_guid"); |
| GetProfile()->SetUserData( |
| kNetworkingPrivateProperties, |
| new NetworkingPrivatePropertiesData(properties_dict.get())); |
| |
| results_ = api::CreateNetwork::Results::Create("fake_guid"); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetVisibleNetworksFunction |
| |
| NetworkingPrivateGetVisibleNetworksFunction:: |
| ~NetworkingPrivateGetVisibleNetworksFunction() { |
| } |
| |
| bool NetworkingPrivateGetVisibleNetworksFunction::RunImpl() { |
| scoped_ptr<api::GetVisibleNetworks::Params> params = |
| api::GetVisibleNetworks::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| const std::string networks_json = |
| "[{" |
| " \"ConnectionState\": \"Connected\"," |
| " \"GUID\": \"stub_ethernet\"," |
| " \"Name\": \"eth0\"," |
| " \"Type\": \"Ethernet\"," |
| " \"Ethernet\": {" |
| " \"Authentication\": \"None\"" |
| " }" |
| " }," |
| " {" |
| " \"ConnectionState\": \"Connected\"," |
| " \"GUID\": \"stub_wifi1\"," |
| " \"Name\": \"wifi1\"," |
| " \"Type\": \"WiFi\"," |
| " \"WiFi\": {" |
| " \"Security\": \"WEP-PSK\"," |
| " \"SignalStrength\": 0" |
| " }" |
| " }," |
| " {" |
| " \"ConnectionState\": \"Connected\"," |
| " \"GUID\": \"stub_vpn1\"," |
| " \"Name\": \"vpn1\"," |
| " \"Type\": \"VPN\"" |
| " }," |
| " {" |
| " \"ConnectionState\": \"NotConnected\"," |
| " \"GUID\": \"stub_wifi2\"," |
| " \"Name\": \"wifi2_PSK\"," |
| " \"Type\": \"WiFi\"," |
| " \"WiFi\": {" |
| " \"Security\": \"WPA-PSK\"," |
| " \"SignalStrength\": 80" |
| " }" |
| " }," |
| " {" |
| " \"Cellular\": {" |
| " \"ActivateOverNonCellularNetwork\": false," |
| " \"ActivationState\": \"not-activated\"," |
| " \"NetworkTechnology\": \"GSM\"," |
| " \"RoamingState\": \"home\"" |
| " }," |
| " \"ConnectionState\": \"NotConnected\"," |
| " \"GUID\": \"stub_cellular1\"," |
| " \"Name\": \"cellular1\"," |
| " \"Type\": \"Cellular\"" |
| " }]"; |
| ListValue* visible_networks = |
| static_cast<ListValue*>(base::JSONReader::Read(networks_json)); |
| // If caller only needs WiFi networks, then remove all other networks. |
| if (params->type == api::GetVisibleNetworks::Params::TYPE_WIFI) { |
| visible_networks->Remove(4, NULL); |
| visible_networks->Remove(2, NULL); |
| visible_networks->Remove(0, NULL); |
| } |
| |
| SetResult(visible_networks); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateGetEnabledNetworkTypesFunction |
| |
| NetworkingPrivateGetEnabledNetworkTypesFunction:: |
| ~NetworkingPrivateGetEnabledNetworkTypesFunction() { |
| } |
| |
| bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunImpl() { |
| base::ListValue* network_list = new base::ListValue; |
| |
| network_list->Append(new base::StringValue("Ethernet")); |
| network_list->Append(new base::StringValue("WiFi")); |
| network_list->Append(new base::StringValue("Cellular")); |
| |
| SetResult(network_list); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateEnableNetworkTypeFunction |
| |
| NetworkingPrivateEnableNetworkTypeFunction:: |
| ~NetworkingPrivateEnableNetworkTypeFunction() { |
| } |
| |
| bool NetworkingPrivateEnableNetworkTypeFunction::RunImpl() { |
| scoped_ptr<api::EnableNetworkType::Params> params = |
| api::EnableNetworkType::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateDisableNetworkTypeFunction |
| |
| NetworkingPrivateDisableNetworkTypeFunction:: |
| ~NetworkingPrivateDisableNetworkTypeFunction() { |
| } |
| |
| bool NetworkingPrivateDisableNetworkTypeFunction::RunImpl() { |
| scoped_ptr<api::DisableNetworkType::Params> params = |
| api::DisableNetworkType::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateRequestNetworkScanFunction |
| |
| NetworkingPrivateRequestNetworkScanFunction:: |
| ~NetworkingPrivateRequestNetworkScanFunction() { |
| } |
| |
| bool NetworkingPrivateRequestNetworkScanFunction::RunImpl() { |
| // Generate onNetworkListChanged event. |
| std::vector<std::string> changes; |
| changes.push_back("stub_ethernet"); |
| changes.push_back("stub_wifi1"); |
| changes.push_back("stub_vpn1"); |
| changes.push_back("stub_wifi2"); |
| changes.push_back("stub_cellular1"); |
| |
| EventRouter* event_router = |
| ExtensionSystem::Get(GetProfile())->event_router(); |
| scoped_ptr<base::ListValue> args(api::OnNetworkListChanged::Create(changes)); |
| scoped_ptr<extensions::Event> extension_event(new extensions::Event( |
| api::OnNetworkListChanged::kEventName, args.Pass())); |
| event_router->BroadcastEvent(extension_event.Pass()); |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateStartConnectFunction |
| |
| NetworkingPrivateStartConnectFunction:: |
| ~NetworkingPrivateStartConnectFunction() { |
| } |
| |
| bool NetworkingPrivateStartConnectFunction::RunImpl() { |
| scoped_ptr<api::StartConnect::Params> params = |
| api::StartConnect::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| if (params->network_guid == "nonexistent_path") { |
| error_ = "configure-failed"; |
| SendResponse(false); |
| } else { |
| SendResponse(true); |
| // Set Properties to reflect connected state |
| const std::string network_properties = |
| "{\"ConnectionState\":\"Connected\"," |
| "\"GUID\":\"stub_wifi2\"," |
| "\"Name\":\"wifi2_PSK\"," |
| "\"Type\":\"WiFi\"," |
| "\"WiFi\":{" |
| "\"SSID\":\"stub_wifi2\"," |
| "\"Security\":\"WPA-PSK\"," |
| "\"SignalStrength\":80}}"; |
| |
| // Store network_properties in profile to return from GetProperties. |
| scoped_ptr<Value> network_properties_value( |
| base::JSONReader::Read(network_properties)); |
| GetProfile()->SetUserData( |
| kNetworkingPrivateProperties, |
| new NetworkingPrivatePropertiesData( |
| static_cast<DictionaryValue*>(network_properties_value.get()))); |
| |
| // Broadcast NetworksChanged Event that network is connected |
| EventRouter* event_router = |
| ExtensionSystem::Get(GetProfile())->event_router(); |
| scoped_ptr<base::ListValue> args(api::OnNetworksChanged::Create( |
| std::vector<std::string>(1, params->network_guid))); |
| scoped_ptr<extensions::Event> netchanged_event( |
| new extensions::Event(api::OnNetworksChanged::kEventName, args.Pass())); |
| event_router->BroadcastEvent(netchanged_event.Pass()); |
| |
| // Generate NetworkListChanged event. |
| std::vector<std::string> list; |
| list.push_back("stub_ethernet"); |
| list.push_back("stub_wifi2"); |
| list.push_back("stub_vpn1"); |
| list.push_back("stub_wifi1"); |
| list.push_back("stub_cellular1"); |
| |
| scoped_ptr<base::ListValue> arg2(api::OnNetworkListChanged::Create(list)); |
| scoped_ptr<extensions::Event> netlist_event(new extensions::Event( |
| api::OnNetworkListChanged::kEventName, arg2.Pass())); |
| event_router->BroadcastEvent(netlist_event.Pass()); |
| } |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateStartDisconnectFunction |
| |
| NetworkingPrivateStartDisconnectFunction:: |
| ~NetworkingPrivateStartDisconnectFunction() { |
| } |
| |
| bool NetworkingPrivateStartDisconnectFunction::RunImpl() { |
| scoped_ptr<api::StartDisconnect::Params> params = |
| api::StartDisconnect::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| if (params->network_guid == "nonexistent_path") { |
| error_ = "not-found"; |
| SendResponse(false); |
| } else { |
| SendResponse(true); |
| |
| // Send Event that network is disconnected. Listener will use GetProperties. |
| EventRouter* event_router = |
| ExtensionSystem::Get(GetProfile())->event_router(); |
| scoped_ptr<base::ListValue> args(api::OnNetworksChanged::Create( |
| std::vector<std::string>(1, params->network_guid))); |
| scoped_ptr<extensions::Event> extension_event( |
| new extensions::Event(api::OnNetworksChanged::kEventName, args.Pass())); |
| event_router->BroadcastEvent(extension_event.Pass()); |
| } |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateVerifyDestinationFunction |
| |
| NetworkingPrivateVerifyDestinationFunction:: |
| ~NetworkingPrivateVerifyDestinationFunction() { |
| } |
| |
| bool NetworkingPrivateVerifyDestinationFunction::RunImpl() { |
| scoped_ptr<api::VerifyDestination::Params> params = |
| api::VerifyDestination::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| SetResult(new base::FundamentalValue(true)); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateVerifyAndEncryptCredentialsFunction |
| |
| NetworkingPrivateVerifyAndEncryptCredentialsFunction:: |
| ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() { |
| } |
| |
| bool NetworkingPrivateVerifyAndEncryptCredentialsFunction::RunImpl() { |
| scoped_ptr<api::VerifyAndEncryptCredentials::Params> params = |
| api::VerifyAndEncryptCredentials::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| SetResult(new base::StringValue("encrypted_credentials")); |
| SendResponse(true); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // NetworkingPrivateVerifyAndEncryptDataFunction |
| |
| NetworkingPrivateVerifyAndEncryptDataFunction:: |
| ~NetworkingPrivateVerifyAndEncryptDataFunction() { |
| } |
| |
| bool NetworkingPrivateVerifyAndEncryptDataFunction::RunImpl() { |
| scoped_ptr<api::VerifyAndEncryptData::Params> params = |
| api::VerifyAndEncryptData::Params::Create(*args_); |
| EXTENSION_FUNCTION_VALIDATE(params); |
| SetResult(new base::StringValue("encrypted_data")); |
| SendResponse(true); |
| return true; |
| } |