2 Provide functions to provide tcg storage core spec related functions.
4 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
9 #include <Library/TcgStorageCoreLib.h>
11 #include <Library/BaseLib.h>
12 #include <Library/BaseMemoryLib.h>
13 #include <Library/DebugLib.h>
14 // #include <Library/PrintLib.h>
17 Required to be called before calling any other Tcg functions with the TCG_CREATE_STRUCT.
18 Initializes the packet variables to NULL. Additionally, the buffer will be memset.
20 @param [in/out] CreateStruct Structure to initialize
21 @param [in] Buffer Buffer allocated by client of library. It will contain the Tcg encoded packet. This cannot be null.
22 @param [in] BufferSize Size of buffer provided. It cannot be 0.
24 @retval Return the action result.
28 TcgInitTcgCreateStruct (
29 TCG_CREATE_STRUCT
*CreateStruct
,
34 NULL_CHECK (CreateStruct
);
37 if (BufferSize
== 0) {
38 DEBUG ((DEBUG_INFO
, "BufferSize=0\n"));
39 return (TcgResultFailureZeroSize
);
42 ZeroMem (Buffer
, BufferSize
);
43 CreateStruct
->BufferSize
= BufferSize
;
44 CreateStruct
->Buffer
= Buffer
;
45 CreateStruct
->ComPacket
= NULL
;
46 CreateStruct
->CurPacket
= NULL
;
47 CreateStruct
->CurSubPacket
= NULL
;
49 return (TcgResultSuccess
);
54 Encodes the ComPacket header to the data structure.
56 @param[in/out] CreateStruct Structure to initialize
57 @param[in] ComId ComID of the Tcg ComPacket.
58 @param[in] ComIdExtension ComID Extension of the Tcg ComPacket.
64 TCG_CREATE_STRUCT
*CreateStruct
,
69 NULL_CHECK (CreateStruct
);
71 if ((CreateStruct
->ComPacket
!= NULL
) ||
72 (CreateStruct
->CurPacket
!= NULL
) ||
73 (CreateStruct
->CurSubPacket
!= NULL
)
78 "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n",
79 CreateStruct
->ComPacket
,
80 CreateStruct
->CurPacket
,
81 CreateStruct
->CurSubPacket
83 return (TcgResultFailureInvalidAction
);
86 if (sizeof (TCG_COM_PACKET
) > CreateStruct
->BufferSize
) {
87 DEBUG ((DEBUG_INFO
, "BufferSize=0x%X\n", CreateStruct
->BufferSize
));
88 return (TcgResultFailureBufferTooSmall
);
91 CreateStruct
->ComPacket
= (TCG_COM_PACKET
*)CreateStruct
->Buffer
;
92 CreateStruct
->ComPacket
->ComIDBE
= SwapBytes16 (ComId
);
93 CreateStruct
->ComPacket
->ComIDExtensionBE
= SwapBytes16 (ComIdExtension
);
95 return (TcgResultSuccess
);
100 Starts a new ComPacket in the Data structure.
102 @param [in/out] CreateStruct Structure used to add Tcg Packet
103 @param[in] Tsn Packet Tper session number
104 @param[in] Hsn Packet Host session number
105 @param[in] SeqNumber Packet Sequence Number
106 @param[in] AckType Packet Acknowledge Type
107 @param[in] Ack Packet Acknowledge
113 TCG_CREATE_STRUCT
*CreateStruct
,
123 NULL_CHECK (CreateStruct
);
127 if ((CreateStruct
->ComPacket
== NULL
) ||
128 (CreateStruct
->CurPacket
!= NULL
) ||
129 (CreateStruct
->CurSubPacket
!= NULL
)
132 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct
->ComPacket
, CreateStruct
->CurPacket
, CreateStruct
->CurSubPacket
));
133 return (TcgResultFailureInvalidAction
);
136 // update TCG_COM_PACKET and packet lengths
137 AddedSize
= sizeof (TCG_PACKET
);
139 if ((SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + AddedSize
) > CreateStruct
->BufferSize
) {
140 DEBUG ((DEBUG_INFO
, "BufferSize=0x%X\n", CreateStruct
->BufferSize
));
141 return (TcgResultFailureBufferTooSmall
);
144 CreateStruct
->CurPacket
= (TCG_PACKET
*)(CreateStruct
->ComPacket
->Payload
+ SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
));
146 CreateStruct
->CurPacket
->TperSessionNumberBE
= SwapBytes32 (Tsn
);
147 CreateStruct
->CurPacket
->HostSessionNumberBE
= SwapBytes32 (Hsn
);
148 CreateStruct
->CurPacket
->SequenceNumberBE
= SwapBytes32 (SeqNumber
);
149 CreateStruct
->CurPacket
->AckTypeBE
= SwapBytes16 (AckType
);
150 CreateStruct
->CurPacket
->AcknowledgementBE
= SwapBytes32 (Ack
);
152 CreateStruct
->CurPacket
->LengthBE
= 0;
154 // update TCG_COM_PACKET Length for next pointer
155 CreateStruct
->ComPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + AddedSize
);
157 return (TcgResultSuccess
);
162 Starts a new SubPacket in the Data structure.
164 @param[in/out] CreateStruct Structure used to start Tcg SubPacket
165 @param[in] Kind SubPacket kind
171 TCG_CREATE_STRUCT
*CreateStruct
,
177 NULL_CHECK (CreateStruct
);
181 if ((CreateStruct
->ComPacket
== NULL
) ||
182 (CreateStruct
->CurPacket
== NULL
) ||
183 (CreateStruct
->CurSubPacket
!= NULL
)
186 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct
->ComPacket
, CreateStruct
->CurPacket
, CreateStruct
->CurSubPacket
));
187 return (TcgResultFailureInvalidAction
);
190 AddedSize
= sizeof (TCG_SUB_PACKET
);
192 if ((SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + AddedSize
) > CreateStruct
->BufferSize
) {
193 DEBUG ((DEBUG_INFO
, "BufferSize=0x%X\n", CreateStruct
->BufferSize
));
194 return (TcgResultFailureBufferTooSmall
);
197 CreateStruct
->CurSubPacket
= (TCG_SUB_PACKET
*)(CreateStruct
->CurPacket
->Payload
+ SwapBytes32 (CreateStruct
->CurPacket
->LengthBE
));
198 CreateStruct
->CurSubPacket
->KindBE
= SwapBytes16 (Kind
);
201 CreateStruct
->CurSubPacket
->LengthBE
= 0;
203 // update TCG_COM_PACKET and packet lengths
204 CreateStruct
->ComPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + AddedSize
);
205 CreateStruct
->CurPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->CurPacket
->LengthBE
) + AddedSize
);
207 return (TcgResultSuccess
);
212 Ends the current SubPacket in the Data structure. This function will also perform the 4-byte padding
213 required for Subpackets.
215 @param[in/out] CreateStruct Structure used to end the current Tcg SubPacket
221 TCG_CREATE_STRUCT
*CreateStruct
226 NULL_CHECK (CreateStruct
);
230 if ((CreateStruct
->ComPacket
== NULL
) ||
231 (CreateStruct
->CurPacket
== NULL
) ||
232 (CreateStruct
->CurSubPacket
== NULL
)
235 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct
->ComPacket
, CreateStruct
->CurPacket
, CreateStruct
->CurSubPacket
));
236 return (TcgResultFailureInvalidAction
);
239 // align to 4-byte boundaries, so shift padding
240 // pad Size does not apply to subpacket Length
241 PadSize
= TCG_SUBPACKET_ALIGNMENT
- (SwapBytes32 (CreateStruct
->CurSubPacket
->LengthBE
) & (TCG_SUBPACKET_ALIGNMENT
- 1));
243 if (PadSize
== TCG_SUBPACKET_ALIGNMENT
) {
247 if ((SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + PadSize
) > CreateStruct
->BufferSize
) {
248 DEBUG ((DEBUG_INFO
, "BufferSize=0x%X\n", CreateStruct
->BufferSize
));
249 return (TcgResultFailureBufferTooSmall
);
252 CreateStruct
->CurPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->CurPacket
->LengthBE
) + PadSize
);
253 CreateStruct
->ComPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + PadSize
);
255 CreateStruct
->CurSubPacket
= NULL
;
257 return (TcgResultSuccess
);
262 Ends the current Packet in the Data structure.
264 @param[in/out] CreateStruct Structure used to end the current Tcg Packet
270 TCG_CREATE_STRUCT
*CreateStruct
273 NULL_CHECK (CreateStruct
);
275 if ((CreateStruct
->ComPacket
== NULL
) ||
276 (CreateStruct
->CurPacket
== NULL
) ||
277 (CreateStruct
->CurSubPacket
!= NULL
)
280 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct
->ComPacket
, CreateStruct
->CurPacket
, CreateStruct
->CurSubPacket
));
281 return (TcgResultFailureInvalidAction
);
284 CreateStruct
->CurPacket
= NULL
;
286 return (TcgResultSuccess
);
291 Ends the ComPacket in the Data structure and ret
293 @param [in/out] CreateStruct Structure used to end the Tcg ComPacket
294 @param [in/out] Size Describes the Size of the entire ComPacket (Header and payload). Filled out by function.
300 TCG_CREATE_STRUCT
*CreateStruct
,
304 NULL_CHECK (CreateStruct
);
307 if ((CreateStruct
->ComPacket
== NULL
) ||
308 (CreateStruct
->CurPacket
!= NULL
) ||
309 (CreateStruct
->CurSubPacket
!= NULL
)
312 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct
->ComPacket
, CreateStruct
->CurPacket
, CreateStruct
->CurSubPacket
));
313 return (TcgResultFailureInvalidAction
);
316 *Size
= SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + sizeof (*CreateStruct
->ComPacket
);
317 CreateStruct
->ComPacket
= NULL
;
319 return (TcgResultSuccess
);
323 Adds raw Data with optional Header
325 @param CreateStruct The create structure.
326 @param Header The header structure.
327 @param HeaderSize The header size.
328 @param Data The data need to add.
329 @param DataSize The data size.
330 @param ByteSwapData Whether byte or swap data.
335 TCG_CREATE_STRUCT
*CreateStruct
,
345 const UINT8
*DataBytes
;
352 NULL_CHECK (CreateStruct
);
354 if (((HeaderSize
!= 0) && (Header
== NULL
)) ||
355 ((DataSize
!= 0) && (Data
== NULL
))
358 DEBUG ((DEBUG_INFO
, "HeaderSize=0x%X Header=%p DataSize=0x%X Data=%p\n", HeaderSize
, Header
, DataSize
, Data
));
359 return (TcgResultFailureNullPointer
);
362 if ((CreateStruct
->ComPacket
== NULL
) ||
363 (CreateStruct
->CurPacket
== NULL
) ||
364 (CreateStruct
->CurSubPacket
== NULL
)
367 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct
->ComPacket
, CreateStruct
->CurPacket
, CreateStruct
->CurSubPacket
));
368 return (TcgResultFailureInvalidAction
);
371 // verify there is enough Buffer Size
372 AddedSize
= HeaderSize
+ DataSize
;
373 if ((SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + AddedSize
) > CreateStruct
->BufferSize
) {
374 return (TcgResultFailureBufferTooSmall
);
377 // Get a pointer to where the new bytes should go
378 Dest
= CreateStruct
->ComPacket
->Payload
+ SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
);
380 switch (HeaderSize
) {
381 case sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM
):
382 case sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM
):
383 case sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM
):
384 CopyMem (Dest
, Header
, HeaderSize
);
386 case 0: // no Header is valid
388 // invalid Header Size
390 DEBUG ((DEBUG_INFO
, "unsupported HeaderSize=%u\n", HeaderSize
));
391 return TcgResultFailure
;
394 // copy the Data bytes
396 DataBytes
= (const UINT8
*)Data
;
397 for (Index
= 0; Index
< DataSize
; Index
++) {
398 Dest
[Index
] = DataBytes
[DataSize
- 1 - Index
];
401 CopyMem (Dest
, Data
, DataSize
);
404 // Update all the packet sizes
405 CreateStruct
->ComPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->ComPacket
->LengthBE
) + AddedSize
);
406 CreateStruct
->CurPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->CurPacket
->LengthBE
) + AddedSize
);
407 CreateStruct
->CurSubPacket
->LengthBE
= SwapBytes32 (SwapBytes32 (CreateStruct
->CurSubPacket
->LengthBE
) + AddedSize
);
409 return (TcgResultSuccess
);
414 Adds a single raw token byte to the Data structure.
416 @param[in/out] CreateStruct Structure used to add the byte
417 @param[in] Byte Byte to add
423 TCG_CREATE_STRUCT
*CreateStruct
,
427 return TcgAddRawTokenData (CreateStruct
, NULL
, 0, &Byte
, 1, FALSE
);
431 simple tokens - atoms: tiny, short, medium, long and empty atoms.
432 tiny atom can be a signed or unsigned integer.
433 short, medium, long can be a signed or unsigned integer OR a complete or non-final byte sequence.
435 @param CreateStruct The create structure.
436 @param Data The data need to add.
437 @param DataSize The data size.
438 @param ByteOrInt, Data format is byte or int.
439 @param SignOrCont sign or cont.
445 TCG_CREATE_STRUCT
*CreateStruct
,
452 const UINT8
*DataBytes
;
453 TCG_SIMPLE_TOKEN_TINY_ATOM TinyAtom
;
454 TCG_SIMPLE_TOKEN_SHORT_ATOM ShortAtom
;
455 TCG_SIMPLE_TOKEN_MEDIUM_ATOM MediumAtom
;
456 TCG_SIMPLE_TOKEN_LONG_ATOM LongAtom
;
458 NULL_CHECK (CreateStruct
);
461 if (ByteOrInt
== TCG_ATOM_TYPE_INTEGER
) {
462 DEBUG ((DEBUG_INFO
, "0-Size integer not allowed\n"));
463 return TcgResultFailure
;
466 // if DataSize != 0, Data must be valid
470 // encode Data using the shortest possible atom
471 DataBytes
= (const UINT8
*)Data
;
472 if ((DataSize
== 1) &&
473 (ByteOrInt
== TCG_ATOM_TYPE_INTEGER
) &&
474 (((SignOrCont
!= 0) && ((TCG_TOKEN_TINYATOM_SIGNED_MIN_VALUE
<= *(INT8
*)Data
) && (*(INT8
*)Data
<= TCG_TOKEN_TINYATOM_SIGNED_MAX_VALUE
))) ||
475 ((SignOrCont
== 0) && ((*DataBytes
<= TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE
))))
478 TinyAtom
.TinyAtomBits
.IsZero
= 0;
479 TinyAtom
.TinyAtomBits
.Sign
= SignOrCont
;
480 TinyAtom
.TinyAtomBits
.Data
= *DataBytes
& TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE
;
481 return TcgAddRawTokenData (CreateStruct
, NULL
, 0, (UINT8
*)&TinyAtom
, sizeof (TCG_SIMPLE_TOKEN_TINY_ATOM
), FALSE
);
484 if (DataSize
<= TCG_TOKEN_SHORTATOM_MAX_BYTE_SIZE
) {
485 ShortAtom
.ShortAtomBits
.IsOne
= 1;
486 ShortAtom
.ShortAtomBits
.IsZero
= 0;
487 ShortAtom
.ShortAtomBits
.ByteOrInt
= ByteOrInt
;
488 ShortAtom
.ShortAtomBits
.SignOrCont
= SignOrCont
;
489 ShortAtom
.ShortAtomBits
.Length
= DataSize
& 0x0F;
490 return TcgAddRawTokenData (CreateStruct
, &ShortAtom
, sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM
), Data
, DataSize
, ByteOrInt
== TCG_ATOM_TYPE_INTEGER
);
493 if (DataSize
<= TCG_TOKEN_MEDIUMATOM_MAX_BYTE_SIZE
) {
494 MediumAtom
.MediumAtomBits
.IsOne1
= 1;
495 MediumAtom
.MediumAtomBits
.IsOne2
= 1;
496 MediumAtom
.MediumAtomBits
.IsZero
= 0;
497 MediumAtom
.MediumAtomBits
.ByteOrInt
= ByteOrInt
;
498 MediumAtom
.MediumAtomBits
.SignOrCont
= SignOrCont
;
499 MediumAtom
.MediumAtomBits
.LengthLow
= DataSize
& 0xFF;
500 MediumAtom
.MediumAtomBits
.LengthHigh
= (DataSize
>> TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT
) & TCG_MEDIUM_ATOM_LENGTH_HIGH_MASK
;
501 return TcgAddRawTokenData (CreateStruct
, &MediumAtom
, sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM
), Data
, DataSize
, ByteOrInt
== TCG_ATOM_TYPE_INTEGER
);
504 LongAtom
.LongAtomBits
.IsOne1
= 1;
505 LongAtom
.LongAtomBits
.IsOne2
= 1;
506 LongAtom
.LongAtomBits
.IsOne3
= 1;
507 LongAtom
.LongAtomBits
.IsZero
= 0;
508 LongAtom
.LongAtomBits
.ByteOrInt
= ByteOrInt
;
509 LongAtom
.LongAtomBits
.SignOrCont
= SignOrCont
;
510 LongAtom
.LongAtomBits
.LengthLow
= DataSize
& 0xFF;
511 LongAtom
.LongAtomBits
.LengthMid
= (DataSize
>> TCG_LONG_ATOM_LENGTH_MID_SHIFT
) & 0xFF;
512 LongAtom
.LongAtomBits
.LengthHigh
= (DataSize
>> TCG_LONG_ATOM_LENGTH_HIGH_SHIFT
) & 0xFF;
513 return TcgAddRawTokenData (CreateStruct
, &LongAtom
, sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM
), Data
, DataSize
, ByteOrInt
== TCG_ATOM_TYPE_INTEGER
);
518 Adds the Data parameter as a byte sequence to the Data structure.
520 @param[in/out] CreateStruct Structure used to add the byte sequence
521 @param[in] Data Byte sequence that will be encoded and copied into Data structure
522 @param[in] DataSize Length of Data provided
523 @param[in] Continued TRUE if byte sequence is continued or
524 FALSE if the Data contains the entire byte sequence to be encoded
530 TCG_CREATE_STRUCT
*CreateStruct
,
536 return TcgAddAtom (CreateStruct
, Data
, DataSize
, TCG_ATOM_TYPE_BYTE
, Continued
? 1 : 0);
541 Adds an arbitrary-Length integer to the Data structure.
542 The integer will be encoded using the shortest possible atom.
544 @param[in/out] CreateStruct Structure used to add the integer
545 @param[in] Data Integer in host byte order that will be encoded and copied into Data structure
546 @param[in] DataSize Length in bytes of the Data provided
547 @param[in] SignedInteger TRUE if the integer is signed or FALSE if the integer is unsigned
553 TCG_CREATE_STRUCT
*CreateStruct
,
556 BOOLEAN SignedInteger
559 const UINT8
*DataBytes
;
560 UINT32 ActualDataSize
;
561 BOOLEAN ValueIsNegative
;
563 NULL_CHECK (CreateStruct
);
567 DEBUG ((DEBUG_INFO
, "invalid DataSize=0\n"));
568 return TcgResultFailure
;
571 DataBytes
= (const UINT8
*)Data
;
573 // integer should be represented by smallest atom possible
574 // so calculate real Data Size
575 ValueIsNegative
= SignedInteger
&& DataBytes
[DataSize
- 1] & 0x80;
577 // assumes native Data is little endian
578 // shorten Data to smallest byte representation
579 for (ActualDataSize
= DataSize
; ActualDataSize
> 1; ActualDataSize
--) {
580 // ignore sign extended FFs
581 if (ValueIsNegative
&& (DataBytes
[ActualDataSize
- 1] != 0xFF)) {
583 } else if (!ValueIsNegative
&& (DataBytes
[ActualDataSize
- 1] != 0)) {
584 // ignore extended 00s
589 return TcgAddAtom (CreateStruct
, Data
, ActualDataSize
, TCG_ATOM_TYPE_INTEGER
, SignedInteger
? 1 : 0);
593 Adds an 8-bit unsigned integer to the Data structure.
595 @param[in/out] CreateStruct Structure used to add the integer
596 @param[in] Value Integer Value to add
602 TCG_CREATE_STRUCT
*CreateStruct
,
606 return TcgAddInteger (CreateStruct
, &Value
, sizeof (Value
), FALSE
);
611 Adds a 16-bit unsigned integer to the Data structure.
613 @param[in/out] CreateStruct Structure used to add the integer
614 @param[in] Value Integer Value to add
620 TCG_CREATE_STRUCT
*CreateStruct
,
624 return TcgAddInteger (CreateStruct
, &Value
, sizeof (Value
), FALSE
);
629 Adds a 32-bit unsigned integer to the Data structure.
631 @param[in/out] CreateStruct Structure used to add the integer
632 @param[in] Value Integer Value to add
638 TCG_CREATE_STRUCT
*CreateStruct
,
642 return TcgAddInteger (CreateStruct
, &Value
, sizeof (Value
), FALSE
);
647 Adds a 64-bit unsigned integer to the Data structure.
649 @param[in/out] CreateStruct Structure used to add the integer
650 @param[in] Value Integer Value to add
656 TCG_CREATE_STRUCT
*CreateStruct
,
660 return TcgAddInteger (CreateStruct
, &Value
, sizeof (Value
), FALSE
);
664 Adds a BOOLEAN to the Data structure.
666 @param[in/out] CreateStruct Structure used to add the integer
667 @param[in] Value BOOLEAN Value to add
673 TCG_CREATE_STRUCT
*CreateStruct
,
677 return TcgAddInteger (CreateStruct
, &Value
, sizeof (Value
), FALSE
);
683 @param [in/out] CreateStruct Structure used to add the integer
684 @param Uid Input uid info.
686 @retval return the action result.
692 TCG_CREATE_STRUCT
*CreateStruct
,
696 return TcgAddByteSequence (CreateStruct
, &Uid
, sizeof (TCG_UID
), FALSE
);
702 @param [in/out] CreateStruct Structure used to add the integer
704 @retval return the action result.
710 TCG_CREATE_STRUCT
*CreateStruct
713 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_STARTLIST
);
719 @param [in/out] CreateStruct Structure used to add the integer
721 @retval return the action result.
727 TCG_CREATE_STRUCT
*CreateStruct
730 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_ENDLIST
);
736 @param [in/out] CreateStruct Structure used to add the integer
738 @retval return the action result.
744 TCG_CREATE_STRUCT
*CreateStruct
747 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_STARTNAME
);
753 @param [in/out] CreateStruct Structure used to add the integer
755 @retval return the action result.
761 TCG_CREATE_STRUCT
*CreateStruct
764 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_ENDNAME
);
770 @param [in/out] CreateStruct Structure used to add the integer
772 @retval return the action result.
778 TCG_CREATE_STRUCT
*CreateStruct
781 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_CALL
);
787 @param [in/out] CreateStruct Structure used to add the integer
789 @retval return the action result.
795 TCG_CREATE_STRUCT
*CreateStruct
798 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_ENDDATA
);
804 @param [in/out] CreateStruct Structure used to add the integer
806 @retval return the action result.
812 TCG_CREATE_STRUCT
*CreateStruct
815 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_ENDSESSION
);
819 Add start transaction.
821 @param [in/out] CreateStruct Structure used to add the integer
823 @retval return the action result.
828 TcgAddStartTransaction (
829 TCG_CREATE_STRUCT
*CreateStruct
832 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_STARTTRANSACTION
);
838 @param [in/out] CreateStruct Structure used to add the integer
840 @retval return the action result.
845 TcgAddEndTransaction (
846 TCG_CREATE_STRUCT
*CreateStruct
849 return TcgAddRawByte (CreateStruct
, TCG_TOKEN_ENDTRANSACTION
);
853 Initial the tcg parse structure.
855 @param ParseStruct Input parse structure.
856 @param Buffer Input buffer data.
857 @param BufferSize Input buffer size.
859 @retval return the action result.
864 TcgInitTcgParseStruct (
865 TCG_PARSE_STRUCT
*ParseStruct
,
870 UINT32 ComPacketLength
;
873 NULL_CHECK (ParseStruct
);
876 if (BufferSize
< sizeof (TCG_COM_PACKET
)) {
877 return (TcgResultFailureBufferTooSmall
);
880 ParseStruct
->ComPacket
= (TCG_COM_PACKET
*)Buffer
;
882 ComPacketLength
= SwapBytes32 (ParseStruct
->ComPacket
->LengthBE
);
884 if ((BufferSize
- sizeof (TCG_COM_PACKET
)) < ComPacketLength
) {
885 DEBUG ((DEBUG_INFO
, "Buffer %u too small for ComPacket %u\n", BufferSize
, ComPacketLength
));
886 return (TcgResultFailureBufferTooSmall
);
889 ParseStruct
->BufferSize
= BufferSize
;
890 ParseStruct
->Buffer
= Buffer
;
892 ParseStruct
->CurPacket
= NULL
;
893 ParseStruct
->CurSubPacket
= NULL
;
894 ParseStruct
->CurPtr
= NULL
;
896 // if payload > 0, then must have a packet
897 if (ComPacketLength
!= 0) {
898 if (ComPacketLength
< sizeof (TCG_PACKET
)) {
899 DEBUG ((DEBUG_INFO
, "ComPacket too small for Packet\n"));
900 return (TcgResultFailureBufferTooSmall
);
903 ParseStruct
->CurPacket
= (TCG_PACKET
*)ParseStruct
->ComPacket
->Payload
;
905 PacketLength
= SwapBytes32 (ParseStruct
->CurPacket
->LengthBE
);
907 if (PacketLength
> 0) {
908 if (PacketLength
< sizeof (TCG_SUB_PACKET
)) {
909 DEBUG ((DEBUG_INFO
, "Packet too small for SubPacket\n"));
910 return (TcgResultFailureBufferTooSmall
);
913 ParseStruct
->CurSubPacket
= (TCG_SUB_PACKET
*)ParseStruct
->CurPacket
->Payload
;
917 // TODO should check for method status list at this point?
919 return (TcgResultSuccess
);
925 @param ParseStruct Input parse structure info.
926 @param TcgToken return the tcg token info.
928 @retval return the action result.
934 TCG_PARSE_STRUCT
*ParseStruct
,
938 const UINT8
*EndOfSubPacket
;
941 TCG_SIMPLE_TOKEN_SHORT_ATOM
*TmpShort
;
942 const TCG_SIMPLE_TOKEN_MEDIUM_ATOM
*TmpMed
;
943 const TCG_SIMPLE_TOKEN_LONG_ATOM
*TmpLong
;
945 NULL_CHECK (ParseStruct
);
946 NULL_CHECK (TcgToken
);
948 if ((ParseStruct
->ComPacket
== NULL
) ||
949 (ParseStruct
->CurPacket
== NULL
) ||
950 (ParseStruct
->CurSubPacket
== NULL
)
953 DEBUG ((DEBUG_INFO
, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", ParseStruct
->ComPacket
, ParseStruct
->CurPacket
, ParseStruct
->CurSubPacket
));
954 return TcgResultFailureInvalidAction
;
957 // initial call, start at sub packet
958 if (ParseStruct
->CurPtr
== NULL
) {
959 ParseStruct
->CurPtr
= ParseStruct
->CurSubPacket
->Payload
;
962 EndOfSubPacket
= ParseStruct
->CurSubPacket
->Payload
+ SwapBytes32 (ParseStruct
->CurSubPacket
->LengthBE
);
965 // confirmed that subpacket Length falls within end of Buffer and TCG_COM_PACKET,
966 // so simply need to verify the loop stays within current subpacket
967 if (ParseStruct
->CurPtr
>= EndOfSubPacket
) {
968 DEBUG ((DEBUG_INFO
, "ParseStruct->CurPtr >= EndOfSubPacket\n"));
969 return (TcgResultFailureEndBuffer
);
972 Hdr
= *ParseStruct
->CurPtr
;
973 TcgToken
->HdrStart
= ParseStruct
->CurPtr
;
977 // tiny atom Header is only 1 byte, so don't need to verify Size before cast and access
978 TcgToken
->Type
= TcgTokenTypeTinyAtom
;
980 TokenEnd
= TcgToken
->HdrStart
+ sizeof (TCG_SIMPLE_TOKEN_TINY_ATOM
);
982 // verify caller will have enough Size to reference token
983 if (TokenEnd
>= EndOfSubPacket
) {
984 DEBUG ((DEBUG_INFO
, "Tiny Atom TokenEnd >= EndOfSubPacket\n"));
985 return (TcgResultFailureEndBuffer
);
989 else if ((0x80 <= Hdr
) && (Hdr
<= 0xBF)) {
990 // short atom Header is only 1 byte, so don't need to verify Size before cast and access
991 TmpShort
= (TCG_SIMPLE_TOKEN_SHORT_ATOM
*)(ParseStruct
->CurPtr
);
992 TcgToken
->Type
= TcgTokenTypeShortAtom
;
994 TokenEnd
= (TcgToken
->HdrStart
+ sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM
) + TmpShort
->ShortAtomBits
.Length
);
996 // verify caller will have enough Size to reference token
997 if (TokenEnd
>= EndOfSubPacket
) {
998 DEBUG ((DEBUG_INFO
, "Short Atom TokenEnd >= EndOfSubPacket\n"));
999 return (TcgResultFailureEndBuffer
);
1002 // Medium Atom Range
1003 else if ((0xC0 <= Hdr
) && (Hdr
<= 0xDF)) {
1004 if (TcgToken
->HdrStart
+ sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM
) >= EndOfSubPacket
) {
1005 return (TcgResultFailureEndBuffer
);
1008 TmpMed
= (const TCG_SIMPLE_TOKEN_MEDIUM_ATOM
*)ParseStruct
->CurPtr
;
1009 TcgToken
->Type
= TcgTokenTypeMediumAtom
;
1010 TokenEnd
= TcgToken
->HdrStart
+ sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM
) +
1011 ((TmpMed
->MediumAtomBits
.LengthHigh
<< TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT
) |
1012 TmpMed
->MediumAtomBits
.LengthLow
);
1014 // verify caller will have enough Size to reference token
1015 if (TokenEnd
>= EndOfSubPacket
) {
1016 DEBUG ((DEBUG_INFO
, "Medium Atom TokenEnd >= EndOfSubPacket\n"));
1017 return (TcgResultFailureEndBuffer
);
1021 else if ((0xE0 <= Hdr
) && (Hdr
<= 0xE3)) {
1022 if (TcgToken
->HdrStart
+ sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM
) >= EndOfSubPacket
) {
1023 return (TcgResultFailureEndBuffer
);
1026 TmpLong
= (const TCG_SIMPLE_TOKEN_LONG_ATOM
*)ParseStruct
->CurPtr
;
1027 TcgToken
->Type
= TcgTokenTypeLongAtom
;
1029 TokenEnd
= TcgToken
->HdrStart
+ sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM
) +
1030 ((TmpLong
->LongAtomBits
.LengthHigh
<< TCG_LONG_ATOM_LENGTH_HIGH_SHIFT
) |
1031 (TmpLong
->LongAtomBits
.LengthMid
<< TCG_LONG_ATOM_LENGTH_MID_SHIFT
) |
1032 TmpLong
->LongAtomBits
.LengthLow
);
1034 // verify caller will have enough Size to reference token
1035 if (TokenEnd
>= EndOfSubPacket
) {
1036 DEBUG ((DEBUG_INFO
, "Long Atom TokenEnd >= EndOfSubPacket\n"));
1037 return (TcgResultFailureEndBuffer
);
1040 // single byte tokens
1042 case TCG_TOKEN_STARTLIST
:
1043 TcgToken
->Type
= TcgTokenTypeStartList
;
1045 case TCG_TOKEN_ENDLIST
:
1046 TcgToken
->Type
= TcgTokenTypeEndList
;
1048 case TCG_TOKEN_STARTNAME
:
1049 TcgToken
->Type
= TcgTokenTypeStartName
;
1051 case TCG_TOKEN_ENDNAME
:
1052 TcgToken
->Type
= TcgTokenTypeEndName
;
1054 case TCG_TOKEN_CALL
:
1055 TcgToken
->Type
= TcgTokenTypeCall
;
1057 case TCG_TOKEN_ENDDATA
:
1058 TcgToken
->Type
= TcgTokenTypeEndOfData
;
1060 case TCG_TOKEN_ENDSESSION
:
1061 TcgToken
->Type
= TcgTokenTypeEndOfSession
;
1063 case TCG_TOKEN_STARTTRANSACTION
:
1064 TcgToken
->Type
= TcgTokenTypeStartTransaction
;
1066 case TCG_TOKEN_ENDTRANSACTION
:
1067 TcgToken
->Type
= TcgTokenTypeEndTransaction
;
1069 case TCG_TOKEN_EMPTY
:
1070 TcgToken
->Type
= TcgTokenTypeEmptyAtom
;
1073 DEBUG ((DEBUG_INFO
, "WARNING: reserved token Type 0x%02X\n", Hdr
));
1074 TcgToken
->Type
= TcgTokenTypeReserved
;
1078 ParseStruct
->CurPtr
++;
1079 TokenEnd
= TcgToken
->HdrStart
+ 1;
1082 // increment curptr for next call
1083 ParseStruct
->CurPtr
= TokenEnd
;
1084 return (TcgResultSuccess
);
1090 @param TcgToken Input token info.
1091 @param HeaderLength return the header length.
1092 @param DataLength return the data length.
1093 @param ByteOrInt return the atom Type.
1094 @param SignOrCont return the sign or count info.
1096 @retval return the action result.
1102 const TCG_TOKEN
*TcgToken
,
1103 UINT32
*HeaderLength
,
1109 TCG_SIMPLE_TOKEN_TINY_ATOM
*TinyAtom
;
1110 TCG_SIMPLE_TOKEN_SHORT_ATOM
*ShortAtom
;
1111 TCG_SIMPLE_TOKEN_MEDIUM_ATOM
*MediumAtom
;
1112 TCG_SIMPLE_TOKEN_LONG_ATOM
*LongAtom
;
1114 NULL_CHECK (TcgToken
);
1115 NULL_CHECK (HeaderLength
);
1116 NULL_CHECK (DataLength
);
1117 NULL_CHECK (ByteOrInt
);
1118 NULL_CHECK (SignOrCont
);
1120 switch (TcgToken
->Type
) {
1121 case TcgTokenTypeTinyAtom
:
1123 TinyAtom
= (TCG_SIMPLE_TOKEN_TINY_ATOM
*)TcgToken
->HdrStart
;
1124 *ByteOrInt
= TCG_ATOM_TYPE_INTEGER
;
1125 *SignOrCont
= TinyAtom
->TinyAtomBits
.Sign
;
1127 *DataLength
= 0; // tiny atom must be handled as a special case - Header and Data in the same byte
1128 return TcgResultSuccess
;
1131 case TcgTokenTypeShortAtom
:
1133 ShortAtom
= (TCG_SIMPLE_TOKEN_SHORT_ATOM
*)TcgToken
->HdrStart
;
1134 *ByteOrInt
= ShortAtom
->ShortAtomBits
.ByteOrInt
;
1135 *SignOrCont
= ShortAtom
->ShortAtomBits
.SignOrCont
;
1136 *HeaderLength
= sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM
);
1137 *DataLength
= ShortAtom
->ShortAtomBits
.Length
;
1138 return TcgResultSuccess
;
1141 case TcgTokenTypeMediumAtom
:
1143 MediumAtom
= (TCG_SIMPLE_TOKEN_MEDIUM_ATOM
*)TcgToken
->HdrStart
;
1144 *ByteOrInt
= MediumAtom
->MediumAtomBits
.ByteOrInt
;
1145 *SignOrCont
= MediumAtom
->MediumAtomBits
.SignOrCont
;
1146 *HeaderLength
= sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM
);
1147 *DataLength
= (MediumAtom
->MediumAtomBits
.LengthHigh
<< TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT
) | MediumAtom
->MediumAtomBits
.LengthLow
;
1148 return TcgResultSuccess
;
1151 case TcgTokenTypeLongAtom
:
1153 LongAtom
= (TCG_SIMPLE_TOKEN_LONG_ATOM
*)TcgToken
->HdrStart
;
1154 *ByteOrInt
= LongAtom
->LongAtomBits
.ByteOrInt
;
1155 *SignOrCont
= LongAtom
->LongAtomBits
.SignOrCont
;
1156 *HeaderLength
= sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM
);
1157 *DataLength
= (LongAtom
->LongAtomBits
.LengthHigh
<< TCG_LONG_ATOM_LENGTH_HIGH_SHIFT
) |
1158 (LongAtom
->LongAtomBits
.LengthMid
<< TCG_LONG_ATOM_LENGTH_MID_SHIFT
) |
1159 LongAtom
->LongAtomBits
.LengthLow
;
1160 return TcgResultSuccess
;
1164 DEBUG ((DEBUG_INFO
, "Token Type is not simple atom (%d)\n", TcgToken
->Type
));
1165 return (TcgResultFailureInvalidType
);
1170 Get token specified value.
1172 @param TcgToken Input token info.
1173 @param Value return the value.
1175 @retval return the action result.
1181 const TCG_TOKEN
*TcgToken
,
1189 TCG_SIMPLE_TOKEN_TINY_ATOM
*TmpTiny
;
1193 NULL_CHECK (TcgToken
);
1198 ERROR_CHECK (TcgGetAtomInfo (TcgToken
, &HdrLength
, &DataLength
, &ByteOrInt
, &IsSigned
));
1200 if (ByteOrInt
!= TCG_ATOM_TYPE_INTEGER
) {
1201 DEBUG ((DEBUG_INFO
, "Invalid Type, expected integer not byte sequence\n"));
1202 return TcgResultFailureInvalidType
;
1205 if (IsSigned
!= 0) {
1206 DEBUG ((DEBUG_INFO
, "Integer is signed, expected unsigned\n"));
1207 return TcgResultFailureInvalidType
;
1210 // special case for tiny atom
1211 // Header and Data are in one byte, so extract only the Data bitfield
1212 if (TcgToken
->Type
== TcgTokenTypeTinyAtom
) {
1213 TmpTiny
= (TCG_SIMPLE_TOKEN_TINY_ATOM
*)TcgToken
->HdrStart
;
1214 *Value
= TmpTiny
->TinyAtomBits
.Data
;
1215 return TcgResultSuccess
;
1218 if (DataLength
> sizeof (UINT64
)) {
1219 DEBUG ((DEBUG_INFO
, "Length %d is greater than Size of UINT64\n", DataLength
));
1220 return TcgResultFailureBufferTooSmall
;
1223 // read big-endian integer
1224 Data
= TcgToken
->HdrStart
+ HdrLength
;
1225 for (Index
= 0; Index
< DataLength
; Index
++) {
1226 *Value
= LShiftU64 (*Value
, 8) | Data
[Index
];
1229 return TcgResultSuccess
;
1233 Get token byte sequence.
1235 @param TcgToken Input token info.
1236 @param Length Input the length info.
1238 @retval Return the value data.
1243 TcgGetTokenByteSequence (
1244 const TCG_TOKEN
*TcgToken
,
1252 if ((TcgToken
== NULL
) || (Length
== NULL
)) {
1257 if (TcgGetAtomInfo (TcgToken
, &HdrLength
, Length
, &ByteOrInt
, &SignOrCont
) != TcgResultSuccess
) {
1258 DEBUG ((DEBUG_INFO
, "Failed to get simple token info\n"));
1262 if (ByteOrInt
!= TCG_ATOM_TYPE_BYTE
) {
1263 DEBUG ((DEBUG_INFO
, "Invalid Type, expected byte sequence not integer\n"));
1267 return (TcgToken
->HdrStart
+ HdrLength
);
1271 Get next specify value.
1273 @param ParseStruct Input parse structure.
1274 @param Value Return value.
1276 @retval return the action result.
1282 TCG_PARSE_STRUCT
*ParseStruct
,
1291 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1292 ERROR_CHECK (TcgGetTokenUINT64 (&Tok
, &Value64
));
1294 if (Value64
> MAX_UINT8
) {
1295 return TcgResultFailure
;
1298 *Value
= (UINT8
)Value64
;
1300 return TcgResultSuccess
;
1304 Get next specify value.
1306 @param ParseStruct Input parse structure.
1307 @param Value Return value.
1309 @retval return the action result.
1315 TCG_PARSE_STRUCT
*ParseStruct
,
1324 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1325 ERROR_CHECK (TcgGetTokenUINT64 (&Tok
, &Value64
));
1327 if (Value64
> MAX_UINT16
) {
1328 return TcgResultFailure
;
1331 *Value
= (UINT16
)Value64
;
1333 return TcgResultSuccess
;
1337 Get next specify value.
1339 @param ParseStruct Input parse structure.
1340 @param Value Return value.
1342 @retval return the action result.
1348 TCG_PARSE_STRUCT
*ParseStruct
,
1357 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1358 ERROR_CHECK (TcgGetTokenUINT64 (&Tok
, &Value64
));
1360 if (Value64
> MAX_UINT32
) {
1361 return TcgResultFailure
;
1364 *Value
= (UINT32
)Value64
;
1366 return TcgResultSuccess
;
1370 Get next specify value.
1372 @param ParseStruct Input parse structure.
1373 @param Value Return value.
1375 @retval return the action result.
1381 TCG_PARSE_STRUCT
*ParseStruct
,
1387 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1388 ERROR_CHECK (TcgGetTokenUINT64 (&Tok
, Value
));
1389 return TcgResultSuccess
;
1393 Get next specify value.
1395 @param ParseStruct Input parse structure.
1396 @param Value Return value.
1398 @retval return the action result.
1404 TCG_PARSE_STRUCT
*ParseStruct
,
1413 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1414 ERROR_CHECK (TcgGetTokenUINT64 (&Tok
, &Value64
));
1417 return TcgResultFailure
;
1420 *Value
= (BOOLEAN
)Value64
;
1422 return TcgResultSuccess
;
1426 Get next tcg uid info.
1428 @param ParseStruct Input parse structure.
1429 @param Uid Get the uid info.
1431 @retval return the action result.
1437 TCG_PARSE_STRUCT
*ParseStruct
,
1443 const UINT8
*ByteSeq
;
1447 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1448 ByteSeq
= TcgGetTokenByteSequence (&Tok
, &Length
);
1450 if (Length
!= sizeof (TCG_UID
)) {
1451 DEBUG ((DEBUG_INFO
, "Token Length %u != TCG_UID Size %u\n", Length
, (UINT32
)sizeof (TCG_UID
)));
1452 return TcgResultFailure
;
1455 ASSERT (ByteSeq
!= NULL
);
1457 CopyMem (Uid
, ByteSeq
, sizeof (TCG_UID
));
1459 return TcgResultSuccess
;
1463 Get next byte sequence.
1465 @param ParseStruct Input parse structure.
1466 @param Data return the data.
1467 @param Length return the length.
1469 @retval return the action result.
1474 TcgGetNextByteSequence (
1475 TCG_PARSE_STRUCT
*ParseStruct
,
1483 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1484 Bs
= TcgGetTokenByteSequence (&Tok
, Length
);
1487 return TcgResultFailure
;
1491 return TcgResultSuccess
;
1495 Get next token Type.
1497 @param ParseStruct Input parse structure.
1498 @param Type Input the type need to check.
1500 @retval return the action result.
1505 TcgGetNextTokenType (
1506 TCG_PARSE_STRUCT
*ParseStruct
,
1512 ERROR_CHECK (TcgGetNextToken (ParseStruct
, &Tok
));
1513 if (Tok
.Type
!= Type
) {
1514 DEBUG ((DEBUG_INFO
, "expected Type %u, got Type %u\n", Type
, Tok
.Type
));
1515 return TcgResultFailure
;
1518 return TcgResultSuccess
;
1522 Get next start list.
1524 @param ParseStruct Input parse structure.
1526 @retval return the action result.
1531 TcgGetNextStartList (
1532 TCG_PARSE_STRUCT
*ParseStruct
1535 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeStartList
);
1541 @param ParseStruct Input parse structure.
1543 @retval return the action result.
1549 TCG_PARSE_STRUCT
*ParseStruct
1552 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeEndList
);
1556 Get next start name.
1558 @param ParseStruct Input parse structure.
1560 @retval return the action result.
1565 TcgGetNextStartName (
1566 TCG_PARSE_STRUCT
*ParseStruct
1569 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeStartName
);
1575 @param ParseStruct Input parse structure.
1577 @retval return the action result.
1583 TCG_PARSE_STRUCT
*ParseStruct
1586 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeEndName
);
1592 @param ParseStruct Input parse structure.
1594 @retval return the action result.
1600 TCG_PARSE_STRUCT
*ParseStruct
1603 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeCall
);
1609 @param ParseStruct Input parse structure.
1611 @retval return the action result.
1616 TcgGetNextEndOfData (
1617 TCG_PARSE_STRUCT
*ParseStruct
1620 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeEndOfData
);
1624 Get next end of session.
1626 @param ParseStruct Input parse structure.
1628 @retval return the action result.
1633 TcgGetNextEndOfSession (
1634 TCG_PARSE_STRUCT
*ParseStruct
1637 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeEndOfSession
);
1641 Get next start transaction.
1643 @param ParseStruct Input parse structure.
1645 @retval return the action result.
1650 TcgGetNextStartTransaction (
1651 TCG_PARSE_STRUCT
*ParseStruct
1654 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeStartTransaction
);
1658 Get next end transaction.
1660 @param ParseStruct Input parse structure.
1662 @retval return the action result.
1667 TcgGetNextEndTransaction (
1668 TCG_PARSE_STRUCT
*ParseStruct
1671 return TcgGetNextTokenType (ParseStruct
, TcgTokenTypeEndTransaction
);