generator: update generated code to use new conditionals
The new generated code uses IS_CC_ENABLED() to determine if command
related code should be compiled in.
BRANCH=cr50
BUG=b:65253310
TEST=modified sources produce identical Cr50 executable.
Change-Id: Idb9d3044c40a544ddd9fc259009f7e184e1d086c
Signed-off-by: Vadim Bendebury <vbendeb@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/1413095
Reviewed-by: Andrey Pronin <apronin@chromium.org>
diff --git a/CommandDispatcher.c b/CommandDispatcher.c
index 25b6347..430a470 100644
--- a/CommandDispatcher.c
+++ b/CommandDispatcher.c
@@ -124,756 +124,756 @@
UINT32* response_parameter_buffer_size) {
BYTE* request_parameter_buffer = request_parameter_buffer_start;
switch (command_code) {
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
case TPM_CC_ActivateCredential:
return Exec_ActivateCredential(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
case TPM_CC_Certify:
return Exec_Certify(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
case TPM_CC_CertifyCreation:
return Exec_CertifyCreation(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ChangeEPS
+#if IS_CC_ENABLED(ChangeEPS)
case TPM_CC_ChangeEPS:
return Exec_ChangeEPS(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ChangePPS
+#if IS_CC_ENABLED(ChangePPS)
case TPM_CC_ChangePPS:
return Exec_ChangePPS(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Clear
+#if IS_CC_ENABLED(Clear)
case TPM_CC_Clear:
return Exec_Clear(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ClearControl
+#if IS_CC_ENABLED(ClearControl)
case TPM_CC_ClearControl:
return Exec_ClearControl(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ClockRateAdjust
+#if IS_CC_ENABLED(ClockRateAdjust)
case TPM_CC_ClockRateAdjust:
return Exec_ClockRateAdjust(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ClockSet
+#if IS_CC_ENABLED(ClockSet)
case TPM_CC_ClockSet:
return Exec_ClockSet(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
case TPM_CC_Commit:
return Exec_Commit(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
case TPM_CC_ContextLoad:
return Exec_ContextLoad(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
case TPM_CC_ContextSave:
return Exec_ContextSave(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
case TPM_CC_Create:
return Exec_Create(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
case TPM_CC_CreatePrimary:
return Exec_CreatePrimary(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_DictionaryAttackLockReset
+#if IS_CC_ENABLED(DictionaryAttackLockReset)
case TPM_CC_DictionaryAttackLockReset:
return Exec_DictionaryAttackLockReset(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_DictionaryAttackParameters
+#if IS_CC_ENABLED(DictionaryAttackParameters)
case TPM_CC_DictionaryAttackParameters:
return Exec_DictionaryAttackParameters(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
case TPM_CC_Duplicate:
return Exec_Duplicate(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
case TPM_CC_ECC_Parameters:
return Exec_ECC_Parameters(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
case TPM_CC_ECDH_KeyGen:
return Exec_ECDH_KeyGen(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
case TPM_CC_ECDH_ZGen:
return Exec_ECDH_ZGen(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
case TPM_CC_EC_Ephemeral:
return Exec_EC_Ephemeral(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
case TPM_CC_EncryptDecrypt:
return Exec_EncryptDecrypt(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
case TPM_CC_EventSequenceComplete:
return Exec_EventSequenceComplete(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_EvictControl
+#if IS_CC_ENABLED(EvictControl)
case TPM_CC_EvictControl:
return Exec_EvictControl(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
case TPM_CC_FieldUpgradeData:
return Exec_FieldUpgradeData(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_FieldUpgradeStart
+#if IS_CC_ENABLED(FieldUpgradeStart)
case TPM_CC_FieldUpgradeStart:
return Exec_FieldUpgradeStart(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
case TPM_CC_FirmwareRead:
return Exec_FirmwareRead(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_FlushContext
+#if IS_CC_ENABLED(FlushContext)
case TPM_CC_FlushContext:
return Exec_FlushContext(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
case TPM_CC_GetCapability:
return Exec_GetCapability(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
case TPM_CC_GetCommandAuditDigest:
return Exec_GetCommandAuditDigest(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
case TPM_CC_GetRandom:
return Exec_GetRandom(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
case TPM_CC_GetSessionAuditDigest:
return Exec_GetSessionAuditDigest(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
case TPM_CC_GetTestResult:
return Exec_GetTestResult(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
case TPM_CC_GetTime:
return Exec_GetTime(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
case TPM_CC_HMAC:
return Exec_HMAC(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
case TPM_CC_HMAC_Start:
return Exec_HMAC_Start(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
case TPM_CC_Hash:
return Exec_Hash(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
case TPM_CC_HashSequenceStart:
return Exec_HashSequenceStart(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_HierarchyChangeAuth
+#if IS_CC_ENABLED(HierarchyChangeAuth)
case TPM_CC_HierarchyChangeAuth:
return Exec_HierarchyChangeAuth(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_HierarchyControl
+#if IS_CC_ENABLED(HierarchyControl)
case TPM_CC_HierarchyControl:
return Exec_HierarchyControl(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
case TPM_CC_Import:
return Exec_Import(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
case TPM_CC_IncrementalSelfTest:
return Exec_IncrementalSelfTest(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
case TPM_CC_Load:
return Exec_Load(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
case TPM_CC_LoadExternal:
return Exec_LoadExternal(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
case TPM_CC_MakeCredential:
return Exec_MakeCredential(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
case TPM_CC_NV_Certify:
return Exec_NV_Certify(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_ChangeAuth
+#if IS_CC_ENABLED(NV_ChangeAuth)
case TPM_CC_NV_ChangeAuth:
return Exec_NV_ChangeAuth(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_DefineSpace
+#if IS_CC_ENABLED(NV_DefineSpace)
case TPM_CC_NV_DefineSpace:
return Exec_NV_DefineSpace(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_Extend
+#if IS_CC_ENABLED(NV_Extend)
case TPM_CC_NV_Extend:
return Exec_NV_Extend(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_GlobalWriteLock
+#if IS_CC_ENABLED(NV_GlobalWriteLock)
case TPM_CC_NV_GlobalWriteLock:
return Exec_NV_GlobalWriteLock(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_Increment
+#if IS_CC_ENABLED(NV_Increment)
case TPM_CC_NV_Increment:
return Exec_NV_Increment(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
case TPM_CC_NV_Read:
return Exec_NV_Read(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_ReadLock
+#if IS_CC_ENABLED(NV_ReadLock)
case TPM_CC_NV_ReadLock:
return Exec_NV_ReadLock(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
case TPM_CC_NV_ReadPublic:
return Exec_NV_ReadPublic(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_SetBits
+#if IS_CC_ENABLED(NV_SetBits)
case TPM_CC_NV_SetBits:
return Exec_NV_SetBits(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_UndefineSpace
+#if IS_CC_ENABLED(NV_UndefineSpace)
case TPM_CC_NV_UndefineSpace:
return Exec_NV_UndefineSpace(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_UndefineSpaceSpecial
+#if IS_CC_ENABLED(NV_UndefineSpaceSpecial)
case TPM_CC_NV_UndefineSpaceSpecial:
return Exec_NV_UndefineSpaceSpecial(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_Write
+#if IS_CC_ENABLED(NV_Write)
case TPM_CC_NV_Write:
return Exec_NV_Write(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_NV_WriteLock
+#if IS_CC_ENABLED(NV_WriteLock)
case TPM_CC_NV_WriteLock:
return Exec_NV_WriteLock(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
case TPM_CC_ObjectChangeAuth:
return Exec_ObjectChangeAuth(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
case TPM_CC_PCR_Allocate:
return Exec_PCR_Allocate(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
case TPM_CC_PCR_Event:
return Exec_PCR_Event(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_Extend
+#if IS_CC_ENABLED(PCR_Extend)
case TPM_CC_PCR_Extend:
return Exec_PCR_Extend(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
case TPM_CC_PCR_Read:
return Exec_PCR_Read(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_Reset
+#if IS_CC_ENABLED(PCR_Reset)
case TPM_CC_PCR_Reset:
return Exec_PCR_Reset(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_SetAuthPolicy
+#if IS_CC_ENABLED(PCR_SetAuthPolicy)
case TPM_CC_PCR_SetAuthPolicy:
return Exec_PCR_SetAuthPolicy(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PCR_SetAuthValue
+#if IS_CC_ENABLED(PCR_SetAuthValue)
case TPM_CC_PCR_SetAuthValue:
return Exec_PCR_SetAuthValue(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PP_Commands
+#if IS_CC_ENABLED(PP_Commands)
case TPM_CC_PP_Commands:
return Exec_PP_Commands(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyAuthValue
+#if IS_CC_ENABLED(PolicyAuthValue)
case TPM_CC_PolicyAuthValue:
return Exec_PolicyAuthValue(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyAuthorize
+#if IS_CC_ENABLED(PolicyAuthorize)
case TPM_CC_PolicyAuthorize:
return Exec_PolicyAuthorize(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyCommandCode
+#if IS_CC_ENABLED(PolicyCommandCode)
case TPM_CC_PolicyCommandCode:
return Exec_PolicyCommandCode(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyCounterTimer
+#if IS_CC_ENABLED(PolicyCounterTimer)
case TPM_CC_PolicyCounterTimer:
return Exec_PolicyCounterTimer(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyCpHash
+#if IS_CC_ENABLED(PolicyCpHash)
case TPM_CC_PolicyCpHash:
return Exec_PolicyCpHash(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyDuplicationSelect
+#if IS_CC_ENABLED(PolicyDuplicationSelect)
case TPM_CC_PolicyDuplicationSelect:
return Exec_PolicyDuplicationSelect(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
case TPM_CC_PolicyGetDigest:
return Exec_PolicyGetDigest(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyLocality
+#if IS_CC_ENABLED(PolicyLocality)
case TPM_CC_PolicyLocality:
return Exec_PolicyLocality(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyNV
+#if IS_CC_ENABLED(PolicyNV)
case TPM_CC_PolicyNV:
return Exec_PolicyNV(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyNameHash
+#if IS_CC_ENABLED(PolicyNameHash)
case TPM_CC_PolicyNameHash:
return Exec_PolicyNameHash(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyNvWritten
+#if IS_CC_ENABLED(PolicyNvWritten)
case TPM_CC_PolicyNvWritten:
return Exec_PolicyNvWritten(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyOR
+#if IS_CC_ENABLED(PolicyOR)
case TPM_CC_PolicyOR:
return Exec_PolicyOR(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyPCR
+#if IS_CC_ENABLED(PolicyPCR)
case TPM_CC_PolicyPCR:
return Exec_PolicyPCR(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyPassword
+#if IS_CC_ENABLED(PolicyPassword)
case TPM_CC_PolicyPassword:
return Exec_PolicyPassword(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyPhysicalPresence
+#if IS_CC_ENABLED(PolicyPhysicalPresence)
case TPM_CC_PolicyPhysicalPresence:
return Exec_PolicyPhysicalPresence(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyRestart
+#if IS_CC_ENABLED(PolicyRestart)
case TPM_CC_PolicyRestart:
return Exec_PolicyRestart(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
case TPM_CC_PolicySecret:
return Exec_PolicySecret(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
case TPM_CC_PolicySigned:
return Exec_PolicySigned(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_PolicyTicket
+#if IS_CC_ENABLED(PolicyTicket)
case TPM_CC_PolicyTicket:
return Exec_PolicyTicket(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
case TPM_CC_Quote:
return Exec_Quote(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
case TPM_CC_RSA_Decrypt:
return Exec_RSA_Decrypt(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
case TPM_CC_RSA_Encrypt:
return Exec_RSA_Encrypt(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
case TPM_CC_ReadClock:
return Exec_ReadClock(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
case TPM_CC_ReadPublic:
return Exec_ReadPublic(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
case TPM_CC_Rewrap:
return Exec_Rewrap(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_SelfTest
+#if IS_CC_ENABLED(SelfTest)
case TPM_CC_SelfTest:
return Exec_SelfTest(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
case TPM_CC_SequenceComplete:
return Exec_SequenceComplete(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_SequenceUpdate
+#if IS_CC_ENABLED(SequenceUpdate)
case TPM_CC_SequenceUpdate:
return Exec_SequenceUpdate(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_SetAlgorithmSet
+#if IS_CC_ENABLED(SetAlgorithmSet)
case TPM_CC_SetAlgorithmSet:
return Exec_SetAlgorithmSet(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_SetCommandCodeAuditStatus
+#if IS_CC_ENABLED(SetCommandCodeAuditStatus)
case TPM_CC_SetCommandCodeAuditStatus:
return Exec_SetCommandCodeAuditStatus(
tag, &request_parameter_buffer, request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_SetPrimaryPolicy
+#if IS_CC_ENABLED(SetPrimaryPolicy)
case TPM_CC_SetPrimaryPolicy:
return Exec_SetPrimaryPolicy(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Shutdown
+#if IS_CC_ENABLED(Shutdown)
case TPM_CC_Shutdown:
return Exec_Shutdown(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
case TPM_CC_Sign:
return Exec_Sign(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
case TPM_CC_StartAuthSession:
return Exec_StartAuthSession(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Startup
+#if IS_CC_ENABLED(Startup)
case TPM_CC_Startup:
return Exec_Startup(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_StirRandom
+#if IS_CC_ENABLED(StirRandom)
case TPM_CC_StirRandom:
return Exec_StirRandom(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_TestParms
+#if IS_CC_ENABLED(TestParms)
case TPM_CC_TestParms:
return Exec_TestParms(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
case TPM_CC_Unseal:
return Exec_Unseal(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
case TPM_CC_VerifySignature:
return Exec_VerifySignature(tag, &request_parameter_buffer,
request_parameter_buffer_size,
request_handles, response_handle_buffer_size,
response_parameter_buffer_size);
#endif
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
case TPM_CC_ZGen_2Phase:
return Exec_ZGen_2Phase(tag, &request_parameter_buffer,
request_parameter_buffer_size, request_handles,
diff --git a/GetCommandCodeString.c b/GetCommandCodeString.c
index df3f585..5026ab1 100644
--- a/GetCommandCodeString.c
+++ b/GetCommandCodeString.c
@@ -8,435 +8,435 @@
const char* GetCommandCodeString(TPM_CC command_code) {
switch (command_code) {
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
case TPM_CC_ActivateCredential:
return "ActivateCredential";
#endif
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
case TPM_CC_Certify:
return "Certify";
#endif
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
case TPM_CC_CertifyCreation:
return "CertifyCreation";
#endif
-#ifdef TPM_CC_ChangeEPS
+#if IS_CC_ENABLED(ChangeEPS)
case TPM_CC_ChangeEPS:
return "ChangeEPS";
#endif
-#ifdef TPM_CC_ChangePPS
+#if IS_CC_ENABLED(ChangePPS)
case TPM_CC_ChangePPS:
return "ChangePPS";
#endif
-#ifdef TPM_CC_Clear
+#if IS_CC_ENABLED(Clear)
case TPM_CC_Clear:
return "Clear";
#endif
-#ifdef TPM_CC_ClearControl
+#if IS_CC_ENABLED(ClearControl)
case TPM_CC_ClearControl:
return "ClearControl";
#endif
-#ifdef TPM_CC_ClockRateAdjust
+#if IS_CC_ENABLED(ClockRateAdjust)
case TPM_CC_ClockRateAdjust:
return "ClockRateAdjust";
#endif
-#ifdef TPM_CC_ClockSet
+#if IS_CC_ENABLED(ClockSet)
case TPM_CC_ClockSet:
return "ClockSet";
#endif
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
case TPM_CC_Commit:
return "Commit";
#endif
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
case TPM_CC_ContextLoad:
return "ContextLoad";
#endif
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
case TPM_CC_ContextSave:
return "ContextSave";
#endif
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
case TPM_CC_Create:
return "Create";
#endif
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
case TPM_CC_CreatePrimary:
return "CreatePrimary";
#endif
-#ifdef TPM_CC_DictionaryAttackLockReset
+#if IS_CC_ENABLED(DictionaryAttackLockReset)
case TPM_CC_DictionaryAttackLockReset:
return "DictionaryAttackLockReset";
#endif
-#ifdef TPM_CC_DictionaryAttackParameters
+#if IS_CC_ENABLED(DictionaryAttackParameters)
case TPM_CC_DictionaryAttackParameters:
return "DictionaryAttackParameters";
#endif
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
case TPM_CC_Duplicate:
return "Duplicate";
#endif
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
case TPM_CC_ECC_Parameters:
return "ECC_Parameters";
#endif
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
case TPM_CC_ECDH_KeyGen:
return "ECDH_KeyGen";
#endif
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
case TPM_CC_ECDH_ZGen:
return "ECDH_ZGen";
#endif
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
case TPM_CC_EC_Ephemeral:
return "EC_Ephemeral";
#endif
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
case TPM_CC_EncryptDecrypt:
return "EncryptDecrypt";
#endif
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
case TPM_CC_EventSequenceComplete:
return "EventSequenceComplete";
#endif
-#ifdef TPM_CC_EvictControl
+#if IS_CC_ENABLED(EvictControl)
case TPM_CC_EvictControl:
return "EvictControl";
#endif
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
case TPM_CC_FieldUpgradeData:
return "FieldUpgradeData";
#endif
-#ifdef TPM_CC_FieldUpgradeStart
+#if IS_CC_ENABLED(FieldUpgradeStart)
case TPM_CC_FieldUpgradeStart:
return "FieldUpgradeStart";
#endif
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
case TPM_CC_FirmwareRead:
return "FirmwareRead";
#endif
-#ifdef TPM_CC_FlushContext
+#if IS_CC_ENABLED(FlushContext)
case TPM_CC_FlushContext:
return "FlushContext";
#endif
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
case TPM_CC_GetCapability:
return "GetCapability";
#endif
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
case TPM_CC_GetCommandAuditDigest:
return "GetCommandAuditDigest";
#endif
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
case TPM_CC_GetRandom:
return "GetRandom";
#endif
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
case TPM_CC_GetSessionAuditDigest:
return "GetSessionAuditDigest";
#endif
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
case TPM_CC_GetTestResult:
return "GetTestResult";
#endif
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
case TPM_CC_GetTime:
return "GetTime";
#endif
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
case TPM_CC_HMAC:
return "HMAC";
#endif
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
case TPM_CC_HMAC_Start:
return "HMAC_Start";
#endif
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
case TPM_CC_Hash:
return "Hash";
#endif
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
case TPM_CC_HashSequenceStart:
return "HashSequenceStart";
#endif
-#ifdef TPM_CC_HierarchyChangeAuth
+#if IS_CC_ENABLED(HierarchyChangeAuth)
case TPM_CC_HierarchyChangeAuth:
return "HierarchyChangeAuth";
#endif
-#ifdef TPM_CC_HierarchyControl
+#if IS_CC_ENABLED(HierarchyControl)
case TPM_CC_HierarchyControl:
return "HierarchyControl";
#endif
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
case TPM_CC_Import:
return "Import";
#endif
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
case TPM_CC_IncrementalSelfTest:
return "IncrementalSelfTest";
#endif
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
case TPM_CC_Load:
return "Load";
#endif
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
case TPM_CC_LoadExternal:
return "LoadExternal";
#endif
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
case TPM_CC_MakeCredential:
return "MakeCredential";
#endif
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
case TPM_CC_NV_Certify:
return "NV_Certify";
#endif
-#ifdef TPM_CC_NV_ChangeAuth
+#if IS_CC_ENABLED(NV_ChangeAuth)
case TPM_CC_NV_ChangeAuth:
return "NV_ChangeAuth";
#endif
-#ifdef TPM_CC_NV_DefineSpace
+#if IS_CC_ENABLED(NV_DefineSpace)
case TPM_CC_NV_DefineSpace:
return "NV_DefineSpace";
#endif
-#ifdef TPM_CC_NV_Extend
+#if IS_CC_ENABLED(NV_Extend)
case TPM_CC_NV_Extend:
return "NV_Extend";
#endif
-#ifdef TPM_CC_NV_GlobalWriteLock
+#if IS_CC_ENABLED(NV_GlobalWriteLock)
case TPM_CC_NV_GlobalWriteLock:
return "NV_GlobalWriteLock";
#endif
-#ifdef TPM_CC_NV_Increment
+#if IS_CC_ENABLED(NV_Increment)
case TPM_CC_NV_Increment:
return "NV_Increment";
#endif
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
case TPM_CC_NV_Read:
return "NV_Read";
#endif
-#ifdef TPM_CC_NV_ReadLock
+#if IS_CC_ENABLED(NV_ReadLock)
case TPM_CC_NV_ReadLock:
return "NV_ReadLock";
#endif
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
case TPM_CC_NV_ReadPublic:
return "NV_ReadPublic";
#endif
-#ifdef TPM_CC_NV_SetBits
+#if IS_CC_ENABLED(NV_SetBits)
case TPM_CC_NV_SetBits:
return "NV_SetBits";
#endif
-#ifdef TPM_CC_NV_UndefineSpace
+#if IS_CC_ENABLED(NV_UndefineSpace)
case TPM_CC_NV_UndefineSpace:
return "NV_UndefineSpace";
#endif
-#ifdef TPM_CC_NV_UndefineSpaceSpecial
+#if IS_CC_ENABLED(NV_UndefineSpaceSpecial)
case TPM_CC_NV_UndefineSpaceSpecial:
return "NV_UndefineSpaceSpecial";
#endif
-#ifdef TPM_CC_NV_Write
+#if IS_CC_ENABLED(NV_Write)
case TPM_CC_NV_Write:
return "NV_Write";
#endif
-#ifdef TPM_CC_NV_WriteLock
+#if IS_CC_ENABLED(NV_WriteLock)
case TPM_CC_NV_WriteLock:
return "NV_WriteLock";
#endif
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
case TPM_CC_ObjectChangeAuth:
return "ObjectChangeAuth";
#endif
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
case TPM_CC_PCR_Allocate:
return "PCR_Allocate";
#endif
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
case TPM_CC_PCR_Event:
return "PCR_Event";
#endif
-#ifdef TPM_CC_PCR_Extend
+#if IS_CC_ENABLED(PCR_Extend)
case TPM_CC_PCR_Extend:
return "PCR_Extend";
#endif
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
case TPM_CC_PCR_Read:
return "PCR_Read";
#endif
-#ifdef TPM_CC_PCR_Reset
+#if IS_CC_ENABLED(PCR_Reset)
case TPM_CC_PCR_Reset:
return "PCR_Reset";
#endif
-#ifdef TPM_CC_PCR_SetAuthPolicy
+#if IS_CC_ENABLED(PCR_SetAuthPolicy)
case TPM_CC_PCR_SetAuthPolicy:
return "PCR_SetAuthPolicy";
#endif
-#ifdef TPM_CC_PCR_SetAuthValue
+#if IS_CC_ENABLED(PCR_SetAuthValue)
case TPM_CC_PCR_SetAuthValue:
return "PCR_SetAuthValue";
#endif
-#ifdef TPM_CC_PP_Commands
+#if IS_CC_ENABLED(PP_Commands)
case TPM_CC_PP_Commands:
return "PP_Commands";
#endif
-#ifdef TPM_CC_PolicyAuthValue
+#if IS_CC_ENABLED(PolicyAuthValue)
case TPM_CC_PolicyAuthValue:
return "PolicyAuthValue";
#endif
-#ifdef TPM_CC_PolicyAuthorize
+#if IS_CC_ENABLED(PolicyAuthorize)
case TPM_CC_PolicyAuthorize:
return "PolicyAuthorize";
#endif
-#ifdef TPM_CC_PolicyCommandCode
+#if IS_CC_ENABLED(PolicyCommandCode)
case TPM_CC_PolicyCommandCode:
return "PolicyCommandCode";
#endif
-#ifdef TPM_CC_PolicyCounterTimer
+#if IS_CC_ENABLED(PolicyCounterTimer)
case TPM_CC_PolicyCounterTimer:
return "PolicyCounterTimer";
#endif
-#ifdef TPM_CC_PolicyCpHash
+#if IS_CC_ENABLED(PolicyCpHash)
case TPM_CC_PolicyCpHash:
return "PolicyCpHash";
#endif
-#ifdef TPM_CC_PolicyDuplicationSelect
+#if IS_CC_ENABLED(PolicyDuplicationSelect)
case TPM_CC_PolicyDuplicationSelect:
return "PolicyDuplicationSelect";
#endif
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
case TPM_CC_PolicyGetDigest:
return "PolicyGetDigest";
#endif
-#ifdef TPM_CC_PolicyLocality
+#if IS_CC_ENABLED(PolicyLocality)
case TPM_CC_PolicyLocality:
return "PolicyLocality";
#endif
-#ifdef TPM_CC_PolicyNV
+#if IS_CC_ENABLED(PolicyNV)
case TPM_CC_PolicyNV:
return "PolicyNV";
#endif
-#ifdef TPM_CC_PolicyNameHash
+#if IS_CC_ENABLED(PolicyNameHash)
case TPM_CC_PolicyNameHash:
return "PolicyNameHash";
#endif
-#ifdef TPM_CC_PolicyNvWritten
+#if IS_CC_ENABLED(PolicyNvWritten)
case TPM_CC_PolicyNvWritten:
return "PolicyNvWritten";
#endif
-#ifdef TPM_CC_PolicyOR
+#if IS_CC_ENABLED(PolicyOR)
case TPM_CC_PolicyOR:
return "PolicyOR";
#endif
-#ifdef TPM_CC_PolicyPCR
+#if IS_CC_ENABLED(PolicyPCR)
case TPM_CC_PolicyPCR:
return "PolicyPCR";
#endif
-#ifdef TPM_CC_PolicyPassword
+#if IS_CC_ENABLED(PolicyPassword)
case TPM_CC_PolicyPassword:
return "PolicyPassword";
#endif
-#ifdef TPM_CC_PolicyPhysicalPresence
+#if IS_CC_ENABLED(PolicyPhysicalPresence)
case TPM_CC_PolicyPhysicalPresence:
return "PolicyPhysicalPresence";
#endif
-#ifdef TPM_CC_PolicyRestart
+#if IS_CC_ENABLED(PolicyRestart)
case TPM_CC_PolicyRestart:
return "PolicyRestart";
#endif
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
case TPM_CC_PolicySecret:
return "PolicySecret";
#endif
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
case TPM_CC_PolicySigned:
return "PolicySigned";
#endif
-#ifdef TPM_CC_PolicyTicket
+#if IS_CC_ENABLED(PolicyTicket)
case TPM_CC_PolicyTicket:
return "PolicyTicket";
#endif
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
case TPM_CC_Quote:
return "Quote";
#endif
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
case TPM_CC_RSA_Decrypt:
return "RSA_Decrypt";
#endif
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
case TPM_CC_RSA_Encrypt:
return "RSA_Encrypt";
#endif
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
case TPM_CC_ReadClock:
return "ReadClock";
#endif
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
case TPM_CC_ReadPublic:
return "ReadPublic";
#endif
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
case TPM_CC_Rewrap:
return "Rewrap";
#endif
-#ifdef TPM_CC_SelfTest
+#if IS_CC_ENABLED(SelfTest)
case TPM_CC_SelfTest:
return "SelfTest";
#endif
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
case TPM_CC_SequenceComplete:
return "SequenceComplete";
#endif
-#ifdef TPM_CC_SequenceUpdate
+#if IS_CC_ENABLED(SequenceUpdate)
case TPM_CC_SequenceUpdate:
return "SequenceUpdate";
#endif
-#ifdef TPM_CC_SetAlgorithmSet
+#if IS_CC_ENABLED(SetAlgorithmSet)
case TPM_CC_SetAlgorithmSet:
return "SetAlgorithmSet";
#endif
-#ifdef TPM_CC_SetCommandCodeAuditStatus
+#if IS_CC_ENABLED(SetCommandCodeAuditStatus)
case TPM_CC_SetCommandCodeAuditStatus:
return "SetCommandCodeAuditStatus";
#endif
-#ifdef TPM_CC_SetPrimaryPolicy
+#if IS_CC_ENABLED(SetPrimaryPolicy)
case TPM_CC_SetPrimaryPolicy:
return "SetPrimaryPolicy";
#endif
-#ifdef TPM_CC_Shutdown
+#if IS_CC_ENABLED(Shutdown)
case TPM_CC_Shutdown:
return "Shutdown";
#endif
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
case TPM_CC_Sign:
return "Sign";
#endif
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
case TPM_CC_StartAuthSession:
return "StartAuthSession";
#endif
-#ifdef TPM_CC_Startup
+#if IS_CC_ENABLED(Startup)
case TPM_CC_Startup:
return "Startup";
#endif
-#ifdef TPM_CC_StirRandom
+#if IS_CC_ENABLED(StirRandom)
case TPM_CC_StirRandom:
return "StirRandom";
#endif
-#ifdef TPM_CC_TestParms
+#if IS_CC_ENABLED(TestParms)
case TPM_CC_TestParms:
return "TestParms";
#endif
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
case TPM_CC_Unseal:
return "Unseal";
#endif
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
case TPM_CC_VerifySignature:
return "VerifySignature";
#endif
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
case TPM_CC_ZGen_2Phase:
return "ZGen_2Phase";
#endif
diff --git a/HandleProcess.c b/HandleProcess.c
index 87e73fe..2d07d22 100644
--- a/HandleProcess.c
+++ b/HandleProcess.c
@@ -17,7 +17,7 @@
TPM_RC result = TPM_RC_SUCCESS;
*num_request_handles = 0;
switch (command_code) {
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
case TPM_CC_ActivateCredential:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -35,7 +35,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
case TPM_CC_Certify:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -53,7 +53,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
case TPM_CC_CertifyCreation:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -71,7 +71,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ChangeEPS
+#if IS_CC_ENABLED(ChangeEPS)
case TPM_CC_ChangeEPS:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -82,7 +82,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ChangePPS
+#if IS_CC_ENABLED(ChangePPS)
case TPM_CC_ChangePPS:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -93,7 +93,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Clear
+#if IS_CC_ENABLED(Clear)
case TPM_CC_Clear:
result = TPMI_RH_CLEAR_Unmarshal(
(TPMI_RH_CLEAR*)&request_handles[*num_request_handles],
@@ -104,7 +104,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ClearControl
+#if IS_CC_ENABLED(ClearControl)
case TPM_CC_ClearControl:
result = TPMI_RH_CLEAR_Unmarshal(
(TPMI_RH_CLEAR*)&request_handles[*num_request_handles],
@@ -115,7 +115,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ClockRateAdjust
+#if IS_CC_ENABLED(ClockRateAdjust)
case TPM_CC_ClockRateAdjust:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -126,7 +126,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ClockSet
+#if IS_CC_ENABLED(ClockSet)
case TPM_CC_ClockSet:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -137,7 +137,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
case TPM_CC_Commit:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -148,11 +148,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
case TPM_CC_ContextLoad:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
case TPM_CC_ContextSave:
result = TPMI_DH_CONTEXT_Unmarshal(
(TPMI_DH_CONTEXT*)&request_handles[*num_request_handles],
@@ -163,7 +163,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
case TPM_CC_Create:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -174,7 +174,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
case TPM_CC_CreatePrimary:
result = TPMI_RH_HIERARCHY_Unmarshal(
(TPMI_RH_HIERARCHY*)&request_handles[*num_request_handles],
@@ -185,7 +185,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_DictionaryAttackLockReset
+#if IS_CC_ENABLED(DictionaryAttackLockReset)
case TPM_CC_DictionaryAttackLockReset:
result = TPMI_RH_LOCKOUT_Unmarshal(
(TPMI_RH_LOCKOUT*)&request_handles[*num_request_handles],
@@ -196,7 +196,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_DictionaryAttackParameters
+#if IS_CC_ENABLED(DictionaryAttackParameters)
case TPM_CC_DictionaryAttackParameters:
result = TPMI_RH_LOCKOUT_Unmarshal(
(TPMI_RH_LOCKOUT*)&request_handles[*num_request_handles],
@@ -207,7 +207,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
case TPM_CC_Duplicate:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -225,11 +225,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
case TPM_CC_ECC_Parameters:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
case TPM_CC_ECDH_KeyGen:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -240,7 +240,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
case TPM_CC_ECDH_ZGen:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -251,11 +251,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
case TPM_CC_EC_Ephemeral:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
case TPM_CC_EncryptDecrypt:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -266,7 +266,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
case TPM_CC_EventSequenceComplete:
result = TPMI_DH_PCR_Unmarshal(
(TPMI_DH_PCR*)&request_handles[*num_request_handles],
@@ -284,7 +284,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_EvictControl
+#if IS_CC_ENABLED(EvictControl)
case TPM_CC_EvictControl:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -302,11 +302,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
case TPM_CC_FieldUpgradeData:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_FieldUpgradeStart
+#if IS_CC_ENABLED(FieldUpgradeStart)
case TPM_CC_FieldUpgradeStart:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -324,19 +324,19 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
case TPM_CC_FirmwareRead:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_FlushContext
+#if IS_CC_ENABLED(FlushContext)
case TPM_CC_FlushContext:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
case TPM_CC_GetCapability:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
case TPM_CC_GetCommandAuditDigest:
result = TPMI_RH_ENDORSEMENT_Unmarshal(
(TPMI_RH_ENDORSEMENT*)&request_handles[*num_request_handles],
@@ -354,11 +354,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
case TPM_CC_GetRandom:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
case TPM_CC_GetSessionAuditDigest:
result = TPMI_RH_ENDORSEMENT_Unmarshal(
(TPMI_RH_ENDORSEMENT*)&request_handles[*num_request_handles],
@@ -383,11 +383,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
case TPM_CC_GetTestResult:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
case TPM_CC_GetTime:
result = TPMI_RH_ENDORSEMENT_Unmarshal(
(TPMI_RH_ENDORSEMENT*)&request_handles[*num_request_handles],
@@ -405,7 +405,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
case TPM_CC_HMAC:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -416,7 +416,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
case TPM_CC_HMAC_Start:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -427,15 +427,15 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
case TPM_CC_Hash:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
case TPM_CC_HashSequenceStart:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_HierarchyChangeAuth
+#if IS_CC_ENABLED(HierarchyChangeAuth)
case TPM_CC_HierarchyChangeAuth:
result = TPMI_RH_HIERARCHY_AUTH_Unmarshal(
(TPMI_RH_HIERARCHY_AUTH*)&request_handles[*num_request_handles],
@@ -446,7 +446,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_HierarchyControl
+#if IS_CC_ENABLED(HierarchyControl)
case TPM_CC_HierarchyControl:
result = TPMI_RH_HIERARCHY_Unmarshal(
(TPMI_RH_HIERARCHY*)&request_handles[*num_request_handles],
@@ -457,7 +457,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
case TPM_CC_Import:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -468,11 +468,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
case TPM_CC_IncrementalSelfTest:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
case TPM_CC_Load:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -483,11 +483,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
case TPM_CC_LoadExternal:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
case TPM_CC_MakeCredential:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -498,7 +498,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
case TPM_CC_NV_Certify:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -523,7 +523,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_ChangeAuth
+#if IS_CC_ENABLED(NV_ChangeAuth)
case TPM_CC_NV_ChangeAuth:
result = TPMI_RH_NV_INDEX_Unmarshal(
(TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles],
@@ -534,7 +534,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_DefineSpace
+#if IS_CC_ENABLED(NV_DefineSpace)
case TPM_CC_NV_DefineSpace:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -545,7 +545,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_Extend
+#if IS_CC_ENABLED(NV_Extend)
case TPM_CC_NV_Extend:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -563,7 +563,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_GlobalWriteLock
+#if IS_CC_ENABLED(NV_GlobalWriteLock)
case TPM_CC_NV_GlobalWriteLock:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -574,7 +574,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_Increment
+#if IS_CC_ENABLED(NV_Increment)
case TPM_CC_NV_Increment:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -592,7 +592,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
case TPM_CC_NV_Read:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -610,7 +610,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_ReadLock
+#if IS_CC_ENABLED(NV_ReadLock)
case TPM_CC_NV_ReadLock:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -628,7 +628,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
case TPM_CC_NV_ReadPublic:
result = TPMI_RH_NV_INDEX_Unmarshal(
(TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles],
@@ -639,7 +639,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_SetBits
+#if IS_CC_ENABLED(NV_SetBits)
case TPM_CC_NV_SetBits:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -657,7 +657,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_UndefineSpace
+#if IS_CC_ENABLED(NV_UndefineSpace)
case TPM_CC_NV_UndefineSpace:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -675,7 +675,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_UndefineSpaceSpecial
+#if IS_CC_ENABLED(NV_UndefineSpaceSpecial)
case TPM_CC_NV_UndefineSpaceSpecial:
result = TPMI_RH_NV_INDEX_Unmarshal(
(TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles],
@@ -693,7 +693,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_Write
+#if IS_CC_ENABLED(NV_Write)
case TPM_CC_NV_Write:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -711,7 +711,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_NV_WriteLock
+#if IS_CC_ENABLED(NV_WriteLock)
case TPM_CC_NV_WriteLock:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -729,7 +729,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
case TPM_CC_ObjectChangeAuth:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -747,7 +747,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
case TPM_CC_PCR_Allocate:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -758,7 +758,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
case TPM_CC_PCR_Event:
result = TPMI_DH_PCR_Unmarshal(
(TPMI_DH_PCR*)&request_handles[*num_request_handles],
@@ -769,7 +769,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_Extend
+#if IS_CC_ENABLED(PCR_Extend)
case TPM_CC_PCR_Extend:
result = TPMI_DH_PCR_Unmarshal(
(TPMI_DH_PCR*)&request_handles[*num_request_handles],
@@ -780,11 +780,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
case TPM_CC_PCR_Read:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_Reset
+#if IS_CC_ENABLED(PCR_Reset)
case TPM_CC_PCR_Reset:
result = TPMI_DH_PCR_Unmarshal(
(TPMI_DH_PCR*)&request_handles[*num_request_handles],
@@ -795,7 +795,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_SetAuthPolicy
+#if IS_CC_ENABLED(PCR_SetAuthPolicy)
case TPM_CC_PCR_SetAuthPolicy:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -813,7 +813,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PCR_SetAuthValue
+#if IS_CC_ENABLED(PCR_SetAuthValue)
case TPM_CC_PCR_SetAuthValue:
result = TPMI_DH_PCR_Unmarshal(
(TPMI_DH_PCR*)&request_handles[*num_request_handles],
@@ -824,7 +824,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PP_Commands
+#if IS_CC_ENABLED(PP_Commands)
case TPM_CC_PP_Commands:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -835,7 +835,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyAuthValue
+#if IS_CC_ENABLED(PolicyAuthValue)
case TPM_CC_PolicyAuthValue:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -846,7 +846,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyAuthorize
+#if IS_CC_ENABLED(PolicyAuthorize)
case TPM_CC_PolicyAuthorize:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -857,7 +857,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyCommandCode
+#if IS_CC_ENABLED(PolicyCommandCode)
case TPM_CC_PolicyCommandCode:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -868,7 +868,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyCounterTimer
+#if IS_CC_ENABLED(PolicyCounterTimer)
case TPM_CC_PolicyCounterTimer:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -879,7 +879,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyCpHash
+#if IS_CC_ENABLED(PolicyCpHash)
case TPM_CC_PolicyCpHash:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -890,7 +890,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyDuplicationSelect
+#if IS_CC_ENABLED(PolicyDuplicationSelect)
case TPM_CC_PolicyDuplicationSelect:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -901,7 +901,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
case TPM_CC_PolicyGetDigest:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -912,7 +912,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyLocality
+#if IS_CC_ENABLED(PolicyLocality)
case TPM_CC_PolicyLocality:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -923,7 +923,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyNV
+#if IS_CC_ENABLED(PolicyNV)
case TPM_CC_PolicyNV:
result = TPMI_RH_NV_AUTH_Unmarshal(
(TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles],
@@ -948,7 +948,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyNameHash
+#if IS_CC_ENABLED(PolicyNameHash)
case TPM_CC_PolicyNameHash:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -959,7 +959,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyNvWritten
+#if IS_CC_ENABLED(PolicyNvWritten)
case TPM_CC_PolicyNvWritten:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -970,7 +970,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyOR
+#if IS_CC_ENABLED(PolicyOR)
case TPM_CC_PolicyOR:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -981,7 +981,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyPCR
+#if IS_CC_ENABLED(PolicyPCR)
case TPM_CC_PolicyPCR:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -992,7 +992,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyPassword
+#if IS_CC_ENABLED(PolicyPassword)
case TPM_CC_PolicyPassword:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -1003,7 +1003,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyPhysicalPresence
+#if IS_CC_ENABLED(PolicyPhysicalPresence)
case TPM_CC_PolicyPhysicalPresence:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -1014,7 +1014,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyRestart
+#if IS_CC_ENABLED(PolicyRestart)
case TPM_CC_PolicyRestart:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -1025,7 +1025,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
case TPM_CC_PolicySecret:
result = TPMI_DH_ENTITY_Unmarshal(
(TPMI_DH_ENTITY*)&request_handles[*num_request_handles],
@@ -1043,7 +1043,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
case TPM_CC_PolicySigned:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1061,7 +1061,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_PolicyTicket
+#if IS_CC_ENABLED(PolicyTicket)
case TPM_CC_PolicyTicket:
result = TPMI_SH_POLICY_Unmarshal(
(TPMI_SH_POLICY*)&request_handles[*num_request_handles],
@@ -1072,7 +1072,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
case TPM_CC_Quote:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1083,7 +1083,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
case TPM_CC_RSA_Decrypt:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1094,7 +1094,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
case TPM_CC_RSA_Encrypt:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1105,11 +1105,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
case TPM_CC_ReadClock:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
case TPM_CC_ReadPublic:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1120,7 +1120,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
case TPM_CC_Rewrap:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1138,11 +1138,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_SelfTest
+#if IS_CC_ENABLED(SelfTest)
case TPM_CC_SelfTest:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
case TPM_CC_SequenceComplete:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1153,7 +1153,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_SequenceUpdate
+#if IS_CC_ENABLED(SequenceUpdate)
case TPM_CC_SequenceUpdate:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1164,7 +1164,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_SetAlgorithmSet
+#if IS_CC_ENABLED(SetAlgorithmSet)
case TPM_CC_SetAlgorithmSet:
result = TPMI_RH_PLATFORM_Unmarshal(
(TPMI_RH_PLATFORM*)&request_handles[*num_request_handles],
@@ -1175,7 +1175,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_SetCommandCodeAuditStatus
+#if IS_CC_ENABLED(SetCommandCodeAuditStatus)
case TPM_CC_SetCommandCodeAuditStatus:
result = TPMI_RH_PROVISION_Unmarshal(
(TPMI_RH_PROVISION*)&request_handles[*num_request_handles],
@@ -1186,7 +1186,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_SetPrimaryPolicy
+#if IS_CC_ENABLED(SetPrimaryPolicy)
case TPM_CC_SetPrimaryPolicy:
result = TPMI_RH_HIERARCHY_AUTH_Unmarshal(
(TPMI_RH_HIERARCHY_AUTH*)&request_handles[*num_request_handles],
@@ -1197,11 +1197,11 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Shutdown
+#if IS_CC_ENABLED(Shutdown)
case TPM_CC_Shutdown:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
case TPM_CC_Sign:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1212,7 +1212,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
case TPM_CC_StartAuthSession:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1230,19 +1230,19 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Startup
+#if IS_CC_ENABLED(Startup)
case TPM_CC_Startup:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_StirRandom
+#if IS_CC_ENABLED(StirRandom)
case TPM_CC_StirRandom:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_TestParms
+#if IS_CC_ENABLED(TestParms)
case TPM_CC_TestParms:
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
case TPM_CC_Unseal:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1253,7 +1253,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
case TPM_CC_VerifySignature:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
@@ -1264,7 +1264,7 @@
++(*num_request_handles);
return TPM_RC_SUCCESS;
#endif
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
case TPM_CC_ZGen_2Phase:
result = TPMI_DH_OBJECT_Unmarshal(
(TPMI_DH_OBJECT*)&request_handles[*num_request_handles],
diff --git a/Marshal_ActivateCredential.c b/Marshal_ActivateCredential.c
index 50aa210..a9a79f9 100644
--- a/Marshal_ActivateCredential.c
+++ b/Marshal_ActivateCredential.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ActivateCredential_fp.h"
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
static UINT16 ActivateCredential_Out_Marshal(ActivateCredential_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -68,7 +68,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ActivateCredential_In in;
ActivateCredential_Out out;
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -89,7 +89,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ActivateCredential) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ActivateCredential_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_Certify.c b/Marshal_Certify.c
index d484954..1a04fef 100644
--- a/Marshal_Certify.c
+++ b/Marshal_Certify.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Certify_fp.h"
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
static UINT16 Certify_Out_Marshal(Certify_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -69,7 +69,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Certify_In in;
Certify_Out out;
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -89,7 +89,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Certify) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_CertifyCreation.c b/Marshal_CertifyCreation.c
index 8fd265a..8e7299e 100644
--- a/Marshal_CertifyCreation.c
+++ b/Marshal_CertifyCreation.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "CertifyCreation_fp.h"
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
static UINT16 CertifyCreation_Out_Marshal(CertifyCreation_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -77,7 +77,7 @@
TPM_RC result = TPM_RC_SUCCESS;
CertifyCreation_In in;
CertifyCreation_Out out;
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -98,7 +98,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
response_buffer = MemoryGetResponseBuffer(TPM_CC_CertifyCreation) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = CertifyCreation_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_ChangeEPS.c b/Marshal_ChangeEPS.c
index ac8c81a..5465410 100644
--- a/Marshal_ChangeEPS.c
+++ b/Marshal_ChangeEPS.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
ChangeEPS_In in;
-#ifdef TPM_CC_ChangeEPS
+#if IS_CC_ENABLED(ChangeEPS)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_ChangeEPS
+#if IS_CC_ENABLED(ChangeEPS)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ChangeEPS) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_ChangePPS.c b/Marshal_ChangePPS.c
index 3077533..45c6317 100644
--- a/Marshal_ChangePPS.c
+++ b/Marshal_ChangePPS.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
ChangePPS_In in;
-#ifdef TPM_CC_ChangePPS
+#if IS_CC_ENABLED(ChangePPS)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_ChangePPS
+#if IS_CC_ENABLED(ChangePPS)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ChangePPS) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Clear.c b/Marshal_Clear.c
index 7bdec13..b8fb5db 100644
--- a/Marshal_Clear.c
+++ b/Marshal_Clear.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
Clear_In in;
-#ifdef TPM_CC_Clear
+#if IS_CC_ENABLED(Clear)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -45,7 +45,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_Clear
+#if IS_CC_ENABLED(Clear)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Clear) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_ClearControl.c b/Marshal_ClearControl.c
index 62c75cc..95ed213 100644
--- a/Marshal_ClearControl.c
+++ b/Marshal_ClearControl.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
ClearControl_In in;
-#ifdef TPM_CC_ClearControl
+#if IS_CC_ENABLED(ClearControl)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_ClearControl
+#if IS_CC_ENABLED(ClearControl)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ClearControl) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_ClockRateAdjust.c b/Marshal_ClockRateAdjust.c
index be26946..f41c497 100644
--- a/Marshal_ClockRateAdjust.c
+++ b/Marshal_ClockRateAdjust.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
ClockRateAdjust_In in;
-#ifdef TPM_CC_ClockRateAdjust
+#if IS_CC_ENABLED(ClockRateAdjust)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_ClockRateAdjust
+#if IS_CC_ENABLED(ClockRateAdjust)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ClockRateAdjust) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_ClockSet.c b/Marshal_ClockSet.c
index 27b7e53..c0afe97 100644
--- a/Marshal_ClockSet.c
+++ b/Marshal_ClockSet.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
ClockSet_In in;
-#ifdef TPM_CC_ClockSet
+#if IS_CC_ENABLED(ClockSet)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -50,7 +50,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_ClockSet
+#if IS_CC_ENABLED(ClockSet)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ClockSet) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Commit.c b/Marshal_Commit.c
index dffe253..01c4852 100644
--- a/Marshal_Commit.c
+++ b/Marshal_Commit.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Commit_fp.h"
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
static UINT16 Commit_Out_Marshal(Commit_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -74,7 +74,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Commit_In in;
Commit_Out out;
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -94,7 +94,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Commit) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_ContextLoad.c b/Marshal_ContextLoad.c
index 72158b1..ddd3e5d 100644
--- a/Marshal_ContextLoad.c
+++ b/Marshal_ContextLoad.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ContextLoad_fp.h"
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
static UINT16 ContextLoad_Out_Marshal(ContextLoad_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -61,7 +61,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ContextLoad_In in;
ContextLoad_Out out;
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -82,7 +82,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ContextLoad) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ContextLoad_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_ContextSave.c b/Marshal_ContextSave.c
index c5e3928..3d4c968 100644
--- a/Marshal_ContextSave.c
+++ b/Marshal_ContextSave.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ContextSave_fp.h"
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
static UINT16 ContextSave_Out_Marshal(ContextSave_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -58,7 +58,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ContextSave_In in;
ContextSave_Out out;
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -79,7 +79,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ContextSave) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ContextSave_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_Create.c b/Marshal_Create.c
index 283c6ef..9d363d2 100644
--- a/Marshal_Create.c
+++ b/Marshal_Create.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Create_fp.h"
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
static UINT16 Create_Out_Marshal(Create_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -80,7 +80,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Create_In in;
Create_Out out;
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -100,7 +100,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Create) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_CreatePrimary.c b/Marshal_CreatePrimary.c
index e72b01c..b518b4c 100644
--- a/Marshal_CreatePrimary.c
+++ b/Marshal_CreatePrimary.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "CreatePrimary_fp.h"
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
static UINT16 CreatePrimary_Out_Marshal(CreatePrimary_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -82,7 +82,7 @@
TPM_RC result = TPM_RC_SUCCESS;
CreatePrimary_In in;
CreatePrimary_Out out;
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -103,7 +103,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
response_buffer = MemoryGetResponseBuffer(TPM_CC_CreatePrimary) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = CreatePrimary_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_DictionaryAttackLockReset.c b/Marshal_DictionaryAttackLockReset.c
index 0d20fa0..a0e38e6 100644
--- a/Marshal_DictionaryAttackLockReset.c
+++ b/Marshal_DictionaryAttackLockReset.c
@@ -29,7 +29,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
DictionaryAttackLockReset_In in;
-#ifdef TPM_CC_DictionaryAttackLockReset
+#if IS_CC_ENABLED(DictionaryAttackLockReset)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -47,7 +47,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_DictionaryAttackLockReset
+#if IS_CC_ENABLED(DictionaryAttackLockReset)
response_buffer =
MemoryGetResponseBuffer(TPM_CC_DictionaryAttackLockReset) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
diff --git a/Marshal_DictionaryAttackParameters.c b/Marshal_DictionaryAttackParameters.c
index 437bd2a..2bad1fc 100644
--- a/Marshal_DictionaryAttackParameters.c
+++ b/Marshal_DictionaryAttackParameters.c
@@ -42,7 +42,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
DictionaryAttackParameters_In in;
-#ifdef TPM_CC_DictionaryAttackParameters
+#if IS_CC_ENABLED(DictionaryAttackParameters)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -60,7 +60,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_DictionaryAttackParameters
+#if IS_CC_ENABLED(DictionaryAttackParameters)
response_buffer =
MemoryGetResponseBuffer(TPM_CC_DictionaryAttackParameters) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
diff --git a/Marshal_Duplicate.c b/Marshal_Duplicate.c
index 9df322d..a54ce15 100644
--- a/Marshal_Duplicate.c
+++ b/Marshal_Duplicate.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Duplicate_fp.h"
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
static UINT16 Duplicate_Out_Marshal(Duplicate_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Duplicate_In in;
Duplicate_Out out;
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Duplicate) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_ECC_Parameters.c b/Marshal_ECC_Parameters.c
index bc8351e..f605f10 100644
--- a/Marshal_ECC_Parameters.c
+++ b/Marshal_ECC_Parameters.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ECC_Parameters_fp.h"
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
static UINT16 ECC_Parameters_Out_Marshal(ECC_Parameters_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -62,7 +62,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ECC_Parameters_In in;
ECC_Parameters_Out out;
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -83,7 +83,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ECC_Parameters) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ECC_Parameters_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_ECDH_KeyGen.c b/Marshal_ECDH_KeyGen.c
index ecba118..fc32eb4 100644
--- a/Marshal_ECDH_KeyGen.c
+++ b/Marshal_ECDH_KeyGen.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ECDH_KeyGen_fp.h"
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
static UINT16 ECDH_KeyGen_Out_Marshal(ECDH_KeyGen_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -59,7 +59,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ECDH_KeyGen_In in;
ECDH_KeyGen_Out out;
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -80,7 +80,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ECDH_KeyGen) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ECDH_KeyGen_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_ECDH_ZGen.c b/Marshal_ECDH_ZGen.c
index 7bef6f9..220e588 100644
--- a/Marshal_ECDH_ZGen.c
+++ b/Marshal_ECDH_ZGen.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ECDH_ZGen_fp.h"
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
static UINT16 ECDH_ZGen_Out_Marshal(ECDH_ZGen_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -63,7 +63,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ECDH_ZGen_In in;
ECDH_ZGen_Out out;
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -84,7 +84,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ECDH_ZGen) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_EC_Ephemeral.c b/Marshal_EC_Ephemeral.c
index 3b2d929..bed68fb 100644
--- a/Marshal_EC_Ephemeral.c
+++ b/Marshal_EC_Ephemeral.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "EC_Ephemeral_fp.h"
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
static UINT16 EC_Ephemeral_Out_Marshal(EC_Ephemeral_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -62,7 +62,7 @@
TPM_RC result = TPM_RC_SUCCESS;
EC_Ephemeral_In in;
EC_Ephemeral_Out out;
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -83,7 +83,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
response_buffer = MemoryGetResponseBuffer(TPM_CC_EC_Ephemeral) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = EC_Ephemeral_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_EncryptDecrypt.c b/Marshal_EncryptDecrypt.c
index dc26e51..3004d5b 100644
--- a/Marshal_EncryptDecrypt.c
+++ b/Marshal_EncryptDecrypt.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "EncryptDecrypt_fp.h"
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
static UINT16 EncryptDecrypt_Out_Marshal(EncryptDecrypt_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -76,7 +76,7 @@
TPM_RC result = TPM_RC_SUCCESS;
EncryptDecrypt_In in;
EncryptDecrypt_Out out;
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -97,7 +97,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
response_buffer = MemoryGetResponseBuffer(TPM_CC_EncryptDecrypt) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = EncryptDecrypt_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_EventSequenceComplete.c b/Marshal_EventSequenceComplete.c
index 8d94137..0a8ae58 100644
--- a/Marshal_EventSequenceComplete.c
+++ b/Marshal_EventSequenceComplete.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "EventSequenceComplete_fp.h"
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
static UINT16 EventSequenceComplete_Out_Marshal(
EventSequenceComplete_Out* source,
TPMI_ST_COMMAND_TAG tag,
@@ -66,7 +66,7 @@
TPM_RC result = TPM_RC_SUCCESS;
EventSequenceComplete_In in;
EventSequenceComplete_Out out;
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -87,7 +87,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
response_buffer = MemoryGetResponseBuffer(TPM_CC_EventSequenceComplete) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = EventSequenceComplete_Out_Marshal(
diff --git a/Marshal_EvictControl.c b/Marshal_EvictControl.c
index 25078b4..9d26084 100644
--- a/Marshal_EvictControl.c
+++ b/Marshal_EvictControl.c
@@ -35,7 +35,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
EvictControl_In in;
-#ifdef TPM_CC_EvictControl
+#if IS_CC_ENABLED(EvictControl)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -53,7 +53,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_EvictControl
+#if IS_CC_ENABLED(EvictControl)
response_buffer = MemoryGetResponseBuffer(TPM_CC_EvictControl) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_FieldUpgradeData.c b/Marshal_FieldUpgradeData.c
index 2ffcc50..5e78590 100644
--- a/Marshal_FieldUpgradeData.c
+++ b/Marshal_FieldUpgradeData.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "FieldUpgradeData_fp.h"
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
static UINT16 FieldUpgradeData_Out_Marshal(FieldUpgradeData_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -62,7 +62,7 @@
TPM_RC result = TPM_RC_SUCCESS;
FieldUpgradeData_In in;
FieldUpgradeData_Out out;
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -83,7 +83,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
response_buffer = MemoryGetResponseBuffer(TPM_CC_FieldUpgradeData) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = FieldUpgradeData_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_FieldUpgradeStart.c b/Marshal_FieldUpgradeStart.c
index 75ab3e9..ea5cc44 100644
--- a/Marshal_FieldUpgradeStart.c
+++ b/Marshal_FieldUpgradeStart.c
@@ -38,7 +38,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
FieldUpgradeStart_In in;
-#ifdef TPM_CC_FieldUpgradeStart
+#if IS_CC_ENABLED(FieldUpgradeStart)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -56,7 +56,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_FieldUpgradeStart
+#if IS_CC_ENABLED(FieldUpgradeStart)
response_buffer = MemoryGetResponseBuffer(TPM_CC_FieldUpgradeStart) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_FirmwareRead.c b/Marshal_FirmwareRead.c
index d52ca14..67d6d49 100644
--- a/Marshal_FirmwareRead.c
+++ b/Marshal_FirmwareRead.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "FirmwareRead_fp.h"
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
static UINT16 FirmwareRead_Out_Marshal(FirmwareRead_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -61,7 +61,7 @@
TPM_RC result = TPM_RC_SUCCESS;
FirmwareRead_In in;
FirmwareRead_Out out;
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -82,7 +82,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
response_buffer = MemoryGetResponseBuffer(TPM_CC_FirmwareRead) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = FirmwareRead_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_FlushContext.c b/Marshal_FlushContext.c
index bc56f70..acbeafb 100644
--- a/Marshal_FlushContext.c
+++ b/Marshal_FlushContext.c
@@ -31,7 +31,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
FlushContext_In in;
-#ifdef TPM_CC_FlushContext
+#if IS_CC_ENABLED(FlushContext)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -49,7 +49,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_FlushContext
+#if IS_CC_ENABLED(FlushContext)
response_buffer = MemoryGetResponseBuffer(TPM_CC_FlushContext) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_GetCapability.c b/Marshal_GetCapability.c
index b3ed58c..64b3a13 100644
--- a/Marshal_GetCapability.c
+++ b/Marshal_GetCapability.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "GetCapability_fp.h"
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
static UINT16 GetCapability_Out_Marshal(GetCapability_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
GetCapability_In in;
GetCapability_Out out;
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
response_buffer = MemoryGetResponseBuffer(TPM_CC_GetCapability) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = GetCapability_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_GetCommandAuditDigest.c b/Marshal_GetCommandAuditDigest.c
index ff7b745..107b728 100644
--- a/Marshal_GetCommandAuditDigest.c
+++ b/Marshal_GetCommandAuditDigest.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "GetCommandAuditDigest_fp.h"
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
static UINT16 GetCommandAuditDigest_Out_Marshal(
GetCommandAuditDigest_Out* source,
TPMI_ST_COMMAND_TAG tag,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
GetCommandAuditDigest_In in;
GetCommandAuditDigest_Out out;
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
response_buffer = MemoryGetResponseBuffer(TPM_CC_GetCommandAuditDigest) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = GetCommandAuditDigest_Out_Marshal(
diff --git a/Marshal_GetRandom.c b/Marshal_GetRandom.c
index 967bb67..abe2eec 100644
--- a/Marshal_GetRandom.c
+++ b/Marshal_GetRandom.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "GetRandom_fp.h"
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
static UINT16 GetRandom_Out_Marshal(GetRandom_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -61,7 +61,7 @@
TPM_RC result = TPM_RC_SUCCESS;
GetRandom_In in;
GetRandom_Out out;
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -82,7 +82,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
response_buffer = MemoryGetResponseBuffer(TPM_CC_GetRandom) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_GetSessionAuditDigest.c b/Marshal_GetSessionAuditDigest.c
index f48ab81..822d8fa 100644
--- a/Marshal_GetSessionAuditDigest.c
+++ b/Marshal_GetSessionAuditDigest.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "GetSessionAuditDigest_fp.h"
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
static UINT16 GetSessionAuditDigest_Out_Marshal(
GetSessionAuditDigest_Out* source,
TPMI_ST_COMMAND_TAG tag,
@@ -72,7 +72,7 @@
TPM_RC result = TPM_RC_SUCCESS;
GetSessionAuditDigest_In in;
GetSessionAuditDigest_Out out;
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -93,7 +93,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
response_buffer = MemoryGetResponseBuffer(TPM_CC_GetSessionAuditDigest) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = GetSessionAuditDigest_Out_Marshal(
diff --git a/Marshal_GetTestResult.c b/Marshal_GetTestResult.c
index e42bd13..2e549c0 100644
--- a/Marshal_GetTestResult.c
+++ b/Marshal_GetTestResult.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "GetTestResult_fp.h"
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
static UINT16 GetTestResult_Out_Marshal(GetTestResult_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -45,7 +45,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
GetTestResult_Out out;
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -60,7 +60,7 @@
}
// Marshal output structure containing response handles and parameters to
// response buffer.
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
response_buffer = MemoryGetResponseBuffer(TPM_CC_GetTestResult) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = GetTestResult_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_GetTime.c b/Marshal_GetTime.c
index fc6bd50..23df0b6 100644
--- a/Marshal_GetTime.c
+++ b/Marshal_GetTime.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "GetTime_fp.h"
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
static UINT16 GetTime_Out_Marshal(GetTime_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -69,7 +69,7 @@
TPM_RC result = TPM_RC_SUCCESS;
GetTime_In in;
GetTime_Out out;
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -89,7 +89,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
response_buffer = MemoryGetResponseBuffer(TPM_CC_GetTime) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_HMAC.c b/Marshal_HMAC.c
index fa866dd..b8674a0 100644
--- a/Marshal_HMAC.c
+++ b/Marshal_HMAC.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "HMAC_fp.h"
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
static UINT16 HMAC_Out_Marshal(HMAC_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -67,7 +67,7 @@
TPM_RC result = TPM_RC_SUCCESS;
HMAC_In in;
HMAC_Out out;
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -87,7 +87,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
response_buffer = MemoryGetResponseBuffer(TPM_CC_HMAC) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_HMAC_Start.c b/Marshal_HMAC_Start.c
index b4f2d81..8c82c3f 100644
--- a/Marshal_HMAC_Start.c
+++ b/Marshal_HMAC_Start.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "HMAC_Start_fp.h"
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
static UINT16 HMAC_Start_Out_Marshal(HMAC_Start_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -67,7 +67,7 @@
TPM_RC result = TPM_RC_SUCCESS;
HMAC_Start_In in;
HMAC_Start_Out out;
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -88,7 +88,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
response_buffer = MemoryGetResponseBuffer(TPM_CC_HMAC_Start) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = HMAC_Start_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_Hash.c b/Marshal_Hash.c
index 8495552..352139d 100644
--- a/Marshal_Hash.c
+++ b/Marshal_Hash.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Hash_fp.h"
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
static UINT16 Hash_Out_Marshal(Hash_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -70,7 +70,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Hash_In in;
Hash_Out out;
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -90,7 +90,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Hash) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_HashSequenceStart.c b/Marshal_HashSequenceStart.c
index 5e9a410..b5405c1 100644
--- a/Marshal_HashSequenceStart.c
+++ b/Marshal_HashSequenceStart.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "HashSequenceStart_fp.h"
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
static UINT16 HashSequenceStart_Out_Marshal(HashSequenceStart_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -65,7 +65,7 @@
TPM_RC result = TPM_RC_SUCCESS;
HashSequenceStart_In in;
HashSequenceStart_Out out;
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -86,7 +86,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
response_buffer = MemoryGetResponseBuffer(TPM_CC_HashSequenceStart) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = HashSequenceStart_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_HierarchyChangeAuth.c b/Marshal_HierarchyChangeAuth.c
index 9dde496..1fefb75 100644
--- a/Marshal_HierarchyChangeAuth.c
+++ b/Marshal_HierarchyChangeAuth.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
HierarchyChangeAuth_In in;
-#ifdef TPM_CC_HierarchyChangeAuth
+#if IS_CC_ENABLED(HierarchyChangeAuth)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_HierarchyChangeAuth
+#if IS_CC_ENABLED(HierarchyChangeAuth)
response_buffer = MemoryGetResponseBuffer(TPM_CC_HierarchyChangeAuth) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_HierarchyControl.c b/Marshal_HierarchyControl.c
index 9d02ec7..cbfe2e3 100644
--- a/Marshal_HierarchyControl.c
+++ b/Marshal_HierarchyControl.c
@@ -37,7 +37,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
HierarchyControl_In in;
-#ifdef TPM_CC_HierarchyControl
+#if IS_CC_ENABLED(HierarchyControl)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -55,7 +55,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_HierarchyControl
+#if IS_CC_ENABLED(HierarchyControl)
response_buffer = MemoryGetResponseBuffer(TPM_CC_HierarchyControl) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Import.c b/Marshal_Import.c
index 946a179..a43f6bc 100644
--- a/Marshal_Import.c
+++ b/Marshal_Import.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Import_fp.h"
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
static UINT16 Import_Out_Marshal(Import_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -79,7 +79,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Import_In in;
Import_Out out;
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -99,7 +99,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Import) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_IncrementalSelfTest.c b/Marshal_IncrementalSelfTest.c
index d1d3148..2dfa1d0 100644
--- a/Marshal_IncrementalSelfTest.c
+++ b/Marshal_IncrementalSelfTest.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "IncrementalSelfTest_fp.h"
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
static UINT16 IncrementalSelfTest_Out_Marshal(IncrementalSelfTest_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -61,7 +61,7 @@
TPM_RC result = TPM_RC_SUCCESS;
IncrementalSelfTest_In in;
IncrementalSelfTest_Out out;
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -82,7 +82,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
response_buffer = MemoryGetResponseBuffer(TPM_CC_IncrementalSelfTest) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = IncrementalSelfTest_Out_Marshal(
diff --git a/Marshal_Load.c b/Marshal_Load.c
index d8e9880..17e1b71 100644
--- a/Marshal_Load.c
+++ b/Marshal_Load.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Load_fp.h"
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
static UINT16 Load_Out_Marshal(Load_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -69,7 +69,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Load_In in;
Load_Out out;
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -89,7 +89,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Load) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_LoadExternal.c b/Marshal_LoadExternal.c
index ba6ce14..f76c03a 100644
--- a/Marshal_LoadExternal.c
+++ b/Marshal_LoadExternal.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "LoadExternal_fp.h"
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
static UINT16 LoadExternal_Out_Marshal(LoadExternal_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
LoadExternal_In in;
LoadExternal_Out out;
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
response_buffer = MemoryGetResponseBuffer(TPM_CC_LoadExternal) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = LoadExternal_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_MakeCredential.c b/Marshal_MakeCredential.c
index cac49c5..819b160 100644
--- a/Marshal_MakeCredential.c
+++ b/Marshal_MakeCredential.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "MakeCredential_fp.h"
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
static UINT16 MakeCredential_Out_Marshal(MakeCredential_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -68,7 +68,7 @@
TPM_RC result = TPM_RC_SUCCESS;
MakeCredential_In in;
MakeCredential_Out out;
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -89,7 +89,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
response_buffer = MemoryGetResponseBuffer(TPM_CC_MakeCredential) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = MakeCredential_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_NV_Certify.c b/Marshal_NV_Certify.c
index 9775867..e5b0d46 100644
--- a/Marshal_NV_Certify.c
+++ b/Marshal_NV_Certify.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "NV_Certify_fp.h"
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
static UINT16 NV_Certify_Out_Marshal(NV_Certify_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -78,7 +78,7 @@
TPM_RC result = TPM_RC_SUCCESS;
NV_Certify_In in;
NV_Certify_Out out;
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -99,7 +99,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_Certify) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = NV_Certify_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_NV_ChangeAuth.c b/Marshal_NV_ChangeAuth.c
index 1e9a6c5..b2ff345 100644
--- a/Marshal_NV_ChangeAuth.c
+++ b/Marshal_NV_ChangeAuth.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_ChangeAuth_In in;
-#ifdef TPM_CC_NV_ChangeAuth
+#if IS_CC_ENABLED(NV_ChangeAuth)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_ChangeAuth
+#if IS_CC_ENABLED(NV_ChangeAuth)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_ChangeAuth) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_DefineSpace.c b/Marshal_NV_DefineSpace.c
index 7632fcc..9fa4cff 100644
--- a/Marshal_NV_DefineSpace.c
+++ b/Marshal_NV_DefineSpace.c
@@ -37,7 +37,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_DefineSpace_In in;
-#ifdef TPM_CC_NV_DefineSpace
+#if IS_CC_ENABLED(NV_DefineSpace)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -55,7 +55,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_DefineSpace
+#if IS_CC_ENABLED(NV_DefineSpace)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_DefineSpace) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_Extend.c b/Marshal_NV_Extend.c
index db66ac2..e1dfc14 100644
--- a/Marshal_NV_Extend.c
+++ b/Marshal_NV_Extend.c
@@ -34,7 +34,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_Extend_In in;
-#ifdef TPM_CC_NV_Extend
+#if IS_CC_ENABLED(NV_Extend)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -52,7 +52,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_Extend
+#if IS_CC_ENABLED(NV_Extend)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_Extend) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_GlobalWriteLock.c b/Marshal_NV_GlobalWriteLock.c
index ab82c0b..e5c8648 100644
--- a/Marshal_NV_GlobalWriteLock.c
+++ b/Marshal_NV_GlobalWriteLock.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_GlobalWriteLock_In in;
-#ifdef TPM_CC_NV_GlobalWriteLock
+#if IS_CC_ENABLED(NV_GlobalWriteLock)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_GlobalWriteLock
+#if IS_CC_ENABLED(NV_GlobalWriteLock)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_GlobalWriteLock) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_Increment.c b/Marshal_NV_Increment.c
index 39db565..fa0e7e2 100644
--- a/Marshal_NV_Increment.c
+++ b/Marshal_NV_Increment.c
@@ -29,7 +29,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_Increment_In in;
-#ifdef TPM_CC_NV_Increment
+#if IS_CC_ENABLED(NV_Increment)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -47,7 +47,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_Increment
+#if IS_CC_ENABLED(NV_Increment)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_Increment) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_Read.c b/Marshal_NV_Read.c
index c88f110..b4928d0 100644
--- a/Marshal_NV_Read.c
+++ b/Marshal_NV_Read.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "NV_Read_fp.h"
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
static UINT16 NV_Read_Out_Marshal(NV_Read_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -68,7 +68,7 @@
TPM_RC result = TPM_RC_SUCCESS;
NV_Read_In in;
NV_Read_Out out;
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -88,7 +88,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_Read) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_NV_ReadLock.c b/Marshal_NV_ReadLock.c
index 934fd47..dc4fda9 100644
--- a/Marshal_NV_ReadLock.c
+++ b/Marshal_NV_ReadLock.c
@@ -29,7 +29,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_ReadLock_In in;
-#ifdef TPM_CC_NV_ReadLock
+#if IS_CC_ENABLED(NV_ReadLock)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -47,7 +47,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_ReadLock
+#if IS_CC_ENABLED(NV_ReadLock)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_ReadLock) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_ReadPublic.c b/Marshal_NV_ReadPublic.c
index 407d81e..a7c8b60 100644
--- a/Marshal_NV_ReadPublic.c
+++ b/Marshal_NV_ReadPublic.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "NV_ReadPublic_fp.h"
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
static UINT16 NV_ReadPublic_Out_Marshal(NV_ReadPublic_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -59,7 +59,7 @@
TPM_RC result = TPM_RC_SUCCESS;
NV_ReadPublic_In in;
NV_ReadPublic_Out out;
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -80,7 +80,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_ReadPublic) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = NV_ReadPublic_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_NV_SetBits.c b/Marshal_NV_SetBits.c
index 09c1aec..fd7ef24 100644
--- a/Marshal_NV_SetBits.c
+++ b/Marshal_NV_SetBits.c
@@ -34,7 +34,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_SetBits_In in;
-#ifdef TPM_CC_NV_SetBits
+#if IS_CC_ENABLED(NV_SetBits)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -52,7 +52,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_SetBits
+#if IS_CC_ENABLED(NV_SetBits)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_SetBits) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_UndefineSpace.c b/Marshal_NV_UndefineSpace.c
index 7120953..dddad1d 100644
--- a/Marshal_NV_UndefineSpace.c
+++ b/Marshal_NV_UndefineSpace.c
@@ -29,7 +29,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_UndefineSpace_In in;
-#ifdef TPM_CC_NV_UndefineSpace
+#if IS_CC_ENABLED(NV_UndefineSpace)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -47,7 +47,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_UndefineSpace
+#if IS_CC_ENABLED(NV_UndefineSpace)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_UndefineSpace) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_UndefineSpaceSpecial.c b/Marshal_NV_UndefineSpaceSpecial.c
index c27e19a..26841e2 100644
--- a/Marshal_NV_UndefineSpaceSpecial.c
+++ b/Marshal_NV_UndefineSpaceSpecial.c
@@ -30,7 +30,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_UndefineSpaceSpecial_In in;
-#ifdef TPM_CC_NV_UndefineSpaceSpecial
+#if IS_CC_ENABLED(NV_UndefineSpaceSpecial)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -48,7 +48,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_UndefineSpaceSpecial
+#if IS_CC_ENABLED(NV_UndefineSpaceSpecial)
response_buffer =
MemoryGetResponseBuffer(TPM_CC_NV_UndefineSpaceSpecial) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
diff --git a/Marshal_NV_Write.c b/Marshal_NV_Write.c
index 91531d3..23fb165 100644
--- a/Marshal_NV_Write.c
+++ b/Marshal_NV_Write.c
@@ -38,7 +38,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_Write_In in;
-#ifdef TPM_CC_NV_Write
+#if IS_CC_ENABLED(NV_Write)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -55,7 +55,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_Write
+#if IS_CC_ENABLED(NV_Write)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_Write) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_NV_WriteLock.c b/Marshal_NV_WriteLock.c
index 84be98f..48887c5 100644
--- a/Marshal_NV_WriteLock.c
+++ b/Marshal_NV_WriteLock.c
@@ -29,7 +29,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
NV_WriteLock_In in;
-#ifdef TPM_CC_NV_WriteLock
+#if IS_CC_ENABLED(NV_WriteLock)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -47,7 +47,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_NV_WriteLock
+#if IS_CC_ENABLED(NV_WriteLock)
response_buffer = MemoryGetResponseBuffer(TPM_CC_NV_WriteLock) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_ObjectChangeAuth.c b/Marshal_ObjectChangeAuth.c
index accba59..c2b3fe9 100644
--- a/Marshal_ObjectChangeAuth.c
+++ b/Marshal_ObjectChangeAuth.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ObjectChangeAuth_fp.h"
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
static UINT16 ObjectChangeAuth_Out_Marshal(ObjectChangeAuth_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -64,7 +64,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ObjectChangeAuth_In in;
ObjectChangeAuth_Out out;
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -85,7 +85,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ObjectChangeAuth) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ObjectChangeAuth_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_PCR_Allocate.c b/Marshal_PCR_Allocate.c
index 1324885..ae0ec70 100644
--- a/Marshal_PCR_Allocate.c
+++ b/Marshal_PCR_Allocate.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "PCR_Allocate_fp.h"
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
static UINT16 PCR_Allocate_Out_Marshal(PCR_Allocate_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -66,7 +66,7 @@
TPM_RC result = TPM_RC_SUCCESS;
PCR_Allocate_In in;
PCR_Allocate_Out out;
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -87,7 +87,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_Allocate) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = PCR_Allocate_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_PCR_Event.c b/Marshal_PCR_Event.c
index 7993676..4cf6ce8 100644
--- a/Marshal_PCR_Event.c
+++ b/Marshal_PCR_Event.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "PCR_Event_fp.h"
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
static UINT16 PCR_Event_Out_Marshal(PCR_Event_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -63,7 +63,7 @@
TPM_RC result = TPM_RC_SUCCESS;
PCR_Event_In in;
PCR_Event_Out out;
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -84,7 +84,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_Event) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_PCR_Extend.c b/Marshal_PCR_Extend.c
index f5956cb..0bcbde5 100644
--- a/Marshal_PCR_Extend.c
+++ b/Marshal_PCR_Extend.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PCR_Extend_In in;
-#ifdef TPM_CC_PCR_Extend
+#if IS_CC_ENABLED(PCR_Extend)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PCR_Extend
+#if IS_CC_ENABLED(PCR_Extend)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_Extend) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PCR_Read.c b/Marshal_PCR_Read.c
index d1ce956..1603282 100644
--- a/Marshal_PCR_Read.c
+++ b/Marshal_PCR_Read.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "PCR_Read_fp.h"
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
static UINT16 PCR_Read_Out_Marshal(PCR_Read_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -64,7 +64,7 @@
TPM_RC result = TPM_RC_SUCCESS;
PCR_Read_In in;
PCR_Read_Out out;
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -84,7 +84,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_Read) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_PCR_Reset.c b/Marshal_PCR_Reset.c
index ab60de2..a8c82a5 100644
--- a/Marshal_PCR_Reset.c
+++ b/Marshal_PCR_Reset.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PCR_Reset_In in;
-#ifdef TPM_CC_PCR_Reset
+#if IS_CC_ENABLED(PCR_Reset)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PCR_Reset
+#if IS_CC_ENABLED(PCR_Reset)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_Reset) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PCR_SetAuthPolicy.c b/Marshal_PCR_SetAuthPolicy.c
index b405dd0..87c30b7 100644
--- a/Marshal_PCR_SetAuthPolicy.c
+++ b/Marshal_PCR_SetAuthPolicy.c
@@ -38,7 +38,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PCR_SetAuthPolicy_In in;
-#ifdef TPM_CC_PCR_SetAuthPolicy
+#if IS_CC_ENABLED(PCR_SetAuthPolicy)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -56,7 +56,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PCR_SetAuthPolicy
+#if IS_CC_ENABLED(PCR_SetAuthPolicy)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_SetAuthPolicy) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PCR_SetAuthValue.c b/Marshal_PCR_SetAuthValue.c
index f308d26..cad7219 100644
--- a/Marshal_PCR_SetAuthValue.c
+++ b/Marshal_PCR_SetAuthValue.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PCR_SetAuthValue_In in;
-#ifdef TPM_CC_PCR_SetAuthValue
+#if IS_CC_ENABLED(PCR_SetAuthValue)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PCR_SetAuthValue
+#if IS_CC_ENABLED(PCR_SetAuthValue)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PCR_SetAuthValue) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PP_Commands.c b/Marshal_PP_Commands.c
index 09efee3..68c2462 100644
--- a/Marshal_PP_Commands.c
+++ b/Marshal_PP_Commands.c
@@ -37,7 +37,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PP_Commands_In in;
-#ifdef TPM_CC_PP_Commands
+#if IS_CC_ENABLED(PP_Commands)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -55,7 +55,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PP_Commands
+#if IS_CC_ENABLED(PP_Commands)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PP_Commands) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyAuthValue.c b/Marshal_PolicyAuthValue.c
index 1ad6a2e..36fdbf1 100644
--- a/Marshal_PolicyAuthValue.c
+++ b/Marshal_PolicyAuthValue.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyAuthValue_In in;
-#ifdef TPM_CC_PolicyAuthValue
+#if IS_CC_ENABLED(PolicyAuthValue)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyAuthValue
+#if IS_CC_ENABLED(PolicyAuthValue)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyAuthValue) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyAuthorize.c b/Marshal_PolicyAuthorize.c
index 634c9c8..a5c14df 100644
--- a/Marshal_PolicyAuthorize.c
+++ b/Marshal_PolicyAuthorize.c
@@ -45,7 +45,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyAuthorize_In in;
-#ifdef TPM_CC_PolicyAuthorize
+#if IS_CC_ENABLED(PolicyAuthorize)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -63,7 +63,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyAuthorize
+#if IS_CC_ENABLED(PolicyAuthorize)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyAuthorize) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyCommandCode.c b/Marshal_PolicyCommandCode.c
index 9bff709..79e96c6 100644
--- a/Marshal_PolicyCommandCode.c
+++ b/Marshal_PolicyCommandCode.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyCommandCode_In in;
-#ifdef TPM_CC_PolicyCommandCode
+#if IS_CC_ENABLED(PolicyCommandCode)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyCommandCode
+#if IS_CC_ENABLED(PolicyCommandCode)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyCommandCode) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyCounterTimer.c b/Marshal_PolicyCounterTimer.c
index 1d8c2d7..1ac6092 100644
--- a/Marshal_PolicyCounterTimer.c
+++ b/Marshal_PolicyCounterTimer.c
@@ -41,7 +41,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyCounterTimer_In in;
-#ifdef TPM_CC_PolicyCounterTimer
+#if IS_CC_ENABLED(PolicyCounterTimer)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -59,7 +59,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyCounterTimer
+#if IS_CC_ENABLED(PolicyCounterTimer)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyCounterTimer) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyCpHash.c b/Marshal_PolicyCpHash.c
index 50e8b7b..f14be57 100644
--- a/Marshal_PolicyCpHash.c
+++ b/Marshal_PolicyCpHash.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyCpHash_In in;
-#ifdef TPM_CC_PolicyCpHash
+#if IS_CC_ENABLED(PolicyCpHash)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyCpHash
+#if IS_CC_ENABLED(PolicyCpHash)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyCpHash) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyDuplicationSelect.c b/Marshal_PolicyDuplicationSelect.c
index 063ed0a..2ddbbd0 100644
--- a/Marshal_PolicyDuplicationSelect.c
+++ b/Marshal_PolicyDuplicationSelect.c
@@ -42,7 +42,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyDuplicationSelect_In in;
-#ifdef TPM_CC_PolicyDuplicationSelect
+#if IS_CC_ENABLED(PolicyDuplicationSelect)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -60,7 +60,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyDuplicationSelect
+#if IS_CC_ENABLED(PolicyDuplicationSelect)
response_buffer =
MemoryGetResponseBuffer(TPM_CC_PolicyDuplicationSelect) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
diff --git a/Marshal_PolicyGetDigest.c b/Marshal_PolicyGetDigest.c
index 76443a1..f5df884 100644
--- a/Marshal_PolicyGetDigest.c
+++ b/Marshal_PolicyGetDigest.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "PolicyGetDigest_fp.h"
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
static UINT16 PolicyGetDigest_Out_Marshal(PolicyGetDigest_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -58,7 +58,7 @@
TPM_RC result = TPM_RC_SUCCESS;
PolicyGetDigest_In in;
PolicyGetDigest_Out out;
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -79,7 +79,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyGetDigest) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = PolicyGetDigest_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_PolicyLocality.c b/Marshal_PolicyLocality.c
index 44551d5..d279973 100644
--- a/Marshal_PolicyLocality.c
+++ b/Marshal_PolicyLocality.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyLocality_In in;
-#ifdef TPM_CC_PolicyLocality
+#if IS_CC_ENABLED(PolicyLocality)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyLocality
+#if IS_CC_ENABLED(PolicyLocality)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyLocality) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyNV.c b/Marshal_PolicyNV.c
index 0187395..74a59fe 100644
--- a/Marshal_PolicyNV.c
+++ b/Marshal_PolicyNV.c
@@ -43,7 +43,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyNV_In in;
-#ifdef TPM_CC_PolicyNV
+#if IS_CC_ENABLED(PolicyNV)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -60,7 +60,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyNV
+#if IS_CC_ENABLED(PolicyNV)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyNV) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyNameHash.c b/Marshal_PolicyNameHash.c
index ede73fa..a5e14eb 100644
--- a/Marshal_PolicyNameHash.c
+++ b/Marshal_PolicyNameHash.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyNameHash_In in;
-#ifdef TPM_CC_PolicyNameHash
+#if IS_CC_ENABLED(PolicyNameHash)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyNameHash
+#if IS_CC_ENABLED(PolicyNameHash)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyNameHash) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyNvWritten.c b/Marshal_PolicyNvWritten.c
index ba87109..da27e4e 100644
--- a/Marshal_PolicyNvWritten.c
+++ b/Marshal_PolicyNvWritten.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyNvWritten_In in;
-#ifdef TPM_CC_PolicyNvWritten
+#if IS_CC_ENABLED(PolicyNvWritten)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyNvWritten
+#if IS_CC_ENABLED(PolicyNvWritten)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyNvWritten) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyOR.c b/Marshal_PolicyOR.c
index fe30bdc..944fb84 100644
--- a/Marshal_PolicyOR.c
+++ b/Marshal_PolicyOR.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyOR_In in;
-#ifdef TPM_CC_PolicyOR
+#if IS_CC_ENABLED(PolicyOR)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -50,7 +50,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyOR
+#if IS_CC_ENABLED(PolicyOR)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyOR) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyPCR.c b/Marshal_PolicyPCR.c
index 253b479..abffefe 100644
--- a/Marshal_PolicyPCR.c
+++ b/Marshal_PolicyPCR.c
@@ -37,7 +37,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyPCR_In in;
-#ifdef TPM_CC_PolicyPCR
+#if IS_CC_ENABLED(PolicyPCR)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -55,7 +55,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyPCR
+#if IS_CC_ENABLED(PolicyPCR)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyPCR) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyPassword.c b/Marshal_PolicyPassword.c
index 2736895..5502759 100644
--- a/Marshal_PolicyPassword.c
+++ b/Marshal_PolicyPassword.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyPassword_In in;
-#ifdef TPM_CC_PolicyPassword
+#if IS_CC_ENABLED(PolicyPassword)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyPassword
+#if IS_CC_ENABLED(PolicyPassword)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyPassword) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyPhysicalPresence.c b/Marshal_PolicyPhysicalPresence.c
index d3bb4a4..18d0187 100644
--- a/Marshal_PolicyPhysicalPresence.c
+++ b/Marshal_PolicyPhysicalPresence.c
@@ -29,7 +29,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyPhysicalPresence_In in;
-#ifdef TPM_CC_PolicyPhysicalPresence
+#if IS_CC_ENABLED(PolicyPhysicalPresence)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -47,7 +47,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyPhysicalPresence
+#if IS_CC_ENABLED(PolicyPhysicalPresence)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyPhysicalPresence) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicyRestart.c b/Marshal_PolicyRestart.c
index d98f725..ef86a95 100644
--- a/Marshal_PolicyRestart.c
+++ b/Marshal_PolicyRestart.c
@@ -28,7 +28,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyRestart_In in;
-#ifdef TPM_CC_PolicyRestart
+#if IS_CC_ENABLED(PolicyRestart)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -46,7 +46,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyRestart
+#if IS_CC_ENABLED(PolicyRestart)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyRestart) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_PolicySecret.c b/Marshal_PolicySecret.c
index ae5a8b7..08e3c56 100644
--- a/Marshal_PolicySecret.c
+++ b/Marshal_PolicySecret.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "PolicySecret_fp.h"
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
static UINT16 PolicySecret_Out_Marshal(PolicySecret_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -77,7 +77,7 @@
TPM_RC result = TPM_RC_SUCCESS;
PolicySecret_In in;
PolicySecret_Out out;
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -98,7 +98,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicySecret) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = PolicySecret_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_PolicySigned.c b/Marshal_PolicySigned.c
index 636026a..65d0bfd 100644
--- a/Marshal_PolicySigned.c
+++ b/Marshal_PolicySigned.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "PolicySigned_fp.h"
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
static UINT16 PolicySigned_Out_Marshal(PolicySigned_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -81,7 +81,7 @@
TPM_RC result = TPM_RC_SUCCESS;
PolicySigned_In in;
PolicySigned_Out out;
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -102,7 +102,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicySigned) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = PolicySigned_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_PolicyTicket.c b/Marshal_PolicyTicket.c
index d4a0ee8..7b4252f 100644
--- a/Marshal_PolicyTicket.c
+++ b/Marshal_PolicyTicket.c
@@ -49,7 +49,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
PolicyTicket_In in;
-#ifdef TPM_CC_PolicyTicket
+#if IS_CC_ENABLED(PolicyTicket)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -67,7 +67,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_PolicyTicket
+#if IS_CC_ENABLED(PolicyTicket)
response_buffer = MemoryGetResponseBuffer(TPM_CC_PolicyTicket) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Quote.c b/Marshal_Quote.c
index 644a25f..c34c84b 100644
--- a/Marshal_Quote.c
+++ b/Marshal_Quote.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Quote_fp.h"
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
static UINT16 Quote_Out_Marshal(Quote_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -72,7 +72,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Quote_In in;
Quote_Out out;
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Quote) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_RSA_Decrypt.c b/Marshal_RSA_Decrypt.c
index c88ca33..d505f63 100644
--- a/Marshal_RSA_Decrypt.c
+++ b/Marshal_RSA_Decrypt.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "RSA_Decrypt_fp.h"
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
static UINT16 RSA_Decrypt_Out_Marshal(RSA_Decrypt_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
RSA_Decrypt_In in;
RSA_Decrypt_Out out;
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
response_buffer = MemoryGetResponseBuffer(TPM_CC_RSA_Decrypt) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = RSA_Decrypt_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_RSA_Encrypt.c b/Marshal_RSA_Encrypt.c
index d4d5cd1..621a952 100644
--- a/Marshal_RSA_Encrypt.c
+++ b/Marshal_RSA_Encrypt.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "RSA_Encrypt_fp.h"
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
static UINT16 RSA_Encrypt_Out_Marshal(RSA_Encrypt_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
RSA_Encrypt_In in;
RSA_Encrypt_Out out;
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -92,7 +92,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
response_buffer = MemoryGetResponseBuffer(TPM_CC_RSA_Encrypt) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = RSA_Encrypt_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_ReadClock.c b/Marshal_ReadClock.c
index d53fbe9..44bc655 100644
--- a/Marshal_ReadClock.c
+++ b/Marshal_ReadClock.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ReadClock_fp.h"
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
static UINT16 ReadClock_Out_Marshal(ReadClock_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -44,7 +44,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
ReadClock_Out out;
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -59,7 +59,7 @@
}
// Marshal output structure containing response handles and parameters to
// response buffer.
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ReadClock) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_ReadPublic.c b/Marshal_ReadPublic.c
index 2667b01..bda91ff 100644
--- a/Marshal_ReadPublic.c
+++ b/Marshal_ReadPublic.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ReadPublic_fp.h"
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
static UINT16 ReadPublic_Out_Marshal(ReadPublic_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -60,7 +60,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ReadPublic_In in;
ReadPublic_Out out;
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -81,7 +81,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ReadPublic) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ReadPublic_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_Rewrap.c b/Marshal_Rewrap.c
index 13278e2..6b58aaf 100644
--- a/Marshal_Rewrap.c
+++ b/Marshal_Rewrap.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Rewrap_fp.h"
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
static UINT16 Rewrap_Out_Marshal(Rewrap_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -74,7 +74,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Rewrap_In in;
Rewrap_Out out;
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -94,7 +94,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Rewrap) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_SelfTest.c b/Marshal_SelfTest.c
index dd279f8..31a82bc 100644
--- a/Marshal_SelfTest.c
+++ b/Marshal_SelfTest.c
@@ -31,7 +31,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
SelfTest_In in;
-#ifdef TPM_CC_SelfTest
+#if IS_CC_ENABLED(SelfTest)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -48,7 +48,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_SelfTest
+#if IS_CC_ENABLED(SelfTest)
response_buffer = MemoryGetResponseBuffer(TPM_CC_SelfTest) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_SequenceComplete.c b/Marshal_SequenceComplete.c
index 8954d0e..d6e5e0f 100644
--- a/Marshal_SequenceComplete.c
+++ b/Marshal_SequenceComplete.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "SequenceComplete_fp.h"
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
static UINT16 SequenceComplete_Out_Marshal(SequenceComplete_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -68,7 +68,7 @@
TPM_RC result = TPM_RC_SUCCESS;
SequenceComplete_In in;
SequenceComplete_Out out;
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -89,7 +89,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
response_buffer = MemoryGetResponseBuffer(TPM_CC_SequenceComplete) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = SequenceComplete_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_SequenceUpdate.c b/Marshal_SequenceUpdate.c
index da1dabc..ab98c87 100644
--- a/Marshal_SequenceUpdate.c
+++ b/Marshal_SequenceUpdate.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
SequenceUpdate_In in;
-#ifdef TPM_CC_SequenceUpdate
+#if IS_CC_ENABLED(SequenceUpdate)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_SequenceUpdate
+#if IS_CC_ENABLED(SequenceUpdate)
response_buffer = MemoryGetResponseBuffer(TPM_CC_SequenceUpdate) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_SetAlgorithmSet.c b/Marshal_SetAlgorithmSet.c
index 8c2f6a8..7b7c504 100644
--- a/Marshal_SetAlgorithmSet.c
+++ b/Marshal_SetAlgorithmSet.c
@@ -33,7 +33,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
SetAlgorithmSet_In in;
-#ifdef TPM_CC_SetAlgorithmSet
+#if IS_CC_ENABLED(SetAlgorithmSet)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -51,7 +51,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_SetAlgorithmSet
+#if IS_CC_ENABLED(SetAlgorithmSet)
response_buffer = MemoryGetResponseBuffer(TPM_CC_SetAlgorithmSet) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_SetCommandCodeAuditStatus.c b/Marshal_SetCommandCodeAuditStatus.c
index 06ddd21..35804ed 100644
--- a/Marshal_SetCommandCodeAuditStatus.c
+++ b/Marshal_SetCommandCodeAuditStatus.c
@@ -42,7 +42,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
SetCommandCodeAuditStatus_In in;
-#ifdef TPM_CC_SetCommandCodeAuditStatus
+#if IS_CC_ENABLED(SetCommandCodeAuditStatus)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -60,7 +60,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_SetCommandCodeAuditStatus
+#if IS_CC_ENABLED(SetCommandCodeAuditStatus)
response_buffer =
MemoryGetResponseBuffer(TPM_CC_SetCommandCodeAuditStatus) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
diff --git a/Marshal_SetPrimaryPolicy.c b/Marshal_SetPrimaryPolicy.c
index 98e70bb..1bed8f6 100644
--- a/Marshal_SetPrimaryPolicy.c
+++ b/Marshal_SetPrimaryPolicy.c
@@ -37,7 +37,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
SetPrimaryPolicy_In in;
-#ifdef TPM_CC_SetPrimaryPolicy
+#if IS_CC_ENABLED(SetPrimaryPolicy)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -55,7 +55,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_SetPrimaryPolicy
+#if IS_CC_ENABLED(SetPrimaryPolicy)
response_buffer = MemoryGetResponseBuffer(TPM_CC_SetPrimaryPolicy) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Shutdown.c b/Marshal_Shutdown.c
index 7bd0d51..3fcef7d 100644
--- a/Marshal_Shutdown.c
+++ b/Marshal_Shutdown.c
@@ -31,7 +31,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
Shutdown_In in;
-#ifdef TPM_CC_Shutdown
+#if IS_CC_ENABLED(Shutdown)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -48,7 +48,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_Shutdown
+#if IS_CC_ENABLED(Shutdown)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Shutdown) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Sign.c b/Marshal_Sign.c
index e72b882..29e8641 100644
--- a/Marshal_Sign.c
+++ b/Marshal_Sign.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Sign_fp.h"
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
static UINT16 Sign_Out_Marshal(Sign_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -71,7 +71,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Sign_In in;
Sign_Out out;
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -91,7 +91,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Sign) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_StartAuthSession.c b/Marshal_StartAuthSession.c
index 86e2417..d9bf135 100644
--- a/Marshal_StartAuthSession.c
+++ b/Marshal_StartAuthSession.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "StartAuthSession_fp.h"
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
static UINT16 StartAuthSession_Out_Marshal(StartAuthSession_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -84,7 +84,7 @@
TPM_RC result = TPM_RC_SUCCESS;
StartAuthSession_In in;
StartAuthSession_Out out;
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -105,7 +105,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
response_buffer = MemoryGetResponseBuffer(TPM_CC_StartAuthSession) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = StartAuthSession_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_Startup.c b/Marshal_Startup.c
index acd0df3..afedff8 100644
--- a/Marshal_Startup.c
+++ b/Marshal_Startup.c
@@ -31,7 +31,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
Startup_In in;
-#ifdef TPM_CC_Startup
+#if IS_CC_ENABLED(Startup)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -48,7 +48,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_Startup
+#if IS_CC_ENABLED(Startup)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Startup) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_StirRandom.c b/Marshal_StirRandom.c
index e15be52..7098595 100644
--- a/Marshal_StirRandom.c
+++ b/Marshal_StirRandom.c
@@ -31,7 +31,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
StirRandom_In in;
-#ifdef TPM_CC_StirRandom
+#if IS_CC_ENABLED(StirRandom)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -49,7 +49,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_StirRandom
+#if IS_CC_ENABLED(StirRandom)
response_buffer = MemoryGetResponseBuffer(TPM_CC_StirRandom) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_TestParms.c b/Marshal_TestParms.c
index a98a395..6a7bdb0 100644
--- a/Marshal_TestParms.c
+++ b/Marshal_TestParms.c
@@ -31,7 +31,7 @@
UINT32* response_parameter_buffer_size) {
TPM_RC result = TPM_RC_SUCCESS;
TestParms_In in;
-#ifdef TPM_CC_TestParms
+#if IS_CC_ENABLED(TestParms)
BYTE* response_buffer;
INT32 response_buffer_size;
#endif
@@ -49,7 +49,7 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_TestParms
+#if IS_CC_ENABLED(TestParms)
response_buffer = MemoryGetResponseBuffer(TPM_CC_TestParms) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
// Add parameter_size field, always equal to 0 here.
diff --git a/Marshal_Unseal.c b/Marshal_Unseal.c
index 12724d8..386e1bd 100644
--- a/Marshal_Unseal.c
+++ b/Marshal_Unseal.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "Unseal_fp.h"
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
static UINT16 Unseal_Out_Marshal(Unseal_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -58,7 +58,7 @@
TPM_RC result = TPM_RC_SUCCESS;
Unseal_In in;
Unseal_Out out;
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -78,7 +78,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
response_buffer = MemoryGetResponseBuffer(TPM_CC_Unseal) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled =
diff --git a/Marshal_VerifySignature.c b/Marshal_VerifySignature.c
index 1f59f0e..253cf70 100644
--- a/Marshal_VerifySignature.c
+++ b/Marshal_VerifySignature.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "VerifySignature_fp.h"
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
static UINT16 VerifySignature_Out_Marshal(VerifySignature_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -67,7 +67,7 @@
TPM_RC result = TPM_RC_SUCCESS;
VerifySignature_In in;
VerifySignature_Out out;
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -88,7 +88,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
response_buffer = MemoryGetResponseBuffer(TPM_CC_VerifySignature) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = VerifySignature_Out_Marshal(&out, tag, &response_buffer,
diff --git a/Marshal_ZGen_2Phase.c b/Marshal_ZGen_2Phase.c
index e2e7de9..048792a 100644
--- a/Marshal_ZGen_2Phase.c
+++ b/Marshal_ZGen_2Phase.c
@@ -7,7 +7,7 @@
#include "MemoryLib_fp.h"
#include "ZGen_2Phase_fp.h"
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
static UINT16 ZGen_2Phase_Out_Marshal(ZGen_2Phase_Out* source,
TPMI_ST_COMMAND_TAG tag,
BYTE** buffer,
@@ -77,7 +77,7 @@
TPM_RC result = TPM_RC_SUCCESS;
ZGen_2Phase_In in;
ZGen_2Phase_Out out;
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
BYTE* response_buffer;
INT32 response_buffer_size;
UINT16 bytes_marshalled;
@@ -98,7 +98,7 @@
return result;
}
// Marshal output structure to global response buffer.
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
response_buffer = MemoryGetResponseBuffer(TPM_CC_ZGen_2Phase) + 10;
response_buffer_size = MAX_RESPONSE_SIZE - 10;
bytes_marshalled = ZGen_2Phase_Out_Marshal(&out, tag, &response_buffer,
diff --git a/tpm_generated.c b/tpm_generated.c
index 954bff3..bb0bd9e 100644
--- a/tpm_generated.c
+++ b/tpm_generated.c
@@ -4678,562 +4678,562 @@
if (result != TPM_RC_SUCCESS) {
return result;
}
-#ifdef TPM_CC_FIRST
+#if IS_CC_ENABLED(FIRST)
if (*target == TPM_CC_FIRST) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PP_FIRST
+#if IS_CC_ENABLED(PP_FIRST)
if (*target == TPM_CC_PP_FIRST) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_UndefineSpaceSpecial
+#if IS_CC_ENABLED(NV_UndefineSpaceSpecial)
if (*target == TPM_CC_NV_UndefineSpaceSpecial) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_EvictControl
+#if IS_CC_ENABLED(EvictControl)
if (*target == TPM_CC_EvictControl) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_HierarchyControl
+#if IS_CC_ENABLED(HierarchyControl)
if (*target == TPM_CC_HierarchyControl) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_UndefineSpace
+#if IS_CC_ENABLED(NV_UndefineSpace)
if (*target == TPM_CC_NV_UndefineSpace) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ChangeEPS
+#if IS_CC_ENABLED(ChangeEPS)
if (*target == TPM_CC_ChangeEPS) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ChangePPS
+#if IS_CC_ENABLED(ChangePPS)
if (*target == TPM_CC_ChangePPS) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Clear
+#if IS_CC_ENABLED(Clear)
if (*target == TPM_CC_Clear) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ClearControl
+#if IS_CC_ENABLED(ClearControl)
if (*target == TPM_CC_ClearControl) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ClockSet
+#if IS_CC_ENABLED(ClockSet)
if (*target == TPM_CC_ClockSet) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_HierarchyChangeAuth
+#if IS_CC_ENABLED(HierarchyChangeAuth)
if (*target == TPM_CC_HierarchyChangeAuth) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_DefineSpace
+#if IS_CC_ENABLED(NV_DefineSpace)
if (*target == TPM_CC_NV_DefineSpace) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_Allocate
+#if IS_CC_ENABLED(PCR_Allocate)
if (*target == TPM_CC_PCR_Allocate) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_SetAuthPolicy
+#if IS_CC_ENABLED(PCR_SetAuthPolicy)
if (*target == TPM_CC_PCR_SetAuthPolicy) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PP_Commands
+#if IS_CC_ENABLED(PP_Commands)
if (*target == TPM_CC_PP_Commands) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_SetPrimaryPolicy
+#if IS_CC_ENABLED(SetPrimaryPolicy)
if (*target == TPM_CC_SetPrimaryPolicy) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_FieldUpgradeStart
+#if IS_CC_ENABLED(FieldUpgradeStart)
if (*target == TPM_CC_FieldUpgradeStart) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ClockRateAdjust
+#if IS_CC_ENABLED(ClockRateAdjust)
if (*target == TPM_CC_ClockRateAdjust) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_CreatePrimary
+#if IS_CC_ENABLED(CreatePrimary)
if (*target == TPM_CC_CreatePrimary) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_GlobalWriteLock
+#if IS_CC_ENABLED(NV_GlobalWriteLock)
if (*target == TPM_CC_NV_GlobalWriteLock) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PP_LAST
+#if IS_CC_ENABLED(PP_LAST)
if (*target == TPM_CC_PP_LAST) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_GetCommandAuditDigest
+#if IS_CC_ENABLED(GetCommandAuditDigest)
if (*target == TPM_CC_GetCommandAuditDigest) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_Increment
+#if IS_CC_ENABLED(NV_Increment)
if (*target == TPM_CC_NV_Increment) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_SetBits
+#if IS_CC_ENABLED(NV_SetBits)
if (*target == TPM_CC_NV_SetBits) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_Extend
+#if IS_CC_ENABLED(NV_Extend)
if (*target == TPM_CC_NV_Extend) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_Write
+#if IS_CC_ENABLED(NV_Write)
if (*target == TPM_CC_NV_Write) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_WriteLock
+#if IS_CC_ENABLED(NV_WriteLock)
if (*target == TPM_CC_NV_WriteLock) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_DictionaryAttackLockReset
+#if IS_CC_ENABLED(DictionaryAttackLockReset)
if (*target == TPM_CC_DictionaryAttackLockReset) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_DictionaryAttackParameters
+#if IS_CC_ENABLED(DictionaryAttackParameters)
if (*target == TPM_CC_DictionaryAttackParameters) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_ChangeAuth
+#if IS_CC_ENABLED(NV_ChangeAuth)
if (*target == TPM_CC_NV_ChangeAuth) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_Event
+#if IS_CC_ENABLED(PCR_Event)
if (*target == TPM_CC_PCR_Event) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_Reset
+#if IS_CC_ENABLED(PCR_Reset)
if (*target == TPM_CC_PCR_Reset) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_SequenceComplete
+#if IS_CC_ENABLED(SequenceComplete)
if (*target == TPM_CC_SequenceComplete) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_SetAlgorithmSet
+#if IS_CC_ENABLED(SetAlgorithmSet)
if (*target == TPM_CC_SetAlgorithmSet) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_SetCommandCodeAuditStatus
+#if IS_CC_ENABLED(SetCommandCodeAuditStatus)
if (*target == TPM_CC_SetCommandCodeAuditStatus) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_FieldUpgradeData
+#if IS_CC_ENABLED(FieldUpgradeData)
if (*target == TPM_CC_FieldUpgradeData) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_IncrementalSelfTest
+#if IS_CC_ENABLED(IncrementalSelfTest)
if (*target == TPM_CC_IncrementalSelfTest) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_SelfTest
+#if IS_CC_ENABLED(SelfTest)
if (*target == TPM_CC_SelfTest) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Startup
+#if IS_CC_ENABLED(Startup)
if (*target == TPM_CC_Startup) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Shutdown
+#if IS_CC_ENABLED(Shutdown)
if (*target == TPM_CC_Shutdown) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_StirRandom
+#if IS_CC_ENABLED(StirRandom)
if (*target == TPM_CC_StirRandom) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ActivateCredential
+#if IS_CC_ENABLED(ActivateCredential)
if (*target == TPM_CC_ActivateCredential) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Certify
+#if IS_CC_ENABLED(Certify)
if (*target == TPM_CC_Certify) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyNV
+#if IS_CC_ENABLED(PolicyNV)
if (*target == TPM_CC_PolicyNV) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_CertifyCreation
+#if IS_CC_ENABLED(CertifyCreation)
if (*target == TPM_CC_CertifyCreation) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Duplicate
+#if IS_CC_ENABLED(Duplicate)
if (*target == TPM_CC_Duplicate) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_GetTime
+#if IS_CC_ENABLED(GetTime)
if (*target == TPM_CC_GetTime) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_GetSessionAuditDigest
+#if IS_CC_ENABLED(GetSessionAuditDigest)
if (*target == TPM_CC_GetSessionAuditDigest) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_Read
+#if IS_CC_ENABLED(NV_Read)
if (*target == TPM_CC_NV_Read) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_ReadLock
+#if IS_CC_ENABLED(NV_ReadLock)
if (*target == TPM_CC_NV_ReadLock) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ObjectChangeAuth
+#if IS_CC_ENABLED(ObjectChangeAuth)
if (*target == TPM_CC_ObjectChangeAuth) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicySecret
+#if IS_CC_ENABLED(PolicySecret)
if (*target == TPM_CC_PolicySecret) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Rewrap
+#if IS_CC_ENABLED(Rewrap)
if (*target == TPM_CC_Rewrap) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Create
+#if IS_CC_ENABLED(Create)
if (*target == TPM_CC_Create) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ECDH_ZGen
+#if IS_CC_ENABLED(ECDH_ZGen)
if (*target == TPM_CC_ECDH_ZGen) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_HMAC
+#if IS_CC_ENABLED(HMAC)
if (*target == TPM_CC_HMAC) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Import
+#if IS_CC_ENABLED(Import)
if (*target == TPM_CC_Import) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Load
+#if IS_CC_ENABLED(Load)
if (*target == TPM_CC_Load) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Quote
+#if IS_CC_ENABLED(Quote)
if (*target == TPM_CC_Quote) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_RSA_Decrypt
+#if IS_CC_ENABLED(RSA_Decrypt)
if (*target == TPM_CC_RSA_Decrypt) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_HMAC_Start
+#if IS_CC_ENABLED(HMAC_Start)
if (*target == TPM_CC_HMAC_Start) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_SequenceUpdate
+#if IS_CC_ENABLED(SequenceUpdate)
if (*target == TPM_CC_SequenceUpdate) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Sign
+#if IS_CC_ENABLED(Sign)
if (*target == TPM_CC_Sign) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Unseal
+#if IS_CC_ENABLED(Unseal)
if (*target == TPM_CC_Unseal) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicySigned
+#if IS_CC_ENABLED(PolicySigned)
if (*target == TPM_CC_PolicySigned) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ContextLoad
+#if IS_CC_ENABLED(ContextLoad)
if (*target == TPM_CC_ContextLoad) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ContextSave
+#if IS_CC_ENABLED(ContextSave)
if (*target == TPM_CC_ContextSave) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ECDH_KeyGen
+#if IS_CC_ENABLED(ECDH_KeyGen)
if (*target == TPM_CC_ECDH_KeyGen) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_EncryptDecrypt
+#if IS_CC_ENABLED(EncryptDecrypt)
if (*target == TPM_CC_EncryptDecrypt) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_FlushContext
+#if IS_CC_ENABLED(FlushContext)
if (*target == TPM_CC_FlushContext) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_LoadExternal
+#if IS_CC_ENABLED(LoadExternal)
if (*target == TPM_CC_LoadExternal) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_MakeCredential
+#if IS_CC_ENABLED(MakeCredential)
if (*target == TPM_CC_MakeCredential) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_ReadPublic
+#if IS_CC_ENABLED(NV_ReadPublic)
if (*target == TPM_CC_NV_ReadPublic) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyAuthorize
+#if IS_CC_ENABLED(PolicyAuthorize)
if (*target == TPM_CC_PolicyAuthorize) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyAuthValue
+#if IS_CC_ENABLED(PolicyAuthValue)
if (*target == TPM_CC_PolicyAuthValue) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyCommandCode
+#if IS_CC_ENABLED(PolicyCommandCode)
if (*target == TPM_CC_PolicyCommandCode) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyCounterTimer
+#if IS_CC_ENABLED(PolicyCounterTimer)
if (*target == TPM_CC_PolicyCounterTimer) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyCpHash
+#if IS_CC_ENABLED(PolicyCpHash)
if (*target == TPM_CC_PolicyCpHash) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyLocality
+#if IS_CC_ENABLED(PolicyLocality)
if (*target == TPM_CC_PolicyLocality) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyNameHash
+#if IS_CC_ENABLED(PolicyNameHash)
if (*target == TPM_CC_PolicyNameHash) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyOR
+#if IS_CC_ENABLED(PolicyOR)
if (*target == TPM_CC_PolicyOR) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyTicket
+#if IS_CC_ENABLED(PolicyTicket)
if (*target == TPM_CC_PolicyTicket) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ReadPublic
+#if IS_CC_ENABLED(ReadPublic)
if (*target == TPM_CC_ReadPublic) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_RSA_Encrypt
+#if IS_CC_ENABLED(RSA_Encrypt)
if (*target == TPM_CC_RSA_Encrypt) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_StartAuthSession
+#if IS_CC_ENABLED(StartAuthSession)
if (*target == TPM_CC_StartAuthSession) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_VerifySignature
+#if IS_CC_ENABLED(VerifySignature)
if (*target == TPM_CC_VerifySignature) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ECC_Parameters
+#if IS_CC_ENABLED(ECC_Parameters)
if (*target == TPM_CC_ECC_Parameters) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_FirmwareRead
+#if IS_CC_ENABLED(FirmwareRead)
if (*target == TPM_CC_FirmwareRead) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_GetCapability
+#if IS_CC_ENABLED(GetCapability)
if (*target == TPM_CC_GetCapability) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_GetRandom
+#if IS_CC_ENABLED(GetRandom)
if (*target == TPM_CC_GetRandom) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_GetTestResult
+#if IS_CC_ENABLED(GetTestResult)
if (*target == TPM_CC_GetTestResult) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Hash
+#if IS_CC_ENABLED(Hash)
if (*target == TPM_CC_Hash) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_Read
+#if IS_CC_ENABLED(PCR_Read)
if (*target == TPM_CC_PCR_Read) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyPCR
+#if IS_CC_ENABLED(PolicyPCR)
if (*target == TPM_CC_PolicyPCR) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyRestart
+#if IS_CC_ENABLED(PolicyRestart)
if (*target == TPM_CC_PolicyRestart) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ReadClock
+#if IS_CC_ENABLED(ReadClock)
if (*target == TPM_CC_ReadClock) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_Extend
+#if IS_CC_ENABLED(PCR_Extend)
if (*target == TPM_CC_PCR_Extend) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PCR_SetAuthValue
+#if IS_CC_ENABLED(PCR_SetAuthValue)
if (*target == TPM_CC_PCR_SetAuthValue) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_NV_Certify
+#if IS_CC_ENABLED(NV_Certify)
if (*target == TPM_CC_NV_Certify) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_EventSequenceComplete
+#if IS_CC_ENABLED(EventSequenceComplete)
if (*target == TPM_CC_EventSequenceComplete) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_HashSequenceStart
+#if IS_CC_ENABLED(HashSequenceStart)
if (*target == TPM_CC_HashSequenceStart) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyPhysicalPresence
+#if IS_CC_ENABLED(PolicyPhysicalPresence)
if (*target == TPM_CC_PolicyPhysicalPresence) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyDuplicationSelect
+#if IS_CC_ENABLED(PolicyDuplicationSelect)
if (*target == TPM_CC_PolicyDuplicationSelect) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyGetDigest
+#if IS_CC_ENABLED(PolicyGetDigest)
if (*target == TPM_CC_PolicyGetDigest) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_TestParms
+#if IS_CC_ENABLED(TestParms)
if (*target == TPM_CC_TestParms) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_Commit
+#if IS_CC_ENABLED(Commit)
if (*target == TPM_CC_Commit) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyPassword
+#if IS_CC_ENABLED(PolicyPassword)
if (*target == TPM_CC_PolicyPassword) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_ZGen_2Phase
+#if IS_CC_ENABLED(ZGen_2Phase)
if (*target == TPM_CC_ZGen_2Phase) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_EC_Ephemeral
+#if IS_CC_ENABLED(EC_Ephemeral)
if (*target == TPM_CC_EC_Ephemeral) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_PolicyNvWritten
+#if IS_CC_ENABLED(PolicyNvWritten)
if (*target == TPM_CC_PolicyNvWritten) {
return TPM_RC_SUCCESS;
}
#endif
-#ifdef TPM_CC_LAST
+#if IS_CC_ENABLED(LAST)
if (*target == TPM_CC_LAST) {
return TPM_RC_SUCCESS;
}
