Merge "Allow offline release retries" into lmp-dev

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -76,7 +76,7 @@ CdmResponseType CdmEngine::OpenSession(
       cert_provisioning_requested_security_level_ =
           new_session->GetRequestedSecurityLevel();
     } else {
-      LOGE("CdmEngine::OpenSession: bad session init: %u", sts);
+      LOGE("CdmEngine::OpenSession: bad session init: %d", sts);
     }
     return sts;
   }
@@ -186,7 +186,7 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
     sts = iter->second->RestoreOfflineSession(key_set_id, kLicenseTypeRelease);
     if (sts != KEY_ADDED) {
       LOGE("CdmEngine::GenerateKeyRequest: key release restoration failed,"
-          "sts = %d", (int)sts);
+          "sts = %d", sts);
       return sts;
     }
   }
@@ -201,7 +201,7 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
           iter->second->GetRequestedSecurityLevel();
     }
     LOGE("CdmEngine::GenerateKeyRequest: key request generation failed, "
-        "sts = %d", (int)sts);
+        "sts = %d", sts);
     return sts;
   }
 
@@ -256,7 +256,7 @@ CdmResponseType CdmEngine::AddKey(
   CdmResponseType sts = iter->second->AddKey(key_data, key_set_id);
 
   if (KEY_ADDED != sts) {
-    LOGE("CdmEngine::AddKey: keys not added, result = %d", (int)sts);
+    LOGE("CdmEngine::AddKey: keys not added, result = %d", sts);
     return sts;
   }
 
@@ -328,7 +328,7 @@ CdmResponseType CdmEngine::GenerateRenewalRequest(
 
   if (KEY_MESSAGE != sts) {
     LOGE("CdmEngine::GenerateRenewalRequest: key request gen. failed, sts=%d",
-         (int)sts);
+         sts);
     return sts;
   }
 
@@ -353,7 +353,7 @@ CdmResponseType CdmEngine::RenewKey(
 
   CdmResponseType sts = iter->second->RenewKey(key_data);
   if (KEY_ADDED != sts) {
-    LOGE("CdmEngine::RenewKey: keys not added, sts=%d", (int)sts);
+    LOGE("CdmEngine::RenewKey: keys not added, sts=%d", sts);
     return sts;
   }
 
@@ -560,7 +560,7 @@ CdmResponseType CdmEngine::GetUsageInfo(CdmUsageInfo* usage_info) {
   status = usage_session_->RestoreUsageSession(license_info[index].first,
                                                 license_info[index].second);
   if (KEY_ADDED != status) {
-    LOGE("CdmEngine::GetUsageInfo: restore usage session (%d) error %ld",
+    LOGE("CdmEngine::GetUsageInfo: restore usage session (%u) error %d",
          index, status);
     usage_info->clear();
     return status;
@@ -569,7 +569,7 @@ CdmResponseType CdmEngine::GetUsageInfo(CdmUsageInfo* usage_info) {
   status = usage_session_->GenerateReleaseRequest(&(*usage_info)[0], &server_url);
 
   if (KEY_MESSAGE != status) {
-    LOGE("CdmEngine::GetUsageInfo: generate release request error: %ld",
+    LOGE("CdmEngine::GetUsageInfo: generate release request error: %d",
          status);
     usage_info->clear();
     return status;
@@ -586,7 +586,7 @@ CdmResponseType CdmEngine::ReleaseUsageInfo(
 
   CdmResponseType status = usage_session_->ReleaseKey(message);
   if (NO_ERROR != status) {
-    LOGE("CdmEngine::ReleaseUsageInfo: release key error: %ld", status);
+    LOGE("CdmEngine::ReleaseUsageInfo: release key error: %d", status);
   }
   return status;
 }
@@ -726,7 +726,7 @@ void CdmEngine::OnTimerEvent() {
       // called only once per update usage information period
       CdmResponseType status = iter->second->UpdateUsageInformation();
       if (NO_ERROR != status) {
-        LOGW("Update usage information failed: %u", status);
+        LOGW("Update usage information failed: %d", status);
       } else {
         update_usage_information = false;
       }

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -143,8 +143,12 @@ CdmResponseType CdmSession::RestoreOfflineSession(
     return UNKNOWN_ERROR;
   }
 
-  if (license_state != DeviceFiles::kLicenseStateActive) {
+  // Do not restore a released offline license, unless a release retry
-    LOGE("CdmSession::Init invalid offline license state = %s", license_state);
+  if (!(license_type == kLicenseTypeRelease ||
+       license_state == DeviceFiles::kLicenseStateActive)) {
+    LOGE("CdmSession::Init invalid offline license state = %d, type = %d",
+        license_state,
+        license_type);
     return UNKNOWN_ERROR;
   }
 

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -66,7 +66,11 @@ void CryptoSession::Init() {
 void CryptoSession::Terminate() {
   LOGV("CryptoSession::Terminate");
   AutoLock auto_lock(crypto_lock_);
-  session_count_ -= 1;
+  if (session_count_ > 0) {
+    session_count_ -= 1;
+  } else {
+    LOGE("CryptoSession::Terminate error, session count: %d", session_count_);
+  }
   if (session_count_ > 0 || !initialized_) return;
   OEMCryptoResult sts = OEMCrypto_Terminate();
   if (OEMCrypto_SUCCESS != sts) {
@@ -240,12 +244,18 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
   OEMCryptoResult sts = OEMCrypto_OpenSession(&sid, requested_security_level);
   if (OEMCrypto_SUCCESS == sts) {
     oec_session_id_ = static_cast<CryptoSessionId>(sid);
-    LOGV("OpenSession: id= %ld", (uint32_t)oec_session_id_);
+    LOGV("OpenSession: id= %d", (uint32_t)oec_session_id_);
     open_ = true;
   } else if (OEMCrypto_ERROR_TOO_MANY_SESSIONS == sts) {
+    LOGE("OEMCrypto_Open failed: %d, open sessions: %ld, initialized: %d",
+        sts, session_count_, (int)initialized_);
     return INSUFFICIENT_CRYPTO_RESOURCES;
   }
-  if (!open_) return UNKNOWN_ERROR;
+  if (!open_) {
+    LOGE("OEMCrypto_Open failed: %d, open sessions: %ld, initialized: %d",
+        sts, session_count_, (int)initialized_);
+    return UNKNOWN_ERROR;
+  }
 
   OEMCrypto_GetRandom(reinterpret_cast<uint8_t*>(&request_id_base_),
                       sizeof(request_id_base_));

libwvdrmengine/cdm/test/Android.mk

@@ -11,6 +11,10 @@ test_name := cdm_engine_test
 test_src_dir := ../core/test
 include $(LOCAL_PATH)/unit-test.mk
 
+test_name := cdm_session_unittest
+test_src_dir := ../core/test
+include $(LOCAL_PATH)/unit-test.mk
+
 test_name := device_files_unittest
 test_src_dir := ../core/test
 include $(LOCAL_PATH)/unit-test.mk

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -922,6 +922,42 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeyTest) {
   VerifyKeyRequestResponse(g_license_server, client_auth, false);
 }
 
+TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) {
+  // override default settings unless configured through the command line
+  std::string key_id;
+  std::string client_auth;
+  GetOfflineConfiguration(&key_id, &client_auth);
+
+  decryptor_.OpenSession(g_key_system, NULL, &session_id_);
+  GenerateKeyRequest(key_id, kLicenseTypeOffline);
+  VerifyKeyRequestResponse(g_license_server, client_auth, false);
+
+  CdmKeySetId key_set_id = key_set_id_;
+  EXPECT_FALSE(key_set_id_.empty());
+  decryptor_.CloseSession(session_id_);
+
+  session_id_.clear();
+  key_set_id_.clear();
+  decryptor_.OpenSession(g_key_system, NULL, &session_id_);
+  EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
+  decryptor_.CloseSession(session_id_);
+
+  session_id_.clear();
+  key_set_id_.clear();
+  GenerateKeyRelease(key_set_id);
+
+  session_id_.clear();
+  decryptor_.OpenSession(g_key_system, NULL, &session_id_);
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, decryptor_.RestoreKey(session_id_, key_set_id));
+  decryptor_.CloseSession(session_id_);
+
+  session_id_.clear();
+  key_set_id_.clear();
+  GenerateKeyRelease(key_set_id);
+  key_set_id_ = key_set_id;
+  VerifyKeyRequestResponse(g_license_server, client_auth, false);
+}
+
 TEST_F(WvCdmRequestLicenseTest, ExpiryOnReleaseOfflineKeyTest) {
   // override default settings unless configured through the command line
   std::string key_id;

libwvdrmengine/run_all_unit_tests.sh

@@ -14,6 +14,7 @@ adb shell /system/bin/policy_engine_unittest
 adb shell /system/bin/libwvdrmmediacrypto_test
 adb shell /system/bin/libwvdrmdrmplugin_test
 adb shell /system/bin/cdm_engine_test
+adb shell /system/bin/cdm_session_unittest
 adb shell /system/bin/file_store_unittest
 adb shell /system/bin/device_files_unittest
 adb shell /system/bin/timer_unittest