Merge "Clean up oemcrypto dynamic adapter and add level 3 libraries"

libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp

@@ -73,7 +73,7 @@ typedef OEMCryptoResult (*L1_LoadKeys_t)(
     const uint8_t* enc_mac_key_iv, const uint8_t* enc_mac_key, size_t num_keys,
     const OEMCrypto_KeyObject* key_array, const uint8_t* pst,
     size_t pst_length, const uint8_t* srm_requirement);
-typedef OEMCryptoResult (*L1_LoadKeys_V12_t)(
+typedef OEMCryptoResult (*L1_LoadKeys_V11_or_V12_t)(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length,
     const uint8_t* enc_mac_key_iv, const uint8_t* enc_mac_key, size_t num_keys,
@@ -316,7 +316,7 @@ struct FunctionPointers {
   L1_GenerateRSASignature_V8_t GenerateRSASignature_V8;
   L1_GetHDCPCapability_V9_t GetHDCPCapability_V9;
   L1_LoadKeys_V9_or_V10_t LoadKeys_V9_or_V10;
-  L1_LoadKeys_V12_t LoadKeys_V12;
+  L1_LoadKeys_V11_or_V12_t LoadKeys_V11_or_V12;
   L1_DeactivateUsageEntry_V12_t DeactivateUsageEntry_V12;
 };
 
@@ -383,14 +383,24 @@ struct LevelSession {
 
 #define QUOTE_DEFINE(A) #A
 #define QUOTE(A) QUOTE_DEFINE(A)
-#define LOOKUP(Name, Function)                                           \
+// This macro looks up a function name, but only if the API version is in the
+// specified range.
+#define LOOKUP(min, max, Name, Function)                                \
+  if ((level1_.version >= min) && (level1_.version <= max)) {           \
     level1_.Name = (L1_##Name##_t)dlsym(level1_library_, QUOTE(Function)); \
     if (!level1_.Name) {                                                \
       LOGW("Could not load L1 %s. Falling Back to L3.",                 \
            QUOTE(Function));                                            \
       return false;                                                     \
+    }                                                                   \
   }
 
+// This macro looks up a function name, but only if the API version is above
+// the specified minimum.
+#define LOOKUP_ALL(min, Name, Function)                                \
+  LOOKUP(min, kMaximumVersion, Name, Function)
+
+
 // An Adapter keeps a block of FunctionPointers for the built-in level 3 and
 // the dynamically loaded level 1 oemcrypto.  When initialized, it tries to
 // load the level 1 library and verifies that all needed functions are present.
@@ -416,6 +426,8 @@ class Adapter {
      */
     wvcdm::metrics::MetricsGroup metrics;
 
+    level1_ = FunctionPointers();  // start with all null pointers.
+    level3_ = FunctionPointers();  // start with all null pointers.
     LoadLevel3();
     std::string base_path;
     wvcdm::Properties::GetDeviceFilesBasePath(wvcdm::kSecurityLevelL3,
@@ -473,30 +485,12 @@ class Adapter {
 
   bool LoadLevel1(wvcdm::metrics::MetricsGroup& metrics) {
     level1_valid_ = true;
-    LOOKUP(Initialize,               OEMCrypto_Initialize);
+    const uint32_t kMinimumVersion = 8;
-    LOOKUP(Terminate,                OEMCrypto_Terminate);
+    const uint32_t kMaximumVersion = 13;
-    LOOKUP(OpenSession,              OEMCrypto_OpenSession);
+    level1_.version = kMinimumVersion;
-    LOOKUP(CloseSession,             OEMCrypto_CloseSession);
+    LOOKUP_ALL(8, Initialize, OEMCrypto_Initialize);
-    LOOKUP(GenerateDerivedKeys,      OEMCrypto_GenerateDerivedKeys);
+    LOOKUP_ALL(8, APIVersion, OEMCrypto_APIVersion);
-    LOOKUP(GenerateNonce,            OEMCrypto_GenerateNonce);
+    LOOKUP_ALL(8, Terminate,  OEMCrypto_Terminate);
-    LOOKUP(GenerateSignature,        OEMCrypto_GenerateSignature);
-    LOOKUP(RefreshKeys,              OEMCrypto_RefreshKeys);
-    LOOKUP(SelectKey,                OEMCrypto_SelectKey);
-    LOOKUP(InstallKeybox,            OEMCrypto_InstallKeybox);
-    LOOKUP(IsKeyboxValid,            OEMCrypto_IsKeyboxValid);
-    LOOKUP(GetDeviceID,              OEMCrypto_GetDeviceID);
-    LOOKUP(GetKeyData,               OEMCrypto_GetKeyData);
-    LOOKUP(GetRandom,                OEMCrypto_GetRandom);
-    LOOKUP(WrapKeybox,               OEMCrypto_WrapKeybox);
-    LOOKUP(RewrapDeviceRSAKey,       OEMCrypto_RewrapDeviceRSAKey);
-    LOOKUP(LoadDeviceRSAKey,         OEMCrypto_LoadDeviceRSAKey);
-    LOOKUP(DeriveKeysFromSessionKey, OEMCrypto_DeriveKeysFromSessionKey);
-    LOOKUP(APIVersion,               OEMCrypto_APIVersion);
-    LOOKUP(SecurityLevel,            OEMCrypto_SecurityLevel);
-    LOOKUP(Generic_Decrypt,          OEMCrypto_Generic_Decrypt);
-    LOOKUP(Generic_Encrypt,          OEMCrypto_Generic_Encrypt);
-    LOOKUP(Generic_Sign,             OEMCrypto_Generic_Sign);
-    LOOKUP(Generic_Verify,           OEMCrypto_Generic_Verify);
     if (!level1_valid_) {
       M_RECORD(
           &metrics,
@@ -516,7 +510,6 @@ class Adapter {
       return false;
     }
     level1_.version = level1_.APIVersion();
-    const uint32_t kMinimumVersion = 8;
     M_RECORD(
         &metrics,
         oemcrypto_l1_api_version_,
@@ -534,74 +527,74 @@ class Adapter {
       level1_.Terminate();
       return false;
     }
-    if (level1_.version == 8) {
+
-      LOOKUP(LoadKeys_V8,             OEMCrypto_LoadKeys_V8);
+    // clang-format off
-      LOOKUP(GenerateRSASignature_V8, OEMCrypto_GenerateRSASignature_V8);
+    LOOKUP_ALL( 8, CloseSession,             OEMCrypto_CloseSession);
-    } else {  // version >= 9
+    LOOKUP_ALL(10, CopyBuffer,               OEMCrypto_CopyBuffer);
-      LOOKUP(GenerateRSASignature,    OEMCrypto_GenerateRSASignature);
+    LOOKUP_ALL(13, CopyOldUsageEntry,        OEMCrypto_CopyOldUsageEntry);
-      LOOKUP(SupportsUsageTable,      OEMCrypto_SupportsUsageTable);
+    LOOKUP_ALL(13, CreateNewUsageEntry,      OEMCrypto_CreateNewUsageEntry);
-      // TODO(fredgc): only use these if version < 13.
+    LOOKUP_ALL(13, CreateOldUsageEntry,      OEMCrypto_CreateOldUsageEntry);
-      LOOKUP(ReportUsage,             OEMCrypto_ReportUsage);
+    LOOKUP_ALL(13, CreateUsageTableHeader,   OEMCrypto_CreateUsageTableHeader);
-      LOOKUP(DeleteOldUsageTable,        OEMCrypto_DeleteOldUsageTable);
+    LOOKUP( 9, 12, DeactivateUsageEntry_V12, OEMCrypto_DeactivateUsageEntry_V12);
-      // TODO(fredgc): remove this hack after unit tests have been fixed.
+    LOOKUP_ALL(13, DeactivateUsageEntry,     OEMCrypto_DeactivateUsageEntry);
-      // TODO(fredgc) if (level1_.version < 13) {
+    LOOKUP( 8, 10, DecryptCTR_V10,           OEMCrypto_DecryptCTR_V10);
-      LOOKUP(UpdateUsageTable,         OEMCrypto_UpdateUsageTable);
+    LOOKUP_ALL(11, DecryptCENC,              OEMCrypto_DecryptCENC);
-      if (level1_.version < 13 ) {
+    LOOKUP_ALL( 9, DeleteOldUsageTable,      OEMCrypto_DeleteOldUsageTable);
-        LOOKUP(DeactivateUsageEntry_V12, OEMCrypto_DeactivateUsageEntry_V12);
+    LOOKUP( 9, 12, DeleteUsageEntry,         OEMCrypto_DeleteUsageEntry);
-      }
+    LOOKUP_ALL( 8, DeriveKeysFromSessionKey, OEMCrypto_DeriveKeysFromSessionKey);
-      LOOKUP(DeleteUsageEntry,         OEMCrypto_DeleteUsageEntry);
+    LOOKUP(10, 12, ForceDeleteUsageEntry,    OEMCrypto_ForceDeleteUsageEntry);
-      // TODO(fredgc): }
+    LOOKUP_ALL( 8, GenerateDerivedKeys,      OEMCrypto_GenerateDerivedKeys);
-      if (level1_.version == 9) {
+    LOOKUP_ALL( 8, GenerateNonce,            OEMCrypto_GenerateNonce);
-        LOOKUP(LoadKeys_V9_or_V10,      OEMCrypto_LoadKeys_V9_or_V10);
+    LOOKUP( 8,  8, GenerateRSASignature_V8,  OEMCrypto_GenerateRSASignature_V8);
-        LOOKUP(GetHDCPCapability_V9,    OEMCrypto_GetHDCPCapability_V9);
+    LOOKUP_ALL( 9, GenerateRSASignature,     OEMCrypto_GenerateRSASignature);
-      } else {  // version >= 10.
+    LOOKUP_ALL( 8, GenerateSignature,        OEMCrypto_GenerateSignature);
-        LOOKUP(LoadTestKeybox,          OEMCrypto_LoadTestKeybox);
+    LOOKUP_ALL( 8, Generic_Decrypt,          OEMCrypto_Generic_Decrypt);
-        LOOKUP(LoadTestRSAKey,          OEMCrypto_LoadTestRSAKey);
+    LOOKUP_ALL( 8, Generic_Encrypt,          OEMCrypto_Generic_Encrypt);
-        LOOKUP(QueryKeyControl,         OEMCrypto_QueryKeyControl);
+    LOOKUP_ALL( 8, Generic_Sign,             OEMCrypto_Generic_Sign);
-        LOOKUP(CopyBuffer,              OEMCrypto_CopyBuffer);
+    LOOKUP_ALL( 8, Generic_Verify,           OEMCrypto_Generic_Verify);
-        LOOKUP(GetHDCPCapability,       OEMCrypto_GetHDCPCapability);
+    LOOKUP_ALL(13, GetCurrentSRMVersion,     OEMCrypto_GetCurrentSRMVersion);
-        LOOKUP(IsAntiRollbackHwPresent, OEMCrypto_IsAntiRollbackHwPresent);
+    LOOKUP_ALL( 8, GetDeviceID,              OEMCrypto_GetDeviceID);
-        LOOKUP(GetNumberOfOpenSessions, OEMCrypto_GetNumberOfOpenSessions);
+    LOOKUP( 9,  9, GetHDCPCapability_V9,     OEMCrypto_GetHDCPCapability_V9);
-        LOOKUP(GetMaxNumberOfSessions,  OEMCrypto_GetMaxNumberOfSessions);
+    LOOKUP_ALL(10, GetHDCPCapability,        OEMCrypto_GetHDCPCapability);
-        // TODO(fredgc): if (level1_.version < 13) {
+    LOOKUP_ALL( 8, GetKeyData,               OEMCrypto_GetKeyData);
-          LOOKUP(ForceDeleteUsageEntry,   OEMCrypto_ForceDeleteUsageEntry);
+    LOOKUP_ALL(10, GetMaxNumberOfSessions,   OEMCrypto_GetMaxNumberOfSessions);
-          // TODO(fredgc):  }
+    LOOKUP_ALL(10, GetNumberOfOpenSessions,  OEMCrypto_GetNumberOfOpenSessions);
-        if (level1_.version == 10) {
+    LOOKUP_ALL(12, GetOEMPublicCertificate,  OEMCrypto_GetOEMPublicCertificate);
-          LOOKUP(LoadKeys_V9_or_V10,      OEMCrypto_LoadKeys_V9_or_V10);
+    LOOKUP_ALL(12, GetProvisioningMethod,    OEMCrypto_GetProvisioningMethod);
-          LOOKUP(DecryptCTR_V10,          OEMCrypto_DecryptCTR_V10);
+    LOOKUP_ALL( 8, GetRandom,                OEMCrypto_GetRandom);
-        } else {  // version >= 11.
+    LOOKUP_ALL( 8, InstallKeybox,            OEMCrypto_InstallKeybox);
-          LOOKUP(DecryptCENC,             OEMCrypto_DecryptCENC);
+    LOOKUP_ALL(10, IsAntiRollbackHwPresent,  OEMCrypto_IsAntiRollbackHwPresent);
-          LOOKUP(SecurityPatchLevel,      OEMCrypto_Security_Patch_Level);
+    LOOKUP_ALL( 8, IsKeyboxValid,            OEMCrypto_IsKeyboxValid);
-          if (level1_.version == 11) {
+    LOOKUP_ALL(13, IsSRMUpdateSupported,     OEMCrypto_IsSRMUpdateSupported);
-            LOOKUP(LoadKeys_V12,            OEMCrypto_LoadKeys_V12);
+    LOOKUP_ALL( 8, LoadDeviceRSAKey,         OEMCrypto_LoadDeviceRSAKey);
-          } else {  // version >= 12.
+    LOOKUP( 8,  8, LoadKeys_V8,              OEMCrypto_LoadKeys_V8);
-            LOOKUP(GetProvisioningMethod,   OEMCrypto_GetProvisioningMethod);
+    LOOKUP( 9, 10, LoadKeys_V9_or_V10,       OEMCrypto_LoadKeys_V9_or_V10);
-            LOOKUP(GetOEMPublicCertificate, OEMCrypto_GetOEMPublicCertificate);
+    LOOKUP(11, 12, LoadKeys_V11_or_V12,      OEMCrypto_LoadKeys_V11_or_V12);
-            LOOKUP(RewrapDeviceRSAKey30,    OEMCrypto_RewrapDeviceRSAKey30);
+    LOOKUP_ALL(13, LoadKeys,                 OEMCrypto_LoadKeys);
-            if (level1_.version == 12) {
+    LOOKUP_ALL(13, LoadSRM,                  OEMCrypto_LoadSRM);
-              LOOKUP(LoadKeys_V12,            OEMCrypto_LoadKeys_V12);
+    LOOKUP_ALL(10, LoadTestKeybox,           OEMCrypto_LoadTestKeybox);
-            } else {  // version >= 13.
+    LOOKUP_ALL(10, LoadTestRSAKey,           OEMCrypto_LoadTestRSAKey);
-              LOOKUP(LoadKeys,               OEMCrypto_LoadKeys);
+    LOOKUP_ALL(13, LoadUsageEntry,           OEMCrypto_LoadUsageEntry);
-              LOOKUP(SupportedCertificates,  OEMCrypto_SupportedCertificates);
+    LOOKUP_ALL(13, LoadUsageTableHeader,     OEMCrypto_LoadUsageTableHeader);
-              LOOKUP(IsSRMUpdateSupported,   OEMCrypto_IsSRMUpdateSupported);
+    LOOKUP_ALL(13, MoveEntry,                OEMCrypto_MoveEntry);
-              LOOKUP(GetCurrentSRMVersion,   OEMCrypto_GetCurrentSRMVersion);
+    LOOKUP_ALL( 8, OpenSession,              OEMCrypto_OpenSession);
-              LOOKUP(LoadSRM,                OEMCrypto_LoadSRM);
+    LOOKUP_ALL(10, QueryKeyControl,          OEMCrypto_QueryKeyControl);
-              LOOKUP(RemoveSRM,              OEMCrypto_RemoveSRM);
+    LOOKUP_ALL( 8, RefreshKeys,              OEMCrypto_RefreshKeys);
-              LOOKUP(CreateUsageTableHeader, OEMCrypto_CreateUsageTableHeader);
+    LOOKUP_ALL(13, RemoveSRM,                OEMCrypto_RemoveSRM);
-              LOOKUP(LoadUsageTableHeader,   OEMCrypto_LoadUsageTableHeader);
+    LOOKUP_ALL( 9, ReportUsage,              OEMCrypto_ReportUsage);
-              LOOKUP(CreateNewUsageEntry,    OEMCrypto_CreateNewUsageEntry);
+    LOOKUP_ALL( 8, RewrapDeviceRSAKey,       OEMCrypto_RewrapDeviceRSAKey);
-              LOOKUP(LoadUsageEntry,         OEMCrypto_LoadUsageEntry);
+    LOOKUP_ALL(12, RewrapDeviceRSAKey30,     OEMCrypto_RewrapDeviceRSAKey30);
-              LOOKUP(UpdateUsageEntry,       OEMCrypto_UpdateUsageEntry);
+    LOOKUP_ALL( 8, SecurityLevel,            OEMCrypto_SecurityLevel);
-              LOOKUP(DeactivateUsageEntry,   OEMCrypto_DeactivateUsageEntry);
+    LOOKUP_ALL(11, SecurityPatchLevel,       OEMCrypto_Security_Patch_Level);
-              LOOKUP(ShrinkUsageTableHeader, OEMCrypto_ShrinkUsageTableHeader);
+    LOOKUP_ALL( 8, SelectKey,                OEMCrypto_SelectKey);
-              LOOKUP(MoveEntry,              OEMCrypto_MoveEntry);
+    LOOKUP_ALL(13, ShrinkUsageTableHeader,   OEMCrypto_ShrinkUsageTableHeader);
-              LOOKUP(CopyOldUsageEntry,      OEMCrypto_CopyOldUsageEntry);
+    LOOKUP_ALL(13, SupportedCertificates,    OEMCrypto_SupportedCertificates);
-              LOOKUP(CreateOldUsageEntry,    OEMCrypto_CreateOldUsageEntry);
+    LOOKUP_ALL( 9, SupportsUsageTable,       OEMCrypto_SupportsUsageTable);
-            }
+    LOOKUP_ALL(13, UpdateUsageEntry,         OEMCrypto_UpdateUsageEntry);
-          }
+    LOOKUP( 9, 12, UpdateUsageTable,         OEMCrypto_UpdateUsageTable);
-        }
+    LOOKUP_ALL( 8, WrapKeybox,               OEMCrypto_WrapKeybox);
-      }
+    // clang-format on
-    }
+
     // If we have a valid keybox, initialization is done. We're good.
     if (OEMCrypto_SUCCESS == level1_.IsKeyboxValid()) {
       M_RECORD(
@@ -698,6 +691,7 @@ class Adapter {
   }
 
   void LoadLevel3() {
+    // clang-format off
     level3_.Terminate                = Level3_Terminate;
     level3_.OpenSession              = Level3_OpenSession;
     level3_.CloseSession             = Level3_CloseSession;
@@ -734,11 +728,8 @@ class Adapter {
     level3_.Generic_Encrypt          = Level3_Generic_Encrypt;
     level3_.Generic_Sign             = Level3_Generic_Sign;
     level3_.Generic_Verify           = Level3_Generic_Verify;
-    level3_.UpdateUsageTable = Level3_UpdateUsageTable;
     level3_.DeactivateUsageEntry     = Level3_DeactivateUsageEntry;
     level3_.ReportUsage              = Level3_ReportUsage;
-    level3_.DeleteUsageEntry = Level3_DeleteUsageEntry;
-    level3_.ForceDeleteUsageEntry = Level3_ForceDeleteUsageEntry;
     level3_.DeleteOldUsageTable      = Level3_DeleteOldUsageTable;
     level3_.GetProvisioningMethod    = Level3_GetProvisioningMethod;
     level3_.GetOEMPublicCertificate  = Level3_GetOEMPublicCertificate;
@@ -748,8 +739,7 @@ class Adapter {
     level3_.GetCurrentSRMVersion     = Level3_GetCurrentSRMVersion;
     level3_.LoadSRM                  = Level3_LoadSRM;
     level3_.RemoveSRM                = Level3_RemoveSRM;
-    // TODO(fredgc): add stub.
+    level3_.CreateUsageTableHeader   = Level3_CreateUsageTableHeader;
-    // level3_.CreateUsageTableHeader = Level3_CreateUsageTableHeader;
     level3_.LoadUsageTableHeader     = Level3_LoadUsageTableHeader;
     level3_.CreateNewUsageEntry      = Level3_CreateNewUsageEntry;
     level3_.LoadUsageEntry           = Level3_LoadUsageEntry;
@@ -757,8 +747,8 @@ class Adapter {
     level3_.ShrinkUsageTableHeader   = Level3_ShrinkUsageTableHeader;
     level3_.MoveEntry                = Level3_MoveEntry;
     level3_.CopyOldUsageEntry        = Level3_CopyOldUsageEntry;
-    // TODO(fredgc): add stub.
+    level3_.CreateOldUsageEntry      = Level3_CreateOldUsageEntry;
-    // level3_.CreateOldUsageEntry = Level3_CreateOldUsageEntry;
+    // clang-format on
 
     level3_.version = Level3_APIVersion();
   }
@@ -869,6 +859,7 @@ OEMCryptoResult OEMCrypto_CopyBuffer(
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->CopyBuffer == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->CopyBuffer(data_addr, data_length, out_buffer, subsample_flags);
 }
 
@@ -878,6 +869,7 @@ OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t* keybox,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->InstallKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->InstallKeybox(keybox, keyBoxLength);
 }
 
@@ -887,6 +879,7 @@ OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ProvisioningError;
   if (fcn->version < 12) return OEMCrypto_Keybox;
+  if (fcn->GetProvisioningMethod == NULL) return OEMCrypto_Keybox;
   return fcn->GetProvisioningMethod();
 }
 
@@ -894,6 +887,7 @@ OEMCryptoResult OEMCrypto_IsKeyboxValid(SecurityLevel level) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->IsKeyboxValid == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->IsKeyboxValid();
 }
 
@@ -902,6 +896,7 @@ OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->GetDeviceID == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetDeviceID(deviceID, idLength);
 }
 
@@ -910,6 +905,7 @@ OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->GetKeyData == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetKeyData(keyData, keyDataLength);
 }
 
@@ -917,6 +913,7 @@ uint32_t OEMCrypto_APIVersion(SecurityLevel level) {
   if (!kAdapter) return 0;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return 0;
+  if (fcn->APIVersion == NULL) return 0;
   return fcn->APIVersion();
 }
 
@@ -925,6 +922,7 @@ uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return 0;
   if (fcn->version < 11) return 0;
+  if (fcn->SecurityPatchLevel == NULL) return 0;
   return fcn->SecurityPatchLevel();
 }
 
@@ -932,6 +930,7 @@ const char* OEMCrypto_SecurityLevel(SecurityLevel level) {
   if (!kAdapter) return "";
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return "";
+  if (fcn->SecurityLevel == NULL) return "";
   return fcn->SecurityLevel();
 }
 
@@ -946,11 +945,15 @@ OEMCryptoResult OEMCrypto_GetHDCPCapability(
     if (current == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
     if (maximum == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
     uint8_t current_byte, maximum_byte;
-    OEMCryptoResult sts = fcn->GetHDCPCapability_V9(&current_byte, &maximum_byte);
+    if (fcn->GetHDCPCapability_V9 == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+    OEMCryptoResult sts =
+        fcn->GetHDCPCapability_V9(&current_byte, &maximum_byte);
     *current = static_cast<OEMCrypto_HDCP_Capability>(current_byte);
     *maximum = static_cast<OEMCrypto_HDCP_Capability>(maximum_byte);
     return sts;
   } else {
+    if (fcn->GetHDCPCapability == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return fcn->GetHDCPCapability(current, maximum);
   }
 }
@@ -960,6 +963,7 @@ bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return false;
   if (fcn->version == 8) return false;
+  if (fcn->SupportsUsageTable == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->SupportsUsageTable();
 }
 
@@ -968,6 +972,8 @@ bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return false;
   if (fcn->version < 10) return false;
+  if (fcn->IsAntiRollbackHwPresent == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->IsAntiRollbackHwPresent();
 }
 
@@ -986,6 +992,8 @@ OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->GetMaxNumberOfSessions == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetMaxNumberOfSessions(maximum);
 }
 
@@ -995,6 +1003,7 @@ uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
   if (!fcn) return 0;
   // Default is to support 2048 bit RSA keys.
   if (fcn->version < 13) return OEMCrypto_Supports_RSA_2048bit;
+  if (fcn->SupportedCertificates == NULL) return OEMCrypto_Supports_RSA_2048bit;
   return fcn->SupportedCertificates();
 }
 
@@ -1005,7 +1014,8 @@ OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (!fcn->CreateUsageTableHeader) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->CreateUsageTableHeader == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->CreateUsageTableHeader(header_buffer, header_buffer_length);
 }
 
@@ -1016,6 +1026,7 @@ OEMCryptoResult OEMCrypto_LoadUsageTableHeader(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->LoadUsageTableHeader == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->LoadUsageTableHeader(buffer, buffer_length);
 }
 
@@ -1027,7 +1038,8 @@ OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (!fcn->ShrinkUsageTableHeader) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->ShrinkUsageTableHeader == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->ShrinkUsageTableHeader(new_table_size, header_buffer,
                                      header_buffer_length);
 }
@@ -1041,7 +1053,7 @@ OEMCryptoResult OEMCrypto_CreateOldUsageEntry(
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (!fcn->CreateOldUsageEntry) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->CreateOldUsageEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->CreateOldUsageEntry(
       time_since_license_received, time_since_first_decrypt,
       time_since_last_decrypt, status, server_mac_key, client_mac_key, pst,
@@ -1084,6 +1096,8 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->GenerateDerivedKeys == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GenerateDerivedKeys(pair.session, mac_key_context,
                                        mac_key_context_length, enc_key_context,
                                        enc_key_context_length);
@@ -1094,6 +1108,7 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->GenerateNonce == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GenerateNonce(pair.session, nonce);
 }
 
@@ -1103,6 +1118,8 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateSignature(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->GenerateSignature == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GenerateSignature(pair.session, message, message_length,
                                      signature, signature_length);
 }
@@ -1111,15 +1128,14 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length,
     const uint8_t* enc_mac_key_iv, const uint8_t* enc_mac_key, size_t num_keys,
-    const OEMCrypto_KeyObject* key_array, const uint8_t* pst,
+    const OEMCrypto_KeyObject* key_array, const uint8_t* pst, size_t pst_length,
-    size_t pst_length, const uint8_t* srm_requirement) {
+    const uint8_t* srm_requirement) {
-
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
     std::vector<OEMCrypto_KeyObject_V10> key_array_v10(num_keys);
-    for(size_t i=0; i < num_keys; i++) {
+    for (size_t i = 0; i < num_keys; i++) {
       key_array_v10[i].key_id = key_array[i].key_id;
       key_array_v10[i].key_id_length = key_array[i].key_id_length;
       key_array_v10[i].key_data_iv = key_array[i].key_data_iv;
@@ -1133,27 +1149,31 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys(
       }
     }
     if (pair.fcn->version == 8) {
+      if (pair.fcn->LoadKeys_V8 == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
       return pair.fcn->LoadKeys_V8(pair.session, message, message_length,
                                    signature, signature_length, enc_mac_key_iv,
                                    enc_mac_key, num_keys, &key_array_v10[0]);
     } else {
+      if (pair.fcn->LoadKeys_V9_or_V10 == NULL)
+        return OEMCrypto_ERROR_NOT_IMPLEMENTED;
       return pair.fcn->LoadKeys_V9_or_V10(pair.session, message, message_length,
                                           signature, signature_length,
-                                          enc_mac_key_iv, enc_mac_key,
+                                          enc_mac_key_iv, enc_mac_key, num_keys,
-                                          num_keys, &key_array_v10[0],
+                                          &key_array_v10[0], pst, pst_length);
-                                          pst, pst_length);
     }
   } else {
     if (pair.fcn->version < 13) {
-      return pair.fcn->LoadKeys_V12(pair.session, message, message_length,
+      if (pair.fcn->LoadKeys_V11_or_V12 == NULL)
+        return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+      return pair.fcn->LoadKeys_V11_or_V12(
+          pair.session, message, message_length, signature, signature_length,
+          enc_mac_key_iv, enc_mac_key, num_keys, key_array, pst, pst_length);
+    } else {
+      if (pair.fcn->LoadKeys == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+      return pair.fcn->LoadKeys(pair.session, message, message_length,
                                 signature, signature_length, enc_mac_key_iv,
                                 enc_mac_key, num_keys, key_array, pst,
-                                    pst_length);
+                                pst_length, srm_requirement);
-    }  else {
-      return pair.fcn->LoadKeys(pair.session, message, message_length, signature,
-                                signature_length, enc_mac_key_iv, enc_mac_key,
-                                num_keys, key_array, pst, pst_length,
-                                srm_requirement);
     }
   }
 }
@@ -1165,6 +1185,7 @@ extern "C" OEMCryptoResult OEMCrypto_RefreshKeys(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->RefreshKeys == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->RefreshKeys(pair.session, message, message_length, signature,
                                signature_length, num_keys, key_array);
 }
@@ -1176,6 +1197,7 @@ extern "C" OEMCryptoResult OEMCrypto_QueryKeyControl(
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->QueryKeyControl == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->QueryKeyControl(pair.session, key_id, key_id_length,
                                    key_control_block, key_control_block_length);
 }
@@ -1186,6 +1208,7 @@ extern "C" OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->SelectKey == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->SelectKey(pair.session, key_id, key_id_length);
 }
 
@@ -1193,16 +1216,18 @@ extern "C" OEMCryptoResult OEMCrypto_DecryptCENC(
     OEMCrypto_SESSION session, const uint8_t* data_addr, size_t data_length,
     bool is_encrypted, const uint8_t* iv, size_t offset,
     OEMCrypto_DestBufferDesc* out_buffer,
-    const OEMCrypto_CENCEncryptPatternDesc* pattern,
+    const OEMCrypto_CENCEncryptPatternDesc* pattern, uint8_t subsample_flags) {
-    uint8_t subsample_flags) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
+    if (pair.fcn->DecryptCTR_V10 == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->DecryptCTR_V10(pair.session, data_addr, data_length,
                                     is_encrypted, iv, offset, out_buffer,
                                     subsample_flags);
   } else {
+    if (pair.fcn->DecryptCENC == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->DecryptCENC(pair.session, data_addr, data_length,
                                  is_encrypted, iv, offset, out_buffer, pattern,
                                  subsample_flags);
@@ -1225,6 +1250,7 @@ extern "C" OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t* keybox,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->WrapKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->WrapKeybox(keybox, keyBoxLength, wrappedKeybox,
                          wrappedKeyBoxLength, transportKey, transportKeyLength);
 }
@@ -1239,6 +1265,7 @@ extern "C" OEMCryptoResult OEMCrypto_LoadTestKeybox() {
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->LoadTestKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->LoadTestKeybox();
 }
 
@@ -1251,13 +1278,14 @@ extern "C" OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod() {
 }
 
 extern "C" OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
-                                  OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, uint8_t* public_cert,
-                                  uint8_t *public_cert,
+    size_t* public_cert_length) {
-                                  size_t *public_cert_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 12) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->GetOEMPublicCertificate == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GetOEMPublicCertificate(pair.session, public_cert,
                                            public_cert_length);
 }
@@ -1277,6 +1305,7 @@ extern "C" OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->GetRandom == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetRandom(randomData, dataLength);
 }
 
@@ -1294,6 +1323,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey30(
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 12) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->RewrapDeviceRSAKey30 == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->RewrapDeviceRSAKey30(session, nonce, encrypted_message_key,
                                         encrypted_message_key_length,
                                         enc_rsa_key, enc_rsa_key_length,
@@ -1301,7 +1332,6 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey30(
                                         wrapped_rsa_key_length);
 }
 
-
 extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length, const uint32_t* nonce,
@@ -1311,6 +1341,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->RewrapDeviceRSAKey == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->RewrapDeviceRSAKey(
       pair.session, message, message_length, signature, signature_length, nonce,
       enc_rsa_key, enc_rsa_key_length, enc_rsa_key_iv, wrapped_rsa_key,
@@ -1323,6 +1355,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->LoadDeviceRSAKey == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->LoadDeviceRSAKey(pair.session, wrapped_rsa_key,
                                     wrapped_rsa_key_length);
 }
@@ -1332,6 +1366,7 @@ extern "C" OEMCryptoResult OEMCrypto_LoadTestRSAKey() {
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->LoadTestRSAKey == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->LoadTestRSAKey();
 }
 
@@ -1343,9 +1378,13 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateRSASignature(
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version == 8) {
+    if (pair.fcn->GenerateRSASignature_V8 == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->GenerateRSASignature_V8(
         pair.session, message, message_length, signature, signature_length);
   } else {
+    if (pair.fcn->GenerateRSASignature == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->GenerateRSASignature(pair.session, message, message_length,
                                           signature, signature_length,
                                           padding_scheme);
@@ -1360,6 +1399,8 @@ extern "C" OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->DeriveKeysFromSessionKey == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->DeriveKeysFromSessionKey(
       pair.session, enc_session_key, enc_session_key_length, mac_key_context,
       mac_key_context_length, enc_key_context, enc_key_context_length);
@@ -1408,20 +1449,19 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Encrypt(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->Generic_Encrypt == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   OEMCryptoResult status = OEMCrypto_SUCCESS;
   std::vector<uint8_t> current_iv(iv, iv + wvcdm::KEY_IV_SIZE);
   while (buffer_length > 0 && status == OEMCrypto_SUCCESS) {
-    const size_t chunk_size = std::min(buffer_length,
+    const size_t chunk_size =
-                                       kMaxGenericEncryptChunkSize);
+        std::min(buffer_length, kMaxGenericEncryptChunkSize);
     status = pair.fcn->Generic_Encrypt(pair.session, in_buffer, chunk_size,
-                                       &current_iv[0],
+                                       &current_iv[0], algorithm, out_buffer);
-                                       algorithm, out_buffer);
     buffer_length -= chunk_size;
     in_buffer += chunk_size;
     out_buffer += chunk_size;
     if (buffer_length > 0) {
-      current_iv.assign(out_buffer - wvcdm::KEY_IV_SIZE,
+      current_iv.assign(out_buffer - wvcdm::KEY_IV_SIZE, out_buffer);
-                        out_buffer);
     }
   }
   return status;
@@ -1433,20 +1473,19 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Decrypt(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->Generic_Decrypt == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   OEMCryptoResult status = OEMCrypto_SUCCESS;
   std::vector<uint8_t> current_iv(iv, iv + wvcdm::KEY_IV_SIZE);
   while (buffer_length > 0 && status == OEMCrypto_SUCCESS) {
-    const size_t chunk_size = std::min(buffer_length,
+    const size_t chunk_size =
-                                       kMaxGenericEncryptChunkSize);
+        std::min(buffer_length, kMaxGenericEncryptChunkSize);
     status = pair.fcn->Generic_Decrypt(pair.session, in_buffer, chunk_size,
-                                        &current_iv[0],
+                                       &current_iv[0], algorithm, out_buffer);
-                                        algorithm, out_buffer);
     buffer_length -= chunk_size;
     in_buffer += chunk_size;
     out_buffer += chunk_size;
     if (buffer_length > 0) {
-      current_iv.assign(in_buffer - wvcdm::KEY_IV_SIZE,
+      current_iv.assign(in_buffer - wvcdm::KEY_IV_SIZE, in_buffer);
-                        in_buffer);
     }
   }
   return status;
@@ -1472,32 +1511,24 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Verify(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->Generic_Verify == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->Generic_Verify(pair.session, in_buffer, buffer_length,
                                   algorithm, signature, signature_length);
 }
 
-// TODO(fredgc): remove this function when cdm layer doesn't need it.
 extern "C" OEMCryptoResult OEMCrypto_UpdateUsageTable() {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
-  const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn3 && fcn3->version > 8 && fcn3->version < 13) {
+  if ((fcn1 != NULL) && (fcn1->UpdateUsageTable != NULL) &&
-    sts = fcn3->UpdateUsageTable();
+      (fcn1->version > 8) && (fcn1->version < 13)) {
-  }
-  if (fcn1 && fcn1 != fcn3 && fcn1->version > 8 && fcn1->version < 13) {
     sts = fcn1->UpdateUsageTable();
-  } else {
-    // TODO(fredgc): Remove this after unit tests, haystack, and mock
-    // have been updated to v13.  RED:  REMOVE BEFORE FLIGHT -->
-    if (fcn1) sts = fcn1->UpdateUsageTable();
   }
   return sts;
 }
 
-extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION session,
+extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(
-                                                          const uint8_t* pst,
+    OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-                                                          size_t pst_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) {
@@ -1508,7 +1539,7 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
     const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
     OEMCryptoResult sts = OEMCrypto_ERROR_INVALID_SESSION;
     if (fcn1) {
-      if(fcn1->version < 13) {
+      if (fcn1->version < 13) {
         if (fcn1->DeactivateUsageEntry_V12) {
           sts = fcn1->DeactivateUsageEntry_V12(pst, pst_length);
         } else {
@@ -1524,7 +1555,7 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
     }
     if (OEMCrypto_SUCCESS != sts) {
       if (fcn3 && fcn1 != fcn3) {
-        if(fcn3->version < 13) {
+        if (fcn3->version < 13) {
           if (fcn3->DeactivateUsageEntry_V12) {
             sts = fcn3->DeactivateUsageEntry_V12(pst, pst_length);
           } else {
@@ -1546,8 +1577,8 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
   if (pair.fcn->version < 9) {
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   }
-  if(pair.fcn->version < 13) {
+  if (pair.fcn->version < 13) {
-    if (pair.fcn->DeactivateUsageEntry_V12 ) {
+    if (pair.fcn->DeactivateUsageEntry_V12) {
       return pair.fcn->DeactivateUsageEntry_V12(pst, pst_length);
     } else {
       LOGE("TODO(fredgc):  problem picking function!\n");
@@ -1571,6 +1602,7 @@ extern "C" OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version > 8) {
+    if (pair.fcn->ReportUsage == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->ReportUsage(pair.session, pst, pst_length, buffer,
                                  buffer_length);
   } else {
@@ -1596,18 +1628,20 @@ extern "C" OEMCryptoResult OEMCrypto_DeleteUsageEntry(
   }
 }
 
-extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(
+extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t* pst,
-    const uint8_t* pst, size_t pst_length) {
+                                                           size_t pst_length) {
   LOGE("TODO(fredgc): remove ForceDeleteUsageEntry.");
 
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
   const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn3 && fcn3->version > 9) {
+  if (fcn3 && (fcn3->version > 9) && (fcn3->version < 13) &&
+      fcn3->ForceDeleteUsageEntry != NULL) {
     sts = fcn3->ForceDeleteUsageEntry(pst, pst_length);
   }
-  if (fcn1 && fcn1 != fcn3 && fcn1->version > 9) {
+  if (fcn1 && fcn1 != fcn3 && (fcn1->version > 9) && (fcn1->version < 13) &&
+      (fcn1->ForceDeleteUsageEntry != NULL)) {
     OEMCryptoResult sts1 = fcn1->ForceDeleteUsageEntry(pst, pst_length);
     if ((sts1 != OEMCrypto_SUCCESS) && (sts == OEMCrypto_SUCCESS)) {
       sts = sts1;
@@ -1617,133 +1651,137 @@ extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(
 }
 
 extern "C" OEMCryptoResult OEMCrypto_DeleteOldUsageTable() {
-
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
   const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn3 && fcn3->version > 8) sts = fcn3->DeleteOldUsageTable();
+  if (fcn3 && (fcn3->version > 8) && (fcn3->DeleteOldUsageTable != NULL)) {
-  if (fcn1 && fcn1 != fcn3 && fcn1->version > 8) sts = fcn1->DeleteOldUsageTable();
+    sts = fcn3->DeleteOldUsageTable();
+  }
+  if (fcn1 && fcn1 != fcn3 &&
+      (fcn1->version > 8) && (fcn1->DeleteOldUsageTable != NULL)) {
+    sts = fcn1->DeleteOldUsageTable();
+  }
   return sts;
 }
 
-extern "C"
+extern "C" bool OEMCrypto_IsSRMUpdateSupported() {
-bool OEMCrypto_IsSRMUpdateSupported() {
   if (!kAdapter) return false;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return false;
   if (fcn->version < 13) return false;
+  if (fcn->IsSRMUpdateSupported == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->IsSRMUpdateSupported();
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
-OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->GetCurrentSRMVersion == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetCurrentSRMVersion(version);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
-OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
                                              size_t buffer_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->LoadSRM == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->LoadSRM(buffer, buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_RemoveSRM() {
-OEMCryptoResult OEMCrypto_RemoveSRM() {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->RemoveSRM == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->RemoveSRM();
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
-OEMCryptoResult OEMCrypto_CreateUsageTableHeader(uint8_t* header_buffer,
+    uint8_t* header_buffer, size_t* header_buffer_length) {
-                                                 size_t* header_buffer_length) {
   return OEMCrypto_CreateUsageTableHeader(kLevelDefault, header_buffer,
                                           header_buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
-OEMCryptoResult OEMCrypto_LoadUsageTableHeader(const uint8_t* buffer,
+    const uint8_t* buffer, size_t buffer_length) {
-                                               size_t buffer_length) {
   return OEMCrypto_LoadUsageTableHeader(kLevelDefault, buffer, buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_CreateNewUsageEntry(
-OEMCryptoResult OEMCrypto_CreateNewUsageEntry(OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, uint32_t* usage_entry_number) {
-                                              uint32_t *usage_entry_number) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->CreateNewUsageEntry == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->CreateNewUsageEntry(pair.session, usage_entry_number);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_LoadUsageEntry(OEMCrypto_SESSION session,
-OEMCryptoResult OEMCrypto_LoadUsageEntry(OEMCrypto_SESSION session,
                                                     uint32_t index,
-                                         const uint8_t *buffer,
+                                                    const uint8_t* buffer,
                                                     size_t buffer_size) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->LoadUsageEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->LoadUsageEntry(pair.session, index, buffer, buffer_size);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_UpdateUsageEntry(
-OEMCryptoResult OEMCrypto_UpdateUsageEntry(OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, uint8_t* header_buffer,
-                                           uint8_t* header_buffer,
+    size_t* header_buffer_length, uint8_t* entry_buffer,
-                                           size_t* header_buffer_length,
-                                           uint8_t* entry_buffer,
     size_t* entry_buffer_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->UpdateUsageEntry == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->UpdateUsageEntry(pair.session, header_buffer,
                                     header_buffer_length, entry_buffer,
                                     entry_buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
-OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(uint32_t new_table_size,
+    uint32_t new_table_size, uint8_t* header_buffer,
-                                                 uint8_t* header_buffer,
     size_t* header_buffer_length) {
+  if (OEMCrypto_ShrinkUsageTableHeader == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return OEMCrypto_ShrinkUsageTableHeader(kLevelDefault, new_table_size,
                                           header_buffer, header_buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
-OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
                                                uint32_t new_index) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->MoveEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->MoveEntry(pair.session, new_index);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_CopyOldUsageEntry(
-OEMCryptoResult OEMCrypto_CopyOldUsageEntry(OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-                                            const uint8_t*pst,
-                                            size_t pst_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->CopyOldUsageEntry == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->CopyOldUsageEntry(pair.session, pst, pst_length);
 }
 

libwvdrmengine/level3/arm64/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := libwvlevel3
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE_SUFFIX := .a
+LOCAL_SRC_FILES := $(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := widevine
+LOCAL_MODULE_TARGET_ARCH := arm64
+include $(BUILD_PREBUILT)

libwvdrmengine/level3/mips/Android.mk

@@ -1,5 +1,4 @@
 LOCAL_PATH:= $(call my-dir)
-
 include $(CLEAR_VARS)
 LOCAL_MODULE := libwvlevel3
 LOCAL_MODULE_CLASS := STATIC_LIBRARIES

libwvdrmengine/level3/mips64/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := libwvlevel3
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE_SUFFIX := .a
+LOCAL_SRC_FILES := $(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := widevine
+LOCAL_MODULE_TARGET_ARCH := mips64
+include $(BUILD_PREBUILT)

libwvdrmengine/level3/x86_64/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := libwvlevel3
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE_SUFFIX := .a
+LOCAL_SRC_FILES := $(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := widevine
+LOCAL_MODULE_TARGET_ARCH := x86_64
+include $(BUILD_PREBUILT)

libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h

@@ -371,7 +371,7 @@ typedef enum OEMCrypto_ProvisioningMethod {
 #define OEMCrypto_GetHDCPCapability        _oecc44
 #define OEMCrypto_LoadTestRSAKey           _oecc45
 #define OEMCrypto_Security_Patch_Level     _oecc46
-#define OEMCrypto_LoadKeys_V12             _oecc47
+#define OEMCrypto_LoadKeys_V11_or_V12      _oecc47
 #define OEMCrypto_DecryptCENC              _oecc48
 #define OEMCrypto_GetProvisioningMethod    _oecc49
 #define OEMCrypto_GetOEMPublicCertificate  _oecc50