/** @file
  Provide functions to provide tcg storage core spec related functions.

Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <Library/TcgStorageCoreLib.h>

#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
// #include <Library/PrintLib.h>

/**
  Required to be called before calling any other Tcg functions with the TCG_CREATE_STRUCT.
  Initializes the packet variables to NULL.  Additionally, the buffer will be memset.

  @param [in/out]    CreateStruct    Structure to initialize
  @param [in]        Buffer          Buffer allocated by client of library.  It will contain the Tcg encoded packet.  This cannot be null.
  @param [in]        BufferSize      Size of buffer provided.  It cannot be 0.

  @retval       Return the action result.
**/
TCG_RESULT
EFIAPI
TcgInitTcgCreateStruct (
  TCG_CREATE_STRUCT  *CreateStruct,
  VOID               *Buffer,
  UINT32             BufferSize
  )
{
  NULL_CHECK (CreateStruct);
  NULL_CHECK (Buffer);

  if (BufferSize == 0) {
    DEBUG ((DEBUG_INFO, "BufferSize=0\n"));
    return (TcgResultFailureZeroSize);
  }

  ZeroMem (Buffer, BufferSize);
  CreateStruct->BufferSize   = BufferSize;
  CreateStruct->Buffer       = Buffer;
  CreateStruct->ComPacket    = NULL;
  CreateStruct->CurPacket    = NULL;
  CreateStruct->CurSubPacket = NULL;

  return (TcgResultSuccess);
}

/**

  Encodes the ComPacket header to the data structure.

  @param[in/out]    CreateStruct          Structure to initialize
  @param[in]        ComId                 ComID of the Tcg ComPacket.
  @param[in]        ComIdExtension        ComID Extension of the Tcg ComPacket.

**/
TCG_RESULT
EFIAPI
TcgStartComPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT16             ComId,
  UINT16             ComIdExtension
  )
{
  NULL_CHECK (CreateStruct);

  if ((CreateStruct->ComPacket != NULL) ||
      (CreateStruct->CurPacket != NULL) ||
      (CreateStruct->CurSubPacket != NULL)
      )
  {
    DEBUG ((
      DEBUG_INFO,
      "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n",
      CreateStruct->ComPacket,
      CreateStruct->CurPacket,
      CreateStruct->CurSubPacket
      ));
    return (TcgResultFailureInvalidAction);
  }

  if (sizeof (TCG_COM_PACKET) > CreateStruct->BufferSize) {
    DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    return (TcgResultFailureBufferTooSmall);
  }

  CreateStruct->ComPacket                   = (TCG_COM_PACKET *)CreateStruct->Buffer;
  CreateStruct->ComPacket->ComIDBE          = SwapBytes16 (ComId);
  CreateStruct->ComPacket->ComIDExtensionBE = SwapBytes16 (ComIdExtension);

  return (TcgResultSuccess);
}

