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 7 #include "tpm_generated.h" 8 #include "HandleProcess_fp.h" 9 #include "Implementation.h" 10 #include "TPM_Types.h" 11 12 TPM_RC ParseHandleBuffer(TPM_CC command_code, 13 BYTE** request_handle_buffer_start, 14 INT32* request_buffer_remaining_size, 15 TPM_HANDLE request_handles[], 16 UINT32* num_request_handles) { 17 TPM_RC result = TPM_RC_SUCCESS; 18 *num_request_handles = 0; 19 switch (command_code) { 20 #ifdef TPM_CC_ActivateCredential 21 case TPM_CC_ActivateCredential: 22 result = TPMI_DH_OBJECT_Unmarshal( 23 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 24 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 25 if (result != TPM_RC_SUCCESS) { 26 return result; 27 } 28 ++(*num_request_handles); 29 result = TPMI_DH_OBJECT_Unmarshal( 30 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 31 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 32 if (result != TPM_RC_SUCCESS) { 33 return result; 34 } 35 ++(*num_request_handles); 36 return TPM_RC_SUCCESS; 37 #endif 38 #ifdef TPM_CC_Certify 39 case TPM_CC_Certify: 40 result = TPMI_DH_OBJECT_Unmarshal( 41 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 42 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 43 if (result != TPM_RC_SUCCESS) { 44 return result; 45 } 46 ++(*num_request_handles); 47 result = TPMI_DH_OBJECT_Unmarshal( 48 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 49 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 50 if (result != TPM_RC_SUCCESS) { 51 return result; 52 } 53 ++(*num_request_handles); 54 return TPM_RC_SUCCESS; 55 #endif 56 #ifdef TPM_CC_CertifyCreation 57 case TPM_CC_CertifyCreation: 58 result = TPMI_DH_OBJECT_Unmarshal( 59 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 60 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 61 if (result != TPM_RC_SUCCESS) { 62 return result; 63 } 64 ++(*num_request_handles); 65 result = TPMI_DH_OBJECT_Unmarshal( 66 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 67 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 68 if (result != TPM_RC_SUCCESS) { 69 return result; 70 } 71 ++(*num_request_handles); 72 return TPM_RC_SUCCESS; 73 #endif 74 #ifdef TPM_CC_ChangeEPS 75 case TPM_CC_ChangeEPS: 76 result = TPMI_RH_PLATFORM_Unmarshal( 77 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 78 request_handle_buffer_start, request_buffer_remaining_size); 79 if (result != TPM_RC_SUCCESS) { 80 return result; 81 } 82 ++(*num_request_handles); 83 return TPM_RC_SUCCESS; 84 #endif 85 #ifdef TPM_CC_ChangePPS 86 case TPM_CC_ChangePPS: 87 result = TPMI_RH_PLATFORM_Unmarshal( 88 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 89 request_handle_buffer_start, request_buffer_remaining_size); 90 if (result != TPM_RC_SUCCESS) { 91 return result; 92 } 93 ++(*num_request_handles); 94 return TPM_RC_SUCCESS; 95 #endif 96 #ifdef TPM_CC_Clear 97 case TPM_CC_Clear: 98 result = TPMI_RH_CLEAR_Unmarshal( 99 (TPMI_RH_CLEAR*)&request_handles[*num_request_handles], 100 request_handle_buffer_start, request_buffer_remaining_size); 101 if (result != TPM_RC_SUCCESS) { 102 return result; 103 } 104 ++(*num_request_handles); 105 return TPM_RC_SUCCESS; 106 #endif 107 #ifdef TPM_CC_ClearControl 108 case TPM_CC_ClearControl: 109 result = TPMI_RH_CLEAR_Unmarshal( 110 (TPMI_RH_CLEAR*)&request_handles[*num_request_handles], 111 request_handle_buffer_start, request_buffer_remaining_size); 112 if (result != TPM_RC_SUCCESS) { 113 return result; 114 } 115 ++(*num_request_handles); 116 return TPM_RC_SUCCESS; 117 #endif 118 #ifdef TPM_CC_ClockRateAdjust 119 case TPM_CC_ClockRateAdjust: 120 result = TPMI_RH_PROVISION_Unmarshal( 121 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 122 request_handle_buffer_start, request_buffer_remaining_size); 123 if (result != TPM_RC_SUCCESS) { 124 return result; 125 } 126 ++(*num_request_handles); 127 return TPM_RC_SUCCESS; 128 #endif 129 #ifdef TPM_CC_ClockSet 130 case TPM_CC_ClockSet: 131 result = TPMI_RH_PROVISION_Unmarshal( 132 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 133 request_handle_buffer_start, request_buffer_remaining_size); 134 if (result != TPM_RC_SUCCESS) { 135 return result; 136 } 137 ++(*num_request_handles); 138 return TPM_RC_SUCCESS; 139 #endif 140 #ifdef TPM_CC_Commit 141 case TPM_CC_Commit: 142 result = TPMI_DH_OBJECT_Unmarshal( 143 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 144 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 145 if (result != TPM_RC_SUCCESS) { 146 return result; 147 } 148 ++(*num_request_handles); 149 return TPM_RC_SUCCESS; 150 #endif 151 #ifdef TPM_CC_ContextLoad 152 case TPM_CC_ContextLoad: 153 return TPM_RC_SUCCESS; 154 #endif 155 #ifdef TPM_CC_ContextSave 156 case TPM_CC_ContextSave: 157 result = TPMI_DH_CONTEXT_Unmarshal( 158 (TPMI_DH_CONTEXT*)&request_handles[*num_request_handles], 159 request_handle_buffer_start, request_buffer_remaining_size); 160 if (result != TPM_RC_SUCCESS) { 161 return result; 162 } 163 ++(*num_request_handles); 164 return TPM_RC_SUCCESS; 165 #endif 166 #ifdef TPM_CC_Create 167 case TPM_CC_Create: 168 result = TPMI_DH_OBJECT_Unmarshal( 169 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 170 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 171 if (result != TPM_RC_SUCCESS) { 172 return result; 173 } 174 ++(*num_request_handles); 175 return TPM_RC_SUCCESS; 176 #endif 177 #ifdef TPM_CC_CreatePrimary 178 case TPM_CC_CreatePrimary: 179 result = TPMI_RH_HIERARCHY_Unmarshal( 180 (TPMI_RH_HIERARCHY*)&request_handles[*num_request_handles], 181 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 182 if (result != TPM_RC_SUCCESS) { 183 return result; 184 } 185 ++(*num_request_handles); 186 return TPM_RC_SUCCESS; 187 #endif 188 #ifdef TPM_CC_DictionaryAttackLockReset 189 case TPM_CC_DictionaryAttackLockReset: 190 result = TPMI_RH_LOCKOUT_Unmarshal( 191 (TPMI_RH_LOCKOUT*)&request_handles[*num_request_handles], 192 request_handle_buffer_start, request_buffer_remaining_size); 193 if (result != TPM_RC_SUCCESS) { 194 return result; 195 } 196 ++(*num_request_handles); 197 return TPM_RC_SUCCESS; 198 #endif 199 #ifdef TPM_CC_DictionaryAttackParameters 200 case TPM_CC_DictionaryAttackParameters: 201 result = TPMI_RH_LOCKOUT_Unmarshal( 202 (TPMI_RH_LOCKOUT*)&request_handles[*num_request_handles], 203 request_handle_buffer_start, request_buffer_remaining_size); 204 if (result != TPM_RC_SUCCESS) { 205 return result; 206 } 207 ++(*num_request_handles); 208 return TPM_RC_SUCCESS; 209 #endif 210 #ifdef TPM_CC_Duplicate 211 case TPM_CC_Duplicate: 212 result = TPMI_DH_OBJECT_Unmarshal( 213 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 214 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 215 if (result != TPM_RC_SUCCESS) { 216 return result; 217 } 218 ++(*num_request_handles); 219 result = TPMI_DH_OBJECT_Unmarshal( 220 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 221 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 222 if (result != TPM_RC_SUCCESS) { 223 return result; 224 } 225 ++(*num_request_handles); 226 return TPM_RC_SUCCESS; 227 #endif 228 #ifdef TPM_CC_ECC_Parameters 229 case TPM_CC_ECC_Parameters: 230 return TPM_RC_SUCCESS; 231 #endif 232 #ifdef TPM_CC_ECDH_KeyGen 233 case TPM_CC_ECDH_KeyGen: 234 result = TPMI_DH_OBJECT_Unmarshal( 235 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 236 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 237 if (result != TPM_RC_SUCCESS) { 238 return result; 239 } 240 ++(*num_request_handles); 241 return TPM_RC_SUCCESS; 242 #endif 243 #ifdef TPM_CC_ECDH_ZGen 244 case TPM_CC_ECDH_ZGen: 245 result = TPMI_DH_OBJECT_Unmarshal( 246 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 247 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 248 if (result != TPM_RC_SUCCESS) { 249 return result; 250 } 251 ++(*num_request_handles); 252 return TPM_RC_SUCCESS; 253 #endif 254 #ifdef TPM_CC_EC_Ephemeral 255 case TPM_CC_EC_Ephemeral: 256 return TPM_RC_SUCCESS; 257 #endif 258 #ifdef TPM_CC_EncryptDecrypt 259 case TPM_CC_EncryptDecrypt: 260 result = TPMI_DH_OBJECT_Unmarshal( 261 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 262 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 263 if (result != TPM_RC_SUCCESS) { 264 return result; 265 } 266 ++(*num_request_handles); 267 return TPM_RC_SUCCESS; 268 #endif 269 #ifdef TPM_CC_EventSequenceComplete 270 case TPM_CC_EventSequenceComplete: 271 result = TPMI_DH_PCR_Unmarshal( 272 (TPMI_DH_PCR*)&request_handles[*num_request_handles], 273 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 274 if (result != TPM_RC_SUCCESS) { 275 return result; 276 } 277 ++(*num_request_handles); 278 result = TPMI_DH_OBJECT_Unmarshal( 279 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 280 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 281 if (result != TPM_RC_SUCCESS) { 282 return result; 283 } 284 ++(*num_request_handles); 285 return TPM_RC_SUCCESS; 286 #endif 287 #ifdef TPM_CC_EvictControl 288 case TPM_CC_EvictControl: 289 result = TPMI_RH_PROVISION_Unmarshal( 290 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 291 request_handle_buffer_start, request_buffer_remaining_size); 292 if (result != TPM_RC_SUCCESS) { 293 return result; 294 } 295 ++(*num_request_handles); 296 result = TPMI_DH_OBJECT_Unmarshal( 297 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 298 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 299 if (result != TPM_RC_SUCCESS) { 300 return result; 301 } 302 ++(*num_request_handles); 303 return TPM_RC_SUCCESS; 304 #endif 305 #ifdef TPM_CC_FieldUpgradeData 306 case TPM_CC_FieldUpgradeData: 307 return TPM_RC_SUCCESS; 308 #endif 309 #ifdef TPM_CC_FieldUpgradeStart 310 case TPM_CC_FieldUpgradeStart: 311 result = TPMI_RH_PLATFORM_Unmarshal( 312 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 313 request_handle_buffer_start, request_buffer_remaining_size); 314 if (result != TPM_RC_SUCCESS) { 315 return result; 316 } 317 ++(*num_request_handles); 318 result = TPMI_DH_OBJECT_Unmarshal( 319 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 320 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 321 if (result != TPM_RC_SUCCESS) { 322 return result; 323 } 324 ++(*num_request_handles); 325 return TPM_RC_SUCCESS; 326 #endif 327 #ifdef TPM_CC_FirmwareRead 328 case TPM_CC_FirmwareRead: 329 return TPM_RC_SUCCESS; 330 #endif 331 #ifdef TPM_CC_FlushContext 332 case TPM_CC_FlushContext: 333 return TPM_RC_SUCCESS; 334 #endif 335 #ifdef TPM_CC_GetCapability 336 case TPM_CC_GetCapability: 337 return TPM_RC_SUCCESS; 338 #endif 339 #ifdef TPM_CC_GetCommandAuditDigest 340 case TPM_CC_GetCommandAuditDigest: 341 result = TPMI_RH_ENDORSEMENT_Unmarshal( 342 (TPMI_RH_ENDORSEMENT*)&request_handles[*num_request_handles], 343 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 344 if (result != TPM_RC_SUCCESS) { 345 return result; 346 } 347 ++(*num_request_handles); 348 result = TPMI_DH_OBJECT_Unmarshal( 349 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 350 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 351 if (result != TPM_RC_SUCCESS) { 352 return result; 353 } 354 ++(*num_request_handles); 355 return TPM_RC_SUCCESS; 356 #endif 357 #ifdef TPM_CC_GetRandom 358 case TPM_CC_GetRandom: 359 return TPM_RC_SUCCESS; 360 #endif 361 #ifdef TPM_CC_GetSessionAuditDigest 362 case TPM_CC_GetSessionAuditDigest: 363 result = TPMI_RH_ENDORSEMENT_Unmarshal( 364 (TPMI_RH_ENDORSEMENT*)&request_handles[*num_request_handles], 365 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 366 if (result != TPM_RC_SUCCESS) { 367 return result; 368 } 369 ++(*num_request_handles); 370 result = TPMI_DH_OBJECT_Unmarshal( 371 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 372 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 373 if (result != TPM_RC_SUCCESS) { 374 return result; 375 } 376 ++(*num_request_handles); 377 result = TPMI_SH_HMAC_Unmarshal( 378 (TPMI_SH_HMAC*)&request_handles[*num_request_handles], 379 request_handle_buffer_start, request_buffer_remaining_size); 380 if (result != TPM_RC_SUCCESS) { 381 return result; 382 } 383 ++(*num_request_handles); 384 return TPM_RC_SUCCESS; 385 #endif 386 #ifdef TPM_CC_GetTestResult 387 case TPM_CC_GetTestResult: 388 return TPM_RC_SUCCESS; 389 #endif 390 #ifdef TPM_CC_GetTime 391 case TPM_CC_GetTime: 392 result = TPMI_RH_ENDORSEMENT_Unmarshal( 393 (TPMI_RH_ENDORSEMENT*)&request_handles[*num_request_handles], 394 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 395 if (result != TPM_RC_SUCCESS) { 396 return result; 397 } 398 ++(*num_request_handles); 399 result = TPMI_DH_OBJECT_Unmarshal( 400 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 401 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 402 if (result != TPM_RC_SUCCESS) { 403 return result; 404 } 405 ++(*num_request_handles); 406 return TPM_RC_SUCCESS; 407 #endif 408 #ifdef TPM_CC_HMAC 409 case TPM_CC_HMAC: 410 result = TPMI_DH_OBJECT_Unmarshal( 411 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 412 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 413 if (result != TPM_RC_SUCCESS) { 414 return result; 415 } 416 ++(*num_request_handles); 417 return TPM_RC_SUCCESS; 418 #endif 419 #ifdef TPM_CC_HMAC_Start 420 case TPM_CC_HMAC_Start: 421 result = TPMI_DH_OBJECT_Unmarshal( 422 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 423 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 424 if (result != TPM_RC_SUCCESS) { 425 return result; 426 } 427 ++(*num_request_handles); 428 return TPM_RC_SUCCESS; 429 #endif 430 #ifdef TPM_CC_Hash 431 case TPM_CC_Hash: 432 return TPM_RC_SUCCESS; 433 #endif 434 #ifdef TPM_CC_HashSequenceStart 435 case TPM_CC_HashSequenceStart: 436 return TPM_RC_SUCCESS; 437 #endif 438 #ifdef TPM_CC_HierarchyChangeAuth 439 case TPM_CC_HierarchyChangeAuth: 440 result = TPMI_RH_HIERARCHY_AUTH_Unmarshal( 441 (TPMI_RH_HIERARCHY_AUTH*)&request_handles[*num_request_handles], 442 request_handle_buffer_start, request_buffer_remaining_size); 443 if (result != TPM_RC_SUCCESS) { 444 return result; 445 } 446 ++(*num_request_handles); 447 return TPM_RC_SUCCESS; 448 #endif 449 #ifdef TPM_CC_HierarchyControl 450 case TPM_CC_HierarchyControl: 451 result = TPMI_RH_HIERARCHY_Unmarshal( 452 (TPMI_RH_HIERARCHY*)&request_handles[*num_request_handles], 453 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 454 if (result != TPM_RC_SUCCESS) { 455 return result; 456 } 457 ++(*num_request_handles); 458 return TPM_RC_SUCCESS; 459 #endif 460 #ifdef TPM_CC_Import 461 case TPM_CC_Import: 462 result = TPMI_DH_OBJECT_Unmarshal( 463 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 464 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 465 if (result != TPM_RC_SUCCESS) { 466 return result; 467 } 468 ++(*num_request_handles); 469 return TPM_RC_SUCCESS; 470 #endif 471 #ifdef TPM_CC_IncrementalSelfTest 472 case TPM_CC_IncrementalSelfTest: 473 return TPM_RC_SUCCESS; 474 #endif 475 #ifdef TPM_CC_Load 476 case TPM_CC_Load: 477 result = TPMI_DH_OBJECT_Unmarshal( 478 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 479 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 480 if (result != TPM_RC_SUCCESS) { 481 return result; 482 } 483 ++(*num_request_handles); 484 return TPM_RC_SUCCESS; 485 #endif 486 #ifdef TPM_CC_LoadExternal 487 case TPM_CC_LoadExternal: 488 return TPM_RC_SUCCESS; 489 #endif 490 #ifdef TPM_CC_MakeCredential 491 case TPM_CC_MakeCredential: 492 result = TPMI_DH_OBJECT_Unmarshal( 493 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 494 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 495 if (result != TPM_RC_SUCCESS) { 496 return result; 497 } 498 ++(*num_request_handles); 499 return TPM_RC_SUCCESS; 500 #endif 501 #ifdef TPM_CC_NV_Certify 502 case TPM_CC_NV_Certify: 503 result = TPMI_DH_OBJECT_Unmarshal( 504 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 505 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 506 if (result != TPM_RC_SUCCESS) { 507 return result; 508 } 509 ++(*num_request_handles); 510 result = TPMI_RH_NV_AUTH_Unmarshal( 511 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 512 request_handle_buffer_start, request_buffer_remaining_size); 513 if (result != TPM_RC_SUCCESS) { 514 return result; 515 } 516 ++(*num_request_handles); 517 result = TPMI_RH_NV_INDEX_Unmarshal( 518 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 519 request_handle_buffer_start, request_buffer_remaining_size); 520 if (result != TPM_RC_SUCCESS) { 521 return result; 522 } 523 ++(*num_request_handles); 524 return TPM_RC_SUCCESS; 525 #endif 526 #ifdef TPM_CC_NV_ChangeAuth 527 case TPM_CC_NV_ChangeAuth: 528 result = TPMI_RH_NV_INDEX_Unmarshal( 529 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 530 request_handle_buffer_start, request_buffer_remaining_size); 531 if (result != TPM_RC_SUCCESS) { 532 return result; 533 } 534 ++(*num_request_handles); 535 return TPM_RC_SUCCESS; 536 #endif 537 #ifdef TPM_CC_NV_DefineSpace 538 case TPM_CC_NV_DefineSpace: 539 result = TPMI_RH_PROVISION_Unmarshal( 540 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 541 request_handle_buffer_start, request_buffer_remaining_size); 542 if (result != TPM_RC_SUCCESS) { 543 return result; 544 } 545 ++(*num_request_handles); 546 return TPM_RC_SUCCESS; 547 #endif 548 #ifdef TPM_CC_NV_Extend 549 case TPM_CC_NV_Extend: 550 result = TPMI_RH_NV_AUTH_Unmarshal( 551 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 552 request_handle_buffer_start, request_buffer_remaining_size); 553 if (result != TPM_RC_SUCCESS) { 554 return result; 555 } 556 ++(*num_request_handles); 557 result = TPMI_RH_NV_INDEX_Unmarshal( 558 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 559 request_handle_buffer_start, request_buffer_remaining_size); 560 if (result != TPM_RC_SUCCESS) { 561 return result; 562 } 563 ++(*num_request_handles); 564 return TPM_RC_SUCCESS; 565 #endif 566 #ifdef TPM_CC_NV_GlobalWriteLock 567 case TPM_CC_NV_GlobalWriteLock: 568 result = TPMI_RH_PROVISION_Unmarshal( 569 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 570 request_handle_buffer_start, request_buffer_remaining_size); 571 if (result != TPM_RC_SUCCESS) { 572 return result; 573 } 574 ++(*num_request_handles); 575 return TPM_RC_SUCCESS; 576 #endif 577 #ifdef TPM_CC_NV_Increment 578 case TPM_CC_NV_Increment: 579 result = TPMI_RH_NV_AUTH_Unmarshal( 580 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 581 request_handle_buffer_start, request_buffer_remaining_size); 582 if (result != TPM_RC_SUCCESS) { 583 return result; 584 } 585 ++(*num_request_handles); 586 result = TPMI_RH_NV_INDEX_Unmarshal( 587 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 588 request_handle_buffer_start, request_buffer_remaining_size); 589 if (result != TPM_RC_SUCCESS) { 590 return result; 591 } 592 ++(*num_request_handles); 593 return TPM_RC_SUCCESS; 594 #endif 595 #ifdef TPM_CC_NV_Read 596 case TPM_CC_NV_Read: 597 result = TPMI_RH_NV_AUTH_Unmarshal( 598 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 599 request_handle_buffer_start, request_buffer_remaining_size); 600 if (result != TPM_RC_SUCCESS) { 601 return result; 602 } 603 ++(*num_request_handles); 604 result = TPMI_RH_NV_INDEX_Unmarshal( 605 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 606 request_handle_buffer_start, request_buffer_remaining_size); 607 if (result != TPM_RC_SUCCESS) { 608 return result; 609 } 610 ++(*num_request_handles); 611 return TPM_RC_SUCCESS; 612 #endif 613 #ifdef TPM_CC_NV_ReadLock 614 case TPM_CC_NV_ReadLock: 615 result = TPMI_RH_NV_AUTH_Unmarshal( 616 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 617 request_handle_buffer_start, request_buffer_remaining_size); 618 if (result != TPM_RC_SUCCESS) { 619 return result; 620 } 621 ++(*num_request_handles); 622 result = TPMI_RH_NV_INDEX_Unmarshal( 623 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 624 request_handle_buffer_start, request_buffer_remaining_size); 625 if (result != TPM_RC_SUCCESS) { 626 return result; 627 } 628 ++(*num_request_handles); 629 return TPM_RC_SUCCESS; 630 #endif 631 #ifdef TPM_CC_NV_ReadPublic 632 case TPM_CC_NV_ReadPublic: 633 result = TPMI_RH_NV_INDEX_Unmarshal( 634 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 635 request_handle_buffer_start, request_buffer_remaining_size); 636 if (result != TPM_RC_SUCCESS) { 637 return result; 638 } 639 ++(*num_request_handles); 640 return TPM_RC_SUCCESS; 641 #endif 642 #ifdef TPM_CC_NV_SetBits 643 case TPM_CC_NV_SetBits: 644 result = TPMI_RH_NV_AUTH_Unmarshal( 645 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 646 request_handle_buffer_start, request_buffer_remaining_size); 647 if (result != TPM_RC_SUCCESS) { 648 return result; 649 } 650 ++(*num_request_handles); 651 result = TPMI_RH_NV_INDEX_Unmarshal( 652 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 653 request_handle_buffer_start, request_buffer_remaining_size); 654 if (result != TPM_RC_SUCCESS) { 655 return result; 656 } 657 ++(*num_request_handles); 658 return TPM_RC_SUCCESS; 659 #endif 660 #ifdef TPM_CC_NV_UndefineSpace 661 case TPM_CC_NV_UndefineSpace: 662 result = TPMI_RH_PROVISION_Unmarshal( 663 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 664 request_handle_buffer_start, request_buffer_remaining_size); 665 if (result != TPM_RC_SUCCESS) { 666 return result; 667 } 668 ++(*num_request_handles); 669 result = TPMI_RH_NV_INDEX_Unmarshal( 670 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 671 request_handle_buffer_start, request_buffer_remaining_size); 672 if (result != TPM_RC_SUCCESS) { 673 return result; 674 } 675 ++(*num_request_handles); 676 return TPM_RC_SUCCESS; 677 #endif 678 #ifdef TPM_CC_NV_UndefineSpaceSpecial 679 case TPM_CC_NV_UndefineSpaceSpecial: 680 result = TPMI_RH_NV_INDEX_Unmarshal( 681 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 682 request_handle_buffer_start, request_buffer_remaining_size); 683 if (result != TPM_RC_SUCCESS) { 684 return result; 685 } 686 ++(*num_request_handles); 687 result = TPMI_RH_PLATFORM_Unmarshal( 688 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 689 request_handle_buffer_start, request_buffer_remaining_size); 690 if (result != TPM_RC_SUCCESS) { 691 return result; 692 } 693 ++(*num_request_handles); 694 return TPM_RC_SUCCESS; 695 #endif 696 #ifdef TPM_CC_NV_Write 697 case TPM_CC_NV_Write: 698 result = TPMI_RH_NV_AUTH_Unmarshal( 699 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 700 request_handle_buffer_start, request_buffer_remaining_size); 701 if (result != TPM_RC_SUCCESS) { 702 return result; 703 } 704 ++(*num_request_handles); 705 result = TPMI_RH_NV_INDEX_Unmarshal( 706 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 707 request_handle_buffer_start, request_buffer_remaining_size); 708 if (result != TPM_RC_SUCCESS) { 709 return result; 710 } 711 ++(*num_request_handles); 712 return TPM_RC_SUCCESS; 713 #endif 714 #ifdef TPM_CC_NV_WriteLock 715 case TPM_CC_NV_WriteLock: 716 result = TPMI_RH_NV_AUTH_Unmarshal( 717 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 718 request_handle_buffer_start, request_buffer_remaining_size); 719 if (result != TPM_RC_SUCCESS) { 720 return result; 721 } 722 ++(*num_request_handles); 723 result = TPMI_RH_NV_INDEX_Unmarshal( 724 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 725 request_handle_buffer_start, request_buffer_remaining_size); 726 if (result != TPM_RC_SUCCESS) { 727 return result; 728 } 729 ++(*num_request_handles); 730 return TPM_RC_SUCCESS; 731 #endif 732 #ifdef TPM_CC_ObjectChangeAuth 733 case TPM_CC_ObjectChangeAuth: 734 result = TPMI_DH_OBJECT_Unmarshal( 735 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 736 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 737 if (result != TPM_RC_SUCCESS) { 738 return result; 739 } 740 ++(*num_request_handles); 741 result = TPMI_DH_OBJECT_Unmarshal( 742 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 743 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 744 if (result != TPM_RC_SUCCESS) { 745 return result; 746 } 747 ++(*num_request_handles); 748 return TPM_RC_SUCCESS; 749 #endif 750 #ifdef TPM_CC_PCR_Allocate 751 case TPM_CC_PCR_Allocate: 752 result = TPMI_RH_PLATFORM_Unmarshal( 753 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 754 request_handle_buffer_start, request_buffer_remaining_size); 755 if (result != TPM_RC_SUCCESS) { 756 return result; 757 } 758 ++(*num_request_handles); 759 return TPM_RC_SUCCESS; 760 #endif 761 #ifdef TPM_CC_PCR_Event 762 case TPM_CC_PCR_Event: 763 result = TPMI_DH_PCR_Unmarshal( 764 (TPMI_DH_PCR*)&request_handles[*num_request_handles], 765 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 766 if (result != TPM_RC_SUCCESS) { 767 return result; 768 } 769 ++(*num_request_handles); 770 return TPM_RC_SUCCESS; 771 #endif 772 #ifdef TPM_CC_PCR_Extend 773 case TPM_CC_PCR_Extend: 774 result = TPMI_DH_PCR_Unmarshal( 775 (TPMI_DH_PCR*)&request_handles[*num_request_handles], 776 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 777 if (result != TPM_RC_SUCCESS) { 778 return result; 779 } 780 ++(*num_request_handles); 781 return TPM_RC_SUCCESS; 782 #endif 783 #ifdef TPM_CC_PCR_Read 784 case TPM_CC_PCR_Read: 785 return TPM_RC_SUCCESS; 786 #endif 787 #ifdef TPM_CC_PCR_Reset 788 case TPM_CC_PCR_Reset: 789 result = TPMI_DH_PCR_Unmarshal( 790 (TPMI_DH_PCR*)&request_handles[*num_request_handles], 791 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 792 if (result != TPM_RC_SUCCESS) { 793 return result; 794 } 795 ++(*num_request_handles); 796 return TPM_RC_SUCCESS; 797 #endif 798 #ifdef TPM_CC_PCR_SetAuthPolicy 799 case TPM_CC_PCR_SetAuthPolicy: 800 result = TPMI_RH_PLATFORM_Unmarshal( 801 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 802 request_handle_buffer_start, request_buffer_remaining_size); 803 if (result != TPM_RC_SUCCESS) { 804 return result; 805 } 806 ++(*num_request_handles); 807 result = TPMI_DH_PCR_Unmarshal( 808 (TPMI_DH_PCR*)&request_handles[*num_request_handles], 809 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 810 if (result != TPM_RC_SUCCESS) { 811 return result; 812 } 813 ++(*num_request_handles); 814 return TPM_RC_SUCCESS; 815 #endif 816 #ifdef TPM_CC_PCR_SetAuthValue 817 case TPM_CC_PCR_SetAuthValue: 818 result = TPMI_DH_PCR_Unmarshal( 819 (TPMI_DH_PCR*)&request_handles[*num_request_handles], 820 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 821 if (result != TPM_RC_SUCCESS) { 822 return result; 823 } 824 ++(*num_request_handles); 825 return TPM_RC_SUCCESS; 826 #endif 827 #ifdef TPM_CC_PP_Commands 828 case TPM_CC_PP_Commands: 829 result = TPMI_RH_PLATFORM_Unmarshal( 830 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 831 request_handle_buffer_start, request_buffer_remaining_size); 832 if (result != TPM_RC_SUCCESS) { 833 return result; 834 } 835 ++(*num_request_handles); 836 return TPM_RC_SUCCESS; 837 #endif 838 #ifdef TPM_CC_PolicyAuthValue 839 case TPM_CC_PolicyAuthValue: 840 result = TPMI_SH_POLICY_Unmarshal( 841 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 842 request_handle_buffer_start, request_buffer_remaining_size); 843 if (result != TPM_RC_SUCCESS) { 844 return result; 845 } 846 ++(*num_request_handles); 847 return TPM_RC_SUCCESS; 848 #endif 849 #ifdef TPM_CC_PolicyAuthorize 850 case TPM_CC_PolicyAuthorize: 851 result = TPMI_SH_POLICY_Unmarshal( 852 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 853 request_handle_buffer_start, request_buffer_remaining_size); 854 if (result != TPM_RC_SUCCESS) { 855 return result; 856 } 857 ++(*num_request_handles); 858 return TPM_RC_SUCCESS; 859 #endif 860 #ifdef TPM_CC_PolicyCommandCode 861 case TPM_CC_PolicyCommandCode: 862 result = TPMI_SH_POLICY_Unmarshal( 863 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 864 request_handle_buffer_start, request_buffer_remaining_size); 865 if (result != TPM_RC_SUCCESS) { 866 return result; 867 } 868 ++(*num_request_handles); 869 return TPM_RC_SUCCESS; 870 #endif 871 #ifdef TPM_CC_PolicyCounterTimer 872 case TPM_CC_PolicyCounterTimer: 873 result = TPMI_SH_POLICY_Unmarshal( 874 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 875 request_handle_buffer_start, request_buffer_remaining_size); 876 if (result != TPM_RC_SUCCESS) { 877 return result; 878 } 879 ++(*num_request_handles); 880 return TPM_RC_SUCCESS; 881 #endif 882 #ifdef TPM_CC_PolicyCpHash 883 case TPM_CC_PolicyCpHash: 884 result = TPMI_SH_POLICY_Unmarshal( 885 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 886 request_handle_buffer_start, request_buffer_remaining_size); 887 if (result != TPM_RC_SUCCESS) { 888 return result; 889 } 890 ++(*num_request_handles); 891 return TPM_RC_SUCCESS; 892 #endif 893 #ifdef TPM_CC_PolicyDuplicationSelect 894 case TPM_CC_PolicyDuplicationSelect: 895 result = TPMI_SH_POLICY_Unmarshal( 896 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 897 request_handle_buffer_start, request_buffer_remaining_size); 898 if (result != TPM_RC_SUCCESS) { 899 return result; 900 } 901 ++(*num_request_handles); 902 return TPM_RC_SUCCESS; 903 #endif 904 #ifdef TPM_CC_PolicyGetDigest 905 case TPM_CC_PolicyGetDigest: 906 result = TPMI_SH_POLICY_Unmarshal( 907 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 908 request_handle_buffer_start, request_buffer_remaining_size); 909 if (result != TPM_RC_SUCCESS) { 910 return result; 911 } 912 ++(*num_request_handles); 913 return TPM_RC_SUCCESS; 914 #endif 915 #ifdef TPM_CC_PolicyLocality 916 case TPM_CC_PolicyLocality: 917 result = TPMI_SH_POLICY_Unmarshal( 918 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 919 request_handle_buffer_start, request_buffer_remaining_size); 920 if (result != TPM_RC_SUCCESS) { 921 return result; 922 } 923 ++(*num_request_handles); 924 return TPM_RC_SUCCESS; 925 #endif 926 #ifdef TPM_CC_PolicyNV 927 case TPM_CC_PolicyNV: 928 result = TPMI_RH_NV_AUTH_Unmarshal( 929 (TPMI_RH_NV_AUTH*)&request_handles[*num_request_handles], 930 request_handle_buffer_start, request_buffer_remaining_size); 931 if (result != TPM_RC_SUCCESS) { 932 return result; 933 } 934 ++(*num_request_handles); 935 result = TPMI_RH_NV_INDEX_Unmarshal( 936 (TPMI_RH_NV_INDEX*)&request_handles[*num_request_handles], 937 request_handle_buffer_start, request_buffer_remaining_size); 938 if (result != TPM_RC_SUCCESS) { 939 return result; 940 } 941 ++(*num_request_handles); 942 result = TPMI_SH_POLICY_Unmarshal( 943 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 944 request_handle_buffer_start, request_buffer_remaining_size); 945 if (result != TPM_RC_SUCCESS) { 946 return result; 947 } 948 ++(*num_request_handles); 949 return TPM_RC_SUCCESS; 950 #endif 951 #ifdef TPM_CC_PolicyNameHash 952 case TPM_CC_PolicyNameHash: 953 result = TPMI_SH_POLICY_Unmarshal( 954 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 955 request_handle_buffer_start, request_buffer_remaining_size); 956 if (result != TPM_RC_SUCCESS) { 957 return result; 958 } 959 ++(*num_request_handles); 960 return TPM_RC_SUCCESS; 961 #endif 962 #ifdef TPM_CC_PolicyNvWritten 963 case TPM_CC_PolicyNvWritten: 964 result = TPMI_SH_POLICY_Unmarshal( 965 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 966 request_handle_buffer_start, request_buffer_remaining_size); 967 if (result != TPM_RC_SUCCESS) { 968 return result; 969 } 970 ++(*num_request_handles); 971 return TPM_RC_SUCCESS; 972 #endif 973 #ifdef TPM_CC_PolicyOR 974 case TPM_CC_PolicyOR: 975 result = TPMI_SH_POLICY_Unmarshal( 976 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 977 request_handle_buffer_start, request_buffer_remaining_size); 978 if (result != TPM_RC_SUCCESS) { 979 return result; 980 } 981 ++(*num_request_handles); 982 return TPM_RC_SUCCESS; 983 #endif 984 #ifdef TPM_CC_PolicyPCR 985 case TPM_CC_PolicyPCR: 986 result = TPMI_SH_POLICY_Unmarshal( 987 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 988 request_handle_buffer_start, request_buffer_remaining_size); 989 if (result != TPM_RC_SUCCESS) { 990 return result; 991 } 992 ++(*num_request_handles); 993 return TPM_RC_SUCCESS; 994 #endif 995 #ifdef TPM_CC_PolicyPassword 996 case TPM_CC_PolicyPassword: 997 result = TPMI_SH_POLICY_Unmarshal( 998 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 999 request_handle_buffer_start, request_buffer_remaining_size); 1000 if (result != TPM_RC_SUCCESS) { 1001 return result; 1002 } 1003 ++(*num_request_handles); 1004 return TPM_RC_SUCCESS; 1005 #endif 1006 #ifdef TPM_CC_PolicyPhysicalPresence 1007 case TPM_CC_PolicyPhysicalPresence: 1008 result = TPMI_SH_POLICY_Unmarshal( 1009 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 1010 request_handle_buffer_start, request_buffer_remaining_size); 1011 if (result != TPM_RC_SUCCESS) { 1012 return result; 1013 } 1014 ++(*num_request_handles); 1015 return TPM_RC_SUCCESS; 1016 #endif 1017 #ifdef TPM_CC_PolicyRestart 1018 case TPM_CC_PolicyRestart: 1019 result = TPMI_SH_POLICY_Unmarshal( 1020 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 1021 request_handle_buffer_start, request_buffer_remaining_size); 1022 if (result != TPM_RC_SUCCESS) { 1023 return result; 1024 } 1025 ++(*num_request_handles); 1026 return TPM_RC_SUCCESS; 1027 #endif 1028 #ifdef TPM_CC_PolicySecret 1029 case TPM_CC_PolicySecret: 1030 result = TPMI_DH_ENTITY_Unmarshal( 1031 (TPMI_DH_ENTITY*)&request_handles[*num_request_handles], 1032 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1033 if (result != TPM_RC_SUCCESS) { 1034 return result; 1035 } 1036 ++(*num_request_handles); 1037 result = TPMI_SH_POLICY_Unmarshal( 1038 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 1039 request_handle_buffer_start, request_buffer_remaining_size); 1040 if (result != TPM_RC_SUCCESS) { 1041 return result; 1042 } 1043 ++(*num_request_handles); 1044 return TPM_RC_SUCCESS; 1045 #endif 1046 #ifdef TPM_CC_PolicySigned 1047 case TPM_CC_PolicySigned: 1048 result = TPMI_DH_OBJECT_Unmarshal( 1049 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1050 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1051 if (result != TPM_RC_SUCCESS) { 1052 return result; 1053 } 1054 ++(*num_request_handles); 1055 result = TPMI_SH_POLICY_Unmarshal( 1056 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 1057 request_handle_buffer_start, request_buffer_remaining_size); 1058 if (result != TPM_RC_SUCCESS) { 1059 return result; 1060 } 1061 ++(*num_request_handles); 1062 return TPM_RC_SUCCESS; 1063 #endif 1064 #ifdef TPM_CC_PolicyTicket 1065 case TPM_CC_PolicyTicket: 1066 result = TPMI_SH_POLICY_Unmarshal( 1067 (TPMI_SH_POLICY*)&request_handles[*num_request_handles], 1068 request_handle_buffer_start, request_buffer_remaining_size); 1069 if (result != TPM_RC_SUCCESS) { 1070 return result; 1071 } 1072 ++(*num_request_handles); 1073 return TPM_RC_SUCCESS; 1074 #endif 1075 #ifdef TPM_CC_Quote 1076 case TPM_CC_Quote: 1077 result = TPMI_DH_OBJECT_Unmarshal( 1078 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1079 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 1080 if (result != TPM_RC_SUCCESS) { 1081 return result; 1082 } 1083 ++(*num_request_handles); 1084 return TPM_RC_SUCCESS; 1085 #endif 1086 #ifdef TPM_CC_RSA_Decrypt 1087 case TPM_CC_RSA_Decrypt: 1088 result = TPMI_DH_OBJECT_Unmarshal( 1089 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1090 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1091 if (result != TPM_RC_SUCCESS) { 1092 return result; 1093 } 1094 ++(*num_request_handles); 1095 return TPM_RC_SUCCESS; 1096 #endif 1097 #ifdef TPM_CC_RSA_Encrypt 1098 case TPM_CC_RSA_Encrypt: 1099 result = TPMI_DH_OBJECT_Unmarshal( 1100 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1101 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1102 if (result != TPM_RC_SUCCESS) { 1103 return result; 1104 } 1105 ++(*num_request_handles); 1106 return TPM_RC_SUCCESS; 1107 #endif 1108 #ifdef TPM_CC_ReadClock 1109 case TPM_CC_ReadClock: 1110 return TPM_RC_SUCCESS; 1111 #endif 1112 #ifdef TPM_CC_ReadPublic 1113 case TPM_CC_ReadPublic: 1114 result = TPMI_DH_OBJECT_Unmarshal( 1115 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1116 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1117 if (result != TPM_RC_SUCCESS) { 1118 return result; 1119 } 1120 ++(*num_request_handles); 1121 return TPM_RC_SUCCESS; 1122 #endif 1123 #ifdef TPM_CC_Rewrap 1124 case TPM_CC_Rewrap: 1125 result = TPMI_DH_OBJECT_Unmarshal( 1126 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1127 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 1128 if (result != TPM_RC_SUCCESS) { 1129 return result; 1130 } 1131 ++(*num_request_handles); 1132 result = TPMI_DH_OBJECT_Unmarshal( 1133 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1134 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 1135 if (result != TPM_RC_SUCCESS) { 1136 return result; 1137 } 1138 ++(*num_request_handles); 1139 return TPM_RC_SUCCESS; 1140 #endif 1141 #ifdef TPM_CC_SelfTest 1142 case TPM_CC_SelfTest: 1143 return TPM_RC_SUCCESS; 1144 #endif 1145 #ifdef TPM_CC_SequenceComplete 1146 case TPM_CC_SequenceComplete: 1147 result = TPMI_DH_OBJECT_Unmarshal( 1148 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1149 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1150 if (result != TPM_RC_SUCCESS) { 1151 return result; 1152 } 1153 ++(*num_request_handles); 1154 return TPM_RC_SUCCESS; 1155 #endif 1156 #ifdef TPM_CC_SequenceUpdate 1157 case TPM_CC_SequenceUpdate: 1158 result = TPMI_DH_OBJECT_Unmarshal( 1159 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1160 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1161 if (result != TPM_RC_SUCCESS) { 1162 return result; 1163 } 1164 ++(*num_request_handles); 1165 return TPM_RC_SUCCESS; 1166 #endif 1167 #ifdef TPM_CC_SetAlgorithmSet 1168 case TPM_CC_SetAlgorithmSet: 1169 result = TPMI_RH_PLATFORM_Unmarshal( 1170 (TPMI_RH_PLATFORM*)&request_handles[*num_request_handles], 1171 request_handle_buffer_start, request_buffer_remaining_size); 1172 if (result != TPM_RC_SUCCESS) { 1173 return result; 1174 } 1175 ++(*num_request_handles); 1176 return TPM_RC_SUCCESS; 1177 #endif 1178 #ifdef TPM_CC_SetCommandCodeAuditStatus 1179 case TPM_CC_SetCommandCodeAuditStatus: 1180 result = TPMI_RH_PROVISION_Unmarshal( 1181 (TPMI_RH_PROVISION*)&request_handles[*num_request_handles], 1182 request_handle_buffer_start, request_buffer_remaining_size); 1183 if (result != TPM_RC_SUCCESS) { 1184 return result; 1185 } 1186 ++(*num_request_handles); 1187 return TPM_RC_SUCCESS; 1188 #endif 1189 #ifdef TPM_CC_SetPrimaryPolicy 1190 case TPM_CC_SetPrimaryPolicy: 1191 result = TPMI_RH_HIERARCHY_AUTH_Unmarshal( 1192 (TPMI_RH_HIERARCHY_AUTH*)&request_handles[*num_request_handles], 1193 request_handle_buffer_start, request_buffer_remaining_size); 1194 if (result != TPM_RC_SUCCESS) { 1195 return result; 1196 } 1197 ++(*num_request_handles); 1198 return TPM_RC_SUCCESS; 1199 #endif 1200 #ifdef TPM_CC_Shutdown 1201 case TPM_CC_Shutdown: 1202 return TPM_RC_SUCCESS; 1203 #endif 1204 #ifdef TPM_CC_Sign 1205 case TPM_CC_Sign: 1206 result = TPMI_DH_OBJECT_Unmarshal( 1207 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1208 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1209 if (result != TPM_RC_SUCCESS) { 1210 return result; 1211 } 1212 ++(*num_request_handles); 1213 return TPM_RC_SUCCESS; 1214 #endif 1215 #ifdef TPM_CC_StartAuthSession 1216 case TPM_CC_StartAuthSession: 1217 result = TPMI_DH_OBJECT_Unmarshal( 1218 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1219 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 1220 if (result != TPM_RC_SUCCESS) { 1221 return result; 1222 } 1223 ++(*num_request_handles); 1224 result = TPMI_DH_ENTITY_Unmarshal( 1225 (TPMI_DH_ENTITY*)&request_handles[*num_request_handles], 1226 request_handle_buffer_start, request_buffer_remaining_size, TRUE); 1227 if (result != TPM_RC_SUCCESS) { 1228 return result; 1229 } 1230 ++(*num_request_handles); 1231 return TPM_RC_SUCCESS; 1232 #endif 1233 #ifdef TPM_CC_Startup 1234 case TPM_CC_Startup: 1235 return TPM_RC_SUCCESS; 1236 #endif 1237 #ifdef TPM_CC_StirRandom 1238 case TPM_CC_StirRandom: 1239 return TPM_RC_SUCCESS; 1240 #endif 1241 #ifdef TPM_CC_TestParms 1242 case TPM_CC_TestParms: 1243 return TPM_RC_SUCCESS; 1244 #endif 1245 #ifdef TPM_CC_Unseal 1246 case TPM_CC_Unseal: 1247 result = TPMI_DH_OBJECT_Unmarshal( 1248 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1249 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1250 if (result != TPM_RC_SUCCESS) { 1251 return result; 1252 } 1253 ++(*num_request_handles); 1254 return TPM_RC_SUCCESS; 1255 #endif 1256 #ifdef TPM_CC_VerifySignature 1257 case TPM_CC_VerifySignature: 1258 result = TPMI_DH_OBJECT_Unmarshal( 1259 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1260 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1261 if (result != TPM_RC_SUCCESS) { 1262 return result; 1263 } 1264 ++(*num_request_handles); 1265 return TPM_RC_SUCCESS; 1266 #endif 1267 #ifdef TPM_CC_ZGen_2Phase 1268 case TPM_CC_ZGen_2Phase: 1269 result = TPMI_DH_OBJECT_Unmarshal( 1270 (TPMI_DH_OBJECT*)&request_handles[*num_request_handles], 1271 request_handle_buffer_start, request_buffer_remaining_size, FALSE); 1272 if (result != TPM_RC_SUCCESS) { 1273 return result; 1274 } 1275 ++(*num_request_handles); 1276 return TPM_RC_SUCCESS; 1277 #endif 1278 default: 1279 return TPM_RC_COMMAND_CODE; 1280 } 1281 }
