| /* Microsoft Reference Implementation for TPM 2.0 | |
| * | |
| * The copyright in this software is being made available under the BSD License, | |
| * included below. This software may be subject to other third party and | |
| * contributor rights, including patent rights, and no such rights are granted | |
| * under this license. | |
| * | |
| * Copyright (c) Microsoft Corporation | |
| * | |
| * All rights reserved. | |
| * | |
| * BSD License | |
| * | |
| * Redistribution and use in source and binary forms, with or without modification, | |
| * are permitted provided that the following conditions are met: | |
| * | |
| * Redistributions of source code must retain the above copyright notice, this list | |
| * of conditions and the following disclaimer. | |
| * | |
| * Redistributions in binary form must reproduce the above copyright notice, this | |
| * list of conditions and the following disclaimer in the documentation and/or | |
| * other materials provided with the distribution. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" | |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR | |
| * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | |
| * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| /*(Auto-generated) | |
| * Created by TpmDispatch; Version 4.0 July 8,2017 | |
| * Date: Feb 28, 2020 Time: 03:04:48PM | |
| */ | |
| #if CC_Startup | |
| case TPM_CC_Startup: | |
| break; | |
| #endif // CC_Startup | |
| #if CC_Shutdown | |
| case TPM_CC_Shutdown: | |
| break; | |
| #endif // CC_Shutdown | |
| #if CC_SelfTest | |
| case TPM_CC_SelfTest: | |
| break; | |
| #endif // CC_SelfTest | |
| #if CC_IncrementalSelfTest | |
| case TPM_CC_IncrementalSelfTest: | |
| break; | |
| #endif // CC_IncrementalSelfTest | |
| #if CC_GetTestResult | |
| case TPM_CC_GetTestResult: | |
| break; | |
| #endif // CC_GetTestResult | |
| #if CC_StartAuthSession | |
| case TPM_CC_StartAuthSession: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_ENTITY_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_StartAuthSession | |
| #if CC_PolicyRestart | |
| case TPM_CC_PolicyRestart: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyRestart | |
| #if CC_Create | |
| case TPM_CC_Create: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Create | |
| #if CC_Load | |
| case TPM_CC_Load: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Load | |
| #if CC_LoadExternal | |
| case TPM_CC_LoadExternal: | |
| break; | |
| #endif // CC_LoadExternal | |
| #if CC_ReadPublic | |
| case TPM_CC_ReadPublic: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ReadPublic | |
| #if CC_ActivateCredential | |
| case TPM_CC_ActivateCredential: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_ActivateCredential | |
| #if CC_MakeCredential | |
| case TPM_CC_MakeCredential: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_MakeCredential | |
| #if CC_Unseal | |
| case TPM_CC_Unseal: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Unseal | |
| #if CC_ObjectChangeAuth | |
| case TPM_CC_ObjectChangeAuth: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_ObjectChangeAuth | |
| #if CC_CreateLoaded | |
| case TPM_CC_CreateLoaded: | |
| *handleCount = 1; | |
| result = TPMI_DH_PARENT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_CreateLoaded | |
| #if CC_Duplicate | |
| case TPM_CC_Duplicate: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_Duplicate | |
| #if CC_Rewrap | |
| case TPM_CC_Rewrap: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_Rewrap | |
| #if CC_Import | |
| case TPM_CC_Import: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Import | |
| #if CC_RSA_Encrypt | |
| case TPM_CC_RSA_Encrypt: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_RSA_Encrypt | |
| #if CC_RSA_Decrypt | |
| case TPM_CC_RSA_Decrypt: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_RSA_Decrypt | |
| #if CC_ECDH_KeyGen | |
| case TPM_CC_ECDH_KeyGen: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ECDH_KeyGen | |
| #if CC_ECDH_ZGen | |
| case TPM_CC_ECDH_ZGen: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ECDH_ZGen | |
| #if CC_ECC_Parameters | |
| case TPM_CC_ECC_Parameters: | |
| break; | |
| #endif // CC_ECC_Parameters | |
| #if CC_ZGen_2Phase | |
| case TPM_CC_ZGen_2Phase: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ZGen_2Phase | |
| #if CC_ECC_Encrypt | |
| case TPM_CC_ECC_Encrypt: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ECC_Encrypt | |
| #if CC_ECC_Decrypt | |
| case TPM_CC_ECC_Decrypt: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ECC_Decrypt | |
| #if CC_EncryptDecrypt | |
| case TPM_CC_EncryptDecrypt: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_EncryptDecrypt | |
| #if CC_EncryptDecrypt2 | |
| case TPM_CC_EncryptDecrypt2: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_EncryptDecrypt2 | |
| #if CC_Hash | |
| case TPM_CC_Hash: | |
| break; | |
| #endif // CC_Hash | |
| #if CC_HMAC | |
| case TPM_CC_HMAC: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_HMAC | |
| #if CC_MAC | |
| case TPM_CC_MAC: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_MAC | |
| #if CC_GetRandom | |
| case TPM_CC_GetRandom: | |
| break; | |
| #endif // CC_GetRandom | |
| #if CC_StirRandom | |
| case TPM_CC_StirRandom: | |
| break; | |
| #endif // CC_StirRandom | |
| #if CC_HMAC_Start | |
| case TPM_CC_HMAC_Start: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_HMAC_Start | |
| #if CC_MAC_Start | |
| case TPM_CC_MAC_Start: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_MAC_Start | |
| #if CC_HashSequenceStart | |
| case TPM_CC_HashSequenceStart: | |
| break; | |
| #endif // CC_HashSequenceStart | |
| #if CC_SequenceUpdate | |
| case TPM_CC_SequenceUpdate: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_SequenceUpdate | |
| #if CC_SequenceComplete | |
| case TPM_CC_SequenceComplete: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_SequenceComplete | |
| #if CC_EventSequenceComplete | |
| case TPM_CC_EventSequenceComplete: | |
| *handleCount = 2; | |
| result = TPMI_DH_PCR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_EventSequenceComplete | |
| #if CC_Certify | |
| case TPM_CC_Certify: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_Certify | |
| #if CC_CertifyCreation | |
| case TPM_CC_CertifyCreation: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_CertifyCreation | |
| #if CC_Quote | |
| case TPM_CC_Quote: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Quote | |
| #if CC_GetSessionAuditDigest | |
| case TPM_CC_GetSessionAuditDigest: | |
| *handleCount = 3; | |
| result = TPMI_RH_ENDORSEMENT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| result = TPMI_SH_HMAC_Unmarshal(&handles[2], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_3; | |
| break; | |
| #endif // CC_GetSessionAuditDigest | |
| #if CC_GetCommandAuditDigest | |
| case TPM_CC_GetCommandAuditDigest: | |
| *handleCount = 2; | |
| result = TPMI_RH_ENDORSEMENT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_GetCommandAuditDigest | |
| #if CC_GetTime | |
| case TPM_CC_GetTime: | |
| *handleCount = 2; | |
| result = TPMI_RH_ENDORSEMENT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_GetTime | |
| #if CC_CertifyX509 | |
| case TPM_CC_CertifyX509: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_CertifyX509 | |
| #if CC_Commit | |
| case TPM_CC_Commit: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Commit | |
| #if CC_EC_Ephemeral | |
| case TPM_CC_EC_Ephemeral: | |
| break; | |
| #endif // CC_EC_Ephemeral | |
| #if CC_VerifySignature | |
| case TPM_CC_VerifySignature: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_VerifySignature | |
| #if CC_Sign | |
| case TPM_CC_Sign: | |
| *handleCount = 1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Sign | |
| #if CC_SetCommandCodeAuditStatus | |
| case TPM_CC_SetCommandCodeAuditStatus: | |
| *handleCount = 1; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_SetCommandCodeAuditStatus | |
| #if CC_PCR_Extend | |
| case TPM_CC_PCR_Extend: | |
| *handleCount = 1; | |
| result = TPMI_DH_PCR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PCR_Extend | |
| #if CC_PCR_Event | |
| case TPM_CC_PCR_Event: | |
| *handleCount = 1; | |
| result = TPMI_DH_PCR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PCR_Event | |
| #if CC_PCR_Read | |
| case TPM_CC_PCR_Read: | |
| break; | |
| #endif // CC_PCR_Read | |
| #if CC_PCR_Allocate | |
| case TPM_CC_PCR_Allocate: | |
| *handleCount = 1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PCR_Allocate | |
| #if CC_PCR_SetAuthPolicy | |
| case TPM_CC_PCR_SetAuthPolicy: | |
| *handleCount = 1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PCR_SetAuthPolicy | |
| #if CC_PCR_SetAuthValue | |
| case TPM_CC_PCR_SetAuthValue: | |
| *handleCount = 1; | |
| result = TPMI_DH_PCR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PCR_SetAuthValue | |
| #if CC_PCR_Reset | |
| case TPM_CC_PCR_Reset: | |
| *handleCount = 1; | |
| result = TPMI_DH_PCR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PCR_Reset | |
| #if CC_PolicySigned | |
| case TPM_CC_PolicySigned: | |
| *handleCount = 2; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_PolicySigned | |
| #if CC_PolicySecret | |
| case TPM_CC_PolicySecret: | |
| *handleCount = 2; | |
| result = TPMI_DH_ENTITY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_PolicySecret | |
| #if CC_PolicyTicket | |
| case TPM_CC_PolicyTicket: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyTicket | |
| #if CC_PolicyOR | |
| case TPM_CC_PolicyOR: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyOR | |
| #if CC_PolicyPCR | |
| case TPM_CC_PolicyPCR: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyPCR | |
| #if CC_PolicyLocality | |
| case TPM_CC_PolicyLocality: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyLocality | |
| #if CC_PolicyNV | |
| case TPM_CC_PolicyNV: | |
| *handleCount = 3; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[2], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_3; | |
| break; | |
| #endif // CC_PolicyNV | |
| #if CC_PolicyCounterTimer | |
| case TPM_CC_PolicyCounterTimer: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyCounterTimer | |
| #if CC_PolicyCommandCode | |
| case TPM_CC_PolicyCommandCode: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyCommandCode | |
| #if CC_PolicyPhysicalPresence | |
| case TPM_CC_PolicyPhysicalPresence: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyPhysicalPresence | |
| #if CC_PolicyCpHash | |
| case TPM_CC_PolicyCpHash: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyCpHash | |
| #if CC_PolicyNameHash | |
| case TPM_CC_PolicyNameHash: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyNameHash | |
| #if CC_PolicyDuplicationSelect | |
| case TPM_CC_PolicyDuplicationSelect: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyDuplicationSelect | |
| #if CC_PolicyAuthorize | |
| case TPM_CC_PolicyAuthorize: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyAuthorize | |
| #if CC_PolicyAuthValue | |
| case TPM_CC_PolicyAuthValue: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyAuthValue | |
| #if CC_PolicyPassword | |
| case TPM_CC_PolicyPassword: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyPassword | |
| #if CC_PolicyGetDigest | |
| case TPM_CC_PolicyGetDigest: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyGetDigest | |
| #if CC_PolicyNvWritten | |
| case TPM_CC_PolicyNvWritten: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyNvWritten | |
| #if CC_PolicyTemplate | |
| case TPM_CC_PolicyTemplate: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PolicyTemplate | |
| #if CC_PolicyAuthorizeNV | |
| case TPM_CC_PolicyAuthorizeNV: | |
| *handleCount = 3; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[2], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_3; | |
| break; | |
| #endif // CC_PolicyAuthorizeNV | |
| #if CC_CreatePrimary | |
| case TPM_CC_CreatePrimary: | |
| *handleCount = 1; | |
| result = TPMI_RH_HIERARCHY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_CreatePrimary | |
| #if CC_HierarchyControl | |
| case TPM_CC_HierarchyControl: | |
| *handleCount = 1; | |
| result = TPMI_RH_HIERARCHY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_HierarchyControl | |
| #if CC_SetPrimaryPolicy | |
| case TPM_CC_SetPrimaryPolicy: | |
| *handleCount = 1; | |
| result = TPMI_RH_HIERARCHY_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_SetPrimaryPolicy | |
| #if CC_ChangePPS | |
| case TPM_CC_ChangePPS: | |
| *handleCount = 1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ChangePPS | |
| #if CC_ChangeEPS | |
| case TPM_CC_ChangeEPS: | |
| *handleCount = 1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ChangeEPS | |
| #if CC_Clear | |
| case TPM_CC_Clear: | |
| *handleCount = 1; | |
| result = TPMI_RH_CLEAR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Clear | |
| #if CC_ClearControl | |
| case TPM_CC_ClearControl: | |
| *handleCount = 1; | |
| result = TPMI_RH_CLEAR_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ClearControl | |
| #if CC_HierarchyChangeAuth | |
| case TPM_CC_HierarchyChangeAuth: | |
| *handleCount = 1; | |
| result = TPMI_RH_HIERARCHY_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_HierarchyChangeAuth | |
| #if CC_DictionaryAttackLockReset | |
| case TPM_CC_DictionaryAttackLockReset: | |
| *handleCount = 1; | |
| result = TPMI_RH_LOCKOUT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_DictionaryAttackLockReset | |
| #if CC_DictionaryAttackParameters | |
| case TPM_CC_DictionaryAttackParameters: | |
| *handleCount = 1; | |
| result = TPMI_RH_LOCKOUT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_DictionaryAttackParameters | |
| #if CC_PP_Commands | |
| case TPM_CC_PP_Commands: | |
| *handleCount = 1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_PP_Commands | |
| #if CC_SetAlgorithmSet | |
| case TPM_CC_SetAlgorithmSet: | |
| *handleCount = 1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_SetAlgorithmSet | |
| #if CC_FieldUpgradeStart | |
| case TPM_CC_FieldUpgradeStart: | |
| *handleCount = 2; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_FieldUpgradeStart | |
| #if CC_FieldUpgradeData | |
| case TPM_CC_FieldUpgradeData: | |
| break; | |
| #endif // CC_FieldUpgradeData | |
| #if CC_FirmwareRead | |
| case TPM_CC_FirmwareRead: | |
| break; | |
| #endif // CC_FirmwareRead | |
| #if CC_ContextSave | |
| case TPM_CC_ContextSave: | |
| *handleCount = 1; | |
| result = TPMI_DH_CONTEXT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ContextSave | |
| #if CC_ContextLoad | |
| case TPM_CC_ContextLoad: | |
| break; | |
| #endif // CC_ContextLoad | |
| #if CC_FlushContext | |
| case TPM_CC_FlushContext: | |
| break; | |
| #endif // CC_FlushContext | |
| #if CC_EvictControl | |
| case TPM_CC_EvictControl: | |
| *handleCount = 2; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_EvictControl | |
| #if CC_ReadClock | |
| case TPM_CC_ReadClock: | |
| break; | |
| #endif // CC_ReadClock | |
| #if CC_ClockSet | |
| case TPM_CC_ClockSet: | |
| *handleCount = 1; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ClockSet | |
| #if CC_ClockRateAdjust | |
| case TPM_CC_ClockRateAdjust: | |
| *handleCount = 1; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ClockRateAdjust | |
| #if CC_GetCapability | |
| case TPM_CC_GetCapability: | |
| break; | |
| #endif // CC_GetCapability | |
| #if CC_TestParms | |
| case TPM_CC_TestParms: | |
| break; | |
| #endif // CC_TestParms | |
| #if CC_NV_DefineSpace | |
| case TPM_CC_NV_DefineSpace: | |
| *handleCount = 1; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_NV_DefineSpace | |
| #if CC_NV_UndefineSpace | |
| case TPM_CC_NV_UndefineSpace: | |
| *handleCount = 2; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_UndefineSpace | |
| #if CC_NV_UndefineSpaceSpecial | |
| case TPM_CC_NV_UndefineSpaceSpecial: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_PLATFORM_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_UndefineSpaceSpecial | |
| #if CC_NV_ReadPublic | |
| case TPM_CC_NV_ReadPublic: | |
| *handleCount = 1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_NV_ReadPublic | |
| #if CC_NV_Write | |
| case TPM_CC_NV_Write: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_Write | |
| #if CC_NV_Increment | |
| case TPM_CC_NV_Increment: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_Increment | |
| #if CC_NV_Extend | |
| case TPM_CC_NV_Extend: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_Extend | |
| #if CC_NV_SetBits | |
| case TPM_CC_NV_SetBits: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_SetBits | |
| #if CC_NV_WriteLock | |
| case TPM_CC_NV_WriteLock: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_WriteLock | |
| #if CC_NV_GlobalWriteLock | |
| case TPM_CC_NV_GlobalWriteLock: | |
| *handleCount = 1; | |
| result = TPMI_RH_PROVISION_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_NV_GlobalWriteLock | |
| #if CC_NV_Read | |
| case TPM_CC_NV_Read: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_Read | |
| #if CC_NV_ReadLock | |
| case TPM_CC_NV_ReadLock: | |
| *handleCount = 2; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| break; | |
| #endif // CC_NV_ReadLock | |
| #if CC_NV_ChangeAuth | |
| case TPM_CC_NV_ChangeAuth: | |
| *handleCount = 1; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_NV_ChangeAuth | |
| #if CC_NV_Certify | |
| case TPM_CC_NV_Certify: | |
| *handleCount = 3; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, TRUE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| result = TPMI_RH_NV_INDEX_Unmarshal(&handles[2], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_3; | |
| break; | |
| #endif // CC_NV_Certify | |
| #if CC_AC_GetCapability | |
| case TPM_CC_AC_GetCapability: | |
| *handleCount = 1; | |
| result = TPMI_RH_AC_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_AC_GetCapability | |
| #if CC_AC_Send | |
| case TPM_CC_AC_Send: | |
| *handleCount = 3; | |
| result = TPMI_DH_OBJECT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize, FALSE); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| result = TPMI_RH_NV_AUTH_Unmarshal(&handles[1], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_2; | |
| result = TPMI_RH_AC_Unmarshal(&handles[2], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_3; | |
| break; | |
| #endif // CC_AC_Send | |
| #if CC_Policy_AC_SendSelect | |
| case TPM_CC_Policy_AC_SendSelect: | |
| *handleCount = 1; | |
| result = TPMI_SH_POLICY_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_Policy_AC_SendSelect | |
| #if CC_ACT_SetTimeout | |
| case TPM_CC_ACT_SetTimeout: | |
| *handleCount = 1; | |
| result = TPMI_RH_ACT_Unmarshal(&handles[0], handleBufferStart, | |
| bufferRemainingSize); | |
| if(TPM_RC_SUCCESS != result) return result + TPM_RC_H + TPM_RC_1; | |
| break; | |
| #endif // CC_ACT_SetTimeout | |
| #if CC_Vendor_TCG_Test | |
| case TPM_CC_Vendor_TCG_Test: | |
| break; | |
| #endif // CC_Vendor_TCG_Test |