/**

  Starts a new ComPacket in the Data structure.

  @param [in/out]     CreateStruct    Structure used to add Tcg Packet
  @param[in]          Tsn             Packet Tper session number
  @param[in]          Hsn             Packet Host session number
  @param[in]          SeqNumber       Packet Sequence Number
  @param[in]          AckType         Packet Acknowledge Type
  @param[in]          Ack             Packet Acknowledge

**/
TCG_RESULT
EFIAPI
TcgStartPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             Tsn,
  UINT32             Hsn,
  UINT32             SeqNumber,
  UINT16             AckType,
  UINT32             Ack
  )
{
  UINT32  AddedSize;

  NULL_CHECK (CreateStruct);

  AddedSize = 0;

  if ((CreateStruct->ComPacket == NULL) ||
      (CreateStruct->CurPacket != NULL) ||
      (CreateStruct->CurSubPacket != NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    return (TcgResultFailureInvalidAction);
  }

  // update TCG_COM_PACKET and packet lengths
  AddedSize = sizeof (TCG_PACKET);

  if ((SwapBytes32 (CreateStruct->ComPacket->LengthBE) + AddedSize) > CreateStruct->BufferSize) {
    DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    return (TcgResultFailureBufferTooSmall);
  }

  CreateStruct->CurPacket = (TCG_PACKET *)(CreateStruct->ComPacket->Payload + SwapBytes32 (CreateStruct->ComPacket->LengthBE));

  CreateStruct->CurPacket->TperSessionNumberBE = SwapBytes32 (Tsn);
  CreateStruct->CurPacket->HostSessionNumberBE = SwapBytes32 (Hsn);
  CreateStruct->CurPacket->SequenceNumberBE    = SwapBytes32 (SeqNumber);
  CreateStruct->CurPacket->AckTypeBE           = SwapBytes16 (AckType);
  CreateStruct->CurPacket->AcknowledgementBE   = SwapBytes32 (Ack);

  CreateStruct->CurPacket->LengthBE = 0;

  // update TCG_COM_PACKET Length for next pointer
  CreateStruct->ComPacket->LengthBE = SwapBytes32 (SwapBytes32 (CreateStruct->ComPacket->LengthBE) + AddedSize);

  return (TcgResultSuccess);
}

/**

  Starts a new SubPacket in the Data structure.

  @param[in/out]    CreateStruct        Structure used to start Tcg SubPacket
  @param[in]        Kind                SubPacket kind

**/
TCG_RESULT
EFIAPI
TcgStartSubPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT16             Kind
  )
{
  UINT32  AddedSize;

  NULL_CHECK (CreateStruct);

  AddedSize = 0;

  if ((CreateStruct->ComPacket == NULL) ||
      (CreateStruct->CurPacket == NULL) ||
      (CreateStruct->CurSubPacket != NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    return (TcgResultFailureInvalidAction);
  }

  AddedSize = sizeof (TCG_SUB_PACKET);

  if ((SwapBytes32 (CreateStruct->ComPacket->LengthBE) + AddedSize) > CreateStruct->BufferSize) {
    DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    return (TcgResultFailureBufferTooSmall);
  }

  CreateStruct->CurSubPacket         = (TCG_SUB_PACKET *)(CreateStruct->CurPacket->Payload + SwapBytes32 (CreateStruct->CurPacket->LengthBE));
  CreateStruct->CurSubPacket->KindBE = SwapBytes16 (Kind);

  // update lengths
  CreateStruct->CurSubPacket->LengthBE = 0;

  // update TCG_COM_PACKET and packet lengths
  CreateStruct->ComPacket->LengthBE = SwapBytes32 (SwapBytes32 (CreateStruct->ComPacket->LengthBE) + AddedSize);
  CreateStruct->CurPacket->LengthBE = SwapBytes32 (SwapBytes32 (CreateStruct->CurPacket->LengthBE) + AddedSize);

  return (TcgResultSuccess);
}

/**

  Ends the current SubPacket in the Data structure.  This function will also perform the 4-byte padding
  required for Subpackets.

  @param[in/out]       CreateStruct        Structure used to end the current Tcg SubPacket

**/
TCG_RESULT
EFIAPI
TcgEndSubPacket (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  UINT32  PadSize;

  NULL_CHECK (CreateStruct);

  PadSize = 0;

  if ((CreateStruct->ComPacket == NULL) ||
      (CreateStruct->CurPacket == NULL) ||
      (CreateStruct->CurSubPacket == NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    return (TcgResultFailureInvalidAction);
  }

  // align to 4-byte boundaries, so shift padding
  // pad Size does not apply to subpacket Length
  PadSize = TCG_SUBPACKET_ALIGNMENT - (SwapBytes32 (CreateStruct->CurSubPacket->LengthBE) & (TCG_SUBPACKET_ALIGNMENT - 1));

  if (PadSize == TCG_SUBPACKET_ALIGNMENT) {
    PadSize = 0;
  }

  if ((SwapBytes32 (CreateStruct->ComPacket->LengthBE) + PadSize) > CreateStruct->BufferSize) {
    DEBUG ((DEBUG_INFO, "BufferSize=0x%X\n", CreateStruct->BufferSize));
    return (TcgResultFailureBufferTooSmall);
  }

  CreateStruct->CurPacket->LengthBE = SwapBytes32 (SwapBytes32 (CreateStruct->CurPacket->LengthBE) + PadSize);
  CreateStruct->ComPacket->LengthBE = SwapBytes32 (SwapBytes32 (CreateStruct->ComPacket->LengthBE) + PadSize);

  CreateStruct->CurSubPacket = NULL;

  return (TcgResultSuccess);
}

/**

  Ends the current Packet in the Data structure.

  @param[in/out]       CreateStruct        Structure used to end the current Tcg Packet

**/
TCG_RESULT
EFIAPI
TcgEndPacket (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  NULL_CHECK (CreateStruct);

  if ((CreateStruct->ComPacket == NULL) ||
      (CreateStruct->CurPacket == NULL) ||
      (CreateStruct->CurSubPacket != NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    return (TcgResultFailureInvalidAction);
  }

  CreateStruct->CurPacket = NULL;

  return (TcgResultSuccess);
}

/**

  Ends the ComPacket in the Data structure and ret

  @param [in/out]       CreateStruct       Structure used to end the Tcg ComPacket
  @param [in/out]       Size               Describes the Size of the entire ComPacket (Header and payload). Filled out by function.

**/
TCG_RESULT
EFIAPI
TcgEndComPacket (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             *Size
  )
{
  NULL_CHECK (CreateStruct);
  NULL_CHECK (Size);

  if ((CreateStruct->ComPacket == NULL) ||
      (CreateStruct->CurPacket != NULL) ||
      (CreateStruct->CurSubPacket != NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    return (TcgResultFailureInvalidAction);
  }

  *Size                   = SwapBytes32 (CreateStruct->ComPacket->LengthBE) + sizeof (*CreateStruct->ComPacket);
  CreateStruct->ComPacket = NULL;

  return (TcgResultSuccess);
}

/**
  Adds raw Data with optional Header

  @param       CreateStruct       The create structure.
  @param       Header             The header structure.
  @param       HeaderSize         The header size.
  @param       Data               The data need to add.
  @param       DataSize           The data size.
  @param       ByteSwapData       Whether byte or swap data.

**/
TCG_RESULT
TcgAddRawTokenData (
  TCG_CREATE_STRUCT  *CreateStruct,
  const VOID         *Header,
  UINT8              HeaderSize,
  const VOID         *Data,
  UINT32             DataSize,
  BOOLEAN            ByteSwapData
  )
{
  UINT32       AddedSize;
  UINT8        *Dest;
  const UINT8  *DataBytes;
  UINT32       Index;

  AddedSize = 0;
  Index     = 0;
  Dest      = NULL;

  NULL_CHECK (CreateStruct);

  if (((HeaderSize != 0) && (Header == NULL)) ||
      ((DataSize != 0) && (Data == NULL))
      )
  {
    DEBUG ((DEBUG_INFO, "HeaderSize=0x%X Header=%p DataSize=0x%X Data=%p\n", HeaderSize, Header, DataSize, Data));
    return (TcgResultFailureNullPointer);
  }

  if ((CreateStruct->ComPacket == NULL) ||
      (CreateStruct->CurPacket == NULL) ||
      (CreateStruct->CurSubPacket == NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
    return (TcgResultFailureInvalidAction);
  }

  // verify there is enough Buffer Size
  AddedSize = HeaderSize + DataSize;
  if ((SwapBytes32 (CreateStruct->ComPacket->LengthBE) + AddedSize) > CreateStruct->BufferSize) {
    return (TcgResultFailureBufferTooSmall);
  }

  // Get a pointer to where the new bytes should go
  Dest = CreateStruct->ComPacket->Payload + SwapBytes32 (CreateStruct->ComPacket->LengthBE);

  switch (HeaderSize) {
    case sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM):
    case sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM):
    case sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM):
      CopyMem (Dest, Header, HeaderSize);
      Dest += HeaderSize;
    case 0: // no Header is valid
      break;
    // invalid Header Size
    default:
      DEBUG ((DEBUG_INFO, "unsupported HeaderSize=%u\n", HeaderSize));
      return TcgResultFailure;
  }

  // copy the Data bytes
  if (ByteSwapData) {
    DataBytes = (const UINT8 *)Data;
    for (Index = 0; Index < DataSize; Index++) {
      Dest[Index] = DataBytes[DataSize - 1 - Index];
    }
  } else {
    CopyMem (Dest, Data, DataSize);
  }

  // Update all the packet sizes
  CreateStruct->ComPacket->LengthBE    = SwapBytes32 (SwapBytes32 (CreateStruct->ComPacket->LengthBE) + AddedSize);
  CreateStruct->CurPacket->LengthBE    = SwapBytes32 (SwapBytes32 (CreateStruct->CurPacket->LengthBE) + AddedSize);
  CreateStruct->CurSubPacket->LengthBE = SwapBytes32 (SwapBytes32 (CreateStruct->CurSubPacket->LengthBE) + AddedSize);

  return (TcgResultSuccess);
}

/**

  Adds a single raw token byte to the Data structure.

  @param[in/out]   CreateStruct        Structure used to add the byte
  @param[in]       Byte                Byte to add

**/
TCG_RESULT
EFIAPI
TcgAddRawByte (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT8              Byte
  )
{
  return TcgAddRawTokenData (CreateStruct, NULL, 0, &Byte, 1, FALSE);
}

/**
   simple tokens - atoms: tiny, short, medium, long and empty atoms.
   tiny atom can be a signed or unsigned integer.
   short, medium, long can be a signed or unsigned integer OR a complete or non-final byte sequence.

  @param       CreateStruct       The create structure.
  @param       Data               The data need to add.
  @param       DataSize           The data size.
  @param       ByteOrInt,         Data format is byte or int.
  @param       SignOrCont         sign or cont.


**/
TCG_RESULT
TcgAddAtom (
  TCG_CREATE_STRUCT  *CreateStruct,
  const VOID         *Data,
  UINT32             DataSize,
  UINT8              ByteOrInt,
  UINT8              SignOrCont
  )
{
  const UINT8                   *DataBytes;
  TCG_SIMPLE_TOKEN_TINY_ATOM    TinyAtom;
  TCG_SIMPLE_TOKEN_SHORT_ATOM   ShortAtom;
  TCG_SIMPLE_TOKEN_MEDIUM_ATOM  MediumAtom;
  TCG_SIMPLE_TOKEN_LONG_ATOM    LongAtom;

  NULL_CHECK (CreateStruct);

  if (DataSize == 0) {
    if (ByteOrInt == TCG_ATOM_TYPE_INTEGER) {
      DEBUG ((DEBUG_INFO, "0-Size integer not allowed\n"));
      return TcgResultFailure;
    }
  } else {
    // if DataSize != 0, Data must be valid
    NULL_CHECK (Data);
  }

  // encode Data using the shortest possible atom
  DataBytes = (const UINT8 *)Data;
  if ((DataSize == 1) &&
      (ByteOrInt == TCG_ATOM_TYPE_INTEGER) &&
      (((SignOrCont != 0) && ((TCG_TOKEN_TINYATOM_SIGNED_MIN_VALUE <= *(INT8 *)Data) && (*(INT8 *)Data <= TCG_TOKEN_TINYATOM_SIGNED_MAX_VALUE))) ||
       ((SignOrCont == 0) && ((*DataBytes <= TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE))))
      )
  {
    TinyAtom.TinyAtomBits.IsZero = 0;
    TinyAtom.TinyAtomBits.Sign   = SignOrCont;
    TinyAtom.TinyAtomBits.Data   = *DataBytes & TCG_TOKEN_TINYATOM_UNSIGNED_MAX_VALUE;
    return TcgAddRawTokenData (CreateStruct, NULL, 0, (UINT8 *)&TinyAtom, sizeof (TCG_SIMPLE_TOKEN_TINY_ATOM), FALSE);
  }

  if (DataSize <= TCG_TOKEN_SHORTATOM_MAX_BYTE_SIZE) {
    ShortAtom.ShortAtomBits.IsOne      = 1;
    ShortAtom.ShortAtomBits.IsZero     = 0;
    ShortAtom.ShortAtomBits.ByteOrInt  = ByteOrInt;
    ShortAtom.ShortAtomBits.SignOrCont = SignOrCont;
    ShortAtom.ShortAtomBits.Length     = DataSize & 0x0F;
    return TcgAddRawTokenData (CreateStruct, &ShortAtom, sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM), Data, DataSize, ByteOrInt == TCG_ATOM_TYPE_INTEGER);
  }

  if (DataSize <= TCG_TOKEN_MEDIUMATOM_MAX_BYTE_SIZE) {
    MediumAtom.MediumAtomBits.IsOne1     = 1;
    MediumAtom.MediumAtomBits.IsOne2     = 1;
    MediumAtom.MediumAtomBits.IsZero     = 0;
    MediumAtom.MediumAtomBits.ByteOrInt  = ByteOrInt;
    MediumAtom.MediumAtomBits.SignOrCont = SignOrCont;
    MediumAtom.MediumAtomBits.LengthLow  = DataSize & 0xFF;
    MediumAtom.MediumAtomBits.LengthHigh = (DataSize >> TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT) & TCG_MEDIUM_ATOM_LENGTH_HIGH_MASK;
    return TcgAddRawTokenData (CreateStruct, &MediumAtom, sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM), Data, DataSize, ByteOrInt == TCG_ATOM_TYPE_INTEGER);
  }

  LongAtom.LongAtomBits.IsOne1     = 1;
  LongAtom.LongAtomBits.IsOne2     = 1;
  LongAtom.LongAtomBits.IsOne3     = 1;
  LongAtom.LongAtomBits.IsZero     = 0;
  LongAtom.LongAtomBits.ByteOrInt  = ByteOrInt;
  LongAtom.LongAtomBits.SignOrCont = SignOrCont;
  LongAtom.LongAtomBits.LengthLow  = DataSize & 0xFF;
  LongAtom.LongAtomBits.LengthMid  = (DataSize >> TCG_LONG_ATOM_LENGTH_MID_SHIFT) & 0xFF;
  LongAtom.LongAtomBits.LengthHigh = (DataSize >> TCG_LONG_ATOM_LENGTH_HIGH_SHIFT) & 0xFF;
  return TcgAddRawTokenData (CreateStruct, &LongAtom, sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM), Data, DataSize, ByteOrInt == TCG_ATOM_TYPE_INTEGER);
}

