cashew: add local byte counters

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"
 #include "src/policy.h"
 #include "src/service_manager.h"
 
 namespace cashew {
 
 // Flimflam Service D-Bus identifiers
 static const char *kFlimflamServiceName = "org.chromium.flimflam";
 
 // Flimflam Service property names
 static const char *kFlimflamServiceDeviceProperty = "Device";
 static const char *kFlimflamServiceStateProperty = "State";
 static const char *kFlimflamServiceTypeProperty = "Type";
 static const char *kFlimflamServiceUsageUrlProperty = "Cellular.UsageUrl";
+static const char *kFlimflamServiceRestrictedPoolProperty =
+    "Cellular.RestrictedPool";
 
 // Flimflam Service on-the-wire State values
 static const char *kFlimflamServiceStateIdle = "idle";
 static const char *kFlimflamServiceStateCarrier = "carrier";
 static const char *kFlimflamServiceStateAssociation = "association";
 static const char *kFlimflamServiceStateConfiguration = "configuration";
 static const char *kFlimflamServiceStateReady = "ready";
 static const char *kFlimflamServiceStateDisconnect = "disconnect";
 static const char *kFlimflamServiceStateFailure = "failure";
 static const char *kFlimflamServiceStateActivationFailure =
@@ skipping 32 matching lines @@
 
 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),
       is_default_service_(false), get_properties_source_id_(0),
-      retrying_get_properties_(false) {
+      retrying_get_properties_(false), restricted_pool_(false) {
   // schedule a GetProperties() call to our Flimflam service path to init state
   // we'll keep trying periodically until we succeed
   // we'll subsequently update this state by monitoring PropertyChanged signals
   get_properties_source_id_ =
       g_idle_add(StaticGetServicePropertiesCallback, this);
   if (get_properties_source_id_ == 0) {
     LOG(ERROR) << path_ << ": ctor: g_idle_add failed";
   }
 }
 
@@ skipping 63 matching lines @@
     // 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;
 }
 
+bool Service::RestrictedPool() const {
+  // NOTE: For now, we rely strictly on the Cellular.RestrictedPool Flimflam
+  // Service property, and we ignore the optional 'restricted' boolean that's
+  // defined as part of the usage API.
+  return restricted_pool_;
+}
+
 // 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 == kFlimflamServiceDeviceProperty) {
     OnDeviceUpdate(new_value.reader().get_path());
   } else if (property_name == kFlimflamServiceStateProperty) {
     OnStateUpdate(new_value.reader().get_string());
   } else if (property_name == kFlimflamServiceTypeProperty) {
     OnTypeUpdate(new_value.reader().get_string());
   } else if (property_name == kFlimflamServiceUsageUrlProperty) {
     OnUsageUrlUpdate(new_value.reader().get_string());
+  } else if (property_name == kFlimflamServiceRestrictedPoolProperty) {
+    OnRestrictedPoolUpdate(new_value.reader().get_bool());
   } 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 == device_->GetCarrier());
+  DCHECK(device_ != NULL);
+  DCHECK(carrier == device_->GetCarrier());
 
   // get rid of state associated with old carrier
   if (provider_ != NULL) {
     DCHECK(carrier != provider_->GetCarrier());
   }
   DeleteCarrierState();
 
   // if we don't have new carrier info, we can't do anything now
