/* 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: Mar  6, 2020  Time: 01:50:10PM
 */

// This macro is added just so that the code is only excessively long.
#define EXIT_IF_ERROR_PLUS(x)  \
  if(TPM_RC_SUCCESS != result) \
  {                            \
    result += (x);             \
    goto Exit;                 \
  }
#if CC_Startup
case TPM_CC_Startup:
{
    Startup_In* in = (Startup_In*)MemoryGetInBuffer(sizeof(Startup_In));
    result         = TPM_SU_Unmarshal(&in->startupType, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Startup_startupType);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Startup(in);
    break;
}
#endif  // CC_Startup
#if CC_Shutdown
case TPM_CC_Shutdown:
{
    Shutdown_In* in = (Shutdown_In*)MemoryGetInBuffer(sizeof(Shutdown_In));
    result = TPM_SU_Unmarshal(&in->shutdownType, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Shutdown_shutdownType);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Shutdown(in);
    break;
}
#endif  // CC_Shutdown
#if CC_SelfTest
case TPM_CC_SelfTest:
{
    SelfTest_In* in = (SelfTest_In*)MemoryGetInBuffer(sizeof(SelfTest_In));
    result = TPMI_YES_NO_Unmarshal(&in->fullTest, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SelfTest_fullTest);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_SelfTest(in);
    break;
}
#endif  // CC_SelfTest
#if CC_IncrementalSelfTest
case TPM_CC_IncrementalSelfTest:
{
    IncrementalSelfTest_In* in =
        (IncrementalSelfTest_In*)MemoryGetInBuffer(sizeof(IncrementalSelfTest_In));
    IncrementalSelfTest_Out* out =
        (IncrementalSelfTest_Out*)MemoryGetOutBuffer(sizeof(IncrementalSelfTest_Out));
    result = TPML_ALG_Unmarshal(&in->toTest, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_IncrementalSelfTest_toTest);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_IncrementalSelfTest(in, out);
    rSize  = sizeof(IncrementalSelfTest_Out);
    *respParmSize += TPML_ALG_Marshal(&out->toDoList, responseBuffer, &rSize);
    break;
}
#endif  // CC_IncrementalSelfTest
#if CC_GetTestResult
case TPM_CC_GetTestResult:
{
    GetTestResult_Out* out =
        (GetTestResult_Out*)MemoryGetOutBuffer(sizeof(GetTestResult_Out));
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_GetTestResult(out);
    rSize  = sizeof(GetTestResult_Out);
    *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->outData, responseBuffer, &rSize);
    *respParmSize += TPM_RC_Marshal(&out->testResult, responseBuffer, &rSize);
    break;
}
#endif  // CC_GetTestResult
#if CC_StartAuthSession
case TPM_CC_StartAuthSession:
{
    StartAuthSession_In* in =
        (StartAuthSession_In*)MemoryGetInBuffer(sizeof(StartAuthSession_In));
    StartAuthSession_Out* out =
        (StartAuthSession_Out*)MemoryGetOutBuffer(sizeof(StartAuthSession_Out));
    in->tpmKey = handles[0];
    in->bind   = handles[1];
    result = TPM2B_NONCE_Unmarshal(&in->nonceCaller, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_StartAuthSession_nonceCaller);
    result = TPM2B_ENCRYPTED_SECRET_Unmarshal(
        &in->encryptedSalt, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_StartAuthSession_encryptedSalt);
    result = TPM_SE_Unmarshal(&in->sessionType, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_StartAuthSession_sessionType);
    result =
        TPMT_SYM_DEF_Unmarshal(&in->symmetric, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_StartAuthSession_symmetric);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->authHash, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_StartAuthSession_authHash);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_StartAuthSession(in, out);
    rSize  = sizeof(StartAuthSession_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->sessionHandle;
    *respParmSize += TPM2B_NONCE_Marshal(&out->nonceTPM, responseBuffer, &rSize);
    break;
}
#endif  // CC_StartAuthSession
#if CC_PolicyRestart
case TPM_CC_PolicyRestart:
{
    PolicyRestart_In* in =
        (PolicyRestart_In*)MemoryGetInBuffer(sizeof(PolicyRestart_In));
    in->sessionHandle = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyRestart(in);
    break;
}
#endif  // CC_PolicyRestart
#if CC_Create
case TPM_CC_Create:
{
    Create_In*  in   = (Create_In*)MemoryGetInBuffer(sizeof(Create_In));
    Create_Out* out  = (Create_Out*)MemoryGetOutBuffer(sizeof(Create_Out));
    in->parentHandle = handles[0];
    result           = TPM2B_SENSITIVE_CREATE_Unmarshal(
        &in->inSensitive, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Create_inSensitive);
    result =
        TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_Create_inPublic);
    result = TPM2B_DATA_Unmarshal(&in->outsideInfo, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Create_outsideInfo);
    result =
        TPML_PCR_SELECTION_Unmarshal(&in->creationPCR, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Create_creationPCR);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Create(in, out);
    rSize  = sizeof(Create_Out);
    *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, responseBuffer, &rSize);
    *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, responseBuffer, &rSize);
    *respParmSize +=
        TPM2B_CREATION_DATA_Marshal(&out->creationData, responseBuffer, &rSize);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->creationHash, responseBuffer, &rSize);
    *respParmSize +=
        TPMT_TK_CREATION_Marshal(&out->creationTicket, responseBuffer, &rSize);
    break;
}
#endif  // CC_Create
#if CC_Load
case TPM_CC_Load:
{
    Load_In*  in     = (Load_In*)MemoryGetInBuffer(sizeof(Load_In));
    Load_Out* out    = (Load_Out*)MemoryGetOutBuffer(sizeof(Load_Out));
    in->parentHandle = handles[0];
    result = TPM2B_PRIVATE_Unmarshal(&in->inPrivate, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Load_inPrivate);
    result =
        TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_Load_inPublic);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Load(in, out);
    rSize  = sizeof(Load_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->objectHandle;
    *respParmSize += TPM2B_NAME_Marshal(&out->name, responseBuffer, &rSize);
    break;
}
#endif  // CC_Load
#if CC_LoadExternal
case TPM_CC_LoadExternal:
{
    LoadExternal_In* in =
        (LoadExternal_In*)MemoryGetInBuffer(sizeof(LoadExternal_In));
    LoadExternal_Out* out =
        (LoadExternal_Out*)MemoryGetOutBuffer(sizeof(LoadExternal_Out));
    result = TPM2B_SENSITIVE_Unmarshal(&in->inPrivate, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_LoadExternal_inPrivate);
    result =
        TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_LoadExternal_inPublic);
    result = TPMI_RH_HIERARCHY_Unmarshal(
        &in->hierarchy, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_LoadExternal_hierarchy);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_LoadExternal(in, out);
    rSize  = sizeof(LoadExternal_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->objectHandle;
    *respParmSize += TPM2B_NAME_Marshal(&out->name, responseBuffer, &rSize);
    break;
}
#endif  // CC_LoadExternal
#if CC_ReadPublic
case TPM_CC_ReadPublic:
{
    ReadPublic_In*  in  = (ReadPublic_In*)MemoryGetInBuffer(sizeof(ReadPublic_In));
    ReadPublic_Out* out = (ReadPublic_Out*)MemoryGetOutBuffer(sizeof(ReadPublic_Out));
    in->objectHandle    = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ReadPublic(in, out);
    rSize  = sizeof(ReadPublic_Out);
    *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, responseBuffer, &rSize);
    *respParmSize += TPM2B_NAME_Marshal(&out->name, responseBuffer, &rSize);
    *respParmSize += TPM2B_NAME_Marshal(&out->qualifiedName, responseBuffer, &rSize);
    break;
}
#endif  // CC_ReadPublic
#if CC_ActivateCredential
case TPM_CC_ActivateCredential:
{
    ActivateCredential_In* in =
        (ActivateCredential_In*)MemoryGetInBuffer(sizeof(ActivateCredential_In));
    ActivateCredential_Out* out =
        (ActivateCredential_Out*)MemoryGetOutBuffer(sizeof(ActivateCredential_Out));
    in->activateHandle = handles[0];
    in->keyHandle      = handles[1];
    result =
        TPM2B_ID_OBJECT_Unmarshal(&in->credentialBlob, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ActivateCredential_credentialBlob);
    result =
        TPM2B_ENCRYPTED_SECRET_Unmarshal(&in->secret, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ActivateCredential_secret);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ActivateCredential(in, out);
    rSize  = sizeof(ActivateCredential_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->certInfo, responseBuffer, &rSize);
    break;
}
#endif  // CC_ActivateCredential
#if CC_MakeCredential
case TPM_CC_MakeCredential:
{
    MakeCredential_In* in =
        (MakeCredential_In*)MemoryGetInBuffer(sizeof(MakeCredential_In));
    MakeCredential_Out* out =
        (MakeCredential_Out*)MemoryGetOutBuffer(sizeof(MakeCredential_Out));
    in->handle = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->credential, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_MakeCredential_credential);
    result = TPM2B_NAME_Unmarshal(&in->objectName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_MakeCredential_objectName);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_MakeCredential(in, out);
    rSize  = sizeof(MakeCredential_Out);
    *respParmSize +=
        TPM2B_ID_OBJECT_Marshal(&out->credentialBlob, responseBuffer, &rSize);
    *respParmSize +=
        TPM2B_ENCRYPTED_SECRET_Marshal(&out->secret, responseBuffer, &rSize);
    break;
}
#endif  // CC_MakeCredential
#if CC_Unseal
case TPM_CC_Unseal:
{
    Unseal_In*  in  = (Unseal_In*)MemoryGetInBuffer(sizeof(Unseal_In));
    Unseal_Out* out = (Unseal_Out*)MemoryGetOutBuffer(sizeof(Unseal_Out));
    in->itemHandle  = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Unseal(in, out);
    rSize  = sizeof(Unseal_Out);
    *respParmSize +=
        TPM2B_SENSITIVE_DATA_Marshal(&out->outData, responseBuffer, &rSize);
    break;
}
#endif  // CC_Unseal
#if CC_ObjectChangeAuth
case TPM_CC_ObjectChangeAuth:
{
    ObjectChangeAuth_In* in =
        (ObjectChangeAuth_In*)MemoryGetInBuffer(sizeof(ObjectChangeAuth_In));
    ObjectChangeAuth_Out* out =
        (ObjectChangeAuth_Out*)MemoryGetOutBuffer(sizeof(ObjectChangeAuth_Out));
    in->objectHandle = handles[0];
    in->parentHandle = handles[1];
    result = TPM2B_AUTH_Unmarshal(&in->newAuth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ObjectChangeAuth_newAuth);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ObjectChangeAuth(in, out);
    rSize  = sizeof(ObjectChangeAuth_Out);
    *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, responseBuffer, &rSize);
    break;
}
#endif  // CC_ObjectChangeAuth
#if CC_CreateLoaded
case TPM_CC_CreateLoaded:
{
    CreateLoaded_In* in =
        (CreateLoaded_In*)MemoryGetInBuffer(sizeof(CreateLoaded_In));
    CreateLoaded_Out* out =
        (CreateLoaded_Out*)MemoryGetOutBuffer(sizeof(CreateLoaded_Out));
    in->parentHandle = handles[0];
    result           = TPM2B_SENSITIVE_CREATE_Unmarshal(
        &in->inSensitive, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CreateLoaded_inSensitive);
    result = TPM2B_TEMPLATE_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CreateLoaded_inPublic);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_CreateLoaded(in, out);
    rSize  = sizeof(CreateLoaded_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->objectHandle;
    *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, responseBuffer, &rSize);
    *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, responseBuffer, &rSize);
    *respParmSize += TPM2B_NAME_Marshal(&out->name, responseBuffer, &rSize);
    break;
}
#endif  // CC_CreateLoaded
#if CC_Duplicate
case TPM_CC_Duplicate:
{
    Duplicate_In*  in   = (Duplicate_In*)MemoryGetInBuffer(sizeof(Duplicate_In));
    Duplicate_Out* out  = (Duplicate_Out*)MemoryGetOutBuffer(sizeof(Duplicate_Out));
    in->objectHandle    = handles[0];
    in->newParentHandle = handles[1];
    result = TPM2B_DATA_Unmarshal(&in->encryptionKeyIn, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Duplicate_encryptionKeyIn);
    result = TPMT_SYM_DEF_OBJECT_Unmarshal(
        &in->symmetricAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_Duplicate_symmetricAlg);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Duplicate(in, out);
    rSize  = sizeof(Duplicate_Out);
    *respParmSize +=
        TPM2B_DATA_Marshal(&out->encryptionKeyOut, responseBuffer, &rSize);
    *respParmSize += TPM2B_PRIVATE_Marshal(&out->duplicate, responseBuffer, &rSize);
    *respParmSize +=
        TPM2B_ENCRYPTED_SECRET_Marshal(&out->outSymSeed, responseBuffer, &rSize);
    break;
}
#endif  // CC_Duplicate
#if CC_Rewrap
case TPM_CC_Rewrap:
{
    Rewrap_In*  in  = (Rewrap_In*)MemoryGetInBuffer(sizeof(Rewrap_In));
    Rewrap_Out* out = (Rewrap_Out*)MemoryGetOutBuffer(sizeof(Rewrap_Out));
    in->oldParent   = handles[0];
    in->newParent   = handles[1];
    result = TPM2B_PRIVATE_Unmarshal(&in->inDuplicate, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Rewrap_inDuplicate);
    result = TPM2B_NAME_Unmarshal(&in->name, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Rewrap_name);
    result = TPM2B_ENCRYPTED_SECRET_Unmarshal(
        &in->inSymSeed, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Rewrap_inSymSeed);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Rewrap(in, out);
    rSize  = sizeof(Rewrap_Out);
    *respParmSize +=
        TPM2B_PRIVATE_Marshal(&out->outDuplicate, responseBuffer, &rSize);
    *respParmSize +=
        TPM2B_ENCRYPTED_SECRET_Marshal(&out->outSymSeed, responseBuffer, &rSize);
    break;
}
#endif  // CC_Rewrap
#if CC_Import
case TPM_CC_Import:
{
    Import_In*  in   = (Import_In*)MemoryGetInBuffer(sizeof(Import_In));
    Import_Out* out  = (Import_Out*)MemoryGetOutBuffer(sizeof(Import_Out));
    in->parentHandle = handles[0];
    result = TPM2B_DATA_Unmarshal(&in->encryptionKey, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Import_encryptionKey);
    result = TPM2B_PUBLIC_Unmarshal(
        &in->objectPublic, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_Import_objectPublic);
    result = TPM2B_PRIVATE_Unmarshal(&in->duplicate, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Import_duplicate);
    result = TPM2B_ENCRYPTED_SECRET_Unmarshal(
        &in->inSymSeed, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Import_inSymSeed);
    result = TPMT_SYM_DEF_OBJECT_Unmarshal(
        &in->symmetricAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_Import_symmetricAlg);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Import(in, out);
    rSize  = sizeof(Import_Out);
    *respParmSize += TPM2B_PRIVATE_Marshal(&out->outPrivate, responseBuffer, &rSize);
    break;
}
#endif  // CC_Import
#if CC_RSA_Encrypt
case TPM_CC_RSA_Encrypt:
{
    RSA_Encrypt_In*  in = (RSA_Encrypt_In*)MemoryGetInBuffer(sizeof(RSA_Encrypt_In));
    RSA_Encrypt_Out* out =
        (RSA_Encrypt_Out*)MemoryGetOutBuffer(sizeof(RSA_Encrypt_Out));
    in->keyHandle = handles[0];
    result =
        TPM2B_PUBLIC_KEY_RSA_Unmarshal(&in->message, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_RSA_Encrypt_message);
    result =
        TPMT_RSA_DECRYPT_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_RSA_Encrypt_inScheme);
    result = TPM2B_DATA_Unmarshal(&in->label, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_RSA_Encrypt_label);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_RSA_Encrypt(in, out);
    rSize  = sizeof(RSA_Encrypt_Out);
    *respParmSize +=
        TPM2B_PUBLIC_KEY_RSA_Marshal(&out->outData, responseBuffer, &rSize);
    break;
}
#endif  // CC_RSA_Encrypt
#if CC_RSA_Decrypt
case TPM_CC_RSA_Decrypt:
{
    RSA_Decrypt_In*  in = (RSA_Decrypt_In*)MemoryGetInBuffer(sizeof(RSA_Decrypt_In));
    RSA_Decrypt_Out* out =
        (RSA_Decrypt_Out*)MemoryGetOutBuffer(sizeof(RSA_Decrypt_Out));
    in->keyHandle = handles[0];
    result =
        TPM2B_PUBLIC_KEY_RSA_Unmarshal(&in->cipherText, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_RSA_Decrypt_cipherText);
    result =
        TPMT_RSA_DECRYPT_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_RSA_Decrypt_inScheme);
    result = TPM2B_DATA_Unmarshal(&in->label, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_RSA_Decrypt_label);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_RSA_Decrypt(in, out);
    rSize  = sizeof(RSA_Decrypt_Out);
    *respParmSize +=
        TPM2B_PUBLIC_KEY_RSA_Marshal(&out->message, responseBuffer, &rSize);
    break;
}
#endif  // CC_RSA_Decrypt
#if CC_ECDH_KeyGen
case TPM_CC_ECDH_KeyGen:
{
    ECDH_KeyGen_In*  in = (ECDH_KeyGen_In*)MemoryGetInBuffer(sizeof(ECDH_KeyGen_In));
    ECDH_KeyGen_Out* out =
        (ECDH_KeyGen_Out*)MemoryGetOutBuffer(sizeof(ECDH_KeyGen_Out));
    in->keyHandle = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ECDH_KeyGen(in, out);
    rSize  = sizeof(ECDH_KeyGen_Out);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->zPoint, responseBuffer, &rSize);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->pubPoint, responseBuffer, &rSize);
    break;
}
#endif  // CC_ECDH_KeyGen
#if CC_ECDH_ZGen
case TPM_CC_ECDH_ZGen:
{
    ECDH_ZGen_In*  in  = (ECDH_ZGen_In*)MemoryGetInBuffer(sizeof(ECDH_ZGen_In));
    ECDH_ZGen_Out* out = (ECDH_ZGen_Out*)MemoryGetOutBuffer(sizeof(ECDH_ZGen_Out));
    in->keyHandle      = handles[0];
    result = TPM2B_ECC_POINT_Unmarshal(&in->inPoint, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ECDH_ZGen_inPoint);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ECDH_ZGen(in, out);
    rSize  = sizeof(ECDH_ZGen_Out);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->outPoint, responseBuffer, &rSize);
    break;
}
#endif  // CC_ECDH_ZGen
#if CC_ECC_Parameters
case TPM_CC_ECC_Parameters:
{
    ECC_Parameters_In* in =
        (ECC_Parameters_In*)MemoryGetInBuffer(sizeof(ECC_Parameters_In));
    ECC_Parameters_Out* out =
        (ECC_Parameters_Out*)MemoryGetOutBuffer(sizeof(ECC_Parameters_Out));
    result = TPMI_ECC_CURVE_Unmarshal(&in->curveID, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ECC_Parameters_curveID);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ECC_Parameters(in, out);
    rSize  = sizeof(ECC_Parameters_Out);
    *respParmSize +=
        TPMS_ALGORITHM_DETAIL_ECC_Marshal(&out->parameters, responseBuffer, &rSize);
    break;
}
#endif  // CC_ECC_Parameters
#if CC_ZGen_2Phase
case TPM_CC_ZGen_2Phase:
{
    ZGen_2Phase_In*  in = (ZGen_2Phase_In*)MemoryGetInBuffer(sizeof(ZGen_2Phase_In));
    ZGen_2Phase_Out* out =
        (ZGen_2Phase_Out*)MemoryGetOutBuffer(sizeof(ZGen_2Phase_Out));
    in->keyA = handles[0];
    result   = TPM2B_ECC_POINT_Unmarshal(&in->inQsB, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_inQsB);
    result = TPM2B_ECC_POINT_Unmarshal(&in->inQeB, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_inQeB);
    result = TPMI_ECC_KEY_EXCHANGE_Unmarshal(
        &in->inScheme, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_inScheme);
    result = UINT16_Unmarshal(&in->counter, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ZGen_2Phase_counter);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ZGen_2Phase(in, out);
    rSize  = sizeof(ZGen_2Phase_Out);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->outZ1, responseBuffer, &rSize);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->outZ2, responseBuffer, &rSize);
    break;
}
#endif  // CC_ZGen_2Phase
#if CC_ECC_Encrypt
case TPM_CC_ECC_Encrypt:
{
    ECC_Encrypt_In*  in = (ECC_Encrypt_In*)MemoryGetInBuffer(sizeof(ECC_Encrypt_In));
    ECC_Encrypt_Out* out =
        (ECC_Encrypt_Out*)MemoryGetOutBuffer(sizeof(ECC_Encrypt_Out));
    in->keyHandle = handles[0];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->plainText, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ECC_Encrypt_plainText);
    result =
        TPMT_KDF_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_ECC_Encrypt_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ECC_Encrypt(in, out);
    rSize  = sizeof(ECC_Encrypt_Out);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->C1, responseBuffer, &rSize);
    *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->C2, responseBuffer, &rSize);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->C3, responseBuffer, &rSize);
    break;
}
#endif  // CC_ECC_Encrypt
#if CC_ECC_Decrypt
case TPM_CC_ECC_Decrypt:
{
    ECC_Decrypt_In*  in = (ECC_Decrypt_In*)MemoryGetInBuffer(sizeof(ECC_Decrypt_In));
    ECC_Decrypt_Out* out =
        (ECC_Decrypt_Out*)MemoryGetOutBuffer(sizeof(ECC_Decrypt_Out));
    in->keyHandle = handles[0];
    result        = TPM2B_ECC_POINT_Unmarshal(&in->C1, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_C1);
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->C2, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_C2);
    result = TPM2B_DIGEST_Unmarshal(&in->C3, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_C3);
    result =
        TPMT_KDF_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_ECC_Decrypt_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ECC_Decrypt(in, out);
    rSize  = sizeof(ECC_Decrypt_Out);
    *respParmSize +=
        TPM2B_MAX_BUFFER_Marshal(&out->plainText, responseBuffer, &rSize);
    break;
}
#endif  // CC_ECC_Decrypt
#if CC_EncryptDecrypt
case TPM_CC_EncryptDecrypt:
{
    EncryptDecrypt_In* in =
        (EncryptDecrypt_In*)MemoryGetInBuffer(sizeof(EncryptDecrypt_In));
    EncryptDecrypt_Out* out =
        (EncryptDecrypt_Out*)MemoryGetOutBuffer(sizeof(EncryptDecrypt_Out));
    in->keyHandle = handles[0];
    result        = TPMI_YES_NO_Unmarshal(&in->decrypt, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_decrypt);
    result =
        TPMI_ALG_CIPHER_MODE_Unmarshal(&in->mode, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_mode);
    result = TPM2B_IV_Unmarshal(&in->ivIn, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_ivIn);
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->inData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt_inData);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_EncryptDecrypt(in, out);
    rSize  = sizeof(EncryptDecrypt_Out);
    *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->outData, responseBuffer, &rSize);
    *respParmSize += TPM2B_IV_Marshal(&out->ivOut, responseBuffer, &rSize);
    break;
}
#endif  // CC_EncryptDecrypt
#if CC_EncryptDecrypt2
case TPM_CC_EncryptDecrypt2:
{
    EncryptDecrypt2_In* in =
        (EncryptDecrypt2_In*)MemoryGetInBuffer(sizeof(EncryptDecrypt2_In));
    EncryptDecrypt2_Out* out =
        (EncryptDecrypt2_Out*)MemoryGetOutBuffer(sizeof(EncryptDecrypt2_Out));
    in->keyHandle = handles[0];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->inData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_inData);
    result = TPMI_YES_NO_Unmarshal(&in->decrypt, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_decrypt);
    result =
        TPMI_ALG_CIPHER_MODE_Unmarshal(&in->mode, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_mode);
    result = TPM2B_IV_Unmarshal(&in->ivIn, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EncryptDecrypt2_ivIn);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_EncryptDecrypt2(in, out);
    rSize  = sizeof(EncryptDecrypt2_Out);
    *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->outData, responseBuffer, &rSize);
    *respParmSize += TPM2B_IV_Marshal(&out->ivOut, responseBuffer, &rSize);
    break;
}
#endif  // CC_EncryptDecrypt2
#if CC_Hash
case TPM_CC_Hash:
{
    Hash_In*  in  = (Hash_In*)MemoryGetInBuffer(sizeof(Hash_In));
    Hash_Out* out = (Hash_Out*)MemoryGetOutBuffer(sizeof(Hash_Out));
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->data, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Hash_data);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_Hash_hashAlg);
    result = TPMI_RH_HIERARCHY_Unmarshal(
        &in->hierarchy, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_Hash_hierarchy);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Hash(in, out);
    rSize  = sizeof(Hash_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->outHash, responseBuffer, &rSize);
    *respParmSize +=
        TPMT_TK_HASHCHECK_Marshal(&out->validation, responseBuffer, &rSize);
    break;
}
#endif  // CC_Hash
#if CC_HMAC
case TPM_CC_HMAC:
{
    HMAC_In*  in  = (HMAC_In*)MemoryGetInBuffer(sizeof(HMAC_In));
    HMAC_Out* out = (HMAC_Out*)MemoryGetOutBuffer(sizeof(HMAC_Out));
    in->handle    = handles[0];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_HMAC_buffer);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_HMAC_hashAlg);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_HMAC(in, out);
    rSize  = sizeof(HMAC_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->outHMAC, responseBuffer, &rSize);
    break;
}
#endif  // CC_HMAC
#if CC_MAC
case TPM_CC_MAC:
{
    MAC_In*  in  = (MAC_In*)MemoryGetInBuffer(sizeof(MAC_In));
    MAC_Out* out = (MAC_Out*)MemoryGetOutBuffer(sizeof(MAC_Out));
    in->handle   = handles[0];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_MAC_buffer);
    result = TPMI_ALG_MAC_SCHEME_Unmarshal(
        &in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_MAC_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_MAC(in, out);
    rSize  = sizeof(MAC_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->outMAC, responseBuffer, &rSize);
    break;
}
#endif  // CC_MAC
#if CC_GetRandom
case TPM_CC_GetRandom:
{
    GetRandom_In*  in  = (GetRandom_In*)MemoryGetInBuffer(sizeof(GetRandom_In));
    GetRandom_Out* out = (GetRandom_Out*)MemoryGetOutBuffer(sizeof(GetRandom_Out));
    result = UINT16_Unmarshal(&in->bytesRequested, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetRandom_bytesRequested);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_GetRandom(in, out);
    rSize  = sizeof(GetRandom_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->randomBytes, responseBuffer, &rSize);
    break;
}
#endif  // CC_GetRandom
#if CC_StirRandom
case TPM_CC_StirRandom:
{
    StirRandom_In* in = (StirRandom_In*)MemoryGetInBuffer(sizeof(StirRandom_In));
    result =
        TPM2B_SENSITIVE_DATA_Unmarshal(&in->inData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_StirRandom_inData);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_StirRandom(in);
    break;
}
#endif  // CC_StirRandom
#if CC_HMAC_Start
case TPM_CC_HMAC_Start:
{
    HMAC_Start_In*  in  = (HMAC_Start_In*)MemoryGetInBuffer(sizeof(HMAC_Start_In));
    HMAC_Start_Out* out = (HMAC_Start_Out*)MemoryGetOutBuffer(sizeof(HMAC_Start_Out));
    in->handle          = handles[0];
    result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_HMAC_Start_auth);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_HMAC_Start_hashAlg);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_HMAC_Start(in, out);
    rSize  = sizeof(HMAC_Start_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->sequenceHandle;
    break;
}
#endif  // CC_HMAC_Start
#if CC_MAC_Start
case TPM_CC_MAC_Start:
{
    MAC_Start_In*  in  = (MAC_Start_In*)MemoryGetInBuffer(sizeof(MAC_Start_In));
    MAC_Start_Out* out = (MAC_Start_Out*)MemoryGetOutBuffer(sizeof(MAC_Start_Out));
    in->handle         = handles[0];
    result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_MAC_Start_auth);
    result = TPMI_ALG_MAC_SCHEME_Unmarshal(
        &in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_MAC_Start_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_MAC_Start(in, out);
    rSize  = sizeof(MAC_Start_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->sequenceHandle;
    break;
}
#endif  // CC_MAC_Start
#if CC_HashSequenceStart
case TPM_CC_HashSequenceStart:
{
    HashSequenceStart_In* in =
        (HashSequenceStart_In*)MemoryGetInBuffer(sizeof(HashSequenceStart_In));
    HashSequenceStart_Out* out =
        (HashSequenceStart_Out*)MemoryGetOutBuffer(sizeof(HashSequenceStart_Out));
    result = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_HashSequenceStart_auth);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_HashSequenceStart_hashAlg);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_HashSequenceStart(in, out);
    rSize  = sizeof(HashSequenceStart_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->sequenceHandle;
    break;
}
#endif  // CC_HashSequenceStart
#if CC_SequenceUpdate
case TPM_CC_SequenceUpdate:
{
    SequenceUpdate_In* in =
        (SequenceUpdate_In*)MemoryGetInBuffer(sizeof(SequenceUpdate_In));
    in->sequenceHandle = handles[0];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SequenceUpdate_buffer);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_SequenceUpdate(in);
    break;
}
#endif  // CC_SequenceUpdate
#if CC_SequenceComplete
case TPM_CC_SequenceComplete:
{
    SequenceComplete_In* in =
        (SequenceComplete_In*)MemoryGetInBuffer(sizeof(SequenceComplete_In));
    SequenceComplete_Out* out =
        (SequenceComplete_Out*)MemoryGetOutBuffer(sizeof(SequenceComplete_Out));
    in->sequenceHandle = handles[0];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SequenceComplete_buffer);
    result = TPMI_RH_HIERARCHY_Unmarshal(
        &in->hierarchy, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_SequenceComplete_hierarchy);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_SequenceComplete(in, out);
    rSize  = sizeof(SequenceComplete_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->result, responseBuffer, &rSize);
    *respParmSize +=
        TPMT_TK_HASHCHECK_Marshal(&out->validation, responseBuffer, &rSize);
    break;
}
#endif  // CC_SequenceComplete
#if CC_EventSequenceComplete
case TPM_CC_EventSequenceComplete:
{
    EventSequenceComplete_In* in = (EventSequenceComplete_In*)MemoryGetInBuffer(
        sizeof(EventSequenceComplete_In));
    EventSequenceComplete_Out* out = (EventSequenceComplete_Out*)MemoryGetOutBuffer(
        sizeof(EventSequenceComplete_Out));
    in->pcrHandle      = handles[0];
    in->sequenceHandle = handles[1];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->buffer, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EventSequenceComplete_buffer);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_EventSequenceComplete(in, out);
    rSize  = sizeof(EventSequenceComplete_Out);
    *respParmSize +=
        TPML_DIGEST_VALUES_Marshal(&out->results, responseBuffer, &rSize);
    break;
}
#endif  // CC_EventSequenceComplete
#if CC_Certify
case TPM_CC_Certify:
{
    Certify_In*  in  = (Certify_In*)MemoryGetInBuffer(sizeof(Certify_In));
    Certify_Out* out = (Certify_Out*)MemoryGetOutBuffer(sizeof(Certify_Out));
    in->objectHandle = handles[0];
    in->signHandle   = handles[1];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Certify_qualifyingData);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_Certify_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Certify(in, out);
    rSize  = sizeof(Certify_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->certifyInfo, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_Certify
#if CC_CertifyCreation
case TPM_CC_CertifyCreation:
{
    CertifyCreation_In* in =
        (CertifyCreation_In*)MemoryGetInBuffer(sizeof(CertifyCreation_In));
    CertifyCreation_Out* out =
        (CertifyCreation_Out*)MemoryGetOutBuffer(sizeof(CertifyCreation_Out));
    in->signHandle   = handles[0];
    in->objectHandle = handles[1];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CertifyCreation_qualifyingData);
    result = TPM2B_DIGEST_Unmarshal(&in->creationHash, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CertifyCreation_creationHash);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_CertifyCreation_inScheme);
    result =
        TPMT_TK_CREATION_Unmarshal(&in->creationTicket, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CertifyCreation_creationTicket);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_CertifyCreation(in, out);
    rSize  = sizeof(CertifyCreation_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->certifyInfo, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_CertifyCreation
#if CC_Quote
case TPM_CC_Quote:
{
    Quote_In*  in  = (Quote_In*)MemoryGetInBuffer(sizeof(Quote_In));
    Quote_Out* out = (Quote_Out*)MemoryGetOutBuffer(sizeof(Quote_Out));
    in->signHandle = handles[0];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Quote_qualifyingData);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_Quote_inScheme);
    result =
        TPML_PCR_SELECTION_Unmarshal(&in->PCRselect, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Quote_PCRselect);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Quote(in, out);
    rSize  = sizeof(Quote_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->quoted, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_Quote
#if CC_GetSessionAuditDigest
case TPM_CC_GetSessionAuditDigest:
{
    GetSessionAuditDigest_In* in = (GetSessionAuditDigest_In*)MemoryGetInBuffer(
        sizeof(GetSessionAuditDigest_In));
    GetSessionAuditDigest_Out* out = (GetSessionAuditDigest_Out*)MemoryGetOutBuffer(
        sizeof(GetSessionAuditDigest_Out));
    in->privacyAdminHandle = handles[0];
    in->signHandle         = handles[1];
    in->sessionHandle      = handles[2];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetSessionAuditDigest_qualifyingData);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_GetSessionAuditDigest_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_GetSessionAuditDigest(in, out);
    rSize  = sizeof(GetSessionAuditDigest_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->auditInfo, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_GetSessionAuditDigest
#if CC_GetCommandAuditDigest
case TPM_CC_GetCommandAuditDigest:
{
    GetCommandAuditDigest_In* in = (GetCommandAuditDigest_In*)MemoryGetInBuffer(
        sizeof(GetCommandAuditDigest_In));
    GetCommandAuditDigest_Out* out = (GetCommandAuditDigest_Out*)MemoryGetOutBuffer(
        sizeof(GetCommandAuditDigest_Out));
    in->privacyHandle = handles[0];
    in->signHandle    = handles[1];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetCommandAuditDigest_qualifyingData);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_GetCommandAuditDigest_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_GetCommandAuditDigest(in, out);
    rSize  = sizeof(GetCommandAuditDigest_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->auditInfo, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_GetCommandAuditDigest
#if CC_GetTime
case TPM_CC_GetTime:
{
    GetTime_In*  in        = (GetTime_In*)MemoryGetInBuffer(sizeof(GetTime_In));
    GetTime_Out* out       = (GetTime_Out*)MemoryGetOutBuffer(sizeof(GetTime_Out));
    in->privacyAdminHandle = handles[0];
    in->signHandle         = handles[1];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetTime_qualifyingData);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_GetTime_inScheme);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_GetTime(in, out);
    rSize  = sizeof(GetTime_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->timeInfo, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_GetTime
#if CC_CertifyX509
case TPM_CC_CertifyX509:
{
    CertifyX509_In*  in = (CertifyX509_In*)MemoryGetInBuffer(sizeof(CertifyX509_In));
    CertifyX509_Out* out =
        (CertifyX509_Out*)MemoryGetOutBuffer(sizeof(CertifyX509_Out));
    in->objectHandle = handles[0];
    in->signHandle   = handles[1];
    result = TPM2B_DATA_Unmarshal(&in->reserved, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CertifyX509_reserved);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_CertifyX509_inScheme);
    result = TPM2B_MAX_BUFFER_Unmarshal(
        &in->partialCertificate, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CertifyX509_partialCertificate);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_CertifyX509(in, out);
    rSize  = sizeof(CertifyX509_Out);
    *respParmSize +=
        TPM2B_MAX_BUFFER_Marshal(&out->addedToCertificate, responseBuffer, &rSize);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->tbsDigest, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_CertifyX509
#if CC_Commit
case TPM_CC_Commit:
{
    Commit_In*  in  = (Commit_In*)MemoryGetInBuffer(sizeof(Commit_In));
    Commit_Out* out = (Commit_Out*)MemoryGetOutBuffer(sizeof(Commit_Out));
    in->signHandle  = handles[0];
    result = TPM2B_ECC_POINT_Unmarshal(&in->P1, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Commit_P1);
    result = TPM2B_SENSITIVE_DATA_Unmarshal(&in->s2, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Commit_s2);
    result = TPM2B_ECC_PARAMETER_Unmarshal(&in->y2, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Commit_y2);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Commit(in, out);
    rSize  = sizeof(Commit_Out);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->K, responseBuffer, &rSize);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->L, responseBuffer, &rSize);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->E, responseBuffer, &rSize);
    *respParmSize += UINT16_Marshal(&out->counter, responseBuffer, &rSize);
    break;
}
#endif  // CC_Commit
#if CC_EC_Ephemeral
case TPM_CC_EC_Ephemeral:
{
    EC_Ephemeral_In* in =
        (EC_Ephemeral_In*)MemoryGetInBuffer(sizeof(EC_Ephemeral_In));
    EC_Ephemeral_Out* out =
        (EC_Ephemeral_Out*)MemoryGetOutBuffer(sizeof(EC_Ephemeral_Out));
    result = TPMI_ECC_CURVE_Unmarshal(&in->curveID, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EC_Ephemeral_curveID);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_EC_Ephemeral(in, out);
    rSize  = sizeof(EC_Ephemeral_Out);
    *respParmSize += TPM2B_ECC_POINT_Marshal(&out->Q, responseBuffer, &rSize);
    *respParmSize += UINT16_Marshal(&out->counter, responseBuffer, &rSize);
    break;
}
#endif  // CC_EC_Ephemeral
#if CC_VerifySignature
case TPM_CC_VerifySignature:
{
    VerifySignature_In* in =
        (VerifySignature_In*)MemoryGetInBuffer(sizeof(VerifySignature_In));
    VerifySignature_Out* out =
        (VerifySignature_Out*)MemoryGetOutBuffer(sizeof(VerifySignature_Out));
    in->keyHandle = handles[0];
    result        = TPM2B_DIGEST_Unmarshal(&in->digest, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_VerifySignature_digest);
    result =
        TPMT_SIGNATURE_Unmarshal(&in->signature, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_VerifySignature_signature);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_VerifySignature(in, out);
    rSize  = sizeof(VerifySignature_Out);
    *respParmSize +=
        TPMT_TK_VERIFIED_Marshal(&out->validation, responseBuffer, &rSize);
    break;
}
#endif  // CC_VerifySignature
#if CC_Sign
case TPM_CC_Sign:
{
    Sign_In*  in  = (Sign_In*)MemoryGetInBuffer(sizeof(Sign_In));
    Sign_Out* out = (Sign_Out*)MemoryGetOutBuffer(sizeof(Sign_Out));
    in->keyHandle = handles[0];
    result        = TPM2B_DIGEST_Unmarshal(&in->digest, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Sign_digest);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_Sign_inScheme);
    result =
        TPMT_TK_HASHCHECK_Unmarshal(&in->validation, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Sign_validation);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Sign(in, out);
    rSize  = sizeof(Sign_Out);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_Sign
