If requested, report network interfaces to management server.

chrome/browser/chromeos/policy/device_status_collector.cc

 // Copyright (c) 2012 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/chromeos/policy/device_status_collector.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/network/device_state.h"
+#include "chromeos/network/network_handler.h"
+#include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 
 using base::Time;
 using base::TimeDelta;
 using chromeos::VersionLoader;
 
 namespace em = enterprise_management;
 
 namespace {
 // How many seconds of inactivity triggers the idle state.
 const int kIdleStateThresholdSeconds = 300;
 
 // How many days in the past to store active periods for.
 const unsigned int kMaxStoredPastActivityDays = 30;
 
 // How many days in the future to store active periods for.
 const unsigned int kMaxStoredFutureActivityDays = 2;
 
 // How often, in seconds, to update the device location.
 const unsigned int kGeolocationPollIntervalSeconds = 30 * 60;
 
 const int64 kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
 
+// Keys for the geolocation status dictionary in local state.
 const char kLatitude[] = "latitude";
-
 const char kLongitude[] = "longitude";
-
 const char kAltitude[] = "altitude";
-
 const char kAccuracy[] = "accuracy";
-
 const char kAltitudeAccuracy[] = "altitude_accuracy";
-
 const char kHeading[] = "heading";
-
 const char kSpeed[] = "speed";
-
 const char kTimestamp[] = "timestamp";
 
 // Determine the day key (milliseconds since epoch for corresponding day in UTC)
 // for a given |timestamp|.
 int64 TimestampToDayKey(Time timestamp) {
   Time::Exploded exploded;
   timestamp.LocalMidnight().LocalExplode(&exploded);
   return (Time::FromUTCExploded(exploded) - Time::UnixEpoch()).InMilliseconds();
 }
 
@@ skipping 52 matching lines @@
       last_idle_check_(Time()),
       last_reported_day_(0),
       duration_for_last_reported_day_(0),
       geolocation_update_in_progress_(false),
       statistics_provider_(provider),
       weak_factory_(this),
       report_version_info_(false),
       report_activity_times_(false),
       report_boot_mode_(false),
       report_location_(false),
+      report_network_interfaces_(false),
       context_(new Context()) {
   if (location_update_requester) {
     location_update_requester_ = *location_update_requester;
   } else {
     location_update_requester_ =
         base::Bind(&Context::GetLocationUpdate, context_.get());
   }
   idle_poll_timer_.Start(FROM_HERE,
                          TimeDelta::FromSeconds(kIdlePollIntervalSeconds),
                          this, &DeviceStatusCollector::CheckIdleState);
 
   cros_settings_ = chromeos::CrosSettings::Get();
 
   // Watch for changes to the individual policies that control what the status
   // reports contain.
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceVersionInfo, this);
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceActivityTimes,
                                       this);
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceBootMode, this);
   cros_settings_->AddSettingsObserver(chromeos::kReportDeviceLocation, this);
+  cros_settings_->AddSettingsObserver(chromeos::kReportDeviceNetworkInterfaces,
+                                      this);
 
   // The last known location is persisted in local state. This makes location
   // information available immediately upon startup and avoids the need to
   // reacquire the location on every user session change or browser crash.
   content::Geoposition position;
   std::string timestamp_str;
   int64 timestamp;
   const base::DictionaryValue* location =
       local_state_->GetDictionary(prefs::kDeviceLocation);
   if (location->GetDouble(kLatitude, &position.latitude) &&
@@ skipping 22 matching lines @@
       &tracker_);
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceVersionInfo,
                                          this);
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceActivityTimes,
                                          this);
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceBootMode, this);
   cros_settings_->RemoveSettingsObserver(chromeos::kReportDeviceLocation, this);
+  cros_settings_->RemoveSettingsObserver(
+      chromeos::kReportDeviceNetworkInterfaces, this);
 }
 
 // static
 void DeviceStatusCollector::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kDeviceActivityTimes,
                                    new base::DictionaryValue);
   registry->RegisterDictionaryPref(prefs::kDeviceLocation,
                                    new base::DictionaryValue);
 }
 
@@ skipping 14 matching lines @@
     return;
   }
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceVersionInfo, &report_version_info_);
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceActivityTimes, &report_activity_times_);
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceBootMode, &report_boot_mode_);
   cros_settings_->GetBoolean(
       chromeos::kReportDeviceLocation, &report_location_);
+  cros_settings_->GetBoolean(
+      chromeos::kReportDeviceNetworkInterfaces, &report_network_interfaces_);
 
   if (report_location_) {
     ScheduleGeolocationUpdateRequest();
   } else {
     geolocation_update_timer_.Stop();
     position_ = content::Geoposition();
     local_state_->ClearPref(prefs::kDeviceLocation);
   }
 }
 