-  if (carrier == Device::kCarrierUnknown) {
+  if (carrier.empty()) {
     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;
@@ skipping 10 matching lines @@
 
   // if we already have usage url, set new provider in motion
   if (!usage_url_.empty()) {
     provider_->SetUsageUrl(usage_url_);
     ReconsiderSendingUsageRequests();
   } else {
     // we'll do this later in OnUsageUrlUpdate
   }
 }
 
+void Service::OnByteCounterUpdate(uint64 rx_bytes, uint64 tx_bytes) {
+  DCHECK(device_ != NULL);
+  DCHECK(device_->ByteCounterRunning());
+  DLOG(INFO) << path_ << ": OnByteCounterUpdate: rx_bytes = " << rx_bytes
+      << ", tx_bytes = " << tx_bytes;
+  DataPlan *active_plan = DataPlan::GetActivePlan(data_plans_);
+  if (active_plan == NULL) {
+    DLOG(WARNING) << path_ << ": OnByteCounterUpdate: no active plan";
+    return;
+  }
+  Bytes local_bytes_used = rx_bytes + tx_bytes;
+  DLOG(INFO) << path_ << ": OnByteCounterUpdate: local_bytes_used = "
+      << local_bytes_used;
+  // try to detect two error conditions:
+  // (1) overflow of the unsigned addition above prior to the assignment
+  // (2) no overflow, but result has high order bit set and so is interpreted as
+  //     a negative number when assigned to |local_bytes_used|
+  if (local_bytes_used < 0 ||
+      static_cast<uint64>(local_bytes_used) < rx_bytes ||
+      static_cast<uint64>(local_bytes_used) < tx_bytes) {
+    LOG(WARNING) << path_ << ": OnByteCounterUpdate: overflow detected";
+    return;
+  }
+  active_plan->SetLocalBytesUsed(local_bytes_used);
+  MaybeEmitDataPlansUpdate();
+}
+
 // DataPlanProviderDelegate methods
 
 void Service::OnRequestComplete(const DataPlanProvider *provider,
                                 bool successful,
                                 const Value *parsed_usage_update) {
   DCHECK(provider != NULL);
   DCHECK(!successful || parsed_usage_update != NULL);
   if (provider != provider_) {
     DLOG(WARNING) <<  path_ << ": OnRequestComplete: wrong provider";
     return;
@@ skipping 42 matching lines @@
   }
   if (status != kCrosUsageStatusOk) {
     LOG(WARNING) << path_ << ": OnRequestComplete: status: " << status;
     OnCrosUsageErrorResult(status);
     return;
   }
 
   bool restricted = false;
   if (root->GetBoolean(kCrosUsageRestrictedProperty, &restricted)) {
     DLOG(INFO) << path_ << ": OnRequestComplete: restricted = " << restricted;
+    // TODO(vlaviano): this should probably take precedence over our
+    // Cellular.RestrictedPool property
   } else {
     DLOG(INFO) << path_ << ": OnRequestComplete: no restricted property";
     // restricted property is optional
   }
 
   ListValue *plans = NULL;  // list to which this points is owned by dictionary
   if (!root->GetList(kCrosUsagePlansProperty, &plans)) {
     LOG(WARNING) << path_ << ": OnRequestComplete: no plans property";
     return;
   }
@@ skipping 20 matching lines @@
     }
     DLOG(INFO) << path_ << ": OnRequestComplete: converted plan[" << i << "]";
     new_plans.push_back(plan);
   }
 
   // store new info, causing it to be used for subsequent updates to clients
   DataPlanList old_plans = data_plans_;
   data_plans_ = new_plans;
   LOG(INFO) << path_ << ": OnRequestComplete: updated data plans";
 
-  // consult policy to determine if we should send an unsolicited update
-  if (policy_->ShouldEmitDataPlansUpdate(old_plans, new_plans)) {
-    DLOG(INFO) << path_ << ": OnRequestComplete: sending update";
-    parent_->EmitDataPlansUpdate(*this);
-  } else {
-    DLOG(INFO) << path_ << ": OnRequestComplete: not sending update";
-  }
+  MaybeEmitDataPlansUpdate();
 
   DLOG(INFO) << path_ << ": OnRequestComplete: deleting old data plans";
   DeleteDataPlans(&old_plans);
+
+  // start local byte counter so that we can stop hitting usage API
+  // we'll stop the counter when we disconnect
+  // we don't bother if carrier told us that there are no active data plans
+  DataPlan *active_plan = DataPlan::GetActivePlan(data_plans_);
+  if (active_plan == NULL) {
+    DLOG(INFO) << path_
+        << ": OnRequestComplete: no active plans, not starting byte counter";
+    return;
+  }
+  DCHECK(device_ != NULL);
+  DCHECK(!device_->ByteCounterRunning());
+  if (!device_->StartByteCounter()) {
+    LOG(WARNING) << path_
+        << ": OnRequestComplete: could not start byte counter";
+    // we'll keep the update timer running and try again later
+  }
+  DLOG(INFO) << path_ << ": OnRequestComplete: started byte counter";
+  ReconsiderSendingUsageRequests();
 }
 
 // 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_) {
