Source release v2.1.2-0-773 + third_party libs

Change-Id: Ia07608577b65b301c22a8ff4bf7f743c2d3f9274

core/src/cdm_engine.cpp

@@ -6,6 +6,8 @@
 #include <sstream>
 
 #include "cdm_session.h"
+#include "clock.h"
+#include "device_files.h"
 #include "license_protocol.pb.h"
 #include "log.h"
 #include "properties.h"
@@ -14,14 +16,24 @@
 #include "wv_cdm_constants.h"
 #include "wv_cdm_event_listener.h"
 
+namespace {
+  const uint32_t kUpdateUsageInformationPeriod = 60;  // seconds
+  const size_t kMinNoncesPerSession = 4;
+}  // unnamed namespace
+
 namespace wvcdm {
 
 CdmEngine::CdmEngine()
-    : cert_provisioning_requested_security_level_(kLevelDefault) {
+    : cert_provisioning_requested_security_level_(kLevelDefault),
+      usage_session_(NULL),
+      last_usage_information_update_time(0) {
   Properties::Init();
 }
 
 CdmEngine::~CdmEngine() {
+  if (NULL != usage_session_)
+    delete usage_session_;
+
   CdmSessionMap::iterator i(sessions_.begin());
   for (; i != sessions_.end(); ++i) {
     delete i->second;
@@ -478,13 +490,87 @@ CdmResponseType CdmEngine::HandleProvisioningResponse(
                                                        wrapped_key);
 }
 
-CdmResponseType CdmEngine::GetSecureStops(
-    CdmSecureStops* secure_stops) {
+CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
+  DeviceFiles handle;
+  if (!handle.Init(security_level)) {
+    LOGE("CdmEngine::Unprovision: unable to initialize device files");
+    return UNKNOWN_ERROR;
+  }
+
+  if (!handle.DeleteAllFiles()) {
+    LOGE("CdmEngine::Unprovision: unable to delete files");
+    return UNKNOWN_ERROR;
+  }
   return NO_ERROR;
 }
 
-CdmResponseType CdmEngine::ReleaseSecureStops(
-    const CdmSecureStopReleaseMessage& message) {
+CdmResponseType CdmEngine::GetUsageInfo(CdmUsageInfo* usage_info) {
+  if (NULL == usage_session_) {
+    usage_session_ = new CdmSession(NULL);
+  }
+
+  CdmResponseType status = usage_session_->Init();
+  if (NO_ERROR != status) {
+    LOGE("CdmEngine::GetUsageInfo: session init error");
+    return status;
+  }
+
+  DeviceFiles handle;
+  if (!handle.Init(usage_session_->GetSecurityLevel())) {
+    LOGE("CdmEngine::GetUsageInfo: unable to initialize device files");
+    return status;
+  }
+
+  std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> > license_info;
+  if (!handle.RetrieveUsageInfo(&license_info)) {
+    LOGE("CdmEngine::GetUsageInfo: unable to read usage information");
+    return UNKNOWN_ERROR;
+  }
+
+  if (0 == license_info.size()) {
+    usage_info->resize(0);
+    return NO_ERROR;
+  }
+
+  std::string server_url;
+  // rate limit secure stop messages based on minimum nonce
+  // table size per session
+  usage_info->resize(license_info.size() >= kMinNoncesPerSession - 1
+                         ? kMinNoncesPerSession - 1
+                         : license_info.size());
+  for (size_t i = 0; i < usage_info->size(); ++i) {
+    status = usage_session_->RestoreUsageSession(license_info[i].first,
+                                                 license_info[i].second);
+    if (KEY_ADDED != status) {
+      LOGE("CdmEngine::GetUsageInfo: restore usage session error: %ld",
+           status);
+      usage_info->clear();
+      return status;
+    }
+    status = usage_session_->GenerateReleaseRequest(&(*usage_info)[i],
+                                                    &server_url);
+    if (KEY_MESSAGE != status) {
+      LOGE("CdmEngine::GetUsageInfo: generate release request error: %ld",
+           status);
+      usage_info->clear();
+      return status;
+    }
+  }
+  return KEY_MESSAGE;
+}
+
+CdmResponseType CdmEngine::ReleaseUsageInfo(
+    const CdmUsageInfoReleaseMessage& message) {
+  if (NULL == usage_session_) {
+    LOGE("CdmEngine::ReleaseUsageInfo: cdm session not initialized");
+    return UNKNOWN_ERROR;
+  }
+
+  CdmResponseType status = usage_session_->ReleaseKey(message);
+  if (NO_ERROR != status) {
+    LOGE("CdmEngine::ReleaseUsageInfo: release key error: %ld", status);
+    return UNKNOWN_ERROR;
+  }
   return NO_ERROR;
 }
 
@@ -527,8 +613,8 @@ CdmResponseType CdmEngine::Decrypt(
   }
   if (iter == sessions_.end()) {
     LOGE("CdmEngine::Decrypt: session not found: id=%s, id size=%d",
-         session_id.size(),
-         session_id.c_str());
+         session_id.c_str(),
+         session_id.size());
     return KEY_ERROR;
   }
 
@@ -604,9 +690,31 @@ bool CdmEngine::ValidateKeySystem(const CdmKeySystem& key_system) {
 }
 
 void CdmEngine::OnTimerEvent() {
+  Clock clock;
+  uint64_t current_time = clock.GetCurrentTime();
+  bool update_usage_information = false;
+
+  if (current_time - last_usage_information_update_time >
+      kUpdateUsageInformationPeriod) {
+    update_usage_information = true;
+    last_usage_information_update_time = current_time;
+  }
+
   for (CdmSessionMap::iterator iter = sessions_.begin();
-       iter != sessions_.end(); ++iter) {
+      iter != sessions_.end(); ++iter) {
     iter->second->OnTimerEvent();
+
+    if (update_usage_information && iter->second->is_usage_update_needed()) {
+      // usage is updated for all sessions so this needs to be
+      // called only once per update usage information period
+      CdmResponseType status = iter->second->UpdateUsageInformation();
+      if (NO_ERROR != status) {
+        LOGW("Update usage information failed: %u", status);
+      } else {
+        update_usage_information = false;
+      }
+    }
+    iter->second->reset_is_usage_update_needed();
   }
 }