cashew: support "usage requests allowed OTA only" policy

src/service.cc

 // Copyright (c) 2010 The Chromium OS 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 "src/service.h"
 
 #include <glog/logging.h>
 
 #include "src/data_plan_provider.h"
 #include "src/device.h"
@@ skipping 33 matching lines @@
 static const char *kCrosUsageVersionProperty = "version";
 static const char *kCrosUsageStatusProperty = "status";
 static const char *kCrosUsageRestrictedProperty = "restricted";
 static const char *kCrosUsagePlansProperty = "plans";
 
 // Chromium OS Usage API version values
 static const int kCrosUsageVersionMinSupported = 1;
 static const int kCrosUsageVersionMaxSupported = 1;
 
 // Chromium OS Usage API status values
+// NOTE: add new values to IsValidCrosUsageStatus below also
 static const char *kCrosUsageStatusOk = "OK";
 static const char *kCrosUsageStatusError = "ERROR";
 static const char *kCrosUsageStatusMalformedRequest = "MALFORMED REQUEST";
 static const char *kCrosUsageStatusInternalError = "INTERNAL ERROR";
 static const char *kCrosUsageStatusServiceUnavailable = "SERVICE UNAVAILABLE";
 static const char *kCrosUsageStatusRequestRefused = "REQUEST REFUSED";
 static const char *kCrosUsageStatusUnknownDevice = "UNKNOWN DEVICE";
 
 Service::Service(ServiceManager * const parent,
                  DBus::Connection& connection,  // NOLINT
                  const DBus::Path& path)
     : DBus::ObjectProxy(connection, path, kFlimflamServiceName),
       parent_(CHECK_NOTNULL(parent)), connection_(connection), path_(path),
       state_(kStateUnknown), type_(kTypeUnknown), device_(NULL),
       provider_(NULL), request_in_progress_(false),