/**

  Adds the Data parameter as a byte sequence to the Data structure.

  @param[in/out]    CreateStruct      Structure used to add the byte sequence
  @param[in]        Data              Byte sequence that will be encoded and copied into Data structure
  @param[in]        DataSize          Length of Data provided
  @param[in]        Continued         TRUE if byte sequence is continued or
                                      FALSE if the Data contains the entire byte sequence to be encoded

**/
TCG_RESULT
EFIAPI
TcgAddByteSequence (
  TCG_CREATE_STRUCT  *CreateStruct,
  const VOID         *Data,
  UINT32             DataSize,
  BOOLEAN            Continued
  )
{
  return TcgAddAtom (CreateStruct, Data, DataSize, TCG_ATOM_TYPE_BYTE, Continued ? 1 : 0);
}

/**

  Adds an arbitrary-Length integer to the Data structure.
  The integer will be encoded using the shortest possible atom.

  @param[in/out]     CreateStruct      Structure used to add the integer
  @param[in]         Data              Integer in host byte order that will be encoded and copied into Data structure
  @param[in]         DataSize          Length in bytes of the Data provided
  @param[in]         SignedInteger     TRUE if the integer is signed or FALSE if the integer is unsigned

**/
TCG_RESULT
EFIAPI
TcgAddInteger (
  TCG_CREATE_STRUCT  *CreateStruct,
  const VOID         *Data,
  UINT32             DataSize,
  BOOLEAN            SignedInteger
  )
{
  const UINT8  *DataBytes;
  UINT32       ActualDataSize;
  BOOLEAN      ValueIsNegative;

  NULL_CHECK (CreateStruct);
  NULL_CHECK (Data);

  if (DataSize == 0) {
    DEBUG ((DEBUG_INFO, "invalid DataSize=0\n"));
    return TcgResultFailure;
  }

  DataBytes = (const UINT8 *)Data;

  // integer should be represented by smallest atom possible
  // so calculate real Data Size
  ValueIsNegative = SignedInteger && DataBytes[DataSize - 1] & 0x80;

  // assumes native Data is little endian
  // shorten Data to smallest byte representation
  for (ActualDataSize = DataSize; ActualDataSize > 1; ActualDataSize--) {
    // ignore sign extended  FFs
    if (ValueIsNegative && (DataBytes[ActualDataSize - 1] != 0xFF)) {
      break;
    } else if (!ValueIsNegative && (DataBytes[ActualDataSize - 1] != 0)) {
      // ignore extended 00s
      break;
    }
  }

  return TcgAddAtom (CreateStruct, Data, ActualDataSize, TCG_ATOM_TYPE_INTEGER, SignedInteger ? 1 : 0);
}

