/src/tpm2/CommandDispatcher.c
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright 2015 The Chromium OS Authors. All rights reserved. |
2 | | // Use of this source code is governed by a BSD-style license that can be |
3 | | // found in the LICENSE file. |
4 | | |
5 | | // THIS CODE IS GENERATED - DO NOT MODIFY! |
6 | | #include "ActivateCredential_fp.h" |
7 | | #include "Certify_fp.h" |
8 | | #include "CertifyCreation_fp.h" |
9 | | #include "ChangeEPS_fp.h" |
10 | | #include "ChangePPS_fp.h" |
11 | | #include "Clear_fp.h" |
12 | | #include "ClearControl_fp.h" |
13 | | #include "ClockRateAdjust_fp.h" |
14 | | #include "ClockSet_fp.h" |
15 | | #include "Commit_fp.h" |
16 | | #include "ContextLoad_fp.h" |
17 | | #include "ContextSave_fp.h" |
18 | | #include "Create_fp.h" |
19 | | #include "CreatePrimary_fp.h" |
20 | | #include "DictionaryAttackLockReset_fp.h" |
21 | | #include "DictionaryAttackParameters_fp.h" |
22 | | #include "Duplicate_fp.h" |
23 | | #include "ECC_Parameters_fp.h" |
24 | | #include "ECDH_KeyGen_fp.h" |
25 | | #include "ECDH_ZGen_fp.h" |
26 | | #include "EC_Ephemeral_fp.h" |
27 | | #include "EncryptDecrypt_fp.h" |
28 | | #include "EventSequenceComplete_fp.h" |
29 | | #include "EvictControl_fp.h" |
30 | | #include "FieldUpgradeData_fp.h" |
31 | | #include "FieldUpgradeStart_fp.h" |
32 | | #include "FirmwareRead_fp.h" |
33 | | #include "FlushContext_fp.h" |
34 | | #include "GetCapability_fp.h" |
35 | | #include "GetCommandAuditDigest_fp.h" |
36 | | #include "GetRandom_fp.h" |
37 | | #include "GetSessionAuditDigest_fp.h" |
38 | | #include "GetTestResult_fp.h" |
39 | | #include "GetTime_fp.h" |
40 | | #include "HMAC_fp.h" |
41 | | #include "HMAC_Start_fp.h" |
42 | | #include "Hash_fp.h" |
43 | | #include "HashSequenceStart_fp.h" |
44 | | #include "HierarchyChangeAuth_fp.h" |
45 | | #include "HierarchyControl_fp.h" |
46 | | #include "Import_fp.h" |
47 | | #include "IncrementalSelfTest_fp.h" |
48 | | #include "Load_fp.h" |
49 | | #include "LoadExternal_fp.h" |
50 | | #include "MakeCredential_fp.h" |
51 | | #include "NV_Certify_fp.h" |
52 | | #include "NV_ChangeAuth_fp.h" |
53 | | #include "NV_DefineSpace_fp.h" |
54 | | #include "NV_Extend_fp.h" |
55 | | #include "NV_GlobalWriteLock_fp.h" |
56 | | #include "NV_Increment_fp.h" |
57 | | #include "NV_Read_fp.h" |
58 | | #include "NV_ReadLock_fp.h" |
59 | | #include "NV_ReadPublic_fp.h" |
60 | | #include "NV_SetBits_fp.h" |
61 | | #include "NV_UndefineSpace_fp.h" |
62 | | #include "NV_UndefineSpaceSpecial_fp.h" |
63 | | #include "NV_Write_fp.h" |
64 | | #include "NV_WriteLock_fp.h" |
65 | | #include "ObjectChangeAuth_fp.h" |
66 | | #include "PCR_Allocate_fp.h" |
67 | | #include "PCR_Event_fp.h" |
68 | | #include "PCR_Extend_fp.h" |
69 | | #include "PCR_Read_fp.h" |
70 | | #include "PCR_Reset_fp.h" |
71 | | #include "PCR_SetAuthPolicy_fp.h" |
72 | | #include "PCR_SetAuthValue_fp.h" |
73 | | #include "PP_Commands_fp.h" |
74 | | #include "PolicyAuthValue_fp.h" |
75 | | #include "PolicyAuthorize_fp.h" |
76 | | #include "PolicyCommandCode_fp.h" |
77 | | #include "PolicyCounterTimer_fp.h" |
78 | | #include "PolicyCpHash_fp.h" |
79 | | #include "PolicyDuplicationSelect_fp.h" |
80 | | #include "PolicyFidoSigned_fp.h" |
81 | | #include "PolicyGetDigest_fp.h" |
82 | | #include "PolicyLocality_fp.h" |
83 | | #include "PolicyNV_fp.h" |
84 | | #include "PolicyNameHash_fp.h" |
85 | | #include "PolicyNvWritten_fp.h" |
86 | | #include "PolicyOR_fp.h" |
87 | | #include "PolicyPCR_fp.h" |
88 | | #include "PolicyPassword_fp.h" |
89 | | #include "PolicyPhysicalPresence_fp.h" |
90 | | #include "PolicyRestart_fp.h" |
91 | | #include "PolicySecret_fp.h" |
92 | | #include "PolicySigned_fp.h" |
93 | | #include "PolicyTicket_fp.h" |
94 | | #include "Quote_fp.h" |
95 | | #include "RSA_Decrypt_fp.h" |
96 | | #include "RSA_Encrypt_fp.h" |
97 | | #include "ReadClock_fp.h" |
98 | | #include "ReadPublic_fp.h" |
99 | | #include "Rewrap_fp.h" |
100 | | #include "SelfTest_fp.h" |
101 | | #include "SequenceComplete_fp.h" |
102 | | #include "SequenceUpdate_fp.h" |
103 | | #include "SetAlgorithmSet_fp.h" |
104 | | #include "SetCommandCodeAuditStatus_fp.h" |
105 | | #include "SetPrimaryPolicy_fp.h" |
106 | | #include "Shutdown_fp.h" |
107 | | #include "Sign_fp.h" |
108 | | #include "StartAuthSession_fp.h" |
109 | | #include "Startup_fp.h" |
110 | | #include "StirRandom_fp.h" |
111 | | #include "TestParms_fp.h" |
112 | | #include "Unseal_fp.h" |
113 | | #include "VerifySignature_fp.h" |
114 | | #include "ZGen_2Phase_fp.h" |
115 | | |
116 | | #include "Implementation.h" |
117 | | #include "CommandDispatcher_fp.h" |
118 | | |
119 | | TPM_RC CommandDispatcher(TPMI_ST_COMMAND_TAG tag, |
120 | | TPM_CC command_code, |
121 | | INT32* request_parameter_buffer_size, |
122 | | BYTE* request_parameter_buffer_start, |
123 | | TPM_HANDLE request_handles[], |
124 | | UINT32* response_handle_buffer_size, |
125 | 456 | UINT32* response_parameter_buffer_size) { |
126 | 456 | BYTE* request_parameter_buffer = request_parameter_buffer_start; |
127 | | |
128 | 456 | if (command_code & TPM_CCE_BIT_MASK) { |
129 | 0 | switch (command_code) { |
130 | 0 | #if IS_CCE_ENABLED(PolicyFidoSigned) |
131 | 0 | case TPM_CCE_PolicyFidoSigned: |
132 | 0 | return Exec_PolicyFidoSigned(tag, &request_parameter_buffer, |
133 | 0 | request_parameter_buffer_size, request_handles, |
134 | 0 | response_handle_buffer_size, |
135 | 0 | response_parameter_buffer_size); |
136 | 0 | #endif |
137 | 0 | default: |
138 | 0 | break; |
139 | 0 | } |
140 | 0 | return TPM_RC_COMMAND_CODE; |
141 | 0 | } |
142 | | |
143 | 456 | switch (command_code) { |
144 | 0 | #if IS_CC_ENABLED(ActivateCredential) |
145 | 0 | case TPM_CC_ActivateCredential: |
146 | 0 | return Exec_ActivateCredential( |
147 | 0 | tag, &request_parameter_buffer, request_parameter_buffer_size, |
148 | 0 | request_handles, response_handle_buffer_size, |
149 | 0 | response_parameter_buffer_size); |
150 | 0 | #endif |
151 | 0 | #if IS_CC_ENABLED(Certify) |
152 | 0 | case TPM_CC_Certify: |
153 | 0 | return Exec_Certify(tag, &request_parameter_buffer, |
154 | 0 | request_parameter_buffer_size, request_handles, |
155 | 0 | response_handle_buffer_size, |
156 | 0 | response_parameter_buffer_size); |
157 | 0 | #endif |
158 | 0 | #if IS_CC_ENABLED(CertifyCreation) |
159 | 0 | case TPM_CC_CertifyCreation: |
160 | 0 | return Exec_CertifyCreation(tag, &request_parameter_buffer, |
161 | 0 | request_parameter_buffer_size, |
162 | 0 | request_handles, response_handle_buffer_size, |
163 | 0 | response_parameter_buffer_size); |
164 | 0 | #endif |
165 | | #if IS_CC_ENABLED(ChangeEPS) |
166 | | case TPM_CC_ChangeEPS: |
167 | | return Exec_ChangeEPS(tag, &request_parameter_buffer, |
168 | | request_parameter_buffer_size, request_handles, |
169 | | response_handle_buffer_size, |
170 | | response_parameter_buffer_size); |
171 | | #endif |
172 | | #if IS_CC_ENABLED(ChangePPS) |
173 | | case TPM_CC_ChangePPS: |
174 | | return Exec_ChangePPS(tag, &request_parameter_buffer, |
175 | | request_parameter_buffer_size, request_handles, |
176 | | response_handle_buffer_size, |
177 | | response_parameter_buffer_size); |
178 | | #endif |
179 | 0 | #if IS_CC_ENABLED(Clear) |
180 | 1 | case TPM_CC_Clear: |
181 | 1 | return Exec_Clear(tag, &request_parameter_buffer, |
182 | 1 | request_parameter_buffer_size, request_handles, |
183 | 1 | response_handle_buffer_size, |
184 | 1 | response_parameter_buffer_size); |
185 | 0 | #endif |
186 | | #if IS_CC_ENABLED(ClearControl) |
187 | | case TPM_CC_ClearControl: |
188 | | return Exec_ClearControl(tag, &request_parameter_buffer, |
189 | | request_parameter_buffer_size, request_handles, |
190 | | response_handle_buffer_size, |
191 | | response_parameter_buffer_size); |
192 | | #endif |
193 | | #if IS_CC_ENABLED(ClockRateAdjust) |
194 | | case TPM_CC_ClockRateAdjust: |
195 | | return Exec_ClockRateAdjust(tag, &request_parameter_buffer, |
196 | | request_parameter_buffer_size, |
197 | | request_handles, response_handle_buffer_size, |
198 | | response_parameter_buffer_size); |
199 | | #endif |
200 | | #if IS_CC_ENABLED(ClockSet) |
201 | | case TPM_CC_ClockSet: |
202 | | return Exec_ClockSet(tag, &request_parameter_buffer, |
203 | | request_parameter_buffer_size, request_handles, |
204 | | response_handle_buffer_size, |
205 | | response_parameter_buffer_size); |
206 | | #endif |
207 | 0 | #if IS_CC_ENABLED(Commit) |
208 | 0 | case TPM_CC_Commit: |
209 | 0 | return Exec_Commit(tag, &request_parameter_buffer, |
210 | 0 | request_parameter_buffer_size, request_handles, |
211 | 0 | response_handle_buffer_size, |
212 | 0 | response_parameter_buffer_size); |
213 | 0 | #endif |
214 | 0 | #if IS_CC_ENABLED(ContextLoad) |
215 | 10 | case TPM_CC_ContextLoad: |
216 | 10 | return Exec_ContextLoad(tag, &request_parameter_buffer, |
217 | 10 | request_parameter_buffer_size, request_handles, |
218 | 10 | response_handle_buffer_size, |
219 | 10 | response_parameter_buffer_size); |
220 | 0 | #endif |
221 | 0 | #if IS_CC_ENABLED(ContextSave) |
222 | 0 | case TPM_CC_ContextSave: |
223 | 0 | return Exec_ContextSave(tag, &request_parameter_buffer, |
224 | 0 | request_parameter_buffer_size, request_handles, |
225 | 0 | response_handle_buffer_size, |
226 | 0 | response_parameter_buffer_size); |
227 | 0 | #endif |
228 | 0 | #if IS_CC_ENABLED(Create) |
229 | 0 | case TPM_CC_Create: |
230 | 0 | return Exec_Create(tag, &request_parameter_buffer, |
231 | 0 | request_parameter_buffer_size, request_handles, |
232 | 0 | response_handle_buffer_size, |
233 | 0 | response_parameter_buffer_size); |
234 | 0 | #endif |
235 | 0 | #if IS_CC_ENABLED(CreatePrimary) |
236 | 11 | case TPM_CC_CreatePrimary: |
237 | 11 | return Exec_CreatePrimary(tag, &request_parameter_buffer, |
238 | 11 | request_parameter_buffer_size, request_handles, |
239 | 11 | response_handle_buffer_size, |
240 | 11 | response_parameter_buffer_size); |
241 | 0 | #endif |
242 | 0 | #if IS_CC_ENABLED(DictionaryAttackLockReset) |
243 | 0 | case TPM_CC_DictionaryAttackLockReset: |
244 | 0 | return Exec_DictionaryAttackLockReset( |
245 | 0 | tag, &request_parameter_buffer, request_parameter_buffer_size, |
246 | 0 | request_handles, response_handle_buffer_size, |
247 | 0 | response_parameter_buffer_size); |
248 | 0 | #endif |
249 | 0 | #if IS_CC_ENABLED(DictionaryAttackParameters) |
250 | 0 | case TPM_CC_DictionaryAttackParameters: |
251 | 0 | return Exec_DictionaryAttackParameters( |
252 | 0 | tag, &request_parameter_buffer, request_parameter_buffer_size, |
253 | 0 | request_handles, response_handle_buffer_size, |
254 | 0 | response_parameter_buffer_size); |
255 | 0 | #endif |
256 | 0 | #if IS_CC_ENABLED(Duplicate) |
257 | 0 | case TPM_CC_Duplicate: |
258 | 0 | return Exec_Duplicate(tag, &request_parameter_buffer, |
259 | 0 | request_parameter_buffer_size, request_handles, |
260 | 0 | response_handle_buffer_size, |
261 | 0 | response_parameter_buffer_size); |
262 | 0 | #endif |
263 | 0 | #if IS_CC_ENABLED(ECC_Parameters) |
264 | 0 | case TPM_CC_ECC_Parameters: |
265 | 0 | return Exec_ECC_Parameters(tag, &request_parameter_buffer, |
266 | 0 | request_parameter_buffer_size, request_handles, |
267 | 0 | response_handle_buffer_size, |
268 | 0 | response_parameter_buffer_size); |
269 | 0 | #endif |
270 | 0 | #if IS_CC_ENABLED(ECDH_KeyGen) |
271 | 0 | case TPM_CC_ECDH_KeyGen: |
272 | 0 | return Exec_ECDH_KeyGen(tag, &request_parameter_buffer, |
273 | 0 | request_parameter_buffer_size, request_handles, |
274 | 0 | response_handle_buffer_size, |
275 | 0 | response_parameter_buffer_size); |
276 | 0 | #endif |
277 | 0 | #if IS_CC_ENABLED(ECDH_ZGen) |
278 | 0 | case TPM_CC_ECDH_ZGen: |
279 | 0 | return Exec_ECDH_ZGen(tag, &request_parameter_buffer, |
280 | 0 | request_parameter_buffer_size, request_handles, |
281 | 0 | response_handle_buffer_size, |
282 | 0 | response_parameter_buffer_size); |
283 | 0 | #endif |
284 | | #if IS_CC_ENABLED(EC_Ephemeral) |
285 | | case TPM_CC_EC_Ephemeral: |
286 | | return Exec_EC_Ephemeral(tag, &request_parameter_buffer, |
287 | | request_parameter_buffer_size, request_handles, |
288 | | response_handle_buffer_size, |
289 | | response_parameter_buffer_size); |
290 | | #endif |
291 | | #if IS_CC_ENABLED(EncryptDecrypt) |
292 | | case TPM_CC_EncryptDecrypt: |
293 | | return Exec_EncryptDecrypt(tag, &request_parameter_buffer, |
294 | | request_parameter_buffer_size, request_handles, |
295 | | response_handle_buffer_size, |
296 | | response_parameter_buffer_size); |
297 | | #endif |
298 | | #if IS_CC_ENABLED(EventSequenceComplete) |
299 | | case TPM_CC_EventSequenceComplete: |
300 | | return Exec_EventSequenceComplete( |
301 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
302 | | request_handles, response_handle_buffer_size, |
303 | | response_parameter_buffer_size); |
304 | | #endif |
305 | 0 | #if IS_CC_ENABLED(EvictControl) |
306 | 0 | case TPM_CC_EvictControl: |
307 | 0 | return Exec_EvictControl(tag, &request_parameter_buffer, |
308 | 0 | request_parameter_buffer_size, request_handles, |
309 | 0 | response_handle_buffer_size, |
310 | 0 | response_parameter_buffer_size); |
311 | 0 | #endif |
312 | | #if IS_CC_ENABLED(FieldUpgradeData) |
313 | | case TPM_CC_FieldUpgradeData: |
314 | | return Exec_FieldUpgradeData(tag, &request_parameter_buffer, |
315 | | request_parameter_buffer_size, |
316 | | request_handles, response_handle_buffer_size, |
317 | | response_parameter_buffer_size); |
318 | | #endif |
319 | | #if IS_CC_ENABLED(FieldUpgradeStart) |
320 | | case TPM_CC_FieldUpgradeStart: |
321 | | return Exec_FieldUpgradeStart( |
322 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
323 | | request_handles, response_handle_buffer_size, |
324 | | response_parameter_buffer_size); |
325 | | #endif |
326 | | #if IS_CC_ENABLED(FirmwareRead) |
327 | | case TPM_CC_FirmwareRead: |
328 | | return Exec_FirmwareRead(tag, &request_parameter_buffer, |
329 | | request_parameter_buffer_size, request_handles, |
330 | | response_handle_buffer_size, |
331 | | response_parameter_buffer_size); |
332 | | #endif |
333 | 0 | #if IS_CC_ENABLED(FlushContext) |
334 | 0 | case TPM_CC_FlushContext: |
335 | 0 | return Exec_FlushContext(tag, &request_parameter_buffer, |
336 | 0 | request_parameter_buffer_size, request_handles, |
337 | 0 | response_handle_buffer_size, |
338 | 0 | response_parameter_buffer_size); |
339 | 0 | #endif |
340 | 0 | #if IS_CC_ENABLED(GetCapability) |
341 | 0 | case TPM_CC_GetCapability: |
342 | 0 | return Exec_GetCapability(tag, &request_parameter_buffer, |
343 | 0 | request_parameter_buffer_size, request_handles, |
344 | 0 | response_handle_buffer_size, |
345 | 0 | response_parameter_buffer_size); |
346 | 0 | #endif |
347 | | #if IS_CC_ENABLED(GetCommandAuditDigest) |
348 | | case TPM_CC_GetCommandAuditDigest: |
349 | | return Exec_GetCommandAuditDigest( |
350 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
351 | | request_handles, response_handle_buffer_size, |
352 | | response_parameter_buffer_size); |
353 | | #endif |
354 | 0 | #if IS_CC_ENABLED(GetRandom) |
355 | 3 | case TPM_CC_GetRandom: |
356 | 3 | return Exec_GetRandom(tag, &request_parameter_buffer, |
357 | 3 | request_parameter_buffer_size, request_handles, |
358 | 3 | response_handle_buffer_size, |
359 | 3 | response_parameter_buffer_size); |
360 | 0 | #endif |
361 | | #if IS_CC_ENABLED(GetSessionAuditDigest) |
362 | | case TPM_CC_GetSessionAuditDigest: |
363 | | return Exec_GetSessionAuditDigest( |
364 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
365 | | request_handles, response_handle_buffer_size, |
366 | | response_parameter_buffer_size); |
367 | | #endif |
368 | 0 | #if IS_CC_ENABLED(GetTestResult) |
369 | 0 | case TPM_CC_GetTestResult: |
370 | 0 | return Exec_GetTestResult(tag, &request_parameter_buffer, |
371 | 0 | request_parameter_buffer_size, request_handles, |
372 | 0 | response_handle_buffer_size, |
373 | 0 | response_parameter_buffer_size); |
374 | 0 | #endif |
375 | | #if IS_CC_ENABLED(GetTime) |
376 | | case TPM_CC_GetTime: |
377 | | return Exec_GetTime(tag, &request_parameter_buffer, |
378 | | request_parameter_buffer_size, request_handles, |
379 | | response_handle_buffer_size, |
380 | | response_parameter_buffer_size); |
381 | | #endif |
382 | 0 | #if IS_CC_ENABLED(HMAC) |
383 | 0 | case TPM_CC_HMAC: |
384 | 0 | return Exec_HMAC(tag, &request_parameter_buffer, |
385 | 0 | request_parameter_buffer_size, request_handles, |
386 | 0 | response_handle_buffer_size, |
387 | 0 | response_parameter_buffer_size); |
388 | 0 | #endif |
389 | | #if IS_CC_ENABLED(HMAC_Start) |
390 | | case TPM_CC_HMAC_Start: |
391 | | return Exec_HMAC_Start(tag, &request_parameter_buffer, |
392 | | request_parameter_buffer_size, request_handles, |
393 | | response_handle_buffer_size, |
394 | | response_parameter_buffer_size); |
395 | | #endif |
396 | 0 | #if IS_CC_ENABLED(Hash) |
397 | 9 | case TPM_CC_Hash: |
398 | 9 | return Exec_Hash(tag, &request_parameter_buffer, |
399 | 9 | request_parameter_buffer_size, request_handles, |
400 | 9 | response_handle_buffer_size, |
401 | 9 | response_parameter_buffer_size); |
402 | 0 | #endif |
403 | | #if IS_CC_ENABLED(HashSequenceStart) |
404 | | case TPM_CC_HashSequenceStart: |
405 | | return Exec_HashSequenceStart( |
406 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
407 | | request_handles, response_handle_buffer_size, |
408 | | response_parameter_buffer_size); |
409 | | #endif |
410 | 0 | #if IS_CC_ENABLED(HierarchyChangeAuth) |
411 | 1 | case TPM_CC_HierarchyChangeAuth: |
412 | 1 | return Exec_HierarchyChangeAuth( |
413 | 1 | tag, &request_parameter_buffer, request_parameter_buffer_size, |
414 | 1 | request_handles, response_handle_buffer_size, |
415 | 1 | response_parameter_buffer_size); |
416 | 0 | #endif |
417 | 0 | #if IS_CC_ENABLED(HierarchyControl) |
418 | 1 | case TPM_CC_HierarchyControl: |
419 | 1 | return Exec_HierarchyControl(tag, &request_parameter_buffer, |
420 | 1 | request_parameter_buffer_size, |
421 | 1 | request_handles, response_handle_buffer_size, |
422 | 1 | response_parameter_buffer_size); |
423 | 0 | #endif |
424 | 0 | #if IS_CC_ENABLED(Import) |
425 | 0 | case TPM_CC_Import: |
426 | 0 | return Exec_Import(tag, &request_parameter_buffer, |
427 | 0 | request_parameter_buffer_size, request_handles, |
428 | 0 | response_handle_buffer_size, |
429 | 0 | response_parameter_buffer_size); |
430 | 0 | #endif |
431 | | #if IS_CC_ENABLED(IncrementalSelfTest) |
432 | | case TPM_CC_IncrementalSelfTest: |
433 | | return Exec_IncrementalSelfTest( |
434 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
435 | | request_handles, response_handle_buffer_size, |
436 | | response_parameter_buffer_size); |
437 | | #endif |
438 | 0 | #if IS_CC_ENABLED(Load) |
439 | 0 | case TPM_CC_Load: |
440 | 0 | return Exec_Load(tag, &request_parameter_buffer, |
441 | 0 | request_parameter_buffer_size, request_handles, |
442 | 0 | response_handle_buffer_size, |
443 | 0 | response_parameter_buffer_size); |
444 | 0 | #endif |
445 | 0 | #if IS_CC_ENABLED(LoadExternal) |
446 | 116 | case TPM_CC_LoadExternal: |
447 | 116 | return Exec_LoadExternal(tag, &request_parameter_buffer, |
448 | 116 | request_parameter_buffer_size, request_handles, |
449 | 116 | response_handle_buffer_size, |
450 | 116 | response_parameter_buffer_size); |
451 | 0 | #endif |
452 | | #if IS_CC_ENABLED(MakeCredential) |
453 | | case TPM_CC_MakeCredential: |
454 | | return Exec_MakeCredential(tag, &request_parameter_buffer, |
455 | | request_parameter_buffer_size, request_handles, |
456 | | response_handle_buffer_size, |
457 | | response_parameter_buffer_size); |
458 | | #endif |
459 | 0 | #if IS_CC_ENABLED(NV_Certify) |
460 | 0 | case TPM_CC_NV_Certify: |
461 | 0 | return Exec_NV_Certify(tag, &request_parameter_buffer, |
462 | 0 | request_parameter_buffer_size, request_handles, |
463 | 0 | response_handle_buffer_size, |
464 | 0 | response_parameter_buffer_size); |
465 | 0 | #endif |
466 | | #if IS_CC_ENABLED(NV_ChangeAuth) |
467 | | case TPM_CC_NV_ChangeAuth: |
468 | | return Exec_NV_ChangeAuth(tag, &request_parameter_buffer, |
469 | | request_parameter_buffer_size, request_handles, |
470 | | response_handle_buffer_size, |
471 | | response_parameter_buffer_size); |
472 | | #endif |
473 | 0 | #if IS_CC_ENABLED(NV_DefineSpace) |
474 | 10 | case TPM_CC_NV_DefineSpace: |
475 | 10 | return Exec_NV_DefineSpace(tag, &request_parameter_buffer, |
476 | 10 | request_parameter_buffer_size, request_handles, |
477 | 10 | response_handle_buffer_size, |
478 | 10 | response_parameter_buffer_size); |
479 | 0 | #endif |
480 | 0 | #if IS_CC_ENABLED(NV_Extend) |
481 | 0 | case TPM_CC_NV_Extend: |
482 | 0 | return Exec_NV_Extend(tag, &request_parameter_buffer, |
483 | 0 | request_parameter_buffer_size, request_handles, |
484 | 0 | response_handle_buffer_size, |
485 | 0 | response_parameter_buffer_size); |
486 | 0 | #endif |
487 | | #if IS_CC_ENABLED(NV_GlobalWriteLock) |
488 | | case TPM_CC_NV_GlobalWriteLock: |
489 | | return Exec_NV_GlobalWriteLock( |
490 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
491 | | request_handles, response_handle_buffer_size, |
492 | | response_parameter_buffer_size); |
493 | | #endif |
494 | 0 | #if IS_CC_ENABLED(NV_Increment) |
495 | 0 | case TPM_CC_NV_Increment: |
496 | 0 | return Exec_NV_Increment(tag, &request_parameter_buffer, |
497 | 0 | request_parameter_buffer_size, request_handles, |
498 | 0 | response_handle_buffer_size, |
499 | 0 | response_parameter_buffer_size); |
500 | 0 | #endif |
501 | 0 | #if IS_CC_ENABLED(NV_Read) |
502 | 0 | case TPM_CC_NV_Read: |
503 | 0 | return Exec_NV_Read(tag, &request_parameter_buffer, |
504 | 0 | request_parameter_buffer_size, request_handles, |
505 | 0 | response_handle_buffer_size, |
506 | 0 | response_parameter_buffer_size); |
507 | 0 | #endif |
508 | 0 | #if IS_CC_ENABLED(NV_ReadLock) |
509 | 0 | case TPM_CC_NV_ReadLock: |
510 | 0 | return Exec_NV_ReadLock(tag, &request_parameter_buffer, |
511 | 0 | request_parameter_buffer_size, request_handles, |
512 | 0 | response_handle_buffer_size, |
513 | 0 | response_parameter_buffer_size); |
514 | 0 | #endif |
515 | 0 | #if IS_CC_ENABLED(NV_ReadPublic) |
516 | 0 | case TPM_CC_NV_ReadPublic: |
517 | 0 | return Exec_NV_ReadPublic(tag, &request_parameter_buffer, |
518 | 0 | request_parameter_buffer_size, request_handles, |
519 | 0 | response_handle_buffer_size, |
520 | 0 | response_parameter_buffer_size); |
521 | 0 | #endif |
522 | | #if IS_CC_ENABLED(NV_SetBits) |
523 | | case TPM_CC_NV_SetBits: |
524 | | return Exec_NV_SetBits(tag, &request_parameter_buffer, |
525 | | request_parameter_buffer_size, request_handles, |
526 | | response_handle_buffer_size, |
527 | | response_parameter_buffer_size); |
528 | | #endif |
529 | 0 | #if IS_CC_ENABLED(NV_UndefineSpace) |
530 | 0 | case TPM_CC_NV_UndefineSpace: |
531 | 0 | return Exec_NV_UndefineSpace(tag, &request_parameter_buffer, |
532 | 0 | request_parameter_buffer_size, |
533 | 0 | request_handles, response_handle_buffer_size, |
534 | 0 | response_parameter_buffer_size); |
535 | 0 | #endif |
536 | 0 | #if IS_CC_ENABLED(NV_UndefineSpaceSpecial) |
537 | 0 | case TPM_CC_NV_UndefineSpaceSpecial: |
538 | 0 | return Exec_NV_UndefineSpaceSpecial( |
539 | 0 | tag, &request_parameter_buffer, request_parameter_buffer_size, |
540 | 0 | request_handles, response_handle_buffer_size, |
541 | 0 | response_parameter_buffer_size); |
542 | 0 | #endif |
543 | 0 | #if IS_CC_ENABLED(NV_Write) |
544 | 0 | case TPM_CC_NV_Write: |
545 | 0 | return Exec_NV_Write(tag, &request_parameter_buffer, |
546 | 0 | request_parameter_buffer_size, request_handles, |
547 | 0 | response_handle_buffer_size, |
548 | 0 | response_parameter_buffer_size); |
549 | 0 | #endif |
550 | 0 | #if IS_CC_ENABLED(NV_WriteLock) |
551 | 0 | case TPM_CC_NV_WriteLock: |
552 | 0 | return Exec_NV_WriteLock(tag, &request_parameter_buffer, |
553 | 0 | request_parameter_buffer_size, request_handles, |
554 | 0 | response_handle_buffer_size, |
555 | 0 | response_parameter_buffer_size); |
556 | 0 | #endif |
557 | 0 | #if IS_CC_ENABLED(ObjectChangeAuth) |
558 | 0 | case TPM_CC_ObjectChangeAuth: |
559 | 0 | return Exec_ObjectChangeAuth(tag, &request_parameter_buffer, |
560 | 0 | request_parameter_buffer_size, |
561 | 0 | request_handles, response_handle_buffer_size, |
562 | 0 | response_parameter_buffer_size); |
563 | 0 | #endif |
564 | 0 | #if IS_CC_ENABLED(PCR_Allocate) |
565 | 0 | case TPM_CC_PCR_Allocate: |
566 | 0 | return Exec_PCR_Allocate(tag, &request_parameter_buffer, |
567 | 0 | request_parameter_buffer_size, request_handles, |
568 | 0 | response_handle_buffer_size, |
569 | 0 | response_parameter_buffer_size); |
570 | 0 | #endif |
571 | | #if IS_CC_ENABLED(PCR_Event) |
572 | | case TPM_CC_PCR_Event: |
573 | | return Exec_PCR_Event(tag, &request_parameter_buffer, |
574 | | request_parameter_buffer_size, request_handles, |
575 | | response_handle_buffer_size, |
576 | | response_parameter_buffer_size); |
577 | | #endif |
578 | 0 | #if IS_CC_ENABLED(PCR_Extend) |
579 | 19 | case TPM_CC_PCR_Extend: |
580 | 19 | return Exec_PCR_Extend(tag, &request_parameter_buffer, |
581 | 19 | request_parameter_buffer_size, request_handles, |
582 | 19 | response_handle_buffer_size, |
583 | 19 | response_parameter_buffer_size); |
584 | 0 | #endif |
585 | 0 | #if IS_CC_ENABLED(PCR_Read) |
586 | 1 | case TPM_CC_PCR_Read: |
587 | 1 | return Exec_PCR_Read(tag, &request_parameter_buffer, |
588 | 1 | request_parameter_buffer_size, request_handles, |
589 | 1 | response_handle_buffer_size, |
590 | 1 | response_parameter_buffer_size); |
591 | 0 | #endif |
592 | 0 | #if IS_CC_ENABLED(PCR_Reset) |
593 | 0 | case TPM_CC_PCR_Reset: |
594 | 0 | return Exec_PCR_Reset(tag, &request_parameter_buffer, |
595 | 0 | request_parameter_buffer_size, request_handles, |
596 | 0 | response_handle_buffer_size, |
597 | 0 | response_parameter_buffer_size); |
598 | 0 | #endif |
599 | | #if IS_CC_ENABLED(PCR_SetAuthPolicy) |
600 | | case TPM_CC_PCR_SetAuthPolicy: |
601 | | return Exec_PCR_SetAuthPolicy( |
602 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
603 | | request_handles, response_handle_buffer_size, |
604 | | response_parameter_buffer_size); |
605 | | #endif |
606 | | #if IS_CC_ENABLED(PCR_SetAuthValue) |
607 | | case TPM_CC_PCR_SetAuthValue: |
608 | | return Exec_PCR_SetAuthValue(tag, &request_parameter_buffer, |
609 | | request_parameter_buffer_size, |
610 | | request_handles, response_handle_buffer_size, |
611 | | response_parameter_buffer_size); |
612 | | #endif |
613 | | #if IS_CC_ENABLED(PP_Commands) |
614 | | case TPM_CC_PP_Commands: |
615 | | return Exec_PP_Commands(tag, &request_parameter_buffer, |
616 | | request_parameter_buffer_size, request_handles, |
617 | | response_handle_buffer_size, |
618 | | response_parameter_buffer_size); |
619 | | #endif |
620 | 0 | #if IS_CC_ENABLED(PolicyAuthValue) |
621 | 0 | case TPM_CC_PolicyAuthValue: |
622 | 0 | return Exec_PolicyAuthValue(tag, &request_parameter_buffer, |
623 | 0 | request_parameter_buffer_size, |
624 | 0 | request_handles, response_handle_buffer_size, |
625 | 0 | response_parameter_buffer_size); |
626 | 0 | #endif |
627 | | #if IS_CC_ENABLED(PolicyAuthorize) |
628 | | case TPM_CC_PolicyAuthorize: |
629 | | return Exec_PolicyAuthorize(tag, &request_parameter_buffer, |
630 | | request_parameter_buffer_size, |
631 | | request_handles, response_handle_buffer_size, |
632 | | response_parameter_buffer_size); |
633 | | #endif |
634 | 0 | #if IS_CC_ENABLED(PolicyCommandCode) |
635 | 0 | case TPM_CC_PolicyCommandCode: |
636 | 0 | return Exec_PolicyCommandCode( |
637 | 0 | tag, &request_parameter_buffer, request_parameter_buffer_size, |
638 | 0 | request_handles, response_handle_buffer_size, |
639 | 0 | response_parameter_buffer_size); |
640 | 0 | #endif |
641 | | #if IS_CC_ENABLED(PolicyCounterTimer) |
642 | | case TPM_CC_PolicyCounterTimer: |
643 | | return Exec_PolicyCounterTimer( |
644 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
645 | | request_handles, response_handle_buffer_size, |
646 | | response_parameter_buffer_size); |
647 | | #endif |
648 | | #if IS_CC_ENABLED(PolicyCpHash) |
649 | | case TPM_CC_PolicyCpHash: |
650 | | return Exec_PolicyCpHash(tag, &request_parameter_buffer, |
651 | | request_parameter_buffer_size, request_handles, |
652 | | response_handle_buffer_size, |
653 | | response_parameter_buffer_size); |
654 | | #endif |
655 | | #if IS_CC_ENABLED(PolicyDuplicationSelect) |
656 | | case TPM_CC_PolicyDuplicationSelect: |
657 | | return Exec_PolicyDuplicationSelect( |
658 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
659 | | request_handles, response_handle_buffer_size, |
660 | | response_parameter_buffer_size); |
661 | | #endif |
662 | 0 | #if IS_CC_ENABLED(PolicyGetDigest) |
663 | 0 | case TPM_CC_PolicyGetDigest: |
664 | 0 | return Exec_PolicyGetDigest(tag, &request_parameter_buffer, |
665 | 0 | request_parameter_buffer_size, |
666 | 0 | request_handles, response_handle_buffer_size, |
667 | 0 | response_parameter_buffer_size); |
668 | 0 | #endif |
669 | | #if IS_CC_ENABLED(PolicyLocality) |
670 | | case TPM_CC_PolicyLocality: |
671 | | return Exec_PolicyLocality(tag, &request_parameter_buffer, |
672 | | request_parameter_buffer_size, request_handles, |
673 | | response_handle_buffer_size, |
674 | | response_parameter_buffer_size); |
675 | | #endif |
676 | | #if IS_CC_ENABLED(PolicyNV) |
677 | | case TPM_CC_PolicyNV: |
678 | | return Exec_PolicyNV(tag, &request_parameter_buffer, |
679 | | request_parameter_buffer_size, request_handles, |
680 | | response_handle_buffer_size, |
681 | | response_parameter_buffer_size); |
682 | | #endif |
683 | | #if IS_CC_ENABLED(PolicyNameHash) |
684 | | case TPM_CC_PolicyNameHash: |
685 | | return Exec_PolicyNameHash(tag, &request_parameter_buffer, |
686 | | request_parameter_buffer_size, request_handles, |
687 | | response_handle_buffer_size, |
688 | | response_parameter_buffer_size); |
689 | | #endif |
690 | | #if IS_CC_ENABLED(PolicyNvWritten) |
691 | | case TPM_CC_PolicyNvWritten: |
692 | | return Exec_PolicyNvWritten(tag, &request_parameter_buffer, |
693 | | request_parameter_buffer_size, |
694 | | request_handles, response_handle_buffer_size, |
695 | | response_parameter_buffer_size); |
696 | | #endif |
697 | 0 | #if IS_CC_ENABLED(PolicyOR) |
698 | 0 | case TPM_CC_PolicyOR: |
699 | 0 | return Exec_PolicyOR(tag, &request_parameter_buffer, |
700 | 0 | request_parameter_buffer_size, request_handles, |
701 | 0 | response_handle_buffer_size, |
702 | 0 | response_parameter_buffer_size); |
703 | 0 | #endif |
704 | 0 | #if IS_CC_ENABLED(PolicyPCR) |
705 | 0 | case TPM_CC_PolicyPCR: |
706 | 0 | return Exec_PolicyPCR(tag, &request_parameter_buffer, |
707 | 0 | request_parameter_buffer_size, request_handles, |
708 | 0 | response_handle_buffer_size, |
709 | 0 | response_parameter_buffer_size); |
710 | 0 | #endif |
711 | | #if IS_CC_ENABLED(PolicyPassword) |
712 | | case TPM_CC_PolicyPassword: |
713 | | return Exec_PolicyPassword(tag, &request_parameter_buffer, |
714 | | request_parameter_buffer_size, request_handles, |
715 | | response_handle_buffer_size, |
716 | | response_parameter_buffer_size); |
717 | | #endif |
718 | | #if IS_CC_ENABLED(PolicyPhysicalPresence) |
719 | | case TPM_CC_PolicyPhysicalPresence: |
720 | | return Exec_PolicyPhysicalPresence( |
721 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
722 | | request_handles, response_handle_buffer_size, |
723 | | response_parameter_buffer_size); |
724 | | #endif |
725 | 0 | #if IS_CC_ENABLED(PolicyRestart) |
726 | 0 | case TPM_CC_PolicyRestart: |
727 | 0 | return Exec_PolicyRestart(tag, &request_parameter_buffer, |
728 | 0 | request_parameter_buffer_size, request_handles, |
729 | 0 | response_handle_buffer_size, |
730 | 0 | response_parameter_buffer_size); |
731 | 0 | #endif |
732 | 0 | #if IS_CC_ENABLED(PolicySecret) |
733 | 0 | case TPM_CC_PolicySecret: |
734 | 0 | return Exec_PolicySecret(tag, &request_parameter_buffer, |
735 | 0 | request_parameter_buffer_size, request_handles, |
736 | 0 | response_handle_buffer_size, |
737 | 0 | response_parameter_buffer_size); |
738 | 0 | #endif |
739 | 0 | #if IS_CC_ENABLED(PolicySigned) |
740 | 0 | case TPM_CC_PolicySigned: |
741 | 0 | return Exec_PolicySigned(tag, &request_parameter_buffer, |
742 | 0 | request_parameter_buffer_size, request_handles, |
743 | 0 | response_handle_buffer_size, |
744 | 0 | response_parameter_buffer_size); |
745 | 0 | #endif |
746 | | #if IS_CC_ENABLED(PolicyTicket) |
747 | | case TPM_CC_PolicyTicket: |
748 | | return Exec_PolicyTicket(tag, &request_parameter_buffer, |
749 | | request_parameter_buffer_size, request_handles, |
750 | | response_handle_buffer_size, |
751 | | response_parameter_buffer_size); |
752 | | #endif |
753 | 0 | #if IS_CC_ENABLED(Quote) |
754 | 8 | case TPM_CC_Quote: |
755 | 8 | return Exec_Quote(tag, &request_parameter_buffer, |
756 | 8 | request_parameter_buffer_size, request_handles, |
757 | 8 | response_handle_buffer_size, |
758 | 8 | response_parameter_buffer_size); |
759 | 0 | #endif |
760 | 0 | #if IS_CC_ENABLED(RSA_Decrypt) |
761 | 0 | case TPM_CC_RSA_Decrypt: |
762 | 0 | return Exec_RSA_Decrypt(tag, &request_parameter_buffer, |
763 | 0 | request_parameter_buffer_size, request_handles, |
764 | 0 | response_handle_buffer_size, |
765 | 0 | response_parameter_buffer_size); |
766 | 0 | #endif |
767 | 0 | #if IS_CC_ENABLED(RSA_Encrypt) |
768 | 0 | case TPM_CC_RSA_Encrypt: |
769 | 0 | return Exec_RSA_Encrypt(tag, &request_parameter_buffer, |
770 | 0 | request_parameter_buffer_size, request_handles, |
771 | 0 | response_handle_buffer_size, |
772 | 0 | response_parameter_buffer_size); |
773 | 0 | #endif |
774 | | #if IS_CC_ENABLED(ReadClock) |
775 | | case TPM_CC_ReadClock: |
776 | | return Exec_ReadClock(tag, &request_parameter_buffer, |
777 | | request_parameter_buffer_size, request_handles, |
778 | | response_handle_buffer_size, |
779 | | response_parameter_buffer_size); |
780 | | #endif |
781 | 0 | #if IS_CC_ENABLED(ReadPublic) |
782 | 0 | case TPM_CC_ReadPublic: |
783 | 0 | return Exec_ReadPublic(tag, &request_parameter_buffer, |
784 | 0 | request_parameter_buffer_size, request_handles, |
785 | 0 | response_handle_buffer_size, |
786 | 0 | response_parameter_buffer_size); |
787 | 0 | #endif |
788 | | #if IS_CC_ENABLED(Rewrap) |
789 | | case TPM_CC_Rewrap: |
790 | | return Exec_Rewrap(tag, &request_parameter_buffer, |
791 | | request_parameter_buffer_size, request_handles, |
792 | | response_handle_buffer_size, |
793 | | response_parameter_buffer_size); |
794 | | #endif |
795 | 0 | #if IS_CC_ENABLED(SelfTest) |
796 | 5 | case TPM_CC_SelfTest: |
797 | 5 | return Exec_SelfTest(tag, &request_parameter_buffer, |
798 | 5 | request_parameter_buffer_size, request_handles, |
799 | 5 | response_handle_buffer_size, |
800 | 5 | response_parameter_buffer_size); |
801 | 0 | #endif |
802 | | #if IS_CC_ENABLED(SequenceComplete) |
803 | | case TPM_CC_SequenceComplete: |
804 | | return Exec_SequenceComplete(tag, &request_parameter_buffer, |
805 | | request_parameter_buffer_size, |
806 | | request_handles, response_handle_buffer_size, |
807 | | response_parameter_buffer_size); |
808 | | #endif |
809 | | #if IS_CC_ENABLED(SequenceUpdate) |
810 | | case TPM_CC_SequenceUpdate: |
811 | | return Exec_SequenceUpdate(tag, &request_parameter_buffer, |
812 | | request_parameter_buffer_size, request_handles, |
813 | | response_handle_buffer_size, |
814 | | response_parameter_buffer_size); |
815 | | #endif |
816 | | #if IS_CC_ENABLED(SetAlgorithmSet) |
817 | | case TPM_CC_SetAlgorithmSet: |
818 | | return Exec_SetAlgorithmSet(tag, &request_parameter_buffer, |
819 | | request_parameter_buffer_size, |
820 | | request_handles, response_handle_buffer_size, |
821 | | response_parameter_buffer_size); |
822 | | #endif |
823 | | #if IS_CC_ENABLED(SetCommandCodeAuditStatus) |
824 | | case TPM_CC_SetCommandCodeAuditStatus: |
825 | | return Exec_SetCommandCodeAuditStatus( |
826 | | tag, &request_parameter_buffer, request_parameter_buffer_size, |
827 | | request_handles, response_handle_buffer_size, |
828 | | response_parameter_buffer_size); |
829 | | #endif |
830 | | #if IS_CC_ENABLED(SetPrimaryPolicy) |
831 | | case TPM_CC_SetPrimaryPolicy: |
832 | | return Exec_SetPrimaryPolicy(tag, &request_parameter_buffer, |
833 | | request_parameter_buffer_size, |
834 | | request_handles, response_handle_buffer_size, |
835 | | response_parameter_buffer_size); |
836 | | #endif |
837 | 0 | #if IS_CC_ENABLED(Shutdown) |
838 | 1 | case TPM_CC_Shutdown: |
839 | 1 | return Exec_Shutdown(tag, &request_parameter_buffer, |
840 | 1 | request_parameter_buffer_size, request_handles, |
841 | 1 | response_handle_buffer_size, |
842 | 1 | response_parameter_buffer_size); |
843 | 0 | #endif |
844 | 0 | #if IS_CC_ENABLED(Sign) |
845 | 0 | case TPM_CC_Sign: |
846 | 0 | return Exec_Sign(tag, &request_parameter_buffer, |
847 | 0 | request_parameter_buffer_size, request_handles, |
848 | 0 | response_handle_buffer_size, |
849 | 0 | response_parameter_buffer_size); |
850 | 0 | #endif |
851 | 0 | #if IS_CC_ENABLED(StartAuthSession) |
852 | 2 | case TPM_CC_StartAuthSession: |
853 | 2 | return Exec_StartAuthSession(tag, &request_parameter_buffer, |
854 | 2 | request_parameter_buffer_size, |
855 | 2 | request_handles, response_handle_buffer_size, |
856 | 2 | response_parameter_buffer_size); |
857 | 0 | #endif |
858 | 0 | #if IS_CC_ENABLED(Startup) |
859 | 253 | case TPM_CC_Startup: |
860 | 253 | return Exec_Startup(tag, &request_parameter_buffer, |
861 | 253 | request_parameter_buffer_size, request_handles, |
862 | 253 | response_handle_buffer_size, |
863 | 253 | response_parameter_buffer_size); |
864 | 0 | #endif |
865 | 0 | #if IS_CC_ENABLED(StirRandom) |
866 | 2 | case TPM_CC_StirRandom: |
867 | 2 | return Exec_StirRandom(tag, &request_parameter_buffer, |
868 | 2 | request_parameter_buffer_size, request_handles, |
869 | 2 | response_handle_buffer_size, |
870 | 2 | response_parameter_buffer_size); |
871 | 0 | #endif |
872 | 0 | #if IS_CC_ENABLED(TestParms) |
873 | 3 | case TPM_CC_TestParms: |
874 | 3 | return Exec_TestParms(tag, &request_parameter_buffer, |
875 | 3 | request_parameter_buffer_size, request_handles, |
876 | 3 | response_handle_buffer_size, |
877 | 3 | response_parameter_buffer_size); |
878 | 0 | #endif |
879 | 0 | #if IS_CC_ENABLED(Unseal) |
880 | 0 | case TPM_CC_Unseal: |
881 | 0 | return Exec_Unseal(tag, &request_parameter_buffer, |
882 | 0 | request_parameter_buffer_size, request_handles, |
883 | 0 | response_handle_buffer_size, |
884 | 0 | response_parameter_buffer_size); |
885 | 0 | #endif |
886 | 0 | #if IS_CC_ENABLED(VerifySignature) |
887 | 0 | case TPM_CC_VerifySignature: |
888 | 0 | return Exec_VerifySignature(tag, &request_parameter_buffer, |
889 | 0 | request_parameter_buffer_size, |
890 | 0 | request_handles, response_handle_buffer_size, |
891 | 0 | response_parameter_buffer_size); |
892 | 0 | #endif |
893 | | #if IS_CC_ENABLED(ZGen_2Phase) |
894 | | case TPM_CC_ZGen_2Phase: |
895 | | return Exec_ZGen_2Phase(tag, &request_parameter_buffer, |
896 | | request_parameter_buffer_size, request_handles, |
897 | | response_handle_buffer_size, |
898 | | response_parameter_buffer_size); |
899 | | #endif |
900 | 0 | default: |
901 | 0 | return TPM_RC_COMMAND_CODE; |
902 | 456 | } |
903 | 456 | } |