content/browser/geolocation/wifi_data_provider_linux.cc

   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 // Provides wifi scan API binding for suitable for typical linux distributions.
   6 // Currently, only the NetworkManager API is used, accessed via D-Bus (in turn
   7 // accessed via the GLib wrapper).
   8
   9 #include "content/browser/geolocation/wifi_data_provider_linux.h"
  10
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "content/browser/geolocation/wifi_data_provider_manager.h"
  15 #include "dbus/bus.h"
  16 #include "dbus/message.h"
  17 #include "dbus/object_path.h"
  18 #include "dbus/object_proxy.h"
  19
  20 namespace content {
  21 namespace {
  22 // The time periods between successive polls of the wifi data.
  23 const int kDefaultPollingIntervalMilliseconds = 10 * 1000;  // 10s
  24 const int kNoChangePollingIntervalMilliseconds = 2 * 60 * 1000;  // 2 mins
  25 const int kTwoNoChangePollingIntervalMilliseconds = 10 * 60 * 1000;  // 10 mins
  26 const int kNoWifiPollingIntervalMilliseconds = 20 * 1000; // 20s
  27
  28 const char kNetworkManagerServiceName[] = "org.freedesktop.NetworkManager";
  29 const char kNetworkManagerPath[] = "/org/freedesktop/NetworkManager";
  30 const char kNetworkManagerInterface[] = "org.freedesktop.NetworkManager";
  31
  32 // From http://projects.gnome.org/NetworkManager/developers/spec.html
  33 enum { NM_DEVICE_TYPE_WIFI = 2 };
  34
  35 // Wifi API binding to NetworkManager, to allow reuse of the polling behavior
  36 // defined in WifiDataProviderCommon.
  37 // TODO(joth): NetworkManager also allows for notification based handling,
  38 // however this will require reworking of the threading code to run a GLib
  39 // event loop (GMainLoop).
  40 class NetworkManagerWlanApi : public WifiDataProviderCommon::WlanApiInterface {
  41  public:
  42   NetworkManagerWlanApi();
  43   ~NetworkManagerWlanApi() override;
  44
  45   // Must be called before any other interface method. Will return false if the
  46   // NetworkManager session cannot be created (e.g. not present on this distro),
  47   // in which case no other method may be called.
  48   bool Init();
  49
  50   // Similar to Init() but can inject the bus object. Used for testing.
  51   bool InitWithBus(dbus::Bus* bus);
  52
  53   // WifiDataProviderCommon::WlanApiInterface
  54   //
  55   // This function makes blocking D-Bus calls, but it's totally fine as
  56   // the code runs in "Geolocation" thread, not the browser's UI thread.
  57   bool GetAccessPointData(WifiData::AccessPointDataSet* data) override;
  58
  59  private:
  60   // Enumerates the list of available network adapter devices known to
  61   // NetworkManager. Return true on success.
  62   bool GetAdapterDeviceList(std::vector<dbus::ObjectPath>* device_paths);
  63
  64   // Given the NetworkManager path to a wireless adapater, dumps the wifi scan
  65   // results and appends them to |data|. Returns false if a fatal error is
  66   // encountered such that the data set could not be populated.
  67   bool GetAccessPointsForAdapter(const dbus::ObjectPath& adapter_path,
  68                                  WifiData::AccessPointDataSet* data);
  69
  70   // Internal method used by |GetAccessPointsForAdapter|, given a wifi access
  71   // point proxy retrieves the named property and returns it. Returns NULL in
  72   // a scoped_ptr if the property could not be read.
  73   scoped_ptr<dbus::Response> GetAccessPointProperty(
  74       dbus::ObjectProxy* proxy,
  75       const std::string& property_name);
  76
  77   scoped_refptr<dbus::Bus> system_bus_;
  78   dbus::ObjectProxy* network_manager_proxy_;
  79
  80   DISALLOW_COPY_AND_ASSIGN(NetworkManagerWlanApi);
  81 };
  82
  83 // Convert a wifi frequency to the corresponding channel. Adapted from
  84 // geolocaiton/wifilib.cc in googleclient (internal to google).
  85 int frquency_in_khz_to_channel(int frequency_khz) {
  86   if (frequency_khz >= 2412000 && frequency_khz <= 2472000)  // Channels 1-13.
  87     return (frequency_khz - 2407000) / 5000;
  88   if (frequency_khz == 2484000)
  89     return 14;
  90   if (frequency_khz > 5000000 && frequency_khz < 6000000)  // .11a bands.
  91     return (frequency_khz - 5000000) / 5000;
  92   // Ignore everything else.
  93   return AccessPointData().channel;  // invalid channel
  94 }
  95
  96 NetworkManagerWlanApi::NetworkManagerWlanApi()
  97     : network_manager_proxy_(NULL) {
  98 }
  99
 100 NetworkManagerWlanApi::~NetworkManagerWlanApi() {
 101   // Close the connection.
 102   system_bus_->ShutdownAndBlock();
 103 }
 104
 105 bool NetworkManagerWlanApi::Init() {
 106   dbus::Bus::Options options;
 107   options.bus_type = dbus::Bus::SYSTEM;
 108   options.connection_type = dbus::Bus::PRIVATE;
 109   return InitWithBus(new dbus::Bus(options));
 110 }
 111
 112 bool NetworkManagerWlanApi::InitWithBus(dbus::Bus* bus) {
 113   system_bus_ = bus;
 114   // system_bus_ will own all object proxies created from the bus.
 115   network_manager_proxy_ =
 116       system_bus_->GetObjectProxy(kNetworkManagerServiceName,
 117                                   dbus::ObjectPath(kNetworkManagerPath));
 118   // Validate the proxy object by checking we can enumerate devices.
 119   std::vector<dbus::ObjectPath> adapter_paths;
 120   const bool success = GetAdapterDeviceList(&adapter_paths);
 121   VLOG(1) << "Init() result:  " << success;
 122   return success;
 123 }
 124
 125 bool NetworkManagerWlanApi::GetAccessPointData(
 126     WifiData::AccessPointDataSet* data) {
 127   std::vector<dbus::ObjectPath> device_paths;
 128   if (!GetAdapterDeviceList(&device_paths)) {
 129     LOG(WARNING) << "Could not enumerate access points";
 130     return false;
 131   }
 132   int success_count = 0;
 133   int fail_count = 0;
 134
 135   // Iterate the devices, getting APs for each wireless adapter found
 136   for (size_t i = 0; i < device_paths.size(); ++i) {
 137     const dbus::ObjectPath& device_path = device_paths[i];
 138     VLOG(1) << "Checking device: " << device_path.value();
 139
 140     dbus::ObjectProxy* device_proxy =
 141         system_bus_->GetObjectProxy(kNetworkManagerServiceName,
 142                                     device_path);
 143
 144     dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES, "Get");
 145     dbus::MessageWriter builder(&method_call);
 146     builder.AppendString("org.freedesktop.NetworkManager.Device");
 147     builder.AppendString("DeviceType");
 148     scoped_ptr<dbus::Response> response(
 149         device_proxy->CallMethodAndBlock(
 150             &method_call,
 151             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 152     if (!response) {
 153       LOG(WARNING) << "Failed to get the device type for "
 154                    << device_path.value();
 155       continue;  // Check the next device.
 156     }
 157     dbus::MessageReader reader(response.get());
 158     uint32 device_type = 0;
 159     if (!reader.PopVariantOfUint32(&device_type)) {
 160       LOG(WARNING) << "Unexpected response for " << device_type << ": "
 161                    << response->ToString();
 162       continue;  // Check the next device.
 163     }
 164     VLOG(1) << "Device type: " << device_type;
 165
 166     if (device_type == NM_DEVICE_TYPE_WIFI) {  // Found a wlan adapter
 167       if (GetAccessPointsForAdapter(device_path, data))
 168         ++success_count;
 169       else
 170         ++fail_count;
 171     }
 172   }
 173   // At least one successfull scan overrides any other adapter reporting error.
 174   return success_count || fail_count == 0;
 175 }
 176
 177 bool NetworkManagerWlanApi::GetAdapterDeviceList(
 178     std::vector<dbus::ObjectPath>* device_paths) {
 179   dbus::MethodCall method_call(kNetworkManagerInterface, "GetDevices");
 180   scoped_ptr<dbus::Response> response(
 181       network_manager_proxy_->CallMethodAndBlock(
 182           &method_call,
 183           dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 184   if (!response) {
 185     LOG(WARNING) << "Failed to get the device list";
 186     return false;
 187   }
 188
 189   dbus::MessageReader reader(response.get());
 190   if (!reader.PopArrayOfObjectPaths(device_paths)) {
 191     LOG(WARNING) << "Unexpected response: " << response->ToString();
 192     return false;
 193   }
 194   return true;
 195 }
 196
 197
 198 bool NetworkManagerWlanApi::GetAccessPointsForAdapter(
 199     const dbus::ObjectPath& adapter_path, WifiData::AccessPointDataSet* data) {
 200   // Create a proxy object for this wifi adapter, and ask it to do a scan
 201   // (or at least, dump its scan results).
 202   dbus::ObjectProxy* device_proxy =
 203       system_bus_->GetObjectProxy(kNetworkManagerServiceName,
 204                                   adapter_path);
 205   dbus::MethodCall method_call(
 206       "org.freedesktop.NetworkManager.Device.Wireless",
 207       "GetAccessPoints");
 208   scoped_ptr<dbus::Response> response(
 209       device_proxy->CallMethodAndBlock(
 210           &method_call,
 211           dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 212   if (!response) {
 213     LOG(WARNING) << "Failed to get access points data for "
 214                  << adapter_path.value();
 215     return false;
 216   }
 217   dbus::MessageReader reader(response.get());
 218   std::vector<dbus::ObjectPath> access_point_paths;
 219   if (!reader.PopArrayOfObjectPaths(&access_point_paths)) {
 220     LOG(WARNING) << "Unexpected response for " << adapter_path.value() << ": "
 221                  << response->ToString();
 222     return false;
 223   }
 224
 225   VLOG(1) << "Wireless adapter " << adapter_path.value() << " found "
 226           << access_point_paths.size() << " access points.";
 227
 228   for (size_t i = 0; i < access_point_paths.size(); ++i) {
 229     const dbus::ObjectPath& access_point_path = access_point_paths[i];
 230     VLOG(1) << "Checking access point: " << access_point_path.value();
 231
 232     dbus::ObjectProxy* access_point_proxy =
 233         system_bus_->GetObjectProxy(kNetworkManagerServiceName,
 234                                     access_point_path);
 235
 236     AccessPointData access_point_data;
 237     {
 238       scoped_ptr<dbus::Response> response(
 239           GetAccessPointProperty(access_point_proxy, "Ssid"));
 240       if (!response)
 241         continue;
 242       // The response should contain a variant that contains an array of bytes.
 243       dbus::MessageReader reader(response.get());
 244       dbus::MessageReader variant_reader(response.get());
 245       if (!reader.PopVariant(&variant_reader)) {
 246         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
 247                      << ": " << response->ToString();
 248         continue;
 249       }
 250       const uint8* ssid_bytes = NULL;
 251       size_t ssid_length = 0;
 252       if (!variant_reader.PopArrayOfBytes(&ssid_bytes, &ssid_length)) {
 253         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
 254                      << ": " << response->ToString();
 255         continue;
 256       }
 257       std::string ssid(ssid_bytes, ssid_bytes + ssid_length);
 258       access_point_data.ssid = base::UTF8ToUTF16(ssid);
 259     }
 260
 261     { // Read the mac address
 262       scoped_ptr<dbus::Response> response(
 263           GetAccessPointProperty(access_point_proxy, "HwAddress"));
 264       if (!response)
 265         continue;
 266       dbus::MessageReader reader(response.get());
 267       std::string mac;
 268       if (!reader.PopVariantOfString(&mac)) {
 269         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
 270                      << ": " << response->ToString();
 271         continue;
 272       }
 273
 274       base::ReplaceSubstringsAfterOffset(&mac, 0U, ":", base::StringPiece());
 275       std::vector<uint8> mac_bytes;
 276       if (!base::HexStringToBytes(mac, &mac_bytes) || mac_bytes.size() != 6) {
 277         LOG(WARNING) << "Can't parse mac address (found " << mac_bytes.size()
 278                      << " bytes) so using raw string: " << mac;
 279         access_point_data.mac_address = base::UTF8ToUTF16(mac);
 280       } else {
 281         access_point_data.mac_address = MacAddressAsString16(&mac_bytes[0]);
 282       }
 283     }
 284
 285     {  // Read signal strength.
 286       scoped_ptr<dbus::Response> response(
 287           GetAccessPointProperty(access_point_proxy, "Strength"));
 288       if (!response)
 289         continue;
 290       dbus::MessageReader reader(response.get());
 291       uint8 strength = 0;
 292       if (!reader.PopVariantOfByte(&strength)) {
 293         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
 294                      << ": " << response->ToString();
 295         continue;
 296       }
 297       // Convert strength as a percentage into dBs.
 298       access_point_data.radio_signal_strength = -100 + strength / 2;
 299     }
 300
 301     { // Read the channel
 302       scoped_ptr<dbus::Response> response(
 303           GetAccessPointProperty(access_point_proxy, "Frequency"));
 304       if (!response)
 305         continue;
 306       dbus::MessageReader reader(response.get());
 307       uint32 frequency = 0;
 308       if (!reader.PopVariantOfUint32(&frequency)) {
 309         LOG(WARNING) << "Unexpected response for " << access_point_path.value()
 310                      << ": " << response->ToString();
 311         continue;
 312       }
 313
 314       // NetworkManager returns frequency in MHz.
 315       access_point_data.channel =
 316           frquency_in_khz_to_channel(frequency * 1000);
 317     }
 318     VLOG(1) << "Access point data of " << access_point_path.value() << ": "
 319             << "SSID: " << access_point_data.ssid << ", "
 320             << "MAC: " << access_point_data.mac_address << ", "
 321             << "Strength: " << access_point_data.radio_signal_strength << ", "
 322             << "Channel: " << access_point_data.channel;
 323
 324     data->insert(access_point_data);
 325   }
 326   return true;
 327 }
 328
 329 scoped_ptr<dbus::Response> NetworkManagerWlanApi::GetAccessPointProperty(
 330     dbus::ObjectProxy* access_point_proxy,
 331     const std::string& property_name) {
 332   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES, "Get");
 333   dbus::MessageWriter builder(&method_call);
 334   builder.AppendString("org.freedesktop.NetworkManager.AccessPoint");
 335   builder.AppendString(property_name);
 336   scoped_ptr<dbus::Response> response = access_point_proxy->CallMethodAndBlock(
 337       &method_call,
 338       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
 339   if (!response) {
 340     LOG(WARNING) << "Failed to get property for " << property_name;
 341   }
 342   return response.Pass();
 343 }
 344
 345 }  // namespace
 346
 347 // static
 348 WifiDataProvider* WifiDataProviderManager::DefaultFactoryFunction() {
 349   return new WifiDataProviderLinux();
 350 }
 351
 352 WifiDataProviderLinux::WifiDataProviderLinux() {
 353 }
 354
 355 WifiDataProviderLinux::~WifiDataProviderLinux() {
 356 }
 357
 358 WifiDataProviderCommon::WlanApiInterface*
 359 WifiDataProviderLinux::NewWlanApi() {
 360   scoped_ptr<NetworkManagerWlanApi> wlan_api(new NetworkManagerWlanApi);
 361   if (wlan_api->Init())
 362     return wlan_api.release();
 363   return NULL;
 364 }
 365
 366 WifiPollingPolicy* WifiDataProviderLinux::NewPollingPolicy() {
 367   return new GenericWifiPollingPolicy<kDefaultPollingIntervalMilliseconds,
 368                                       kNoChangePollingIntervalMilliseconds,
 369                                       kTwoNoChangePollingIntervalMilliseconds,
 370                                       kNoWifiPollingIntervalMilliseconds>;
 371 }
 372
 373 WifiDataProviderCommon::WlanApiInterface*
 374 WifiDataProviderLinux::NewWlanApiForTesting(dbus::Bus* bus) {
 375   scoped_ptr<NetworkManagerWlanApi> wlan_api(new NetworkManagerWlanApi);
 376   if (wlan_api->InitWithBus(bus))
 377     return wlan_api.release();
 378   return NULL;
 379 }
 380
 381 }  // namespace content