Merges to android Pi release (part 3)

These are a set of CLs merged from the wv cdm repo to the android repo. * Add CDM status return for decrypt blocked by HDCP. Author: Gene Morgan <gmorgan@google.com> [ Merge of http://go/wvgerrit/28062 ] New status code is kKeyUsageBlockedByPolicy. It is returned by the decrypt() call instead of kDecryptError or kNoKey. Also shuffled the CDM status returns to define the EME-aligned codes first, and added comments to highlight the differences in handling. BUG: 37540672 * Change division and mod ops to relocatables Author: Srujan Gaddam <srujzs@google.com> [ Merge of http://go/wvgerrit/28600 ] This is similar to I2dad1028acf295288cd10817a2bcff2513c053c9. We should be using the relocatable functions instead of the native division and mod operations. * Cleanup Encrypted ClientID in provisioning request Author: Gene Morgan <gmorgan@google.com> [ Merge of http://go/wvgerrit/28083 ] b/36897239 Staging server does not support it (or the client is not constructing it properly). Leave it disabled pending investigation. * Certificate Provisioning fixes. Author: Gene Morgan <gmorgan@google.com> [ Merge of http://go/wvgerrit/28066 ] Partial fix for BUG: 37482676 Partial fix for BUG: 37481392 Update service certificates, get rid of DEV/QA root certificate. Provisioning request and response are base64 (web-safe) encoded. Response is optionally JSON-wrapped. Change ConfigTestEnv; clearer comments and a closer match to reality. BUG: 71650075 Test: Not currently passing. Will be addressed in a subsequent commit in the chain. Change-Id: I79d3c4bf1124e5e0d3e4d40baead65a8266ea874
2018-01-09 15:43:41 -08:00
parent 387147dffe
commit 11068accd2
30 changed files with 902 additions and 920 deletions
--- a/libwvdrmengine/cdm/core/src/device_files.cpp
+++ b/libwvdrmengine/cdm/core/src/device_files.cpp
@@ -41,6 +41,8 @@ using video_widevine_client::sdk::
    UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE;
 using video_widevine_client::sdk::
    UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO;
+using video_widevine_client::sdk::
+    UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN;

 using video_widevine::SignedDrmDeviceCertificate;
 using video_widevine::DrmDeviceCertificate;
@@ -218,7 +220,8 @@ bool DeviceFiles::StoreLicense(
    const std::string& release_server_url, int64_t playback_start_time,
    int64_t last_playback_time, int64_t grace_period_end_time,
    const CdmAppParameterMap& app_parameters,
-    const CdmUsageEntry& usage_entry) {
+    const CdmUsageEntry& usage_entry,
+    const uint32_t usage_entry_number) {
  if (!initialized_) {
    LOGW("DeviceFiles::StoreLicense: not initialized");
    return false;
@@ -260,6 +263,7 @@ bool DeviceFiles::StoreLicense(
    app_params->set_value(iter->second);
  }
  license->set_usage_entry(usage_entry);
+  license->set_usage_entry_number(usage_entry_number);

  std::string serialized_file;
  file.SerializeToString(&serialized_file);
@@ -274,7 +278,8 @@ bool DeviceFiles::RetrieveLicense(
    CdmKeyMessage* license_renewal_request, CdmKeyResponse* license_renewal,
    std::string* release_server_url, int64_t* playback_start_time,
    int64_t* last_playback_time, int64_t* grace_period_end_time,
-    CdmAppParameterMap* app_parameters, CdmUsageEntry* usage_entry) {
+    CdmAppParameterMap* app_parameters, CdmUsageEntry* usage_entry,
+    uint32_t* usage_entry_number) {
  if (!initialized_) {
    LOGW("DeviceFiles::RetrieveLicense: not initialized");
    return false;
@@ -329,6 +334,7 @@ bool DeviceFiles::RetrieveLicense(
        license.app_parameters(i).value();
  }
  *usage_entry = license.usage_entry();
+  *usage_entry_number = license.usage_entry_number();
  return true;
 }

@@ -422,21 +428,21 @@ bool DeviceFiles::UnreserveLicenseId(const std::string& key_set_id) {
 bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
                                 const CdmKeyMessage& key_request,
                                 const CdmKeyResponse& key_response,
-                                 const std::string& app_id,
+                                 const std::string& usage_info_file_name,
                                 const std::string& key_set_id,
-                                 const CdmUsageEntry& usage_entry) {
+                                 const std::string& usage_entry,
+                                 uint32_t usage_entry_number) {
  if (!initialized_) {
    LOGW("DeviceFiles::StoreUsageInfo: not initialized");
    return false;
  }

  video_widevine_client::sdk::File file;
-  std::string file_name = GetUsageInfoFileName(app_id);
-  if (!FileExists(file_name)) {
+  if (!FileExists(usage_info_file_name)) {
    file.set_type(video_widevine_client::sdk::File::USAGE_INFO);
    file.set_version(video_widevine_client::sdk::File::VERSION_1);
  } else {
-    if (!RetrieveHashedFile(file_name, &file)) {
+    if (!RetrieveHashedFile(usage_info_file_name, &file)) {
      LOGW("DeviceFiles::StoreUsageInfo: Unable to parse file");
      return false;
    }
@@ -451,10 +457,11 @@ bool DeviceFiles::StoreUsageInfo(const std::string& provider_session_token,
  provider_session->set_license(key_response.data(), key_response.size());
  provider_session->set_key_set_id(key_set_id.data(), key_set_id.size());
  provider_session->set_usage_entry(usage_entry);
+  provider_session->set_usage_entry_number(usage_entry_number);

  std::string serialized_file;
  file.SerializeToString(&serialized_file);
-  return StoreFileWithHash(file_name, serialized_file);
+  return StoreFileWithHash(usage_info_file_name, serialized_file);
 }

 bool DeviceFiles::ListUsageRecords(const std::string& app_id,
@@ -528,15 +535,14 @@ bool DeviceFiles::GetProviderSessionToken(const std::string& app_id,
  return false;
 }

-bool DeviceFiles::DeleteUsageInfo(const std::string& app_id,
+bool DeviceFiles::DeleteUsageInfo(const std::string& usage_info_file_name,
                                  const std::string& provider_session_token) {
  if (!initialized_) {
    LOGW("DeviceFiles::DeleteUsageInfo: not initialized");
    return false;
  }
  video_widevine_client::sdk::File file;
-  std::string file_name = GetUsageInfoFileName(app_id);
-  if (!RetrieveHashedFile(file_name, &file)) return false;
+  if (!RetrieveHashedFile(usage_info_file_name, &file)) return false;

  UsageInfo* usage_info = file.mutable_usage_info();
  int index = 0;
@@ -565,11 +571,11 @@ bool DeviceFiles::DeleteUsageInfo(const std::string& app_id,

  std::string serialized_file;
  file.SerializeToString(&serialized_file);
-  return StoreFileWithHash(file_name, serialized_file);
+  return StoreFileWithHash(usage_info_file_name, serialized_file);
 }

 bool DeviceFiles::DeleteAllUsageInfoForApp(
-    const std::string& app_id,
+    const std::string& usage_info_file_name,
    std::vector<std::string>* provider_session_tokens) {
  if (!initialized_) {
    LOGW("DeviceFiles::DeleteAllUsageInfoForApp: not initialized");
@@ -581,22 +587,21 @@ bool DeviceFiles::DeleteAllUsageInfoForApp(
  }
  provider_session_tokens->clear();

-  std::string file_name = GetUsageInfoFileName(app_id);
-  if (!FileExists(file_name)) return true;
+  if (!FileExists(usage_info_file_name)) return true;

  video_widevine_client::sdk::File file;
-  if (RetrieveHashedFile(file_name, &file)) {
+  if (RetrieveHashedFile(usage_info_file_name, &file)) {
    for (int i = 0; i < file.usage_info().sessions_size(); ++i) {
      provider_session_tokens->push_back(file.usage_info().sessions(i).token());
    }
  } else {
    LOGW("DeviceFiles::DeleteAllUsageInfoForApp: Unable to retrieve file");
  }
-  return RemoveFile(file_name);
+  return RemoveFile(usage_info_file_name);
 }

 bool DeviceFiles::RetrieveUsageInfo(
-    const std::string& app_id,
+    const std::string& usage_info_file_name,
    std::vector<std::pair<CdmKeyMessage, CdmKeyResponse> >* usage_info) {
  if (!initialized_) {
    LOGW("DeviceFiles::RetrieveUsageInfo: not initialized");
@@ -610,14 +615,14 @@ bool DeviceFiles::RetrieveUsageInfo(
    return false;
  }

-  std::string file_name = GetUsageInfoFileName(app_id);
-  if (!FileExists(file_name) || GetFileSize(file_name) == 0) {
+  if (!FileExists(usage_info_file_name) ||
+      GetFileSize(usage_info_file_name) == 0) {
    usage_info->resize(0);
    return true;
  }

  video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(file_name, &file)) {
+  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
    LOGW("DeviceFiles::RetrieveUsageInfo: Unable to parse file");
    return false;
  }
@@ -632,19 +637,19 @@ bool DeviceFiles::RetrieveUsageInfo(
  return true;
 }

-bool DeviceFiles::RetrieveUsageInfo(const std::string& app_id,
+bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
                                    const std::string& provider_session_token,
                                    CdmKeyMessage* license_request,
                                    CdmKeyResponse* license_response,
-                                    CdmUsageEntry* usage_entry) {
+                                    std::string* usage_entry,
+                                    uint32_t* usage_entry_number) {
  if (!initialized_) {
    LOGW("DeviceFiles::RetrieveUsageInfo: not initialized");
    return false;
  }

-  std::string file_name = GetUsageInfoFileName(app_id);
  video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(file_name, &file)) {
+  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
    return false;
  }

@@ -654,6 +659,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& app_id,
      *license_request = file.usage_info().sessions(index).license_request();
      *license_response = file.usage_info().sessions(index).license();
      *usage_entry = file.usage_info().sessions(index).usage_entry();
+      *usage_entry_number =
+          file.usage_info().sessions(index).usage_entry_number();
      return true;
    }
  }
@@ -662,28 +669,32 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& app_id,
 }

 bool DeviceFiles::RetrieveUsageInfoByKeySetId(
-    const std::string& app_id,
+    const std::string& usage_info_file_name,
    const std::string& key_set_id,
+    std::string* provider_session_token,
    CdmKeyMessage* license_request,
    CdmKeyResponse* license_response,
-    CdmUsageEntry* usage_entry) {
+    std::string* usage_entry,
+    uint32_t* usage_entry_number) {
  if (!initialized_) {
    LOGW("DeviceFiles::RetrieveUsageInfoByKeySetId: not initialized");
    return false;
  }

-  std::string file_name = GetUsageInfoFileName(app_id);
  video_widevine_client::sdk::File file;
-  if (!RetrieveHashedFile(file_name, &file)) {
+  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
    return false;
  }

  int index = 0;
  for (; index < file.usage_info().sessions_size(); ++index) {
    if (file.usage_info().sessions(index).key_set_id() == key_set_id) {
+      *provider_session_token = file.usage_info().sessions(index).token();
      *license_request = file.usage_info().sessions(index).license_request();
      *license_response = file.usage_info().sessions(index).license();
      *usage_entry = file.usage_info().sessions(index).usage_entry();
+      *usage_entry_number =
+          file.usage_info().sessions(index).usage_entry_number();
      return true;
    }
  }
@@ -691,6 +702,97 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId(
  return false;
 }

+bool DeviceFiles::StoreUsageInfo(const std::string& usage_info_file_name,
+                                 const std::vector<CdmUsageData>& usage_data) {
+  if (!initialized_) {
+    LOGW("DeviceFiles::StoreUsageInfo: not initialized");
+    return false;
+  }
+
+  video_widevine_client::sdk::File file;
+  file.set_type(video_widevine_client::sdk::File::USAGE_INFO);
+  file.set_version(video_widevine_client::sdk::File::VERSION_1);
+
+  UsageInfo* usage_info = file.mutable_usage_info();
+  for (size_t i = 0; i < usage_data.size(); ++i) {
+    UsageInfo_ProviderSession* provider_session = usage_info->add_sessions();
+
+    provider_session->set_token(usage_data[i].provider_session_token.data(),
+                                usage_data[i].provider_session_token.size());
+    provider_session->set_license_request(usage_data[i].license_request.data(),
+                                          usage_data[i].license_request.size());
+    provider_session->set_license(usage_data[i].license.data(),
+                                  usage_data[i].license.size());
+    provider_session->set_key_set_id(usage_data[i].key_set_id.data(),
+                                     usage_data[i].key_set_id.size());
+    provider_session->set_usage_entry(usage_data[i].usage_entry);
+    provider_session->set_usage_entry_number(usage_data[i].usage_entry_number);
+  }
+
+  std::string serialized_file;
+  file.SerializeToString(&serialized_file);
+  return StoreFileWithHash(usage_info_file_name, serialized_file);
+}
+
+bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
+                                    std::vector<CdmUsageData>* usage_data) {
+
+  if (!initialized_) {
+    LOGW("DeviceFiles::RetrieveUsageInfo: not initialized");
+    return false;
+  }
+
+  video_widevine_client::sdk::File file;
+  if (!RetrieveHashedFile(usage_info_file_name, &file)) {
+    return false;
+  }
+
+  usage_data->resize(file.usage_info().sessions_size());
+  for (int i = 0; i < file.usage_info().sessions_size(); ++i) {
+    (*usage_data)[i].provider_session_token =
+        file.usage_info().sessions(i).token();
+    (*usage_data)[i].license_request =
+        file.usage_info().sessions(i).license_request();
+    (*usage_data)[i].license = file.usage_info().sessions(i).license();
+    (*usage_data)[i].key_set_id = file.usage_info().sessions(i).key_set_id();
+    (*usage_data)[i].usage_entry = file.usage_info().sessions(i).usage_entry();
+    (*usage_data)[i].usage_entry_number =
+      file.usage_info().sessions(i).usage_entry_number();
+  }
+
+  return false;
+}
+
+bool DeviceFiles::ListUsageInfoFiles(
+    std::vector<std::string>* usage_info_file_names) {
+  if (!initialized_) {
+    LOGW("DeviceFiles::ListUsageInfoFiles: not initialized");
+    return false;
+  }
+
+  // Get list of filenames
+  std::vector<std::string> filenames;
+  if (!ListFiles(&filenames)) {
+    return false;
+  }
+
+  // Scan list of all filenames and return only usage info filenames
+  usage_info_file_names->clear();
+  for (size_t i = 0; i < filenames.size(); i++) {
+    std::string* name = &filenames[i];
+    std::size_t pos_prefix = name->find(kUsageInfoFileNamePrefix);
+    std::size_t pos_suffix = name->find(kUsageInfoFileNameExt);
+    if (pos_prefix == std::string::npos ||
+        pos_suffix == std::string::npos) {
+      // Skip this file - extension does not match
+      continue;
+    }
+
+    usage_info_file_names->push_back(*name);
+  }
+  return true;
+}
+
 bool DeviceFiles::StoreHlsAttributes(
    const std::string& key_set_id, const CdmHlsMethod method,
    const std::vector<uint8_t>& media_segment_iv) {
@@ -790,7 +892,7 @@ bool DeviceFiles::DeleteHlsAttributes(const std::string& key_set_id) {

 bool DeviceFiles::StoreUsageTableInfo(
    const CdmUsageTableHeader& usage_table_header,
-    const std::vector<DeviceFiles::UsageEntryInfo>& usage_entry_info) {
+    const std::vector<CdmUsageEntryInfo>& usage_entry_info) {
  if (!initialized_) {
    LOGW("DeviceFiles::StoreUsageTableHeader: not initialized");
    return false;
@@ -807,23 +909,23 @@ bool DeviceFiles::StoreUsageTableInfo(
  for (size_t i = 0; i < usage_entry_info.size(); ++i) {
    UsageTableInfo_UsageEntryInfo* info =
        usage_table_info->add_usage_entry_info();
+    info->set_key_set_id(usage_entry_info[i].key_set_id);
    switch (usage_entry_info[i].storage_type) {
      case kStorageLicense:
        info->set_storage(
            UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE);
-        info->set_key_set_id(usage_entry_info[i].key_set_id);
        break;
      case kStorageUsageInfo:
        info->set_storage(
            UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO);
-        info->set_provider_session_token(
-            usage_entry_info[i].provider_session_token);
-        info->set_app_id(usage_entry_info[i].app_id);
+        info->set_usage_info_file_name(
+            usage_entry_info[i].usage_info_file_name);
        break;
+      case kStorageUnknown:
      default:
-        LOGW("DeviceFiles::StoreUsageTableHeader: unknown storage type: %d",
-             usage_entry_info[i].storage_type);
-        return false;
+        info->set_storage(
+            UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN);
+        break;
    }
  }

@@ -835,7 +937,7 @@ bool DeviceFiles::StoreUsageTableInfo(

 bool DeviceFiles::RetrieveUsageTableInfo(
    CdmUsageTableHeader* usage_table_header,
-    std::vector<DeviceFiles::UsageEntryInfo>* usage_entry_info) {
+    std::vector<CdmUsageEntryInfo>* usage_entry_info) {
  if (!initialized_) {
    LOGW("DeviceFiles::RetrieveUsageTableInfo: not initialized");
    return false;
@@ -879,21 +981,20 @@ bool DeviceFiles::RetrieveUsageTableInfo(
  for (int i = 0; i < usage_table_info.usage_entry_info_size(); ++i) {
    const UsageTableInfo_UsageEntryInfo& info =
        usage_table_info.usage_entry_info(i);
+    (*usage_entry_info)[i].key_set_id = info.key_set_id();
    switch (info.storage()) {
      case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE:
        (*usage_entry_info)[i].storage_type = kStorageLicense;
-        (*usage_entry_info)[i].key_set_id = info.key_set_id();
        break;
      case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO:
        (*usage_entry_info)[i].storage_type = kStorageUsageInfo;
-        (*usage_entry_info)[i].provider_session_token =
-            info.provider_session_token();
-        (*usage_entry_info)[i].app_id = info.app_id();
+        (*usage_entry_info)[i].usage_info_file_name =
+            info.usage_info_file_name();
        break;
+      case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN:
      default:
-        LOGW("DeviceFiles::RetrieveUsageTableInfo: Unknown storage type: %d",
-             info.storage());
-        return false;
+        (*usage_entry_info)[i].storage_type = kStorageUnknown;
+        break;
    }
  }