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 *kFlimflamServiceConnectivityStateProperty =
+    "ConnectivityState";
 static const char *kFlimflamServiceDeviceProperty = "Device";
 static const char *kFlimflamServiceStateProperty = "State";
 static const char *kFlimflamServiceTypeProperty = "Type";
 static const char *kFlimflamServiceUsageUrlProperty = "Cellular.UsageUrl";
 
+// Flimflam Service on-the-wire ConnectivityState values
+static const char *kFlimflamServiceConnectivityStateUnknown = "unknown";
+static const char *kFlimflamServiceConnectivityStateRestricted = "restricted";
+static const char *kFlimflamServiceConnectivityStateUnrestricted =
+    "unrestricted";
+static const char *kFlimflamServiceConnectivityStateNone = "none";
+
 // 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 =
     "activation-failure";
@@ skipping 31 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),
+      connectivity_state_(kConnectivityStateUnknown) {
   // 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;
 }
 
+Service::ConnectivityState Service::GetConnectivityState() const {
+  return connectivity_state_;
+}
+
 // 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 == kFlimflamServiceConnectivityStateProperty) {
+    OnConnectivityStateUpdate(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 == 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);
+  DLOG(INFO) << path_
+      << ": OnByteCounterUpdate: updated plan state: data bytes used = "
+      << active_plan->GetDataBytesUsed() << ", local byes used = "
+      << active_plan->GetLocalBytesUsed();
+  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 be combined with flimflam's
+    // ConnectivityState property to arrive at a conclusion.
+
   } 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 30 matching lines @@
 bool Service::RetryingGetProperties() const {
   return retrying_get_properties_;
 }
 
 void Service::OnRetryingGetProperties(bool retrying) {
   retrying_get_properties_ = retrying;
 }
 
 // Private methods
 
-Service::State Service::StateFromString(const std::string& state) const {
+// static
+Service::ConnectivityState Service::ConnectivityStateFromString(
+    const std::string& connectivity_state) {
+  if (connectivity_state == kFlimflamServiceConnectivityStateUnknown) {
+    return kConnectivityStateUnknown;
+  }
+  if (connectivity_state == kFlimflamServiceConnectivityStateRestricted) {
+    return kConnectivityStateRestricted;
+  }
+  if (connectivity_state == kFlimflamServiceConnectivityStateUnrestricted) {
+    return kConnectivityStateUnrestricted;
+  }
+  if (connectivity_state == kFlimflamServiceConnectivityStateNone) {
+    return kConnectivityStateNone;
+  }
+  return kConnectivityStateUnknown;
+}
+
+// static
+Service::State Service::StateFromString(const std::string& state) {
   if (state == kFlimflamServiceStateIdle) {
     return kStateIdle;
   }
   if (state == kFlimflamServiceStateCarrier) {
     return kStateCarrier;
   }
   if (state == kFlimflamServiceStateAssociation) {
     return kStateAssociation;
   }
   if (state == kFlimflamServiceStateConfiguration) {
@@ skipping 35 matching lines @@
   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::OnConnectivityStateUpdate(const std::string& connectivity_state) {
+  DLOG(INFO) << path_ << ": OnConnectivityStateUpdate: connectivity_state = "
+      << connectivity_state;
+  Service::ConnectivityState new_connectivity_state =
+      ConnectivityStateFromString(connectivity_state);
+  if (connectivity_state_ == new_connectivity_state) {
+    return;
+  }
+  connectivity_state_ = new_connectivity_state;
+  ReconsiderSendingUsageRequests();
+}
+
 void Service::OnStateUpdate(const std::string& state) {
   DLOG(INFO) << path_ << ": OnStateUpdate: state = " << state;
   Service::State old_state = state_;
   state_ = StateFromString(state);
   if (old_state != kStateReady && IsConnected()) {
     OnConnected();
   } else if (old_state == kStateReady && !IsConnected()) {
     OnDisconnected();
   }
 }
@@ skipping 106 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";
   }
+  // flimflam docs re: ConnectivityState: "This state is currently only
+  // computed for services of type Cellular"
+  it = properties.find(kFlimflamServiceConnectivityStateProperty);
+  if (it != properties.end()) {
+    const DBus::Variant& value = static_cast<DBus::Variant>(it->second);
+    OnConnectivityStateUpdate(value.reader().get_string());
+  } else {
+    DLOG(WARNING) << path_
+        << ": GetServiceProperties: no ConnectivityState 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;
+  }
+  // TODO(vlaviano): this is a blunt way to ensure that we don't count local
+  // traffic if we're already in the restricted pool when cashew starts
+  if (GetConnectivityState() == kConnectivityStateRestricted) {
+    DLOG(INFO) << path_ << ": ShouldSendUsageRequests: no: in restricted pool";
+    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