Backward compatibility for licenses and certificates

Certificates and offline licenses are stored in security level
specific directories in klp. When devices transition from jb-mr2,
their persistent information has to be ported to these directories.

bug:10366036

Merge of https://widevine-internal-review.googlesource.com/#/c/7310/
from the widevine CDM repo

Change-Id: I70b4a79dc5b69bda7fc3a4b92fdcde7ef8b41836

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -22,6 +22,8 @@ namespace {
 const char kCertificateFileName[] = "cert.bin";
 const char kLicenseFileNameExt[] = ".lic";
 const char kWildcard[] = "*";
+const char kPathDelimiter[] = "/";
+const char *kSecurityLevelPathCompatibilityExclusionList[] = { "ay64.dat" };
 }  // namespace
 
 namespace wvcdm {
@@ -90,6 +92,10 @@ bool DeviceFiles::RetrieveCertificate(std::string* certificate,
     return false;
   }
 
+  if (Properties::security_level_path_backward_compatibility_support()) {
+    SecurityLevelPathBackwardCompatibility();
+  }
+
   std::string serialized_hashed_file;
   if (!RetrieveFile(kCertificateFileName, &serialized_hashed_file))
     return false;
@@ -448,6 +454,65 @@ bool DeviceFiles::RetrieveFile(const char* name, std::string* data) {
   return true;
 }
 
+void DeviceFiles::SecurityLevelPathBackwardCompatibility() {
+  std::string path;
+  if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
+    LOGW("DeviceFiles::SecurityLevelPathBackwardCompatibility: Unable to "
+        "get base path");
+    return;
+  }
+
+  std::vector<std::string> security_dirs;
+  if (!Properties::GetSecurityLevelDirectories(&security_dirs)) {
+    LOGW("DeviceFiles::SecurityLevelPathBackwardCompatibility: Unable to "
+        "get security directories");
+    return;
+  }
+
+  size_t pos = std::string::npos;
+  for (size_t i = 0; i < security_dirs.size(); ++i) {
+    pos = path.rfind(security_dirs[i]);
+    if (std::string::npos != pos)
+      break;
+  }
+
+  if (pos == std::string::npos) {
+    LOGV("DeviceFiles::SecurityLevelPathBackwardCompatibility: Security level "
+        "specific path not found. Check properties?");
+    return;
+  }
+
+  std::string from_dir(path, 0, pos);
+
+  std::vector<std::string> files;
+  file_->List(from_dir, &files);
+
+  for (size_t i = 0; i < files.size(); ++i) {
+    std::string from = from_dir + files[i];
+    bool exclude = false;
+    for (size_t j = 0;
+         j < sizeof(kSecurityLevelPathCompatibilityExclusionList) /
+             sizeof(const char*);
+         j++) {
+      if (files[i].compare(kSecurityLevelPathCompatibilityExclusionList[j]) == 0) {
+        exclude = true;
+        break;
+      }
+    }
+    if (exclude) continue;
+    if (!file_->IsRegularFile(from)) continue;
+
+    for (size_t j = 0; j < security_dirs.size(); ++j) {
+      std::string to_dir = from_dir + security_dirs[j];
+      if (!file_->Exists(to_dir))
+        file_->CreateDirectory(to_dir);
+      std::string to = to_dir + files[i];
+      file_->Copy(from, to);
+    }
+    file_->Remove(from);
+  }
+}
+
 std::string DeviceFiles::GetCertificateFileName() {
   return kCertificateFileName;
 }

libwvdrmengine/cdm/core/src/properties.cpp

@@ -4,6 +4,10 @@
 #include "properties_configuration.h"
 #include "wv_cdm_constants.h"
 
+namespace {
+const char *kSecurityLevelDirs[] = { "L1/", "L3/" };
+}  // namespace
+
 namespace wvcdm {
 bool Properties::begin_license_usage_when_received_;
 bool Properties::require_explicit_renew_request_;
@@ -13,6 +17,7 @@ bool Properties::oem_crypto_use_userspace_buffers_;
 bool Properties::use_certificates_as_identification_;
 bool Properties::extract_pssh_data_;
 bool Properties::decrypt_with_empty_session_support_;
+bool Properties::security_level_path_backward_compatibility_support_;
 scoped_ptr<CdmClientPropertySetMap> Properties::session_property_set_;
 
 void Properties::Init() {
@@ -25,6 +30,7 @@ void Properties::Init() {
       kPropertyUseCertificatesAsIdentification;
   extract_pssh_data_ = kExtractPsshData;
   decrypt_with_empty_session_support_ = kDecryptWithEmptySessionSupport;
+  security_level_path_backward_compatibility_support_ = kSecurityLevelPathBackwardCompatibilitySupport;
   session_property_set_.reset(new CdmClientPropertySetMap());
 }
 
@@ -93,4 +99,13 @@ bool Properties::UsePrivacyMode(const CdmSessionId& session_id) {
   }
   return property_set->use_privacy_mode();
 }
+
+bool Properties::GetSecurityLevelDirectories(std::vector<std::string>* dirs) {
+  dirs->resize(sizeof(kSecurityLevelDirs)/sizeof(const char*));
+  for (size_t i = 0; i < dirs->size(); ++i) {
+    (*dirs)[i] = kSecurityLevelDirs[i];
+  }
+  return true;
+}
+
 }  // namespace wvcdm