Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(569)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/extensions/api/networking_private/networking_private_linux.cc

Issue 870163002: Move networking_private to src/extensions (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix GN 2 Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/extensions/api/networking_private/networking_private_linux.h ('k') | chrome/browser/extensions/api/networking_private/networking_private_service_client.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/extensions/api/networking_private/networking_private_linux.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_linux.cc b/chrome/browser/extensions/api/networking_private/networking_private_linux.cc
deleted file mode 100644
index 120e4005ec7da1df2bfe1e93bdac71572d05ff58..0000000000000000000000000000000000000000
--- a/chrome/browser/extensions/api/networking_private/networking_private_linux.cc
+++ /dev/null
@@ -1,1168 +0,0 @@
-// Copyright 2014 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_linux.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/callback.h"
-#include "base/message_loop/message_loop.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_split.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/extensions/api/networking_private/network_config_dbus_constants_linux.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_api.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_delegate_observer.h"
-#include "components/onc/onc_constants.h"
-#include "content/public/browser/browser_context.h"
-#include "content/public/browser/browser_thread.h"
-#include "dbus/bus.h"
-#include "dbus/message.h"
-#include "dbus/object_path.h"
-#include "dbus/object_proxy.h"
-
-////////////////////////////////////////////////////////////////////////////////
-
-namespace extensions {
-
-namespace {
-// Access Point info strings.
-const char kAccessPointInfoName[] = "Name";
-const char kAccessPointInfoGuid[] = "GUID";
-const char kAccessPointInfoConnectable[] = "Connectable";
-const char kAccessPointInfoConnectionState[] = "ConnectionState";
-const char kAccessPointInfoType[] = "Type";
-const char kAccessPointInfoTypeWifi[] = "WiFi";
-const char kAccessPointInfoWifiSignalStrengthDotted[] = "WiFi.SignalStrength";
-const char kAccessPointInfoWifiSecurityDotted[] = "WiFi.Security";
-
-// Access point security type strings.
-const char kAccessPointSecurityNone[] = "None";
-const char kAccessPointSecurityUnknown[] = "Unknown";
-const char kAccessPointSecurityWpaPsk[] = "WPA-PSK";
-const char kAccessPointSecurity9021X[] = "WEP-8021X";
-
-// Parses the GUID which contains 3 pieces of relevant information. The
-// object path to the network device, the object path of the access point,
-// and the ssid.
-bool ParseNetworkGuid(const std::string& guid,
- std::string* device_path,
- std::string* access_point_path,
- std::string* ssid) {
- std::vector<std::string> guid_parts;
-
- base::SplitString(guid, '|', &guid_parts);
-
- if (guid_parts.size() != 3) {
- return false;
- }
-
- *device_path = guid_parts[0];
- *access_point_path = guid_parts[1];
- *ssid = guid_parts[2];
-
- if (device_path->empty() || access_point_path->empty() || ssid->empty()) {
- return false;
- }
-
- return true;
-}
-
-// Simplified helper to parse the SSID from the GUID.
-bool GuidToSsid(const std::string& guid, std::string* ssid) {
- std::string unused_1;
- std::string unused_2;
- return ParseNetworkGuid(guid, &unused_1, &unused_2, ssid);
-}
-
-// Iterates over the map cloning the contained networks to a
-// list then returns the list.
-scoped_ptr<base::ListValue> CopyNetworkMapToList(
- const NetworkingPrivateLinux::NetworkMap& network_map) {
- scoped_ptr<base::ListValue> network_list(new base::ListValue);
-
- for (const auto& network : network_map) {
- network_list->Append(network.second->DeepCopy());
- }
-
- return network_list.Pass();
-}
-
-// Constructs a network guid from its constituent parts.
-std::string ConstructNetworkGuid(const dbus::ObjectPath& device_path,
- const dbus::ObjectPath& access_point_path,
- const std::string& ssid) {
- return device_path.value() + "|" + access_point_path.value() + "|" + ssid;
-}
-
-// Logs that the method is not implemented and reports |kErrorNotSupported|
-// to the failure callback.
-void ReportNotSupported(
- const std::string& method_name,
- const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
- LOG(WARNING) << method_name << " is not supported";
- failure_callback.Run(extensions::networking_private::kErrorNotSupported);
-}
-
-// Fires the appropriate callback when the network connect operation succeeds
-// or fails.
-void OnNetworkConnectOperationCompleted(
- scoped_ptr<std::string> error,
- const NetworkingPrivateDelegate::VoidCallback& success_callback,
- const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
- if (!error->empty()) {
- failure_callback.Run(*error);
- return;
- }
- success_callback.Run();
-}
-
-// Fires the appropriate callback when the network properties are returned
-// from the |dbus_thread_|.
-void GetCachedNetworkPropertiesCallback(
- scoped_ptr<std::string> error,
- scoped_ptr<base::DictionaryValue> properties,
- const NetworkingPrivateDelegate::DictionaryCallback& success_callback,
- const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
- if (!error->empty()) {
- failure_callback.Run(*error);
- return;
- }
- success_callback.Run(properties.Pass());
-}
-
-} // namespace
-
-NetworkingPrivateLinux::NetworkingPrivateLinux(
- content::BrowserContext* browser_context,
- scoped_ptr<VerifyDelegate> verify_delegate)
- : NetworkingPrivateDelegate(verify_delegate.Pass()),
- browser_context_(browser_context),
- dbus_thread_("Networking Private DBus"),
- network_manager_proxy_(NULL) {
- base::Thread::Options thread_options(base::MessageLoop::Type::TYPE_IO, 0);
-
- dbus_thread_.StartWithOptions(thread_options);
- dbus_thread_.task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&NetworkingPrivateLinux::Initialize, base::Unretained(this)));
-}
-
-NetworkingPrivateLinux::~NetworkingPrivateLinux() {
- dbus_thread_.Stop();
-}
-
-void NetworkingPrivateLinux::AssertOnDBusThread() {
- DCHECK(dbus_task_runner_->RunsTasksOnCurrentThread());
-}
-
-void NetworkingPrivateLinux::Initialize() {
- dbus_task_runner_ = dbus_thread_.task_runner();
- // This has to be called after the task runner is initialized.
- AssertOnDBusThread();
-
- dbus::Bus::Options dbus_options;
- dbus_options.bus_type = dbus::Bus::SYSTEM;
- dbus_options.connection_type = dbus::Bus::PRIVATE;
- dbus_options.dbus_task_runner = dbus_task_runner_;
-
- dbus_ = new dbus::Bus(dbus_options);
- network_manager_proxy_ = dbus_->GetObjectProxy(
- networking_private::kNetworkManagerNamespace,
- dbus::ObjectPath(networking_private::kNetworkManagerPath));
-
- if (!network_manager_proxy_) {
- LOG(ERROR) << "Platform does not support NetworkManager over DBUS";
- }
-
- network_map_.reset(new NetworkMap());
-}
-
-bool NetworkingPrivateLinux::CheckNetworkManagerSupported(
- const FailureCallback& failure_callback) {
- if (!network_manager_proxy_) {
- ReportNotSupported("NetworkManager over DBus", failure_callback);
- return false;
- }
-
- return true;
-}
-
-void NetworkingPrivateLinux::GetProperties(
- const std::string& guid,
- const DictionaryCallback& success_callback,
- const FailureCallback& failure_callback) {
- GetState(guid, success_callback, failure_callback);
-}
-
-void NetworkingPrivateLinux::GetManagedProperties(
- const std::string& guid,
- const DictionaryCallback& success_callback,
- const FailureCallback& failure_callback) {
- ReportNotSupported("GetManagedProperties", failure_callback);
-}
-
-void NetworkingPrivateLinux::GetState(
- const std::string& guid,
- const DictionaryCallback& success_callback,
- const FailureCallback& failure_callback) {
- if (!CheckNetworkManagerSupported(failure_callback))
- return;
-
- scoped_ptr<std::string> error(new std::string);
- scoped_ptr<base::DictionaryValue> network_properties(
- new base::DictionaryValue);
-
- // Runs GetCachedNetworkProperties on |dbus_thread|.
- dbus_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE, base::Bind(&NetworkingPrivateLinux::GetCachedNetworkProperties,
- base::Unretained(this), guid,
- base::Unretained(network_properties.get()),
- base::Unretained(error.get())),
- base::Bind(&GetCachedNetworkPropertiesCallback, base::Passed(&error),
- base::Passed(&network_properties), success_callback,
- failure_callback));
-}
-
-void NetworkingPrivateLinux::GetCachedNetworkProperties(
- const std::string& guid,
- base::DictionaryValue* properties,
- std::string* error) {
- AssertOnDBusThread();
- std::string ssid;
-
- if (!GuidToSsid(guid, &ssid)) {
- *error = "Invalid Network GUID format";
- return;
- }
-
- NetworkMap::const_iterator network_iter =
- network_map_->find(base::UTF8ToUTF16(ssid));
- if (network_iter == network_map_->end()) {
- *error = "Unknown network GUID";
- return;
- }
-
- // Make a copy of the properties out of the cached map.
- scoped_ptr<base::DictionaryValue> temp_properties(
- network_iter->second->DeepCopy());
-
- // Swap the new copy into the dictionary that is shared with the reply.
- properties->Swap(temp_properties.get());
-}
-
-void NetworkingPrivateLinux::SetProperties(
- const std::string& guid,
- scoped_ptr<base::DictionaryValue> properties,
- const VoidCallback& success_callback,
- const FailureCallback& failure_callback) {
- ReportNotSupported("SetProperties", failure_callback);
-}
-
-void NetworkingPrivateLinux::CreateNetwork(
- bool shared,
- scoped_ptr<base::DictionaryValue> properties,
- const StringCallback& success_callback,
- const FailureCallback& failure_callback) {
- ReportNotSupported("CreateNetwork", failure_callback);
-}
-
-void NetworkingPrivateLinux::GetNetworks(
- const std::string& network_type,
- bool configured_only,
- bool visible_only,
- int limit,
- const NetworkListCallback& success_callback,
- const FailureCallback& failure_callback) {
- if (!CheckNetworkManagerSupported(failure_callback)) {
- return;
- }
-
- scoped_ptr<NetworkMap> network_map(new NetworkMap);
-
- if (!(network_type == ::onc::network_type::kWiFi ||
- network_type == ::onc::network_type::kWireless ||
- network_type == ::onc::network_type::kAllTypes)) {
- // Only enumerating WiFi networks is supported on linux.
- ReportNotSupported("GetNetworks with network_type=" + network_type,
- failure_callback);
- return;
- }
-
- // Runs GetAllWiFiAccessPoints on the dbus_thread and returns the
- // results back to OnAccessPointsFound where the callback is fired.
- dbus_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE,
- base::Bind(&NetworkingPrivateLinux::GetAllWiFiAccessPoints,
- base::Unretained(this), configured_only, visible_only, limit,
- base::Unretained(network_map.get())),
- base::Bind(&NetworkingPrivateLinux::OnAccessPointsFound,
- base::Unretained(this), base::Passed(&network_map),
- success_callback, failure_callback));
-}
-
-bool NetworkingPrivateLinux::GetNetworksForScanRequest() {
- if (!network_manager_proxy_) {
- return false;
- }
-
- scoped_ptr<NetworkMap> network_map(new NetworkMap);
-
- // Runs GetAllWiFiAccessPoints on the dbus_thread and returns the
- // results back to SendNetworkListChangedEvent to fire the event. No
- // callbacks are used in this case.
- dbus_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE, base::Bind(&NetworkingPrivateLinux::GetAllWiFiAccessPoints,
- base::Unretained(this), false /* configured_only */,
- false /* visible_only */, 0 /* limit */,
- base::Unretained(network_map.get())),
- base::Bind(&NetworkingPrivateLinux::OnAccessPointsFoundViaScan,
- base::Unretained(this), base::Passed(&network_map)));
-
- return true;
-}
-
-// Constructs the network configuration message and connects to the network.
-// The message is of the form:
-// {
-// '802-11-wireless': {
-// 'ssid': 'FooNetwork'
-// }
-// }
-void NetworkingPrivateLinux::ConnectToNetwork(const std::string& guid,
- std::string* error) {
- AssertOnDBusThread();
- std::string device_path_str;
- std::string access_point_path_str;
- std::string ssid;
- DVLOG(1) << "Connecting to network GUID " << guid;
-
- if (!ParseNetworkGuid(guid, &device_path_str, &access_point_path_str,
- &ssid)) {
- *error = "Invalid Network GUID format";
- return;
- }
-
- // Set the connection state to connecting in the map.
- if (!SetConnectionStateAndPostEvent(guid, ssid,
- ::onc::connection_state::kConnecting)) {
- *error = "Unknown network GUID";
- return;
- }
-
- dbus::ObjectPath device_path(device_path_str);
- dbus::ObjectPath access_point_path(access_point_path_str);
-
- dbus::MethodCall method_call(
- networking_private::kNetworkManagerNamespace,
- networking_private::kNetworkManagerAddAndActivateConnectionMethod);
- dbus::MessageWriter builder(&method_call);
-
- // Build up the settings nested dictionary.
- dbus::MessageWriter array_writer(&method_call);
- builder.OpenArray("{sa{sv}}", &array_writer);
-
- dbus::MessageWriter dict_writer(&method_call);
- array_writer.OpenDictEntry(&dict_writer);
- // TODO(zentaro): Support other network types. Currently only WiFi is
- // supported.
- dict_writer.AppendString(
- networking_private::kNetworkManagerConnectionConfig80211Wireless);
-
- dbus::MessageWriter wifi_array(&method_call);
- dict_writer.OpenArray("{sv}", &wifi_array);
-
- dbus::MessageWriter wifi_dict_writer(&method_call);
- wifi_array.OpenDictEntry(&wifi_dict_writer);
- wifi_dict_writer.AppendString(
- networking_private::kNetworkManagerConnectionConfigSsid);
-
- dbus::MessageWriter variant_writer(&method_call);
- wifi_dict_writer.OpenVariant("ay", &variant_writer);
- variant_writer.AppendArrayOfBytes(
- reinterpret_cast<const uint8*>(ssid.c_str()), ssid.size());
-
- // Close all the arrays and dicts.
- wifi_dict_writer.CloseContainer(&variant_writer);
- wifi_array.CloseContainer(&wifi_dict_writer);
- dict_writer.CloseContainer(&wifi_array);
- array_writer.CloseContainer(&dict_writer);
- builder.CloseContainer(&array_writer);
-
- builder.AppendObjectPath(device_path);
- builder.AppendObjectPath(access_point_path);
-
- scoped_ptr<dbus::Response> response(
- network_manager_proxy_->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
- if (!response) {
- LOG(ERROR) << "Failed to add a new connection";
- *error = "Failed to connect.";
-
- // Set the connection state to NotConnected in the map.
- SetConnectionStateAndPostEvent(guid, ssid,
- ::onc::connection_state::kNotConnected);
- return;
- }
-
- dbus::MessageReader reader(response.get());
- dbus::ObjectPath connection_settings_path;
- dbus::ObjectPath active_connection_path;
-
- if (!reader.PopObjectPath(&connection_settings_path)) {
- LOG(ERROR) << "Unexpected response for add connection path "
- << ": " << response->ToString();
- *error = "Failed to connect.";
-
- // Set the connection state to NotConnected in the map.
- SetConnectionStateAndPostEvent(guid, ssid,
- ::onc::connection_state::kNotConnected);
- return;
- }
-
- if (!reader.PopObjectPath(&active_connection_path)) {
- LOG(ERROR) << "Unexpected response for connection path "
- << ": " << response->ToString();
- *error = "Failed to connect.";
-
- // Set the connection state to NotConnected in the map.
- SetConnectionStateAndPostEvent(guid, ssid,
- ::onc::connection_state::kNotConnected);
- return;
- }
-
- // Set the connection state to Connected in the map.
- SetConnectionStateAndPostEvent(guid, ssid,
- ::onc::connection_state::kConnected);
- return;
-}
-
-void NetworkingPrivateLinux::DisconnectFromNetwork(const std::string& guid,
- std::string* error) {
- AssertOnDBusThread();
- std::string device_path_str;
- std::string access_point_path_str;
- std::string ssid;
- DVLOG(1) << "Disconnecting from network GUID " << guid;
-
- if (!ParseNetworkGuid(guid, &device_path_str, &access_point_path_str,
- &ssid)) {
- *error = "Invalid Network GUID format";
- return;
- }
-
- scoped_ptr<NetworkMap> network_map(new NetworkMap);
- GetAllWiFiAccessPoints(false /* configured_only */, false /* visible_only */,
- 0 /* limit */, network_map.get());
-
- NetworkMap::const_iterator network_iter =
- network_map->find(base::UTF8ToUTF16(ssid));
- if (network_iter == network_map->end()) {
- // This network doesn't exist so there's nothing to do.
- return;
- }
-
- std::string connection_state;
- network_iter->second->GetString(kAccessPointInfoConnectionState,
- &connection_state);
- if (connection_state == ::onc::connection_state::kNotConnected) {
- // Already disconnected so nothing to do.
- return;
- }
-
- // It's not disconnected so disconnect it.
- dbus::ObjectProxy* device_proxy =
- dbus_->GetObjectProxy(networking_private::kNetworkManagerNamespace,
- dbus::ObjectPath(device_path_str));
- dbus::MethodCall method_call(
- networking_private::kNetworkManagerDeviceNamespace,
- networking_private::kNetworkManagerDisconnectMethod);
- scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!response) {
- LOG(WARNING) << "Failed to disconnect network on device "
- << device_path_str;
- *error = "Failed to disconnect network";
- }
-}
-
-void NetworkingPrivateLinux::StartConnect(
- const std::string& guid,
- const VoidCallback& success_callback,
- const FailureCallback& failure_callback) {
- if (!CheckNetworkManagerSupported(failure_callback))
- return;
-
- scoped_ptr<std::string> error(new std::string);
-
- // Runs ConnectToNetwork on |dbus_thread|.
- dbus_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE,
- base::Bind(&NetworkingPrivateLinux::ConnectToNetwork,
- base::Unretained(this), guid, base::Unretained(error.get())),
- base::Bind(&OnNetworkConnectOperationCompleted, base::Passed(&error),
- success_callback, failure_callback));
-}
-
-void NetworkingPrivateLinux::StartDisconnect(
- const std::string& guid,
- const VoidCallback& success_callback,
- const FailureCallback& failure_callback) {
- if (!CheckNetworkManagerSupported(failure_callback))
- return;
-
- scoped_ptr<std::string> error(new std::string);
-
- // Runs DisconnectFromNetwork on |dbus_thread|.
- dbus_thread_.task_runner()->PostTaskAndReply(
- FROM_HERE,
- base::Bind(&NetworkingPrivateLinux::DisconnectFromNetwork,
- base::Unretained(this), guid, base::Unretained(error.get())),
- base::Bind(&OnNetworkConnectOperationCompleted, base::Passed(&error),
- success_callback, failure_callback));
-}
-
-void NetworkingPrivateLinux::SetWifiTDLSEnabledState(
- const std::string& ip_or_mac_address,
- bool enabled,
- const StringCallback& success_callback,
- const FailureCallback& failure_callback) {
- ReportNotSupported("SetWifiTDLSEnabledState", failure_callback);
-}
-
-void NetworkingPrivateLinux::GetWifiTDLSStatus(
- const std::string& ip_or_mac_address,
- const StringCallback& success_callback,
- const FailureCallback& failure_callback) {
- ReportNotSupported("GetWifiTDLSStatus", failure_callback);
-}
-
-void NetworkingPrivateLinux::GetCaptivePortalStatus(
- const std::string& guid,
- const StringCallback& success_callback,
- const FailureCallback& failure_callback) {
- ReportNotSupported("GetCaptivePortalStatus", failure_callback);
-}
-
-scoped_ptr<base::ListValue> NetworkingPrivateLinux::GetEnabledNetworkTypes() {
- scoped_ptr<base::ListValue> network_list(new base::ListValue);
- return network_list.Pass();
-}
-
-bool NetworkingPrivateLinux::EnableNetworkType(const std::string& type) {
- return false;
-}
-
-bool NetworkingPrivateLinux::DisableNetworkType(const std::string& type) {
- return false;
-}
-
-bool NetworkingPrivateLinux::RequestScan() {
- return GetNetworksForScanRequest();
-}
-
-void NetworkingPrivateLinux::AddObserver(
- NetworkingPrivateDelegateObserver* observer) {
- network_events_observers_.AddObserver(observer);
-}
-
-void NetworkingPrivateLinux::RemoveObserver(
- NetworkingPrivateDelegateObserver* observer) {
- network_events_observers_.RemoveObserver(observer);
-}
-
-void NetworkingPrivateLinux::OnAccessPointsFound(
- scoped_ptr<NetworkMap> network_map,
- const NetworkListCallback& success_callback,
- const FailureCallback& failure_callback) {
- scoped_ptr<base::ListValue> network_list = CopyNetworkMapToList(*network_map);
- // Give ownership to the member variable.
- network_map_.swap(network_map);
- SendNetworkListChangedEvent(*network_list);
- success_callback.Run(network_list.Pass());
-}
-
-void NetworkingPrivateLinux::OnAccessPointsFoundViaScan(
- scoped_ptr<NetworkMap> network_map) {
- scoped_ptr<base::ListValue> network_list = CopyNetworkMapToList(*network_map);
- // Give ownership to the member variable.
- network_map_.swap(network_map);
- SendNetworkListChangedEvent(*network_list);
-}
-
-void NetworkingPrivateLinux::SendNetworkListChangedEvent(
- const base::ListValue& network_list) {
- GuidList guidsForEventCallback;
-
- for (const auto& network : network_list) {
- std::string guid;
- base::DictionaryValue* dict;
- if (network->GetAsDictionary(&dict)) {
- if (dict->GetString(kAccessPointInfoGuid, &guid)) {
- guidsForEventCallback.push_back(guid);
- }
- }
- }
-
- OnNetworkListChangedEventOnUIThread(guidsForEventCallback);
-}
-
-bool NetworkingPrivateLinux::GetNetworkDevices(
- std::vector<dbus::ObjectPath>* device_paths) {
- AssertOnDBusThread();
- dbus::MethodCall method_call(
- networking_private::kNetworkManagerNamespace,
- networking_private::kNetworkManagerGetDevicesMethod);
-
- scoped_ptr<dbus::Response> device_response(
- network_manager_proxy_->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!device_response) {
- return false;
- }
-
- dbus::MessageReader reader(device_response.get());
- if (!reader.PopArrayOfObjectPaths(device_paths)) {
- LOG(WARNING) << "Unexpected response: " << device_response->ToString();
- return false;
- }
-
- return true;
-}
-
-NetworkingPrivateLinux::DeviceType NetworkingPrivateLinux::GetDeviceType(
- const dbus::ObjectPath& device_path) {
- AssertOnDBusThread();
- dbus::ObjectProxy* device_proxy = dbus_->GetObjectProxy(
- networking_private::kNetworkManagerNamespace, device_path);
- dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
- networking_private::kNetworkManagerGetMethod);
- dbus::MessageWriter builder(&method_call);
- builder.AppendString(networking_private::kNetworkManagerDeviceNamespace);
- builder.AppendString(networking_private::kNetworkManagerDeviceType);
-
- scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!response) {
- LOG(ERROR) << "Failed to get the device type for device "
- << device_path.value();
- return NetworkingPrivateLinux::NM_DEVICE_TYPE_UNKNOWN;
- }
-
- dbus::MessageReader reader(response.get());
- uint32 device_type = 0;
- if (!reader.PopVariantOfUint32(&device_type)) {
- LOG(ERROR) << "Unexpected response for device " << device_type << ": "
- << response->ToString();
- return NM_DEVICE_TYPE_UNKNOWN;
- }
-
- return static_cast<NetworkingPrivateLinux::DeviceType>(device_type);
-}
-
-void NetworkingPrivateLinux::GetAllWiFiAccessPoints(bool configured_only,
- bool visible_only,
- int limit,
- NetworkMap* network_map) {
- AssertOnDBusThread();
- // TODO(zentaro): The filters are not implemented and are ignored.
- std::vector<dbus::ObjectPath> device_paths;
- if (!GetNetworkDevices(&device_paths)) {
- LOG(ERROR) << "Failed to enumerate network devices";
- return;
- }
-
- for (const auto& device_path : device_paths) {
- NetworkingPrivateLinux::DeviceType device_type = GetDeviceType(device_path);
-
- // Get the access points for each WiFi adapter. Other network types are
- // ignored.
- if (device_type != NetworkingPrivateLinux::NM_DEVICE_TYPE_WIFI)
- continue;
-
- // Found a wlan adapter
- if (!AddAccessPointsFromDevice(device_path, network_map)) {
- // Ignore devices we can't enumerate.
- LOG(WARNING) << "Failed to add access points from device "
- << device_path.value();
- }
- }
-}
-
-scoped_ptr<dbus::Response> NetworkingPrivateLinux::GetAccessPointProperty(
- dbus::ObjectProxy* access_point_proxy,
- const std::string& property_name) {
- AssertOnDBusThread();
- dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
- networking_private::kNetworkManagerGetMethod);
- dbus::MessageWriter builder(&method_call);
- builder.AppendString(networking_private::kNetworkManagerAccessPointNamespace);
- builder.AppendString(property_name);
- scoped_ptr<dbus::Response> response = access_point_proxy->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
- if (!response) {
- LOG(ERROR) << "Failed to get property for " << property_name;
- }
- return response.Pass();
-}
-
-bool NetworkingPrivateLinux::GetAccessPointInfo(
- const dbus::ObjectPath& access_point_path,
- const scoped_ptr<base::DictionaryValue>& access_point_info) {
- AssertOnDBusThread();
- dbus::ObjectProxy* access_point_proxy = dbus_->GetObjectProxy(
- networking_private::kNetworkManagerNamespace, access_point_path);
-
- // Read the SSID. The GUID is derived from the Ssid.
- {
- scoped_ptr<dbus::Response> response(GetAccessPointProperty(
- access_point_proxy, networking_private::kNetworkManagerSsidProperty));
-
- if (!response) {
- return false;
- }
-
- // The response should contain a variant that contains an array of bytes.
- dbus::MessageReader reader(response.get());
- dbus::MessageReader variant_reader(response.get());
- if (!reader.PopVariant(&variant_reader)) {
- LOG(ERROR) << "Unexpected response for " << access_point_path.value()
- << ": " << response->ToString();
- return false;
- }
-
- const uint8* ssid_bytes = NULL;
- size_t ssid_length = 0;
- if (!variant_reader.PopArrayOfBytes(&ssid_bytes, &ssid_length)) {
- LOG(ERROR) << "Unexpected response for " << access_point_path.value()
- << ": " << response->ToString();
- return false;
- }
-
- std::string ssidUTF8(ssid_bytes, ssid_bytes + ssid_length);
- base::string16 ssid = base::UTF8ToUTF16(ssidUTF8);
-
- access_point_info->SetString(kAccessPointInfoName, ssid);
- }
-
- // Read signal strength.
- {
- scoped_ptr<dbus::Response> response(GetAccessPointProperty(
- access_point_proxy,
- networking_private::kNetworkManagerStrengthProperty));
- if (!response) {
- return false;
- }
-
- dbus::MessageReader reader(response.get());
- uint8 strength = 0;
- if (!reader.PopVariantOfByte(&strength)) {
- LOG(ERROR) << "Unexpected response for " << access_point_path.value()
- << ": " << response->ToString();
- return false;
- }
-
- access_point_info->SetInteger(kAccessPointInfoWifiSignalStrengthDotted,
- strength);
- }
-
- // Read the security type. This is from the WpaFlags and RsnFlags property
- // which are of the same type and can be OR'd together to find all supported
- // security modes.
-
- uint32 wpa_security_flags = 0;
- {
- scoped_ptr<dbus::Response> response(GetAccessPointProperty(
- access_point_proxy,
- networking_private::kNetworkManagerWpaFlagsProperty));
- if (!response) {
- return false;
- }
-
- dbus::MessageReader reader(response.get());
-
- if (!reader.PopVariantOfUint32(&wpa_security_flags)) {
- LOG(ERROR) << "Unexpected response for " << access_point_path.value()
- << ": " << response->ToString();
- return false;
- }
- }
-
- uint32 rsn_security_flags = 0;
- {
- scoped_ptr<dbus::Response> response(GetAccessPointProperty(
- access_point_proxy,
- networking_private::kNetworkManagerRsnFlagsProperty));
- if (!response) {
- return false;
- }
-
- dbus::MessageReader reader(response.get());
-
- if (!reader.PopVariantOfUint32(&rsn_security_flags)) {
- LOG(ERROR) << "Unexpected response for " << access_point_path.value()
- << ": " << response->ToString();
- return false;
- }
- }
-
- std::string security;
- MapSecurityFlagsToString(rsn_security_flags | wpa_security_flags, &security);
- access_point_info->SetString(kAccessPointInfoWifiSecurityDotted, security);
- access_point_info->SetString(kAccessPointInfoType, kAccessPointInfoTypeWifi);
- access_point_info->SetBoolean(kAccessPointInfoConnectable, true);
- return true;
-}
-
-bool NetworkingPrivateLinux::AddAccessPointsFromDevice(
- const dbus::ObjectPath& device_path,
- NetworkMap* network_map) {
- AssertOnDBusThread();
- dbus::ObjectPath connected_access_point;
- if (!GetConnectedAccessPoint(device_path, &connected_access_point)) {
- return false;
- }
-
- dbus::ObjectProxy* device_proxy = dbus_->GetObjectProxy(
- networking_private::kNetworkManagerNamespace, device_path);
- dbus::MethodCall method_call(
- networking_private::kNetworkManagerWirelessDeviceNamespace,
- networking_private::kNetworkManagerGetAccessPointsMethod);
- scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!response) {
- LOG(WARNING) << "Failed to get access points data for "
- << device_path.value();
- return false;
- }
-
- dbus::MessageReader reader(response.get());
- std::vector<dbus::ObjectPath> access_point_paths;
- if (!reader.PopArrayOfObjectPaths(&access_point_paths)) {
- LOG(ERROR) << "Unexpected response for " << device_path.value() << ": "
- << response->ToString();
- return false;
- }
-
- for (const auto& access_point_path : access_point_paths) {
- scoped_ptr<base::DictionaryValue> access_point(new base::DictionaryValue);
-
- if (GetAccessPointInfo(access_point_path, access_point)) {
- std::string connection_state =
- (access_point_path == connected_access_point)
- ? ::onc::connection_state::kConnected
- : ::onc::connection_state::kNotConnected;
-
- access_point->SetString(kAccessPointInfoConnectionState,
- connection_state);
- std::string ssid;
- access_point->GetString(kAccessPointInfoName, &ssid);
-
- std::string network_guid =
- ConstructNetworkGuid(device_path, access_point_path, ssid);
-
- // Adds the network to the map. Since each SSID can actually have multiple
- // access point paths, this consolidates them. If it is already
- // in the map it updates the signal strength and GUID paths if this
- // network is stronger or the one that is connected.
- AddOrUpdateAccessPoint(network_map, network_guid, access_point);
- }
- }
-
- return true;
-}
-
-void NetworkingPrivateLinux::AddOrUpdateAccessPoint(
- NetworkMap* network_map,
- const std::string& network_guid,
- scoped_ptr<base::DictionaryValue>& access_point) {
- base::string16 ssid;
- std::string connection_state;
- int signal_strength;
-
- access_point->GetString(kAccessPointInfoConnectionState, &connection_state);
- access_point->GetInteger(kAccessPointInfoWifiSignalStrengthDotted,
- &signal_strength);
- access_point->GetString(kAccessPointInfoName, &ssid);
- access_point->SetString(kAccessPointInfoGuid, network_guid);
-
- NetworkMap::iterator existing_access_point_iter = network_map->find(ssid);
-
- if (existing_access_point_iter == network_map->end()) {
- // Unseen access point. Add it to the map.
- network_map->insert(NetworkMap::value_type(
- ssid, linked_ptr<base::DictionaryValue>(access_point.release())));
- } else {
- // Already seen access point. Update the record if this is the connected
- // record or if the signal strength is higher. But don't override a weaker
- // access point if that is the one that is connected.
- int existing_signal_strength;
- linked_ptr<base::DictionaryValue>& existing_access_point =
- existing_access_point_iter->second;
- existing_access_point->GetInteger(kAccessPointInfoWifiSignalStrengthDotted,
- &existing_signal_strength);
-
- std::string existing_connection_state;
- existing_access_point->GetString(kAccessPointInfoConnectionState,
- &existing_connection_state);
-
- if ((connection_state == ::onc::connection_state::kConnected) ||
- (!(existing_connection_state == ::onc::connection_state::kConnected) &&
- signal_strength > existing_signal_strength)) {
- existing_access_point->SetString(kAccessPointInfoConnectionState,
- connection_state);
- existing_access_point->SetInteger(
- kAccessPointInfoWifiSignalStrengthDotted, signal_strength);
- existing_access_point->SetString(kAccessPointInfoGuid, network_guid);
- }
- }
-}
-
-void NetworkingPrivateLinux::MapSecurityFlagsToString(uint32 security_flags,
- std::string* security) {
- // Valid values are None, WEP-PSK, WEP-8021X, WPA-PSK, WPA-EAP
- if (security_flags == NetworkingPrivateLinux::NM_802_11_AP_SEC_NONE) {
- *security = kAccessPointSecurityNone;
- } else if (security_flags &
- NetworkingPrivateLinux::NM_802_11_AP_SEC_KEY_MGMT_PSK) {
- *security = kAccessPointSecurityWpaPsk;
- } else if (security_flags &
- NetworkingPrivateLinux::NM_802_11_AP_SEC_KEY_MGMT_802_1X) {
- *security = kAccessPointSecurity9021X;
- } else {
- DVLOG(1) << "Security flag mapping is missing. Found " << security_flags;
- *security = kAccessPointSecurityUnknown;
- }
-
- DVLOG(1) << "Network security setting " << *security;
-}
-
-bool NetworkingPrivateLinux::GetConnectedAccessPoint(
- dbus::ObjectPath device_path,
- dbus::ObjectPath* access_point_path) {
- AssertOnDBusThread();
- dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
- networking_private::kNetworkManagerGetMethod);
- dbus::MessageWriter builder(&method_call);
- builder.AppendString(networking_private::kNetworkManagerNamespace);
- builder.AppendString(networking_private::kNetworkManagerActiveConnections);
-
- scoped_ptr<dbus::Response> response(
- network_manager_proxy_->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!response) {
- LOG(WARNING) << "Failed to get a list of active connections";
- return false;
- }
-
- dbus::MessageReader reader(response.get());
- dbus::MessageReader variant_reader(response.get());
- if (!reader.PopVariant(&variant_reader)) {
- LOG(ERROR) << "Unexpected response: " << response->ToString();
- return false;
- }
-
- std::vector<dbus::ObjectPath> connection_paths;
- if (!variant_reader.PopArrayOfObjectPaths(&connection_paths)) {
- LOG(ERROR) << "Unexpected response: " << response->ToString();
- return false;
- }
-
- for (const auto& connection_path : connection_paths) {
- dbus::ObjectPath connections_device_path;
- if (!GetDeviceOfConnection(connection_path, &connections_device_path)) {
- return false;
- }
-
- if (connections_device_path == device_path) {
- if (!GetAccessPointForConnection(connection_path, access_point_path)) {
- return false;
- }
-
- break;
- }
- }
-
- return true;
-}
-
-bool NetworkingPrivateLinux::GetDeviceOfConnection(
- dbus::ObjectPath connection_path,
- dbus::ObjectPath* device_path) {
- AssertOnDBusThread();
- dbus::ObjectProxy* connection_proxy = dbus_->GetObjectProxy(
- networking_private::kNetworkManagerNamespace, connection_path);
-
- if (!connection_proxy) {
- return false;
- }
-
- dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
- networking_private::kNetworkManagerGetMethod);
- dbus::MessageWriter builder(&method_call);
- builder.AppendString(
- networking_private::kNetworkManagerActiveConnectionNamespace);
- builder.AppendString("Devices");
-
- scoped_ptr<dbus::Response> response(connection_proxy->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!response) {
- LOG(ERROR) << "Failed to get devices";
- return false;
- }
-
- dbus::MessageReader reader(response.get());
- dbus::MessageReader variant_reader(response.get());
- if (!reader.PopVariant(&variant_reader)) {
- LOG(ERROR) << "Unexpected response: " << response->ToString();
- return false;
- }
-
- std::vector<dbus::ObjectPath> device_paths;
- if (!variant_reader.PopArrayOfObjectPaths(&device_paths)) {
- LOG(ERROR) << "Unexpected response: " << response->ToString();
- return false;
- }
-
- if (device_paths.size() == 1) {
- *device_path = device_paths[0];
-
- return true;
- }
-
- return false;
-}
-
-bool NetworkingPrivateLinux::GetAccessPointForConnection(
- dbus::ObjectPath connection_path,
- dbus::ObjectPath* access_point_path) {
- AssertOnDBusThread();
- dbus::ObjectProxy* connection_proxy = dbus_->GetObjectProxy(
- networking_private::kNetworkManagerNamespace, connection_path);
-
- if (!connection_proxy) {
- return false;
- }
-
- dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
- networking_private::kNetworkManagerGetMethod);
- dbus::MessageWriter builder(&method_call);
- builder.AppendString(
- networking_private::kNetworkManagerActiveConnectionNamespace);
- builder.AppendString(networking_private::kNetworkManagerSpecificObject);
-
- scoped_ptr<dbus::Response> response(connection_proxy->CallMethodAndBlock(
- &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
-
- if (!response) {
- LOG(WARNING) << "Failed to get access point from active connection";
- return false;
- }
-
- dbus::MessageReader reader(response.get());
- dbus::MessageReader variant_reader(response.get());
- if (!reader.PopVariant(&variant_reader)) {
- LOG(ERROR) << "Unexpected response: " << response->ToString();
- return false;
- }
-
- if (!variant_reader.PopObjectPath(access_point_path)) {
- LOG(ERROR) << "Unexpected response: " << response->ToString();
- return false;
- }
-
- return true;
-}
-
-bool NetworkingPrivateLinux::SetConnectionStateAndPostEvent(
- const std::string& guid,
- const std::string& ssid,
- const std::string& connection_state) {
- AssertOnDBusThread();
-
- NetworkMap::iterator network_iter =
- network_map_->find(base::UTF8ToUTF16(ssid));
- if (network_iter == network_map_->end()) {
- return false;
- }
-
- DVLOG(1) << "Setting connection state of " << ssid << " to "
- << connection_state;
-
- // If setting this network to connected, find the previously connected network
- // and disconnect that one. Also retain the guid of that network to fire a
- // changed event.
- std::string connected_network_guid;
- if (connection_state == ::onc::connection_state::kConnected) {
- for (auto& network : *network_map_) {
- std::string other_connection_state;
- if (network.second->GetString(kAccessPointInfoConnectionState,
- &other_connection_state)) {
- if (other_connection_state == ::onc::connection_state::kConnected) {
- network.second->GetString(kAccessPointInfoGuid,
- &connected_network_guid);
- network.second->SetString(kAccessPointInfoConnectionState,
- ::onc::connection_state::kNotConnected);
- }
- }
- }
- }
-
- // Set the status.
- network_iter->second->SetString(kAccessPointInfoConnectionState,
- connection_state);
-
- scoped_ptr<GuidList> changed_networks(new GuidList());
- changed_networks->push_back(guid);
-
- // Only add a second network if it exists and it is not the same as the
- // network already being added to the list.
- if (!connected_network_guid.empty() && connected_network_guid != guid) {
- changed_networks->push_back(connected_network_guid);
- }
-
- PostOnNetworksChangedToUIThread(changed_networks.Pass());
- return true;
-}
-
-void NetworkingPrivateLinux::OnNetworksChangedEventOnUIThread(
- const GuidList& network_guids) {
- DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
- FOR_EACH_OBSERVER(NetworkingPrivateDelegateObserver,
- network_events_observers_,
- OnNetworksChangedEvent(network_guids));
-}
-
-void NetworkingPrivateLinux::OnNetworkListChangedEventOnUIThread(
- const GuidList& network_guids) {
- DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
- FOR_EACH_OBSERVER(NetworkingPrivateDelegateObserver,
- network_events_observers_,
- OnNetworkListChangedEvent(network_guids));
-}
-
-void NetworkingPrivateLinux::PostOnNetworksChangedToUIThread(
- scoped_ptr<GuidList> guid_list) {
- AssertOnDBusThread();
-
- content::BrowserThread::PostTask(
- content::BrowserThread::UI, FROM_HERE,
- base::Bind(&NetworkingPrivateLinux::OnNetworksChangedEventTask,
- base::Unretained(this), base::Passed(&guid_list)));
-}
-
-void NetworkingPrivateLinux::OnNetworksChangedEventTask(
- scoped_ptr<GuidList> guid_list) {
- DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
- OnNetworksChangedEventOnUIThread(*guid_list);
-}
-
-} // namespace extensions
« no previous file with comments | « chrome/browser/extensions/api/networking_private/networking_private_linux.h ('k') | chrome/browser/extensions/api/networking_private/networking_private_service_client.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698