diff options
Diffstat (limited to 'src/tspi/rpc/tcs_api.c')
| -rw-r--r-- | src/tspi/rpc/tcs_api.c | 3377 |
1 files changed, 3377 insertions, 0 deletions
diff --git a/src/tspi/rpc/tcs_api.c b/src/tspi/rpc/tcs_api.c new file mode 100644 index 0000000..3eeb1fb --- /dev/null +++ b/src/tspi/rpc/tcs_api.c @@ -0,0 +1,3377 @@ + +/* + * Licensed Materials - Property of IBM + * + * trousers - An open source TCG Software Stack + * + * (C) Copyright International Business Machines Corp. 2004, 2007 + * + */ + + +#include <stdlib.h> +#include <syslog.h> +#include <unistd.h> + +#include "trousers/tss.h" +#include "trousers_types.h" +#include "trousers_types.h" +#include "spi_utils.h" +#include "hosttable.h" +#include "tsplog.h" +#include "rpc_tcstp_tsp.h" +#include "obj_context.h" + + +TSS_RESULT +RPC_Error(TSS_HCONTEXT tspContext, ...) +{ + LogDebugFn("Context: 0x%x", tspContext); + return TSPERR(TSS_E_INTERNAL_ERROR); +} + +TSS_RESULT +RPC_OpenContext(TSS_HCONTEXT tspContext, BYTE *hostname, int type) +{ + TSS_RESULT result; + TCS_CONTEXT_HANDLE tcsContext; + struct host_table_entry *entry; + UINT32 tpm_version; + + /* __tspi_add_table_entry() will make sure an entry doesn't already exist for this tsp context */ + if ((result = __tspi_add_table_entry(tspContext, hostname, type, &entry))) + return result; + + switch (type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + if ((result = RPC_OpenContext_TP(entry, &tpm_version, &tcsContext))) + remove_table_entry(tspContext); + else { + entry->tcsContext = tcsContext; + if (obj_context_set_tpm_version(tspContext, tpm_version)) { + remove_table_entry(tspContext); + result = TSPERR(TSS_E_INTERNAL_ERROR); + } + } + return result; + default: + break; + } + + return TSPERR(TSS_E_INTERNAL_ERROR); +} + +TSS_RESULT RPC_GetRegisteredKeyByPublicInfo(TSS_HCONTEXT tspContext, + TCPA_ALGORITHM_ID algID, /* in */ + UINT32 ulPublicInfoLength, /* in */ + BYTE * rgbPublicInfo, /* in */ + UINT32 * keySize, BYTE ** keyBlob) +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetRegisteredKeyByPublicInfo_TP(entry, algID, + ulPublicInfoLength, + rgbPublicInfo, keySize, + keyBlob); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CloseContext(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + if ((result = RPC_CloseContext_TP(entry)) == TSS_SUCCESS) { + close(entry->socket); + remove_table_entry(tspContext); + } + break; + default: + break; + } + + if (result != TSS_SUCCESS) + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_FreeMemory(TSS_HCONTEXT tspContext, /* in */ + BYTE * pMemory) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_FreeMemory_TP(entry, pMemory); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_LogPcrEvent(TSS_HCONTEXT tspContext, /* in */ + TSS_PCR_EVENT Event, /* in */ + UINT32 * pNumber) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_LogPcrEvent_TP(entry, Event, pNumber); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetPcrEvent(TSS_HCONTEXT tspContext, /* in */ + UINT32 PcrIndex, /* in */ + UINT32 * pNumber, /* in, out */ + TSS_PCR_EVENT ** ppEvent) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = + RPC_GetPcrEvent_TP(entry, PcrIndex, pNumber, ppEvent); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetPcrEventsByPcr(TSS_HCONTEXT tspContext, /* in */ + UINT32 PcrIndex, /* in */ + UINT32 FirstEvent, /* in */ + UINT32 * pEventCount, /* in,out */ + TSS_PCR_EVENT ** ppEvents) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetPcrEventsByPcr_TP(entry, PcrIndex, FirstEvent, + pEventCount, ppEvents); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetPcrEventLog(TSS_HCONTEXT tspContext, /* in */ + UINT32 * pEventCount, /* out */ + TSS_PCR_EVENT ** ppEvents) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetPcrEventLog_TP(entry, pEventCount, ppEvents); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_RegisterKey(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID WrappingKeyUUID, /* in */ + TSS_UUID KeyUUID, /* in */ + UINT32 cKeySize, /* in */ + BYTE * rgbKey, /* in */ + UINT32 cVendorData, /* in */ + BYTE * gbVendorData) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_RegisterKey_TP(entry, WrappingKeyUUID, KeyUUID, cKeySize, + rgbKey, cVendorData, gbVendorData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_UnregisterKey(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID KeyUUID) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_UnregisterKey_TP(entry, KeyUUID); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_EnumRegisteredKeys(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID * pKeyUUID, /* in */ + UINT32 * pcKeyHierarchySize, /* out */ + TSS_KM_KEYINFO ** ppKeyHierarchy) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_EnumRegisteredKeys_TP(entry, pKeyUUID, pcKeyHierarchySize, + ppKeyHierarchy); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_EnumRegisteredKeys2(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID * pKeyUUID, /* in */ + UINT32 * pcKeyHierarchySize, /* out */ + TSS_KM_KEYINFO2 ** ppKeyHierarchy) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_EnumRegisteredKeys2_TP(entry, pKeyUUID, pcKeyHierarchySize, + ppKeyHierarchy); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + + +TSS_RESULT RPC_GetRegisteredKey(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID KeyUUID, /* in */ + TSS_KM_KEYINFO ** ppKeyInfo) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetRegisteredKey_TP(entry, KeyUUID, ppKeyInfo); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetRegisteredKeyBlob(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID KeyUUID, /* in */ + UINT32 * pcKeySize, /* out */ + BYTE ** prgbKey) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetRegisteredKeyBlob_TP(entry, KeyUUID, pcKeySize, prgbKey); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_LoadKeyByBlob(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE hUnwrappingKey, /* in */ + UINT32 cWrappedKeyBlobSize, /* in */ + BYTE * rgbWrappedKeyBlob, /* in */ + TPM_AUTH * pAuth, /* in, out */ + TCS_KEY_HANDLE * phKeyTCSI, /* out */ + TCS_KEY_HANDLE * phKeyHMAC) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_LoadKeyByBlob_TP(entry, hUnwrappingKey, cWrappedKeyBlobSize, + rgbWrappedKeyBlob, pAuth, phKeyTCSI, + phKeyHMAC); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_LoadKeyByUUID(TSS_HCONTEXT tspContext, /* in */ + TSS_UUID KeyUUID, /* in */ + TCS_LOADKEY_INFO * pLoadKeyInfo, /* in, out */ + TCS_KEY_HANDLE * phKeyTCSI) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_LoadKeyByUUID_TP(entry, KeyUUID, pLoadKeyInfo, phKeyTCSI); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_EvictKey(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE hKey) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_EvictKey_TP(entry, hKey); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CreateWrapKey(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE hWrappingKey, /* in */ + TCPA_ENCAUTH *KeyUsageAuth, /* in */ + TCPA_ENCAUTH *KeyMigrationAuth, /* in */ + UINT32 keyInfoSize, /* in */ + BYTE * keyInfo, /* in */ + UINT32 * keyDataSize, /* out */ + BYTE ** keyData, /* out */ + TPM_AUTH * pAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CreateWrapKey_TP(entry, hWrappingKey, KeyUsageAuth, + KeyMigrationAuth, keyInfoSize, keyInfo, + keyDataSize, keyData, pAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetPubKey(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE hKey, /* in */ + TPM_AUTH * pAuth, /* in, out */ + UINT32 * pcPubKeySize, /* out */ + BYTE ** prgbPubKey) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetPubKey_TP(entry, hKey, pAuth, pcPubKeySize, prgbPubKey); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_MakeIdentity(TSS_HCONTEXT tspContext, /* in */ + TCPA_ENCAUTH identityAuth, /* in */ + TCPA_CHOSENID_HASH IDLabel_PrivCAHash, /* in */ + UINT32 idKeyInfoSize, /* in */ + BYTE * idKeyInfo, /* in */ + TPM_AUTH * pSrkAuth, /* in, out */ + TPM_AUTH * pOwnerAuth, /* in, out */ + UINT32 * idKeySize, /* out */ + BYTE ** idKey, /* out */ + UINT32 * pcIdentityBindingSize, /* out */ + BYTE ** prgbIdentityBinding, /* out */ + UINT32 * pcEndorsementCredentialSize, /* out */ + BYTE ** prgbEndorsementCredential, /* out */ + UINT32 * pcPlatformCredentialSize, /* out */ + BYTE ** prgbPlatformCredential, /* out */ + UINT32 * pcConformanceCredentialSize, /* out */ + BYTE ** prgbConformanceCredential) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_MakeIdentity_TP(entry, identityAuth, + IDLabel_PrivCAHash, idKeyInfoSize, idKeyInfo, + pSrkAuth, pOwnerAuth, idKeySize, idKey, + pcIdentityBindingSize, prgbIdentityBinding, + pcEndorsementCredentialSize, + prgbEndorsementCredential, + pcPlatformCredentialSize, + prgbPlatformCredential, + pcConformanceCredentialSize, + prgbConformanceCredential); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT RPC_GetCredential(TSS_HCONTEXT tspContext, /* in */ + UINT32 ulCredentialType, /* in */ + UINT32 ulCredentialAccessMode, /* in */ + UINT32 * pulCredentialSize, /* out */ + BYTE ** prgbCredentialData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetCredential_TP(entry, ulCredentialType, + ulCredentialAccessMode, pulCredentialSize, + prgbCredentialData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +TSS_RESULT RPC_SetOwnerInstall(TSS_HCONTEXT tspContext, /* in */ + TSS_BOOL state) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SetOwnerInstall_TP(entry, state); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_TakeOwnership(TSS_HCONTEXT tspContext, /* in */ + UINT16 protocolID, /* in */ + UINT32 encOwnerAuthSize, /* in */ + BYTE * encOwnerAuth, /* in */ + UINT32 encSrkAuthSize, /* in */ + BYTE * encSrkAuth, /* in */ + UINT32 srkInfoSize, /* in */ + BYTE * srkInfo, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * srkKeySize, + BYTE ** srkKey) +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_TakeOwnership_TP(entry, protocolID, + encOwnerAuthSize, encOwnerAuth, + encSrkAuthSize, encSrkAuth, srkInfoSize, + srkInfo, ownerAuth, srkKeySize, srkKey); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_OIAP(TSS_HCONTEXT tspContext, /* in */ + TCS_AUTHHANDLE * authHandle, /* out */ + TCPA_NONCE * nonce0) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_OIAP_TP(entry, authHandle, nonce0); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_OSAP(TSS_HCONTEXT tspContext, /* in */ + TCPA_ENTITY_TYPE entityType, /* in */ + UINT32 entityValue, /* in */ + TPM_NONCE *nonceOddOSAP, /* in */ + TCS_AUTHHANDLE * authHandle, /* out */ + TCPA_NONCE * nonceEven, /* out */ + TCPA_NONCE * nonceEvenOSAP) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_OSAP_TP(entry, entityType, entityValue, nonceOddOSAP, + authHandle, nonceEven, nonceEvenOSAP); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ChangeAuth(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE parentHandle, /* in */ + TCPA_PROTOCOL_ID protocolID, /* in */ + TCPA_ENCAUTH *newAuth, /* in */ + TCPA_ENTITY_TYPE entityType, /* in */ + UINT32 encDataSize, /* in */ + BYTE * encData, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + TPM_AUTH * entityAuth, /* in, out */ + UINT32 * outDataSize, /* out */ + BYTE ** outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ChangeAuth_TP(entry, parentHandle, protocolID, newAuth, + entityType, encDataSize, encData, ownerAuth, + entityAuth, outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ChangeAuthOwner(TSS_HCONTEXT tspContext, /* in */ + TCPA_PROTOCOL_ID protocolID, /* in */ + TCPA_ENCAUTH *newAuth, /* in */ + TCPA_ENTITY_TYPE entityType, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ChangeAuthOwner_TP(entry, protocolID, newAuth, entityType, + ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ChangeAuthAsymStart(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE idHandle, /* in */ + TCPA_NONCE antiReplay, /* in */ + UINT32 KeySizeIn, /* in */ + BYTE * KeyDataIn, /* in */ + TPM_AUTH * pAuth, /* in, out */ + UINT32 * KeySizeOut, /* out */ + BYTE ** KeyDataOut, /* out */ + UINT32 * CertifyInfoSize, /* out */ + BYTE ** CertifyInfo, /* out */ + UINT32 * sigSize, /* out */ + BYTE ** sig, /* out */ + TCS_KEY_HANDLE * ephHandle) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ChangeAuthAsymStart_TP(entry, idHandle, antiReplay, + KeySizeIn, KeyDataIn, pAuth, + KeySizeOut, KeyDataOut, + CertifyInfoSize, CertifyInfo, sigSize, + sig, ephHandle); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ChangeAuthAsymFinish(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE parentHandle, /* in */ + TCS_KEY_HANDLE ephHandle, /* in */ + TCPA_ENTITY_TYPE entityType, /* in */ + TCPA_HMAC newAuthLink, /* in */ + UINT32 newAuthSize, /* in */ + BYTE * encNewAuth, /* in */ + UINT32 encDataSizeIn, /* in */ + BYTE * encDataIn, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * encDataSizeOut, /* out */ + BYTE ** encDataOut, /* out */ + TCPA_SALT_NONCE * saltNonce, /* out */ + TCPA_DIGEST * changeProof) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ChangeAuthAsymFinish_TP(entry, parentHandle, ephHandle, + entityType, newAuthLink, + newAuthSize, encNewAuth, + encDataSizeIn, encDataIn, ownerAuth, + encDataSizeOut, encDataOut, saltNonce, + changeProof); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_TerminateHandle(TSS_HCONTEXT tspContext, /* in */ + TCS_AUTHHANDLE handle) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_TerminateHandle_TP(entry, handle); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ActivateTPMIdentity(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE idKey, /* in */ + UINT32 blobSize, /* in */ + BYTE * blob, /* in */ + TPM_AUTH * idKeyAuth, /* in, out */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * SymmetricKeySize, /* out */ + BYTE ** SymmetricKey) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ActivateTPMIdentity_TP(entry, idKey, blobSize, blob, idKeyAuth, + ownerAuth, SymmetricKeySize, + SymmetricKey); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_Extend(TSS_HCONTEXT tspContext, /* in */ + TCPA_PCRINDEX pcrNum, /* in */ + TCPA_DIGEST inDigest, /* in */ + TCPA_PCRVALUE * outDigest) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Extend_TP(entry, pcrNum, inDigest, outDigest); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_PcrRead(TSS_HCONTEXT tspContext, /* in */ + TCPA_PCRINDEX pcrNum, /* in */ + TCPA_PCRVALUE * outDigest) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_PcrRead_TP(entry, pcrNum, outDigest); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_PcrReset(TSS_HCONTEXT tspContext, /* in */ + UINT32 pcrDataSizeIn, /* in */ + BYTE * pcrDataIn) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_PcrReset_TP(entry, pcrDataSizeIn, pcrDataIn); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + + +TSS_RESULT RPC_Quote(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TCPA_NONCE *antiReplay, /* in */ + UINT32 pcrDataSizeIn, /* in */ + BYTE * pcrDataIn, /* in */ + TPM_AUTH * privAuth, /* in, out */ + UINT32 * pcrDataSizeOut, /* out */ + BYTE ** pcrDataOut, /* out */ + UINT32 * sigSize, /* out */ + BYTE ** sig) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Quote_TP(entry, keyHandle, antiReplay, pcrDataSizeIn, + pcrDataIn, privAuth, pcrDataSizeOut, pcrDataOut, + sigSize, sig); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT RPC_Quote2(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TCPA_NONCE *antiReplay, /* in */ + UINT32 pcrDataSizeIn, /* in */ + BYTE * pcrDataIn, /* in */ + TSS_BOOL addVersion, /* in */ + TPM_AUTH * privAuth, /* in,out */ + UINT32 * pcrDataSizeOut, /* out */ + BYTE ** pcrDataOut, /* out */ + UINT32 * versionInfoSize, /* out */ + BYTE ** versionInfo, /* out */ + UINT32 * sigSize, /* out */ + BYTE ** sig) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Quote2_TP(entry, keyHandle, antiReplay, pcrDataSizeIn, pcrDataIn, + addVersion,privAuth, pcrDataSizeOut, pcrDataOut, + versionInfoSize, versionInfo,sigSize, sig); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +TSS_RESULT RPC_DirWriteAuth(TSS_HCONTEXT tspContext, /* in */ + TCPA_DIRINDEX dirIndex, /* in */ + TCPA_DIRVALUE *newContents, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DirWriteAuth_TP(entry, dirIndex, newContents, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_DirRead(TSS_HCONTEXT tspContext, /* in */ + TCPA_DIRINDEX dirIndex, /* in */ + TCPA_DIRVALUE * dirValue) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DirRead_TP(entry, dirIndex, dirValue); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_Seal(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TCPA_ENCAUTH *encAuth, /* in */ + UINT32 pcrInfoSize, /* in */ + BYTE * PcrInfo, /* in */ + UINT32 inDataSize, /* in */ + BYTE * inData, /* in */ + TPM_AUTH * pubAuth, /* in, out */ + UINT32 * SealedDataSize, /* out */ + BYTE ** SealedData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Seal_TP(entry, keyHandle, encAuth, pcrInfoSize, PcrInfo, + inDataSize, inData, pubAuth, SealedDataSize, + SealedData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_SEALX +TSS_RESULT RPC_Sealx(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TCPA_ENCAUTH *encAuth, /* in */ + UINT32 pcrInfoSize, /* in */ + BYTE * PcrInfo, /* in */ + UINT32 inDataSize, /* in */ + BYTE * inData, /* in */ + TPM_AUTH * pubAuth, /* in, out */ + UINT32 * SealedDataSize, /* out */ + BYTE ** SealedData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Sealx_TP(entry, keyHandle, encAuth, pcrInfoSize, PcrInfo, + inDataSize, inData, pubAuth, SealedDataSize, + SealedData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +TSS_RESULT RPC_Unseal(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE parentHandle, /* in */ + UINT32 SealedDataSize, /* in */ + BYTE * SealedData, /* in */ + TPM_AUTH * parentAuth, /* in, out */ + TPM_AUTH * dataAuth, /* in, out */ + UINT32 * DataSize, /* out */ + BYTE ** Data) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Unseal_TP(entry, parentHandle, SealedDataSize, SealedData, + parentAuth, dataAuth, DataSize, Data); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_UnBind(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + UINT32 inDataSize, /* in */ + BYTE * inData, /* in */ + TPM_AUTH * privAuth, /* in, out */ + UINT32 * outDataSize, /* out */ + BYTE ** outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_UnBind_TP(entry, keyHandle, inDataSize, inData, privAuth, + outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CreateMigrationBlob(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE parentHandle, /* in */ + TCPA_MIGRATE_SCHEME migrationType, /* in */ + UINT32 MigrationKeyAuthSize, /* in */ + BYTE * MigrationKeyAuth, /* in */ + UINT32 encDataSize, /* in */ + BYTE * encData, /* in */ + TPM_AUTH * parentAuth, /* in, out */ + TPM_AUTH * entityAuth, /* in, out */ + UINT32 * randomSize, /* out */ + BYTE ** random, /* out */ + UINT32 * outDataSize, /* out */ + BYTE ** outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CreateMigrationBlob_TP(entry, parentHandle, + migrationType, MigrationKeyAuthSize, + MigrationKeyAuth, encDataSize, encData, + parentAuth, entityAuth, randomSize, + random, outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ConvertMigrationBlob(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE parentHandle, /* in */ + UINT32 inDataSize, /* in */ + BYTE * inData, /* in */ + UINT32 randomSize, /* in */ + BYTE * random, /* in */ + TPM_AUTH * parentAuth, /* in, out */ + UINT32 * outDataSize, /* out */ + BYTE ** outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ConvertMigrationBlob_TP(entry, parentHandle, + inDataSize, inData, randomSize, + random, parentAuth, outDataSize, + outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_AuthorizeMigrationKey(TSS_HCONTEXT tspContext, /* in */ + TCPA_MIGRATE_SCHEME migrateScheme, /* in */ + UINT32 MigrationKeySize, /* in */ + BYTE * MigrationKey, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * MigrationKeyAuthSize, /* out */ + BYTE ** MigrationKeyAuth) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_AuthorizeMigrationKey_TP(entry, migrateScheme, + MigrationKeySize, MigrationKey, + ownerAuth, MigrationKeyAuthSize, + MigrationKeyAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CertifyKey(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE certHandle, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TPM_NONCE * antiReplay, /* in */ + TPM_AUTH * certAuth, /* in, out */ + TPM_AUTH * keyAuth, /* in, out */ + UINT32 * CertifyInfoSize, /* out */ + BYTE ** CertifyInfo, /* out */ + UINT32 * outDataSize, /* out */ + BYTE ** outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CertifyKey_TP(entry, certHandle, keyHandle, antiReplay, + certAuth, keyAuth, CertifyInfoSize, CertifyInfo, + outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_Sign(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + UINT32 areaToSignSize, /* in */ + BYTE * areaToSign, /* in */ + TPM_AUTH * privAuth, /* in, out */ + UINT32 * sigSize, /* out */ + BYTE ** sig) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Sign_TP(entry, keyHandle, areaToSignSize, areaToSign, privAuth, + sigSize, sig); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetRandom(TSS_HCONTEXT tspContext, /* in */ + UINT32 bytesRequested, /* in */ + BYTE ** randomBytes) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetRandom_TP(entry, bytesRequested, randomBytes); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_StirRandom(TSS_HCONTEXT tspContext, /* in */ + UINT32 inDataSize, /* in */ + BYTE * inData) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_StirRandom_TP(entry, inDataSize, inData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetTPMCapability(TSS_HCONTEXT tspContext, /* in */ + TCPA_CAPABILITY_AREA capArea, /* in */ + UINT32 subCapSize, /* in */ + BYTE * subCap, /* in */ + UINT32 * respSize, /* out */ + BYTE ** resp) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetTPMCapability_TP(entry, capArea, subCapSize, subCap, + respSize, resp); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_SetCapability(TSS_HCONTEXT tspContext, /* in */ + TCPA_CAPABILITY_AREA capArea, /* in */ + UINT32 subCapSize, /* in */ + BYTE * subCap, /* in */ + UINT32 valueSize, /* in */ + BYTE * value, /* in */ + TPM_AUTH *ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SetCapability_TP(entry, capArea, subCapSize, subCap, + valueSize, value, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetCapability(TSS_HCONTEXT tspContext, /* in */ + TCPA_CAPABILITY_AREA capArea, /* in */ + UINT32 subCapSize, /* in */ + BYTE * subCap, /* in */ + UINT32 * respSize, /* out */ + BYTE ** resp) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetCapability_TP(entry, capArea, subCapSize, subCap, respSize, + resp); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetCapabilitySigned(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TCPA_NONCE antiReplay, /* in */ + TCPA_CAPABILITY_AREA capArea, /* in */ + UINT32 subCapSize, /* in */ + BYTE * subCap, /* in */ + TPM_AUTH * privAuth, /* in, out */ + TCPA_VERSION * Version, /* out */ + UINT32 * respSize, /* out */ + BYTE ** resp, /* out */ + UINT32 * sigSize, /* out */ + BYTE ** sig) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetCapabilitySigned_TP(entry, keyHandle, antiReplay, capArea, + subCapSize, subCap, privAuth, Version, + respSize, resp, sigSize, sig); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetCapabilityOwner(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * pOwnerAuth, /* out */ + TCPA_VERSION * pVersion, /* out */ + UINT32 * pNonVolatileFlags, /* out */ + UINT32 * pVolatileFlags) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetCapabilityOwner_TP(entry, pOwnerAuth, pVersion, + pNonVolatileFlags, pVolatileFlags); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CreateEndorsementKeyPair(TSS_HCONTEXT tspContext, /* in */ + TCPA_NONCE antiReplay, /* in */ + UINT32 endorsementKeyInfoSize, /* in */ + BYTE * endorsementKeyInfo, /* in */ + UINT32 * endorsementKeySize, /* out */ + BYTE ** endorsementKey, /* out */ + TCPA_DIGEST * checksum) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CreateEndorsementKeyPair_TP(entry, antiReplay, + endorsementKeyInfoSize, + endorsementKeyInfo, + endorsementKeySize, + endorsementKey, checksum); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ReadPubek(TSS_HCONTEXT tspContext, /* in */ + TCPA_NONCE antiReplay, /* in */ + UINT32 * pubEndorsementKeySize, /* out */ + BYTE ** pubEndorsementKey, /* out */ + TCPA_DIGEST * checksum) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReadPubek_TP(entry, antiReplay, pubEndorsementKeySize, + pubEndorsementKey, checksum); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_DisablePubekRead(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DisablePubekRead_TP(entry, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_OwnerReadPubek(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * pubEndorsementKeySize, /* out */ + BYTE ** pubEndorsementKey) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_OwnerReadPubek_TP(entry, ownerAuth, pubEndorsementKeySize, + pubEndorsementKey); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT RPC_CreateRevocableEndorsementKeyPair(TSS_HCONTEXT tspContext, /* in */ + TPM_NONCE antiReplay, /* in */ + UINT32 endorsementKeyInfoSize,/* in */ + BYTE * endorsementKeyInfo, /* in */ + TSS_BOOL genResetAuth, /* in */ + TPM_DIGEST * eKResetAuth, /* in, out */ + UINT32 * endorsementKeySize, /* out */ + BYTE ** endorsementKey, /* out */ + TPM_DIGEST * checksum) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CreateRevocableEndorsementKeyPair_TP(entry, antiReplay, + endorsementKeyInfoSize, + endorsementKeyInfo, + genResetAuth, + eKResetAuth, + endorsementKeySize, + endorsementKey, checksum); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_RevokeEndorsementKeyPair(TSS_HCONTEXT tspContext, /* in */ + TPM_DIGEST *EKResetAuth) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_RevokeEndorsementKeyPair_TP(entry, EKResetAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +TSS_RESULT RPC_SelfTestFull(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SelfTestFull_TP(entry); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CertifySelfTest(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TCPA_NONCE antiReplay, /* in */ + TPM_AUTH * privAuth, /* in, out */ + UINT32 * sigSize, /* out */ + BYTE ** sig) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CertifySelfTest_TP(entry, keyHandle, antiReplay, privAuth, + sigSize, sig); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_GetTestResult(TSS_HCONTEXT tspContext, /* in */ + UINT32 * outDataSize, /* out */ + BYTE ** outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetTestResult_TP(entry, outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_OwnerSetDisable(TSS_HCONTEXT tspContext, /* in */ + TSS_BOOL disableState, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_OwnerSetDisable_TP(entry, disableState, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT RPC_ResetLockValue(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ResetLockValue_TP(entry, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +TSS_RESULT RPC_OwnerClear(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_OwnerClear_TP(entry, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_DisableOwnerClear(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DisableOwnerClear_TP(entry, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ForceClear(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ForceClear_TP(entry); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_DisableForceClear(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DisableForceClear_TP(entry); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_PhysicalDisable(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_PhysicalDisable_TP(entry); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_PhysicalEnable(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_PhysicalEnable_TP(entry); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_PhysicalSetDeactivated(TSS_HCONTEXT tspContext, /* in */ + TSS_BOOL state) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_PhysicalSetDeactivated_TP(entry, state); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_PhysicalPresence(TSS_HCONTEXT tspContext, /* in */ + TCPA_PHYSICAL_PRESENCE fPhysicalPresence) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_PhysicalPresence_TP(entry, fPhysicalPresence); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_SetTempDeactivated(TSS_HCONTEXT tspContext) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SetTempDeactivated_TP(entry); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT RPC_SetTempDeactivated2(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH *operatorAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SetTempDeactivated2_TP(entry, operatorAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +TSS_RESULT RPC_FieldUpgrade(TSS_HCONTEXT tspContext, /* in */ + UINT32 dataInSize, /* in */ + BYTE * dataIn, /* in */ + UINT32 * dataOutSize, /* out */ + BYTE ** dataOut, /* out */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = (UINT32) TSPERR(TSS_E_INTERNAL_ERROR); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_SetRedirection(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + UINT32 c1, /* in */ + UINT32 c2, /* in */ + TPM_AUTH * privAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = (UINT32) TSPERR(TSS_E_INTERNAL_ERROR); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_CreateMaintenanceArchive(TSS_HCONTEXT tspContext, /* in */ + TSS_BOOL generateRandom, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * randomSize, /* out */ + BYTE ** random, /* out */ + UINT32 * archiveSize, /* out */ + BYTE ** archive) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CreateMaintenanceArchive_TP(entry, generateRandom, ownerAuth, + randomSize, random, archiveSize, + archive); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_LoadMaintenanceArchive(TSS_HCONTEXT tspContext, /* in */ + UINT32 dataInSize, /* in */ + BYTE * dataIn, /* in */ + TPM_AUTH * ownerAuth, /* in, out */ + UINT32 * dataOutSize, /* out */ + BYTE ** dataOut) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_LoadMaintenanceArchive_TP(entry, dataInSize, dataIn, ownerAuth, + dataOutSize, dataOut); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_KillMaintenanceFeature(TSS_HCONTEXT tspContext, /* in */ + TPM_AUTH * ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_KillMaintenanceFeature_TP(entry, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_LoadManuMaintPub(TSS_HCONTEXT tspContext, /* in */ + TCPA_NONCE antiReplay, /* in */ + UINT32 PubKeySize, /* in */ + BYTE * PubKey, /* in */ + TCPA_DIGEST * checksum) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_LoadManuMaintPub_TP(entry, antiReplay, PubKeySize, PubKey, + checksum); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT RPC_ReadManuMaintPub(TSS_HCONTEXT tspContext, /* in */ + TCPA_NONCE antiReplay, /* in */ + TCPA_DIGEST * checksum) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReadManuMaintPub_TP(entry, antiReplay, checksum); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#ifdef TSS_BUILD_DAA +TSS_RESULT +RPC_DaaJoin(TSS_HCONTEXT tspContext, /* in */ + TPM_HANDLE daa_session, /* in */ + BYTE stage, /* in */ + UINT32 inputSize0, /* in */ + BYTE* inputData0, /* in */ + UINT32 inputSize1, /* in */ + BYTE* inputData1, /* in */ + TPM_AUTH* ownerAuth, /* in, out */ + UINT32* outputSize, /* out */ + BYTE** outputData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DaaJoin_TP(entry, daa_session, stage, inputSize0, inputData0, + inputSize1, inputData1, ownerAuth, outputSize, + outputData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; + +} + +TSS_RESULT +RPC_DaaSign(TSS_HCONTEXT tspContext, /* in */ + TPM_HANDLE daa_session, /* in */ + BYTE stage, /* in */ + UINT32 inputSize0, /* in */ + BYTE* inputData0, /* in */ + UINT32 inputSize1, /* in */ + BYTE* inputData1, /* in */ + TPM_AUTH* ownerAuth, /* in, out */ + UINT32* outputSize, /* out */ + BYTE** outputData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DaaSign_TP(entry, daa_session, stage, inputSize0, inputData0, + inputSize1, inputData1, ownerAuth, outputSize, + outputData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_COUNTER +TSS_RESULT +RPC_ReadCounter(TSS_HCONTEXT tspContext, /* in */ + TSS_COUNTER_ID idCounter, /* in */ + TPM_COUNTER_VALUE* counterValue) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReadCounter_TP(entry, idCounter, counterValue); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_CreateCounter(TSS_HCONTEXT tspContext, /* in */ + UINT32 LabelSize, /* in (=4) */ + BYTE* pLabel, /* in */ + TPM_ENCAUTH CounterAuth, /* in */ + TPM_AUTH* pOwnerAuth, /* in, out */ + TSS_COUNTER_ID* idCounter, /* out */ + TPM_COUNTER_VALUE* counterValue) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CreateCounter_TP(entry, LabelSize, pLabel, CounterAuth, + pOwnerAuth, idCounter, counterValue); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_IncrementCounter(TSS_HCONTEXT tspContext, /* in */ + TSS_COUNTER_ID idCounter, /* in */ + TPM_AUTH* pCounterAuth, /* in, out */ + TPM_COUNTER_VALUE* counterValue) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_IncrementCounter_TP(entry, idCounter, pCounterAuth, + counterValue); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_ReleaseCounter(TSS_HCONTEXT tspContext, /* in */ + TSS_COUNTER_ID idCounter, /* in */ + TPM_AUTH* pCounterAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReleaseCounter_TP(entry, idCounter, pCounterAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_ReleaseCounterOwner(TSS_HCONTEXT tspContext, /* in */ + TSS_COUNTER_ID idCounter, /* in */ + TPM_AUTH* pOwnerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReleaseCounterOwner_TP(entry, idCounter, pOwnerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_TICK +TSS_RESULT +RPC_ReadCurrentTicks(TSS_HCONTEXT tspContext, /* in */ + UINT32* pulCurrentTime, /* out */ + BYTE** prgbCurrentTime) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReadCurrentTicks_TP(entry, pulCurrentTime, prgbCurrentTime); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_TickStampBlob(TSS_HCONTEXT tspContext, /* in */ + TCS_KEY_HANDLE hKey, /* in */ + TPM_NONCE* antiReplay, /* in */ + TPM_DIGEST* digestToStamp, /* in */ + TPM_AUTH* privAuth, /* in, out */ + UINT32* pulSignatureLength, /* out */ + BYTE** prgbSignature, /* out */ + UINT32* pulTickCountLength, /* out */ + BYTE** prgbTickCount) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_TickStampBlob_TP(entry, hKey, antiReplay, digestToStamp, + privAuth, pulSignatureLength, + prgbSignature, pulTickCountLength, + prgbTickCount); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_TRANSPORT +TSS_RESULT +RPC_EstablishTransport(TSS_HCONTEXT tspContext, + UINT32 ulTransControlFlags, + TCS_KEY_HANDLE hEncKey, + UINT32 ulTransSessionInfoSize, + BYTE* rgbTransSessionInfo, + UINT32 ulSecretSize, + BYTE* rgbSecret, + TPM_AUTH* pEncKeyAuth, /* in, out */ + TPM_MODIFIER_INDICATOR* pbLocality, + TCS_HANDLE* hTransSession, + UINT32* ulCurrentTicksSize, + BYTE** prgbCurrentTicks, + TPM_NONCE* pTransNonce) +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_EstablishTransport_TP(entry, ulTransControlFlags, hEncKey, + ulTransSessionInfoSize, + rgbTransSessionInfo, ulSecretSize, + rgbSecret, pEncKeyAuth, pbLocality, + hTransSession, ulCurrentTicksSize, + prgbCurrentTicks, pTransNonce); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + + +TSS_RESULT +RPC_ExecuteTransport(TSS_HCONTEXT tspContext, + TPM_COMMAND_CODE unWrappedCommandOrdinal, + UINT32 ulWrappedCmdParamInSize, + BYTE* rgbWrappedCmdParamIn, + UINT32* pulHandleListSize, /* in, out */ + TCS_HANDLE** rghHandles, /* in, out */ + TPM_AUTH* pWrappedCmdAuth1, /* in, out */ + TPM_AUTH* pWrappedCmdAuth2, /* in, out */ + TPM_AUTH* pTransAuth, /* in, out */ + UINT64* punCurrentTicks, + TPM_MODIFIER_INDICATOR* pbLocality, + TPM_RESULT* pulWrappedCmdReturnCode, + UINT32* ulWrappedCmdParamOutSize, + BYTE** rgbWrappedCmdParamOut) +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ExecuteTransport_TP(entry, unWrappedCommandOrdinal, + ulWrappedCmdParamInSize, + rgbWrappedCmdParamIn, pulHandleListSize, + rghHandles, pWrappedCmdAuth1, + pWrappedCmdAuth2, pTransAuth, + punCurrentTicks, pbLocality, + pulWrappedCmdReturnCode, + ulWrappedCmdParamOutSize, + rgbWrappedCmdParamOut); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_ReleaseTransportSigned(TSS_HCONTEXT tspContext, + TCS_KEY_HANDLE hSignatureKey, + TPM_NONCE* AntiReplayNonce, + TPM_AUTH* pKeyAuth, /* in, out */ + TPM_AUTH* pTransAuth, /* in, out */ + TPM_MODIFIER_INDICATOR* pbLocality, + UINT32* pulCurrentTicksSize, + BYTE** prgbCurrentTicks, + UINT32* pulSignatureSize, + BYTE** prgbSignature) +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(tspContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_ReleaseTransportSigned_TP(entry, hSignatureKey, + AntiReplayNonce, pKeyAuth, + pTransAuth, pbLocality, + pulCurrentTicksSize, + prgbCurrentTicks, pulSignatureSize, + prgbSignature); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_NV +TSS_RESULT +RPC_NV_DefineOrReleaseSpace(TSS_HCONTEXT hContext, /* in */ + UINT32 cPubInfoSize, /* in */ + BYTE* pPubInfo, /* in */ + TCPA_ENCAUTH encAuth, /* in */ + TPM_AUTH* pAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_NV_DefineOrReleaseSpace_TP(entry, cPubInfoSize, pPubInfo, + encAuth, pAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_NV_WriteValue(TSS_HCONTEXT hContext, /* in */ + TSS_NV_INDEX hNVStore, /* in */ + UINT32 offset, /* in */ + UINT32 ulDataLength, /* in */ + BYTE* rgbDataToWrite, /* in */ + TPM_AUTH* privAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_NV_WriteValue_TP(entry, hNVStore, offset, ulDataLength, + rgbDataToWrite, privAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + + +TSS_RESULT +RPC_NV_WriteValueAuth(TSS_HCONTEXT hContext, /* in */ + TSS_NV_INDEX hNVStore, /* in */ + UINT32 offset, /* in */ + UINT32 ulDataLength, /* in */ + BYTE* rgbDataToWrite, /* in */ + TPM_AUTH* NVAuth) /* in, out */ +{ + + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_NV_WriteValueAuth_TP(entry, hNVStore, offset, ulDataLength, + rgbDataToWrite, NVAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + + +TSS_RESULT +RPC_NV_ReadValue(TSS_HCONTEXT hContext, /* in */ + TSS_NV_INDEX hNVStore, /* in */ + UINT32 offset, /* in */ + UINT32* pulDataLength, /* in, out */ + TPM_AUTH* privAuth, /* in, out */ + BYTE** rgbDataRead) /* out */ +{ + + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_NV_ReadValue_TP(entry, hNVStore, offset, pulDataLength, + privAuth, rgbDataRead); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_NV_ReadValueAuth(TSS_HCONTEXT hContext, /* in */ + TSS_NV_INDEX hNVStore, /* in */ + UINT32 offset, /* in */ + UINT32* pulDataLength, /* in, out */ + TPM_AUTH* NVAuth, /* in, out */ + BYTE** rgbDataRead) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_NV_ReadValueAuth_TP(entry, hNVStore, offset, pulDataLength, + NVAuth, rgbDataRead); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_AUDIT +TSS_RESULT +RPC_SetOrdinalAuditStatus(TSS_HCONTEXT hContext, /* in */ + TPM_AUTH *ownerAuth, /* in/out */ + UINT32 ulOrdinal, /* in */ + TSS_BOOL bAuditState) /* in */ +{ + TSS_RESULT result = TSS_SUCCESS; + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SetOrdinalAuditStatus_TP(entry, ownerAuth, ulOrdinal, + bAuditState); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_GetAuditDigest(TSS_HCONTEXT hContext, /* in */ + UINT32 startOrdinal, /* in */ + TPM_DIGEST *auditDigest, /* out */ + UINT32 *counterValueSize, /* out */ + BYTE **counterValue, /* out */ + TSS_BOOL *more, /* out */ + UINT32 *ordSize, /* out */ + UINT32 **ordList) /* out */ +{ + TSS_RESULT result = TSS_SUCCESS; + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetAuditDigest_TP(entry, startOrdinal, auditDigest, + counterValueSize, counterValue, more, + ordSize, ordList); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_GetAuditDigestSigned(TSS_HCONTEXT hContext, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TSS_BOOL closeAudit, /* in */ + TPM_NONCE *antiReplay, /* in */ + TPM_AUTH *privAuth, /* in/out */ + UINT32 *counterValueSize, /* out */ + BYTE **counterValue, /* out */ + TPM_DIGEST *auditDigest, /* out */ + TPM_DIGEST *ordinalDigest, /* out */ + UINT32 *sigSize, /* out */ + BYTE **sig) /* out */ +{ + TSS_RESULT result = TSS_SUCCESS; + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_GetAuditDigestSigned_TP(entry, keyHandle, closeAudit, + antiReplay, privAuth, + counterValueSize, counterValue, + auditDigest, ordinalDigest, + sigSize, sig); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT +RPC_SetOperatorAuth(TSS_HCONTEXT hContext, /* in */ + TCPA_SECRET *operatorAuth) /* in */ +{ + TSS_RESULT result = TSS_SUCCESS; + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_SetOperatorAuth_TP(entry, operatorAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_OwnerReadInternalPub(TSS_HCONTEXT hContext, /* in */ + TCS_KEY_HANDLE hKey, /* in */ + TPM_AUTH* pOwnerAuth, /* in, out */ + UINT32* punPubKeySize, /* out */ + BYTE** ppbPubKeyData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_OwnerReadInternalPub_TP(entry, hKey, pOwnerAuth, punPubKeySize, + ppbPubKeyData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_DELEGATION +TSS_RESULT +RPC_Delegate_Manage(TSS_HCONTEXT hContext, /* in */ + TPM_FAMILY_ID familyID, /* in */ + TPM_FAMILY_OPERATION opFlag, /* in */ + UINT32 opDataSize, /* in */ + BYTE *opData, /* in */ + TPM_AUTH *ownerAuth, /* in, out */ + UINT32 *retDataSize, /* out */ + BYTE **retData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_Manage_TP(entry, familyID, opFlag, opDataSize, opData, + ownerAuth, retDataSize, retData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_Delegate_CreateKeyDelegation(TSS_HCONTEXT hContext, /* in */ + TCS_KEY_HANDLE hKey, /* in */ + UINT32 publicInfoSize, /* in */ + BYTE *publicInfo, /* in */ + TPM_ENCAUTH *encDelAuth, /* in */ + TPM_AUTH *keyAuth, /* in, out */ + UINT32 *blobSize, /* out */ + BYTE **blob) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_CreateKeyDelegation_TP(entry, hKey, publicInfoSize, + publicInfo, encDelAuth, + keyAuth, blobSize, blob); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_Delegate_CreateOwnerDelegation(TSS_HCONTEXT hContext, /* in */ + TSS_BOOL increment, /* in */ + UINT32 publicInfoSize, /* in */ + BYTE *publicInfo, /* in */ + TPM_ENCAUTH *encDelAuth, /* in */ + TPM_AUTH *ownerAuth, /* in, out */ + UINT32 *blobSize, /* out */ + BYTE **blob) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_CreateOwnerDelegation_TP(entry, increment, + publicInfoSize, publicInfo, + encDelAuth, ownerAuth, + blobSize, blob); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_Delegate_LoadOwnerDelegation(TSS_HCONTEXT hContext, /* in */ + TPM_DELEGATE_INDEX index, /* in */ + UINT32 blobSize, /* in */ + BYTE *blob, /* in */ + TPM_AUTH *ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_LoadOwnerDelegation_TP(entry, index, blobSize, blob, + ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_Delegate_ReadTable(TSS_HCONTEXT hContext, /* in */ + UINT32 *familyTableSize, /* out */ + BYTE **familyTable, /* out */ + UINT32 *delegateTableSize, /* out */ + BYTE **delegateTable) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_ReadTable_TP(entry, familyTableSize, familyTable, + delegateTableSize, delegateTable); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_Delegate_UpdateVerificationCount(TSS_HCONTEXT hContext, /* in */ + UINT32 inputSize, /* in */ + BYTE *input, /* in */ + TPM_AUTH *ownerAuth, /* in, out */ + UINT32 *outputSize, /* out */ + BYTE **output) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_UpdateVerificationCount_TP(entry, inputSize, input, + ownerAuth, outputSize, + output); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_Delegate_VerifyDelegation(TSS_HCONTEXT hContext, /* in */ + UINT32 delegateSize, /* in */ + BYTE *delegate) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_Delegate_VerifyDelegation_TP(entry, delegateSize, delegate); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_DSAP(TSS_HCONTEXT hContext, /* in */ + TPM_ENTITY_TYPE entityType, /* in */ + TCS_KEY_HANDLE keyHandle, /* in */ + TPM_NONCE *nonceOddDSAP, /* in */ + UINT32 entityValueSize, /* in */ + BYTE * entityValue, /* in */ + TCS_AUTHHANDLE *authHandle, /* out */ + TPM_NONCE *nonceEven, /* out */ + TPM_NONCE *nonceEvenDSAP) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_DSAP_TP(entry, entityType, keyHandle, nonceOddDSAP, + entityValueSize, entityValue, authHandle, nonceEven, + nonceEvenDSAP); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +#endif + +#ifdef TSS_BUILD_CMK +TSS_RESULT +RPC_CMK_SetRestrictions(TSS_HCONTEXT hContext, /* in */ + TSS_CMK_DELEGATE restriction, /* in */ + TPM_AUTH *ownerAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CMK_SetRestrictions_TP(entry, restriction, ownerAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_CMK_ApproveMA(TSS_HCONTEXT hContext, /* in */ + TPM_DIGEST migAuthorityDigest, /* in */ + TPM_AUTH *ownerAuth, /* in, out */ + TPM_HMAC *migAuthorityApproval) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CMK_ApproveMA_TP(entry, migAuthorityDigest, ownerAuth, + migAuthorityApproval); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_CMK_CreateKey(TSS_HCONTEXT hContext, /* in */ + TCS_KEY_HANDLE hWrappingKey, /* in */ + TPM_ENCAUTH *keyUsageAuth, /* in */ + TPM_HMAC *migAuthorityApproval, /* in */ + TPM_DIGEST *migAuthorityDigest, /* in */ + UINT32 *keyDataSize, /* in, out */ + BYTE **keyData, /* in, out */ + TPM_AUTH *pAuth) /* in, out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CMK_CreateKey_TP(entry, hWrappingKey, keyUsageAuth, + migAuthorityApproval, migAuthorityDigest, keyDataSize, + keyData, pAuth); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_CMK_CreateTicket(TSS_HCONTEXT hContext, /* in */ + UINT32 publicVerifyKeySize, /* in */ + BYTE *publicVerifyKey, /* in */ + TPM_DIGEST signedData, /* in */ + UINT32 sigValueSize, /* in */ + BYTE *sigValue, /* in */ + TPM_AUTH *ownerAuth, /* in, out */ + TPM_HMAC *sigTicket) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CMK_CreateTicket_TP(entry, publicVerifyKeySize, + publicVerifyKey, signedData, sigValueSize, sigValue, + ownerAuth, sigTicket); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_CMK_CreateBlob(TSS_HCONTEXT hContext, /* in */ + TCS_KEY_HANDLE hParentKey, /* in */ + TSS_MIGRATE_SCHEME migrationType, /* in */ + UINT32 migKeyAuthSize, /* in */ + BYTE *migKeyAuth, /* in */ + TPM_DIGEST pubSourceKeyDigest, /* in */ + UINT32 msaListSize, /* in */ + BYTE *msaList, /* in */ + UINT32 restrictTicketSize, /* in */ + BYTE *restrictTicket, /* in */ + UINT32 sigTicketSize, /* in */ + BYTE *sigTicket, /* in */ + UINT32 encDataSize, /* in */ + BYTE *encData, /* in */ + TPM_AUTH *pAuth, /* in, out */ + UINT32 *randomSize, /* out */ + BYTE **random, /* out */ + UINT32 *outDataSize, /* out */ + BYTE **outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CMK_CreateBlob_TP(entry, hParentKey, migrationType, + migKeyAuthSize, migKeyAuth, pubSourceKeyDigest, + msaListSize, msaList, restrictTicketSize, restrictTicket, + sigTicketSize, sigTicket, encDataSize, encData, pAuth, + randomSize, random, outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_CMK_ConvertMigration(TSS_HCONTEXT hContext, /* in */ + TCS_KEY_HANDLE hParentHandle, /* in */ + TPM_CMK_AUTH restrictTicket, /* in */ + TPM_HMAC sigTicket, /* in */ + UINT32 keyDataSize, /* in */ + BYTE *keyData, /* in */ + UINT32 msaListSize, /* in */ + BYTE *msaList, /* in */ + UINT32 randomSize, /* in */ + BYTE *random, /* in */ + TPM_AUTH *pAuth, /* in, out */ + UINT32 *outDataSize, /* out */ + BYTE **outData) /* out */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_CMK_ConvertMigration_TP(entry, hParentHandle, restrictTicket, + sigTicket, keyDataSize, keyData, msaListSize, msaList, + randomSize, random, pAuth, outDataSize, outData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + +#ifdef TSS_BUILD_TSS12 +TSS_RESULT +RPC_FlushSpecific(TSS_HCONTEXT hContext, /* in */ + TCS_HANDLE hResHandle, /* in */ + TPM_RESOURCE_TYPE resourceType) /* in */ +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_FlushSpecific_TP(entry, hResHandle, resourceType); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} + +TSS_RESULT +RPC_KeyControlOwner(TCS_CONTEXT_HANDLE hContext, /* in */ + TCS_KEY_HANDLE hKey, /* in */ + UINT32 ulPublicInfoLength, /* in */ + BYTE* rgbPublicInfo, /* in */ + UINT32 attribName, /* in */ + TSS_BOOL attribValue, /* in */ + TPM_AUTH* pOwnerAuth, /* in, out */ + TSS_UUID* pUuidData) /* out */ + +{ + TSS_RESULT result = (TSS_E_INTERNAL_ERROR | TSS_LAYER_TSP); + struct host_table_entry *entry = get_table_entry(hContext); + + if (entry == NULL) + return TSPERR(TSS_E_NO_CONNECTION); + + switch (entry->type) { + case CONNECTION_TYPE_TCP_PERSISTANT: + result = RPC_KeyControlOwner_TP(entry, hKey, + ulPublicInfoLength, + rgbPublicInfo, + attribName, + attribValue, + pOwnerAuth, + pUuidData); + break; + default: + break; + } + + put_table_entry(entry); + + return result; +} +#endif + |