@@ skipping 155 matching lines @@
     if (position_.altitude_accuracy >= 0.)
       location->set_altitude_accuracy(position_.altitude_accuracy);
     if (position_.heading >= 0. && position_.heading <= 360)
       location->set_heading(position_.heading);
     if (position_.speed >= 0.)
       location->set_speed(position_.speed);
     location->set_error_code(em::DeviceLocation::ERROR_CODE_NONE);
   }
 }
 
+void DeviceStatusCollector::GetNetworkInterfaces(
+    em::DeviceStatusReportRequest* request) {
+  // Maps flimflam device type strings to proto enum constants.

[pneubeck (no reviews), 2013/07/11 18:49:32]

nit: although the namespace is still 'flimflam', we may refer to Shill's device
types instead. 

+  static struct {
+    const char* type_string;
+    em::NetworkInterface::NetworkDeviceType type_constant;
+  } kDeviceTypeMap[] = {

[pneubeck (no reviews), 2013/07/11 18:49:32]

nit: could be an array of _const_ entries.

[pneubeck (no reviews), 2013/07/12 07:57:54]

would be in accordance with this thread (they discussed const char* list[] vs.
const char* const list[])
https://groups.google.com/a/chromium.org/forum/#!searchin/chromium-dev/uninit...

[Mattias Nissler (ping if slow), 2013/07/12 08:11:55]

Valid point, done.

+    { flimflam::kTypeEthernet,  em::NetworkInterface::TYPE_ETHERNET,  },
+    { flimflam::kTypeWifi,      em::NetworkInterface::TYPE_WIFI,      },
+    { flimflam::kTypeWimax,     em::NetworkInterface::TYPE_WIMAX,     },
+    { flimflam::kTypeBluetooth, em::NetworkInterface::TYPE_BLUETOOTH, },
+    { flimflam::kTypeCellular,  em::NetworkInterface::TYPE_CELLULAR,  },
+  };
+
+  chromeos::NetworkStateHandler::DeviceStateList device_list;
+  chromeos::NetworkHandler::Get()->network_state_handler()->GetDeviceList(
+      &device_list);
+
+  chromeos::NetworkStateHandler::DeviceStateList::const_iterator device;
+  for (device = device_list.begin(); device != device_list.end(); ++device) {
+    // Determine the type enum constant for |device|.
+    size_t type_idx = 0;
+    for (; type_idx < ARRAYSIZE_UNSAFE(kDeviceTypeMap); ++type_idx) {
+      if ((*device)->type() == kDeviceTypeMap[type_idx].type_string)
+        break;
+    }
+
+    // If the type isn't in |kDeviceTypeMap|, the interface is not relevant for
+    // reporting. This filters out VPN devices.
+    if (type_idx >= ARRAYSIZE_UNSAFE(kDeviceTypeMap))
+      continue;
+
+    em::NetworkInterface* interface = request->add_network_interface();
+    interface->set_type(kDeviceTypeMap[type_idx].type_constant);
+    if (!(*device)->mac_address().empty())
+      interface->set_mac_address((*device)->mac_address());
+    if (!(*device)->meid().empty())
+      interface->set_meid((*device)->meid());
+    if (!(*device)->imei().empty())
+      interface->set_imei((*device)->imei());
+  }
+}
+
 void DeviceStatusCollector::GetStatus(em::DeviceStatusReportRequest* request) {
   // TODO(mnissler): Remove once the old cloud policy stack is retired. The old
   // stack doesn't support reporting successful submissions back to here, so
   // just assume whatever ends up in |request| gets submitted successfully.
   GetDeviceStatus(request);
   OnSubmittedSuccessfully();
 }
 
 bool DeviceStatusCollector::GetDeviceStatus(
     em::DeviceStatusReportRequest* status) {
   if (report_activity_times_)
     GetActivityTimes(status);
 
   if (report_version_info_)
     GetVersionInfo(status);
 
   if (report_boot_mode_)
     GetBootMode(status);
 
   if (report_location_)
     GetLocation(status);
 
+  if (report_network_interfaces_)
+    GetNetworkInterfaces(status);
+
   return true;
 }
 
 bool DeviceStatusCollector::GetSessionStatus(
     em::SessionStatusReportRequest* status) {
   return false;
 }
 
 void DeviceStatusCollector::OnSubmittedSuccessfully() {
   TrimStoredActivityPeriods(last_reported_day_, duration_for_last_reported_day_,
@@ skipping 66 matching lines @@
     location.SetDouble(kSpeed, position.speed);
     location.SetString(kTimestamp,
         base::Int64ToString(position.timestamp.ToInternalValue()));
     local_state_->Set(prefs::kDeviceLocation, location);
   }
 
   ScheduleGeolocationUpdateRequest();
 }
 
 }  // namespace policy