1 /* Microsoft Reference Implementation for TPM 2.0 2 * 3 * The copyright in this software is being made available under the BSD License, 4 * included below. This software may be subject to other third party and 5 * contributor rights, including patent rights, and no such rights are granted 6 * under this license. 7 * 8 * Copyright (c) Microsoft Corporation 9 * 10 * All rights reserved. 11 * 12 * BSD License 13 * 14 * Redistribution and use in source and binary forms, with or without modification, 15 * are permitted provided that the following conditions are met: 16 * 17 * Redistributions of source code must retain the above copyright notice, this list 18 * of conditions and the following disclaimer. 19 * 20 * Redistributions in binary form must reproduce the above copyright notice, this 21 * list of conditions and the following disclaimer in the documentation and/or 22 * other materials provided with the distribution. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 28 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 31 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /*(Auto-generated) 36 * Created by TpmMarshal; Version 4.1 Dec 10, 2018 37 * Date: Mar 6, 2020 Time: 01:50:10PM 38 */ 39 40 #ifndef _MARSHAL_FP_H_ 41 #define _MARSHAL_FP_H_ 42 43 // Table 2:3 - Definition of Base Types 44 // UINT8 definition from table 2:3 45 TPM_RC 46 UINT8_Unmarshal(UINT8 *target, BYTE **buffer, INT32 *size); 47 UINT16 48 UINT8_Marshal(UINT8 *source, BYTE **buffer, INT32 *size); 49 50 // BYTE definition from table 2:3 51 #if !USE_MARSHALING_DEFINES 52 TPM_RC 53 BYTE_Unmarshal(BYTE *target, BYTE **buffer, INT32 *size); 54 #else 55 #define BYTE_Unmarshal(target, buffer, size) \ 56 UINT8_Unmarshal((UINT8 *)(target), (buffer), (size)) 57 #endif // !USE_MARSHALING_DEFINES 58 #if !USE_MARSHALING_DEFINES 59 UINT16 60 BYTE_Marshal(BYTE *source, BYTE **buffer, INT32 *size); 61 #else 62 #define BYTE_Marshal(source, buffer, size) \ 63 UINT8_Marshal((UINT8 *)(source), (buffer), (size)) 64 #endif // !USE_MARSHALING_DEFINES 65 66 // INT8 definition from table 2:3 67 #if !USE_MARSHALING_DEFINES 68 TPM_RC 69 INT8_Unmarshal(INT8 *target, BYTE **buffer, INT32 *size); 70 #else 71 #define INT8_Unmarshal(target, buffer, size) \ 72 UINT8_Unmarshal((UINT8 *)(target), (buffer), (size)) 73 #endif // !USE_MARSHALING_DEFINES 74 #if !USE_MARSHALING_DEFINES 75 UINT16 76 INT8_Marshal(INT8 *source, BYTE **buffer, INT32 *size); 77 #else 78 #define INT8_Marshal(source, buffer, size) \ 79 UINT8_Marshal((UINT8 *)(source), (buffer), (size)) 80 #endif // !USE_MARSHALING_DEFINES 81 82 // UINT16 definition from table 2:3 83 TPM_RC 84 UINT16_Unmarshal(UINT16 *target, BYTE **buffer, INT32 *size); 85 UINT16 86 UINT16_Marshal(UINT16 *source, BYTE **buffer, INT32 *size); 87 88 // INT16 definition from table 2:3 89 #if !USE_MARSHALING_DEFINES 90 TPM_RC 91 INT16_Unmarshal(INT16 *target, BYTE **buffer, INT32 *size); 92 #else 93 #define INT16_Unmarshal(target, buffer, size) \ 94 UINT16_Unmarshal((UINT16 *)(target), (buffer), (size)) 95 #endif // !USE_MARSHALING_DEFINES 96 #if !USE_MARSHALING_DEFINES 97 UINT16 98 INT16_Marshal(INT16 *source, BYTE **buffer, INT32 *size); 99 #else 100 #define INT16_Marshal(source, buffer, size) \ 101 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 102 #endif // !USE_MARSHALING_DEFINES 103 104 // UINT32 definition from table 2:3 105 TPM_RC 106 UINT32_Unmarshal(UINT32 *target, BYTE **buffer, INT32 *size); 107 UINT16 108 UINT32_Marshal(UINT32 *source, BYTE **buffer, INT32 *size); 109 110 // INT32 definition from table 2:3 111 #if !USE_MARSHALING_DEFINES 112 TPM_RC 113 INT32_Unmarshal(INT32 *target, BYTE **buffer, INT32 *size); 114 #else 115 #define INT32_Unmarshal(target, buffer, size) \ 116 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 117 #endif // !USE_MARSHALING_DEFINES 118 #if !USE_MARSHALING_DEFINES 119 UINT16 120 INT32_Marshal(INT32 *source, BYTE **buffer, INT32 *size); 121 #else 122 #define INT32_Marshal(source, buffer, size) \ 123 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 124 #endif // !USE_MARSHALING_DEFINES 125 126 // UINT64 definition from table 2:3 127 TPM_RC 128 UINT64_Unmarshal(UINT64 *target, BYTE **buffer, INT32 *size); 129 UINT16 130 UINT64_Marshal(UINT64 *source, BYTE **buffer, INT32 *size); 131 132 // INT64 definition from table 2:3 133 #if !USE_MARSHALING_DEFINES 134 TPM_RC 135 INT64_Unmarshal(INT64 *target, BYTE **buffer, INT32 *size); 136 #else 137 #define INT64_Unmarshal(target, buffer, size) \ 138 UINT64_Unmarshal((UINT64 *)(target), (buffer), (size)) 139 #endif // !USE_MARSHALING_DEFINES 140 #if !USE_MARSHALING_DEFINES 141 UINT16 142 INT64_Marshal(INT64 *source, BYTE **buffer, INT32 *size); 143 #else 144 #define INT64_Marshal(source, buffer, size) \ 145 UINT64_Marshal((UINT64 *)(source), (buffer), (size)) 146 #endif // !USE_MARSHALING_DEFINES 147 148 // Table 2:4 - Defines for Logic Values 149 // Table 2:5 - Definition of Types for Documentation Clarity 150 #if !USE_MARSHALING_DEFINES 151 TPM_RC 152 TPM_ALGORITHM_ID_Unmarshal(TPM_ALGORITHM_ID *target, BYTE **buffer, INT32 *size); 153 #else 154 #define TPM_ALGORITHM_ID_Unmarshal(target, buffer, size) \ 155 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 156 #endif // !USE_MARSHALING_DEFINES 157 #if !USE_MARSHALING_DEFINES 158 UINT16 159 TPM_ALGORITHM_ID_Marshal(TPM_ALGORITHM_ID *source, BYTE **buffer, INT32 *size); 160 #else 161 #define TPM_ALGORITHM_ID_Marshal(source, buffer, size) \ 162 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 163 #endif // !USE_MARSHALING_DEFINES 164 #if !USE_MARSHALING_DEFINES 165 TPM_RC 166 TPM_MODIFIER_INDICATOR_Unmarshal(TPM_MODIFIER_INDICATOR *target, 167 BYTE **buffer, INT32 *size); 168 #else 169 #define TPM_MODIFIER_INDICATOR_Unmarshal(target, buffer, size) \ 170 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 171 #endif // !USE_MARSHALING_DEFINES 172 #if !USE_MARSHALING_DEFINES 173 UINT16 174 TPM_MODIFIER_INDICATOR_Marshal(TPM_MODIFIER_INDICATOR *source, 175 BYTE **buffer, INT32 *size); 176 #else 177 #define TPM_MODIFIER_INDICATOR_Marshal(source, buffer, size) \ 178 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 179 #endif // !USE_MARSHALING_DEFINES 180 #if !USE_MARSHALING_DEFINES 181 TPM_RC 182 TPM_AUTHORIZATION_SIZE_Unmarshal(TPM_AUTHORIZATION_SIZE *target, 183 BYTE **buffer, INT32 *size); 184 #else 185 #define TPM_AUTHORIZATION_SIZE_Unmarshal(target, buffer, size) \ 186 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 187 #endif // !USE_MARSHALING_DEFINES 188 #if !USE_MARSHALING_DEFINES 189 UINT16 190 TPM_AUTHORIZATION_SIZE_Marshal(TPM_AUTHORIZATION_SIZE *source, 191 BYTE **buffer, INT32 *size); 192 #else 193 #define TPM_AUTHORIZATION_SIZE_Marshal(source, buffer, size) \ 194 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 195 #endif // !USE_MARSHALING_DEFINES 196 #if !USE_MARSHALING_DEFINES 197 TPM_RC 198 TPM_PARAMETER_SIZE_Unmarshal(TPM_PARAMETER_SIZE *target, 199 BYTE **buffer, INT32 *size); 200 #else 201 #define TPM_PARAMETER_SIZE_Unmarshal(target, buffer, size) \ 202 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 203 #endif // !USE_MARSHALING_DEFINES 204 #if !USE_MARSHALING_DEFINES 205 UINT16 206 TPM_PARAMETER_SIZE_Marshal(TPM_PARAMETER_SIZE *source, BYTE **buffer, INT32 *size); 207 #else 208 #define TPM_PARAMETER_SIZE_Marshal(source, buffer, size) \ 209 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 210 #endif // !USE_MARSHALING_DEFINES 211 #if !USE_MARSHALING_DEFINES 212 TPM_RC 213 TPM_KEY_SIZE_Unmarshal(TPM_KEY_SIZE *target, BYTE **buffer, INT32 *size); 214 #else 215 #define TPM_KEY_SIZE_Unmarshal(target, buffer, size) \ 216 UINT16_Unmarshal((UINT16 *)(target), (buffer), (size)) 217 #endif // !USE_MARSHALING_DEFINES 218 #if !USE_MARSHALING_DEFINES 219 UINT16 220 TPM_KEY_SIZE_Marshal(TPM_KEY_SIZE *source, BYTE **buffer, INT32 *size); 221 #else 222 #define TPM_KEY_SIZE_Marshal(source, buffer, size) \ 223 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 224 #endif // !USE_MARSHALING_DEFINES 225 #if !USE_MARSHALING_DEFINES 226 TPM_RC 227 TPM_KEY_BITS_Unmarshal(TPM_KEY_BITS *target, BYTE **buffer, INT32 *size); 228 #else 229 #define TPM_KEY_BITS_Unmarshal(target, buffer, size) \ 230 UINT16_Unmarshal((UINT16 *)(target), (buffer), (size)) 231 #endif // !USE_MARSHALING_DEFINES 232 #if !USE_MARSHALING_DEFINES 233 UINT16 234 TPM_KEY_BITS_Marshal(TPM_KEY_BITS *source, BYTE **buffer, INT32 *size); 235 #else 236 #define TPM_KEY_BITS_Marshal(source, buffer, size) \ 237 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 238 #endif // !USE_MARSHALING_DEFINES 239 240 // Table 2:6 - Definition of TPM_SPEC Constants 241 // Table 2:7 - Definition of TPM_CONSTANTS32 Constants 242 #if !USE_MARSHALING_DEFINES 243 UINT16 244 TPM_CONSTANTS32_Marshal(TPM_CONSTANTS32 *source, BYTE **buffer, INT32 *size); 245 #else 246 #define TPM_CONSTANTS32_Marshal(source, buffer, size) \ 247 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 248 #endif // !USE_MARSHALING_DEFINES 249 250 // Table 2:9 - Definition of TPM_ALG_ID Constants 251 #if !USE_MARSHALING_DEFINES 252 TPM_RC 253 TPM_ALG_ID_Unmarshal(TPM_ALG_ID *target, BYTE **buffer, INT32 *size); 254 #else 255 #define TPM_ALG_ID_Unmarshal(target, buffer, size) \ 256 UINT16_Unmarshal((UINT16 *)(target), (buffer), (size)) 257 #endif // !USE_MARSHALING_DEFINES 258 #if !USE_MARSHALING_DEFINES 259 UINT16 260 TPM_ALG_ID_Marshal(TPM_ALG_ID *source, BYTE **buffer, INT32 *size); 261 #else 262 #define TPM_ALG_ID_Marshal(source, buffer, size) \ 263 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 264 #endif // !USE_MARSHALING_DEFINES 265 266 // Table 2:10 - Definition of TPM_ECC_CURVE Constants 267 #if ALG_ECC 268 TPM_RC 269 TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE *target, BYTE **buffer, INT32 *size); 270 #if !USE_MARSHALING_DEFINES 271 UINT16 272 TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE *source, BYTE **buffer, INT32 *size); 273 #else 274 #define TPM_ECC_CURVE_Marshal(source, buffer, size) \ 275 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 276 #endif // !USE_MARSHALING_DEFINES 277 #endif // ALG_ECC 278 279 // Table 2:12 - Definition of TPM_CC Constants 280 #if !USE_MARSHALING_DEFINES 281 TPM_RC 282 TPM_CC_Unmarshal(TPM_CC *target, BYTE **buffer, INT32 *size); 283 #else 284 #define TPM_CC_Unmarshal(target, buffer, size) \ 285 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 286 #endif // !USE_MARSHALING_DEFINES 287 #if !USE_MARSHALING_DEFINES 288 UINT16 289 TPM_CC_Marshal(TPM_CC *source, BYTE **buffer, INT32 *size); 290 #else 291 #define TPM_CC_Marshal(source, buffer, size) \ 292 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 293 #endif // !USE_MARSHALING_DEFINES 294 295 // Table 2:16 - Definition of TPM_RC Constants 296 #if !USE_MARSHALING_DEFINES 297 UINT16 298 TPM_RC_Marshal(TPM_RC *source, BYTE **buffer, INT32 *size); 299 #else 300 #define TPM_RC_Marshal(source, buffer, size) \ 301 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 302 #endif // !USE_MARSHALING_DEFINES 303 304 // Table 2:17 - Definition of TPM_CLOCK_ADJUST Constants 305 TPM_RC 306 TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST *target, BYTE **buffer, INT32 *size); 307 308 // Table 2:18 - Definition of TPM_EO Constants 309 TPM_RC 310 TPM_EO_Unmarshal(TPM_EO *target, BYTE **buffer, INT32 *size); 311 #if !USE_MARSHALING_DEFINES 312 UINT16 313 TPM_EO_Marshal(TPM_EO *source, BYTE **buffer, INT32 *size); 314 #else 315 #define TPM_EO_Marshal(source, buffer, size) \ 316 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 317 #endif // !USE_MARSHALING_DEFINES 318 319 // Table 2:19 - Definition of TPM_ST Constants 320 #if !USE_MARSHALING_DEFINES 321 TPM_RC 322 TPM_ST_Unmarshal(TPM_ST *target, BYTE **buffer, INT32 *size); 323 #else 324 #define TPM_ST_Unmarshal(target, buffer, size) \ 325 UINT16_Unmarshal((UINT16 *)(target), (buffer), (size)) 326 #endif // !USE_MARSHALING_DEFINES 327 #if !USE_MARSHALING_DEFINES 328 UINT16 329 TPM_ST_Marshal(TPM_ST *source, BYTE **buffer, INT32 *size); 330 #else 331 #define TPM_ST_Marshal(source, buffer, size) \ 332 UINT16_Marshal((UINT16 *)(source), (buffer), (size)) 333 #endif // !USE_MARSHALING_DEFINES 334 335 // Table 2:20 - Definition of TPM_SU Constants 336 TPM_RC 337 TPM_SU_Unmarshal(TPM_SU *target, BYTE **buffer, INT32 *size); 338 339 // Table 2:21 - Definition of TPM_SE Constants 340 TPM_RC 341 TPM_SE_Unmarshal(TPM_SE *target, BYTE **buffer, INT32 *size); 342 343 // Table 2:22 - Definition of TPM_CAP Constants 344 TPM_RC 345 TPM_CAP_Unmarshal(TPM_CAP *target, BYTE **buffer, INT32 *size); 346 #if !USE_MARSHALING_DEFINES 347 UINT16 348 TPM_CAP_Marshal(TPM_CAP *source, BYTE **buffer, INT32 *size); 349 #else 350 #define TPM_CAP_Marshal(source, buffer, size) \ 351 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 352 #endif // !USE_MARSHALING_DEFINES 353 354 // Table 2:23 - Definition of TPM_PT Constants 355 #if !USE_MARSHALING_DEFINES 356 TPM_RC 357 TPM_PT_Unmarshal(TPM_PT *target, BYTE **buffer, INT32 *size); 358 #else 359 #define TPM_PT_Unmarshal(target, buffer, size) \ 360 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 361 #endif // !USE_MARSHALING_DEFINES 362 #if !USE_MARSHALING_DEFINES 363 UINT16 364 TPM_PT_Marshal(TPM_PT *source, BYTE **buffer, INT32 *size); 365 #else 366 #define TPM_PT_Marshal(source, buffer, size) \ 367 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 368 #endif // !USE_MARSHALING_DEFINES 369 370 // Table 2:24 - Definition of TPM_PT_PCR Constants 371 #if !USE_MARSHALING_DEFINES 372 TPM_RC 373 TPM_PT_PCR_Unmarshal(TPM_PT_PCR *target, BYTE **buffer, INT32 *size); 374 #else 375 #define TPM_PT_PCR_Unmarshal(target, buffer, size) \ 376 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 377 #endif // !USE_MARSHALING_DEFINES 378 #if !USE_MARSHALING_DEFINES 379 UINT16 380 TPM_PT_PCR_Marshal(TPM_PT_PCR *source, BYTE **buffer, INT32 *size); 381 #else 382 #define TPM_PT_PCR_Marshal(source, buffer, size) \ 383 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 384 #endif // !USE_MARSHALING_DEFINES 385 386 // Table 2:25 - Definition of TPM_PS Constants 387 #if !USE_MARSHALING_DEFINES 388 UINT16 389 TPM_PS_Marshal(TPM_PS *source, BYTE **buffer, INT32 *size); 390 #else 391 #define TPM_PS_Marshal(source, buffer, size) \ 392 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 393 #endif // !USE_MARSHALING_DEFINES 394 395 // Table 2:26 - Definition of Types for Handles 396 #if !USE_MARSHALING_DEFINES 397 TPM_RC 398 TPM_HANDLE_Unmarshal(TPM_HANDLE *target, BYTE **buffer, INT32 *size); 399 #else 400 #define TPM_HANDLE_Unmarshal(target, buffer, size) \ 401 UINT32_Unmarshal((UINT32 *)(target), (buffer), (size)) 402 #endif // !USE_MARSHALING_DEFINES 403 #if !USE_MARSHALING_DEFINES 404 UINT16 405 TPM_HANDLE_Marshal(TPM_HANDLE *source, BYTE **buffer, INT32 *size); 406 #else 407 #define TPM_HANDLE_Marshal(source, buffer, size) \ 408 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 409 #endif // !USE_MARSHALING_DEFINES 410 411 // Table 2:27 - Definition of TPM_HT Constants 412 #if !USE_MARSHALING_DEFINES 413 TPM_RC 414 TPM_HT_Unmarshal(TPM_HT *target, BYTE **buffer, INT32 *size); 415 #else 416 #define TPM_HT_Unmarshal(target, buffer, size) \ 417 UINT8_Unmarshal((UINT8 *)(target), (buffer), (size)) 418 #endif // !USE_MARSHALING_DEFINES 419 #if !USE_MARSHALING_DEFINES 420 UINT16 421 TPM_HT_Marshal(TPM_HT *source, BYTE **buffer, INT32 *size); 422 #else 423 #define TPM_HT_Marshal(source, buffer, size) \ 424 UINT8_Marshal((UINT8 *)(source), (buffer), (size)) 425 #endif // !USE_MARSHALING_DEFINES 426 427 // Table 2:28 - Definition of TPM_RH Constants 428 #if !USE_MARSHALING_DEFINES 429 TPM_RC 430 TPM_RH_Unmarshal(TPM_RH *target, BYTE **buffer, INT32 *size); 431 #else 432 #define TPM_RH_Unmarshal(target, buffer, size) \ 433 TPM_HANDLE_Unmarshal((TPM_HANDLE *)(target), (buffer), (size)) 434 #endif // !USE_MARSHALING_DEFINES 435 #if !USE_MARSHALING_DEFINES 436 UINT16 437 TPM_RH_Marshal(TPM_RH *source, BYTE **buffer, INT32 *size); 438 #else 439 #define TPM_RH_Marshal(source, buffer, size) \ 440 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 441 #endif // !USE_MARSHALING_DEFINES 442 443 // Table 2:29 - Definition of TPM_HC Constants 444 #if !USE_MARSHALING_DEFINES 445 TPM_RC 446 TPM_HC_Unmarshal(TPM_HC *target, BYTE **buffer, INT32 *size); 447 #else 448 #define TPM_HC_Unmarshal(target, buffer, size) \ 449 TPM_HANDLE_Unmarshal((TPM_HANDLE *)(target), (buffer), (size)) 450 #endif // !USE_MARSHALING_DEFINES 451 #if !USE_MARSHALING_DEFINES 452 UINT16 453 TPM_HC_Marshal(TPM_HC *source, BYTE **buffer, INT32 *size); 454 #else 455 #define TPM_HC_Marshal(source, buffer, size) \ 456 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 457 #endif // !USE_MARSHALING_DEFINES 458 459 // Table 2:30 - Definition of TPMA_ALGORITHM Bits 460 TPM_RC 461 TPMA_ALGORITHM_Unmarshal(TPMA_ALGORITHM *target, BYTE **buffer, INT32 *size); 462 463 #if !USE_MARSHALING_DEFINES 464 UINT16 465 TPMA_ALGORITHM_Marshal(TPMA_ALGORITHM *source, BYTE **buffer, INT32 *size); 466 #else 467 #define TPMA_ALGORITHM_Marshal(source, buffer, size) \ 468 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 469 #endif // !USE_MARSHALING_DEFINES 470 471 // Table 2:31 - Definition of TPMA_OBJECT Bits 472 TPM_RC 473 TPMA_OBJECT_Unmarshal(TPMA_OBJECT *target, BYTE **buffer, INT32 *size); 474 475 #if !USE_MARSHALING_DEFINES 476 UINT16 477 TPMA_OBJECT_Marshal(TPMA_OBJECT *source, BYTE **buffer, INT32 *size); 478 #else 479 #define TPMA_OBJECT_Marshal(source, buffer, size) \ 480 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 481 #endif // !USE_MARSHALING_DEFINES 482 483 // Table 2:32 - Definition of TPMA_SESSION Bits 484 TPM_RC 485 TPMA_SESSION_Unmarshal(TPMA_SESSION *target, BYTE **buffer, INT32 *size); 486 487 #if !USE_MARSHALING_DEFINES 488 UINT16 489 TPMA_SESSION_Marshal(TPMA_SESSION *source, BYTE **buffer, INT32 *size); 490 #else 491 #define TPMA_SESSION_Marshal(source, buffer, size) \ 492 UINT8_Marshal((UINT8 *)(source), (buffer), (size)) 493 #endif // !USE_MARSHALING_DEFINES 494 495 // Table 2:33 - Definition of TPMA_LOCALITY Bits 496 #if !USE_MARSHALING_DEFINES 497 TPM_RC 498 TPMA_LOCALITY_Unmarshal(TPMA_LOCALITY *target, BYTE **buffer, INT32 *size); 499 #else 500 #define TPMA_LOCALITY_Unmarshal(target, buffer, size) \ 501 UINT8_Unmarshal((UINT8 *)(target), (buffer), (size)) 502 #endif // !USE_MARSHALING_DEFINES 503 504 #if !USE_MARSHALING_DEFINES 505 UINT16 506 TPMA_LOCALITY_Marshal(TPMA_LOCALITY *source, BYTE **buffer, INT32 *size); 507 #else 508 #define TPMA_LOCALITY_Marshal(source, buffer, size) \ 509 UINT8_Marshal((UINT8 *)(source), (buffer), (size)) 510 #endif // !USE_MARSHALING_DEFINES 511 512 // Table 2:34 - Definition of TPMA_PERMANENT Bits 513 #if !USE_MARSHALING_DEFINES 514 UINT16 515 TPMA_PERMANENT_Marshal(TPMA_PERMANENT *source, BYTE **buffer, INT32 *size); 516 #else 517 #define TPMA_PERMANENT_Marshal(source, buffer, size) \ 518 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 519 #endif // !USE_MARSHALING_DEFINES 520 521 // Table 2:35 - Definition of TPMA_STARTUP_CLEAR Bits 522 #if !USE_MARSHALING_DEFINES 523 UINT16 524 TPMA_STARTUP_CLEAR_Marshal(TPMA_STARTUP_CLEAR *source, BYTE **buffer, INT32 *size); 525 #else 526 #define TPMA_STARTUP_CLEAR_Marshal(source, buffer, size) \ 527 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 528 #endif // !USE_MARSHALING_DEFINES 529 530 // Table 2:36 - Definition of TPMA_MEMORY Bits 531 #if !USE_MARSHALING_DEFINES 532 UINT16 533 TPMA_MEMORY_Marshal(TPMA_MEMORY *source, BYTE **buffer, INT32 *size); 534 #else 535 #define TPMA_MEMORY_Marshal(source, buffer, size) \ 536 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 537 #endif // !USE_MARSHALING_DEFINES 538 539 // Table 2:37 - Definition of TPMA_CC Bits 540 #if !USE_MARSHALING_DEFINES 541 UINT16 542 TPMA_CC_Marshal(TPMA_CC *source, BYTE **buffer, INT32 *size); 543 #else 544 #define TPMA_CC_Marshal(source, buffer, size) \ 545 TPM_CC_Marshal((TPM_CC *)(source), (buffer), (size)) 546 #endif // !USE_MARSHALING_DEFINES 547 548 // Table 2:38 - Definition of TPMA_MODES Bits 549 #if !USE_MARSHALING_DEFINES 550 UINT16 551 TPMA_MODES_Marshal(TPMA_MODES *source, BYTE **buffer, INT32 *size); 552 #else 553 #define TPMA_MODES_Marshal(source, buffer, size) \ 554 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 555 #endif // !USE_MARSHALING_DEFINES 556 557 // Table 2:39 - Definition of TPMA_X509_KEY_USAGE Bits 558 #if !USE_MARSHALING_DEFINES 559 UINT16 560 TPMA_X509_KEY_USAGE_Marshal(TPMA_X509_KEY_USAGE *source, 561 BYTE **buffer, INT32 *size); 562 #else 563 #define TPMA_X509_KEY_USAGE_Marshal(source, buffer, size) \ 564 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 565 #endif // !USE_MARSHALING_DEFINES 566 567 // Table 2:40 - Definition of TPMA_ACT Bits 568 TPM_RC 569 TPMA_ACT_Unmarshal(TPMA_ACT *target, BYTE **buffer, INT32 *size); 570 571 #if !USE_MARSHALING_DEFINES 572 UINT16 573 TPMA_ACT_Marshal(TPMA_ACT *source, BYTE **buffer, INT32 *size); 574 #else 575 #define TPMA_ACT_Marshal(source, buffer, size) \ 576 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 577 #endif // !USE_MARSHALING_DEFINES 578 579 // Table 2:41 - Definition of TPMI_YES_NO Type 580 TPM_RC 581 TPMI_YES_NO_Unmarshal(TPMI_YES_NO *target, BYTE **buffer, INT32 *size); 582 #if !USE_MARSHALING_DEFINES 583 UINT16 584 TPMI_YES_NO_Marshal(TPMI_YES_NO *source, BYTE **buffer, INT32 *size); 585 #else 586 #define TPMI_YES_NO_Marshal(source, buffer, size) \ 587 BYTE_Marshal((BYTE *)(source), (buffer), (size)) 588 #endif // !USE_MARSHALING_DEFINES 589 590 // Table 2:42 - Definition of TPMI_DH_OBJECT Type 591 TPM_RC 592 TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT *target, 593 BYTE **buffer, INT32 *size, BOOL flag); 594 #if !USE_MARSHALING_DEFINES 595 UINT16 596 TPMI_DH_OBJECT_Marshal(TPMI_DH_OBJECT *source, BYTE **buffer, INT32 *size); 597 #else 598 #define TPMI_DH_OBJECT_Marshal(source, buffer, size) \ 599 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 600 #endif // !USE_MARSHALING_DEFINES 601 602 // Table 2:43 - Definition of TPMI_DH_PARENT Type 603 TPM_RC 604 TPMI_DH_PARENT_Unmarshal(TPMI_DH_PARENT *target, 605 BYTE **buffer, INT32 *size, BOOL flag); 606 #if !USE_MARSHALING_DEFINES 607 UINT16 608 TPMI_DH_PARENT_Marshal(TPMI_DH_PARENT *source, BYTE **buffer, INT32 *size); 609 #else 610 #define TPMI_DH_PARENT_Marshal(source, buffer, size) \ 611 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 612 #endif // !USE_MARSHALING_DEFINES 613 614 // Table 2:44 - Definition of TPMI_DH_PERSISTENT Type 615 TPM_RC 616 TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT *target, 617 BYTE **buffer, INT32 *size); 618 #if !USE_MARSHALING_DEFINES 619 UINT16 620 TPMI_DH_PERSISTENT_Marshal(TPMI_DH_PERSISTENT *source, BYTE **buffer, INT32 *size); 621 #else 622 #define TPMI_DH_PERSISTENT_Marshal(source, buffer, size) \ 623 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 624 #endif // !USE_MARSHALING_DEFINES 625 626 // Table 2:45 - Definition of TPMI_DH_ENTITY Type 627 TPM_RC 628 TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY *target, 629 BYTE **buffer, INT32 *size, BOOL flag); 630 631 // Table 2:46 - Definition of TPMI_DH_PCR Type 632 TPM_RC 633 TPMI_DH_PCR_Unmarshal(TPMI_DH_PCR *target, BYTE **buffer, INT32 *size, BOOL flag); 634 635 // Table 2:47 - Definition of TPMI_SH_AUTH_SESSION Type 636 TPM_RC 637 TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION *target, 638 BYTE **buffer, INT32 *size, BOOL flag); 639 #if !USE_MARSHALING_DEFINES 640 UINT16 641 TPMI_SH_AUTH_SESSION_Marshal(TPMI_SH_AUTH_SESSION *source, 642 BYTE **buffer, INT32 *size); 643 #else 644 #define TPMI_SH_AUTH_SESSION_Marshal(source, buffer, size) \ 645 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 646 #endif // !USE_MARSHALING_DEFINES 647 648 // Table 2:48 - Definition of TPMI_SH_HMAC Type 649 TPM_RC 650 TPMI_SH_HMAC_Unmarshal(TPMI_SH_HMAC *target, BYTE **buffer, INT32 *size); 651 #if !USE_MARSHALING_DEFINES 652 UINT16 653 TPMI_SH_HMAC_Marshal(TPMI_SH_HMAC *source, BYTE **buffer, INT32 *size); 654 #else 655 #define TPMI_SH_HMAC_Marshal(source, buffer, size) \ 656 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 657 #endif // !USE_MARSHALING_DEFINES 658 659 // Table 2:49 - Definition of TPMI_SH_POLICY Type 660 TPM_RC 661 TPMI_SH_POLICY_Unmarshal(TPMI_SH_POLICY *target, BYTE **buffer, INT32 *size); 662 #if !USE_MARSHALING_DEFINES 663 UINT16 664 TPMI_SH_POLICY_Marshal(TPMI_SH_POLICY *source, BYTE **buffer, INT32 *size); 665 #else 666 #define TPMI_SH_POLICY_Marshal(source, buffer, size) \ 667 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 668 #endif // !USE_MARSHALING_DEFINES 669 670 // Table 2:50 - Definition of TPMI_DH_CONTEXT Type 671 TPM_RC 672 TPMI_DH_CONTEXT_Unmarshal(TPMI_DH_CONTEXT *target, BYTE **buffer, INT32 *size); 673 #if !USE_MARSHALING_DEFINES 674 UINT16 675 TPMI_DH_CONTEXT_Marshal(TPMI_DH_CONTEXT *source, BYTE **buffer, INT32 *size); 676 #else 677 #define TPMI_DH_CONTEXT_Marshal(source, buffer, size) \ 678 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 679 #endif // !USE_MARSHALING_DEFINES 680 681 // Table 2:51 - Definition of TPMI_DH_SAVED Type 682 TPM_RC 683 TPMI_DH_SAVED_Unmarshal(TPMI_DH_SAVED *target, BYTE **buffer, INT32 *size); 684 #if !USE_MARSHALING_DEFINES 685 UINT16 686 TPMI_DH_SAVED_Marshal(TPMI_DH_SAVED *source, BYTE **buffer, INT32 *size); 687 #else 688 #define TPMI_DH_SAVED_Marshal(source, buffer, size) \ 689 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 690 #endif // !USE_MARSHALING_DEFINES 691 692 // Table 2:52 - Definition of TPMI_RH_HIERARCHY Type 693 TPM_RC 694 TPMI_RH_HIERARCHY_Unmarshal(TPMI_RH_HIERARCHY *target, 695 BYTE **buffer, INT32 *size, BOOL flag); 696 #if !USE_MARSHALING_DEFINES 697 UINT16 698 TPMI_RH_HIERARCHY_Marshal(TPMI_RH_HIERARCHY *source, BYTE **buffer, INT32 *size); 699 #else 700 #define TPMI_RH_HIERARCHY_Marshal(source, buffer, size) \ 701 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 702 #endif // !USE_MARSHALING_DEFINES 703 704 // Table 2:53 - Definition of TPMI_RH_ENABLES Type 705 TPM_RC 706 TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES *target, 707 BYTE **buffer, INT32 *size, BOOL flag); 708 #if !USE_MARSHALING_DEFINES 709 UINT16 710 TPMI_RH_ENABLES_Marshal(TPMI_RH_ENABLES *source, BYTE **buffer, INT32 *size); 711 #else 712 #define TPMI_RH_ENABLES_Marshal(source, buffer, size) \ 713 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 714 #endif // !USE_MARSHALING_DEFINES 715 716 // Table 2:54 - Definition of TPMI_RH_HIERARCHY_AUTH Type 717 TPM_RC 718 TPMI_RH_HIERARCHY_AUTH_Unmarshal(TPMI_RH_HIERARCHY_AUTH *target, 719 BYTE **buffer, INT32 *size); 720 721 // Table 2:55 - Definition of TPMI_RH_HIERARCHY_POLICY Type 722 TPM_RC 723 TPMI_RH_HIERARCHY_POLICY_Unmarshal(TPMI_RH_HIERARCHY_POLICY *target, 724 BYTE **buffer, INT32 *size); 725 726 // Table 2:56 - Definition of TPMI_RH_PLATFORM Type 727 TPM_RC 728 TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM *target, BYTE **buffer, INT32 *size); 729 730 // Table 2:57 - Definition of TPMI_RH_OWNER Type 731 TPM_RC 732 TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER *target, 733 BYTE **buffer, INT32 *size, BOOL flag); 734 735 // Table 2:58 - Definition of TPMI_RH_ENDORSEMENT Type 736 TPM_RC 737 TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT *target, 738 BYTE **buffer, INT32 *size, BOOL flag); 739 740 // Table 2:59 - Definition of TPMI_RH_PROVISION Type 741 TPM_RC 742 TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION *target, BYTE **buffer, INT32 *size); 743 744 // Table 2:60 - Definition of TPMI_RH_CLEAR Type 745 TPM_RC 746 TPMI_RH_CLEAR_Unmarshal(TPMI_RH_CLEAR *target, BYTE **buffer, INT32 *size); 747 748 // Table 2:61 - Definition of TPMI_RH_NV_AUTH Type 749 TPM_RC 750 TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH *target, BYTE **buffer, INT32 *size); 751 752 // Table 2:62 - Definition of TPMI_RH_LOCKOUT Type 753 TPM_RC 754 TPMI_RH_LOCKOUT_Unmarshal(TPMI_RH_LOCKOUT *target, BYTE **buffer, INT32 *size); 755 756 // Table 2:63 - Definition of TPMI_RH_NV_INDEX Type 757 TPM_RC 758 TPMI_RH_NV_INDEX_Unmarshal(TPMI_RH_NV_INDEX *target, BYTE **buffer, INT32 *size); 759 #if !USE_MARSHALING_DEFINES 760 UINT16 761 TPMI_RH_NV_INDEX_Marshal(TPMI_RH_NV_INDEX *source, BYTE **buffer, INT32 *size); 762 #else 763 #define TPMI_RH_NV_INDEX_Marshal(source, buffer, size) \ 764 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 765 #endif // !USE_MARSHALING_DEFINES 766 767 // Table 2:64 - Definition of TPMI_RH_AC Type 768 TPM_RC 769 TPMI_RH_AC_Unmarshal(TPMI_RH_AC *target, BYTE **buffer, INT32 *size); 770 771 // Table 2:65 - Definition of TPMI_RH_ACT Type 772 TPM_RC 773 TPMI_RH_ACT_Unmarshal(TPMI_RH_ACT *target, BYTE **buffer, INT32 *size); 774 #if !USE_MARSHALING_DEFINES 775 UINT16 776 TPMI_RH_ACT_Marshal(TPMI_RH_ACT *source, BYTE **buffer, INT32 *size); 777 #else 778 #define TPMI_RH_ACT_Marshal(source, buffer, size) \ 779 TPM_HANDLE_Marshal((TPM_HANDLE *)(source), (buffer), (size)) 780 #endif // !USE_MARSHALING_DEFINES 781 782 // Table 2:66 - Definition of TPMI_ALG_HASH Type 783 TPM_RC 784 TPMI_ALG_HASH_Unmarshal(TPMI_ALG_HASH *target, 785 BYTE **buffer, INT32 *size, BOOL flag); 786 #if !USE_MARSHALING_DEFINES 787 UINT16 788 TPMI_ALG_HASH_Marshal(TPMI_ALG_HASH *source, BYTE **buffer, INT32 *size); 789 #else 790 #define TPMI_ALG_HASH_Marshal(source, buffer, size) \ 791 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 792 #endif // !USE_MARSHALING_DEFINES 793 794 // Table 2:67 - Definition of TPMI_ALG_ASYM Type 795 TPM_RC 796 TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM *target, 797 BYTE **buffer, INT32 *size, BOOL flag); 798 #if !USE_MARSHALING_DEFINES 799 UINT16 800 TPMI_ALG_ASYM_Marshal(TPMI_ALG_ASYM *source, BYTE **buffer, INT32 *size); 801 #else 802 #define TPMI_ALG_ASYM_Marshal(source, buffer, size) \ 803 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 804 #endif // !USE_MARSHALING_DEFINES 805 806 // Table 2:68 - Definition of TPMI_ALG_SYM Type 807 TPM_RC 808 TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM *target, BYTE **buffer, INT32 *size, BOOL flag); 809 #if !USE_MARSHALING_DEFINES 810 UINT16 811 TPMI_ALG_SYM_Marshal(TPMI_ALG_SYM *source, BYTE **buffer, INT32 *size); 812 #else 813 #define TPMI_ALG_SYM_Marshal(source, buffer, size) \ 814 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 815 #endif // !USE_MARSHALING_DEFINES 816 817 // Table 2:69 - Definition of TPMI_ALG_SYM_OBJECT Type 818 TPM_RC 819 TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT *target, 820 BYTE **buffer, INT32 *size, BOOL flag); 821 #if !USE_MARSHALING_DEFINES 822 UINT16 823 TPMI_ALG_SYM_OBJECT_Marshal(TPMI_ALG_SYM_OBJECT *source, 824 BYTE **buffer, INT32 *size); 825 #else 826 #define TPMI_ALG_SYM_OBJECT_Marshal(source, buffer, size) \ 827 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 828 #endif // !USE_MARSHALING_DEFINES 829 830 // Table 2:70 - Definition of TPMI_ALG_SYM_MODE Type 831 TPM_RC 832 TPMI_ALG_SYM_MODE_Unmarshal(TPMI_ALG_SYM_MODE *target, 833 BYTE **buffer, INT32 *size, BOOL flag); 834 #if !USE_MARSHALING_DEFINES 835 UINT16 836 TPMI_ALG_SYM_MODE_Marshal(TPMI_ALG_SYM_MODE *source, BYTE **buffer, INT32 *size); 837 #else 838 #define TPMI_ALG_SYM_MODE_Marshal(source, buffer, size) \ 839 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 840 #endif // !USE_MARSHALING_DEFINES 841 842 // Table 2:71 - Definition of TPMI_ALG_KDF Type 843 TPM_RC 844 TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF *target, BYTE **buffer, INT32 *size, BOOL flag); 845 #if !USE_MARSHALING_DEFINES 846 UINT16 847 TPMI_ALG_KDF_Marshal(TPMI_ALG_KDF *source, BYTE **buffer, INT32 *size); 848 #else 849 #define TPMI_ALG_KDF_Marshal(source, buffer, size) \ 850 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 851 #endif // !USE_MARSHALING_DEFINES 852 853 // Table 2:72 - Definition of TPMI_ALG_SIG_SCHEME Type 854 TPM_RC 855 TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME *target, 856 BYTE **buffer, INT32 *size, BOOL flag); 857 #if !USE_MARSHALING_DEFINES 858 UINT16 859 TPMI_ALG_SIG_SCHEME_Marshal(TPMI_ALG_SIG_SCHEME *source, 860 BYTE **buffer, INT32 *size); 861 #else 862 #define TPMI_ALG_SIG_SCHEME_Marshal(source, buffer, size) \ 863 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 864 #endif // !USE_MARSHALING_DEFINES 865 866 // Table 2:73 - Definition of TPMI_ECC_KEY_EXCHANGE Type 867 #if ALG_ECC 868 TPM_RC 869 TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE *target, 870 BYTE **buffer, INT32 *size, BOOL flag); 871 #if !USE_MARSHALING_DEFINES 872 UINT16 873 TPMI_ECC_KEY_EXCHANGE_Marshal(TPMI_ECC_KEY_EXCHANGE *source, 874 BYTE **buffer, INT32 *size); 875 #else 876 #define TPMI_ECC_KEY_EXCHANGE_Marshal(source, buffer, size) \ 877 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 878 #endif // !USE_MARSHALING_DEFINES 879 #endif // ALG_ECC 880 881 // Table 2:74 - Definition of TPMI_ST_COMMAND_TAG Type 882 TPM_RC 883 TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG *target, 884 BYTE **buffer, INT32 *size); 885 #if !USE_MARSHALING_DEFINES 886 UINT16 887 TPMI_ST_COMMAND_TAG_Marshal(TPMI_ST_COMMAND_TAG *source, 888 BYTE **buffer, INT32 *size); 889 #else 890 #define TPMI_ST_COMMAND_TAG_Marshal(source, buffer, size) \ 891 TPM_ST_Marshal((TPM_ST *)(source), (buffer), (size)) 892 #endif // !USE_MARSHALING_DEFINES 893 894 // Table 2:75 - Definition of TPMI_ALG_MAC_SCHEME Type 895 TPM_RC 896 TPMI_ALG_MAC_SCHEME_Unmarshal(TPMI_ALG_MAC_SCHEME *target, 897 BYTE **buffer, INT32 *size, BOOL flag); 898 #if !USE_MARSHALING_DEFINES 899 UINT16 900 TPMI_ALG_MAC_SCHEME_Marshal(TPMI_ALG_MAC_SCHEME *source, 901 BYTE **buffer, INT32 *size); 902 #else 903 #define TPMI_ALG_MAC_SCHEME_Marshal(source, buffer, size) \ 904 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 905 #endif // !USE_MARSHALING_DEFINES 906 907 // Table 2:76 - Definition of TPMI_ALG_CIPHER_MODE Type 908 TPM_RC 909 TPMI_ALG_CIPHER_MODE_Unmarshal(TPMI_ALG_CIPHER_MODE *target, 910 BYTE **buffer, INT32 *size, BOOL flag); 911 #if !USE_MARSHALING_DEFINES 912 UINT16 913 TPMI_ALG_CIPHER_MODE_Marshal(TPMI_ALG_CIPHER_MODE *source, 914 BYTE **buffer, INT32 *size); 915 #else 916 #define TPMI_ALG_CIPHER_MODE_Marshal(source, buffer, size) \ 917 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 918 #endif // !USE_MARSHALING_DEFINES 919 920 // Table 2:77 - Definition of TPMS_EMPTY Structure 921 TPM_RC 922 TPMS_EMPTY_Unmarshal(TPMS_EMPTY *target, BYTE **buffer, INT32 *size); 923 UINT16 924 TPMS_EMPTY_Marshal(TPMS_EMPTY *source, BYTE **buffer, INT32 *size); 925 926 // Table 2:78 - Definition of TPMS_ALGORITHM_DESCRIPTION Structure 927 UINT16 928 TPMS_ALGORITHM_DESCRIPTION_Marshal(TPMS_ALGORITHM_DESCRIPTION *source, 929 BYTE **buffer, INT32 *size); 930 931 // Table 2:79 - Definition of TPMU_HA Union 932 TPM_RC 933 TPMU_HA_Unmarshal(TPMU_HA *target, BYTE **buffer, INT32 *size, UINT32 selector); 934 UINT16 935 TPMU_HA_Marshal(TPMU_HA *source, BYTE **buffer, INT32 *size, UINT32 selector); 936 937 // Table 2:80 - Definition of TPMT_HA Structure 938 TPM_RC 939 TPMT_HA_Unmarshal(TPMT_HA *target, BYTE **buffer, INT32 *size, BOOL flag); 940 UINT16 941 TPMT_HA_Marshal(TPMT_HA *source, BYTE **buffer, INT32 *size); 942 943 // Table 2:81 - Definition of TPM2B_DIGEST Structure 944 TPM_RC 945 TPM2B_DIGEST_Unmarshal(TPM2B_DIGEST *target, BYTE **buffer, INT32 *size); 946 UINT16 947 TPM2B_DIGEST_Marshal(TPM2B_DIGEST *source, BYTE **buffer, INT32 *size); 948 949 // Table 2:82 - Definition of TPM2B_DATA Structure 950 TPM_RC 951 TPM2B_DATA_Unmarshal(TPM2B_DATA *target, BYTE **buffer, INT32 *size); 952 UINT16 953 TPM2B_DATA_Marshal(TPM2B_DATA *source, BYTE **buffer, INT32 *size); 954 955 // Table 2:83 - Definition of Types for TPM2B_NONCE 956 #if !USE_MARSHALING_DEFINES 957 TPM_RC 958 TPM2B_NONCE_Unmarshal(TPM2B_NONCE *target, BYTE **buffer, INT32 *size); 959 #else 960 #define TPM2B_NONCE_Unmarshal(target, buffer, size) \ 961 TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)(target), (buffer), (size)) 962 #endif // !USE_MARSHALING_DEFINES 963 #if !USE_MARSHALING_DEFINES 964 UINT16 965 TPM2B_NONCE_Marshal(TPM2B_NONCE *source, BYTE **buffer, INT32 *size); 966 #else 967 #define TPM2B_NONCE_Marshal(source, buffer, size) \ 968 TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)(source), (buffer), (size)) 969 #endif // !USE_MARSHALING_DEFINES 970 971 // Table 2:84 - Definition of Types for TPM2B_AUTH 972 #if !USE_MARSHALING_DEFINES 973 TPM_RC 974 TPM2B_AUTH_Unmarshal(TPM2B_AUTH *target, BYTE **buffer, INT32 *size); 975 #else 976 #define TPM2B_AUTH_Unmarshal(target, buffer, size) \ 977 TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)(target), (buffer), (size)) 978 #endif // !USE_MARSHALING_DEFINES 979 #if !USE_MARSHALING_DEFINES 980 UINT16 981 TPM2B_AUTH_Marshal(TPM2B_AUTH *source, BYTE **buffer, INT32 *size); 982 #else 983 #define TPM2B_AUTH_Marshal(source, buffer, size) \ 984 TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)(source), (buffer), (size)) 985 #endif // !USE_MARSHALING_DEFINES 986 987 // Table 2:85 - Definition of Types for TPM2B_OPERAND 988 #if !USE_MARSHALING_DEFINES 989 TPM_RC 990 TPM2B_OPERAND_Unmarshal(TPM2B_OPERAND *target, BYTE **buffer, INT32 *size); 991 #else 992 #define TPM2B_OPERAND_Unmarshal(target, buffer, size) \ 993 TPM2B_DIGEST_Unmarshal((TPM2B_DIGEST *)(target), (buffer), (size)) 994 #endif // !USE_MARSHALING_DEFINES 995 #if !USE_MARSHALING_DEFINES 996 UINT16 997 TPM2B_OPERAND_Marshal(TPM2B_OPERAND *source, BYTE **buffer, INT32 *size); 998 #else 999 #define TPM2B_OPERAND_Marshal(source, buffer, size) \ 1000 TPM2B_DIGEST_Marshal((TPM2B_DIGEST *)(source), (buffer), (size)) 1001 #endif // !USE_MARSHALING_DEFINES 1002 1003 // Table 2:86 - Definition of TPM2B_EVENT Structure 1004 TPM_RC 1005 TPM2B_EVENT_Unmarshal(TPM2B_EVENT *target, BYTE **buffer, INT32 *size); 1006 UINT16 1007 TPM2B_EVENT_Marshal(TPM2B_EVENT *source, BYTE **buffer, INT32 *size); 1008 1009 // Table 2:87 - Definition of TPM2B_MAX_BUFFER Structure 1010 TPM_RC 1011 TPM2B_MAX_BUFFER_Unmarshal(TPM2B_MAX_BUFFER *target, BYTE **buffer, INT32 *size); 1012 UINT16 1013 TPM2B_MAX_BUFFER_Marshal(TPM2B_MAX_BUFFER *source, BYTE **buffer, INT32 *size); 1014 1015 // Table 2:88 - Definition of TPM2B_MAX_NV_BUFFER Structure 1016 TPM_RC 1017 TPM2B_MAX_NV_BUFFER_Unmarshal(TPM2B_MAX_NV_BUFFER *target, 1018 BYTE **buffer, INT32 *size); 1019 UINT16 1020 TPM2B_MAX_NV_BUFFER_Marshal(TPM2B_MAX_NV_BUFFER *source, 1021 BYTE **buffer, INT32 *size); 1022 1023 // Table 2:89 - Definition of TPM2B_TIMEOUT Structure 1024 TPM_RC 1025 TPM2B_TIMEOUT_Unmarshal(TPM2B_TIMEOUT *target, BYTE **buffer, INT32 *size); 1026 UINT16 1027 TPM2B_TIMEOUT_Marshal(TPM2B_TIMEOUT *source, BYTE **buffer, INT32 *size); 1028 1029 // Table 2:90 - Definition of TPM2B_IV Structure 1030 TPM_RC 1031 TPM2B_IV_Unmarshal(TPM2B_IV *target, BYTE **buffer, INT32 *size); 1032 UINT16 1033 TPM2B_IV_Marshal(TPM2B_IV *source, BYTE **buffer, INT32 *size); 1034 1035 // Table 2:91 - Definition of TPMU_NAME Union 1036 // Table 2:92 - Definition of TPM2B_NAME Structure 1037 TPM_RC 1038 TPM2B_NAME_Unmarshal(TPM2B_NAME *target, BYTE **buffer, INT32 *size); 1039 UINT16 1040 TPM2B_NAME_Marshal(TPM2B_NAME *source, BYTE **buffer, INT32 *size); 1041 1042 // Table 2:93 - Definition of TPMS_PCR_SELECT Structure 1043 TPM_RC 1044 TPMS_PCR_SELECT_Unmarshal(TPMS_PCR_SELECT *target, BYTE **buffer, INT32 *size); 1045 UINT16 1046 TPMS_PCR_SELECT_Marshal(TPMS_PCR_SELECT *source, BYTE **buffer, INT32 *size); 1047 1048 // Table 2:94 - Definition of TPMS_PCR_SELECTION Structure 1049 TPM_RC 1050 TPMS_PCR_SELECTION_Unmarshal(TPMS_PCR_SELECTION *target, 1051 BYTE **buffer, INT32 *size); 1052 UINT16 1053 TPMS_PCR_SELECTION_Marshal(TPMS_PCR_SELECTION *source, BYTE **buffer, INT32 *size); 1054 1055 // Table 2:97 - Definition of TPMT_TK_CREATION Structure 1056 TPM_RC 1057 TPMT_TK_CREATION_Unmarshal(TPMT_TK_CREATION *target, BYTE **buffer, INT32 *size); 1058 UINT16 1059 TPMT_TK_CREATION_Marshal(TPMT_TK_CREATION *source, BYTE **buffer, INT32 *size); 1060 1061 // Table 2:98 - Definition of TPMT_TK_VERIFIED Structure 1062 TPM_RC 1063 TPMT_TK_VERIFIED_Unmarshal(TPMT_TK_VERIFIED *target, BYTE **buffer, INT32 *size); 1064 UINT16 1065 TPMT_TK_VERIFIED_Marshal(TPMT_TK_VERIFIED *source, BYTE **buffer, INT32 *size); 1066 1067 // Table 2:99 - Definition of TPMT_TK_AUTH Structure 1068 TPM_RC 1069 TPMT_TK_AUTH_Unmarshal(TPMT_TK_AUTH *target, BYTE **buffer, INT32 *size); 1070 UINT16 1071 TPMT_TK_AUTH_Marshal(TPMT_TK_AUTH *source, BYTE **buffer, INT32 *size); 1072 1073 // Table 2:100 - Definition of TPMT_TK_HASHCHECK Structure 1074 TPM_RC 1075 TPMT_TK_HASHCHECK_Unmarshal(TPMT_TK_HASHCHECK *target, BYTE **buffer, INT32 *size); 1076 UINT16 1077 TPMT_TK_HASHCHECK_Marshal(TPMT_TK_HASHCHECK *source, BYTE **buffer, INT32 *size); 1078 1079 // Table 2:101 - Definition of TPMS_ALG_PROPERTY Structure 1080 UINT16 1081 TPMS_ALG_PROPERTY_Marshal(TPMS_ALG_PROPERTY *source, BYTE **buffer, INT32 *size); 1082 1083 // Table 2:102 - Definition of TPMS_TAGGED_PROPERTY Structure 1084 UINT16 1085 TPMS_TAGGED_PROPERTY_Marshal(TPMS_TAGGED_PROPERTY *source, 1086 BYTE **buffer, INT32 *size); 1087 1088 // Table 2:103 - Definition of TPMS_TAGGED_PCR_SELECT Structure 1089 UINT16 1090 TPMS_TAGGED_PCR_SELECT_Marshal(TPMS_TAGGED_PCR_SELECT *source, 1091 BYTE **buffer, INT32 *size); 1092 1093 // Table 2:104 - Definition of TPMS_TAGGED_POLICY Structure 1094 UINT16 1095 TPMS_TAGGED_POLICY_Marshal(TPMS_TAGGED_POLICY *source, BYTE **buffer, INT32 *size); 1096 1097 // Table 2:105 - Definition of TPMS_ACT_DATA Structure 1098 UINT16 1099 TPMS_ACT_DATA_Marshal(TPMS_ACT_DATA *source, BYTE **buffer, INT32 *size); 1100 1101 // Table 2:106 - Definition of TPML_CC Structure 1102 TPM_RC 1103 TPML_CC_Unmarshal(TPML_CC *target, BYTE **buffer, INT32 *size); 1104 UINT16 1105 TPML_CC_Marshal(TPML_CC *source, BYTE **buffer, INT32 *size); 1106 1107 // Table 2:107 - Definition of TPML_CCA Structure 1108 UINT16 1109 TPML_CCA_Marshal(TPML_CCA *source, BYTE **buffer, INT32 *size); 1110 1111 // Table 2:108 - Definition of TPML_ALG Structure 1112 TPM_RC 1113 TPML_ALG_Unmarshal(TPML_ALG *target, BYTE **buffer, INT32 *size); 1114 UINT16 1115 TPML_ALG_Marshal(TPML_ALG *source, BYTE **buffer, INT32 *size); 1116 1117 // Table 2:109 - Definition of TPML_HANDLE Structure 1118 UINT16 1119 TPML_HANDLE_Marshal(TPML_HANDLE *source, BYTE **buffer, INT32 *size); 1120 1121 // Table 2:110 - Definition of TPML_DIGEST Structure 1122 TPM_RC 1123 TPML_DIGEST_Unmarshal(TPML_DIGEST *target, BYTE **buffer, INT32 *size); 1124 UINT16 1125 TPML_DIGEST_Marshal(TPML_DIGEST *source, BYTE **buffer, INT32 *size); 1126 1127 // Table 2:111 - Definition of TPML_DIGEST_VALUES Structure 1128 TPM_RC 1129 TPML_DIGEST_VALUES_Unmarshal(TPML_DIGEST_VALUES *target, 1130 BYTE **buffer, INT32 *size); 1131 UINT16 1132 TPML_DIGEST_VALUES_Marshal(TPML_DIGEST_VALUES *source, BYTE **buffer, INT32 *size); 1133 1134 // Table 2:112 - Definition of TPML_PCR_SELECTION Structure 1135 TPM_RC 1136 TPML_PCR_SELECTION_Unmarshal(TPML_PCR_SELECTION *target, 1137 BYTE **buffer, INT32 *size); 1138 UINT16 1139 TPML_PCR_SELECTION_Marshal(TPML_PCR_SELECTION *source, BYTE **buffer, INT32 *size); 1140 1141 // Table 2:113 - Definition of TPML_ALG_PROPERTY Structure 1142 UINT16 1143 TPML_ALG_PROPERTY_Marshal(TPML_ALG_PROPERTY *source, BYTE **buffer, INT32 *size); 1144 1145 // Table 2:114 - Definition of TPML_TAGGED_TPM_PROPERTY Structure 1146 UINT16 1147 TPML_TAGGED_TPM_PROPERTY_Marshal(TPML_TAGGED_TPM_PROPERTY *source, 1148 BYTE **buffer, INT32 *size); 1149 1150 // Table 2:115 - Definition of TPML_TAGGED_PCR_PROPERTY Structure 1151 UINT16 1152 TPML_TAGGED_PCR_PROPERTY_Marshal(TPML_TAGGED_PCR_PROPERTY *source, 1153 BYTE **buffer, INT32 *size); 1154 1155 // Table 2:116 - Definition of TPML_ECC_CURVE Structure 1156 #if ALG_ECC 1157 UINT16 1158 TPML_ECC_CURVE_Marshal(TPML_ECC_CURVE *source, BYTE **buffer, INT32 *size); 1159 #endif // ALG_ECC 1160 1161 // Table 2:117 - Definition of TPML_TAGGED_POLICY Structure 1162 UINT16 1163 TPML_TAGGED_POLICY_Marshal(TPML_TAGGED_POLICY *source, BYTE **buffer, INT32 *size); 1164 1165 // Table 2:118 - Definition of TPML_ACT_DATA Structure 1166 UINT16 1167 TPML_ACT_DATA_Marshal(TPML_ACT_DATA *source, BYTE **buffer, INT32 *size); 1168 1169 // Table 2:119 - Definition of TPMU_CAPABILITIES Union 1170 UINT16 1171 TPMU_CAPABILITIES_Marshal(TPMU_CAPABILITIES *source, 1172 BYTE **buffer, INT32 *size, UINT32 selector); 1173 1174 // Table 2:120 - Definition of TPMS_CAPABILITY_DATA Structure 1175 UINT16 1176 TPMS_CAPABILITY_DATA_Marshal(TPMS_CAPABILITY_DATA *source, 1177 BYTE **buffer, INT32 *size); 1178 1179 // Table 2:121 - Definition of TPMS_CLOCK_INFO Structure 1180 TPM_RC 1181 TPMS_CLOCK_INFO_Unmarshal(TPMS_CLOCK_INFO *target, BYTE **buffer, INT32 *size); 1182 UINT16 1183 TPMS_CLOCK_INFO_Marshal(TPMS_CLOCK_INFO *source, BYTE **buffer, INT32 *size); 1184 1185 // Table 2:122 - Definition of TPMS_TIME_INFO Structure 1186 TPM_RC 1187 TPMS_TIME_INFO_Unmarshal(TPMS_TIME_INFO *target, BYTE **buffer, INT32 *size); 1188 UINT16 1189 TPMS_TIME_INFO_Marshal(TPMS_TIME_INFO *source, BYTE **buffer, INT32 *size); 1190 1191 // Table 2:123 - Definition of TPMS_TIME_ATTEST_INFO Structure 1192 UINT16 1193 TPMS_TIME_ATTEST_INFO_Marshal(TPMS_TIME_ATTEST_INFO *source, 1194 BYTE **buffer, INT32 *size); 1195 1196 // Table 2:124 - Definition of TPMS_CERTIFY_INFO Structure 1197 UINT16 1198 TPMS_CERTIFY_INFO_Marshal(TPMS_CERTIFY_INFO *source, BYTE **buffer, INT32 *size); 1199 1200 // Table 2:125 - Definition of TPMS_QUOTE_INFO Structure 1201 UINT16 1202 TPMS_QUOTE_INFO_Marshal(TPMS_QUOTE_INFO *source, BYTE **buffer, INT32 *size); 1203 1204 // Table 2:126 - Definition of TPMS_COMMAND_AUDIT_INFO Structure 1205 UINT16 1206 TPMS_COMMAND_AUDIT_INFO_Marshal(TPMS_COMMAND_AUDIT_INFO *source, 1207 BYTE **buffer, INT32 *size); 1208 1209 // Table 2:127 - Definition of TPMS_SESSION_AUDIT_INFO Structure 1210 UINT16 1211 TPMS_SESSION_AUDIT_INFO_Marshal(TPMS_SESSION_AUDIT_INFO *source, 1212 BYTE **buffer, INT32 *size); 1213 1214 // Table 2:128 - Definition of TPMS_CREATION_INFO Structure 1215 UINT16 1216 TPMS_CREATION_INFO_Marshal(TPMS_CREATION_INFO *source, BYTE **buffer, INT32 *size); 1217 1218 // Table 2:129 - Definition of TPMS_NV_CERTIFY_INFO Structure 1219 UINT16 1220 TPMS_NV_CERTIFY_INFO_Marshal(TPMS_NV_CERTIFY_INFO *source, 1221 BYTE **buffer, INT32 *size); 1222 1223 // Table 2:130 - Definition of TPMS_NV_DIGEST_CERTIFY_INFO Structure 1224 UINT16 1225 TPMS_NV_DIGEST_CERTIFY_INFO_Marshal(TPMS_NV_DIGEST_CERTIFY_INFO *source, 1226 BYTE **buffer, INT32 *size); 1227 1228 // Table 2:131 - Definition of TPMI_ST_ATTEST Type 1229 #if !USE_MARSHALING_DEFINES 1230 UINT16 1231 TPMI_ST_ATTEST_Marshal(TPMI_ST_ATTEST *source, BYTE **buffer, INT32 *size); 1232 #else 1233 #define TPMI_ST_ATTEST_Marshal(source, buffer, size) \ 1234 TPM_ST_Marshal((TPM_ST *)(source), (buffer), (size)) 1235 #endif // !USE_MARSHALING_DEFINES 1236 1237 // Table 2:132 - Definition of TPMU_ATTEST Union 1238 UINT16 1239 TPMU_ATTEST_Marshal(TPMU_ATTEST *source, 1240 BYTE **buffer, INT32 *size, UINT32 selector); 1241 1242 // Table 2:133 - Definition of TPMS_ATTEST Structure 1243 UINT16 1244 TPMS_ATTEST_Marshal(TPMS_ATTEST *source, BYTE **buffer, INT32 *size); 1245 1246 // Table 2:134 - Definition of TPM2B_ATTEST Structure 1247 UINT16 1248 TPM2B_ATTEST_Marshal(TPM2B_ATTEST *source, BYTE **buffer, INT32 *size); 1249 1250 // Table 2:135 - Definition of TPMS_AUTH_COMMAND Structure 1251 TPM_RC 1252 TPMS_AUTH_COMMAND_Unmarshal(TPMS_AUTH_COMMAND *target, BYTE **buffer, INT32 *size); 1253 1254 // Table 2:136 - Definition of TPMS_AUTH_RESPONSE Structure 1255 UINT16 1256 TPMS_AUTH_RESPONSE_Marshal(TPMS_AUTH_RESPONSE *source, BYTE **buffer, INT32 *size); 1257 1258 // Table 2:137 - Definition of TPMI_TDES_KEY_BITS Type 1259 #if ALG_TDES 1260 TPM_RC 1261 TPMI_TDES_KEY_BITS_Unmarshal(TPMI_TDES_KEY_BITS *target, 1262 BYTE **buffer, INT32 *size); 1263 #if !USE_MARSHALING_DEFINES 1264 UINT16 1265 TPMI_TDES_KEY_BITS_Marshal(TPMI_TDES_KEY_BITS *source, BYTE **buffer, INT32 *size); 1266 #else 1267 #define TPMI_TDES_KEY_BITS_Marshal(source, buffer, size) \ 1268 TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)(source), (buffer), (size)) 1269 #endif // !USE_MARSHALING_DEFINES 1270 #endif // ALG_TDES 1271 1272 // Table 2:137 - Definition of TPMI_AES_KEY_BITS Type 1273 #if ALG_AES 1274 TPM_RC 1275 TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS *target, BYTE **buffer, INT32 *size); 1276 #if !USE_MARSHALING_DEFINES 1277 UINT16 1278 TPMI_AES_KEY_BITS_Marshal(TPMI_AES_KEY_BITS *source, BYTE **buffer, INT32 *size); 1279 #else 1280 #define TPMI_AES_KEY_BITS_Marshal(source, buffer, size) \ 1281 TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)(source), (buffer), (size)) 1282 #endif // !USE_MARSHALING_DEFINES 1283 #endif // ALG_AES 1284 1285 // Table 2:137 - Definition of TPMI_SM4_KEY_BITS Type 1286 #if ALG_SM4 1287 TPM_RC 1288 TPMI_SM4_KEY_BITS_Unmarshal(TPMI_SM4_KEY_BITS *target, BYTE **buffer, INT32 *size); 1289 #if !USE_MARSHALING_DEFINES 1290 UINT16 1291 TPMI_SM4_KEY_BITS_Marshal(TPMI_SM4_KEY_BITS *source, BYTE **buffer, INT32 *size); 1292 #else 1293 #define TPMI_SM4_KEY_BITS_Marshal(source, buffer, size) \ 1294 TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)(source), (buffer), (size)) 1295 #endif // !USE_MARSHALING_DEFINES 1296 #endif // ALG_SM4 1297 1298 // Table 2:137 - Definition of TPMI_CAMELLIA_KEY_BITS Type 1299 #if ALG_CAMELLIA 1300 TPM_RC 1301 TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS *target, 1302 BYTE **buffer, INT32 *size); 1303 #if !USE_MARSHALING_DEFINES 1304 UINT16 1305 TPMI_CAMELLIA_KEY_BITS_Marshal(TPMI_CAMELLIA_KEY_BITS *source, 1306 BYTE **buffer, INT32 *size); 1307 #else 1308 #define TPMI_CAMELLIA_KEY_BITS_Marshal(source, buffer, size) \ 1309 TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)(source), (buffer), (size)) 1310 #endif // !USE_MARSHALING_DEFINES 1311 #endif // ALG_CAMELLIA 1312 1313 // Table 2:138 - Definition of TPMU_SYM_KEY_BITS Union 1314 TPM_RC 1315 TPMU_SYM_KEY_BITS_Unmarshal(TPMU_SYM_KEY_BITS *target, 1316 BYTE **buffer, INT32 *size, UINT32 selector); 1317 UINT16 1318 TPMU_SYM_KEY_BITS_Marshal(TPMU_SYM_KEY_BITS *source, 1319 BYTE **buffer, INT32 *size, UINT32 selector); 1320 1321 // Table 2:139 - Definition of TPMU_SYM_MODE Union 1322 TPM_RC 1323 TPMU_SYM_MODE_Unmarshal(TPMU_SYM_MODE *target, 1324 BYTE **buffer, INT32 *size, UINT32 selector); 1325 UINT16 1326 TPMU_SYM_MODE_Marshal(TPMU_SYM_MODE *source, 1327 BYTE **buffer, INT32 *size, UINT32 selector); 1328 1329 // Table 2:141 - Definition of TPMT_SYM_DEF Structure 1330 TPM_RC 1331 TPMT_SYM_DEF_Unmarshal(TPMT_SYM_DEF *target, BYTE **buffer, INT32 *size, BOOL flag); 1332 UINT16 1333 TPMT_SYM_DEF_Marshal(TPMT_SYM_DEF *source, BYTE **buffer, INT32 *size); 1334 1335 // Table 2:142 - Definition of TPMT_SYM_DEF_OBJECT Structure 1336 TPM_RC 1337 TPMT_SYM_DEF_OBJECT_Unmarshal(TPMT_SYM_DEF_OBJECT *target, 1338 BYTE **buffer, INT32 *size, BOOL flag); 1339 UINT16 1340 TPMT_SYM_DEF_OBJECT_Marshal(TPMT_SYM_DEF_OBJECT *source, 1341 BYTE **buffer, INT32 *size); 1342 1343 // Table 2:143 - Definition of TPM2B_SYM_KEY Structure 1344 TPM_RC 1345 TPM2B_SYM_KEY_Unmarshal(TPM2B_SYM_KEY *target, BYTE **buffer, INT32 *size); 1346 UINT16 1347 TPM2B_SYM_KEY_Marshal(TPM2B_SYM_KEY *source, BYTE **buffer, INT32 *size); 1348 1349 // Table 2:144 - Definition of TPMS_SYMCIPHER_PARMS Structure 1350 TPM_RC 1351 TPMS_SYMCIPHER_PARMS_Unmarshal(TPMS_SYMCIPHER_PARMS *target, 1352 BYTE **buffer, INT32 *size); 1353 UINT16 1354 TPMS_SYMCIPHER_PARMS_Marshal(TPMS_SYMCIPHER_PARMS *source, 1355 BYTE **buffer, INT32 *size); 1356 1357 // Table 2:145 - Definition of TPM2B_LABEL Structure 1358 TPM_RC 1359 TPM2B_LABEL_Unmarshal(TPM2B_LABEL *target, BYTE **buffer, INT32 *size); 1360 UINT16 1361 TPM2B_LABEL_Marshal(TPM2B_LABEL *source, BYTE **buffer, INT32 *size); 1362 1363 // Table 2:146 - Definition of TPMS_DERIVE Structure 1364 TPM_RC 1365 TPMS_DERIVE_Unmarshal(TPMS_DERIVE *target, BYTE **buffer, INT32 *size); 1366 UINT16 1367 TPMS_DERIVE_Marshal(TPMS_DERIVE *source, BYTE **buffer, INT32 *size); 1368 1369 // Table 2:147 - Definition of TPM2B_DERIVE Structure 1370 TPM_RC 1371 TPM2B_DERIVE_Unmarshal(TPM2B_DERIVE *target, BYTE **buffer, INT32 *size); 1372 UINT16 1373 TPM2B_DERIVE_Marshal(TPM2B_DERIVE *source, BYTE **buffer, INT32 *size); 1374 1375 // Table 2:148 - Definition of TPMU_SENSITIVE_CREATE Union 1376 // Table 2:149 - Definition of TPM2B_SENSITIVE_DATA Structure 1377 TPM_RC 1378 TPM2B_SENSITIVE_DATA_Unmarshal(TPM2B_SENSITIVE_DATA *target, 1379 BYTE **buffer, INT32 *size); 1380 UINT16 1381 TPM2B_SENSITIVE_DATA_Marshal(TPM2B_SENSITIVE_DATA *source, 1382 BYTE **buffer, INT32 *size); 1383 1384 // Table 2:150 - Definition of TPMS_SENSITIVE_CREATE Structure 1385 TPM_RC 1386 TPMS_SENSITIVE_CREATE_Unmarshal(TPMS_SENSITIVE_CREATE *target, 1387 BYTE **buffer, INT32 *size); 1388 1389 // Table 2:151 - Definition of TPM2B_SENSITIVE_CREATE Structure 1390 TPM_RC 1391 TPM2B_SENSITIVE_CREATE_Unmarshal(TPM2B_SENSITIVE_CREATE *target, 1392 BYTE **buffer, INT32 *size); 1393 1394 // Table 2:152 - Definition of TPMS_SCHEME_HASH Structure 1395 TPM_RC 1396 TPMS_SCHEME_HASH_Unmarshal(TPMS_SCHEME_HASH *target, BYTE **buffer, INT32 *size); 1397 UINT16 1398 TPMS_SCHEME_HASH_Marshal(TPMS_SCHEME_HASH *source, BYTE **buffer, INT32 *size); 1399 1400 // Table 2:153 - Definition of TPMS_SCHEME_ECDAA Structure 1401 #if ALG_ECC 1402 TPM_RC 1403 TPMS_SCHEME_ECDAA_Unmarshal(TPMS_SCHEME_ECDAA *target, BYTE **buffer, INT32 *size); 1404 UINT16 1405 TPMS_SCHEME_ECDAA_Marshal(TPMS_SCHEME_ECDAA *source, BYTE **buffer, INT32 *size); 1406 #endif // ALG_ECC 1407 1408 // Table 2:154 - Definition of TPMI_ALG_KEYEDHASH_SCHEME Type 1409 TPM_RC 1410 TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME *target, 1411 BYTE **buffer, INT32 *size, BOOL flag); 1412 #if !USE_MARSHALING_DEFINES 1413 UINT16 1414 TPMI_ALG_KEYEDHASH_SCHEME_Marshal(TPMI_ALG_KEYEDHASH_SCHEME *source, 1415 BYTE **buffer, INT32 *size); 1416 #else 1417 #define TPMI_ALG_KEYEDHASH_SCHEME_Marshal(source, buffer, size) \ 1418 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 1419 #endif // !USE_MARSHALING_DEFINES 1420 1421 // Table 2:155 - Definition of Types for HMAC_SIG_SCHEME 1422 #if !USE_MARSHALING_DEFINES 1423 TPM_RC 1424 TPMS_SCHEME_HMAC_Unmarshal(TPMS_SCHEME_HMAC *target, BYTE **buffer, INT32 *size); 1425 #else 1426 #define TPMS_SCHEME_HMAC_Unmarshal(target, buffer, size) \ 1427 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1428 (buffer), \ 1429 (size)) 1430 #endif // !USE_MARSHALING_DEFINES 1431 #if !USE_MARSHALING_DEFINES 1432 UINT16 1433 TPMS_SCHEME_HMAC_Marshal(TPMS_SCHEME_HMAC *source, BYTE **buffer, INT32 *size); 1434 #else 1435 #define TPMS_SCHEME_HMAC_Marshal(source, buffer, size) \ 1436 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1437 (buffer), \ 1438 (size)) 1439 #endif // !USE_MARSHALING_DEFINES 1440 1441 // Table 2:156 - Definition of TPMS_SCHEME_XOR Structure 1442 TPM_RC 1443 TPMS_SCHEME_XOR_Unmarshal(TPMS_SCHEME_XOR *target, BYTE **buffer, INT32 *size); 1444 UINT16 1445 TPMS_SCHEME_XOR_Marshal(TPMS_SCHEME_XOR *source, BYTE **buffer, INT32 *size); 1446 1447 // Table 2:157 - Definition of TPMU_SCHEME_KEYEDHASH Union 1448 TPM_RC 1449 TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH *target, 1450 BYTE **buffer, INT32 *size, UINT32 selector); 1451 UINT16 1452 TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH *source, 1453 BYTE **buffer, INT32 *size, UINT32 selector); 1454 1455 // Table 2:158 - Definition of TPMT_KEYEDHASH_SCHEME Structure 1456 TPM_RC 1457 TPMT_KEYEDHASH_SCHEME_Unmarshal(TPMT_KEYEDHASH_SCHEME *target, 1458 BYTE **buffer, INT32 *size, BOOL flag); 1459 UINT16 1460 TPMT_KEYEDHASH_SCHEME_Marshal(TPMT_KEYEDHASH_SCHEME *source, 1461 BYTE **buffer, INT32 *size); 1462 1463 // Table 2:159 - Definition of Types for RSA Signature Schemes 1464 #if ALG_RSA 1465 #if !USE_MARSHALING_DEFINES 1466 TPM_RC 1467 TPMS_SIG_SCHEME_RSASSA_Unmarshal(TPMS_SIG_SCHEME_RSASSA *target, 1468 BYTE **buffer, INT32 *size); 1469 #else 1470 #define TPMS_SIG_SCHEME_RSASSA_Unmarshal(target, buffer, size) \ 1471 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1472 (buffer), \ 1473 (size)) 1474 #endif // !USE_MARSHALING_DEFINES 1475 #if !USE_MARSHALING_DEFINES 1476 UINT16 1477 TPMS_SIG_SCHEME_RSASSA_Marshal(TPMS_SIG_SCHEME_RSASSA *source, 1478 BYTE **buffer, INT32 *size); 1479 #else 1480 #define TPMS_SIG_SCHEME_RSASSA_Marshal(source, buffer, size) \ 1481 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1482 (buffer), \ 1483 (size)) 1484 #endif // !USE_MARSHALING_DEFINES 1485 #if !USE_MARSHALING_DEFINES 1486 TPM_RC 1487 TPMS_SIG_SCHEME_RSAPSS_Unmarshal(TPMS_SIG_SCHEME_RSAPSS *target, 1488 BYTE **buffer, INT32 *size); 1489 #else 1490 #define TPMS_SIG_SCHEME_RSAPSS_Unmarshal(target, buffer, size) \ 1491 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1492 (buffer), \ 1493 (size)) 1494 #endif // !USE_MARSHALING_DEFINES 1495 #if !USE_MARSHALING_DEFINES 1496 UINT16 1497 TPMS_SIG_SCHEME_RSAPSS_Marshal(TPMS_SIG_SCHEME_RSAPSS *source, 1498 BYTE **buffer, INT32 *size); 1499 #else 1500 #define TPMS_SIG_SCHEME_RSAPSS_Marshal(source, buffer, size) \ 1501 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1502 (buffer), \ 1503 (size)) 1504 #endif // !USE_MARSHALING_DEFINES 1505 #endif // ALG_RSA 1506 1507 // Table 2:160 - Definition of Types for ECC Signature Schemes 1508 #if ALG_ECC 1509 #if !USE_MARSHALING_DEFINES 1510 TPM_RC 1511 TPMS_SIG_SCHEME_ECDSA_Unmarshal(TPMS_SIG_SCHEME_ECDSA *target, 1512 BYTE **buffer, INT32 *size); 1513 #else 1514 #define TPMS_SIG_SCHEME_ECDSA_Unmarshal(target, buffer, size) \ 1515 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1516 (buffer), \ 1517 (size)) 1518 #endif // !USE_MARSHALING_DEFINES 1519 #if !USE_MARSHALING_DEFINES 1520 UINT16 1521 TPMS_SIG_SCHEME_ECDSA_Marshal(TPMS_SIG_SCHEME_ECDSA *source, 1522 BYTE **buffer, INT32 *size); 1523 #else 1524 #define TPMS_SIG_SCHEME_ECDSA_Marshal(source, buffer, size) \ 1525 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1526 (buffer), \ 1527 (size)) 1528 #endif // !USE_MARSHALING_DEFINES 1529 #if !USE_MARSHALING_DEFINES 1530 TPM_RC 1531 TPMS_SIG_SCHEME_SM2_Unmarshal(TPMS_SIG_SCHEME_SM2 *target, 1532 BYTE **buffer, INT32 *size); 1533 #else 1534 #define TPMS_SIG_SCHEME_SM2_Unmarshal(target, buffer, size) \ 1535 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1536 (buffer), \ 1537 (size)) 1538 #endif // !USE_MARSHALING_DEFINES 1539 #if !USE_MARSHALING_DEFINES 1540 UINT16 1541 TPMS_SIG_SCHEME_SM2_Marshal(TPMS_SIG_SCHEME_SM2 *source, 1542 BYTE **buffer, INT32 *size); 1543 #else 1544 #define TPMS_SIG_SCHEME_SM2_Marshal(source, buffer, size) \ 1545 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1546 (buffer), \ 1547 (size)) 1548 #endif // !USE_MARSHALING_DEFINES 1549 #if !USE_MARSHALING_DEFINES 1550 TPM_RC 1551 TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(TPMS_SIG_SCHEME_ECSCHNORR *target, 1552 BYTE **buffer, INT32 *size); 1553 #else 1554 #define TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(target, buffer, size) \ 1555 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1556 (buffer), \ 1557 (size)) 1558 #endif // !USE_MARSHALING_DEFINES 1559 #if !USE_MARSHALING_DEFINES 1560 UINT16 1561 TPMS_SIG_SCHEME_ECSCHNORR_Marshal(TPMS_SIG_SCHEME_ECSCHNORR *source, 1562 BYTE **buffer, INT32 *size); 1563 #else 1564 #define TPMS_SIG_SCHEME_ECSCHNORR_Marshal(source, buffer, size) \ 1565 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1566 (buffer), \ 1567 (size)) 1568 #endif // !USE_MARSHALING_DEFINES 1569 #if !USE_MARSHALING_DEFINES 1570 TPM_RC 1571 TPMS_SIG_SCHEME_ECDAA_Unmarshal(TPMS_SIG_SCHEME_ECDAA *target, 1572 BYTE **buffer, INT32 *size); 1573 #else 1574 #define TPMS_SIG_SCHEME_ECDAA_Unmarshal(target, buffer, size) \ 1575 TPMS_SCHEME_ECDAA_Unmarshal((TPMS_SCHEME_ECDAA *)(target), \ 1576 (buffer), \ 1577 (size)) 1578 #endif // !USE_MARSHALING_DEFINES 1579 #if !USE_MARSHALING_DEFINES 1580 UINT16 1581 TPMS_SIG_SCHEME_ECDAA_Marshal(TPMS_SIG_SCHEME_ECDAA *source, 1582 BYTE **buffer, INT32 *size); 1583 #else 1584 #define TPMS_SIG_SCHEME_ECDAA_Marshal(source, buffer, size) \ 1585 TPMS_SCHEME_ECDAA_Marshal((TPMS_SCHEME_ECDAA *)(source), \ 1586 (buffer), \ 1587 (size)) 1588 #endif // !USE_MARSHALING_DEFINES 1589 #endif // ALG_ECC 1590 1591 // Table 2:161 - Definition of TPMU_SIG_SCHEME Union 1592 TPM_RC 1593 TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME *target, 1594 BYTE **buffer, INT32 *size, UINT32 selector); 1595 UINT16 1596 TPMU_SIG_SCHEME_Marshal(TPMU_SIG_SCHEME *source, 1597 BYTE **buffer, INT32 *size, UINT32 selector); 1598 1599 // Table 2:162 - Definition of TPMT_SIG_SCHEME Structure 1600 TPM_RC 1601 TPMT_SIG_SCHEME_Unmarshal(TPMT_SIG_SCHEME *target, 1602 BYTE **buffer, INT32 *size, BOOL flag); 1603 UINT16 1604 TPMT_SIG_SCHEME_Marshal(TPMT_SIG_SCHEME *source, BYTE **buffer, INT32 *size); 1605 1606 // Table 2:163 - Definition of Types for Encryption Schemes 1607 #if ALG_RSA 1608 #if !USE_MARSHALING_DEFINES 1609 TPM_RC 1610 TPMS_ENC_SCHEME_OAEP_Unmarshal(TPMS_ENC_SCHEME_OAEP *target, 1611 BYTE **buffer, INT32 *size); 1612 #else 1613 #define TPMS_ENC_SCHEME_OAEP_Unmarshal(target, buffer, size) \ 1614 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1615 (buffer), \ 1616 (size)) 1617 #endif // !USE_MARSHALING_DEFINES 1618 #if !USE_MARSHALING_DEFINES 1619 UINT16 1620 TPMS_ENC_SCHEME_OAEP_Marshal(TPMS_ENC_SCHEME_OAEP *source, 1621 BYTE **buffer, INT32 *size); 1622 #else 1623 #define TPMS_ENC_SCHEME_OAEP_Marshal(source, buffer, size) \ 1624 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1625 (buffer), \ 1626 (size)) 1627 #endif // !USE_MARSHALING_DEFINES 1628 #if !USE_MARSHALING_DEFINES 1629 TPM_RC 1630 TPMS_ENC_SCHEME_RSAES_Unmarshal(TPMS_ENC_SCHEME_RSAES *target, 1631 BYTE **buffer, INT32 *size); 1632 #else 1633 #define TPMS_ENC_SCHEME_RSAES_Unmarshal(target, buffer, size) \ 1634 TPMS_EMPTY_Unmarshal((TPMS_EMPTY *)(target), (buffer), (size)) 1635 #endif // !USE_MARSHALING_DEFINES 1636 #if !USE_MARSHALING_DEFINES 1637 UINT16 1638 TPMS_ENC_SCHEME_RSAES_Marshal(TPMS_ENC_SCHEME_RSAES *source, 1639 BYTE **buffer, INT32 *size); 1640 #else 1641 #define TPMS_ENC_SCHEME_RSAES_Marshal(source, buffer, size) \ 1642 TPMS_EMPTY_Marshal((TPMS_EMPTY *)(source), (buffer), (size)) 1643 #endif // !USE_MARSHALING_DEFINES 1644 #endif // ALG_RSA 1645 1646 // Table 2:164 - Definition of Types for ECC Key Exchange 1647 #if ALG_ECC 1648 #if !USE_MARSHALING_DEFINES 1649 TPM_RC 1650 TPMS_KEY_SCHEME_ECDH_Unmarshal(TPMS_KEY_SCHEME_ECDH *target, 1651 BYTE **buffer, INT32 *size); 1652 #else 1653 #define TPMS_KEY_SCHEME_ECDH_Unmarshal(target, buffer, size) \ 1654 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1655 (buffer), \ 1656 (size)) 1657 #endif // !USE_MARSHALING_DEFINES 1658 #if !USE_MARSHALING_DEFINES 1659 UINT16 1660 TPMS_KEY_SCHEME_ECDH_Marshal(TPMS_KEY_SCHEME_ECDH *source, 1661 BYTE **buffer, INT32 *size); 1662 #else 1663 #define TPMS_KEY_SCHEME_ECDH_Marshal(source, buffer, size) \ 1664 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1665 (buffer), \ 1666 (size)) 1667 #endif // !USE_MARSHALING_DEFINES 1668 #if !USE_MARSHALING_DEFINES 1669 TPM_RC 1670 TPMS_KEY_SCHEME_ECMQV_Unmarshal(TPMS_KEY_SCHEME_ECMQV *target, 1671 BYTE **buffer, INT32 *size); 1672 #else 1673 #define TPMS_KEY_SCHEME_ECMQV_Unmarshal(target, buffer, size) \ 1674 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1675 (buffer), \ 1676 (size)) 1677 #endif // !USE_MARSHALING_DEFINES 1678 #if !USE_MARSHALING_DEFINES 1679 UINT16 1680 TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV *source, 1681 BYTE **buffer, INT32 *size); 1682 #else 1683 #define TPMS_KEY_SCHEME_ECMQV_Marshal(source, buffer, size) \ 1684 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1685 (buffer), \ 1686 (size)) 1687 #endif // !USE_MARSHALING_DEFINES 1688 #endif // ALG_ECC 1689 1690 // Table 2:165 - Definition of Types for KDF Schemes 1691 #if !USE_MARSHALING_DEFINES 1692 TPM_RC 1693 TPMS_KDF_SCHEME_MGF1_Unmarshal(TPMS_KDF_SCHEME_MGF1 *target, 1694 BYTE **buffer, INT32 *size); 1695 #else 1696 #define TPMS_KDF_SCHEME_MGF1_Unmarshal(target, buffer, size) \ 1697 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1698 (buffer), \ 1699 (size)) 1700 #endif // !USE_MARSHALING_DEFINES 1701 #if !USE_MARSHALING_DEFINES 1702 UINT16 1703 TPMS_KDF_SCHEME_MGF1_Marshal(TPMS_KDF_SCHEME_MGF1 *source, 1704 BYTE **buffer, INT32 *size); 1705 #else 1706 #define TPMS_KDF_SCHEME_MGF1_Marshal(source, buffer, size) \ 1707 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1708 (buffer), \ 1709 (size)) 1710 #endif // !USE_MARSHALING_DEFINES 1711 #if !USE_MARSHALING_DEFINES 1712 TPM_RC 1713 TPMS_KDF_SCHEME_KDF1_SP800_56A_Unmarshal(TPMS_KDF_SCHEME_KDF1_SP800_56A *target, 1714 BYTE **buffer, INT32 *size); 1715 #else 1716 #define TPMS_KDF_SCHEME_KDF1_SP800_56A_Unmarshal(target, buffer, size) \ 1717 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1718 (buffer), \ 1719 (size)) 1720 #endif // !USE_MARSHALING_DEFINES 1721 #if !USE_MARSHALING_DEFINES 1722 UINT16 1723 TPMS_KDF_SCHEME_KDF1_SP800_56A_Marshal(TPMS_KDF_SCHEME_KDF1_SP800_56A *source, 1724 BYTE **buffer, INT32 *size); 1725 #else 1726 #define TPMS_KDF_SCHEME_KDF1_SP800_56A_Marshal(source, buffer, size) \ 1727 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1728 (buffer), \ 1729 (size)) 1730 #endif // !USE_MARSHALING_DEFINES 1731 #if !USE_MARSHALING_DEFINES 1732 TPM_RC 1733 TPMS_KDF_SCHEME_KDF2_Unmarshal(TPMS_KDF_SCHEME_KDF2 *target, 1734 BYTE **buffer, INT32 *size); 1735 #else 1736 #define TPMS_KDF_SCHEME_KDF2_Unmarshal(target, buffer, size) \ 1737 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1738 (buffer), \ 1739 (size)) 1740 #endif // !USE_MARSHALING_DEFINES 1741 #if !USE_MARSHALING_DEFINES 1742 UINT16 1743 TPMS_KDF_SCHEME_KDF2_Marshal(TPMS_KDF_SCHEME_KDF2 *source, 1744 BYTE **buffer, INT32 *size); 1745 #else 1746 #define TPMS_KDF_SCHEME_KDF2_Marshal(source, buffer, size) \ 1747 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1748 (buffer), \ 1749 (size)) 1750 #endif // !USE_MARSHALING_DEFINES 1751 #if !USE_MARSHALING_DEFINES 1752 TPM_RC 1753 TPMS_KDF_SCHEME_KDF1_SP800_108_Unmarshal(TPMS_KDF_SCHEME_KDF1_SP800_108 *target, 1754 BYTE **buffer, INT32 *size); 1755 #else 1756 #define TPMS_KDF_SCHEME_KDF1_SP800_108_Unmarshal(target, buffer, size) \ 1757 TPMS_SCHEME_HASH_Unmarshal((TPMS_SCHEME_HASH *)(target), \ 1758 (buffer), \ 1759 (size)) 1760 #endif // !USE_MARSHALING_DEFINES 1761 #if !USE_MARSHALING_DEFINES 1762 UINT16 1763 TPMS_KDF_SCHEME_KDF1_SP800_108_Marshal(TPMS_KDF_SCHEME_KDF1_SP800_108 *source, 1764 BYTE **buffer, INT32 *size); 1765 #else 1766 #define TPMS_KDF_SCHEME_KDF1_SP800_108_Marshal(source, buffer, size) \ 1767 TPMS_SCHEME_HASH_Marshal((TPMS_SCHEME_HASH *)(source), \ 1768 (buffer), \ 1769 (size)) 1770 #endif // !USE_MARSHALING_DEFINES 1771 1772 // Table 2:166 - Definition of TPMU_KDF_SCHEME Union 1773 TPM_RC 1774 TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME *target, 1775 BYTE **buffer, INT32 *size, UINT32 selector); 1776 UINT16 1777 TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME *source, 1778 BYTE **buffer, INT32 *size, UINT32 selector); 1779 1780 // Table 2:167 - Definition of TPMT_KDF_SCHEME Structure 1781 TPM_RC 1782 TPMT_KDF_SCHEME_Unmarshal(TPMT_KDF_SCHEME *target, 1783 BYTE **buffer, INT32 *size, BOOL flag); 1784 UINT16 1785 TPMT_KDF_SCHEME_Marshal(TPMT_KDF_SCHEME *source, BYTE **buffer, INT32 *size); 1786 1787 // Table 2:168 - Definition of TPMI_ALG_ASYM_SCHEME Type 1788 TPM_RC 1789 TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME *target, 1790 BYTE **buffer, INT32 *size, BOOL flag); 1791 #if !USE_MARSHALING_DEFINES 1792 UINT16 1793 TPMI_ALG_ASYM_SCHEME_Marshal(TPMI_ALG_ASYM_SCHEME *source, 1794 BYTE **buffer, INT32 *size); 1795 #else 1796 #define TPMI_ALG_ASYM_SCHEME_Marshal(source, buffer, size) \ 1797 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 1798 #endif // !USE_MARSHALING_DEFINES 1799 1800 // Table 2:169 - Definition of TPMU_ASYM_SCHEME Union 1801 TPM_RC 1802 TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME *target, 1803 BYTE **buffer, INT32 *size, UINT32 selector); 1804 UINT16 1805 TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME *source, 1806 BYTE **buffer, INT32 *size, UINT32 selector); 1807 1808 // Table 2:170 - Definition of TPMT_ASYM_SCHEME Structure 1809 // Table 2:171 - Definition of TPMI_ALG_RSA_SCHEME Type 1810 #if ALG_RSA 1811 TPM_RC 1812 TPMI_ALG_RSA_SCHEME_Unmarshal(TPMI_ALG_RSA_SCHEME *target, 1813 BYTE **buffer, INT32 *size, BOOL flag); 1814 #if !USE_MARSHALING_DEFINES 1815 UINT16 1816 TPMI_ALG_RSA_SCHEME_Marshal(TPMI_ALG_RSA_SCHEME *source, 1817 BYTE **buffer, INT32 *size); 1818 #else 1819 #define TPMI_ALG_RSA_SCHEME_Marshal(source, buffer, size) \ 1820 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 1821 #endif // !USE_MARSHALING_DEFINES 1822 #endif // ALG_RSA 1823 1824 // Table 2:172 - Definition of TPMT_RSA_SCHEME Structure 1825 #if ALG_RSA 1826 TPM_RC 1827 TPMT_RSA_SCHEME_Unmarshal(TPMT_RSA_SCHEME *target, 1828 BYTE **buffer, INT32 *size, BOOL flag); 1829 UINT16 1830 TPMT_RSA_SCHEME_Marshal(TPMT_RSA_SCHEME *source, BYTE **buffer, INT32 *size); 1831 #endif // ALG_RSA 1832 1833 // Table 2:173 - Definition of TPMI_ALG_RSA_DECRYPT Type 1834 #if ALG_RSA 1835 TPM_RC 1836 TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT *target, 1837 BYTE **buffer, INT32 *size, BOOL flag); 1838 #if !USE_MARSHALING_DEFINES 1839 UINT16 1840 TPMI_ALG_RSA_DECRYPT_Marshal(TPMI_ALG_RSA_DECRYPT *source, 1841 BYTE **buffer, INT32 *size); 1842 #else 1843 #define TPMI_ALG_RSA_DECRYPT_Marshal(source, buffer, size) \ 1844 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 1845 #endif // !USE_MARSHALING_DEFINES 1846 #endif // ALG_RSA 1847 1848 // Table 2:174 - Definition of TPMT_RSA_DECRYPT Structure 1849 #if ALG_RSA 1850 TPM_RC 1851 TPMT_RSA_DECRYPT_Unmarshal(TPMT_RSA_DECRYPT *target, 1852 BYTE **buffer, INT32 *size, BOOL flag); 1853 UINT16 1854 TPMT_RSA_DECRYPT_Marshal(TPMT_RSA_DECRYPT *source, BYTE **buffer, INT32 *size); 1855 #endif // ALG_RSA 1856 1857 // Table 2:175 - Definition of TPM2B_PUBLIC_KEY_RSA Structure 1858 #if ALG_RSA 1859 TPM_RC 1860 TPM2B_PUBLIC_KEY_RSA_Unmarshal(TPM2B_PUBLIC_KEY_RSA *target, 1861 BYTE **buffer, INT32 *size); 1862 UINT16 1863 TPM2B_PUBLIC_KEY_RSA_Marshal(TPM2B_PUBLIC_KEY_RSA *source, 1864 BYTE **buffer, INT32 *size); 1865 #endif // ALG_RSA 1866 1867 // Table 2:176 - Definition of TPMI_RSA_KEY_BITS Type 1868 #if ALG_RSA 1869 TPM_RC 1870 TPMI_RSA_KEY_BITS_Unmarshal(TPMI_RSA_KEY_BITS *target, BYTE **buffer, INT32 *size); 1871 #if !USE_MARSHALING_DEFINES 1872 UINT16 1873 TPMI_RSA_KEY_BITS_Marshal(TPMI_RSA_KEY_BITS *source, BYTE **buffer, INT32 *size); 1874 #else 1875 #define TPMI_RSA_KEY_BITS_Marshal(source, buffer, size) \ 1876 TPM_KEY_BITS_Marshal((TPM_KEY_BITS *)(source), (buffer), (size)) 1877 #endif // !USE_MARSHALING_DEFINES 1878 #endif // ALG_RSA 1879 1880 // Table 2:177 - Definition of TPM2B_PRIVATE_KEY_RSA Structure 1881 #if ALG_RSA 1882 TPM_RC 1883 TPM2B_PRIVATE_KEY_RSA_Unmarshal(TPM2B_PRIVATE_KEY_RSA *target, 1884 BYTE **buffer, INT32 *size); 1885 UINT16 1886 TPM2B_PRIVATE_KEY_RSA_Marshal(TPM2B_PRIVATE_KEY_RSA *source, 1887 BYTE **buffer, INT32 *size); 1888 #endif // ALG_RSA 1889 1890 // Table 2:178 - Definition of TPM2B_ECC_PARAMETER Structure 1891 TPM_RC 1892 TPM2B_ECC_PARAMETER_Unmarshal(TPM2B_ECC_PARAMETER *target, 1893 BYTE **buffer, INT32 *size); 1894 UINT16 1895 TPM2B_ECC_PARAMETER_Marshal(TPM2B_ECC_PARAMETER *source, 1896 BYTE **buffer, INT32 *size); 1897 1898 // Table 2:179 - Definition of TPMS_ECC_POINT Structure 1899 #if ALG_ECC 1900 TPM_RC 1901 TPMS_ECC_POINT_Unmarshal(TPMS_ECC_POINT *target, BYTE **buffer, INT32 *size); 1902 UINT16 1903 TPMS_ECC_POINT_Marshal(TPMS_ECC_POINT *source, BYTE **buffer, INT32 *size); 1904 #endif // ALG_ECC 1905 1906 // Table 2:180 - Definition of TPM2B_ECC_POINT Structure 1907 #if ALG_ECC 1908 TPM_RC 1909 TPM2B_ECC_POINT_Unmarshal(TPM2B_ECC_POINT *target, BYTE **buffer, INT32 *size); 1910 UINT16 1911 TPM2B_ECC_POINT_Marshal(TPM2B_ECC_POINT *source, BYTE **buffer, INT32 *size); 1912 #endif // ALG_ECC 1913 1914 // Table 2:181 - Definition of TPMI_ALG_ECC_SCHEME Type 1915 #if ALG_ECC 1916 TPM_RC 1917 TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME *target, 1918 BYTE **buffer, INT32 *size, BOOL flag); 1919 #if !USE_MARSHALING_DEFINES 1920 UINT16 1921 TPMI_ALG_ECC_SCHEME_Marshal(TPMI_ALG_ECC_SCHEME *source, 1922 BYTE **buffer, INT32 *size); 1923 #else 1924 #define TPMI_ALG_ECC_SCHEME_Marshal(source, buffer, size) \ 1925 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 1926 #endif // !USE_MARSHALING_DEFINES 1927 #endif // ALG_ECC 1928 1929 // Table 2:182 - Definition of TPMI_ECC_CURVE Type 1930 #if ALG_ECC 1931 TPM_RC 1932 TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE *target, BYTE **buffer, INT32 *size); 1933 #if !USE_MARSHALING_DEFINES 1934 UINT16 1935 TPMI_ECC_CURVE_Marshal(TPMI_ECC_CURVE *source, BYTE **buffer, INT32 *size); 1936 #else 1937 #define TPMI_ECC_CURVE_Marshal(source, buffer, size) \ 1938 TPM_ECC_CURVE_Marshal((TPM_ECC_CURVE *)(source), (buffer), (size)) 1939 #endif // !USE_MARSHALING_DEFINES 1940 #endif // ALG_ECC 1941 1942 // Table 2:183 - Definition of TPMT_ECC_SCHEME Structure 1943 #if ALG_ECC 1944 TPM_RC 1945 TPMT_ECC_SCHEME_Unmarshal(TPMT_ECC_SCHEME *target, 1946 BYTE **buffer, INT32 *size, BOOL flag); 1947 UINT16 1948 TPMT_ECC_SCHEME_Marshal(TPMT_ECC_SCHEME *source, BYTE **buffer, INT32 *size); 1949 #endif // ALG_ECC 1950 1951 // Table 2:184 - Definition of TPMS_ALGORITHM_DETAIL_ECC Structure 1952 #if ALG_ECC 1953 UINT16 1954 TPMS_ALGORITHM_DETAIL_ECC_Marshal(TPMS_ALGORITHM_DETAIL_ECC *source, 1955 BYTE **buffer, INT32 *size); 1956 #endif // ALG_ECC 1957 1958 // Table 2:185 - Definition of TPMS_SIGNATURE_RSA Structure 1959 #if ALG_RSA 1960 TPM_RC 1961 TPMS_SIGNATURE_RSA_Unmarshal(TPMS_SIGNATURE_RSA *target, 1962 BYTE **buffer, INT32 *size); 1963 UINT16 1964 TPMS_SIGNATURE_RSA_Marshal(TPMS_SIGNATURE_RSA *source, BYTE **buffer, INT32 *size); 1965 #endif // ALG_RSA 1966 1967 // Table 2:186 - Definition of Types for Signature 1968 #if ALG_RSA 1969 #if !USE_MARSHALING_DEFINES 1970 TPM_RC 1971 TPMS_SIGNATURE_RSASSA_Unmarshal(TPMS_SIGNATURE_RSASSA *target, 1972 BYTE **buffer, INT32 *size); 1973 #else 1974 #define TPMS_SIGNATURE_RSASSA_Unmarshal(target, buffer, size) \ 1975 TPMS_SIGNATURE_RSA_Unmarshal((TPMS_SIGNATURE_RSA *)(target), \ 1976 (buffer), \ 1977 (size)) 1978 #endif // !USE_MARSHALING_DEFINES 1979 #if !USE_MARSHALING_DEFINES 1980 UINT16 1981 TPMS_SIGNATURE_RSASSA_Marshal(TPMS_SIGNATURE_RSASSA *source, 1982 BYTE **buffer, INT32 *size); 1983 #else 1984 #define TPMS_SIGNATURE_RSASSA_Marshal(source, buffer, size) \ 1985 TPMS_SIGNATURE_RSA_Marshal((TPMS_SIGNATURE_RSA *)(source), \ 1986 (buffer), \ 1987 (size)) 1988 #endif // !USE_MARSHALING_DEFINES 1989 #if !USE_MARSHALING_DEFINES 1990 TPM_RC 1991 TPMS_SIGNATURE_RSAPSS_Unmarshal(TPMS_SIGNATURE_RSAPSS *target, 1992 BYTE **buffer, INT32 *size); 1993 #else 1994 #define TPMS_SIGNATURE_RSAPSS_Unmarshal(target, buffer, size) \ 1995 TPMS_SIGNATURE_RSA_Unmarshal((TPMS_SIGNATURE_RSA *)(target), \ 1996 (buffer), \ 1997 (size)) 1998 #endif // !USE_MARSHALING_DEFINES 1999 #if !USE_MARSHALING_DEFINES 2000 UINT16 2001 TPMS_SIGNATURE_RSAPSS_Marshal(TPMS_SIGNATURE_RSAPSS *source, 2002 BYTE **buffer, INT32 *size); 2003 #else 2004 #define TPMS_SIGNATURE_RSAPSS_Marshal(source, buffer, size) \ 2005 TPMS_SIGNATURE_RSA_Marshal((TPMS_SIGNATURE_RSA *)(source), \ 2006 (buffer), \ 2007 (size)) 2008 #endif // !USE_MARSHALING_DEFINES 2009 #endif // ALG_RSA 2010 2011 // Table 2:187 - Definition of TPMS_SIGNATURE_ECC Structure 2012 #if ALG_ECC 2013 TPM_RC 2014 TPMS_SIGNATURE_ECC_Unmarshal(TPMS_SIGNATURE_ECC *target, 2015 BYTE **buffer, INT32 *size); 2016 UINT16 2017 TPMS_SIGNATURE_ECC_Marshal(TPMS_SIGNATURE_ECC *source, BYTE **buffer, INT32 *size); 2018 #endif // ALG_ECC 2019 2020 // Table 2:188 - Definition of Types for TPMS_SIGNATURE_ECC 2021 #if ALG_ECC 2022 #if !USE_MARSHALING_DEFINES 2023 TPM_RC 2024 TPMS_SIGNATURE_ECDAA_Unmarshal(TPMS_SIGNATURE_ECDAA *target, 2025 BYTE **buffer, INT32 *size); 2026 #else 2027 #define TPMS_SIGNATURE_ECDAA_Unmarshal(target, buffer, size) \ 2028 TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)(target), \ 2029 (buffer), \ 2030 (size)) 2031 #endif // !USE_MARSHALING_DEFINES 2032 #if !USE_MARSHALING_DEFINES 2033 UINT16 2034 TPMS_SIGNATURE_ECDAA_Marshal(TPMS_SIGNATURE_ECDAA *source, 2035 BYTE **buffer, INT32 *size); 2036 #else 2037 #define TPMS_SIGNATURE_ECDAA_Marshal(source, buffer, size) \ 2038 TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)(source), \ 2039 (buffer), \ 2040 (size)) 2041 #endif // !USE_MARSHALING_DEFINES 2042 #if !USE_MARSHALING_DEFINES 2043 TPM_RC 2044 TPMS_SIGNATURE_ECDSA_Unmarshal(TPMS_SIGNATURE_ECDSA *target, 2045 BYTE **buffer, INT32 *size); 2046 #else 2047 #define TPMS_SIGNATURE_ECDSA_Unmarshal(target, buffer, size) \ 2048 TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)(target), \ 2049 (buffer), \ 2050 (size)) 2051 #endif // !USE_MARSHALING_DEFINES 2052 #if !USE_MARSHALING_DEFINES 2053 UINT16 2054 TPMS_SIGNATURE_ECDSA_Marshal(TPMS_SIGNATURE_ECDSA *source, 2055 BYTE **buffer, INT32 *size); 2056 #else 2057 #define TPMS_SIGNATURE_ECDSA_Marshal(source, buffer, size) \ 2058 TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)(source), \ 2059 (buffer), \ 2060 (size)) 2061 #endif // !USE_MARSHALING_DEFINES 2062 #if !USE_MARSHALING_DEFINES 2063 TPM_RC 2064 TPMS_SIGNATURE_SM2_Unmarshal(TPMS_SIGNATURE_SM2 *target, 2065 BYTE **buffer, INT32 *size); 2066 #else 2067 #define TPMS_SIGNATURE_SM2_Unmarshal(target, buffer, size) \ 2068 TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)(target), \ 2069 (buffer), \ 2070 (size)) 2071 #endif // !USE_MARSHALING_DEFINES 2072 #if !USE_MARSHALING_DEFINES 2073 UINT16 2074 TPMS_SIGNATURE_SM2_Marshal(TPMS_SIGNATURE_SM2 *source, BYTE **buffer, INT32 *size); 2075 #else 2076 #define TPMS_SIGNATURE_SM2_Marshal(source, buffer, size) \ 2077 TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)(source), \ 2078 (buffer), \ 2079 (size)) 2080 #endif // !USE_MARSHALING_DEFINES 2081 #if !USE_MARSHALING_DEFINES 2082 TPM_RC 2083 TPMS_SIGNATURE_ECSCHNORR_Unmarshal(TPMS_SIGNATURE_ECSCHNORR *target, 2084 BYTE **buffer, INT32 *size); 2085 #else 2086 #define TPMS_SIGNATURE_ECSCHNORR_Unmarshal(target, buffer, size) \ 2087 TPMS_SIGNATURE_ECC_Unmarshal((TPMS_SIGNATURE_ECC *)(target), \ 2088 (buffer), \ 2089 (size)) 2090 #endif // !USE_MARSHALING_DEFINES 2091 #if !USE_MARSHALING_DEFINES 2092 UINT16 2093 TPMS_SIGNATURE_ECSCHNORR_Marshal(TPMS_SIGNATURE_ECSCHNORR *source, 2094 BYTE **buffer, INT32 *size); 2095 #else 2096 #define TPMS_SIGNATURE_ECSCHNORR_Marshal(source, buffer, size) \ 2097 TPMS_SIGNATURE_ECC_Marshal((TPMS_SIGNATURE_ECC *)(source), \ 2098 (buffer), \ 2099 (size)) 2100 #endif // !USE_MARSHALING_DEFINES 2101 #endif // ALG_ECC 2102 2103 // Table 2:189 - Definition of TPMU_SIGNATURE Union 2104 TPM_RC 2105 TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE *target, 2106 BYTE **buffer, INT32 *size, UINT32 selector); 2107 UINT16 2108 TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE *source, 2109 BYTE **buffer, INT32 *size, UINT32 selector); 2110 2111 // Table 2:190 - Definition of TPMT_SIGNATURE Structure 2112 TPM_RC 2113 TPMT_SIGNATURE_Unmarshal(TPMT_SIGNATURE *target, 2114 BYTE **buffer, INT32 *size, BOOL flag); 2115 UINT16 2116 TPMT_SIGNATURE_Marshal(TPMT_SIGNATURE *source, BYTE **buffer, INT32 *size); 2117 2118 // Table 2:191 - Definition of TPMU_ENCRYPTED_SECRET Union 2119 TPM_RC 2120 TPMU_ENCRYPTED_SECRET_Unmarshal(TPMU_ENCRYPTED_SECRET *target, 2121 BYTE **buffer, INT32 *size, UINT32 selector); 2122 UINT16 2123 TPMU_ENCRYPTED_SECRET_Marshal(TPMU_ENCRYPTED_SECRET *source, 2124 BYTE **buffer, INT32 *size, UINT32 selector); 2125 2126 // Table 2:192 - Definition of TPM2B_ENCRYPTED_SECRET Structure 2127 TPM_RC 2128 TPM2B_ENCRYPTED_SECRET_Unmarshal(TPM2B_ENCRYPTED_SECRET *target, 2129 BYTE **buffer, INT32 *size); 2130 UINT16 2131 TPM2B_ENCRYPTED_SECRET_Marshal(TPM2B_ENCRYPTED_SECRET *source, 2132 BYTE **buffer, INT32 *size); 2133 2134 // Table 2:193 - Definition of TPMI_ALG_PUBLIC Type 2135 TPM_RC 2136 TPMI_ALG_PUBLIC_Unmarshal(TPMI_ALG_PUBLIC *target, BYTE **buffer, INT32 *size); 2137 #if !USE_MARSHALING_DEFINES 2138 UINT16 2139 TPMI_ALG_PUBLIC_Marshal(TPMI_ALG_PUBLIC *source, BYTE **buffer, INT32 *size); 2140 #else 2141 #define TPMI_ALG_PUBLIC_Marshal(source, buffer, size) \ 2142 TPM_ALG_ID_Marshal((TPM_ALG_ID *)(source), (buffer), (size)) 2143 #endif // !USE_MARSHALING_DEFINES 2144 2145 // Table 2:194 - Definition of TPMU_PUBLIC_ID Union 2146 TPM_RC 2147 TPMU_PUBLIC_ID_Unmarshal(TPMU_PUBLIC_ID *target, 2148 BYTE **buffer, INT32 *size, UINT32 selector); 2149 UINT16 2150 TPMU_PUBLIC_ID_Marshal(TPMU_PUBLIC_ID *source, 2151 BYTE **buffer, INT32 *size, UINT32 selector); 2152 2153 // Table 2:195 - Definition of TPMS_KEYEDHASH_PARMS Structure 2154 TPM_RC 2155 TPMS_KEYEDHASH_PARMS_Unmarshal(TPMS_KEYEDHASH_PARMS *target, 2156 BYTE **buffer, INT32 *size); 2157 UINT16 2158 TPMS_KEYEDHASH_PARMS_Marshal(TPMS_KEYEDHASH_PARMS *source, 2159 BYTE **buffer, INT32 *size); 2160 2161 // Table 2:196 - Definition of TPMS_ASYM_PARMS Structure 2162 // Table 2:197 - Definition of TPMS_RSA_PARMS Structure 2163 #if ALG_RSA 2164 TPM_RC 2165 TPMS_RSA_PARMS_Unmarshal(TPMS_RSA_PARMS *target, BYTE **buffer, INT32 *size); 2166 UINT16 2167 TPMS_RSA_PARMS_Marshal(TPMS_RSA_PARMS *source, BYTE **buffer, INT32 *size); 2168 #endif // ALG_RSA 2169 2170 // Table 2:198 - Definition of TPMS_ECC_PARMS Structure 2171 #if ALG_ECC 2172 TPM_RC 2173 TPMS_ECC_PARMS_Unmarshal(TPMS_ECC_PARMS *target, BYTE **buffer, INT32 *size); 2174 UINT16 2175 TPMS_ECC_PARMS_Marshal(TPMS_ECC_PARMS *source, BYTE **buffer, INT32 *size); 2176 #endif // ALG_ECC 2177 2178 // Table 2:199 - Definition of TPMU_PUBLIC_PARMS Union 2179 TPM_RC 2180 TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS *target, 2181 BYTE **buffer, INT32 *size, UINT32 selector); 2182 UINT16 2183 TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS *source, 2184 BYTE **buffer, INT32 *size, UINT32 selector); 2185 2186 // Table 2:200 - Definition of TPMT_PUBLIC_PARMS Structure 2187 TPM_RC 2188 TPMT_PUBLIC_PARMS_Unmarshal(TPMT_PUBLIC_PARMS *target, BYTE **buffer, INT32 *size); 2189 UINT16 2190 TPMT_PUBLIC_PARMS_Marshal(TPMT_PUBLIC_PARMS *source, BYTE **buffer, INT32 *size); 2191 2192 // Table 2:201 - Definition of TPMT_PUBLIC Structure 2193 TPM_RC 2194 TPMT_PUBLIC_Unmarshal(TPMT_PUBLIC *target, BYTE **buffer, INT32 *size, BOOL flag); 2195 UINT16 2196 TPMT_PUBLIC_Marshal(TPMT_PUBLIC *source, BYTE **buffer, INT32 *size); 2197 2198 // Table 2:202 - Definition of TPM2B_PUBLIC Structure 2199 TPM_RC 2200 TPM2B_PUBLIC_Unmarshal(TPM2B_PUBLIC *target, BYTE **buffer, INT32 *size, BOOL flag); 2201 UINT16 2202 TPM2B_PUBLIC_Marshal(TPM2B_PUBLIC *source, BYTE **buffer, INT32 *size); 2203 2204 // Table 2:203 - Definition of TPM2B_TEMPLATE Structure 2205 TPM_RC 2206 TPM2B_TEMPLATE_Unmarshal(TPM2B_TEMPLATE *target, BYTE **buffer, INT32 *size); 2207 UINT16 2208 TPM2B_TEMPLATE_Marshal(TPM2B_TEMPLATE *source, BYTE **buffer, INT32 *size); 2209 2210 // Table 2:204 - Definition of TPM2B_PRIVATE_VENDOR_SPECIFIC Structure 2211 TPM_RC 2212 TPM2B_PRIVATE_VENDOR_SPECIFIC_Unmarshal(TPM2B_PRIVATE_VENDOR_SPECIFIC *target, 2213 BYTE **buffer, INT32 *size); 2214 UINT16 2215 TPM2B_PRIVATE_VENDOR_SPECIFIC_Marshal(TPM2B_PRIVATE_VENDOR_SPECIFIC *source, 2216 BYTE **buffer, INT32 *size); 2217 2218 // Table 2:205 - Definition of TPMU_SENSITIVE_COMPOSITE Union 2219 TPM_RC 2220 TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE *target, 2221 BYTE **buffer, INT32 *size, UINT32 selector); 2222 UINT16 2223 TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE *source, 2224 BYTE **buffer, INT32 *size, UINT32 selector); 2225 2226 // Table 2:206 - Definition of TPMT_SENSITIVE Structure 2227 TPM_RC 2228 TPMT_SENSITIVE_Unmarshal(TPMT_SENSITIVE *target, BYTE **buffer, INT32 *size); 2229 UINT16 2230 TPMT_SENSITIVE_Marshal(TPMT_SENSITIVE *source, BYTE **buffer, INT32 *size); 2231 2232 // Table 2:207 - Definition of TPM2B_SENSITIVE Structure 2233 TPM_RC 2234 TPM2B_SENSITIVE_Unmarshal(TPM2B_SENSITIVE *target, BYTE **buffer, INT32 *size); 2235 UINT16 2236 TPM2B_SENSITIVE_Marshal(TPM2B_SENSITIVE *source, BYTE **buffer, INT32 *size); 2237 2238 // Table 2:208 - Definition of _PRIVATE Structure 2239 // Table 2:209 - Definition of TPM2B_PRIVATE Structure 2240 TPM_RC 2241 TPM2B_PRIVATE_Unmarshal(TPM2B_PRIVATE *target, BYTE **buffer, INT32 *size); 2242 UINT16 2243 TPM2B_PRIVATE_Marshal(TPM2B_PRIVATE *source, BYTE **buffer, INT32 *size); 2244 2245 // Table 2:210 - Definition of TPMS_ID_OBJECT Structure 2246 // Table 2:211 - Definition of TPM2B_ID_OBJECT Structure 2247 TPM_RC 2248 TPM2B_ID_OBJECT_Unmarshal(TPM2B_ID_OBJECT *target, BYTE **buffer, INT32 *size); 2249 UINT16 2250 TPM2B_ID_OBJECT_Marshal(TPM2B_ID_OBJECT *source, BYTE **buffer, INT32 *size); 2251 2252 // Table 2:212 - Definition of TPM_NV_INDEX Bits 2253 #if !USE_MARSHALING_DEFINES 2254 UINT16 2255 TPM_NV_INDEX_Marshal(TPM_NV_INDEX *source, BYTE **buffer, INT32 *size); 2256 #else 2257 #define TPM_NV_INDEX_Marshal(source, buffer, size) \ 2258 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 2259 #endif // !USE_MARSHALING_DEFINES 2260 2261 // Table 2:213 - Definition of TPM_NT Constants 2262 // Table 2:214 - Definition of TPMS_NV_PIN_COUNTER_PARAMETERS Structure 2263 TPM_RC 2264 TPMS_NV_PIN_COUNTER_PARAMETERS_Unmarshal(TPMS_NV_PIN_COUNTER_PARAMETERS *target, 2265 BYTE **buffer, INT32 *size); 2266 UINT16 2267 TPMS_NV_PIN_COUNTER_PARAMETERS_Marshal(TPMS_NV_PIN_COUNTER_PARAMETERS *source, 2268 BYTE **buffer, INT32 *size); 2269 2270 // Table 2:215 - Definition of TPMA_NV Bits 2271 TPM_RC 2272 TPMA_NV_Unmarshal(TPMA_NV *target, BYTE **buffer, INT32 *size); 2273 2274 #if !USE_MARSHALING_DEFINES 2275 UINT16 2276 TPMA_NV_Marshal(TPMA_NV *source, BYTE **buffer, INT32 *size); 2277 #else 2278 #define TPMA_NV_Marshal(source, buffer, size) \ 2279 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 2280 #endif // !USE_MARSHALING_DEFINES 2281 2282 // Table 2:216 - Definition of TPMS_NV_PUBLIC Structure 2283 TPM_RC 2284 TPMS_NV_PUBLIC_Unmarshal(TPMS_NV_PUBLIC *target, BYTE **buffer, INT32 *size); 2285 UINT16 2286 TPMS_NV_PUBLIC_Marshal(TPMS_NV_PUBLIC *source, BYTE **buffer, INT32 *size); 2287 2288 // Table 2:217 - Definition of TPM2B_NV_PUBLIC Structure 2289 TPM_RC 2290 TPM2B_NV_PUBLIC_Unmarshal(TPM2B_NV_PUBLIC *target, BYTE **buffer, INT32 *size); 2291 UINT16 2292 TPM2B_NV_PUBLIC_Marshal(TPM2B_NV_PUBLIC *source, BYTE **buffer, INT32 *size); 2293 2294 // Table 2:218 - Definition of TPM2B_CONTEXT_SENSITIVE Structure 2295 TPM_RC 2296 TPM2B_CONTEXT_SENSITIVE_Unmarshal(TPM2B_CONTEXT_SENSITIVE *target, 2297 BYTE **buffer, INT32 *size); 2298 UINT16 2299 TPM2B_CONTEXT_SENSITIVE_Marshal(TPM2B_CONTEXT_SENSITIVE *source, 2300 BYTE **buffer, INT32 *size); 2301 2302 // Table 2:219 - Definition of TPMS_CONTEXT_DATA Structure 2303 TPM_RC 2304 TPMS_CONTEXT_DATA_Unmarshal(TPMS_CONTEXT_DATA *target, BYTE **buffer, INT32 *size); 2305 UINT16 2306 TPMS_CONTEXT_DATA_Marshal(TPMS_CONTEXT_DATA *source, BYTE **buffer, INT32 *size); 2307 2308 // Table 2:220 - Definition of TPM2B_CONTEXT_DATA Structure 2309 TPM_RC 2310 TPM2B_CONTEXT_DATA_Unmarshal(TPM2B_CONTEXT_DATA *target, 2311 BYTE **buffer, INT32 *size); 2312 UINT16 2313 TPM2B_CONTEXT_DATA_Marshal(TPM2B_CONTEXT_DATA *source, BYTE **buffer, INT32 *size); 2314 2315 // Table 2:221 - Definition of TPMS_CONTEXT Structure 2316 TPM_RC 2317 TPMS_CONTEXT_Unmarshal(TPMS_CONTEXT *target, BYTE **buffer, INT32 *size); 2318 UINT16 2319 TPMS_CONTEXT_Marshal(TPMS_CONTEXT *source, BYTE **buffer, INT32 *size); 2320 2321 // Table 2:223 - Definition of TPMS_CREATION_DATA Structure 2322 UINT16 2323 TPMS_CREATION_DATA_Marshal(TPMS_CREATION_DATA *source, BYTE **buffer, INT32 *size); 2324 2325 // Table 2:224 - Definition of TPM2B_CREATION_DATA Structure 2326 UINT16 2327 TPM2B_CREATION_DATA_Marshal(TPM2B_CREATION_DATA *source, 2328 BYTE **buffer, INT32 *size); 2329 2330 // Table 2:225 - Definition of TPM_AT Constants 2331 TPM_RC 2332 TPM_AT_Unmarshal(TPM_AT *target, BYTE **buffer, INT32 *size); 2333 #if !USE_MARSHALING_DEFINES 2334 UINT16 2335 TPM_AT_Marshal(TPM_AT *source, BYTE **buffer, INT32 *size); 2336 #else 2337 #define TPM_AT_Marshal(source, buffer, size) \ 2338 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 2339 #endif // !USE_MARSHALING_DEFINES 2340 2341 // Table 2:226 - Definition of TPM_AE Constants 2342 #if !USE_MARSHALING_DEFINES 2343 UINT16 2344 TPM_AE_Marshal(TPM_AE *source, BYTE **buffer, INT32 *size); 2345 #else 2346 #define TPM_AE_Marshal(source, buffer, size) \ 2347 UINT32_Marshal((UINT32 *)(source), (buffer), (size)) 2348 #endif // !USE_MARSHALING_DEFINES 2349 2350 // Table 2:227 - Definition of TPMS_AC_OUTPUT Structure 2351 UINT16 2352 TPMS_AC_OUTPUT_Marshal(TPMS_AC_OUTPUT *source, BYTE **buffer, INT32 *size); 2353 2354 // Table 2:228 - Definition of TPML_AC_CAPABILITIES Structure 2355 UINT16 2356 TPML_AC_CAPABILITIES_Marshal(TPML_AC_CAPABILITIES *source, 2357 BYTE **buffer, INT32 *size); 2358 2359 // Array Marshal/Unmarshal for BYTE 2360 TPM_RC 2361 BYTE_Array_Unmarshal(BYTE *target, BYTE **buffer, INT32 *size, INT32 count); 2362 UINT16 2363 BYTE_Array_Marshal(BYTE *source, BYTE **buffer, INT32 *size, INT32 count); 2364 2365 // Array Marshal/Unmarshal for TPM2B_DIGEST 2366 TPM_RC 2367 TPM2B_DIGEST_Array_Unmarshal(TPM2B_DIGEST *target, 2368 BYTE **buffer, INT32 *size, INT32 count); 2369 UINT16 2370 TPM2B_DIGEST_Array_Marshal(TPM2B_DIGEST *source, 2371 BYTE **buffer, INT32 *size, INT32 count); 2372 2373 // Array Marshal for TPMA_CC 2374 UINT16 2375 TPMA_CC_Array_Marshal(TPMA_CC *source, BYTE **buffer, INT32 *size, INT32 count); 2376 2377 // Array Marshal for TPMS_ACT_DATA 2378 UINT16 2379 TPMS_ACT_DATA_Array_Marshal(TPMS_ACT_DATA *source, 2380 BYTE **buffer, INT32 *size, INT32 count); 2381 2382 // Array Marshal for TPMS_AC_OUTPUT 2383 UINT16 2384 TPMS_AC_OUTPUT_Array_Marshal(TPMS_AC_OUTPUT *source, 2385 BYTE **buffer, INT32 *size, INT32 count); 2386 2387 // Array Marshal for TPMS_ALG_PROPERTY 2388 UINT16 2389 TPMS_ALG_PROPERTY_Array_Marshal(TPMS_ALG_PROPERTY *source, 2390 BYTE **buffer, INT32 *size, INT32 count); 2391 2392 // Array Marshal/Unmarshal for TPMS_PCR_SELECTION 2393 TPM_RC 2394 TPMS_PCR_SELECTION_Array_Unmarshal(TPMS_PCR_SELECTION *target, 2395 BYTE **buffer, INT32 *size, INT32 count); 2396 UINT16 2397 TPMS_PCR_SELECTION_Array_Marshal(TPMS_PCR_SELECTION *source, 2398 BYTE **buffer, INT32 *size, INT32 count); 2399 2400 // Array Marshal for TPMS_TAGGED_PCR_SELECT 2401 UINT16 2402 TPMS_TAGGED_PCR_SELECT_Array_Marshal(TPMS_TAGGED_PCR_SELECT *source, 2403 BYTE **buffer, INT32 *size, INT32 count); 2404 2405 // Array Marshal for TPMS_TAGGED_POLICY 2406 UINT16 2407 TPMS_TAGGED_POLICY_Array_Marshal(TPMS_TAGGED_POLICY *source, 2408 BYTE **buffer, INT32 *size, INT32 count); 2409 2410 // Array Marshal for TPMS_TAGGED_PROPERTY 2411 UINT16 2412 TPMS_TAGGED_PROPERTY_Array_Marshal(TPMS_TAGGED_PROPERTY *source, 2413 BYTE **buffer, INT32 *size, INT32 count); 2414 2415 // Array Marshal/Unmarshal for TPMT_HA 2416 TPM_RC 2417 TPMT_HA_Array_Unmarshal(TPMT_HA *target, 2418 BYTE **buffer, INT32 *size, BOOL flag, INT32 count); 2419 UINT16 2420 TPMT_HA_Array_Marshal(TPMT_HA *source, BYTE **buffer, INT32 *size, INT32 count); 2421 2422 // Array Marshal/Unmarshal for TPM_ALG_ID 2423 TPM_RC 2424 TPM_ALG_ID_Array_Unmarshal(TPM_ALG_ID *target, 2425 BYTE **buffer, INT32 *size, INT32 count); 2426 UINT16 2427 TPM_ALG_ID_Array_Marshal(TPM_ALG_ID *source, 2428 BYTE **buffer, INT32 *size, INT32 count); 2429 2430 // Array Marshal/Unmarshal for TPM_CC 2431 TPM_RC 2432 TPM_CC_Array_Unmarshal(TPM_CC *target, BYTE **buffer, INT32 *size, INT32 count); 2433 UINT16 2434 TPM_CC_Array_Marshal(TPM_CC *source, BYTE **buffer, INT32 *size, INT32 count); 2435 2436 // Array Marshal/Unmarshal for TPM_ECC_CURVE 2437 #if ALG_ECC 2438 TPM_RC 2439 TPM_ECC_CURVE_Array_Unmarshal(TPM_ECC_CURVE *target, 2440 BYTE **buffer, INT32 *size, INT32 count); 2441 UINT16 2442 TPM_ECC_CURVE_Array_Marshal(TPM_ECC_CURVE *source, 2443 BYTE **buffer, INT32 *size, INT32 count); 2444 #endif // ALG_ECC 2445 2446 // Array Marshal/Unmarshal for TPM_HANDLE 2447 TPM_RC 2448 TPM_HANDLE_Array_Unmarshal(TPM_HANDLE *target, 2449 BYTE **buffer, INT32 *size, INT32 count); 2450 UINT16 2451 TPM_HANDLE_Array_Marshal(TPM_HANDLE *source, 2452 BYTE **buffer, INT32 *size, INT32 count); 2453 #endif // _MARSHAL_FP_H_ 2454