/**
  Adds an 8-bit unsigned integer to the Data structure.

  @param[in/out]       CreateStruct        Structure used to add the integer
  @param[in]           Value               Integer Value to add

**/
TCG_RESULT
EFIAPI
TcgAddUINT8 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT8              Value
  )
{
  return TcgAddInteger (CreateStruct, &Value, sizeof (Value), FALSE);
}

/**

  Adds a 16-bit unsigned integer to the Data structure.

  @param[in/out]       CreateStruct        Structure used to add the integer
  @param[in]           Value               Integer Value to add

**/
TCG_RESULT
EFIAPI
TcgAddUINT16 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT16             Value
  )
{
  return TcgAddInteger (CreateStruct, &Value, sizeof (Value), FALSE);
}

/**

  Adds a 32-bit unsigned integer to the Data structure.

  @param[in/out]        CreateStruct        Structure used to add the integer
  @param[in]            Value               Integer Value to add

**/
TCG_RESULT
EFIAPI
TcgAddUINT32 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT32             Value
  )
{
  return TcgAddInteger (CreateStruct, &Value, sizeof (Value), FALSE);
}

/**

  Adds a 64-bit unsigned integer to the Data structure.

  @param[in/out]      CreateStruct        Structure used to add the integer
  @param[in]          Value               Integer Value to add

**/
TCG_RESULT
EFIAPI
TcgAddUINT64 (
  TCG_CREATE_STRUCT  *CreateStruct,
  UINT64             Value
  )
{
  return TcgAddInteger (CreateStruct, &Value, sizeof (Value), FALSE);
}

/**
  Adds a BOOLEAN to the Data structure.

  @param[in/out]       CreateStruct     Structure used to add the integer
  @param[in]           Value              BOOLEAN Value to add

**/
TCG_RESULT
EFIAPI
TcgAddBOOLEAN (
  TCG_CREATE_STRUCT  *CreateStruct,
  BOOLEAN            Value
  )
{
  return TcgAddInteger (CreateStruct, &Value, sizeof (Value), FALSE);
}

