Merge "Delete usage information on insufficient resources" into pi-dev am: b4b02e7762

am: 4540d4eba3

Change-Id: I617db9b5b8ee69681036456d8e2a7b4711b2d926

libwvdrmengine/cdm/core/include/device_files.h

@@ -129,6 +129,8 @@ class DeviceFiles {
       const std::string& usage_info_file_name,
       std::vector<std::string>* provider_session_tokens);
 
+  virtual bool DeleteAllUsageInfo();
+
   // Retrieve one usage info from the file.  Subsequent calls will retrieve
   // subsequent entries in the table for this app_id.
   virtual bool RetrieveUsageInfo(
@@ -186,6 +188,8 @@ class DeviceFiles {
       CdmUsageTableHeader* usage_table_header,
       std::vector<CdmUsageEntryInfo>* usage_entry_info);
 
+  virtual bool DeleteUsageTableInfo();
+
  private:
   // Extract serial number and system ID from DRM Device certificate
   bool ExtractDeviceInfo(const std::string& device_certificate,

libwvdrmengine/cdm/core/include/usage_table_header.h

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "crypto_session.h"
 #include "device_files.h"
 #include "file_store.h"
 #include "lock.h"
@@ -17,8 +18,6 @@
 
 namespace wvcdm {
 
-class CryptoSession;
-
 // Offline licenses/secure stops may be securely tracked using usage
 // tables (OEMCrypto v9-12) or usage table headers+usage entries
 // (OEMCrypto v13+). This class assists with the latter, synchronizing
@@ -117,6 +116,8 @@ class UsageTableHeader {
   // data-structures
   Lock usage_table_header_lock_;
 
+  metrics::CryptoMetrics alternate_crypto_metrics_;
+
   // Test related declarations
   friend class UsageTableHeaderTest;
 

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -2085,6 +2085,8 @@ CdmResponseType CryptoSession::LoadUsageEntry(
       return LOAD_USAGE_ENTRY_GENERATION_SKEW;
     case OEMCrypto_ERROR_SIGNATURE_FAILURE:
       return LOAD_USAGE_ENTRY_SIGNATURE_FAILURE;
+    case OEMCrypto_ERROR_INSUFFICIENT_RESOURCES:
+      return INSUFFICIENT_CRYPTO_RESOURCES_3;
     default:
       return LOAD_USAGE_ENTRY_UNKNOWN_ERROR;
   }

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -611,6 +611,15 @@ bool DeviceFiles::DeleteAllUsageInfoForApp(
   return RemoveFile(usage_info_file_name);
 }
 
+bool DeviceFiles::DeleteAllUsageInfo() {
+  if (!initialized_) {
+    LOGW("DeviceFiles::DeleteAllUsageInfo: not initialized");
+    return false;
+  }
+  return RemoveFile(kUsageInfoFileNamePrefix + std::string(kWildcard) +
+                    kUsageInfoFileNameExt);
+}
+
 bool DeviceFiles::RetrieveUsageInfo(
     const std::string& usage_info_file_name,
     std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> >* usage_info) {
@@ -1105,6 +1114,14 @@ bool DeviceFiles::RetrieveUsageTableInfo(
   return true;
 }
 
+bool DeviceFiles::DeleteUsageTableInfo() {
+  if (!initialized_) {
+    LOGW("DeviceFiles::DeleteUsageTableInfo: not initialized");
+    return false;
+  }
+  return RemoveFile(GetUsageTableFileName());
+}
+
 bool DeviceFiles::StoreFileWithHash(const std::string& name,
                                     const std::string& serialized_file) {
   // calculate SHA hash

libwvdrmengine/cdm/core/src/usage_table_header.cpp

@@ -11,6 +11,9 @@
 
 namespace {
 std::string kEmptyString;
+size_t kMaxCryptoRetries = 3;
+size_t kMinUsageEntriesSupported = 200;
+wvcdm::CdmKeySetId kDummyKeySetId = "DummyKsid";
 uint64_t kOldUsageEntryTimeSinceLicenseReceived = 0;
 uint64_t kOldUsageEntryTimeSinceFirstDecrypt = 0;
 uint64_t kOldUsageEntryTimeSinceLastDecrypt = 0;
@@ -58,14 +61,42 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
   }
 
   CdmResponseType status = USAGE_INFO_NOT_FOUND;
+  metrics::CryptoMetrics* metrics = crypto_session->GetCryptoMetrics();
+  if (metrics == NULL) metrics = &alternate_crypto_metrics_;
+
   if (file_handle_->RetrieveUsageTableInfo(&usage_table_header_,
                                             &usage_entry_info_)) {
     status = crypto_session->LoadUsageTableHeader(usage_table_header_);
+
+    // If the usage table header has been successfully loaded, and is at
+    // minimum capacity (>200), we need to make sure we can still add and
+    // remove entries. If not, clear files/data and recreate usage header table.
+    if (status == NO_ERROR) {
+      if (usage_entry_info_.size() > kMinUsageEntriesSupported) {
+        uint32_t temporary_usage_entry_number;
+        CdmResponseType result = AddEntry(crypto_session, true,
+                                          kDummyKeySetId, kEmptyString,
+                                          &temporary_usage_entry_number);
+        if (result == NO_ERROR) {
+          result = DeleteEntry(temporary_usage_entry_number,
+                               file_handle_.get(), metrics);
+        }
+        if (result != NO_ERROR) {
+          LOGE("UsageTableHeader::Init: Unable to create/delete new entry. "
+              "Clear usage entries, security level: %d, usage entries: %d",
+              security_level, usage_entry_info_.size());
+          status = result;
+        }
+      }
+    }
+
     if (status != NO_ERROR) {
       LOGE(
           "UsageTableHeader::Init: load usage table failed, security level: %d",
           security_level);
       file_handle_->DeleteAllLicenses();
+      file_handle_->DeleteAllUsageInfo();
+      file_handle_->DeleteUsageTableInfo();
       usage_entry_info_.clear();
       usage_table_header_.clear();
       status = crypto_session->CreateUsageTableHeader(&usage_table_header_);
@@ -77,11 +108,6 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
     if (status != NO_ERROR) return false;
     file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
 
-    metrics::CryptoMetrics alternate_metrics;
-    metrics::CryptoMetrics* metrics =
-        crypto_session->GetCryptoMetrics() != NULL ?
-        crypto_session->GetCryptoMetrics() : &alternate_metrics;
-
     UpgradeFromUsageTable(file_handle_.get(), metrics);
     file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
   }
@@ -95,11 +121,25 @@ CdmResponseType UsageTableHeader::AddEntry(
     const CdmKeySetId& key_set_id, const std::string& usage_info_file_name,
     uint32_t* usage_entry_number) {
   LOGV("UsageTableHeader::AddEntry: Lock");
-  AutoLock auto_lock(usage_table_header_lock_);
-  CdmResponseType status = crypto_session->CreateUsageEntry(usage_entry_number);
+
+  metrics::CryptoMetrics* metrics = crypto_session->GetCryptoMetrics();
+  if (metrics == NULL) metrics = &alternate_crypto_metrics_;
+
+  uint32_t retry_count = 0;
+  CdmResponseType status = NO_ERROR;
+  do {
+    {
+      AutoLock auto_lock(usage_table_header_lock_);
+      status = crypto_session->CreateUsageEntry(usage_entry_number);
+    }
+    if (status == INSUFFICIENT_CRYPTO_RESOURCES_3)
+      DeleteEntry(retry_count, file_handle_.get(), metrics);
+  } while (status == INSUFFICIENT_CRYPTO_RESOURCES_3 &&
+           ++retry_count < kMaxCryptoRetries);
 
   if (status != NO_ERROR) return status;
 
+  AutoLock auto_lock(usage_table_header_lock_);
   if (*usage_entry_number < usage_entry_info_.size()) {
     LOGE("UsageTableHeader::AddEntry: new entry %d smaller than table size: %d",
          *usage_entry_number, usage_entry_info_.size());
@@ -134,17 +174,34 @@ CdmResponseType UsageTableHeader::AddEntry(
 CdmResponseType UsageTableHeader::LoadEntry(CryptoSession* crypto_session,
                                             const CdmUsageEntry& usage_entry,
                                             uint32_t usage_entry_number) {
-  LOGV("UsageTableHeader::LoadEntry: Lock");
-  AutoLock auto_lock(usage_table_header_lock_);
+  {
+    LOGV("UsageTableHeader::LoadEntry: Lock");
+    AutoLock auto_lock(usage_table_header_lock_);
 
-  if (usage_entry_number >= usage_entry_info_.size()) {
-    LOGE(
-        "UsageTableHeader::LoadEntry: usage entry number %d larger than table "
-        "size: %d",
-        usage_entry_number, usage_entry_info_.size());
-    return USAGE_INVALID_LOAD_ENTRY;
+    if (usage_entry_number >= usage_entry_info_.size()) {
+      LOGE(
+          "UsageTableHeader::LoadEntry: usage entry number %d larger than "
+          "table size: %d",
+          usage_entry_number, usage_entry_info_.size());
+      return USAGE_INVALID_LOAD_ENTRY;
+    }
   }
-  return crypto_session->LoadUsageEntry(usage_entry_number, usage_entry);
+  metrics::CryptoMetrics* metrics = crypto_session->GetCryptoMetrics();
+  if (metrics == NULL) metrics = &alternate_crypto_metrics_;
+
+  uint32_t retry_count = 0;
+  CdmResponseType status = NO_ERROR;
+  do {
+    {
+      AutoLock auto_lock(usage_table_header_lock_);
+      status = crypto_session->LoadUsageEntry(usage_entry_number, usage_entry);
+    }
+    if (status == INSUFFICIENT_CRYPTO_RESOURCES_3)
+      DeleteEntry(retry_count, file_handle_.get(), metrics);
+  } while (status == INSUFFICIENT_CRYPTO_RESOURCES_3 &&
+           ++retry_count < kMaxCryptoRetries);
+
+  return status;
 }
 
 CdmResponseType UsageTableHeader::UpdateEntry(CryptoSession* crypto_session,