Home | History | Annotate | Download | only in TcgStorageCoreLib 
      1 /** @file
      2   Provide functions to provide tcg storage core spec related functions.
      3 
      4 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
      5 This program and the accompanying materials
      6 are licensed and made available under the terms and conditions of the BSD License
      7 which accompanies this distribution.  The full text of the license may be found at
      8 http://opensource.org/licenses/bsd-license.php
      9 
     10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     12 
     13 **/
     14 
     15 #include <Library/TcgStorageCoreLib.h>
     16 
     17 #include <Library/BaseLib.h>
     18 #include <Library/BaseMemoryLib.h>
     19 #include <Library/DebugLib.h>
     20 //#include <Library/PrintLib.h>
     21 
     22 /**
     23   Required to be called before calling any other Tcg functions with the TCG_CREATE_STRUCT.
     24   Initializes the packet variables to NULL.  Additionally, the buffer will be memset.
     25 
     26   @param [in/out]    CreateStruct    Structure to initialize
     27   @param [in]        Buffer          Buffer allocated by client of library.  It will contain the Tcg encoded packet.  This cannot be null.
     28   @param [in]        BufferSize      Size of buffer provided.  It cannot be 0.
     29 
     30   @retval       Return the action result.
     31 **/
     32 TCG_RESULT
     33 EFIAPI
     34 TcgInitTcgCreateStruct(
     35   TCG_CREATE_STRUCT      *CreateStruct,
     36   VOID                   *Buffer,
     37   UINT32                 BufferSize
     38   )
     39 {
     40   NULL_CHECK(CreateStruct);
     41   NULL_CHECK(Buffer);
     42 
     43   if (BufferSize == 0) {
     44     DEBUG ((DEBUG_INFO, "BufferSize=0\n"));
     45     return (TcgResultFailureZeroSize);
     46   }
     47 
     48   ZeroMem(Buffer, BufferSize);
     49   CreateStruct->BufferSize = BufferSize;
     50   CreateStruct->Buffer = Buffer;
     51   CreateStruct->ComPacket = NULL;
     52   CreateStruct->CurPacket = NULL;
     53   CreateStruct->CurSubPacket = NULL;
     54 
     55   return (TcgResultSuccess);
     56 }
     57 
     58 /**
     59 
     60   Encodes the ComPacket header to the data structure.
     61 
     62   @param[in/out]    CreateStruct          Structure to initialize
     63   @param[in]        ComId                 ComID of the Tcg ComPacket.
     64   @param[in]        ComIdExtension        ComID Extension of the Tcg ComPacket.
     65 
     66 **/
     67 TCG_RESULT
     68 EFIAPI
     69 TcgStartComPacket(
     70   TCG_CREATE_STRUCT   *CreateStruct,
     71   UINT16              ComId,
     72   UINT16              ComIdExtension
     73   )
     74 {
     75   NULL_CHECK(CreateStruct);
     76 
     77   if (CreateStruct->ComPacket != NULL ||
     78       CreateStruct->CurPacket != NULL ||
     79       CreateStruct->CurSubPacket != NULL
     80      ) {
     81     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket,
     82     CreateStruct->CurSubPacket));
     83     return (TcgResultFailureInvalidAction);
     84   }
     85 
     86   if (sizeof(TCG_COM_PACKET) > CreateStruct->BufferSize) {
     87     DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
     88     return (TcgResultFailureBufferTooSmall);
     89   }
     90 
     91   CreateStruct->ComPacket = (TCG_COM_PACKET*)CreateStruct->Buffer;
     92   CreateStruct->ComPacket->ComIDBE = SwapBytes16(ComId);
     93   CreateStruct->ComPacket->ComIDExtensionBE = SwapBytes16(ComIdExtension);
     94 
     95   return (TcgResultSuccess);
     96 }
     97 
     98 /**
     99 
    100   Starts a new ComPacket in the Data structure.
    101 
    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
    108 
    109 **/
    110 TCG_RESULT
    111 EFIAPI
    112 TcgStartPacket(
    113   TCG_CREATE_STRUCT    *CreateStruct,
    114   UINT32               Tsn,
    115   UINT32               Hsn,
    116   UINT32               SeqNumber,
    117   UINT16               AckType,
    118   UINT32               Ack
    119   )
    120 {
    121   UINT32 AddedSize;
    122   NULL_CHECK(CreateStruct);
    123 
    124   AddedSize = 0;
    125 
    126   if (CreateStruct->ComPacket == NULL ||
    127       CreateStruct->CurPacket != NULL ||
    128       CreateStruct->CurSubPacket != NULL
    129      ) {
    130     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    131     return (TcgResultFailureInvalidAction);
    132   }
    133 
    134   // update TCG_COM_PACKET and packet lengths
    135   AddedSize = sizeof(TCG_PACKET);
    136 
    137   if ((SwapBytes32(CreateStruct->ComPacket->LengthBE) + AddedSize) > CreateStruct->BufferSize) {
    138     DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    139     return (TcgResultFailureBufferTooSmall);
    140   }
    141 
    142   CreateStruct->CurPacket = (TCG_PACKET*)(CreateStruct->ComPacket->Payload + SwapBytes32(CreateStruct->ComPacket->LengthBE));
    143 
    144   CreateStruct->CurPacket->TperSessionNumberBE = SwapBytes32( Tsn );
    145   CreateStruct->CurPacket->HostSessionNumberBE = SwapBytes32( Hsn );
    146   CreateStruct->CurPacket->SequenceNumberBE = SwapBytes32( SeqNumber );
    147   CreateStruct->CurPacket->AckTypeBE = SwapBytes16( AckType );
    148   CreateStruct->CurPacket->AcknowledgementBE = SwapBytes32( Ack );
    149 
    150   CreateStruct->CurPacket->LengthBE = 0;
    151 
    152   // update TCG_COM_PACKET Length for next pointer
    153   CreateStruct->ComPacket->LengthBE = SwapBytes32( SwapBytes32(CreateStruct->ComPacket->LengthBE) + AddedSize );
    154 
    155   return (TcgResultSuccess);
    156 }
    157 
    158 /**
    159 
    160   Starts a new SubPacket in the Data structure.
    161 
    162   @param[in/out]    CreateStruct        Structure used to start Tcg SubPacket
    163   @param[in]        Kind                SubPacket kind
    164 
    165 **/
    166 TCG_RESULT
    167 EFIAPI
    168 TcgStartSubPacket(
    169   TCG_CREATE_STRUCT    *CreateStruct,
    170   UINT16               Kind
    171   )
    172 {
    173   UINT32 AddedSize;
    174 
    175   NULL_CHECK(CreateStruct);
    176 
    177   AddedSize = 0;
    178 
    179   if (CreateStruct->ComPacket == NULL ||
    180       CreateStruct->CurPacket == NULL ||
    181       CreateStruct->CurSubPacket != NULL
    182      ) {
    183     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    184     return (TcgResultFailureInvalidAction);
    185   }
    186 
    187   AddedSize = sizeof(TCG_SUB_PACKET);
    188 
    189   if ((SwapBytes32(CreateStruct->ComPacket->LengthBE) + AddedSize) > CreateStruct->BufferSize) {
    190     DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    191     return (TcgResultFailureBufferTooSmall);
    192   }
    193 
    194   CreateStruct->CurSubPacket = (TCG_SUB_PACKET*)(CreateStruct->CurPacket->Payload + SwapBytes32(CreateStruct->CurPacket->LengthBE));
    195   CreateStruct->CurSubPacket->KindBE = SwapBytes16(Kind);
    196 
    197   // update lengths
    198   CreateStruct->CurSubPacket->LengthBE = 0;
    199 
    200   // update TCG_COM_PACKET and packet lengths
    201   CreateStruct->ComPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->ComPacket->LengthBE) + AddedSize);
    202   CreateStruct->CurPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->CurPacket->LengthBE) + AddedSize);
    203 
    204   return (TcgResultSuccess);
    205 }
    206 
    207 /**
    208 
    209   Ends the current SubPacket in the Data structure.  This function will also perform the 4-byte padding
    210   required for Subpackets.
    211 
    212   @param[in/out]       CreateStruct        Structure used to end the current Tcg SubPacket
    213 
    214 **/
    215 TCG_RESULT
    216 EFIAPI
    217 TcgEndSubPacket(
    218   TCG_CREATE_STRUCT   *CreateStruct
    219   )
    220 {
    221   UINT32 PadSize;
    222 
    223   NULL_CHECK(CreateStruct);
    224 
    225   PadSize = 0;
    226 
    227   if (CreateStruct->ComPacket == NULL ||
    228       CreateStruct->CurPacket == NULL  ||
    229       CreateStruct->CurSubPacket == NULL
    230      ) {
    231     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    232     return (TcgResultFailureInvalidAction);
    233   }
    234 
    235   // align to 4-byte boundaries, so shift padding
    236   // pad Size does not apply to subpacket Length
    237   PadSize = TCG_SUBPACKET_ALIGNMENT - (SwapBytes32(CreateStruct->CurSubPacket->LengthBE) & (TCG_SUBPACKET_ALIGNMENT - 1));
    238 
    239   if (PadSize == TCG_SUBPACKET_ALIGNMENT) {
    240     PadSize = 0;
    241   }
    242 
    243   if ((SwapBytes32(CreateStruct->ComPacket->LengthBE) + PadSize) > CreateStruct->BufferSize) {
    244     DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    245     return (TcgResultFailureBufferTooSmall);
    246   }
    247 
    248   CreateStruct->CurPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->CurPacket->LengthBE) + PadSize);
    249   CreateStruct->ComPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->ComPacket->LengthBE) + PadSize);
    250 
    251   CreateStruct->CurSubPacket = NULL;
    252 
    253   return (TcgResultSuccess);
    254 }
    255 
    256 /**
    257 
    258   Ends the current Packet in the Data structure.
    259 
    260   @param[in/out]       CreateStruct        Structure used to end the current Tcg Packet
    261 
    262 **/
    263 TCG_RESULT
    264 EFIAPI
    265 TcgEndPacket(
    266   TCG_CREATE_STRUCT     *CreateStruct
    267   )
    268 {
    269   NULL_CHECK(CreateStruct);
    270 
    271   if (CreateStruct->ComPacket == NULL ||
    272       CreateStruct->CurPacket == NULL ||
    273       CreateStruct->CurSubPacket != NULL
    274      ) {
    275     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    276     return (TcgResultFailureInvalidAction);
    277   }
    278 
    279   CreateStruct->CurPacket = NULL;
    280 
    281   return (TcgResultSuccess);
    282 }
    283 
    284 /**
    285 
    286   Ends the ComPacket in the Data structure and ret
    287 
    288   @param [in/out]       CreateStruct       Structure used to end the Tcg ComPacket
    289   @param [in/out]       Size               Describes the Size of the entire ComPacket (Header and payload). Filled out by function.
    290 
    291 **/
    292 TCG_RESULT
    293 EFIAPI
    294 TcgEndComPacket(
    295   TCG_CREATE_STRUCT      *CreateStruct,
    296   UINT32                 *Size
    297   )
    298 {
    299   NULL_CHECK(CreateStruct);
    300   NULL_CHECK(Size);
    301 
    302   if (CreateStruct->ComPacket == NULL ||
    303       CreateStruct->CurPacket != NULL ||
    304       CreateStruct->CurSubPacket != NULL
    305      ) {
    306     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    307     return (TcgResultFailureInvalidAction);
    308   }
    309 
    310   *Size = SwapBytes32(CreateStruct->ComPacket->LengthBE) + sizeof(*CreateStruct->ComPacket);
    311   CreateStruct->ComPacket = NULL;
    312 
    313   return (TcgResultSuccess);
    314 }
    315 
    316 /**
    317   Adds raw Data with optional Header
    318 
    319   @param       CreateStruct       The create structure.
    320   @param       Header             The header structure.
    321   @param       HeaderSize         The header size.
    322   @param       Data               The data need to add.
    323   @param       DataSize           The data size.
    324   @param       ByteSwapData       Whether byte or swap data.
    325 
    326 **/
    327 TCG_RESULT
    328 TcgAddRawTokenData(
    329   TCG_CREATE_STRUCT      *CreateStruct,
    330   const VOID             *Header,
    331   UINT8                  HeaderSize,
    332   const VOID             *Data,
    333   UINT32                 DataSize,
    334   BOOLEAN                ByteSwapData
    335   )
    336 {
    337   UINT32 AddedSize;
    338   UINT8* Dest;
    339   const UINT8* DataBytes;
    340   UINT32 Index;
    341 
    342   AddedSize = 0;
    343   Index = 0;
    344   Dest = NULL;
    345 
    346   NULL_CHECK(CreateStruct);
    347 
    348   if ((HeaderSize != 0 && Header == NULL) ||
    349       (DataSize != 0 && Data == NULL)
    350      ) {
    351     DEBUG ((DEBUG_INFO, "HeaderSize=0x%X Header=%p DataSize=0x%X Data=%p\n", HeaderSize, Header, DataSize, Data));
    352     return (TcgResultFailureNullPointer);
    353   }
    354 
    355   if (CreateStruct->ComPacket == NULL ||
    356       CreateStruct->CurPacket == NULL ||
    357       CreateStruct->CurSubPacket == NULL
    358      ) {
    359     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    360     return (TcgResultFailureInvalidAction);
    361   }
    362 
    363   // verify there is enough Buffer Size
    364   AddedSize = HeaderSize + DataSize;
    365   if ((SwapBytes32(CreateStruct->ComPacket->LengthBE) + AddedSize) > CreateStruct->BufferSize) {
    366     return (TcgResultFailureBufferTooSmall);
    367   }
    368 
    369   // Get a pointer to where the new bytes should go
    370   Dest = CreateStruct->ComPacket->Payload + SwapBytes32(CreateStruct->ComPacket->LengthBE);
    371 
    372   switch (HeaderSize) {
    373     case sizeof(TCG_SIMPLE_TOKEN_SHORT_ATOM):
    374     case sizeof(TCG_SIMPLE_TOKEN_MEDIUM_ATOM):
    375     case sizeof(TCG_SIMPLE_TOKEN_LONG_ATOM):
    376       CopyMem(Dest, Header, HeaderSize);
    377       Dest += HeaderSize;
    378     case 0: // no Header is valid
    379       break;
    380     // invalid Header Size
    381     default:
    382       DEBUG ((DEBUG_INFO, "unsupported HeaderSize=%u\n", HeaderSize));
    383       return TcgResultFailure;
    384   }
    385 
    386   // copy the Data bytes
    387   if (ByteSwapData) {
    388     DataBytes = (const UINT8*)Data;
    389     for (Index = 0; Index < DataSize; Index++) {
    390       Dest[Index] = DataBytes[DataSize - 1 - Index];
    391     }
    392   } else {
    393     CopyMem(Dest, Data, DataSize);
    394   }
    395 
    396   // Update all the packet sizes
    397   CreateStruct->ComPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->ComPacket->LengthBE) + AddedSize);
    398   CreateStruct->CurPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->CurPacket->LengthBE) + AddedSize);
    399   CreateStruct->CurSubPacket->LengthBE = SwapBytes32(SwapBytes32(CreateStruct->CurSubPacket->LengthBE) + AddedSize);
    400 
    401   return (TcgResultSuccess);
    402 }
    403 
    404 /**
    405 
    406   Adds a single raw token byte to the Data structure.
    407 
    408   @param[in/out]   CreateStruct        Structure used to add the byte
    409   @param[in]       Byte                Byte to add
    410 
    411 **/
    412 TCG_RESULT
    413 EFIAPI
    414 TcgAddRawByte(
    415   TCG_CREATE_STRUCT     *CreateStruct,
    416   UINT8                 Byte
    417   )
    418 {
    419   return TcgAddRawTokenData(CreateStruct, NULL, 0, &Byte, 1, FALSE);
    420 }
    421 
    422 
    423 /**
    424    simple tokens - atoms: tiny, short, medium, long and empty atoms.
    425    tiny atom can be a signed or unsigned integer.
    426    short, medium, long can be a signed or unsigned integer OR a complete or non-final byte sequence.
    427 
    428   @param       CreateStruct       The create structure.
    429   @param       Data               The data need to add.
    430   @param       DataSize           The data size.
    431   @param       ByteOrInt,         Data format is byte or int.
    432   @param       SignOrCont         sign or cont.
    433 
    434 
    435 **/
    436 TCG_RESULT
    437 TcgAddAtom(
    438   TCG_CREATE_STRUCT   *CreateStruct,
    439   const VOID          *Data,
    440   UINT32              DataSize,
    441   UINT8               ByteOrInt,
    442   UINT8               SignOrCont
    443   )
    444 {
    445   const UINT8* DataBytes;
    446   TCG_SIMPLE_TOKEN_TINY_ATOM TinyAtom;
    447   TCG_SIMPLE_TOKEN_SHORT_ATOM ShortAtom;
    448   TCG_SIMPLE_TOKEN_MEDIUM_ATOM MediumAtom;
    449   TCG_SIMPLE_TOKEN_LONG_ATOM LongAtom;
    450 
    451   NULL_CHECK(CreateStruct);
    452 
    453   if (DataSize == 0) {
    454     if (ByteOrInt == TCG_ATOM_TYPE_INTEGER) {
    455       DEBUG ((DEBUG_INFO, "0-Size integer not allowed\n"));
    456       return TcgResultFailure;
    457     }
    458   } else {
    459     // if DataSize != 0, Data must be valid
    460     NULL_CHECK(Data);
    461   }
    462 
    463   // encode Data using the shortest possible atom
    464   DataBytes = (const UINT8*)Data;
    465   if ((DataSize == 1) &&
    466       (ByteOrInt == TCG_ATOM_TYPE_INTEGER) &&
    467       ((SignOrCont != 0 && ((TCG_TOKEN_TINYATOM_SIGNED_MIN_VALUE <= *(INT8*)Data) && (*(INT8*)Data <= TCG_TOKEN_TINYATOM_SIGNED_MAX_VALUE))) ||
    468        (SignOrCont == 0 && ((*DataBytes <= TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE))))
    469      ) {
    470     TinyAtom.TinyAtomBits.IsZero = 0;
    471     TinyAtom.TinyAtomBits.Sign = SignOrCont;
    472     TinyAtom.TinyAtomBits.Data = *DataBytes & TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE;
    473     return TcgAddRawTokenData(CreateStruct, NULL, 0, (UINT8*)&TinyAtom, sizeof(TCG_SIMPLE_TOKEN_TINY_ATOM), FALSE);
    474   }
    475 
    476   if (DataSize <= TCG_TOKEN_SHORTATOM_MAX_BYTE_SIZE) {
    477     ShortAtom.ShortAtomBits.IsOne = 1;
    478     ShortAtom.ShortAtomBits.IsZero = 0;
    479     ShortAtom.ShortAtomBits.ByteOrInt = ByteOrInt;
    480     ShortAtom.ShortAtomBits.SignOrCont = SignOrCont;
    481     ShortAtom.ShortAtomBits.Length = DataSize & 0x0F;
    482     return TcgAddRawTokenData(CreateStruct, &ShortAtom, sizeof(TCG_SIMPLE_TOKEN_SHORT_ATOM), Data, DataSize, ByteOrInt == TCG_ATOM_TYPE_INTEGER);
    483   }
    484 
    485   if (DataSize <= TCG_TOKEN_MEDIUMATOM_MAX_BYTE_SIZE) {
    486     MediumAtom.MediumAtomBits.IsOne1 = 1;
    487     MediumAtom.MediumAtomBits.IsOne2 = 1;
    488     MediumAtom.MediumAtomBits.IsZero = 0;
    489     MediumAtom.MediumAtomBits.ByteOrInt = ByteOrInt;
    490     MediumAtom.MediumAtomBits.SignOrCont = SignOrCont;
    491     MediumAtom.MediumAtomBits.LengthLow = DataSize & 0xFF;
    492     MediumAtom.MediumAtomBits.LengthHigh = (DataSize >> TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT) & TCG_MEDIUM_ATOM_LENGTH_HIGH_MASK;
    493     return TcgAddRawTokenData(CreateStruct, &MediumAtom, sizeof(TCG_SIMPLE_TOKEN_MEDIUM_ATOM), Data, DataSize, ByteOrInt == TCG_ATOM_TYPE_INTEGER);
    494   }
    495 
    496   LongAtom.LongAtomBits.IsOne1 = 1;
    497   LongAtom.LongAtomBits.IsOne2 = 1;
    498   LongAtom.LongAtomBits.IsOne3 = 1;
    499   LongAtom.LongAtomBits.IsZero = 0;
    500   LongAtom.LongAtomBits.ByteOrInt = ByteOrInt;
    501   LongAtom.LongAtomBits.SignOrCont = SignOrCont;
    502   LongAtom.LongAtomBits.LengthLow = DataSize & 0xFF;
    503   LongAtom.LongAtomBits.LengthMid = (DataSize >> TCG_LONG_ATOM_LENGTH_MID_SHIFT) & 0xFF;
    504   LongAtom.LongAtomBits.LengthHigh = (DataSize >> TCG_LONG_ATOM_LENGTH_HIGH_SHIFT) & 0xFF;
    505   return TcgAddRawTokenData(CreateStruct, &LongAtom, sizeof(TCG_SIMPLE_TOKEN_LONG_ATOM), Data, DataSize, ByteOrInt == TCG_ATOM_TYPE_INTEGER);
    506 }
    507 
    508 /**
    509 
    510   Adds the Data parameter as a byte sequence to the Data structure.
    511 
    512   @param[in/out]    CreateStruct      Structure used to add the byte sequence
    513   @param[in]        Data              Byte sequence that will be encoded and copied into Data structure
    514   @param[in]        DataSize          Length of Data provided
    515   @param[in]        Continued         TRUE if byte sequence is continued or
    516                                       FALSE if the Data contains the entire byte sequence to be encoded
    517 
    518 **/
    519 TCG_RESULT
    520 EFIAPI
    521 TcgAddByteSequence(
    522   TCG_CREATE_STRUCT     *CreateStruct,
    523   const VOID            *Data,
    524   UINT32                DataSize,
    525   BOOLEAN               Continued
    526   )
    527 {
    528   return TcgAddAtom(CreateStruct, Data, DataSize, TCG_ATOM_TYPE_BYTE, Continued ? 1 : 0);
    529 }
    530 
    531 /**
    532 
    533   Adds an arbitrary-Length integer to the Data structure.
    534   The integer will be encoded using the shortest possible atom.
    535 
    536   @param[in/out]     CreateStruct      Structure used to add the integer
    537   @param[in]         Data              Integer in host byte order that will be encoded and copied into Data structure
    538   @param[in]         DataSize          Length in bytes of the Data provided
    539   @param[in]         SignedInteger     TRUE if the integer is signed or FALSE if the integer is unsigned
    540 
    541 **/
    542 TCG_RESULT
    543 EFIAPI
    544 TcgAddInteger(
    545   TCG_CREATE_STRUCT  *CreateStruct,
    546   const VOID         *Data,
    547   UINT32             DataSize,
    548   BOOLEAN            SignedInteger
    549   )
    550 {
    551   const UINT8* DataBytes;
    552   UINT32 ActualDataSize;
    553   BOOLEAN ValueIsNegative;
    554 
    555   NULL_CHECK(CreateStruct);
    556   NULL_CHECK(Data);
    557 
    558   if (DataSize == 0) {
    559     DEBUG ((DEBUG_INFO, "invalid DataSize=0\n"));
    560     return TcgResultFailure;
    561   }
    562 
    563   DataBytes = (const UINT8*)Data;
    564 
    565   // integer should be represented by smallest atom possible
    566   // so calculate real Data Size
    567   ValueIsNegative = SignedInteger && DataBytes[ DataSize - 1 ] & 0x80;
    568 
    569   // assumes native Data is little endian
    570   // shorten Data to smallest byte representation
    571   for (ActualDataSize = DataSize; ActualDataSize > 1; ActualDataSize--) {
    572     // ignore sign extended  FFs
    573     if (ValueIsNegative && (DataBytes[ActualDataSize - 1] != 0xFF)) {
    574       break;
    575     } else if (!ValueIsNegative && (DataBytes[ActualDataSize - 1] != 0)) {
    576       // ignore extended 00s
    577       break;
    578     }
    579   }
    580 
    581   return TcgAddAtom(CreateStruct, Data, ActualDataSize, TCG_ATOM_TYPE_INTEGER, SignedInteger ? 1 : 0);
    582 }
    583 
    584 /**
    585   Adds an 8-bit unsigned integer to the Data structure.
    586 
    587   @param[in/out]       CreateStruct        Structure used to add the integer
    588   @param[in]           Value               Integer Value to add
    589 
    590 **/
    591 TCG_RESULT
    592 EFIAPI
    593 TcgAddUINT8(
    594   TCG_CREATE_STRUCT   *CreateStruct,
    595   UINT8               Value
    596   )
    597 {
    598   return TcgAddInteger(CreateStruct, &Value, sizeof(Value), FALSE);
    599 }
    600 
    601 /**
    602 
    603   Adds a 16-bit unsigned integer to the Data structure.
    604 
    605   @param[in/out]       CreateStruct        Structure used to add the integer
    606   @param[in]           Value               Integer Value to add
    607 
    608 **/
    609 TCG_RESULT
    610 EFIAPI
    611 TcgAddUINT16 (
    612   TCG_CREATE_STRUCT   *CreateStruct,
    613   UINT16              Value
    614   )
    615 {
    616   return TcgAddInteger(CreateStruct, &Value, sizeof(Value), FALSE);
    617 }
    618 
    619 /**
    620 
    621   Adds a 32-bit unsigned integer to the Data structure.
    622 
    623   @param[in/out]        CreateStruct        Structure used to add the integer
    624   @param[in]            Value               Integer Value to add
    625 
    626 **/
    627 TCG_RESULT
    628 EFIAPI
    629 TcgAddUINT32(
    630   TCG_CREATE_STRUCT    *CreateStruct,
    631   UINT32               Value
    632   )
    633 {
    634   return TcgAddInteger(CreateStruct, &Value, sizeof(Value), FALSE);
    635 }
    636 
    637 
    638 /**
    639 
    640   Adds a 64-bit unsigned integer to the Data structure.
    641 
    642   @param[in/out]      CreateStruct        Structure used to add the integer
    643   @param[in]          Value               Integer Value to add
    644 
    645 **/
    646 TCG_RESULT
    647 EFIAPI
    648 TcgAddUINT64(
    649   TCG_CREATE_STRUCT   *CreateStruct,
    650   UINT64              Value
    651   )
    652 {
    653   return TcgAddInteger(CreateStruct, &Value, sizeof(Value), FALSE);
    654 }
    655 
    656 /**
    657   Adds a BOOLEAN to the Data structure.
    658 
    659   @param[in/out]       CreateStruct     Structure used to add the integer
    660   @param[in]           Value              BOOLEAN Value to add
    661 
    662 **/
    663 TCG_RESULT
    664 EFIAPI
    665 TcgAddBOOLEAN(
    666   TCG_CREATE_STRUCT    *CreateStruct,
    667   BOOLEAN              Value
    668   )
    669 {
    670   return TcgAddInteger(CreateStruct, &Value, sizeof(Value), FALSE);
    671 }
    672 
    673 /**
    674   Add tcg uid info.
    675 
    676   @param [in/out]       CreateStruct       Structure used to add the integer
    677   @param                Uid                Input uid info.
    678 
    679   @retval   return the action result.
    680 
    681 **/
    682 TCG_RESULT
    683 EFIAPI
    684 TcgAddTcgUid(
    685   TCG_CREATE_STRUCT   *CreateStruct,
    686   TCG_UID             Uid
    687   )
    688 {
    689   return TcgAddByteSequence(CreateStruct, &Uid, sizeof(TCG_UID), FALSE);
    690 }
    691 
    692 /**
    693   Add start list.
    694 
    695   @param [in/out]       CreateStruct       Structure used to add the integer
    696 
    697   @retval   return the action result.
    698 
    699 **/
    700 TCG_RESULT
    701 EFIAPI
    702 TcgAddStartList(
    703   TCG_CREATE_STRUCT          *CreateStruct
    704   )
    705 {
    706   return TcgAddRawByte(CreateStruct, TCG_TOKEN_STARTLIST);
    707 }
    708 
    709 /**
    710   Add end list.
    711 
    712   @param [in/out]       CreateStruct       Structure used to add the integer
    713 
    714   @retval   return the action result.
    715 
    716 **/
    717 TCG_RESULT
    718 EFIAPI
    719 TcgAddEndList(
    720   TCG_CREATE_STRUCT       *CreateStruct
    721   )
    722 {
    723   return TcgAddRawByte(CreateStruct, TCG_TOKEN_ENDLIST);
    724 }
    725 
    726 /**
    727   Add start name.
    728 
    729   @param [in/out]       CreateStruct       Structure used to add the integer
    730 
    731   @retval   return the action result.
    732 
    733 **/
    734 TCG_RESULT
    735 EFIAPI
    736 TcgAddStartName(
    737   TCG_CREATE_STRUCT          *CreateStruct
    738   )
    739 {
    740   return TcgAddRawByte(CreateStruct, TCG_TOKEN_STARTNAME);
    741 }
    742 
    743 /**
    744   Add end name.
    745 
    746   @param [in/out]       CreateStruct       Structure used to add the integer
    747 
    748   @retval   return the action result.
    749 
    750 **/
    751 TCG_RESULT
    752 EFIAPI
    753 TcgAddEndName(
    754   TCG_CREATE_STRUCT          *CreateStruct
    755   )
    756 {
    757   return TcgAddRawByte(CreateStruct, TCG_TOKEN_ENDNAME);
    758 }
    759 
    760 /**
    761   Add end call.
    762 
    763   @param [in/out]       CreateStruct       Structure used to add the integer
    764 
    765   @retval   return the action result.
    766 
    767 **/
    768 TCG_RESULT
    769 EFIAPI
    770 TcgAddCall(
    771   TCG_CREATE_STRUCT      *CreateStruct
    772   )
    773 {
    774   return TcgAddRawByte(CreateStruct, TCG_TOKEN_CALL);
    775 }
    776 
    777 /**
    778   Add end of data.
    779 
    780   @param [in/out]       CreateStruct       Structure used to add the integer
    781 
    782   @retval   return the action result.
    783 
    784 **/
    785 TCG_RESULT
    786 EFIAPI
    787 TcgAddEndOfData(
    788   TCG_CREATE_STRUCT          *CreateStruct
    789   )
    790 {
    791   return TcgAddRawByte(CreateStruct, TCG_TOKEN_ENDDATA);
    792 }
    793 
    794 /**
    795   Add end of session.
    796 
    797   @param [in/out]       CreateStruct       Structure used to add the integer
    798 
    799   @retval   return the action result.
    800 
    801 **/
    802 TCG_RESULT
    803 EFIAPI
    804 TcgAddEndOfSession(
    805   TCG_CREATE_STRUCT              *CreateStruct
    806   )
    807 {
    808   return TcgAddRawByte(CreateStruct, TCG_TOKEN_ENDSESSION);
    809 }
    810 
    811 /**
    812   Add start transaction.
    813 
    814   @param [in/out]       CreateStruct       Structure used to add the integer
    815 
    816   @retval   return the action result.
    817 
    818 **/
    819 TCG_RESULT
    820 EFIAPI
    821 TcgAddStartTransaction(
    822   TCG_CREATE_STRUCT             *CreateStruct
    823   )
    824 {
    825   return TcgAddRawByte(CreateStruct, TCG_TOKEN_STARTTRANSACTION);
    826 }
    827 
    828 /**
    829   Add end transaction.
    830 
    831   @param [in/out]       CreateStruct       Structure used to add the integer
    832 
    833   @retval   return the action result.
    834 
    835 **/
    836 TCG_RESULT
    837 EFIAPI
    838 TcgAddEndTransaction(
    839   TCG_CREATE_STRUCT           *CreateStruct
    840   )
    841 {
    842   return TcgAddRawByte(CreateStruct, TCG_TOKEN_ENDTRANSACTION);
    843 }
    844 
    845 /**
    846   Initial the tcg parse stucture.
    847 
    848   @param    ParseStruct    Input parse structure.
    849   @param    Buffer         Input buffer data.
    850   @param    BufferSize     Input buffer size.
    851 
    852   @retval   return the action result.
    853 
    854 **/
    855 TCG_RESULT
    856 EFIAPI
    857 TcgInitTcgParseStruct(
    858   TCG_PARSE_STRUCT          *ParseStruct,
    859   const VOID                *Buffer,
    860   UINT32                    BufferSize
    861   )
    862 {
    863   UINT32 ComPacketLength;
    864   UINT32 PacketLength;
    865 
    866   NULL_CHECK(ParseStruct);
    867   NULL_CHECK(Buffer);
    868 
    869   if (BufferSize < sizeof(TCG_COM_PACKET)) {
    870     return (TcgResultFailureBufferTooSmall);
    871   }
    872 
    873   ParseStruct->ComPacket = (TCG_COM_PACKET*)Buffer;
    874 
    875   ComPacketLength = SwapBytes32(ParseStruct->ComPacket->LengthBE);
    876 
    877   if ((BufferSize - sizeof(TCG_COM_PACKET)) < ComPacketLength) {
    878     DEBUG ((DEBUG_INFO, "Buffer %u too small for ComPacket %u\n", BufferSize, ComPacketLength));
    879     return (TcgResultFailureBufferTooSmall);
    880   }
    881 
    882   ParseStruct->BufferSize = BufferSize;
    883   ParseStruct->Buffer = Buffer;
    884 
    885   ParseStruct->CurPacket = NULL;
    886   ParseStruct->CurSubPacket = NULL;
    887   ParseStruct->CurPtr = NULL;
    888 
    889   // if payload > 0, then must have a packet
    890   if (ComPacketLength != 0) {
    891     if (ComPacketLength < sizeof(TCG_PACKET)) {
    892       DEBUG ((DEBUG_INFO, "ComPacket too small for Packet\n"));
    893       return (TcgResultFailureBufferTooSmall);
    894     }
    895     ParseStruct->CurPacket = (TCG_PACKET*)ParseStruct->ComPacket->Payload;
    896 
    897     PacketLength = SwapBytes32(ParseStruct->CurPacket->LengthBE);
    898 
    899     if (PacketLength > 0) {
    900       if (PacketLength < sizeof(TCG_SUB_PACKET)) {
    901           DEBUG ((DEBUG_INFO, "Packet too small for SubPacket\n"));
    902           return (TcgResultFailureBufferTooSmall);
    903       }
    904 
    905       ParseStruct->CurSubPacket = (TCG_SUB_PACKET*)ParseStruct->CurPacket->Payload;
    906     }
    907   }
    908 
    909   //TODO should check for method status list at this point?
    910 
    911   return (TcgResultSuccess);
    912 }
    913 
    914 /**
    915   Get next token info.
    916 
    917   @param    ParseStruct      Input parse structure info.
    918   @param    TcgToken         return the tcg token info.
    919 
    920   @retval   return the action result.
    921 
    922 **/
    923 TCG_RESULT
    924 EFIAPI
    925 TcgGetNextToken(
    926   TCG_PARSE_STRUCT      *ParseStruct,
    927   TCG_TOKEN             *TcgToken
    928   )
    929 {
    930   const UINT8* EndOfSubPacket;
    931   UINT8* TokenEnd;
    932   UINT8 Hdr;
    933   TCG_SIMPLE_TOKEN_SHORT_ATOM* TmpShort;
    934   const TCG_SIMPLE_TOKEN_MEDIUM_ATOM* TmpMed;
    935   const TCG_SIMPLE_TOKEN_LONG_ATOM* TmpLong;
    936 
    937   NULL_CHECK(ParseStruct);
    938   NULL_CHECK(TcgToken);
    939 
    940   if (ParseStruct->ComPacket == NULL ||
    941       ParseStruct->CurPacket == NULL ||
    942       ParseStruct->CurSubPacket == NULL
    943      ) {
    944     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", ParseStruct->ComPacket, ParseStruct->CurPacket, ParseStruct->CurSubPacket));
    945     return TcgResultFailureInvalidAction;
    946   }
    947 
    948   // initial call, start at sub packet
    949   if (ParseStruct->CurPtr == NULL) {
    950     ParseStruct->CurPtr = ParseStruct->CurSubPacket->Payload;
    951   }
    952 
    953   EndOfSubPacket = ParseStruct->CurSubPacket->Payload + SwapBytes32(ParseStruct->CurSubPacket->LengthBE);
    954   TokenEnd = NULL;
    955 
    956   // confirmed that subpacket Length falls within end of Buffer and TCG_COM_PACKET,
    957   // so simply need to verify the loop stays within current subpacket
    958   if (ParseStruct->CurPtr >= EndOfSubPacket) {
    959     DEBUG ((DEBUG_INFO, "ParseStruct->CurPtr >= EndOfSubPacket\n"));
    960     return (TcgResultFailureEndBuffer);
    961   }
    962 
    963   Hdr = *ParseStruct->CurPtr;
    964   TcgToken->HdrStart = ParseStruct->CurPtr;
    965 
    966   // Tiny Atom range
    967   if (Hdr <= 0x7F) {
    968     // tiny atom Header is only 1 byte, so don't need to verify Size before cast and access
    969     TcgToken->Type = TcgTokenTypeTinyAtom;
    970 
    971     TokenEnd = TcgToken->HdrStart + sizeof(TCG_SIMPLE_TOKEN_TINY_ATOM);
    972 
    973     // verify caller will have enough Size to reference token
    974     if (TokenEnd >= EndOfSubPacket) {
    975       DEBUG ((DEBUG_INFO, "Tiny Atom TokenEnd >= EndOfSubPacket\n"));
    976       return (TcgResultFailureEndBuffer);
    977     }
    978   }
    979   // Short Atom Range
    980   else if (0x80 <= Hdr && Hdr <= 0xBF) {
    981     // short atom Header is only 1 byte, so don't need to verify Size before cast and access
    982     TmpShort = (TCG_SIMPLE_TOKEN_SHORT_ATOM*)(ParseStruct->CurPtr);
    983     TcgToken->Type = TcgTokenTypeShortAtom;
    984 
    985     TokenEnd = (TcgToken->HdrStart + sizeof(TCG_SIMPLE_TOKEN_SHORT_ATOM) + TmpShort->ShortAtomBits.Length);
    986 
    987     // verify caller will have enough Size to reference token
    988     if (TokenEnd >= EndOfSubPacket) {
    989       DEBUG ((DEBUG_INFO, "Short Atom TokenEnd >= EndOfSubPacket\n"));
    990       return (TcgResultFailureEndBuffer);
    991     }
    992   }
    993   // Medium Atom Range
    994   else if (0xC0 <= Hdr && Hdr <= 0xDF) {
    995     if (TcgToken->HdrStart + sizeof(TCG_SIMPLE_TOKEN_MEDIUM_ATOM) >= EndOfSubPacket) {
    996       return (TcgResultFailureEndBuffer);
    997     }
    998     TmpMed = (const TCG_SIMPLE_TOKEN_MEDIUM_ATOM*)ParseStruct->CurPtr;
    999     TcgToken->Type = TcgTokenTypeMediumAtom;
   1000     TokenEnd = TcgToken->HdrStart + sizeof(TCG_SIMPLE_TOKEN_MEDIUM_ATOM) +
   1001                ((TmpMed->MediumAtomBits.LengthHigh << TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT) |
   1002                 TmpMed->MediumAtomBits.LengthLow);
   1003 
   1004     // verify caller will have enough Size to reference token
   1005     if (TokenEnd >= EndOfSubPacket) {
   1006       DEBUG ((DEBUG_INFO, "Medium Atom TokenEnd >= EndOfSubPacket\n"));
   1007       return (TcgResultFailureEndBuffer);
   1008     }
   1009   }
   1010   // Long Atom Range
   1011   else if (0xE0 <= Hdr && Hdr <= 0xE3) {
   1012     if (TcgToken->HdrStart + sizeof(TCG_SIMPLE_TOKEN_LONG_ATOM) >= EndOfSubPacket) {
   1013       return (TcgResultFailureEndBuffer);
   1014     }
   1015     TmpLong = (const TCG_SIMPLE_TOKEN_LONG_ATOM*)ParseStruct->CurPtr;
   1016     TcgToken->Type = TcgTokenTypeLongAtom;
   1017 
   1018     TokenEnd = TcgToken->HdrStart + sizeof(TCG_SIMPLE_TOKEN_LONG_ATOM) +
   1019                ((TmpLong->LongAtomBits.LengthHigh << TCG_LONG_ATOM_LENGTH_HIGH_SHIFT) |
   1020                 (TmpLong->LongAtomBits.LengthMid << TCG_LONG_ATOM_LENGTH_MID_SHIFT)   |
   1021                 TmpLong->LongAtomBits.LengthLow);
   1022 
   1023     // verify caller will have enough Size to reference token
   1024     if (TokenEnd >= EndOfSubPacket) {
   1025       DEBUG ((DEBUG_INFO, "Long Atom TokenEnd >= EndOfSubPacket\n"));
   1026       return (TcgResultFailureEndBuffer);
   1027     }
   1028   } else {
   1029     // single byte tokens
   1030     switch (Hdr) {
   1031       case TCG_TOKEN_STARTLIST:
   1032           TcgToken->Type = TcgTokenTypeStartList;
   1033           break;
   1034       case TCG_TOKEN_ENDLIST:
   1035           TcgToken->Type = TcgTokenTypeEndList;
   1036           break;
   1037       case TCG_TOKEN_STARTNAME:
   1038           TcgToken->Type = TcgTokenTypeStartName;
   1039           break;
   1040       case TCG_TOKEN_ENDNAME:
   1041           TcgToken->Type = TcgTokenTypeEndName;
   1042           break;
   1043       case TCG_TOKEN_CALL:
   1044           TcgToken->Type = TcgTokenTypeCall;
   1045           break;
   1046       case TCG_TOKEN_ENDDATA:
   1047           TcgToken->Type = TcgTokenTypeEndOfData;
   1048           break;
   1049       case TCG_TOKEN_ENDSESSION:
   1050           TcgToken->Type = TcgTokenTypeEndOfSession;
   1051           break;
   1052       case TCG_TOKEN_STARTTRANSACTION:
   1053           TcgToken->Type = TcgTokenTypeStartTransaction;
   1054           break;
   1055       case TCG_TOKEN_ENDTRANSACTION:
   1056           TcgToken->Type = TcgTokenTypeEndTransaction;
   1057           break;
   1058       case TCG_TOKEN_EMPTY:
   1059           TcgToken->Type = TcgTokenTypeEmptyAtom;
   1060           break;
   1061       default:
   1062           DEBUG ((DEBUG_INFO, "WARNING: reserved token Type 0x%02X\n", Hdr));
   1063           TcgToken->Type = TcgTokenTypeReserved;
   1064           break;
   1065     }
   1066     ParseStruct->CurPtr++;
   1067     TokenEnd = TcgToken->HdrStart + 1;
   1068   }
   1069 
   1070   // increment curptr for next call
   1071   ParseStruct->CurPtr = TokenEnd;
   1072   return (TcgResultSuccess);
   1073 }
   1074 
   1075 /**
   1076   Get atom info.
   1077 
   1078   @param    TcgToken          Input token info.
   1079   @param    HeaderLength      return the header length.
   1080   @param    DataLength        return the data length.
   1081   @param    ByteOrInt         return the atom Type.
   1082   @param    SignOrCont        return the sign or count info.
   1083 
   1084   @retval   return the action result.
   1085 
   1086 **/
   1087 TCG_RESULT
   1088 EFIAPI
   1089 TcgGetAtomInfo(
   1090   const TCG_TOKEN      *TcgToken,
   1091   UINT32               *HeaderLength,
   1092   UINT32               *DataLength,
   1093   UINT8                *ByteOrInt,
   1094   UINT8                *SignOrCont
   1095   )
   1096 {
   1097   TCG_SIMPLE_TOKEN_TINY_ATOM* TinyAtom;
   1098   TCG_SIMPLE_TOKEN_SHORT_ATOM* ShortAtom;
   1099   TCG_SIMPLE_TOKEN_MEDIUM_ATOM* MediumAtom;
   1100   TCG_SIMPLE_TOKEN_LONG_ATOM* LongAtom;
   1101 
   1102   NULL_CHECK(TcgToken);
   1103   NULL_CHECK(HeaderLength);
   1104   NULL_CHECK(DataLength);
   1105   NULL_CHECK(ByteOrInt);
   1106   NULL_CHECK(SignOrCont);
   1107 
   1108   switch (TcgToken->Type) {
   1109     case TcgTokenTypeTinyAtom: {
   1110       TinyAtom = (TCG_SIMPLE_TOKEN_TINY_ATOM*)TcgToken->HdrStart;
   1111       *ByteOrInt      = TCG_ATOM_TYPE_INTEGER;
   1112       *SignOrCont     = TinyAtom->TinyAtomBits.Sign;
   1113       *HeaderLength   = 0;
   1114       *DataLength     = 0; // tiny atom must be handled as a special case - Header and Data in the same byte
   1115       return TcgResultSuccess;
   1116     }
   1117 
   1118     case TcgTokenTypeShortAtom: {
   1119       ShortAtom = (TCG_SIMPLE_TOKEN_SHORT_ATOM*)TcgToken->HdrStart;
   1120       *ByteOrInt      = ShortAtom->ShortAtomBits.ByteOrInt;
   1121       *SignOrCont     = ShortAtom->ShortAtomBits.SignOrCont;
   1122       *HeaderLength   = sizeof(TCG_SIMPLE_TOKEN_SHORT_ATOM);
   1123       *DataLength     = ShortAtom->ShortAtomBits.Length;
   1124       return TcgResultSuccess;
   1125     }
   1126 
   1127     case TcgTokenTypeMediumAtom: {
   1128       MediumAtom = (TCG_SIMPLE_TOKEN_MEDIUM_ATOM*)TcgToken->HdrStart;
   1129       *ByteOrInt      = MediumAtom->MediumAtomBits.ByteOrInt;
   1130       *SignOrCont     = MediumAtom->MediumAtomBits.SignOrCont;
   1131       *HeaderLength   = sizeof(TCG_SIMPLE_TOKEN_MEDIUM_ATOM);
   1132       *DataLength     = (MediumAtom->MediumAtomBits.LengthHigh << TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT) | MediumAtom->MediumAtomBits.LengthLow;
   1133       return TcgResultSuccess;
   1134     }
   1135 
   1136     case TcgTokenTypeLongAtom: {
   1137       LongAtom = (TCG_SIMPLE_TOKEN_LONG_ATOM*)TcgToken->HdrStart;
   1138       *ByteOrInt      = LongAtom->LongAtomBits.ByteOrInt;
   1139       *SignOrCont     = LongAtom->LongAtomBits.SignOrCont;
   1140       *HeaderLength   = sizeof(TCG_SIMPLE_TOKEN_LONG_ATOM);
   1141       *DataLength     = (LongAtom->LongAtomBits.LengthHigh << TCG_LONG_ATOM_LENGTH_HIGH_SHIFT) |
   1142                         (LongAtom->LongAtomBits.LengthMid << TCG_LONG_ATOM_LENGTH_MID_SHIFT) |
   1143                         LongAtom->LongAtomBits.LengthLow;
   1144       return TcgResultSuccess;
   1145     }
   1146 
   1147     default:
   1148       DEBUG ((DEBUG_INFO, "Token Type is not simple atom (%d)\n", TcgToken->Type));
   1149       return (TcgResultFailureInvalidType);
   1150   }
   1151 }
   1152 
   1153 /**
   1154   Get token specified value.
   1155 
   1156   @param    TcgToken   Input token info.
   1157   @param    Value      return the value.
   1158 
   1159   @retval   return the action result.
   1160 
   1161 **/
   1162 TCG_RESULT
   1163 EFIAPI
   1164 TcgGetTokenUINT64(
   1165   const TCG_TOKEN      *TcgToken,
   1166   UINT64               *Value
   1167   )
   1168 {
   1169   UINT32 HdrLength;
   1170   UINT32 DataLength;
   1171   UINT8 ByteOrInt;
   1172   UINT8 IsSigned;
   1173   TCG_SIMPLE_TOKEN_TINY_ATOM* TmpTiny;
   1174   const UINT8* Data;
   1175   UINT32 Index;
   1176 
   1177   NULL_CHECK(TcgToken);
   1178   NULL_CHECK(Value);
   1179 
   1180   Index = 0;
   1181   *Value = 0;
   1182   ERROR_CHECK(TcgGetAtomInfo(TcgToken, &HdrLength, &DataLength, &ByteOrInt, &IsSigned));
   1183 
   1184   if (ByteOrInt != TCG_ATOM_TYPE_INTEGER) {
   1185     DEBUG ((DEBUG_INFO, "Invalid Type, expected integer not byte sequence\n"));
   1186     return TcgResultFailureInvalidType;
   1187   }
   1188 
   1189   if (IsSigned != 0) {
   1190     DEBUG ((DEBUG_INFO, "Integer is signed, expected unsigned\n"));
   1191     return TcgResultFailureInvalidType;
   1192   }
   1193 
   1194   // special case for tiny atom
   1195   // Header and Data are in one byte, so extract only the Data bitfield
   1196   if (TcgToken->Type == TcgTokenTypeTinyAtom) {
   1197     TmpTiny = (TCG_SIMPLE_TOKEN_TINY_ATOM*)TcgToken->HdrStart;
   1198     *Value = TmpTiny->TinyAtomBits.Data;
   1199     return TcgResultSuccess;
   1200   }
   1201 
   1202   if (DataLength > sizeof(UINT64)) {
   1203     DEBUG ((DEBUG_INFO, "Length %d is greater than Size of UINT64\n", DataLength));
   1204     return TcgResultFailureBufferTooSmall;
   1205   }
   1206 
   1207   // read big-endian integer
   1208   Data = TcgToken->HdrStart + HdrLength;
   1209   for (Index = 0; Index < DataLength; Index++) {
   1210     *Value = LShiftU64(*Value, 8) | Data[Index];
   1211   }
   1212 
   1213   return TcgResultSuccess;
   1214 }
   1215 
   1216 /**
   1217   Get token byte sequence.
   1218 
   1219   @param    TcgToken   Input token info.
   1220   @param    Length     Input the length info.
   1221 
   1222   @retval   Return the value data.
   1223 
   1224 **/
   1225 UINT8*
   1226 EFIAPI
   1227 TcgGetTokenByteSequence(
   1228   const TCG_TOKEN     *TcgToken,
   1229   UINT32              *Length
   1230   )
   1231 {
   1232   UINT32 HdrLength;
   1233   UINT8 ByteOrInt;
   1234   UINT8 SignOrCont;
   1235 
   1236   if (TcgToken == NULL || Length == NULL) {
   1237     return NULL;
   1238   }
   1239 
   1240   *Length = 0;
   1241   if (TcgGetAtomInfo(TcgToken, &HdrLength, Length, &ByteOrInt, &SignOrCont) != TcgResultSuccess) {
   1242     DEBUG ((DEBUG_INFO, "Failed to get simple token info\n"));
   1243     return NULL;
   1244   }
   1245 
   1246   if (ByteOrInt != TCG_ATOM_TYPE_BYTE) {
   1247     DEBUG ((DEBUG_INFO, "Invalid Type, expected byte sequence not integer\n"));
   1248     return NULL;
   1249   }
   1250 
   1251   return (TcgToken->HdrStart + HdrLength);
   1252 }
   1253 
   1254 /**
   1255   Get next specify value.
   1256 
   1257   @param    ParseStruct   Input parse structure.
   1258   @param    Value         Return vlaue.
   1259 
   1260   @retval   return the action result.
   1261 
   1262 **/
   1263 TCG_RESULT
   1264 EFIAPI
   1265 TcgGetNextUINT8(
   1266   TCG_PARSE_STRUCT      *ParseStruct,
   1267   UINT8                 *Value
   1268   )
   1269 {
   1270   UINT64 Value64;
   1271   TCG_TOKEN Tok;
   1272 
   1273   NULL_CHECK(Value);
   1274 
   1275   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1276   ERROR_CHECK(TcgGetTokenUINT64(&Tok, &Value64));
   1277 
   1278   if (Value64 > MAX_UINT8) {
   1279     return TcgResultFailure;
   1280   }
   1281 
   1282   *Value = (UINT8)Value64;
   1283 
   1284   return TcgResultSuccess;
   1285 }
   1286 
   1287 /**
   1288   Get next specify value.
   1289 
   1290   @param    ParseStruct   Input parse structure.
   1291   @param    Value         Return vlaue.
   1292 
   1293   @retval   return the action result.
   1294 
   1295 **/
   1296 TCG_RESULT
   1297 EFIAPI
   1298 TcgGetNextUINT16(
   1299   TCG_PARSE_STRUCT     *ParseStruct,
   1300   UINT16               *Value
   1301   )
   1302 {
   1303   UINT64 Value64;
   1304   TCG_TOKEN Tok;
   1305 
   1306   NULL_CHECK(Value);
   1307 
   1308   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1309   ERROR_CHECK(TcgGetTokenUINT64(&Tok, &Value64));
   1310 
   1311   if (Value64 > MAX_UINT16) {
   1312     return TcgResultFailure;
   1313   }
   1314 
   1315   *Value = (UINT16)Value64;
   1316 
   1317   return TcgResultSuccess;
   1318 }
   1319 
   1320 /**
   1321   Get next specify value.
   1322 
   1323   @param    ParseStruct   Input parse structure.
   1324   @param    Value         Return vlaue.
   1325 
   1326   @retval   return the action result.
   1327 
   1328 **/
   1329 TCG_RESULT
   1330 EFIAPI
   1331 TcgGetNextUINT32(
   1332   TCG_PARSE_STRUCT          *ParseStruct,
   1333   UINT32                    *Value
   1334   )
   1335 {
   1336   UINT64 Value64;
   1337   TCG_TOKEN Tok;
   1338 
   1339   NULL_CHECK(Value);
   1340 
   1341   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1342   ERROR_CHECK(TcgGetTokenUINT64(&Tok, &Value64));
   1343 
   1344   if (Value64 > MAX_UINT32) {
   1345     return TcgResultFailure;
   1346   }
   1347 
   1348   *Value = (UINT32)Value64;
   1349 
   1350   return TcgResultSuccess;
   1351 }
   1352 
   1353 /**
   1354   Get next specify value.
   1355 
   1356   @param    ParseStruct   Input parse structure.
   1357   @param    Value         Return vlaue.
   1358 
   1359   @retval   return the action result.
   1360 
   1361 **/
   1362 TCG_RESULT
   1363 EFIAPI
   1364 TcgGetNextUINT64(
   1365   TCG_PARSE_STRUCT           *ParseStruct,
   1366   UINT64                     *Value
   1367   )
   1368 {
   1369   TCG_TOKEN Tok;
   1370   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1371   ERROR_CHECK(TcgGetTokenUINT64(&Tok, Value));
   1372   return TcgResultSuccess;
   1373 }
   1374 
   1375 /**
   1376   Get next specify value.
   1377 
   1378   @param    ParseStruct   Input parse structure.
   1379   @param    Value         Return vlaue.
   1380 
   1381   @retval   return the action result.
   1382 
   1383 **/
   1384 TCG_RESULT
   1385 EFIAPI
   1386 TcgGetNextBOOLEAN(
   1387   TCG_PARSE_STRUCT        *ParseStruct,
   1388   BOOLEAN                 *Value
   1389   )
   1390 {
   1391   UINT64 Value64;
   1392   TCG_TOKEN Tok;
   1393 
   1394   NULL_CHECK(Value);
   1395 
   1396   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1397   ERROR_CHECK(TcgGetTokenUINT64(&Tok, &Value64));
   1398 
   1399   if (Value64 > 1) {
   1400     return TcgResultFailure;
   1401   }
   1402 
   1403   *Value = (BOOLEAN)Value64;
   1404 
   1405   return TcgResultSuccess;
   1406 }
   1407 
   1408 /**
   1409   Get next tcg uid info.
   1410 
   1411   @param    ParseStruct    Input parse structure.
   1412   @param    Uid            Get the uid info.
   1413 
   1414   @retval   return the action result.
   1415 
   1416 **/
   1417 TCG_RESULT
   1418 EFIAPI
   1419 TcgGetNextTcgUid(
   1420   TCG_PARSE_STRUCT         *ParseStruct,
   1421   TCG_UID                  *Uid
   1422   )
   1423 {
   1424   TCG_TOKEN Tok;
   1425   UINT32 Length;
   1426   const UINT8* ByteSeq;
   1427 
   1428   NULL_CHECK(Uid);
   1429 
   1430   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1431   ByteSeq = TcgGetTokenByteSequence(&Tok, &Length);
   1432 
   1433   if (Length != sizeof(TCG_UID)) {
   1434     DEBUG ((DEBUG_INFO, "Token Length %u != TCG_UID Size %u\n", Length, (UINT32)sizeof(TCG_UID)));
   1435     return TcgResultFailure;
   1436   }
   1437 
   1438   ASSERT (ByteSeq != NULL);
   1439 
   1440   CopyMem(Uid, ByteSeq, sizeof(TCG_UID));
   1441 
   1442   return TcgResultSuccess;
   1443 }
   1444 
   1445 /**
   1446   Get next byte sequence.
   1447 
   1448   @param    ParseStruct     Input parse structure.
   1449   @param    Data            return the data.
   1450   @param    Length          return the length.
   1451 
   1452   @retval   return the action result.
   1453 
   1454 **/
   1455 TCG_RESULT
   1456 EFIAPI
   1457 TcgGetNextByteSequence(
   1458   TCG_PARSE_STRUCT      *ParseStruct,
   1459   const VOID            **Data,
   1460   UINT32                *Length
   1461   )
   1462 {
   1463   TCG_TOKEN Tok;
   1464   const UINT8* Bs;
   1465 
   1466   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1467   Bs = TcgGetTokenByteSequence(&Tok, Length);
   1468 
   1469   if (Bs == NULL) {
   1470     return TcgResultFailure;
   1471   }
   1472   *Data = Bs;
   1473   return TcgResultSuccess;
   1474 }
   1475 
   1476 /**
   1477   Get next token Type.
   1478 
   1479   @param    ParseStruct    Input parse structure.
   1480   @param    Type           Input the type need to check.
   1481 
   1482   @retval   return the action result.
   1483 
   1484 **/
   1485 TCG_RESULT
   1486 EFIAPI
   1487 TcgGetNextTokenType(
   1488   TCG_PARSE_STRUCT        *ParseStruct,
   1489   TCG_TOKEN_TYPE          Type
   1490   )
   1491 {
   1492   TCG_TOKEN Tok;
   1493   ERROR_CHECK(TcgGetNextToken(ParseStruct, &Tok));
   1494   if (Tok.Type != Type) {
   1495     DEBUG ((DEBUG_INFO, "expected Type %u, got Type %u\n", Type, Tok.Type));
   1496     return TcgResultFailure;
   1497   }
   1498   return TcgResultSuccess;
   1499 }
   1500 
   1501 /**
   1502   Get next start list.
   1503 
   1504   @param    ParseStruct   Input parse structure.
   1505 
   1506   @retval   return the action result.
   1507 
   1508 **/
   1509 TCG_RESULT
   1510 EFIAPI
   1511 TcgGetNextStartList(
   1512   TCG_PARSE_STRUCT          *ParseStruct
   1513   )
   1514 {
   1515   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeStartList);
   1516 }
   1517 
   1518 /**
   1519   Get next end list.
   1520 
   1521   @param    ParseStruct   Input parse structure.
   1522 
   1523   @retval   return the action result.
   1524 
   1525 **/
   1526 TCG_RESULT
   1527 EFIAPI
   1528 TcgGetNextEndList(
   1529   TCG_PARSE_STRUCT             *ParseStruct
   1530   )
   1531 {
   1532   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeEndList);
   1533 }
   1534 
   1535 /**
   1536   Get next start name.
   1537 
   1538   @param    ParseStruct   Input parse structure.
   1539 
   1540   @retval   return the action result.
   1541 
   1542 **/
   1543 TCG_RESULT
   1544 EFIAPI
   1545 TcgGetNextStartName(
   1546   TCG_PARSE_STRUCT              *ParseStruct
   1547   )
   1548 {
   1549   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeStartName);
   1550 }
   1551 
   1552 /**
   1553   Get next end name.
   1554 
   1555   @param    ParseStruct   Input parse structure.
   1556 
   1557   @retval   return the action result.
   1558 
   1559 **/
   1560 TCG_RESULT
   1561 EFIAPI
   1562 TcgGetNextEndName(
   1563   TCG_PARSE_STRUCT               *ParseStruct
   1564   )
   1565 {
   1566   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeEndName);
   1567 }
   1568 
   1569 /**
   1570   Get next call.
   1571 
   1572   @param    ParseStruct   Input parse structure.
   1573 
   1574   @retval   return the action result.
   1575 
   1576 **/
   1577 TCG_RESULT
   1578 EFIAPI
   1579 TcgGetNextCall(
   1580   TCG_PARSE_STRUCT                   *ParseStruct
   1581   )
   1582 {
   1583   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeCall);
   1584 }
   1585 
   1586 /**
   1587   Get next end data.
   1588 
   1589   @param    ParseStruct   Input parse structure.
   1590 
   1591   @retval   return the action result.
   1592 
   1593 **/
   1594 TCG_RESULT
   1595 EFIAPI
   1596 TcgGetNextEndOfData(
   1597   TCG_PARSE_STRUCT                    *ParseStruct
   1598   )
   1599 {
   1600   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeEndOfData);
   1601 }
   1602 
   1603 /**
   1604   Get next end of session.
   1605 
   1606   @param    ParseStruct   Input parse structure.
   1607 
   1608   @retval   return the action result.
   1609 
   1610 **/
   1611 TCG_RESULT
   1612 EFIAPI
   1613 TcgGetNextEndOfSession(
   1614   TCG_PARSE_STRUCT                      *ParseStruct
   1615   )
   1616 {
   1617   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeEndOfSession);
   1618 }
   1619 
   1620 /**
   1621   Get next start transaction.
   1622 
   1623   @param    ParseStruct   Input parse structure.
   1624 
   1625   @retval   return the action result.
   1626 
   1627 **/
   1628 TCG_RESULT
   1629 EFIAPI
   1630 TcgGetNextStartTransaction(
   1631   TCG_PARSE_STRUCT                        *ParseStruct
   1632   )
   1633 {
   1634   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeStartTransaction);
   1635 }
   1636 
   1637 /**
   1638   Get next end transaction.
   1639 
   1640   @param    ParseStruct   Input parse structure.
   1641 
   1642   @retval   return the action result.
   1643 
   1644 **/
   1645 TCG_RESULT
   1646 EFIAPI
   1647 TcgGetNextEndTransaction(
   1648   TCG_PARSE_STRUCT                  *ParseStruct
   1649   )
   1650 {
   1651   return TcgGetNextTokenType(ParseStruct, TcgTokenTypeEndTransaction);
   1652 }
   1653