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
12TPM_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}