@@ skipping 119 matching lines @@
   }
   usage_url_ = usage_url;
   if (provider_ != NULL) {
     DCHECK(usage_url_ != provider_->GetUsageUrl());
     StopSendingUsageRequests();
     provider_->SetUsageUrl(usage_url_);
     ReconsiderSendingUsageRequests();
   }
 }
 
+void Service::OnRestrictedPoolUpdate(bool restricted_pool) {
+  DLOG(INFO) << path_ << ": OnRestrictedPoolUpdate: restricted_pool = "
+      << restricted_pool;
+  if (restricted_pool == restricted_pool_) {
+    return;
+  }
+  ReconsiderSendingUsageRequests();
+}
+
 // static
 gboolean Service::StaticGetServicePropertiesCallback(gpointer data) {
   Service *service = reinterpret_cast<Service*>(data);
   CHECK_NOTNULL(service);
   DCHECK_NE(service->GetGetPropertiesSourceId(), 0);
   if (!service->GetServiceProperties()) {
     // call failed, so try again later
     DLOG(WARNING) << service->GetPath()
         << ": StaticGetServicePropertiesCallback: "
         << "GetServiceProperties failed, will retry in "
@@ skipping 73 matching lines @@
     return true;
   }
   it = properties.find(kFlimflamServiceUsageUrlProperty);
   if (it != properties.end()) {
     const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
     OnUsageUrlUpdate(value.reader().get_string());
   } else {
     DLOG(WARNING) << path_
         << ": GetServiceProperties: no Cellular.UsageUrl property";
   }
+  it = properties.find(kFlimflamServiceRestrictedPoolProperty);
+  if (it != properties.end()) {
+    const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
+    OnRestrictedPoolUpdate(value.reader().get_bool());
+  } else {
+    DLOG(WARNING) << path_
+        << ": GetServiceProperties: no Cellular.RestrictedPool property";
+  }
   return true;
 }
 
 void Service::DeleteDataPlans(DataPlanList *data_plans) {
   DCHECK(data_plans != NULL);
   while (!data_plans->empty()) {
     DataPlan *plan = *data_plans->begin();
     DCHECK(plan != NULL);
     DLOG(INFO) << path_ << ": DeleteDataPlans: deleting plan: "
         << plan->GetName();
@@ skipping 138 matching lines @@
 
 void Service::OnConnected() {
   DLOG(INFO) << path_ << ": OnConnected";
   DCHECK(IsConnected());
   ReconsiderSendingUsageRequests();
 }
 
 void Service::OnDisconnected() {
   DLOG(INFO) << path_ << ": OnDisconnected";
   DCHECK(!IsConnected());
+  // stop byte counter
+  // we'll issue a new usage API request when we reconnect
+  if (device_ != NULL) {
+    device_->StopByteCounter();
+  }
   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(device_ != NULL);
+  DCHECK(!device_->GetCarrier().empty());
   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;
-    }
+  if (!IsConnected()) {
+    DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: not connected";
+    return false;
+  }
+  if (!IsDefaultService()) {
+    DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: not default service";
+    return false;
+  }
+  if (device_->ByteCounterRunning()) {
+    DLOG(INFO) << path_
+        << ": ShouldSendUsageRequests: no: local byte counter is running";
+    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();
   }
 }
 
+void Service::MaybeEmitDataPlansUpdate() {
+  DCHECK(policy_ != NULL);
+  if (policy_->ShouldEmitDataPlansUpdate(data_plans_)) {
+    DLOG(INFO) << path_ << ": MaybeEmitDataPlansUpdate: sending update";
+    parent_->EmitDataPlansUpdate(*this);
+  } else {
+    DLOG(INFO) << path_ << ": MaybeEmitDataPlansUpdate: not sending update";
+  }
+}
+
 }  // namespace cashew