#if CC_SetCommandCodeAuditStatus
case TPM_CC_SetCommandCodeAuditStatus:
{
    SetCommandCodeAuditStatus_In* in =
        (SetCommandCodeAuditStatus_In*)MemoryGetInBuffer(
            sizeof(SetCommandCodeAuditStatus_In));
    in->auth = handles[0];
    result =
        TPMI_ALG_HASH_Unmarshal(&in->auditAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_SetCommandCodeAuditStatus_auditAlg);
    result = TPML_CC_Unmarshal(&in->setList, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SetCommandCodeAuditStatus_setList);
    result = TPML_CC_Unmarshal(&in->clearList, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SetCommandCodeAuditStatus_clearList);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_SetCommandCodeAuditStatus(in);
    break;
}
#endif  // CC_SetCommandCodeAuditStatus
#if CC_PCR_Extend
case TPM_CC_PCR_Extend:
{
    PCR_Extend_In* in = (PCR_Extend_In*)MemoryGetInBuffer(sizeof(PCR_Extend_In));
    in->pcrHandle     = handles[0];
    result = TPML_DIGEST_VALUES_Unmarshal(&in->digests, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PCR_Extend_digests);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_Extend(in);
    break;
}
#endif  // CC_PCR_Extend
#if CC_PCR_Event
case TPM_CC_PCR_Event:
{
    PCR_Event_In*  in  = (PCR_Event_In*)MemoryGetInBuffer(sizeof(PCR_Event_In));
    PCR_Event_Out* out = (PCR_Event_Out*)MemoryGetOutBuffer(sizeof(PCR_Event_Out));
    in->pcrHandle      = handles[0];
    result = TPM2B_EVENT_Unmarshal(&in->eventData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PCR_Event_eventData);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_Event(in, out);
    rSize  = sizeof(PCR_Event_Out);
    *respParmSize +=
        TPML_DIGEST_VALUES_Marshal(&out->digests, responseBuffer, &rSize);
    break;
}
#endif  // CC_PCR_Event
#if CC_PCR_Read
case TPM_CC_PCR_Read:
{
    PCR_Read_In*  in  = (PCR_Read_In*)MemoryGetInBuffer(sizeof(PCR_Read_In));
    PCR_Read_Out* out = (PCR_Read_Out*)MemoryGetOutBuffer(sizeof(PCR_Read_Out));
    result            = TPML_PCR_SELECTION_Unmarshal(
        &in->pcrSelectionIn, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PCR_Read_pcrSelectionIn);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_Read(in, out);
    rSize  = sizeof(PCR_Read_Out);
    *respParmSize += UINT32_Marshal(&out->pcrUpdateCounter, responseBuffer, &rSize);
    *respParmSize +=
        TPML_PCR_SELECTION_Marshal(&out->pcrSelectionOut, responseBuffer, &rSize);
    *respParmSize += TPML_DIGEST_Marshal(&out->pcrValues, responseBuffer, &rSize);
    break;
}
#endif  // CC_PCR_Read
#if CC_PCR_Allocate
case TPM_CC_PCR_Allocate:
{
    PCR_Allocate_In* in =
        (PCR_Allocate_In*)MemoryGetInBuffer(sizeof(PCR_Allocate_In));
    PCR_Allocate_Out* out =
        (PCR_Allocate_Out*)MemoryGetOutBuffer(sizeof(PCR_Allocate_Out));
    in->authHandle = handles[0];
    result         = TPML_PCR_SELECTION_Unmarshal(
        &in->pcrAllocation, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PCR_Allocate_pcrAllocation);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_Allocate(in, out);
    rSize  = sizeof(PCR_Allocate_Out);
    *respParmSize +=
        TPMI_YES_NO_Marshal(&out->allocationSuccess, responseBuffer, &rSize);
    *respParmSize += UINT32_Marshal(&out->maxPCR, responseBuffer, &rSize);
    *respParmSize += UINT32_Marshal(&out->sizeNeeded, responseBuffer, &rSize);
    *respParmSize += UINT32_Marshal(&out->sizeAvailable, responseBuffer, &rSize);
    break;
}
#endif  // CC_PCR_Allocate
#if CC_PCR_SetAuthPolicy
case TPM_CC_PCR_SetAuthPolicy:
{
    PCR_SetAuthPolicy_In* in =
        (PCR_SetAuthPolicy_In*)MemoryGetInBuffer(sizeof(PCR_SetAuthPolicy_In));
    in->authHandle = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->authPolicy, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthPolicy_authPolicy);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthPolicy_hashAlg);
    result = TPMI_DH_PCR_Unmarshal(&in->pcrNum, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthPolicy_pcrNum);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_SetAuthPolicy(in);
    break;
}
#endif  // CC_PCR_SetAuthPolicy
#if CC_PCR_SetAuthValue
case TPM_CC_PCR_SetAuthValue:
{
    PCR_SetAuthValue_In* in =
        (PCR_SetAuthValue_In*)MemoryGetInBuffer(sizeof(PCR_SetAuthValue_In));
    in->pcrHandle = handles[0];
    result        = TPM2B_DIGEST_Unmarshal(&in->auth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PCR_SetAuthValue_auth);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_SetAuthValue(in);
    break;
}
#endif  // CC_PCR_SetAuthValue
#if CC_PCR_Reset
case TPM_CC_PCR_Reset:
{
    PCR_Reset_In* in = (PCR_Reset_In*)MemoryGetInBuffer(sizeof(PCR_Reset_In));
    in->pcrHandle    = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PCR_Reset(in);
    break;
}
#endif  // CC_PCR_Reset
#if CC_PolicySigned
case TPM_CC_PolicySigned:
{
    PolicySigned_In* in =
        (PolicySigned_In*)MemoryGetInBuffer(sizeof(PolicySigned_In));
    PolicySigned_Out* out =
        (PolicySigned_Out*)MemoryGetOutBuffer(sizeof(PolicySigned_Out));
    in->authObject    = handles[0];
    in->policySession = handles[1];
    result = TPM2B_NONCE_Unmarshal(&in->nonceTPM, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySigned_nonceTPM);
    result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySigned_cpHashA);
    result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySigned_policyRef);
    result = INT32_Unmarshal(&in->expiration, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySigned_expiration);
    result = TPMT_SIGNATURE_Unmarshal(&in->auth, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_PolicySigned_auth);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicySigned(in, out);
    rSize  = sizeof(PolicySigned_Out);
    *respParmSize += TPM2B_TIMEOUT_Marshal(&out->timeout, responseBuffer, &rSize);
    *respParmSize += TPMT_TK_AUTH_Marshal(&out->policyTicket, responseBuffer, &rSize);
    break;
}
#endif  // CC_PolicySigned
#if CC_PolicySecret
case TPM_CC_PolicySecret:
{
    PolicySecret_In* in =
        (PolicySecret_In*)MemoryGetInBuffer(sizeof(PolicySecret_In));
    PolicySecret_Out* out =
        (PolicySecret_Out*)MemoryGetOutBuffer(sizeof(PolicySecret_Out));
    in->authHandle    = handles[0];
    in->policySession = handles[1];
    result = TPM2B_NONCE_Unmarshal(&in->nonceTPM, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySecret_nonceTPM);
    result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySecret_cpHashA);
    result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySecret_policyRef);
    result = INT32_Unmarshal(&in->expiration, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicySecret_expiration);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicySecret(in, out);
    rSize  = sizeof(PolicySecret_Out);
    *respParmSize += TPM2B_TIMEOUT_Marshal(&out->timeout, responseBuffer, &rSize);
    *respParmSize += TPMT_TK_AUTH_Marshal(&out->policyTicket, responseBuffer, &rSize);
    break;
}
#endif  // CC_PolicySecret
#if CC_PolicyTicket
case TPM_CC_PolicyTicket:
{
    PolicyTicket_In* in =
        (PolicyTicket_In*)MemoryGetInBuffer(sizeof(PolicyTicket_In));
    in->policySession = handles[0];
    result = TPM2B_TIMEOUT_Unmarshal(&in->timeout, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyTicket_timeout);
    result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyTicket_cpHashA);
    result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyTicket_policyRef);
    result = TPM2B_NAME_Unmarshal(&in->authName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyTicket_authName);
    result = TPMT_TK_AUTH_Unmarshal(&in->ticket, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyTicket_ticket);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyTicket(in);
    break;
}
#endif  // CC_PolicyTicket
#if CC_PolicyOR
case TPM_CC_PolicyOR:
{
    PolicyOR_In* in   = (PolicyOR_In*)MemoryGetInBuffer(sizeof(PolicyOR_In));
    in->policySession = handles[0];
    result = TPML_DIGEST_Unmarshal(&in->pHashList, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyOR_pHashList);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyOR(in);
    break;
}
#endif  // CC_PolicyOR
#if CC_PolicyPCR
case TPM_CC_PolicyPCR:
{
    PolicyPCR_In* in  = (PolicyPCR_In*)MemoryGetInBuffer(sizeof(PolicyPCR_In));
    in->policySession = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->pcrDigest, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyPCR_pcrDigest);
    result = TPML_PCR_SELECTION_Unmarshal(&in->pcrs, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyPCR_pcrs);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyPCR(in);
    break;
}
#endif  // CC_PolicyPCR
#if CC_PolicyLocality
case TPM_CC_PolicyLocality:
{
    PolicyLocality_In* in =
        (PolicyLocality_In*)MemoryGetInBuffer(sizeof(PolicyLocality_In));
    in->policySession = handles[0];
    result = TPMA_LOCALITY_Unmarshal(&in->locality, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyLocality_locality);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyLocality(in);
    break;
}
#endif  // CC_PolicyLocality
#if CC_PolicyNV
case TPM_CC_PolicyNV:
{
    PolicyNV_In* in   = (PolicyNV_In*)MemoryGetInBuffer(sizeof(PolicyNV_In));
    in->authHandle    = handles[0];
    in->nvIndex       = handles[1];
    in->policySession = handles[2];
    result = TPM2B_OPERAND_Unmarshal(&in->operandB, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyNV_operandB);
    result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyNV_offset);
    result = TPM_EO_Unmarshal(&in->operation, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyNV_operation);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyNV(in);
    break;
}
#endif  // CC_PolicyNV
#if CC_PolicyCounterTimer
case TPM_CC_PolicyCounterTimer:
{
    PolicyCounterTimer_In* in =
        (PolicyCounterTimer_In*)MemoryGetInBuffer(sizeof(PolicyCounterTimer_In));
    in->policySession = handles[0];
    result = TPM2B_OPERAND_Unmarshal(&in->operandB, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyCounterTimer_operandB);
    result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyCounterTimer_offset);
    result = TPM_EO_Unmarshal(&in->operation, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyCounterTimer_operation);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyCounterTimer(in);
    break;
}
#endif  // CC_PolicyCounterTimer
#if CC_PolicyCommandCode
case TPM_CC_PolicyCommandCode:
{
    PolicyCommandCode_In* in =
        (PolicyCommandCode_In*)MemoryGetInBuffer(sizeof(PolicyCommandCode_In));
    in->policySession = handles[0];
    result            = TPM_CC_Unmarshal(&in->code, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyCommandCode_code);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyCommandCode(in);
    break;
}
#endif  // CC_PolicyCommandCode
#if CC_PolicyPhysicalPresence
case TPM_CC_PolicyPhysicalPresence:
{
    PolicyPhysicalPresence_In* in = (PolicyPhysicalPresence_In*)MemoryGetInBuffer(
        sizeof(PolicyPhysicalPresence_In));
    in->policySession = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyPhysicalPresence(in);
    break;
}
#endif  // CC_PolicyPhysicalPresence
#if CC_PolicyCpHash
case TPM_CC_PolicyCpHash:
{
    PolicyCpHash_In* in =
        (PolicyCpHash_In*)MemoryGetInBuffer(sizeof(PolicyCpHash_In));
    in->policySession = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->cpHashA, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyCpHash_cpHashA);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyCpHash(in);
    break;
}
#endif  // CC_PolicyCpHash
#if CC_PolicyNameHash
case TPM_CC_PolicyNameHash:
{
    PolicyNameHash_In* in =
        (PolicyNameHash_In*)MemoryGetInBuffer(sizeof(PolicyNameHash_In));
    in->policySession = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->nameHash, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyNameHash_nameHash);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyNameHash(in);
    break;
}
#endif  // CC_PolicyNameHash
#if CC_PolicyDuplicationSelect
case TPM_CC_PolicyDuplicationSelect:
{
    PolicyDuplicationSelect_In* in = (PolicyDuplicationSelect_In*)MemoryGetInBuffer(
        sizeof(PolicyDuplicationSelect_In));
    in->policySession = handles[0];
    result = TPM2B_NAME_Unmarshal(&in->objectName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyDuplicationSelect_objectName);
    result = TPM2B_NAME_Unmarshal(&in->newParentName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyDuplicationSelect_newParentName);
    result = TPMI_YES_NO_Unmarshal(&in->includeObject, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyDuplicationSelect_includeObject);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyDuplicationSelect(in);
    break;
}
#endif  // CC_PolicyDuplicationSelect
#if CC_PolicyAuthorize
case TPM_CC_PolicyAuthorize:
{
    PolicyAuthorize_In* in =
        (PolicyAuthorize_In*)MemoryGetInBuffer(sizeof(PolicyAuthorize_In));
    in->policySession = handles[0];
    result =
        TPM2B_DIGEST_Unmarshal(&in->approvedPolicy, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_approvedPolicy);
    result = TPM2B_NONCE_Unmarshal(&in->policyRef, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_policyRef);
    result = TPM2B_NAME_Unmarshal(&in->keySign, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_keySign);
    result =
        TPMT_TK_VERIFIED_Unmarshal(&in->checkTicket, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyAuthorize_checkTicket);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyAuthorize(in);
    break;
}
#endif  // CC_PolicyAuthorize
#if CC_PolicyAuthValue
case TPM_CC_PolicyAuthValue:
{
    PolicyAuthValue_In* in =
        (PolicyAuthValue_In*)MemoryGetInBuffer(sizeof(PolicyAuthValue_In));
    in->policySession = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyAuthValue(in);
    break;
}
#endif  // CC_PolicyAuthValue
#if CC_PolicyPassword
case TPM_CC_PolicyPassword:
{
    PolicyPassword_In* in =
        (PolicyPassword_In*)MemoryGetInBuffer(sizeof(PolicyPassword_In));
    in->policySession = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyPassword(in);
    break;
}
#endif  // CC_PolicyPassword
#if CC_PolicyGetDigest
case TPM_CC_PolicyGetDigest:
{
    PolicyGetDigest_In* in =
        (PolicyGetDigest_In*)MemoryGetInBuffer(sizeof(PolicyGetDigest_In));
    PolicyGetDigest_Out* out =
        (PolicyGetDigest_Out*)MemoryGetOutBuffer(sizeof(PolicyGetDigest_Out));
    in->policySession = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyGetDigest(in, out);
    rSize  = sizeof(PolicyGetDigest_Out);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->policyDigest, responseBuffer, &rSize);
    break;
}
#endif  // CC_PolicyGetDigest
#if CC_PolicyNvWritten
case TPM_CC_PolicyNvWritten:
{
    PolicyNvWritten_In* in =
        (PolicyNvWritten_In*)MemoryGetInBuffer(sizeof(PolicyNvWritten_In));
    in->policySession = handles[0];
    result = TPMI_YES_NO_Unmarshal(&in->writtenSet, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyNvWritten_writtenSet);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyNvWritten(in);
    break;
}
#endif  // CC_PolicyNvWritten
#if CC_PolicyTemplate
case TPM_CC_PolicyTemplate:
{
    PolicyTemplate_In* in =
        (PolicyTemplate_In*)MemoryGetInBuffer(sizeof(PolicyTemplate_In));
    in->policySession = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->templateHash, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PolicyTemplate_templateHash);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyTemplate(in);
    break;
}
#endif  // CC_PolicyTemplate
#if CC_PolicyAuthorizeNV
case TPM_CC_PolicyAuthorizeNV:
{
    PolicyAuthorizeNV_In* in =
        (PolicyAuthorizeNV_In*)MemoryGetInBuffer(sizeof(PolicyAuthorizeNV_In));
    in->authHandle    = handles[0];
    in->nvIndex       = handles[1];
    in->policySession = handles[2];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PolicyAuthorizeNV(in);
    break;
}
#endif  // CC_PolicyAuthorizeNV
#if CC_CreatePrimary
case TPM_CC_CreatePrimary:
{
    CreatePrimary_In* in =
        (CreatePrimary_In*)MemoryGetInBuffer(sizeof(CreatePrimary_In));
    CreatePrimary_Out* out =
        (CreatePrimary_Out*)MemoryGetOutBuffer(sizeof(CreatePrimary_Out));
    in->primaryHandle = handles[0];
    result            = TPM2B_SENSITIVE_CREATE_Unmarshal(
        &in->inSensitive, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CreatePrimary_inSensitive);
    result =
        TPM2B_PUBLIC_Unmarshal(&in->inPublic, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_CreatePrimary_inPublic);
    result = TPM2B_DATA_Unmarshal(&in->outsideInfo, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CreatePrimary_outsideInfo);
    result =
        TPML_PCR_SELECTION_Unmarshal(&in->creationPCR, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_CreatePrimary_creationPCR);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_CreatePrimary(in, out);
    rSize  = sizeof(CreatePrimary_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->objectHandle;
    *respParmSize += TPM2B_PUBLIC_Marshal(&out->outPublic, responseBuffer, &rSize);
    *respParmSize +=
        TPM2B_CREATION_DATA_Marshal(&out->creationData, responseBuffer, &rSize);
    *respParmSize += TPM2B_DIGEST_Marshal(&out->creationHash, responseBuffer, &rSize);
    *respParmSize +=
        TPMT_TK_CREATION_Marshal(&out->creationTicket, responseBuffer, &rSize);
    *respParmSize += TPM2B_NAME_Marshal(&out->name, responseBuffer, &rSize);
    break;
}
#endif  // CC_CreatePrimary
#if CC_HierarchyControl
case TPM_CC_HierarchyControl:
{
    HierarchyControl_In* in =
        (HierarchyControl_In*)MemoryGetInBuffer(sizeof(HierarchyControl_In));
    in->authHandle = handles[0];
    result =
        TPMI_RH_ENABLES_Unmarshal(&in->enable, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_HierarchyControl_enable);
    result = TPMI_YES_NO_Unmarshal(&in->state, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_HierarchyControl_state);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_HierarchyControl(in);
    break;
}
#endif  // CC_HierarchyControl
#if CC_SetPrimaryPolicy
case TPM_CC_SetPrimaryPolicy:
{
    SetPrimaryPolicy_In* in =
        (SetPrimaryPolicy_In*)MemoryGetInBuffer(sizeof(SetPrimaryPolicy_In));
    in->authHandle = handles[0];
    result = TPM2B_DIGEST_Unmarshal(&in->authPolicy, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SetPrimaryPolicy_authPolicy);
    result =
        TPMI_ALG_HASH_Unmarshal(&in->hashAlg, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_SetPrimaryPolicy_hashAlg);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_SetPrimaryPolicy(in);
    break;
}
#endif  // CC_SetPrimaryPolicy
#if CC_ChangePPS
case TPM_CC_ChangePPS:
{
    ChangePPS_In* in = (ChangePPS_In*)MemoryGetInBuffer(sizeof(ChangePPS_In));
    in->authHandle   = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ChangePPS(in);
    break;
}
#endif  // CC_ChangePPS
#if CC_ChangeEPS
case TPM_CC_ChangeEPS:
{
    ChangeEPS_In* in = (ChangeEPS_In*)MemoryGetInBuffer(sizeof(ChangeEPS_In));
    in->authHandle   = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ChangeEPS(in);
    break;
}
#endif  // CC_ChangeEPS
#if CC_Clear
case TPM_CC_Clear:
{
    Clear_In* in   = (Clear_In*)MemoryGetInBuffer(sizeof(Clear_In));
    in->authHandle = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Clear(in);
    break;
}
#endif  // CC_Clear
#if CC_ClearControl
case TPM_CC_ClearControl:
{
    ClearControl_In* in =
        (ClearControl_In*)MemoryGetInBuffer(sizeof(ClearControl_In));
    in->auth = handles[0];
    result   = TPMI_YES_NO_Unmarshal(&in->disable, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ClearControl_disable);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ClearControl(in);
    break;
}
#endif  // CC_ClearControl
#if CC_HierarchyChangeAuth
case TPM_CC_HierarchyChangeAuth:
{
    HierarchyChangeAuth_In* in =
        (HierarchyChangeAuth_In*)MemoryGetInBuffer(sizeof(HierarchyChangeAuth_In));
    in->authHandle = handles[0];
    result         = TPM2B_AUTH_Unmarshal(&in->newAuth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_HierarchyChangeAuth_newAuth);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_HierarchyChangeAuth(in);
    break;
}
#endif  // CC_HierarchyChangeAuth
#if CC_DictionaryAttackLockReset
case TPM_CC_DictionaryAttackLockReset:
{
    DictionaryAttackLockReset_In* in =
        (DictionaryAttackLockReset_In*)MemoryGetInBuffer(
            sizeof(DictionaryAttackLockReset_In));
    in->lockHandle = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_DictionaryAttackLockReset(in);
    break;
}
#endif  // CC_DictionaryAttackLockReset
#if CC_DictionaryAttackParameters
case TPM_CC_DictionaryAttackParameters:
{
    DictionaryAttackParameters_In* in =
        (DictionaryAttackParameters_In*)MemoryGetInBuffer(
            sizeof(DictionaryAttackParameters_In));
    in->lockHandle = handles[0];
    result         = UINT32_Unmarshal(&in->newMaxTries, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_DictionaryAttackParameters_newMaxTries);
    result = UINT32_Unmarshal(&in->newRecoveryTime, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_DictionaryAttackParameters_newRecoveryTime);
    result = UINT32_Unmarshal(&in->lockoutRecovery, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_DictionaryAttackParameters_lockoutRecovery);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_DictionaryAttackParameters(in);
    break;
}
#endif  // CC_DictionaryAttackParameters
#if CC_PP_Commands
case TPM_CC_PP_Commands:
{
    PP_Commands_In* in = (PP_Commands_In*)MemoryGetInBuffer(sizeof(PP_Commands_In));
    in->auth           = handles[0];
    result = TPML_CC_Unmarshal(&in->setList, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PP_Commands_setList);
    result = TPML_CC_Unmarshal(&in->clearList, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_PP_Commands_clearList);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_PP_Commands(in);
    break;
}
#endif  // CC_PP_Commands
#if CC_SetAlgorithmSet
case TPM_CC_SetAlgorithmSet:
{
    SetAlgorithmSet_In* in =
        (SetAlgorithmSet_In*)MemoryGetInBuffer(sizeof(SetAlgorithmSet_In));
    in->authHandle = handles[0];
    result = UINT32_Unmarshal(&in->algorithmSet, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_SetAlgorithmSet_algorithmSet);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_SetAlgorithmSet(in);
    break;
}
#endif  // CC_SetAlgorithmSet
#if CC_FieldUpgradeStart
case TPM_CC_FieldUpgradeStart:
{
    FieldUpgradeStart_In* in =
        (FieldUpgradeStart_In*)MemoryGetInBuffer(sizeof(FieldUpgradeStart_In));
    in->authorization = handles[0];
    in->keyHandle     = handles[1];
    result = TPM2B_DIGEST_Unmarshal(&in->fuDigest, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_FieldUpgradeStart_fuDigest);
    result = TPMT_SIGNATURE_Unmarshal(
        &in->manifestSignature, paramBuffer, paramBufferSize, FALSE);
    EXIT_IF_ERROR_PLUS(RC_FieldUpgradeStart_manifestSignature);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_FieldUpgradeStart(in);
    break;
}
#endif  // CC_FieldUpgradeStart
#if CC_FieldUpgradeData
case TPM_CC_FieldUpgradeData:
{
    FieldUpgradeData_In* in =
        (FieldUpgradeData_In*)MemoryGetInBuffer(sizeof(FieldUpgradeData_In));
    FieldUpgradeData_Out* out =
        (FieldUpgradeData_Out*)MemoryGetOutBuffer(sizeof(FieldUpgradeData_Out));
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->fuData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_FieldUpgradeData_fuData);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_FieldUpgradeData(in, out);
    rSize  = sizeof(FieldUpgradeData_Out);
    *respParmSize += TPMT_HA_Marshal(&out->nextDigest, responseBuffer, &rSize);
    *respParmSize += TPMT_HA_Marshal(&out->firstDigest, responseBuffer, &rSize);
    break;
}
#endif  // CC_FieldUpgradeData
#if CC_FirmwareRead
case TPM_CC_FirmwareRead:
{
    FirmwareRead_In* in =
        (FirmwareRead_In*)MemoryGetInBuffer(sizeof(FirmwareRead_In));
    FirmwareRead_Out* out =
        (FirmwareRead_Out*)MemoryGetOutBuffer(sizeof(FirmwareRead_Out));
    result = UINT32_Unmarshal(&in->sequenceNumber, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_FirmwareRead_sequenceNumber);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_FirmwareRead(in, out);
    rSize  = sizeof(FirmwareRead_Out);
    *respParmSize += TPM2B_MAX_BUFFER_Marshal(&out->fuData, responseBuffer, &rSize);
    break;
}
#endif  // CC_FirmwareRead
#if CC_ContextSave
case TPM_CC_ContextSave:
{
    ContextSave_In*  in = (ContextSave_In*)MemoryGetInBuffer(sizeof(ContextSave_In));
    ContextSave_Out* out =
        (ContextSave_Out*)MemoryGetOutBuffer(sizeof(ContextSave_Out));
    in->saveHandle = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ContextSave(in, out);
    rSize  = sizeof(ContextSave_Out);
    *respParmSize += TPMS_CONTEXT_Marshal(&out->context, responseBuffer, &rSize);
    break;
}
#endif  // CC_ContextSave
#if CC_ContextLoad
case TPM_CC_ContextLoad:
{
    ContextLoad_In*  in = (ContextLoad_In*)MemoryGetInBuffer(sizeof(ContextLoad_In));
    ContextLoad_Out* out =
        (ContextLoad_Out*)MemoryGetOutBuffer(sizeof(ContextLoad_Out));
    result = TPMS_CONTEXT_Unmarshal(&in->context, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ContextLoad_context);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ContextLoad(in, out);
    rSize  = sizeof(ContextLoad_Out);
    if(TPM_RC_SUCCESS != result)
        goto Exit;
    command->handles[command->handleNum++] = out->loadedHandle;
    break;
}
#endif  // CC_ContextLoad
#if CC_FlushContext
case TPM_CC_FlushContext:
{
    FlushContext_In* in =
        (FlushContext_In*)MemoryGetInBuffer(sizeof(FlushContext_In));
    result =
        TPMI_DH_CONTEXT_Unmarshal(&in->flushHandle, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_FlushContext_flushHandle);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_FlushContext(in);
    break;
}
#endif  // CC_FlushContext
#if CC_EvictControl
case TPM_CC_EvictControl:
{
    EvictControl_In* in =
        (EvictControl_In*)MemoryGetInBuffer(sizeof(EvictControl_In));
    in->auth         = handles[0];
    in->objectHandle = handles[1];
    result           = TPMI_DH_PERSISTENT_Unmarshal(
        &in->persistentHandle, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_EvictControl_persistentHandle);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_EvictControl(in);
    break;
}
#endif  // CC_EvictControl
#if CC_ReadClock
case TPM_CC_ReadClock:
{
    ReadClock_Out* out = (ReadClock_Out*)MemoryGetOutBuffer(sizeof(ReadClock_Out));
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ReadClock(out);
    rSize  = sizeof(ReadClock_Out);
    *respParmSize +=
        TPMS_TIME_INFO_Marshal(&out->currentTime, responseBuffer, &rSize);
    break;
}
#endif  // CC_ReadClock
#if CC_ClockSet
case TPM_CC_ClockSet:
{
    ClockSet_In* in = (ClockSet_In*)MemoryGetInBuffer(sizeof(ClockSet_In));
    in->auth        = handles[0];
    result          = UINT64_Unmarshal(&in->newTime, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ClockSet_newTime);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ClockSet(in);
    break;
}
#endif  // CC_ClockSet
#if CC_ClockRateAdjust
case TPM_CC_ClockRateAdjust:
{
    ClockRateAdjust_In* in =
        (ClockRateAdjust_In*)MemoryGetInBuffer(sizeof(ClockRateAdjust_In));
    in->auth = handles[0];
    result =
        TPM_CLOCK_ADJUST_Unmarshal(&in->rateAdjust, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ClockRateAdjust_rateAdjust);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ClockRateAdjust(in);
    break;
}
#endif  // CC_ClockRateAdjust
#if CC_GetCapability
case TPM_CC_GetCapability:
{
    GetCapability_In* in =
        (GetCapability_In*)MemoryGetInBuffer(sizeof(GetCapability_In));
    GetCapability_Out* out =
        (GetCapability_Out*)MemoryGetOutBuffer(sizeof(GetCapability_Out));
    result = TPM_CAP_Unmarshal(&in->capability, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetCapability_capability);
    result = UINT32_Unmarshal(&in->property, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetCapability_property);
    result = UINT32_Unmarshal(&in->propertyCount, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_GetCapability_propertyCount);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_GetCapability(in, out);
    rSize  = sizeof(GetCapability_Out);
    *respParmSize += TPMI_YES_NO_Marshal(&out->moreData, responseBuffer, &rSize);
    *respParmSize +=
        TPMS_CAPABILITY_DATA_Marshal(&out->capabilityData, responseBuffer, &rSize);
    break;
}
#endif  // CC_GetCapability
#if CC_TestParms
case TPM_CC_TestParms:
{
    TestParms_In* in = (TestParms_In*)MemoryGetInBuffer(sizeof(TestParms_In));
    result =
        TPMT_PUBLIC_PARMS_Unmarshal(&in->parameters, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_TestParms_parameters);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_TestParms(in);
    break;
}
#endif  // CC_TestParms
#if CC_NV_DefineSpace
case TPM_CC_NV_DefineSpace:
{
    NV_DefineSpace_In* in =
        (NV_DefineSpace_In*)MemoryGetInBuffer(sizeof(NV_DefineSpace_In));
    in->authHandle = handles[0];
    result         = TPM2B_AUTH_Unmarshal(&in->auth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_DefineSpace_auth);
    result = TPM2B_NV_PUBLIC_Unmarshal(&in->publicInfo, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_DefineSpace_publicInfo);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_DefineSpace(in);
    break;
}
#endif  // CC_NV_DefineSpace
#if CC_NV_UndefineSpace
case TPM_CC_NV_UndefineSpace:
{
    NV_UndefineSpace_In* in =
        (NV_UndefineSpace_In*)MemoryGetInBuffer(sizeof(NV_UndefineSpace_In));
    in->authHandle = handles[0];
    in->nvIndex    = handles[1];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_UndefineSpace(in);
    break;
}
#endif  // CC_NV_UndefineSpace
#if CC_NV_UndefineSpaceSpecial
case TPM_CC_NV_UndefineSpaceSpecial:
{
    NV_UndefineSpaceSpecial_In* in = (NV_UndefineSpaceSpecial_In*)MemoryGetInBuffer(
        sizeof(NV_UndefineSpaceSpecial_In));
    in->nvIndex  = handles[0];
    in->platform = handles[1];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_UndefineSpaceSpecial(in);
    break;
}
#endif  // CC_NV_UndefineSpaceSpecial
#if CC_NV_ReadPublic
case TPM_CC_NV_ReadPublic:
{
    NV_ReadPublic_In* in =
        (NV_ReadPublic_In*)MemoryGetInBuffer(sizeof(NV_ReadPublic_In));
    NV_ReadPublic_Out* out =
        (NV_ReadPublic_Out*)MemoryGetOutBuffer(sizeof(NV_ReadPublic_Out));
    in->nvIndex = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_ReadPublic(in, out);
    rSize  = sizeof(NV_ReadPublic_Out);
    *respParmSize += TPM2B_NV_PUBLIC_Marshal(&out->nvPublic, responseBuffer, &rSize);
    *respParmSize += TPM2B_NAME_Marshal(&out->nvName, responseBuffer, &rSize);
    break;
}
#endif  // CC_NV_ReadPublic
#if CC_NV_Write
case TPM_CC_NV_Write:
{
    NV_Write_In* in = (NV_Write_In*)MemoryGetInBuffer(sizeof(NV_Write_In));
    in->authHandle  = handles[0];
    in->nvIndex     = handles[1];
    result = TPM2B_MAX_NV_BUFFER_Unmarshal(&in->data, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Write_data);
    result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Write_offset);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_Write(in);
    break;
}
#endif  // CC_NV_Write
#if CC_NV_Increment
case TPM_CC_NV_Increment:
{
    NV_Increment_In* in =
        (NV_Increment_In*)MemoryGetInBuffer(sizeof(NV_Increment_In));
    in->authHandle = handles[0];
    in->nvIndex    = handles[1];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_Increment(in);
    break;
}
#endif  // CC_NV_Increment
#if CC_NV_Extend
case TPM_CC_NV_Extend:
{
    NV_Extend_In* in = (NV_Extend_In*)MemoryGetInBuffer(sizeof(NV_Extend_In));
    in->authHandle   = handles[0];
    in->nvIndex      = handles[1];
    result = TPM2B_MAX_NV_BUFFER_Unmarshal(&in->data, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Extend_data);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_Extend(in);
    break;
}
#endif  // CC_NV_Extend
#if CC_NV_SetBits
case TPM_CC_NV_SetBits:
{
    NV_SetBits_In* in = (NV_SetBits_In*)MemoryGetInBuffer(sizeof(NV_SetBits_In));
    in->authHandle    = handles[0];
    in->nvIndex       = handles[1];
    result            = UINT64_Unmarshal(&in->bits, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_SetBits_bits);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_SetBits(in);
    break;
}
#endif  // CC_NV_SetBits
#if CC_NV_WriteLock
case TPM_CC_NV_WriteLock:
{
    NV_WriteLock_In* in =
        (NV_WriteLock_In*)MemoryGetInBuffer(sizeof(NV_WriteLock_In));
    in->authHandle = handles[0];
    in->nvIndex    = handles[1];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_WriteLock(in);
    break;
}
#endif  // CC_NV_WriteLock
#if CC_NV_GlobalWriteLock
case TPM_CC_NV_GlobalWriteLock:
{
    NV_GlobalWriteLock_In* in =
        (NV_GlobalWriteLock_In*)MemoryGetInBuffer(sizeof(NV_GlobalWriteLock_In));
    in->authHandle = handles[0];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_GlobalWriteLock(in);
    break;
}
#endif  // CC_NV_GlobalWriteLock
#if CC_NV_Read
case TPM_CC_NV_Read:
{
    NV_Read_In*  in  = (NV_Read_In*)MemoryGetInBuffer(sizeof(NV_Read_In));
    NV_Read_Out* out = (NV_Read_Out*)MemoryGetOutBuffer(sizeof(NV_Read_Out));
    in->authHandle   = handles[0];
    in->nvIndex      = handles[1];
    result           = UINT16_Unmarshal(&in->size, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Read_size);
    result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Read_offset);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_Read(in, out);
    rSize  = sizeof(NV_Read_Out);
    *respParmSize += TPM2B_MAX_NV_BUFFER_Marshal(&out->data, responseBuffer, &rSize);
    break;
}
#endif  // CC_NV_Read
#if CC_NV_ReadLock
case TPM_CC_NV_ReadLock:
{
    NV_ReadLock_In* in = (NV_ReadLock_In*)MemoryGetInBuffer(sizeof(NV_ReadLock_In));
    in->authHandle     = handles[0];
    in->nvIndex        = handles[1];
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_ReadLock(in);
    break;
}
#endif  // CC_NV_ReadLock
#if CC_NV_ChangeAuth
case TPM_CC_NV_ChangeAuth:
{
    NV_ChangeAuth_In* in =
        (NV_ChangeAuth_In*)MemoryGetInBuffer(sizeof(NV_ChangeAuth_In));
    in->nvIndex = handles[0];
    result      = TPM2B_AUTH_Unmarshal(&in->newAuth, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_ChangeAuth_newAuth);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_ChangeAuth(in);
    break;
}
#endif  // CC_NV_ChangeAuth
#if CC_NV_Certify
case TPM_CC_NV_Certify:
{
    NV_Certify_In*  in  = (NV_Certify_In*)MemoryGetInBuffer(sizeof(NV_Certify_In));
    NV_Certify_Out* out = (NV_Certify_Out*)MemoryGetOutBuffer(sizeof(NV_Certify_Out));
    in->signHandle      = handles[0];
    in->authHandle      = handles[1];
    in->nvIndex         = handles[2];
    result = TPM2B_DATA_Unmarshal(&in->qualifyingData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Certify_qualifyingData);
    result =
        TPMT_SIG_SCHEME_Unmarshal(&in->inScheme, paramBuffer, paramBufferSize, TRUE);
    EXIT_IF_ERROR_PLUS(RC_NV_Certify_inScheme);
    result = UINT16_Unmarshal(&in->size, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Certify_size);
    result = UINT16_Unmarshal(&in->offset, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_NV_Certify_offset);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_NV_Certify(in, out);
    rSize  = sizeof(NV_Certify_Out);
    *respParmSize += TPM2B_ATTEST_Marshal(&out->certifyInfo, responseBuffer, &rSize);
    *respParmSize += TPMT_SIGNATURE_Marshal(&out->signature, responseBuffer, &rSize);
    break;
}
#endif  // CC_NV_Certify
#if CC_AC_GetCapability
case TPM_CC_AC_GetCapability:
{
    AC_GetCapability_In* in =
        (AC_GetCapability_In*)MemoryGetInBuffer(sizeof(AC_GetCapability_In));
    AC_GetCapability_Out* out =
        (AC_GetCapability_Out*)MemoryGetOutBuffer(sizeof(AC_GetCapability_Out));
    in->ac = handles[0];
    result = TPM_AT_Unmarshal(&in->capability, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_AC_GetCapability_capability);
    result = UINT32_Unmarshal(&in->count, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_AC_GetCapability_count);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_AC_GetCapability(in, out);
    rSize  = sizeof(AC_GetCapability_Out);
    *respParmSize += TPMI_YES_NO_Marshal(&out->moreData, responseBuffer, &rSize);
    *respParmSize +=
        TPML_AC_CAPABILITIES_Marshal(&out->capabilitiesData, responseBuffer, &rSize);
    break;
}
#endif  // CC_AC_GetCapability
#if CC_AC_Send
case TPM_CC_AC_Send:
{
    AC_Send_In*  in  = (AC_Send_In*)MemoryGetInBuffer(sizeof(AC_Send_In));
    AC_Send_Out* out = (AC_Send_Out*)MemoryGetOutBuffer(sizeof(AC_Send_Out));
    in->sendObject   = handles[0];
    in->authHandle   = handles[1];
    in->ac           = handles[2];
    result = TPM2B_MAX_BUFFER_Unmarshal(&in->acDataIn, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_AC_Send_acDataIn);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_AC_Send(in, out);
    rSize  = sizeof(AC_Send_Out);
    *respParmSize += TPMS_AC_OUTPUT_Marshal(&out->acDataOut, responseBuffer, &rSize);
    break;
}
#endif  // CC_AC_Send
#if CC_Policy_AC_SendSelect
case TPM_CC_Policy_AC_SendSelect:
{
    Policy_AC_SendSelect_In* in =
        (Policy_AC_SendSelect_In*)MemoryGetInBuffer(sizeof(Policy_AC_SendSelect_In));
    in->policySession = handles[0];
    result = TPM2B_NAME_Unmarshal(&in->objectName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_objectName);
    result = TPM2B_NAME_Unmarshal(&in->authHandleName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_authHandleName);
    result = TPM2B_NAME_Unmarshal(&in->acName, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_acName);
    result = TPMI_YES_NO_Unmarshal(&in->includeObject, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Policy_AC_SendSelect_includeObject);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Policy_AC_SendSelect(in);
    break;
}
#endif  // CC_Policy_AC_SendSelect
#if CC_ACT_SetTimeout
case TPM_CC_ACT_SetTimeout:
{
    ACT_SetTimeout_In* in =
        (ACT_SetTimeout_In*)MemoryGetInBuffer(sizeof(ACT_SetTimeout_In));
    in->actHandle = handles[0];
    result        = UINT32_Unmarshal(&in->startTimeout, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_ACT_SetTimeout_startTimeout);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_ACT_SetTimeout(in);
    break;
}
#endif  // CC_ACT_SetTimeout
#if CC_Vendor_TCG_Test
case TPM_CC_Vendor_TCG_Test:
{
    Vendor_TCG_Test_In* in =
        (Vendor_TCG_Test_In*)MemoryGetInBuffer(sizeof(Vendor_TCG_Test_In));
    Vendor_TCG_Test_Out* out =
        (Vendor_TCG_Test_Out*)MemoryGetOutBuffer(sizeof(Vendor_TCG_Test_Out));
    result = TPM2B_DATA_Unmarshal(&in->inputData, paramBuffer, paramBufferSize);
    EXIT_IF_ERROR_PLUS(RC_Vendor_TCG_Test_inputData);
    if(*paramBufferSize != 0)
    {
        result = TPM_RC_SIZE;
        goto Exit;
    }
    result = TPM2_Vendor_TCG_Test(in, out);
    rSize  = sizeof(Vendor_TCG_Test_Out);
    *respParmSize += TPM2B_DATA_Marshal(&out->outputData, responseBuffer, &rSize);
    break;
}
#endif  // CC_Vendor_TCG_Test
