1 /********************************************************************************/
2 /* */
3 /* Parameter Unmarshaling */
4 /* Written by Ken Goldman */
5 /* IBM Thomas J. Watson Research Center */
6 /* $Id: Unmarshal12.c 1285 2018-07-27 18:33:41Z kgoldman $ */
7 /* */
8 /* (c) Copyright IBM Corporation 2015, 2017 */
9 /* */
10 /* All rights reserved. */
11 /* */
12 /* Redistribution and use in source and binary forms, with or without */
13 /* modification, are permitted provided that the following conditions are */
14 /* met: */
15 /* */
16 /* Redistributions of source code must retain the above copyright notice, */
17 /* this list of conditions and the following disclaimer. */
18 /* */
19 /* Redistributions in binary form must reproduce the above copyright */
20 /* notice, this list of conditions and the following disclaimer in the */
21 /* documentation and/or other materials provided with the distribution. */
22 /* */
23 /* Neither the names of the IBM Corporation nor the names of its */
24 /* contributors may be used to endorse or promote products derived from */
25 /* this software without specific prior written permission. */
26 /* */
27 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
28 /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
29 /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR */
30 /* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
31 /* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
32 /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */
33 /* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */
34 /* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY */
35 /* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
36 /* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */
37 /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
38 /********************************************************************************/
39
40 #include <string.h>
41
42 #include <ibmtss/Unmarshal_fp.h>
43 #include <ibmtss/tpmconstants12.h>
44 #include <ibmtss/Unmarshal12_fp.h>
45
46 TPM_RC
TSS_TPM_STARTUP_TYPE_Unmarshalu(TPM_STARTUP_TYPE * target,BYTE ** buffer,uint32_t * size)47 TSS_TPM_STARTUP_TYPE_Unmarshalu(TPM_STARTUP_TYPE *target, BYTE **buffer, uint32_t *size)
48 {
49 TPM_RC rc = TPM_RC_SUCCESS;
50
51 if (rc == TPM_RC_SUCCESS) {
52 rc = TSS_UINT16_Unmarshalu(target, buffer, size);
53 }
54 if (rc == TPM_RC_SUCCESS) {
55 switch (*target) {
56 case TPM_ST_CLEAR:
57 case TPM_ST_STATE:
58 case TPM_ST_DEACTIVATED:
59 break;
60 default:
61 rc = TPM_RC_VALUE;
62 }
63 }
64 return rc;
65 }
66
67 /* 5.0 */
68
69
70 TPM_RC
TSS_TPM_VERSION_Unmarshalu(TPM_VERSION * target,BYTE ** buffer,uint32_t * size)71 TSS_TPM_VERSION_Unmarshalu(TPM_VERSION *target, BYTE **buffer, uint32_t *size)
72 {
73 TPM_RC rc = 0;
74 if (rc == 0) {
75 rc = TSS_UINT8_Unmarshalu(&target->major, buffer, size);
76 }
77 if (rc == 0) {
78 rc = TSS_UINT8_Unmarshalu(&target->minor, buffer, size);
79 }
80 if (rc == 0) {
81 rc = TSS_UINT8_Unmarshalu(&target->revMajor, buffer, size);
82 }
83 if (rc == 0) {
84 rc = TSS_UINT8_Unmarshalu(&target->revMinor, buffer, size);
85 }
86 return rc;
87 }
88
89 /* 6.0 */
90
91 TPM_RC
TSS_TPM_TAG_Unmarshalu(TPM_TAG * target,BYTE ** buffer,uint32_t * size)92 TSS_TPM_TAG_Unmarshalu(TPM_TAG *target, BYTE **buffer, uint32_t *size)
93 {
94 TPM_RC rc = TPM_RC_SUCCESS;
95
96 if (rc == TPM_RC_SUCCESS) {
97 rc = TSS_UINT16_Unmarshalu(target, buffer, size);
98 }
99 if (rc == TPM_RC_SUCCESS) {
100 switch (*target) {
101 case TPM_TAG_RSP_COMMAND:
102 case TPM_TAG_RSP_AUTH1_COMMAND:
103 case TPM_TAG_RSP_AUTH2_COMMAND:
104 break;
105 default:
106 rc = TPM_RC_VALUE;
107 }
108 }
109 return rc;
110 }
111
112 /* 8.0 */
113
114 TPM_RC
TSS_TPM_PCR_SELECTION_Unmarshalu(TPM_PCR_SELECTION * target,BYTE ** buffer,uint32_t * size)115 TSS_TPM_PCR_SELECTION_Unmarshalu(TPM_PCR_SELECTION *target, BYTE **buffer, uint32_t *size)
116 {
117 TPM_RC rc = 0;
118 if (rc == 0) {
119 rc = TSS_UINT16_Unmarshalu(&target->sizeOfSelect, buffer, size);
120 }
121 if (rc == 0) {
122 if (target->sizeOfSelect > sizeof(target->pcrSelect)) {
123 rc = TPM_RC_SIZE;
124 }
125 }
126 if (rc == 0) {
127 rc = TSS_Array_Unmarshalu(target->pcrSelect, target->sizeOfSelect, buffer, size);
128 }
129 return rc;
130 }
131
132 TPM_RC
TSS_TPM4B_TPM_PCR_INFO_LONG_Unmarshalu(TPM_PCR_INFO_LONG * target,BYTE ** buffer,uint32_t * size)133 TSS_TPM4B_TPM_PCR_INFO_LONG_Unmarshalu(TPM_PCR_INFO_LONG *target, BYTE **buffer, uint32_t *size)
134 {
135 TPM_RC rc = 0;
136 uint32_t sizeRead32;
137 uint32_t startSize;
138 if (rc == 0) {
139 rc = TSS_UINT32_Unmarshalu(&sizeRead32, buffer, size);
140 }
141 if (rc == 0) {
142 if (sizeRead32 == 0) {
143 rc = TPM_RC_SIZE;
144 }
145 }
146 if (rc == 0) {
147 startSize = *size;
148 }
149 if (rc == 0) {
150 rc = TSS_TPM_PCR_INFO_LONG_Unmarshalu(target, buffer, size);
151 }
152 if (rc == 0) {
153 if (sizeRead32 != startSize - *size) {
154 rc = TPM_RC_SIZE;
155 }
156 }
157 return rc;
158 }
159
160 TPM_RC
TSS_TPM_PCR_INFO_LONG_Unmarshalu(TPM_PCR_INFO_LONG * target,BYTE ** buffer,uint32_t * size)161 TSS_TPM_PCR_INFO_LONG_Unmarshalu(TPM_PCR_INFO_LONG *target, BYTE **buffer, uint32_t *size)
162 {
163 TPM_RC rc = 0;
164 if (rc == 0) {
165 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
166 }
167 if (rc == 0) {
168 rc = TSS_UINT8_Unmarshalu(&target->localityAtCreation, buffer, size);
169 }
170 if (rc == 0) {
171 rc = TSS_UINT8_Unmarshalu(&target->localityAtRelease, buffer, size);
172 }
173 if (rc == 0) {
174 rc = TSS_TPM_PCR_SELECTION_Unmarshalu(&target->creationPCRSelection, buffer, size);
175 }
176 if (rc == 0) {
177 rc = TSS_TPM_PCR_SELECTION_Unmarshalu(&target->releasePCRSelection, buffer, size);
178 }
179 if (rc == 0) {
180 rc = TSS_Array_Unmarshalu(target->digestAtCreation, SHA1_DIGEST_SIZE, buffer, size);
181 }
182 if (rc == 0) {
183 rc = TSS_Array_Unmarshalu(target->digestAtRelease, SHA1_DIGEST_SIZE, buffer, size);
184 }
185 return rc;
186 }
187
188 TPM_RC
TSS_TPM_PCR_INFO_SHORT_Unmarshalu(TPM_PCR_INFO_SHORT * target,BYTE ** buffer,uint32_t * size)189 TSS_TPM_PCR_INFO_SHORT_Unmarshalu(TPM_PCR_INFO_SHORT *target, BYTE **buffer, uint32_t *size)
190 {
191 TPM_RC rc = 0;
192 if (rc == 0) {
193 rc = TSS_TPM_PCR_SELECTION_Unmarshalu(&target->pcrSelection, buffer, size);
194 }
195 if (rc == 0) {
196 rc = TSS_UINT8_Unmarshalu(&target->localityAtRelease, buffer, size);
197 }
198 if (rc == 0) {
199 rc = TSS_Array_Unmarshalu(target->digestAtRelease, SHA1_DIGEST_SIZE, buffer, size);
200 }
201 return rc;
202 }
203
204 /* 9.0 */
205
206 TPM_RC
TSS_TPM_SYMMETRIC_KEY_Unmarshalu(TPM_SYMMETRIC_KEY * target,BYTE ** buffer,uint32_t * size)207 TSS_TPM_SYMMETRIC_KEY_Unmarshalu(TPM_SYMMETRIC_KEY *target, BYTE **buffer, uint32_t *size)
208 {
209 TPM_RC rc = 0;
210 if (rc == 0) {
211 rc = TSS_UINT32_Unmarshalu(&target->algId, buffer, size);
212 }
213 if (rc == 0) {
214 rc = TSS_UINT16_Unmarshalu(&target->encScheme, buffer, size);
215 }
216 if (rc == 0) {
217 rc = TSS_UINT16_Unmarshalu(&target->size, buffer, size);
218 }
219 if (rc == 0) {
220 if (target->size > sizeof(target->data)) {
221 rc = TPM_RC_SIZE;
222 }
223 }
224 if (rc == 0) {
225 rc = TSS_Array_Unmarshalu(target->data, target->size, buffer, size);
226 }
227 return rc;
228 }
229
230 /* 10.0 */
231
232 TPM_RC
TSS_TPM_RSA_KEY_PARMS_Unmarshalu(TPM_RSA_KEY_PARMS * target,BYTE ** buffer,uint32_t * size)233 TSS_TPM_RSA_KEY_PARMS_Unmarshalu(TPM_RSA_KEY_PARMS *target, BYTE **buffer, uint32_t *size)
234 {
235 TPM_RC rc = 0;
236 if (rc == 0) {
237 rc = TSS_UINT32_Unmarshalu(&target->keyLength, buffer, size);
238 }
239 if (rc == 0) {
240 rc = TSS_UINT32_Unmarshalu(&target->numPrimes, buffer, size);
241 }
242 if (rc == 0) {
243 rc = TSS_UINT32_Unmarshalu(&target->exponentSize, buffer, size);
244 }
245 if (rc == 0) {
246 if (target->exponentSize > sizeof(target->exponent)) {
247 rc = TPM_RC_SIZE;
248 }
249 }
250 if (rc == 0) {
251 rc = TSS_Array_Unmarshalu(target->exponent, target->exponentSize, buffer, size);
252 }
253 return rc;
254 }
255
256 TPM_RC
TSS_TPMU_PARMS_Unmarshalu(TPMU_PARMS * target,BYTE ** buffer,uint32_t * size,uint32_t selector)257 TSS_TPMU_PARMS_Unmarshalu(TPMU_PARMS *target, BYTE **buffer, uint32_t *size, uint32_t selector)
258 {
259 TPM_RC rc = 0;
260 switch (selector) {
261 case TPM_ALG_RSA: /* A structure of type TPM_RSA_KEY_PARMS */
262 rc = TSS_TPM_RSA_KEY_PARMS_Unmarshalu(&target->rsaParms, buffer, size);
263 break;
264 case TPM_ALG_AES128: /* A structure of type TPM_SYMMETRIC_KEY_PARMS */
265 /* not implemented yet */
266 default:
267 rc = TPM_RC_SELECTOR;
268 }
269 return rc;
270 }
271
272 TPM_RC
TSS_TPM4B_TPMU_PARMS_Unmarshalu(TPMU_PARMS * target,BYTE ** buffer,uint32_t * size,uint32_t selector)273 TSS_TPM4B_TPMU_PARMS_Unmarshalu(TPMU_PARMS *target, BYTE **buffer, uint32_t *size, uint32_t selector)
274 {
275 TPM_RC rc = 0;
276 uint32_t sizeRead32;
277 uint32_t startSize;
278 if (rc == 0) {
279 rc = TSS_UINT32_Unmarshalu(&sizeRead32, buffer, size);
280 }
281 if (rc == 0) {
282 if (sizeRead32 == 0) {
283 rc = TPM_RC_SIZE;
284 }
285 }
286 if (rc == 0) {
287 startSize = *size;
288 }
289 if (rc == 0) {
290 rc = TSS_TPMU_PARMS_Unmarshalu(target, buffer, size, selector);
291 }
292 if (rc == 0) {
293 if (sizeRead32 != startSize - *size) {
294 rc = TPM_RC_SIZE;
295 }
296 }
297 return rc;
298 }
299
300 TPM_RC
TSS_TPM_KEY_PARMS_Unmarshalu(TPM_KEY_PARMS * target,BYTE ** buffer,uint32_t * size)301 TSS_TPM_KEY_PARMS_Unmarshalu(TPM_KEY_PARMS *target, BYTE **buffer, uint32_t *size)
302 {
303 TPM_RC rc = 0;
304 if (rc == 0) {
305 rc = TSS_UINT32_Unmarshalu(&target->algorithmID, buffer, size);
306 }
307 if (rc == 0) {
308 rc = TSS_UINT16_Unmarshalu(&target->encScheme, buffer, size);
309 }
310 if (rc == 0) {
311 rc = TSS_UINT16_Unmarshalu(&target->sigScheme, buffer, size);
312 }
313 if (rc == 0) {
314 rc = TSS_TPM4B_TPMU_PARMS_Unmarshalu(&target->parms, buffer, size, target->algorithmID);
315 }
316 return rc;
317 }
318
319 TPM_RC
TSS_TPM_KEY12_Unmarshalu(TPM_KEY12 * target,BYTE ** buffer,uint32_t * size)320 TSS_TPM_KEY12_Unmarshalu(TPM_KEY12 *target, BYTE **buffer, uint32_t *size)
321 {
322 TPM_RC rc = 0;
323 if (rc == 0) {
324 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
325 }
326 if (rc == 0) {
327 rc = TSS_UINT16_Unmarshalu(&target->fill, buffer, size);
328 }
329 if (rc == 0) {
330 rc = TSS_UINT16_Unmarshalu(&target->keyUsage, buffer, size);
331 }
332 if (rc == 0) {
333 rc = TSS_UINT32_Unmarshalu(&target->keyFlags, buffer, size);
334 }
335 if (rc == 0) {
336 rc = TSS_UINT8_Unmarshalu(&target->authDataUsage, buffer, size);
337 }
338 if (rc == 0) {
339 rc = TSS_TPM_KEY_PARMS_Unmarshalu(&target->algorithmParms, buffer, size);
340 }
341 if (rc == 0) {
342 rc = TSS_TPM4B_TPM_PCR_INFO_LONG_Unmarshalu(&target->PCRInfo, buffer, size);
343 }
344 if (rc == 0) {
345 rc = TSS_TPM_STORE_PUBKEY_Unmarshalu(&target->pubKey, buffer, size);
346 }
347 if (rc == 0) {
348 rc = TSS_TPM_STORE_PUBKEY_Unmarshalu(&target->encData, buffer, size);
349 }
350 return rc;
351 }
352
353 TPM_RC
TSS_TPM_STORE_PUBKEY_Unmarshalu(TPM_STORE_PUBKEY * target,BYTE ** buffer,uint32_t * size)354 TSS_TPM_STORE_PUBKEY_Unmarshalu(TPM_STORE_PUBKEY *target, BYTE **buffer, uint32_t *size)
355 {
356 TPM_RC rc = 0;
357 if (rc == 0) {
358 rc = TSS_UINT32_Unmarshalu(&target->keyLength, buffer, size);
359 }
360 if (rc == 0) {
361 if (target->keyLength > sizeof(target->key)) {
362 rc = TPM_RC_SIZE;
363 }
364 }
365 if (rc == 0) {
366 rc = TSS_Array_Unmarshalu(target->key, target->keyLength, buffer, size);
367 }
368 return rc;
369 }
370
371 TPM_RC
TSS_TPM_PUBKEY_Unmarshalu(TPM_PUBKEY * target,BYTE ** buffer,uint32_t * size)372 TSS_TPM_PUBKEY_Unmarshalu(TPM_PUBKEY *target, BYTE **buffer, uint32_t *size)
373 {
374 TPM_RC rc = 0;
375 if (rc == 0) {
376 rc = TSS_TPM_KEY_PARMS_Unmarshalu(&target->algorithmParms, buffer, size);
377 }
378 if (rc == 0) {
379 rc = TSS_TPM_STORE_PUBKEY_Unmarshalu(&target->pubKey, buffer, size);
380 }
381 return rc;
382 }
383
384 /* 19 */
385
386 TPM_RC
TSS_TPM_NV_ATTRIBUTES_Unmarshalu(TPM_NV_ATTRIBUTES * target,BYTE ** buffer,uint32_t * size)387 TSS_TPM_NV_ATTRIBUTES_Unmarshalu(TPM_NV_ATTRIBUTES *target, BYTE **buffer, uint32_t *size)
388 {
389 TPM_RC rc = 0;
390 if (rc == 0) {
391 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
392 }
393 if (rc == 0) {
394 rc = TSS_UINT32_Unmarshalu(&target->attributes, buffer, size);
395 }
396 return rc;
397 }
398
399 TPM_RC
TSS_TPM_NV_DATA_PUBLIC_Unmarshalu(TPM_NV_DATA_PUBLIC * target,BYTE ** buffer,uint32_t * size)400 TSS_TPM_NV_DATA_PUBLIC_Unmarshalu(TPM_NV_DATA_PUBLIC *target, BYTE **buffer, uint32_t *size)
401 {
402 TPM_RC rc = 0;
403 if (rc == 0) {
404 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
405 }
406 if (rc == 0) {
407 rc = TSS_UINT32_Unmarshalu(&target->nvIndex, buffer, size);
408 }
409 if (rc == 0) {
410 rc = TSS_TPM_PCR_INFO_SHORT_Unmarshalu(&target->pcrInfoRead, buffer, size);
411 }
412 if (rc == 0) {
413 rc = TSS_TPM_PCR_INFO_SHORT_Unmarshalu(&target->pcrInfoWrite, buffer, size);
414 }
415 if (rc == 0) {
416 rc = TSS_TPM_NV_ATTRIBUTES_Unmarshalu(&target->permission, buffer, size);
417 }
418 if (rc == 0) {
419 rc = TSS_UINT8_Unmarshalu(&target->bReadSTClear, buffer, size);
420 }
421 if (rc == 0) {
422 rc = TSS_UINT8_Unmarshalu(&target->bWriteSTClear, buffer, size);
423 }
424 if (rc == 0) {
425 rc = TSS_UINT8_Unmarshalu(&target->bWriteDefine, buffer, size);
426 }
427 if (rc == 0) {
428 rc = TSS_UINT32_Unmarshalu(&target->dataSize, buffer, size);
429 }
430 return rc;
431 }
432
433 /* 21 */
434
435 TPM_RC
TSS_TPM_CAP_VERSION_INFO_Unmarshalu(TPM_CAP_VERSION_INFO * target,BYTE ** buffer,uint32_t * size)436 TSS_TPM_CAP_VERSION_INFO_Unmarshalu(TPM_CAP_VERSION_INFO *target, BYTE **buffer, uint32_t *size)
437 {
438 TPM_RC rc = 0;
439 if (rc == 0) {
440 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
441 }
442 if (rc == 0) {
443 rc = TSS_TPM_VERSION_Unmarshalu(&target->version, buffer, size);
444 }
445 if (rc == 0) {
446 rc = TSS_UINT16_Unmarshalu(&target->specLevel, buffer, size);
447 }
448 if (rc == 0) {
449 rc = TSS_UINT8_Unmarshalu(&target->errataRev, buffer, size);
450 }
451 if (rc == 0) {
452 rc = TSS_Array_Unmarshalu(target->tpmVendorID, sizeof(target->tpmVendorID), buffer, size);
453 }
454 if (rc == 0) {
455 rc = TSS_UINT16_Unmarshalu(&target->vendorSpecificSize, buffer, size);
456 }
457 if (rc == 0) {
458 if (target->vendorSpecificSize > sizeof(target->vendorSpecific)) {
459 rc = TPM_RC_SIZE;
460 }
461 }
462 if (rc == 0) {
463 rc = TSS_Array_Unmarshalu(target->vendorSpecific, target->vendorSpecificSize, buffer, size);
464 }
465 return rc;
466 }
467
468 TPM_RC
TSS_TPM_DA_INFO_Unmarshalu(TPM_DA_INFO * target,BYTE ** buffer,uint32_t * size)469 TSS_TPM_DA_INFO_Unmarshalu(TPM_DA_INFO *target, BYTE **buffer, uint32_t *size)
470 {
471 TPM_RC rc = 0;
472 if (rc == 0) {
473 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
474 }
475 if (rc == 0) {
476 rc = TSS_UINT8_Unmarshalu(&target->state, buffer, size);
477 }
478 if (rc == 0) {
479 rc = TSS_UINT16_Unmarshalu(&target->currentCount, buffer, size);
480 }
481 if (rc == 0) {
482 rc = TSS_UINT16_Unmarshalu(&target->thresholdCount, buffer, size);
483 }
484 if (rc == 0) {
485 rc = TSS_TPM_DA_ACTION_TYPE_Unmarshalu(&target->actionAtThreshold, buffer, size);
486 }
487 if (rc == 0) {
488 rc = TSS_UINT32_Unmarshalu(&target->actionDependValue, buffer, size);
489 }
490 if (rc == 0) {
491 rc = TSS_UINT32_Unmarshalu(&target->vendorDataSize, buffer, size);
492 }
493 if (rc == 0) {
494 if (target->vendorDataSize > sizeof(target->vendorData)) {
495 rc = TPM_RC_SIZE;
496 }
497 }
498 if (rc == 0) {
499 rc = TSS_Array_Unmarshalu(target->vendorData, target->vendorDataSize , buffer, size);
500 }
501 return rc;
502 }
503
504 TPM_RC
TSS_TPM_DA_INFO_LIMITED_Unmarshalu(TPM_DA_INFO_LIMITED * target,BYTE ** buffer,uint32_t * size)505 TSS_TPM_DA_INFO_LIMITED_Unmarshalu(TPM_DA_INFO_LIMITED *target, BYTE **buffer, uint32_t *size)
506 {
507 TPM_RC rc = 0;
508 if (rc == 0) {
509 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
510 }
511 if (rc == 0) {
512 rc = TSS_UINT8_Unmarshalu(&target->state, buffer, size);
513 }
514 if (rc == 0) {
515 rc = TSS_TPM_DA_ACTION_TYPE_Unmarshalu(&target->actionAtThreshold, buffer, size);
516 }
517 if (rc == 0) {
518 rc = TSS_UINT32_Unmarshalu(&target->vendorDataSize, buffer, size);
519 }
520 if (rc == 0) {
521 if (target->vendorDataSize > sizeof(target->vendorData)) {
522 rc = TPM_RC_SIZE;
523 }
524 }
525 if (rc == 0) {
526 rc = TSS_Array_Unmarshalu(target->vendorData, target->vendorDataSize , buffer, size);
527 }
528 return rc;
529 }
530
531 TPM_RC
TSS_TPM_DA_ACTION_TYPE_Unmarshalu(TPM_DA_ACTION_TYPE * target,BYTE ** buffer,uint32_t * size)532 TSS_TPM_DA_ACTION_TYPE_Unmarshalu(TPM_DA_ACTION_TYPE *target, BYTE **buffer, uint32_t *size)
533 {
534 TPM_RC rc = 0;
535 if (rc == 0) {
536 rc = TSS_UINT16_Unmarshalu(&target->tag, buffer, size);
537 }
538 if (rc == 0) {
539 rc = TSS_UINT32_Unmarshalu(&target->actions, buffer, size);
540 }
541 return rc;
542 }
543