/**
  Add tcg uid info.

  @param [in/out]       CreateStruct       Structure used to add the integer
  @param                Uid                Input uid info.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddTcgUid (
  TCG_CREATE_STRUCT  *CreateStruct,
  TCG_UID            Uid
  )
{
  return TcgAddByteSequence (CreateStruct, &Uid, sizeof (TCG_UID), FALSE);
}

/**
  Add start list.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddStartList (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_STARTLIST);
}

/**
  Add end list.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddEndList (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_ENDLIST);
}

/**
  Add start name.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddStartName (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_STARTNAME);
}

/**
  Add end name.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddEndName (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_ENDNAME);
}

/**
  Add end call.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddCall (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_CALL);
}

/**
  Add end of data.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddEndOfData (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_ENDDATA);
}

/**
  Add end of session.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddEndOfSession (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_ENDSESSION);
}

/**
  Add start transaction.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddStartTransaction (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_STARTTRANSACTION);
}

/**
  Add end transaction.

  @param [in/out]       CreateStruct       Structure used to add the integer

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgAddEndTransaction (
  TCG_CREATE_STRUCT  *CreateStruct
  )
{
  return TcgAddRawByte (CreateStruct, TCG_TOKEN_ENDTRANSACTION);
}

/**
  Initial the tcg parse structure.

  @param    ParseStruct    Input parse structure.
  @param    Buffer         Input buffer data.
  @param    BufferSize     Input buffer size.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgInitTcgParseStruct (
  TCG_PARSE_STRUCT  *ParseStruct,
  const VOID        *Buffer,
  UINT32            BufferSize
  )
{
  UINT32  ComPacketLength;
  UINT32  PacketLength;

  NULL_CHECK (ParseStruct);
  NULL_CHECK (Buffer);

  if (BufferSize < sizeof (TCG_COM_PACKET)) {
    return (TcgResultFailureBufferTooSmall);
  }

  ParseStruct->ComPacket = (TCG_COM_PACKET *)Buffer;

  ComPacketLength = SwapBytes32 (ParseStruct->ComPacket->LengthBE);

  if ((BufferSize - sizeof (TCG_COM_PACKET)) < ComPacketLength) {
    DEBUG ((DEBUG_INFO, "Buffer %u too small for ComPacket %u\n", BufferSize, ComPacketLength));
    return (TcgResultFailureBufferTooSmall);
  }

  ParseStruct->BufferSize = BufferSize;
  ParseStruct->Buffer     = Buffer;

  ParseStruct->CurPacket    = NULL;
  ParseStruct->CurSubPacket = NULL;
  ParseStruct->CurPtr       = NULL;

  // if payload > 0, then must have a packet
  if (ComPacketLength != 0) {
    if (ComPacketLength < sizeof (TCG_PACKET)) {
      DEBUG ((DEBUG_INFO, "ComPacket too small for Packet\n"));
      return (TcgResultFailureBufferTooSmall);
    }

    ParseStruct->CurPacket = (TCG_PACKET *)ParseStruct->ComPacket->Payload;

    PacketLength = SwapBytes32 (ParseStruct->CurPacket->LengthBE);

    if (PacketLength > 0) {
      if (PacketLength < sizeof (TCG_SUB_PACKET)) {
        DEBUG ((DEBUG_INFO, "Packet too small for SubPacket\n"));
        return (TcgResultFailureBufferTooSmall);
      }

      ParseStruct->CurSubPacket = (TCG_SUB_PACKET *)ParseStruct->CurPacket->Payload;
    }
  }

  // TODO should check for method status list at this point?

  return (TcgResultSuccess);
}

/**
  Get next token info.

  @param    ParseStruct      Input parse structure info.
  @param    TcgToken         return the tcg token info.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextToken (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_TOKEN         *TcgToken
  )
{
  const UINT8                         *EndOfSubPacket;
  UINT8                               *TokenEnd;
  UINT8                               Hdr;
  TCG_SIMPLE_TOKEN_SHORT_ATOM         *TmpShort;
  const TCG_SIMPLE_TOKEN_MEDIUM_ATOM  *TmpMed;
  const TCG_SIMPLE_TOKEN_LONG_ATOM    *TmpLong;

  NULL_CHECK (ParseStruct);
  NULL_CHECK (TcgToken);

  if ((ParseStruct->ComPacket == NULL) ||
      (ParseStruct->CurPacket == NULL) ||
      (ParseStruct->CurSubPacket == NULL)
      )
  {
    DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", ParseStruct->ComPacket, ParseStruct->CurPacket, ParseStruct->CurSubPacket));
    return TcgResultFailureInvalidAction;
  }

  // initial call, start at sub packet
  if (ParseStruct->CurPtr == NULL) {
    ParseStruct->CurPtr = ParseStruct->CurSubPacket->Payload;
  }

  EndOfSubPacket = ParseStruct->CurSubPacket->Payload + SwapBytes32 (ParseStruct->CurSubPacket->LengthBE);
  TokenEnd       = NULL;

  // confirmed that subpacket Length falls within end of Buffer and TCG_COM_PACKET,
  // so simply need to verify the loop stays within current subpacket
  if (ParseStruct->CurPtr >= EndOfSubPacket) {
    DEBUG ((DEBUG_INFO, "ParseStruct->CurPtr >= EndOfSubPacket\n"));
    return (TcgResultFailureEndBuffer);
  }

  Hdr                = *ParseStruct->CurPtr;
  TcgToken->HdrStart = ParseStruct->CurPtr;

  // Tiny Atom range
  if (Hdr <= 0x7F) {
    // tiny atom Header is only 1 byte, so don't need to verify Size before cast and access
    TcgToken->Type = TcgTokenTypeTinyAtom;

    TokenEnd = TcgToken->HdrStart + sizeof (TCG_SIMPLE_TOKEN_TINY_ATOM);

    // verify caller will have enough Size to reference token
    if (TokenEnd >= EndOfSubPacket) {
      DEBUG ((DEBUG_INFO, "Tiny Atom TokenEnd >= EndOfSubPacket\n"));
      return (TcgResultFailureEndBuffer);
    }
  }
  // Short Atom Range
  else if ((0x80 <= Hdr) && (Hdr <= 0xBF)) {
    // short atom Header is only 1 byte, so don't need to verify Size before cast and access
    TmpShort       = (TCG_SIMPLE_TOKEN_SHORT_ATOM *)(ParseStruct->CurPtr);
    TcgToken->Type = TcgTokenTypeShortAtom;

    TokenEnd = (TcgToken->HdrStart + sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM) + TmpShort->ShortAtomBits.Length);

    // verify caller will have enough Size to reference token
    if (TokenEnd >= EndOfSubPacket) {
      DEBUG ((DEBUG_INFO, "Short Atom TokenEnd >= EndOfSubPacket\n"));
      return (TcgResultFailureEndBuffer);
    }
  }
  // Medium Atom Range
  else if ((0xC0 <= Hdr) && (Hdr <= 0xDF)) {
    if (TcgToken->HdrStart + sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM) >= EndOfSubPacket) {
      return (TcgResultFailureEndBuffer);
    }

    TmpMed         = (const TCG_SIMPLE_TOKEN_MEDIUM_ATOM *)ParseStruct->CurPtr;
    TcgToken->Type = TcgTokenTypeMediumAtom;
    TokenEnd       = TcgToken->HdrStart + sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM) +
                     ((TmpMed->MediumAtomBits.LengthHigh << TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT) |
                      TmpMed->MediumAtomBits.LengthLow);

    // verify caller will have enough Size to reference token
    if (TokenEnd >= EndOfSubPacket) {
      DEBUG ((DEBUG_INFO, "Medium Atom TokenEnd >= EndOfSubPacket\n"));
      return (TcgResultFailureEndBuffer);
    }
  }
  // Long Atom Range
  else if ((0xE0 <= Hdr) && (Hdr <= 0xE3)) {
    if (TcgToken->HdrStart + sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM) >= EndOfSubPacket) {
      return (TcgResultFailureEndBuffer);
    }

    TmpLong        = (const TCG_SIMPLE_TOKEN_LONG_ATOM *)ParseStruct->CurPtr;
    TcgToken->Type = TcgTokenTypeLongAtom;

    TokenEnd = TcgToken->HdrStart + sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM) +
               ((TmpLong->LongAtomBits.LengthHigh << TCG_LONG_ATOM_LENGTH_HIGH_SHIFT) |
                (TmpLong->LongAtomBits.LengthMid << TCG_LONG_ATOM_LENGTH_MID_SHIFT)   |
                TmpLong->LongAtomBits.LengthLow);

    // verify caller will have enough Size to reference token
    if (TokenEnd >= EndOfSubPacket) {
      DEBUG ((DEBUG_INFO, "Long Atom TokenEnd >= EndOfSubPacket\n"));
      return (TcgResultFailureEndBuffer);
    }
  } else {
    // single byte tokens
    switch (Hdr) {
      case TCG_TOKEN_STARTLIST:
        TcgToken->Type = TcgTokenTypeStartList;
        break;
      case TCG_TOKEN_ENDLIST:
        TcgToken->Type = TcgTokenTypeEndList;
        break;
      case TCG_TOKEN_STARTNAME:
        TcgToken->Type = TcgTokenTypeStartName;
        break;
      case TCG_TOKEN_ENDNAME:
        TcgToken->Type = TcgTokenTypeEndName;
        break;
      case TCG_TOKEN_CALL:
        TcgToken->Type = TcgTokenTypeCall;
        break;
      case TCG_TOKEN_ENDDATA:
        TcgToken->Type = TcgTokenTypeEndOfData;
        break;
      case TCG_TOKEN_ENDSESSION:
        TcgToken->Type = TcgTokenTypeEndOfSession;
        break;
      case TCG_TOKEN_STARTTRANSACTION:
        TcgToken->Type = TcgTokenTypeStartTransaction;
        break;
      case TCG_TOKEN_ENDTRANSACTION:
        TcgToken->Type = TcgTokenTypeEndTransaction;
        break;
      case TCG_TOKEN_EMPTY:
        TcgToken->Type = TcgTokenTypeEmptyAtom;
        break;
      default:
        DEBUG ((DEBUG_INFO, "WARNING: reserved token Type 0x%02X\n", Hdr));
        TcgToken->Type = TcgTokenTypeReserved;
        break;
    }

    ParseStruct->CurPtr++;
    TokenEnd = TcgToken->HdrStart + 1;
  }

  // increment curptr for next call
  ParseStruct->CurPtr = TokenEnd;
  return (TcgResultSuccess);
}

/**
  Get atom info.

  @param    TcgToken          Input token info.
  @param    HeaderLength      return the header length.
  @param    DataLength        return the data length.
  @param    ByteOrInt         return the atom Type.
  @param    SignOrCont        return the sign or count info.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetAtomInfo (
  const TCG_TOKEN  *TcgToken,
  UINT32           *HeaderLength,
  UINT32           *DataLength,
  UINT8            *ByteOrInt,
  UINT8            *SignOrCont
  )
{
  TCG_SIMPLE_TOKEN_TINY_ATOM    *TinyAtom;
  TCG_SIMPLE_TOKEN_SHORT_ATOM   *ShortAtom;
  TCG_SIMPLE_TOKEN_MEDIUM_ATOM  *MediumAtom;
  TCG_SIMPLE_TOKEN_LONG_ATOM    *LongAtom;

  NULL_CHECK (TcgToken);
  NULL_CHECK (HeaderLength);
  NULL_CHECK (DataLength);
  NULL_CHECK (ByteOrInt);
  NULL_CHECK (SignOrCont);

  switch (TcgToken->Type) {
    case TcgTokenTypeTinyAtom:
    {
      TinyAtom      = (TCG_SIMPLE_TOKEN_TINY_ATOM *)TcgToken->HdrStart;
      *ByteOrInt    = TCG_ATOM_TYPE_INTEGER;
      *SignOrCont   = TinyAtom->TinyAtomBits.Sign;
      *HeaderLength = 0;
      *DataLength   = 0;   // tiny atom must be handled as a special case - Header and Data in the same byte
      return TcgResultSuccess;
    }

    case TcgTokenTypeShortAtom:
    {
      ShortAtom     = (TCG_SIMPLE_TOKEN_SHORT_ATOM *)TcgToken->HdrStart;
      *ByteOrInt    = ShortAtom->ShortAtomBits.ByteOrInt;
      *SignOrCont   = ShortAtom->ShortAtomBits.SignOrCont;
      *HeaderLength = sizeof (TCG_SIMPLE_TOKEN_SHORT_ATOM);
      *DataLength   = ShortAtom->ShortAtomBits.Length;
      return TcgResultSuccess;
    }

    case TcgTokenTypeMediumAtom:
    {
      MediumAtom    = (TCG_SIMPLE_TOKEN_MEDIUM_ATOM *)TcgToken->HdrStart;
      *ByteOrInt    = MediumAtom->MediumAtomBits.ByteOrInt;
      *SignOrCont   = MediumAtom->MediumAtomBits.SignOrCont;
      *HeaderLength = sizeof (TCG_SIMPLE_TOKEN_MEDIUM_ATOM);
      *DataLength   = (MediumAtom->MediumAtomBits.LengthHigh << TCG_MEDIUM_ATOM_LENGTH_HIGH_SHIFT) | MediumAtom->MediumAtomBits.LengthLow;
      return TcgResultSuccess;
    }

    case TcgTokenTypeLongAtom:
    {
      LongAtom      = (TCG_SIMPLE_TOKEN_LONG_ATOM *)TcgToken->HdrStart;
      *ByteOrInt    = LongAtom->LongAtomBits.ByteOrInt;
      *SignOrCont   = LongAtom->LongAtomBits.SignOrCont;
      *HeaderLength = sizeof (TCG_SIMPLE_TOKEN_LONG_ATOM);
      *DataLength   = (LongAtom->LongAtomBits.LengthHigh << TCG_LONG_ATOM_LENGTH_HIGH_SHIFT) |
                      (LongAtom->LongAtomBits.LengthMid << TCG_LONG_ATOM_LENGTH_MID_SHIFT) |
                      LongAtom->LongAtomBits.LengthLow;
      return TcgResultSuccess;
    }

    default:
      DEBUG ((DEBUG_INFO, "Token Type is not simple atom (%d)\n", TcgToken->Type));
      return (TcgResultFailureInvalidType);
  }
}

/**
  Get token specified value.

  @param    TcgToken   Input token info.
  @param    Value      return the value.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetTokenUINT64 (
  const TCG_TOKEN  *TcgToken,
  UINT64           *Value
  )
{
  UINT32                      HdrLength;
  UINT32                      DataLength;
  UINT8                       ByteOrInt;
  UINT8                       IsSigned;
  TCG_SIMPLE_TOKEN_TINY_ATOM  *TmpTiny;
  const UINT8                 *Data;
  UINT32                      Index;

  NULL_CHECK (TcgToken);
  NULL_CHECK (Value);

  Index  = 0;
  *Value = 0;
  ERROR_CHECK (TcgGetAtomInfo (TcgToken, &HdrLength, &DataLength, &ByteOrInt, &IsSigned));

  if (ByteOrInt != TCG_ATOM_TYPE_INTEGER) {
    DEBUG ((DEBUG_INFO, "Invalid Type, expected integer not byte sequence\n"));
    return TcgResultFailureInvalidType;
  }

  if (IsSigned != 0) {
    DEBUG ((DEBUG_INFO, "Integer is signed, expected unsigned\n"));
    return TcgResultFailureInvalidType;
  }

  // special case for tiny atom
  // Header and Data are in one byte, so extract only the Data bitfield
  if (TcgToken->Type == TcgTokenTypeTinyAtom) {
    TmpTiny = (TCG_SIMPLE_TOKEN_TINY_ATOM *)TcgToken->HdrStart;
    *Value  = TmpTiny->TinyAtomBits.Data;
    return TcgResultSuccess;
  }

  if (DataLength > sizeof (UINT64)) {
    DEBUG ((DEBUG_INFO, "Length %d is greater than Size of UINT64\n", DataLength));
    return TcgResultFailureBufferTooSmall;
  }

  // read big-endian integer
  Data = TcgToken->HdrStart + HdrLength;
  for (Index = 0; Index < DataLength; Index++) {
    *Value = LShiftU64 (*Value, 8) | Data[Index];
  }

  return TcgResultSuccess;
}

/**
  Get token byte sequence.

  @param    TcgToken   Input token info.
  @param    Length     Input the length info.

  @retval   Return the value data.

**/
UINT8 *
EFIAPI
TcgGetTokenByteSequence (
  const TCG_TOKEN  *TcgToken,
  UINT32           *Length
  )
{
  UINT32  HdrLength;
  UINT8   ByteOrInt;
  UINT8   SignOrCont;

  if ((TcgToken == NULL) || (Length == NULL)) {
    return NULL;
  }

  *Length = 0;
  if (TcgGetAtomInfo (TcgToken, &HdrLength, Length, &ByteOrInt, &SignOrCont) != TcgResultSuccess) {
    DEBUG ((DEBUG_INFO, "Failed to get simple token info\n"));
    return NULL;
  }

  if (ByteOrInt != TCG_ATOM_TYPE_BYTE) {
    DEBUG ((DEBUG_INFO, "Invalid Type, expected byte sequence not integer\n"));
    return NULL;
  }

  return (TcgToken->HdrStart + HdrLength);
}