-      update_timeout_source_(NULL), policy_(NULL) {
+      update_timeout_source_(NULL), policy_(NULL),
+      is_default_service_(false) {
   // init our state with a GetProperties() call to our Flimflam service path
   // we'll update this state by monitoring PropertyChanged signals
   GetServiceProperties();
 }
 
 Service::~Service() {
   DeleteCarrierState();
   DeleteDataPlans(&data_plans_);
   if (device_ != NULL) {
     DLOG(INFO) << path_ << ": deleting device " << device_->GetPath();
     delete device_;
     device_ = NULL;
   }
 }
 
 const DBus::Path& Service::GetPath() const {
   return path_;
 }
 
 Service::State Service::GetState() const {
   return state_;
 }
 
 Service::Type Service::GetType() const {
   return type_;
 }
 
+// static
+Service::Type Service::TypeFromString(const std::string& type) {
+  if (type == kFlimflamServiceTypeEthernet) {
+    return kTypeEthernet;
+  }
+  if (type == kFlimflamServiceTypeWifi) {
+    return kTypeWifi;
+  }
+  if (type == kFlimflamServiceTypeWimax) {
+    return kTypeWimax;
+  }
+  if (type == kFlimflamServiceTypeBluetooth) {
+    return kTypeBluetooth;
+  }
+  if (type == kFlimflamServiceTypeCellular) {
+    return kTypeCellular;
+  }
+  return kTypeUnknown;
+}
+
 Device* Service::GetDevice() const {
   return device_;
 }
 
 DBusDataPlanList Service::GetDBusDataPlans() const {
   DBusDataPlanList dbus_data_plans;
   DataPlanList::const_iterator it;
   for (it = data_plans_.begin(); it != data_plans_.end(); ++it) {
     DataPlan *plan = *it;
     DCHECK(plan != NULL);
     dbus_data_plans.push_back(plan->ToDBusFormat());
   }
   return dbus_data_plans;
 }
 
+bool Service::IsDefaultService() const {
+  if (is_default_service_) {
+    // cross-check with parent's idea of default technology
+    if (parent_->GetDefaultTechnology() != kTypeCellular) {
+      DLOG(WARNING) << path_ << ": IsDefaultService: "
+          << "service manager doesn't think default technology is cellular";
+    }
+    return true;
+  }
+  return false;
+}
+
 // Flimflam Service D-Bus Proxy methods
 
 void Service::PropertyChanged(const std::string& property_name,
                               const DBus::Variant& new_value) {
   DLOG(INFO) << path_ << ": PropertyChanged: property_name = " << property_name;
-  if (property_name.compare(kFlimflamServiceDeviceProperty) == 0) {
+  if (property_name == kFlimflamServiceDeviceProperty) {
     OnDeviceUpdate(new_value.reader().get_path());
-  } else if (property_name.compare(kFlimflamServiceStateProperty) == 0) {
+  } else if (property_name == kFlimflamServiceStateProperty) {
     OnStateUpdate(new_value.reader().get_string());
-  } else if (property_name.compare(kFlimflamServiceTypeProperty) == 0) {
+  } else if (property_name == kFlimflamServiceTypeProperty) {
     OnTypeUpdate(new_value.reader().get_string());
-  } else if (property_name.compare(kFlimflamServiceUsageUrlProperty) == 0) {
+  } else if (property_name == kFlimflamServiceUsageUrlProperty) {
     OnUsageUrlUpdate(new_value.reader().get_string());
   } else {
     // we don't care about this property
   }
 }
 
 // Device methods
 
 void Service::OnCarrierUpdate(const std::string& carrier) {
   DLOG(INFO) << path_ << ": OnCarrierUpdate: carrier = " << carrier;
   // NOTE: device_ can be NULL here because we may still be in Device ctor
-  DCHECK(device_ == NULL || carrier.compare(device_->GetCarrier()) == 0);
+  DCHECK(device_ == NULL || carrier == device_->GetCarrier());
 
   // get rid of state associated with old carrier
   if (provider_ != NULL) {
-    DCHECK(carrier.compare(provider_->GetCarrier()));
+    DCHECK(carrier != provider_->GetCarrier());
   }
   DeleteCarrierState();
 
   // if we don't have new carrier info, we can't do anything now
-  if (carrier.compare(Device::kCarrierUnknown) == 0) {
+  if (carrier == Device::kCarrierUnknown) {
     return;
   }
 
   // create state for new carrier
   DLOG(INFO) << path_ << ": OnCarrierUpdate: creating data plan provider";
   provider_ = new(std::nothrow) DataPlanProvider(carrier);
   if (provider_ == NULL) {
     LOG(ERROR) << path_
         << ": OnCarrierUpdate: could not create data plan provider";
     return;
   }
   provider_->SetDelegate(this);
   DLOG(INFO) << path_ << ": OnCarrierUpdate: getting policy for " << carrier;
   policy_ = Policy::GetPolicy(carrier);
   if (policy_ == NULL) {
     LOG(ERROR) << path_ << ": OnCarrierUpdate: could not get policy for "
         << carrier;
     DeleteCarrierState();
     return;
   }
 
   // if we already have usage url, set new provider in motion
   if (!usage_url_.empty()) {
     provider_->SetUsageUrl(usage_url_);
-    RequestUsageUpdate();
-    CreateUpdateTimer();
+    ReconsiderSendingUsageRequests();
   } else {
     // we'll do this later in OnUsageUrlUpdate
   }
 }
 
 // DataPlanProviderDelegate methods
 
 void Service::OnRequestComplete(const DataPlanProvider *provider,
                                 bool successful,
                                 const Value *parsed_usage_update) {
@@ skipping 99 matching lines @@
     DLOG(INFO) << path_ << ": OnRequestComplete: sending update";
     parent_->EmitDataPlansUpdate(*this);
   } else {
     DLOG(INFO) << path_ << ": OnRequestComplete: not sending update";
   }
 
   DLOG(INFO) << path_ << ": OnRequestComplete: deleting old data plans";
   DeleteDataPlans(&old_plans);
 }
 
+// Service Manager methods
+
+void Service::OnDefaultServiceUpdate(bool is_default_service) {
+  DCHECK(is_default_service_ == !is_default_service);
+  DLOG(INFO) << path_ << ": OnDefaultServiceUpdate: is_default_service = "
+      << is_default_service;
+  is_default_service_ = is_default_service;
+  if (is_default_service_) {
+    // we just became the default service
+    // cross-check with parent's idea of default technology
+    if (parent_->GetDefaultTechnology() != kTypeCellular) {
+      DLOG(WARNING) << path_ << ": OnDefaultServiceUpdate: "
+          << "service manager doesn't think default technology is cellular";
+    }
+  }
+  ReconsiderSendingUsageRequests();
+}
+
+void Service::OnFlimflamOnline() {
+  DLOG(INFO) << path_ << ": OnFlimflamOnline";
+  ReconsiderSendingUsageRequests();
+}
+
+void Service::OnFlimflamOffline() {
+  DLOG(INFO) << path_ << ": OnFlimflamOffline";
+  ReconsiderSendingUsageRequests();
+}
+
 // Private methods
 
 Service::State Service::StateFromString(const std::string& state) const {
-  if (state.compare(kFlimflamServiceStateIdle) == 0) {
+  if (state == kFlimflamServiceStateIdle) {
     return kStateIdle;
   }
-  if (state.compare(kFlimflamServiceStateCarrier) == 0) {
+  if (state == kFlimflamServiceStateCarrier) {
     return kStateCarrier;
   }
-  if (state.compare(kFlimflamServiceStateAssociation) == 0) {
+  if (state == kFlimflamServiceStateAssociation) {
     return kStateAssociation;
   }
-  if (state.compare(kFlimflamServiceStateConfiguration) == 0) {
+  if (state == kFlimflamServiceStateConfiguration) {
     return kStateConfiguration;
   }
-  if (state.compare(kFlimflamServiceStateReady) == 0) {
+  if (state == kFlimflamServiceStateReady) {
     return kStateReady;
   }
-  if (state.compare(kFlimflamServiceStateDisconnect) == 0) {
+  if (state == kFlimflamServiceStateDisconnect) {
     return kStateDisconnect;
   }
-  if (state.compare(kFlimflamServiceStateFailure) == 0) {
+  if (state == kFlimflamServiceStateFailure) {
     return kStateFailure;
   }
-  if (state.compare(kFlimflamServiceStateActivationFailure) == 0) {
+  if (state == kFlimflamServiceStateActivationFailure) {
     return kStateActivationFailure;
   }
   return kStateUnknown;
 }
 
-Service::Type Service::TypeFromString(const std::string& type) const {
-  if (type.compare(kFlimflamServiceTypeEthernet) == 0) {
-    return kTypeEthernet;
-  }
-  if (type.compare(kFlimflamServiceTypeWifi) == 0) {
-    return kTypeWifi;
-  }
-  if (type.compare(kFlimflamServiceTypeWimax) == 0) {
-    return kTypeWimax;
-  }
-  if (type.compare(kFlimflamServiceTypeBluetooth) == 0) {
-    return kTypeBluetooth;
-  }
-  if (type.compare(kFlimflamServiceTypeCellular) == 0) {
-    return kTypeCellular;
-  }
-  return kTypeUnknown;
-}
-
 void Service::OnDeviceUpdate(const DBus::Path& device_path) {
   DLOG(INFO) << path_ << ": OnDeviceUpdate: device_path = " << device_path;
 
   // if there's an existing device with a non-matching path: destroy it and
   // fall through to make a new one below.
-  if (device_ != NULL && device_->GetPath().compare(device_path)) {
+  if (device_ != NULL && device_->GetPath() != device_path) {
     LOG(WARNING) << path_ << ": OnDeviceUpdate: device path changed from "
         << device_->GetPath() << " to " << device_path;
     delete device_;
     device_ = NULL;
   }
 
   // if there's an existing device with matching path: all is well
   if (device_ != NULL) {
     return;
   }
 
   // if there's no existing device: make one
   device_ = new(std::nothrow) Device(this, connection_, device_path);
   if (device_ == NULL) {
     LOG(ERROR) << path_ << ": OnDeviceUpdate: couldn't create device for "
         << device_path;
     return;
   }
   DLOG(INFO) << path_ << ": OnDeviceUpdate: created device for "
       << device_path;
 }
 
 void Service::OnStateUpdate(const std::string& state) {
   DLOG(INFO) << path_ << ": OnStateUpdate: state = " << state;
+  Service::State old_state = state_;
   state_ = StateFromString(state);
-  // TODO(vlaviano): react to state changes
-  // note that ready does not necessarily mean that we're the default route
+  if (old_state != kStateReady && IsConnected()) {
+    OnConnected();
+  } else if (old_state == kStateReady && !IsConnected()) {
+    OnDisconnected();
+  }
 }
 
 void Service::OnTypeUpdate(const std::string& type) {
   DLOG(INFO) << path_ << ": OnTypeUpdate: type = " << type;
   type_ = TypeFromString(type);
   if (type_ != kTypeCellular) {
     LOG(WARNING) << path_ << ": OnTypeUpdate: type is not cellular!";
   }
 }
 
 void Service::OnUsageUrlUpdate(const std::string& usage_url) {
   DLOG(INFO) << path_ << ": OnUsageUrlUpdate: url = " << usage_url;
-  if (usage_url.compare(usage_url_) == 0) {
+  if (usage_url == usage_url_) {
     return;
   }
   usage_url_ = usage_url;
   if (provider_ != NULL) {
-    DCHECK(usage_url.compare(provider_->GetUsageUrl()));
-    DestroyUpdateTimer();
-    CancelPendingRequests();
+    DCHECK(usage_url != provider_->GetUsageUrl());
+    StopSendingUsageRequests();
     provider_->SetUsageUrl(usage_url);
-    RequestUsageUpdate();
-    CreateUpdateTimer();
+    ReconsiderSendingUsageRequests();
   }
 }
 
 void Service::GetServiceProperties() {
   DLOG(INFO) << path_ << ": GetServiceProperties";
   PropertyMap properties;
   // dbus-c++ throws exceptions
   // invoke the "Existing Non-conformant Code" clause of the style guide and
   // isolate the rest of the system from this
   try {
     // TODO(vlaviano): make this call asynchronous
     properties = GetProperties();
   } catch (DBus::Error& error) {  // NOLINT
     LOG(WARNING) << path_
         << ": GetServiceProperties: GetProperties() -> Exception: "
         << error.name() << ": " << error.message();
     // TODO(vlaviano): schedule another attempt later
     return;
   } catch (...) {  // NOLINT
     LOG(WARNING) << path_
         << ": GetServiceProperties: GetProperties() -> Exception";
     // TODO(vlaviano): schedule another attempt later
     return;
   }
-  DLOG(INFO) << "Received " << properties.size() << " properties";
+  DLOG(INFO) << path_ << ": GetServiceProperties: Received "
+      << properties.size() << " properties";
 
   // grab the properties in which we're interested
   PropertyMap::const_iterator it;
   it = properties.find(kFlimflamServiceDeviceProperty);
   if (it != properties.end()) {
     const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
     OnDeviceUpdate(value.reader().get_path());
   } else {
     DLOG(WARNING) << path_ << ": GetServiceProperties: no Device property";
   }
@@ skipping 52 matching lines @@
                                               data_bytes_max, data_bytes_used);
   if (plan == NULL) {
     LOG(ERROR) << path_ << ": AddHardcodedDataPlan: could not create plan";
     return;
   }
 
   data_plans_.push_back(plan);
 }
 
 void Service::RequestUsageUpdate() {
-  DCHECK(provider_ != NULL);
-  DCHECK(!usage_url_.empty());
-  DCHECK(device_ == NULL ||
-         device_->GetCarrier().compare(Device::kCarrierUnknown));
-
+  DCHECK(ShouldSendUsageRequests());
   if (request_in_progress_) {
+    DLOG(WARNING) << path_
+        << ": RequestUsageUpdate: request already in progress";
     return;
   }
-
-  // TODO(vlaviano): apply policy to determine if current connectivity state
-  // allows this request (e.g., if we can only make API requests over the
-  // cellular service itself, is this service the default route?)
-
   request_in_progress_ = true;
   if (!provider_->RequestUsageUpdate()) {
     DLOG(WARNING) << path_ << ": RequestUsageUpdate: request failed";
     request_in_progress_ = false;
   } else {
     DLOG(INFO) << path_ << ": RequestUsageUpdate: request succeeded";
   }
 }
 
 void Service::CancelPendingRequests() {
@@ skipping 44 matching lines @@
   }
 }
 
 void Service::DeleteCarrierState() {
   DLOG(INFO) << path_ << ": DeleteCarrierState";
   if (policy_ != NULL) {
     DLOG(INFO) << path_ << ": DeleteCarrierState: deleting policy";
     delete policy_;
     policy_ = NULL;
   }
-  DestroyUpdateTimer();
-  CancelPendingRequests();
+  StopSendingUsageRequests();
   if (provider_ != NULL) {
     DLOG(INFO) << path_ << ": DeleteCarrierState: deleting data plan provider";
     delete provider_;
     provider_ = NULL;
   }
 }
 
 bool Service::IsValidCrosUsageStatus(const std::string& status) const {
   if (status == kCrosUsageStatusOk ||
       status == kCrosUsageStatusError ||
       status == kCrosUsageStatusMalformedRequest ||
       status == kCrosUsageStatusInternalError ||
       status == kCrosUsageStatusServiceUnavailable ||
       status == kCrosUsageStatusRequestRefused ||
       status == kCrosUsageStatusUnknownDevice) {
     return true;
   }
   return false;
 }
 
 void Service::OnCrosUsageErrorResult(const std::string& status) {
   DLOG(WARNING) << path_ << ": OnCrosUsageErrorResult: " << status;
-  // TODO(vlaviano): take action based on which specific error status string
-  // we've received (e.g., we could adjust the update timer interval, or
-  // disable the timer entirely).
+  // TODO(vlaviano): hook for future use
+}
+
+bool Service::IsConnected() const {
+  if (state_ != kStateReady) {
+    return false;
+  }
+  // cross-check with parent Service Manager's idea of Flimflam global
+  // connectivity state
+  if (ServiceManager::IsOfflineConnectivityState(
+      parent_->GetConnectivityState())) {
+    DLOG(WARNING) << path_
+        << ": IsConnected: service manager thinks we're offline";
+    return false;
+  }
+  return true;
+}
+
+void Service::OnConnected() {
+  DLOG(INFO) << path_ << ": OnConnected";
+  DCHECK(IsConnected());
+  ReconsiderSendingUsageRequests();
+}
+
+void Service::OnDisconnected() {
+  DLOG(INFO) << path_ << ": OnDisconnected";
+  DCHECK(!IsConnected());
+  ReconsiderSendingUsageRequests();
+}
+
+bool Service::IsSendingUsageRequests() const {
+  return request_in_progress_ || update_timeout_source_ != NULL;
+}
+
+// NOTE: we centralize our decisionmaking here to avoid insanity and just call
+// ReconsiderSendingUsageRequests when anything changes
+bool Service::ShouldSendUsageRequests() const {
+  if (provider_ == NULL) {
+    DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: no provider";
+    DCHECK(policy_ == NULL);
+    return false;
+  }
+  DCHECK(device_ == NULL || device_->GetCarrier() != Device::kCarrierUnknown);
+  DCHECK(policy_ != NULL);
+  if (usage_url_.empty()) {
+    DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: no usage url";
+    return false;
+  }
+  if (ServiceManager::IsOfflineConnectivityState(
+      parent_->GetConnectivityState())) {
+    DLOG(INFO) << path_
+        << ": ShouldSendUsageRequests: no: flimflam is offline";
+    return false;
+  }
+  if (policy_->UsageRequestsMustBeSentOTA()) {
+    if (!IsConnected()) {
+      DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: "
+          << "ota-only policy and not connected";
+      return false;
+    }
+    if (!IsDefaultService()) {
+      DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: "
+          << "ota-only policy and not default service";
+      return false;
+    }
+  }
+  DLOG(INFO) << path_ << ": ShouldSendUsageRequests: yes";
+  return true;
+}
+
+void Service::StopSendingUsageRequests() {
+  DLOG(INFO) << path_ << ": StopSendingUsageRequests";
+  DestroyUpdateTimer();
+  CancelPendingRequests();
+}
+
+void Service::StartSendingUsageRequests() {
+  DLOG(INFO) << path_ << ": StartSendingUsageRequests";
+  DCHECK(!IsSendingUsageRequests());
+  RequestUsageUpdate();
+  CreateUpdateTimer();
+}
+
+void Service::ReconsiderSendingUsageRequests() {
+  DLOG(INFO) << path_ << ": ReconsiderSendingUsageRequests";
+  if (!IsSendingUsageRequests() && ShouldSendUsageRequests()) {
+    StartSendingUsageRequests();
+  } else if (IsSendingUsageRequests() && !ShouldSendUsageRequests()) {
+    StopSendingUsageRequests();
+  }
 }
 
 }  // namespace cashew