Lines Matching defs:response
8169 const std::string& response,
8172 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
8174 std::string buffer(response);
8193 if (response_size != response.size()) {
8244 const std::string& response) {
8248 TPM_RC rc = Tpm::ParseResponse_Startup(response, authorization_delegate);
8283 std::string response = transceiver_->SendCommandAndWait(command);
8284 rc = ParseResponse_Startup(response, authorization_delegate);
8360 const std::string& response,
8363 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
8365 std::string buffer(response);
8384 if (response_size != response.size()) {
8435 const std::string& response) {
8439 TPM_RC rc = Tpm::ParseResponse_Shutdown(response, authorization_delegate);
8474 std::string response = transceiver_->SendCommandAndWait(command);
8475 rc = ParseResponse_Shutdown(response, authorization_delegate);
8551 const std::string& response,
8554 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
8556 std::string buffer(response);
8575 if (response_size != response.size()) {
8626 const std::string& response) {
8630 TPM_RC rc = Tpm::ParseResponse_SelfTest(response, authorization_delegate);
8665 std::string response = transceiver_->SendCommandAndWait(command);
8666 rc = ParseResponse_SelfTest(response, authorization_delegate);
8742 const std::string& response,
8746 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
8748 std::string buffer(response);
8767 if (response_size != response.size()) {
8825 const std::string& response) {
8830 TPM_RC rc = Tpm::ParseResponse_IncrementalSelfTest(response, &to_do_list,
8868 std::string response = transceiver_->SendCommandAndWait(command);
8869 rc = ParseResponse_IncrementalSelfTest(response, to_do_list,
8937 const std::string& response,
8942 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
8944 std::string buffer(response);
8963 if (response_size != response.size()) {
9037 const std::string& response) {
9044 response, &out_data, &test_result, authorization_delegate);
9077 std::string response = transceiver_->SendCommandAndWait(command);
9078 rc = ParseResponse_GetTestResult(response, out_data, test_result,
9219 const std::string& response,
9224 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
9226 std::string buffer(response);
9245 if (response_size != response.size()) {
9322 const std::string& response) {
9329 response, &session_handle, &nonce_tpm, authorization_delegate);
9385 std::string response = transceiver_->SendCommandAndWait(command);
9386 rc = ParseResponse_StartAuthSession(response, session_handle, nonce_tpm,
9464 const std::string& response,
9467 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
9469 std::string buffer(response);
9488 if (response_size != response.size()) {
9539 const std::string& response) {
9544 Tpm::ParseResponse_PolicyRestart(response, authorization_delegate);
9581 std::string response = transceiver_->SendCommandAndWait(command);
9582 rc = ParseResponse_PolicyRestart(response, authorization_delegate);
9703 const std::string& response,
9711 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
9713 std::string buffer(response);
9732 if (response_size != response.size()) {
9822 const std::string& response) {
9832 response, &out_private, &out_public, &creation_data, &creation_hash,
9886 std::string response = transceiver_->SendCommandAndWait(command);
9887 rc = ParseResponse_Create(response, out_private, out_public, creation_data,
9991 TPM_RC Tpm::ParseResponse_Load(const std::string& response,
9996 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
9998 std::string buffer(response);
10017 if (response_size != response.size()) {
10091 const std::string& response) {
10097 TPM_RC rc = Tpm::ParseResponse_Load(response, &object_handle, &name,
10143 std::string response = transceiver_->SendCommandAndWait(command);
10145 ParseResponse_Load(response, object_handle, name, authorization_delegate);
10247 const std::string& response,
10252 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
10254 std::string buffer(response);
10273 if (response_size != response.size()) {
10347 const std::string& response) {
10353 TPM_RC rc = Tpm::ParseResponse_LoadExternal(response, &object_handle, &name,
10395 std::string response = transceiver_->SendCommandAndWait(command);
10396 rc = ParseResponse_LoadExternal(response, object_handle, name,
10474 const std::string& response,
10480 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
10482 std::string buffer(response);
10501 if (response_size != response.size()) {
10580 const std::string& response) {
10588 response, &out_public, &name, &qualified_name, authorization_delegate);
10628 std::string response = transceiver_->SendCommandAndWait(command);
10629 rc = ParseResponse_ReadPublic(response, out_public, name, qualified_name,
10743 const std::string& response,
10747 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
10749 std::string buffer(response);
10768 if (response_size != response.size()) {
10839 const std::string& response) {
10844 TPM_RC rc = Tpm::ParseResponse_ActivateCredential(response, &cert_info,
10894 std::string response = transceiver_->SendCommandAndWait(command);
10895 rc = ParseResponse_ActivateCredential(response, cert_info,
10999 const std::string& response,
11004 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
11006 std::string buffer(response);
11025 if (response_size != response.size()) {
11100 const std::string& response) {
11107 response, &credential_blob, &secret, authorization_delegate);
11152 std::string response = transceiver_->SendCommandAndWait(command);
11153 rc = ParseResponse_MakeCredential(response, credential_blob, secret,
11231 const std::string& response,
11235 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
11237 std::string buffer(response);
11256 if (response_size != response.size()) {
11325 const std::string& response) {
11331 Tpm::ParseResponse_Unseal(response, &out_data, authorization_delegate);
11369 std::string response = transceiver_->SendCommandAndWait(command);
11370 rc = ParseResponse_Unseal(response, out_data, authorization_delegate);
11474 const std::string& response,
11478 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
11480 std::string buffer(response);
11499 if (response_size != response.size()) {
11570 const std::string& response) {
11575 TPM_RC rc = Tpm::ParseResponse_ObjectChangeAuth(response, &out_private,
11623 std::string response = transceiver_->SendCommandAndWait(command);
11624 rc = ParseResponse_ObjectChangeAuth(response, out_private,
11738 const std::string& response,
11744 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
11746 std::string buffer(response);
11765 if (response_size != response.size()) {
11846 const std::string& response) {
11854 Tpm::ParseResponse_Duplicate(response, &encryption_key_out, &duplicate,
11907 std::string response = transceiver_->SendCommandAndWait(command);
11908 rc = ParseResponse_Duplicate(response, encryption_key_out, duplicate,
12031 const std::string& response,
12036 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
12038 std::string buffer(response);
12057 if (response_size != response.size()) {
12131 const std::string& response) {
12137 TPM_RC rc = Tpm::ParseResponse_Rewrap(response, &out_duplicate, &out_sym_seed,
12189 std::string response = transceiver_->SendCommandAndWait(command);
12190 rc = ParseResponse_Rewrap(response, out_duplicate, out_sym_seed,
12321 const std::string& response,
12325 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
12327 std::string buffer(response);
12346 if (response_size != response.size()) {
12415 const std::string& response) {
12421 Tpm::ParseResponse_Import(response, &out_private, authorization_delegate);
12471 std::string response = transceiver_->SendCommandAndWait(command);
12472 rc = ParseResponse_Import(response, out_private, authorization_delegate);
12584 const std::string& response,
12588 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
12590 std::string buffer(response);
12609 if (response_size != response.size()) {
12678 const std::string& response) {
12683 TPM_RC rc = Tpm::ParseResponse_RSA_Encrypt(response, &out_data,
12730 std::string response = transceiver_->SendCommandAndWait(command);
12731 rc = ParseResponse_RSA_Encrypt(response, out_data, authorization_delegate);
12843 const std::string& response,
12847 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
12849 std::string buffer(response);
12868 if (response_size != response.size()) {
12937 const std::string& response) {
12942 TPM_RC rc = Tpm::ParseResponse_RSA_Decrypt(response, &message,
12989 std::string response = transceiver_->SendCommandAndWait(command);
12990 rc = ParseResponse_RSA_Decrypt(response, message, authorization_delegate);
13067 const std::string& response,
13072 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
13074 std::string buffer(response);
13093 if (response_size != response.size()) {
13167 const std::string& response) {
13173 TPM_RC rc = Tpm::ParseResponse_ECDH_KeyGen(response, &z_point, &pub_point,
13213 std::string response = transceiver_->SendCommandAndWait(command);
13214 rc = ParseResponse_ECDH_KeyGen(response, z_point, pub_point,
13309 const std::string& response,
13313 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
13315 std::string buffer(response);
13334 if (response_size != response.size()) {
13403 const std::string& response) {
13408 TPM_RC rc = Tpm::ParseResponse_ECDH_ZGen(response, &out_point,
13449 std::string response = transceiver_->SendCommandAndWait(command);
13450 rc = ParseResponse_ECDH_ZGen(response, out_point, authorization_delegate);
13526 const std::string& response,
13530 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
13532 std::string buffer(response);
13551 if (response_size != response.size()) {
13607 const std::string& response) {
13612 TPM_RC rc = Tpm::ParseResponse_ECC_Parameters(response, ¶meters,
13649 std::string response = transceiver_->SendCommandAndWait(command);
13650 rc = ParseResponse_ECC_Parameters(response, parameters,
13772 const std::string& response,
13777 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
13779 std::string buffer(response);
13798 if (response_size != response.size()) {
13872 const std::string& response) {
13878 TPM_RC rc = Tpm::ParseResponse_ZGen_2Phase(response, &out_z1, &out_z2,
13928 std::string response = transceiver_->SendCommandAndWait(command);
13929 rc = ParseResponse_ZGen_2Phase(response, out_z1, out_z2,
14043 const std::string& response,
14048 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
14050 std::string buffer(response);
14069 if (response_size != response.size()) {
14143 const std::string& response) {
14149 TPM_RC rc = Tpm::ParseResponse_EncryptDecrypt(response, &out_data, &iv_out,
14199 std::string response = transceiver_->SendCommandAndWait(command);
14200 rc = ParseResponse_EncryptDecrypt(response, out_data, iv_out,
14302 TPM_RC Tpm::ParseResponse_Hash(const std::string& response,
14307 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
14309 std::string buffer(response);
14328 if (response_size != response.size()) {
14402 const std::string& response) {
14408 TPM_RC rc = Tpm::ParseResponse_Hash(response, &out_hash, &validation,
14450 std::string response = transceiver_->SendCommandAndWait(command);
14451 rc = ParseResponse_Hash(response, out_hash, validation,
14554 TPM_RC Tpm::ParseResponse_HMAC(const std::string& response,
14558 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
14560 std::string buffer(response);
14579 if (response_size != response.size()) {
14648 const std::string& response) {
14654 Tpm::ParseResponse_HMAC(response, &out_hmac, authorization_delegate);
14696 std::string response = transceiver_->SendCommandAndWait(command);
14697 rc = ParseResponse_HMAC(response, out_hmac, authorization_delegate);
14773 const std::string& response,
14777 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
14779 std::string buffer(response);
14798 if (response_size != response.size()) {
14867 const std::string& response) {
14872 TPM_RC rc = Tpm::ParseResponse_GetRandom(response, &random_bytes,
14909 std::string response = transceiver_->SendCommandAndWait(command);
14910 rc = ParseResponse_GetRandom(response, random_bytes, authorization_delegate);
14994 const std::string& response,
14997 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
14999 std::string buffer(response);
15018 if (response_size != response.size()) {
15069 const std::string& response) {
15073 TPM_RC rc = Tpm::ParseResponse_StirRandom(response, authorization_delegate);
15108 std::string response = transceiver_->SendCommandAndWait(command);
15109 rc = ParseResponse_StirRandom(response, authorization_delegate);
15212 const std::string& response,
15216 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
15218 std::string buffer(response);
15237 if (response_size != response.size()) {
15293 const std::string& response) {
15298 TPM_RC rc = Tpm::ParseResponse_HMAC_Start(response, &sequence_handle,
15341 std::string response = transceiver_->SendCommandAndWait(command);
15342 rc = ParseResponse_HMAC_Start(response, sequence_handle,
15436 const std::string& response,
15440 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
15442 std::string buffer(response);
15461 if (response_size != response.size()) {
15519 const std::string& response) {
15524 TPM_RC rc = Tpm::ParseResponse_HashSequenceStart(response, &sequence_handle,
15564 std::string response = transceiver_->SendCommandAndWait(command);
15565 rc = ParseResponse_HashSequenceStart(response, sequence_handle,
15660 const std::string& response,
15663 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
15665 std::string buffer(response);
15684 if (response_size != response.size()) {
15735 const std::string& response) {
15740 Tpm::ParseResponse_SequenceUpdate(response, authorization_delegate);
15781 std::string response = transceiver_->SendCommandAndWait(command);
15782 rc = ParseResponse_SequenceUpdate(response, authorization_delegate);
15885 const std::string& response,
15890 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
15892 std::string buffer(response);
15911 if (response_size != response.size()) {
15987 const std::string& response) {
15994 response, &result, &validation, authorization_delegate);
16040 std::string response = transceiver_->SendCommandAndWait(command);
16041 rc = ParseResponse_SequenceComplete(response, result, validation,
16146 const std::string& response,
16150 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
16152 std::string buffer(response);
16171 if (response_size != response.size()) {
16229 const std::string& response) {
16234 TPM_RC rc = Tpm::ParseResponse_EventSequenceComplete(response, &results,
16282 std::string response = transceiver_->SendCommandAndWait(command);
16283 rc = ParseResponse_EventSequenceComplete(response, results,
16397 const std::string& response,
16402 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
16404 std::string buffer(response);
16423 if (response_size != response.size()) {
16497 const std::string& response) {
16503 TPM_RC rc = Tpm::ParseResponse_Certify(response, &certify_info, &signature,
16553 std::string response = transceiver_->SendCommandAndWait(command);
16554 rc = ParseResponse_Certify(response, certify_info, signature,
16686 const std::string& response,
16691 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
16693 std::string buffer(response);
16712 if (response_size != response.size()) {
16787 const std::string& response) {
16794 response, &certify_info, &signature, authorization_delegate);
16849 std::string response = transceiver_->SendCommandAndWait(command);
16850 rc = ParseResponse_CertifyCreation(response, certify_info, signature,
16962 TPM_RC Tpm::ParseResponse_Quote(const std::string& response,
16967 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
16969 std::string buffer(response);
16988 if (response_size != response.size()) {
17062 const std::string& response) {
17068 TPM_RC rc = Tpm::ParseResponse_Quote(response, "ed, &signature,
17116 std::string response = transceiver_->SendCommandAndWait(command);
17117 rc = ParseResponse_Quote(response, quoted, signature, authorization_delegate);
17242 const std::string& response,
17247 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
17249 std::string buffer(response);
17268 if (response_size != response.size()) {
17344 const std::string& response) {
17351 response, &audit_info, &signature, authorization_delegate);
17407 std::string response = transceiver_->SendCommandAndWait(command);
17408 rc = ParseResponse_GetSessionAuditDigest(response, audit_info, signature,
17522 const std::string& response,
17527 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
17529 std::string buffer(response);
17548 if (response_size != response.size()) {
17624 const std::string& response) {
17631 response, &audit_info, &signature, authorization_delegate);
17681 std::string response = transceiver_->SendCommandAndWait(command);
17682 rc = ParseResponse_GetCommandAuditDigest(response, audit_info, signature,
17798 const std::string& response,
17803 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
17805 std::string buffer(response);
17824 if (response_size != response.size()) {
17898 const std::string& response) {
17904 TPM_RC rc = Tpm::ParseResponse_GetTime(response, &time_info, &signature,
17956 std::string response = transceiver_->SendCommandAndWait(command);
17957 rc = ParseResponse_GetTime(response, time_info, signature,
18071 const std::string& response,
18079 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
18081 std::string buffer(response);
18100 if (response_size != response.size()) {
18177 const std::string& response) {
18186 TPM_RC rc = Tpm::ParseResponse_Commit(response, ¶m_size_out, &k, &l, &e,
18239 std::string response = transceiver_->SendCommandAndWait(command);
18240 rc = ParseResponse_Commit(response, param_size_out, k, l, e, counter,
18326 const std::string& response,
18332 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
18334 std::string buffer(response);
18353 if (response_size != response.size()) {
18419 const std::string& response) {
18426 TPM_RC rc = Tpm::ParseResponse_EC_Ephemeral(response, ¶m_size_out, &q,
18467 std::string response = transceiver_->SendCommandAndWait(command);
18468 rc = ParseResponse_EC_Ephemeral(response, param_size_out, q, counter,
18572 const std::string& response,
18576 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
18578 std::string buffer(response);
18597 if (response_size != response.size()) {
18654 const std::string& response) {
18659 TPM_RC rc = Tpm::ParseResponse_VerifySignature(response, &validation,
18704 std::string response = transceiver_->SendCommandAndWait(command);
18705 rc = ParseResponse_VerifySignature(response, validation,
18817 TPM_RC Tpm::ParseResponse_Sign(const std::string& response,
18821 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
18823 std::string buffer(response);
18842 if (response_size != response.size()) {
18898 const std::string& response) {
18904 Tpm::ParseResponse_Sign(response, &signature, authorization_delegate);
18950 std::string response = transceiver_->SendCommandAndWait(command);
18951 rc = ParseResponse_Sign(response, signature, authorization_delegate);
19055 const std::string& response,
19058 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
19060 std::string buffer(response);
19079 if (response_size != response.size()) {
19132 const std::string& response) {
19137 response, authorization_delegate);
19185 std::string response = transceiver_->SendCommandAndWait(command);
19187 ParseResponse_SetCommandCodeAuditStatus(response, authorization_delegate);
19273 const std::string& response,
19276 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
19278 std::string buffer(response);
19297 if (response_size != response.size()) {
19348 const std::string& response) {
19352 TPM_RC rc = Tpm::ParseResponse_PCR_Extend(response, authorization_delegate);
19391 std::string response = transceiver_->SendCommandAndWait(command);
19392 rc = ParseResponse_PCR_Extend(response, authorization_delegate);
19486 const std::string& response,
19490 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
19492 std::string buffer(response);
19511 if (response_size != response.size()) {
19567 const std::string& response) {
19573 Tpm::ParseResponse_PCR_Event(response, &digests, authorization_delegate);
19615 std::string response = transceiver_->SendCommandAndWait(command);
19616 rc = ParseResponse_PCR_Event(response, digests, authorization_delegate);
19692 const std::string& response,
19698 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
19700 std::string buffer(response);
19719 if (response_size != response.size()) {
19786 const std::string& response) {
19793 TPM_RC rc = Tpm::ParseResponse_PCR_Read(response, &pcr_update_counter,
19833 std::string response = transceiver_->SendCommandAndWait(command);
19834 rc = ParseResponse_PCR_Read(response, pcr_update_counter, pcr_selection_out,
19921 const std::string& response,
19928 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
19930 std::string buffer(response);
19949 if (response_size != response.size()) {
20021 const std::string& response) {
20030 response, &allocation_success, &max_pcr, &size_needed, &size_available,
20076 std::string response = transceiver_->SendCommandAndWait(command);
20077 rc = ParseResponse_PCR_Allocate(response, allocation_success, max_pcr,
20192 const std::string& response,
20195 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
20197 std::string buffer(response);
20216 if (response_size != response.size()) {
20269 const std::string& response) {
20274 Tpm::ParseResponse_PCR_SetAuthPolicy(response, authorization_delegate);
20322 std::string response = transceiver_->SendCommandAndWait(command);
20323 rc = ParseResponse_PCR_SetAuthPolicy(response, authorization_delegate);
20417 const std::string& response,
20420 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
20422 std::string buffer(response);
20441 if (response_size != response.size()) {
20494 const std::string& response) {
20499 Tpm::ParseResponse_PCR_SetAuthValue(response, authorization_delegate);
20539 std::string response = transceiver_->SendCommandAndWait(command);
20540 rc = ParseResponse_PCR_SetAuthValue(response, authorization_delegate);
20617 const std::string& response,
20620 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
20622 std::string buffer(response);
20641 if (response_size != response.size()) {
20692 const std::string& response) {
20696 TPM_RC rc = Tpm::ParseResponse_PCR_Reset(response, authorization_delegate);
20733 std::string response = transceiver_->SendCommandAndWait(command);
20734 rc = ParseResponse_PCR_Reset(response, authorization_delegate);
20874 const std::string& response,
20879 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
20881 std::string buffer(response);
20900 if (response_size != response.size()) {
20974 const std::string& response) {
20981 response, &timeout, &policy_ticket, authorization_delegate);
21038 std::string response = transceiver_->SendCommandAndWait(command);
21039 rc = ParseResponse_PolicySigned(response, timeout, policy_ticket,
21171 const std::string& response,
21176 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
21178 std::string buffer(response);
21197 if (response_size != response.size()) {
21271 const std::string& response) {
21278 response, &timeout, &policy_ticket, authorization_delegate);
21333 std::string response = transceiver_->SendCommandAndWait(command);
21334 rc = ParseResponse_PolicySecret(response, timeout, policy_ticket,
21465 const std::string& response,
21468 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
21470 std::string buffer(response);
21489 if (response_size != response.size()) {
21540 const std::string& response) {
21544 TPM_RC rc = Tpm::ParseResponse_PolicyTicket(response, authorization_delegate);
21593 std::string response = transceiver_->SendCommandAndWait(command);
21594 rc = ParseResponse_PolicyTicket(response, authorization_delegate);
21680 const std::string& response,
21683 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
21685 std::string buffer(response);
21704 if (response_size != response.size()) {
21755 const std::string& response) {
21759 TPM_RC rc = Tpm::ParseResponse_PolicyOR(response, authorization_delegate);
21800 std::string response = transceiver_->SendCommandAndWait(command);
21801 rc = ParseResponse_PolicyOR(response, authorization_delegate);
21904 const std::string& response,
21907 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
21909 std::string buffer(response);
21928 if (response_size != response.size()) {
21979 const std::string& response) {
21983 TPM_RC rc = Tpm::ParseResponse_PolicyPCR(response, authorization_delegate);
22026 std::string response = transceiver_->SendCommandAndWait(command);
22027 rc = ParseResponse_PolicyPCR(response, authorization_delegate);
22113 const std::string& response,
22116 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
22118 std::string buffer(response);
22137 if (response_size != response.size()) {
22188 const std::string& response) {
22193 Tpm::ParseResponse_PolicyLocality(response, authorization_delegate);
22234 std::string response = transceiver_->SendCommandAndWait(command);
22235 rc = ParseResponse_PolicyLocality(response, authorization_delegate);
22367 const std::string& response,
22370 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
22372 std::string buffer(response);
22391 if (response_size != response.size()) {
22442 const std::string& response) {
22446 TPM_RC rc = Tpm::ParseResponse_PolicyNV(response, authorization_delegate);
22501 std::string response = transceiver_->SendCommandAndWait(command);
22502 rc = ParseResponse_PolicyNV(response, authorization_delegate);
22614 const std::string& response,
22617 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
22619 std::string buffer(response);
22638 if (response_size != response.size()) {
22691 const std::string& response) {
22696 Tpm::ParseResponse_PolicyCounterTimer(response, authorization_delegate);
22742 std::string response = transceiver_->SendCommandAndWait(command);
22743 rc = ParseResponse_PolicyCounterTimer(response, authorization_delegate);
22829 const std::string& response,
22832 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
22834 std::string buffer(response);
22853 if (response_size != response.size()) {
22906 const std::string& response) {
22911 Tpm::ParseResponse_PolicyCommandCode(response, authorization_delegate);
22953 std::string response = transceiver_->SendCommandAndWait(command);
22954 rc = ParseResponse_PolicyCommandCode(response, authorization_delegate);
23031 const std::string& response,
23034 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
23036 std::string buffer(response);
23055 if (response_size != response.size()) {
23108 const std::string& response) {
23112 TPM_RC rc = Tpm::ParseResponse_PolicyPhysicalPresence(response,
23152 std::string response = transceiver_->SendCommandAndWait(command);
23153 rc = ParseResponse_PolicyPhysicalPresence(response, authorization_delegate);
23247 const std::string& response,
23250 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
23252 std::string buffer(response);
23271 if (response_size != response.size()) {
23322 const std::string& response) {
23326 TPM_RC rc = Tpm::ParseResponse_PolicyCpHash(response, authorization_delegate);
23367 std::string response = transceiver_->SendCommandAndWait(command);
23368 rc = ParseResponse_PolicyCpHash(response, authorization_delegate);
23462 const std::string& response,
23465 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
23467 std::string buffer(response);
23486 if (response_size != response.size()) {
23537 const std::string& response) {
23542 Tpm::ParseResponse_PolicyNameHash(response, authorization_delegate);
23583 std::string response = transceiver_->SendCommandAndWait(command);
23584 rc = ParseResponse_PolicyNameHash(response, authorization_delegate);
23696 const std::string& response,
23699 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
23701 std::string buffer(response);
23720 if (response_size != response.size()) {
23773 const std::string& response) {
23778 response, authorization_delegate);
23825 std::string response = transceiver_->SendCommandAndWait(command);
23826 rc = ParseResponse_PolicyDuplicationSelect(response, authorization_delegate);
23947 const std::string& response,
23950 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
23952 std::string buffer(response);
23971 if (response_size != response.size()) {
24023 const std::string& response) {
24028 Tpm::ParseResponse_PolicyAuthorize(response, authorization_delegate);
24075 std::string response = transceiver_->SendCommandAndWait(command);
24076 rc = ParseResponse_PolicyAuthorize(response, authorization_delegate);
24153 const std::string& response,
24156 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
24158 std::string buffer(response);
24177 if (response_size != response.size()) {
24229 const std::string& response) {
24234 Tpm::ParseResponse_PolicyAuthValue(response, authorization_delegate);
24271 std::string response = transceiver_->SendCommandAndWait(command);
24272 rc = ParseResponse_PolicyAuthValue(response, authorization_delegate);
24349 const std::string& response,
24352 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
24354 std::string buffer(response);
24373 if (response_size != response.size()) {
24424 const std::string& response) {
24429 Tpm::ParseResponse_PolicyPassword(response, authorization_delegate);
24466 std::string response = transceiver_->SendCommandAndWait(command);
24467 rc = ParseResponse_PolicyPassword(response, authorization_delegate);
24544 const std::string& response,
24548 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
24550 std::string buffer(response);
24569 if (response_size != response.size()) {
24639 const std::string& response) {
24644 TPM_RC rc = Tpm::ParseResponse_PolicyGetDigest(response, &policy_digest,
24683 std::string response = transceiver_->SendCommandAndWait(command);
24684 rc = ParseResponse_PolicyGetDigest(response, policy_digest,
24771 const std::string& response,
24774 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
24776 std::string buffer(response);
24795 if (response_size != response.size()) {
24847 const std::string& response) {
24852 Tpm::ParseResponse_PolicyNvWritten(response, authorization_delegate);
24893 std::string response = transceiver_->SendCommandAndWait(command);
24894 rc = ParseResponse_PolicyNvWritten(response, authorization_delegate);
25015 const std::string& response,
25024 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
25026 std::string buffer(response);
25045 if (response_size != response.size()) {
25141 const std::string& response) {
25152 response, &object_handle, &out_public, &creation_data, &creation_hash,
25207 std::string response = transceiver_->SendCommandAndWait(command);
25209 response, object_handle, out_public, creation_data, creation_hash,
25305 const std::string& response,
25308 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
25310 std::string buffer(response);
25329 if (response_size != response.size()) {
25382 const std::string& response) {
25387 Tpm::ParseResponse_HierarchyControl(response, authorization_delegate);
25431 std::string response = transceiver_->SendCommandAndWait(command);
25432 rc = ParseResponse_HierarchyControl(response, authorization_delegate);
25535 const std::string& response,
25538 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
25540 std::string buffer(response);
25559 if (response_size != response.size()) {
25612 const std::string& response) {
25617 Tpm::ParseResponse_SetPrimaryPolicy(response, authorization_delegate);
25661 std::string response = transceiver_->SendCommandAndWait(command);
25662 rc = ParseResponse_SetPrimaryPolicy(response, authorization_delegate);
25739 const std::string& response,
25742 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
25744 std::string buffer(response);
25763 if (response_size != response.size()) {
25814 const std::string& response) {
25818 TPM_RC rc = Tpm::ParseResponse_ChangePPS(response, authorization_delegate);
25855 std::string response = transceiver_->SendCommandAndWait(command);
25856 rc = ParseResponse_ChangePPS(response, authorization_delegate);
25933 const std::string& response,
25936 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
25938 std::string buffer(response);
25957 if (response_size != response.size()) {
26008 const std::string& response) {
26012 TPM_RC rc = Tpm::ParseResponse_ChangeEPS(response, authorization_delegate);
26049 std::string response = transceiver_->SendCommandAndWait(command);
26050 rc = ParseResponse_ChangeEPS(response, authorization_delegate);
26126 TPM_RC Tpm::ParseResponse_Clear(const std::string& response,
26129 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
26131 std::string buffer(response);
26150 if (response_size != response.size()) {
26201 const std::string& response) {
26205 TPM_RC rc = Tpm::ParseResponse_Clear(response, authorization_delegate);
26242 std::string response = transceiver_->SendCommandAndWait(command);
26243 rc = ParseResponse_Clear(response, authorization_delegate);
26329 const std::string& response,
26332 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
26334 std::string buffer(response);
26353 if (response_size != response.size()) {
26404 const std::string& response) {
26408 TPM_RC rc = Tpm::ParseResponse_ClearControl(response, authorization_delegate);
26447 std::string response = transceiver_->SendCommandAndWait(command);
26448 rc = ParseResponse_ClearControl(response, authorization_delegate);
26542 const std::string& response,
26545 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
26547 std::string buffer(response);
26566 if (response_size != response.size()) {
26619 const std::string& response) {
26624 Tpm::ParseResponse_HierarchyChangeAuth(response, authorization_delegate);
26666 std::string response = transceiver_->SendCommandAndWait(command);
26667 rc = ParseResponse_HierarchyChangeAuth(response, authorization_delegate);
26744 const std::string& response,
26747 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
26749 std::string buffer(response);
26768 if (response_size != response.size()) {
26821 const std::string& response) {
26826 response, authorization_delegate);
26866 std::string response = transceiver_->SendCommandAndWait(command);
26868 ParseResponse_DictionaryAttackLockReset(response, authorization_delegate);
26972 const std::string& response,
26975 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
26977 std::string buffer(response);
26996 if (response_size != response.size()) {
27049 const std::string& response) {
27054 response, authorization_delegate);
27102 std::string response = transceiver_->SendCommandAndWait(command);
27103 rc = ParseResponse_DictionaryAttackParameters(response,
27199 const std::string& response,
27202 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
27204 std::string buffer(response);
27223 if (response_size != response.size()) {
27274 const std::string& response) {
27278 TPM_RC rc = Tpm::ParseResponse_PP_Commands(response, authorization_delegate);
27319 std::string response = transceiver_->SendCommandAndWait(command);
27320 rc = ParseResponse_PP_Commands(response, authorization_delegate);
27406 const std::string& response,
27409 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
27411 std::string buffer(response);
27430 if (response_size != response.size()) {
27482 const std::string& response) {
27487 Tpm::ParseResponse_SetAlgorithmSet(response, authorization_delegate);
27528 std::string response = transceiver_->SendCommandAndWait(command);
27529 rc = ParseResponse_SetAlgorithmSet(response, authorization_delegate);
27643 const std::string& response,
27646 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
27648 std::string buffer(response);
27667 if (response_size != response.size()) {
27720 const std::string& response) {
27725 Tpm::ParseResponse_FieldUpgradeStart(response, authorization_delegate);
27773 std::string response = transceiver_->SendCommandAndWait(command);
27774 rc = ParseResponse_FieldUpgradeStart(response, authorization_delegate);
27858 const std::string& response,
27863 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
27865 std::string buffer(response);
27884 if (response_size != response.size()) {
27947 const std::string& response) {
27954 response, &next_digest, &first_digest, authorization_delegate);
27992 std::string response = transceiver_->SendCommandAndWait(command);
27993 rc = ParseResponse_FieldUpgradeData(response, next_digest, first_digest,
28070 const std::string& response,
28074 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
28076 std::string buffer(response);
28095 if (response_size != response.size()) {
28164 const std::string& response) {
28169 TPM_RC rc = Tpm::ParseResponse_FirmwareRead(response, &fu_data,
28206 std::string response = transceiver_->SendCommandAndWait(command);
28207 rc = ParseResponse_FirmwareRead(response, fu_data, authorization_delegate);
28284 const std::string& response,
28288 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
28290 std::string buffer(response);
28309 if (response_size != response.size()) {
28365 const std::string& response) {
28370 TPM_RC rc = Tpm::ParseResponse_ContextSave(response, &context,
28409 std::string response = transceiver_->SendCommandAndWait(command);
28410 rc = ParseResponse_ContextSave(response, context, authorization_delegate);
28486 const std::string& response,
28490 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
28492 std::string buffer(response);
28511 if (response_size != response.size()) {
28567 const std::string& response) {
28572 TPM_RC rc = Tpm::ParseResponse_ContextLoad(response, &loaded_handle,
28609 std::string response = transceiver_->SendCommandAndWait(command);
28610 rc = ParseResponse_ContextLoad(response, loaded_handle,
28687 const std::string& response,
28690 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
28692 std::string buffer(response);
28711 if (response_size != response.size()) {
28762 const std::string& response) {
28766 TPM_RC rc = Tpm::ParseResponse_FlushContext(response, authorization_delegate);
28801 std::string response = transceiver_->SendCommandAndWait(command);
28802 rc = ParseResponse_FlushContext(response, authorization_delegate);
28899 const std::string& response,
28902 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
28904 std::string buffer(response);
28923 if (response_size != response.size()) {
28974 const std::string& response) {
28978 TPM_RC rc = Tpm::ParseResponse_EvictControl(response, authorization_delegate);
29023 std::string response = transceiver_->SendCommandAndWait(command);
29024 rc = ParseResponse_EvictControl(response, authorization_delegate);
29091 const std::string& response,
29095 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
29097 std::string buffer(response);
29116 if (response_size != response.size()) {
29172 const std::string& response) {
29177 TPM_RC rc = Tpm::ParseResponse_ReadClock(response, ¤t_time,
29210 std::string response = transceiver_->SendCommandAndWait(command);
29211 rc = ParseResponse_ReadClock(response, current_time, authorization_delegate);
29297 const std::string& response,
29300 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
29302 std::string buffer(response);
29321 if (response_size != response.size()) {
29372 const std::string& response) {
29376 TPM_RC rc = Tpm::ParseResponse_ClockSet(response, authorization_delegate);
29415 std::string response = transceiver_->SendCommandAndWait(command);
29416 rc = ParseResponse_ClockSet(response, authorization_delegate);
29502 const std::string& response,
29505 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
29507 std::string buffer(response);
29526 if (response_size != response.size()) {
29578 const std::string& response) {
29583 Tpm::ParseResponse_ClockRateAdjust(response, authorization_delegate);
29622 std::string response = transceiver_->SendCommandAndWait(command);
29623 rc = ParseResponse_ClockRateAdjust(response, authorization_delegate);
29717 const std::string& response,
29722 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
29724 std::string buffer(response);
29743 if (response_size != response.size()) {
29805 const std::string& response) {
29812 response, &more_data, &capability_data, authorization_delegate);
29853 std::string response = transceiver_->SendCommandAndWait(command);
29854 rc = ParseResponse_GetCapability(response, more_data, capability_data,
29931 const std::string& response,
29934 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
29936 std::string buffer(response);
29955 if (response_size != response.size()) {
30006 const std::string& response) {
30010 TPM_RC rc = Tpm::ParseResponse_TestParms(response, authorization_delegate);
30045 std::string response = transceiver_->SendCommandAndWait(command);
30046 rc = ParseResponse_TestParms(response, authorization_delegate);
30149 const std::string& response,
30152 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
30154 std::string buffer(response);
30173 if (response_size != response.size()) {
30224 const std::string& response) {
30229 Tpm::ParseResponse_NV_DefineSpace(response, authorization_delegate);
30272 std::string response = transceiver_->SendCommandAndWait(command);
30273 rc = ParseResponse_NV_DefineSpace(response, authorization_delegate);
30360 const std::string& response,
30363 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
30365 std::string buffer(response);
30384 if (response_size != response.size()) {
30437 const std::string& response) {
30442 Tpm::ParseResponse_NV_UndefineSpace(response, authorization_delegate);
30486 std::string response = transceiver_->SendCommandAndWait(command);
30487 rc = ParseResponse_NV_UndefineSpace(response, authorization_delegate);
30574 const std::string& response,
30577 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
30579 std::string buffer(response);
30598 if (response_size != response.size()) {
30651 const std::string& response) {
30656 response, authorization_delegate);
30701 std::string response = transceiver_->SendCommandAndWait(command);
30702 rc = ParseResponse_NV_UndefineSpaceSpecial(response, authorization_delegate);
30779 const std::string& response,
30784 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
30786 std::string buffer(response);
30805 if (response_size != response.size()) {
30879 const std::string& response) {
30885 TPM_RC rc = Tpm::ParseResponse_NV_ReadPublic(response, &nv_public, &nv_name,
30925 std::string response = transceiver_->SendCommandAndWait(command);
30926 rc = ParseResponse_NV_ReadPublic(response, nv_public, nv_name,
31040 const std::string& response,
31043 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
31045 std::string buffer(response);
31064 if (response_size != response.size()) {
31115 const std::string& response) {
31119 TPM_RC rc = Tpm::ParseResponse_NV_Write(response, authorization_delegate);
31166 std::string response = transceiver_->SendCommandAndWait(command);
31167 rc = ParseResponse_NV_Write(response, authorization_delegate);
31254 const std::string& response,
31257 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
31259 std::string buffer(response);
31278 if (response_size != response.size()) {
31329 const std::string& response) {
31333 TPM_RC rc = Tpm::ParseResponse_NV_Increment(response, authorization_delegate);
31376 std::string response = transceiver_->SendCommandAndWait(command);
31377 rc = ParseResponse_NV_Increment(response, authorization_delegate);
31481 const std::string& response,
31484 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
31486 std::string buffer(response);
31505 if (response_size != response.size()) {
31556 const std::string& response) {
31560 TPM_RC rc = Tpm::ParseResponse_NV_Extend(response, authorization_delegate);
31605 std::string response = transceiver_->SendCommandAndWait(command);
31606 rc = ParseResponse_NV_Extend(response, authorization_delegate);
31702 const std::string& response,
31705 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
31707 std::string buffer(response);
31726 if (response_size != response.size()) {
31777 const std::string& response) {
31781 TPM_RC rc = Tpm::ParseResponse_NV_SetBits(response, authorization_delegate);
31826 std::string response = transceiver_->SendCommandAndWait(command);
31827 rc = ParseResponse_NV_SetBits(response, authorization_delegate);
31914 const std::string& response,
31917 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
31919 std::string buffer(response);
31938 if (response_size != response.size()) {
31989 const std::string& response) {
31993 TPM_RC rc = Tpm::ParseResponse_NV_WriteLock(response, authorization_delegate);
32036 std::string response = transceiver_->SendCommandAndWait(command);
32037 rc = ParseResponse_NV_WriteLock(response, authorization_delegate);
32114 const std::string& response,
32117 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
32119 std::string buffer(response);
32138 if (response_size != response.size()) {
32191 const std::string& response) {
32196 Tpm::ParseResponse_NV_GlobalWriteLock(response, authorization_delegate);
32234 std::string response = transceiver_->SendCommandAndWait(command);
32235 rc = ParseResponse_NV_GlobalWriteLock(response, authorization_delegate);
32340 const std::string& response,
32344 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
32346 std::string buffer(response);
32365 if (response_size != response.size()) {
32434 const std::string& response) {
32440 Tpm::ParseResponse_NV_Read(response, &data, authorization_delegate);
32488 std::string response = transceiver_->SendCommandAndWait(command);
32489 rc = ParseResponse_NV_Read(response, data, authorization_delegate);
32576 const std::string& response,
32579 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
32581 std::string buffer(response);
32600 if (response_size != response.size()) {
32651 const std::string& response) {
32655 TPM_RC rc = Tpm::ParseResponse_NV_ReadLock(response, authorization_delegate);
32698 std::string response = transceiver_->SendCommandAndWait(command);
32699 rc = ParseResponse_NV_ReadLock(response, authorization_delegate);
32793 const std::string& response,
32796 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
32798 std::string buffer(response);
32817 if (response_size != response.size()) {
32868 const std::string& response) {
32873 Tpm::ParseResponse_NV_ChangeAuth(response, authorization_delegate);
32912 std::string response = transceiver_->SendCommandAndWait(command);
32913 rc = ParseResponse_NV_ChangeAuth(response, authorization_delegate);
33054 const std::string& response,
33059 VLOG(2) << "Response: " << base::HexEncode(response.data(), response.size());
33061 std::string buffer(response);
33080 if (response_size != response.size()) {
33154 const std::string& response) {
33160 TPM_RC rc = Tpm::ParseResponse_NV_Certify(response, &certify_info, &signature,
33220 std::string response = transceiver_->SendCommandAndWait(command);
33221 rc = ParseResponse_NV_Certify(response, certify_info, signature,