/**
  Get next specify value.

  @param    ParseStruct   Input parse structure.
  @param    Value         Return value.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextUINT8 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT8             *Value
  )
{
  UINT64     Value64;
  TCG_TOKEN  Tok;

  NULL_CHECK (Value);

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  ERROR_CHECK (TcgGetTokenUINT64 (&Tok, &Value64));

  if (Value64 > MAX_UINT8) {
    return TcgResultFailure;
  }

  *Value = (UINT8)Value64;

  return TcgResultSuccess;
}

/**
  Get next specify value.

  @param    ParseStruct   Input parse structure.
  @param    Value         Return value.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextUINT16 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT16            *Value
  )
{
  UINT64     Value64;
  TCG_TOKEN  Tok;

  NULL_CHECK (Value);

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  ERROR_CHECK (TcgGetTokenUINT64 (&Tok, &Value64));

  if (Value64 > MAX_UINT16) {
    return TcgResultFailure;
  }

  *Value = (UINT16)Value64;

  return TcgResultSuccess;
}

/**
  Get next specify value.

  @param    ParseStruct   Input parse structure.
  @param    Value         Return value.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextUINT32 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT32            *Value
  )
{
  UINT64     Value64;
  TCG_TOKEN  Tok;

  NULL_CHECK (Value);

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  ERROR_CHECK (TcgGetTokenUINT64 (&Tok, &Value64));

  if (Value64 > MAX_UINT32) {
    return TcgResultFailure;
  }

  *Value = (UINT32)Value64;

  return TcgResultSuccess;
}

/**
  Get next specify value.

  @param    ParseStruct   Input parse structure.
  @param    Value         Return value.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextUINT64 (
  TCG_PARSE_STRUCT  *ParseStruct,
  UINT64            *Value
  )
{
  TCG_TOKEN  Tok;

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  ERROR_CHECK (TcgGetTokenUINT64 (&Tok, Value));
  return TcgResultSuccess;
}

/**
  Get next specify value.

  @param    ParseStruct   Input parse structure.
  @param    Value         Return value.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextBOOLEAN (
  TCG_PARSE_STRUCT  *ParseStruct,
  BOOLEAN           *Value
  )
{
  UINT64     Value64;
  TCG_TOKEN  Tok;

  NULL_CHECK (Value);

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  ERROR_CHECK (TcgGetTokenUINT64 (&Tok, &Value64));

  if (Value64 > 1) {
    return TcgResultFailure;
  }

  *Value = (BOOLEAN)Value64;

  return TcgResultSuccess;
}

/**
  Get next tcg uid info.

  @param    ParseStruct    Input parse structure.
  @param    Uid            Get the uid info.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextTcgUid (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_UID           *Uid
  )
{
  TCG_TOKEN    Tok;
  UINT32       Length;
  const UINT8  *ByteSeq;

  NULL_CHECK (Uid);

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  ByteSeq = TcgGetTokenByteSequence (&Tok, &Length);

  if (Length != sizeof (TCG_UID)) {
    DEBUG ((DEBUG_INFO, "Token Length %u != TCG_UID Size %u\n", Length, (UINT32)sizeof (TCG_UID)));
    return TcgResultFailure;
  }

  ASSERT (ByteSeq != NULL);

  CopyMem (Uid, ByteSeq, sizeof (TCG_UID));

  return TcgResultSuccess;
}

/**
  Get next byte sequence.

  @param    ParseStruct     Input parse structure.
  @param    Data            return the data.
  @param    Length          return the length.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextByteSequence (
  TCG_PARSE_STRUCT  *ParseStruct,
  const VOID        **Data,
  UINT32            *Length
  )
{
  TCG_TOKEN    Tok;
  const UINT8  *Bs;

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  Bs = TcgGetTokenByteSequence (&Tok, Length);

  if (Bs == NULL) {
    return TcgResultFailure;
  }

  *Data = Bs;
  return TcgResultSuccess;
}

/**
  Get next token Type.

  @param    ParseStruct    Input parse structure.
  @param    Type           Input the type need to check.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextTokenType (
  TCG_PARSE_STRUCT  *ParseStruct,
  TCG_TOKEN_TYPE    Type
  )
{
  TCG_TOKEN  Tok;

  ERROR_CHECK (TcgGetNextToken (ParseStruct, &Tok));
  if (Tok.Type != Type) {
    DEBUG ((DEBUG_INFO, "expected Type %u, got Type %u\n", Type, Tok.Type));
    return TcgResultFailure;
  }

  return TcgResultSuccess;
}

/**
  Get next start list.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextStartList (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeStartList);
}

/**
  Get next end list.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextEndList (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeEndList);
}

/**
  Get next start name.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextStartName (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeStartName);
}

/**
  Get next end name.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextEndName (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeEndName);
}

/**
  Get next call.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextCall (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeCall);
}

/**
  Get next end data.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextEndOfData (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeEndOfData);
}

/**
  Get next end of session.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextEndOfSession (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeEndOfSession);
}

/**
  Get next start transaction.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextStartTransaction (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeStartTransaction);
}

/**
  Get next end transaction.

  @param    ParseStruct   Input parse structure.

  @retval   return the action result.

**/
TCG_RESULT
EFIAPI
TcgGetNextEndTransaction (
  TCG_PARSE_STRUCT  *ParseStruct
  )
{
  return TcgGetNextTokenType (ParseStruct, TcgTokenTypeEndTransaction);
}