Source release v3.2.0

core/src/device_files.cpp

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "file_store.h"
+#include "license_protocol.pb.h"
 #include "log.h"
 #include "properties.h"
 #include "string_conversions.h"
@@ -35,6 +36,9 @@ using video_widevine_client::sdk::NameValue;
 using video_widevine_client::sdk::UsageInfo;
 using video_widevine_client::sdk::UsageInfo_ProviderSession;
 
+using video_widevine::SignedDrmDeviceCertificate;
+using video_widevine::DrmDeviceCertificate;
+
 namespace {
 
 const char kCertificateFileName[] = "cert.bin";
@@ -110,7 +114,9 @@ bool DeviceFiles::StoreCertificate(const std::string& certificate,
 }
 
 bool DeviceFiles::RetrieveCertificate(std::string* certificate,
-                                      std::string* wrapped_private_key) {
+                                      std::string* wrapped_private_key,
+                                      std::string* serial_number,
+                                      uint32_t* system_id) {
   if (!initialized_) {
     LOGW("DeviceFiles::RetrieveCertificate: not initialized");
     return false;
@@ -138,11 +144,55 @@ bool DeviceFiles::RetrieveCertificate(std::string* certificate,
 
   DeviceCertificate device_certificate = file.device_certificate();
 
+  ExtractDeviceInfo(device_certificate.certificate(), serial_number, system_id);
+
   *certificate = device_certificate.certificate();
   *wrapped_private_key = device_certificate.wrapped_private_key();
   return true;
 }
 
+bool DeviceFiles::ExtractDeviceInfo(const std::string& device_certificate,
+                                    std::string* serial_number,
+                                    uint32_t* system_id) {
+  LOGI("[WEM] ExtractDeviceInfo");
+  // Get serial number and system ID from certificate
+  if ((serial_number != NULL) || (system_id != NULL)) {
+    SignedDrmDeviceCertificate signed_drm_device_certificate;
+    if (!signed_drm_device_certificate.ParseFromString(device_certificate) ||
+        !signed_drm_device_certificate.has_drm_certificate()) {
+      LOGE("DeviceFiles::ExtractDeviceInfo: fails parsing signed drm device "
+           "certificate.");
+      return false;
+    }
+    DrmDeviceCertificate drm_device_certificate;
+    if (!drm_device_certificate.ParseFromString(
+            signed_drm_device_certificate.drm_certificate()) ||
+        (drm_device_certificate.type() !=
+         video_widevine::DrmDeviceCertificate::DRM_USER_DEVICE)) {
+      LOGE("DeviceFiles::ExtractDeviceInfo: fails parsing drm device "
+           "certificate message.");
+      return false;
+    }
+    if (serial_number != NULL) {
+      if (drm_device_certificate.has_serial_number()) {
+        LOGI("DeviceFiles::ExtractDeviceInfo: serial number: [%s]",
+             (b2a_hex(drm_device_certificate.serial_number())).c_str());
+        *serial_number = drm_device_certificate.serial_number();
+      }
+    }
+    if (system_id != NULL) {
+      if (drm_device_certificate.has_system_id()) {
+        LOGI("DeviceFiles::ExtractDeviceInfo: system id: [%d]",
+             drm_device_certificate.system_id());
+        *system_id = drm_device_certificate.system_id();
+      } else {
+        *system_id = 0;
+      }
+    }
+  }
+  return true;
+}
+
 bool DeviceFiles::HasCertificate() {
   if (!initialized_) {
     LOGW("DeviceFiles::HasCertificate: not initialized");
@@ -168,7 +218,8 @@ bool DeviceFiles::StoreLicense(
     const CdmKeyMessage& license_renewal_request,
     const CdmKeyResponse& license_renewal,
     const std::string& release_server_url, int64_t playback_start_time,
-    int64_t last_playback_time, const CdmAppParameterMap& app_parameters) {
+    int64_t last_playback_time, int64_t grace_period_end_time,
+    const CdmAppParameterMap& app_parameters) {
   if (!initialized_) {
     LOGW("DeviceFiles::StoreLicense: not initialized");
     return false;
@@ -201,6 +252,7 @@ bool DeviceFiles::StoreLicense(
   license->set_release_server_url(release_server_url);
   license->set_playback_start_time(playback_start_time);
   license->set_last_playback_time(last_playback_time);
+  license->set_grace_period_end_time(grace_period_end_time);
   NameValue* app_params;
   for (CdmAppParameterMap::const_iterator iter = app_parameters.begin();
        iter != app_parameters.end(); ++iter) {
@@ -221,7 +273,8 @@ bool DeviceFiles::RetrieveLicense(
     CdmKeyMessage* license_request, CdmKeyResponse* license_message,
     CdmKeyMessage* license_renewal_request, CdmKeyResponse* license_renewal,
     std::string* release_server_url, int64_t* playback_start_time,
-    int64_t* last_playback_time, CdmAppParameterMap* app_parameters) {
+    int64_t* last_playback_time, int64_t* grace_period_end_time,
+    CdmAppParameterMap* app_parameters) {
   if (!initialized_) {
     LOGW("DeviceFiles::RetrieveLicense: not initialized");
     return false;
@@ -270,6 +323,7 @@ bool DeviceFiles::RetrieveLicense(
   *release_server_url = license.release_server_url();
   *playback_start_time = license.playback_start_time();
   *last_playback_time = license.last_playback_time();
+  *grace_period_end_time = license.grace_period_end_time();
   for (int i = 0; i < license.app_parameters_size(); ++i) {
     (*app_parameters)[license.app_parameters(i).name()] =
         license.app_parameters(i).value();
@@ -285,6 +339,34 @@ bool DeviceFiles::DeleteLicense(const std::string& key_set_id) {
   return RemoveFile(key_set_id + kLicenseFileNameExt);
 }
 
+bool DeviceFiles::ListLicenses(std::vector<std::string>* key_set_ids) {
+  if (!initialized_) {
+    LOGW("DeviceFiles::DeleteAllLicenses: not initialized");
+    return false;
+  }
+
+  // Get list of filenames
+  std::vector<std::string> filenames;
+  if (!ListFiles(&filenames)) {
+    return false;
+  }
+
+  // Scan list of returned filenames, remove extension, and return
+  // as a list of key_set_ids.
+  key_set_ids->clear();
+  for (int i = 0; i < filenames.size(); i++) {
+    std::string* name = &filenames[i];
+    std::size_t pos = name->find(kLicenseFileNameExt);
+    if (pos == std::string::npos) {
+      // Skip this file - extension does not match
+      continue;
+    }
+    // Store filename (minus extension).  This should be a key set ID.
+    key_set_ids->push_back(name->substr(0, pos));
+  }
+  return true;
+}
+
 bool DeviceFiles::DeleteAllLicenses() {
   if (!initialized_) {
     LOGW("DeviceFiles::DeleteAllLicenses: not initialized");
@@ -688,7 +770,7 @@ bool DeviceFiles::RetrieveHashedFile(
 
   std::string path;
   if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
-    LOGW("DeviceFiles::StoreFileWithHash: Unable to get base path");
+    LOGW("DeviceFiles::RetrieveHashedFile: Unable to get base path");
     return false;
   }
 
@@ -765,6 +847,15 @@ bool DeviceFiles::FileExists(const std::string& name) {
   return file_system_->Exists(path);
 }
 
+bool DeviceFiles::ListFiles(std::vector<std::string>* names) {
+  std::string path;
+  if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {
+    LOGW("DeviceFiles::RemoveFile: Unable to get base path");
+    return false;
+  }
+  return file_system_->List(path, names);
+}
+
 bool DeviceFiles::RemoveFile(const std::string& name) {
   std::string path;
   if (!Properties::GetDeviceFilesBasePath(security_level_, &path)) {