/* Microsoft Reference Implementation for TPM 2.0
 *
 *  The copyright in this software is being made available under the BSD License,
 *  included below. This software may be subject to other third party and
 *  contributor rights, including patent rights, and no such rights are granted
 *  under this license.
 *
 *  Copyright (c) Microsoft Corporation
 *
 *  All rights reserved.
 *
 *  BSD License
 *
 *  Redistribution and use in source and binary forms, with or without modification,
 *  are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice, this list
 *  of conditions and the following disclaimer.
 *
 *  Redistributions in binary form must reproduce the above copyright notice, this
 *  list of conditions and the following disclaimer in the documentation and/or
 *  other materials provided with the distribution.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 *  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _TABLE_MARSHAL_H_
#define _TABLE_MARSHAL_H_

// These are the basic unmarshaling types. This is in the first byte of
// each structure descriptor that is passed to Marshal()/Unmarshal() for processing.
#define UINT_MTYPE          0                          
#define VALUES_MTYPE        (UINT_MTYPE + 1)
#define TABLE_MTYPE         (VALUES_MTYPE + 1)
#define MIN_MAX_MTYPE       (TABLE_MTYPE + 1)
#define ATTRIBUTES_MTYPE    (MIN_MAX_MTYPE + 1)
#define STRUCTURE_MTYPE     (ATTRIBUTES_MTYPE + 1)
#define TPM2B_MTYPE         (STRUCTURE_MTYPE + 1)
#define TPM2BS_MTYPE        (TPM2B_MTYPE + 1)
#define LIST_MTYPE          (TPM2BS_MTYPE + 1) // TPML
#define ERROR_MTYPE         (LIST_MTYPE + 1)
#define NULL_MTYPE          (ERROR_MTYPE + 1)
#define COMPOSITE_MTYPE     (NULL_MTYPE + 1)   

//*** The Marshal Index 
// A structure is used to hold the values that guide the marshaling/unmarshaling of
// each of the types. Each structure has a name and an address. For a structure to 
// define a TPMS_name, the structure is a TPMS_name_MARSHAL_STRUCT and its
// index is TPMS_name_MARSHAL_INDEX. So, to get the proper structure, use the 
// associated marshal index. The marshal index is passed to Marshal() or Unmarshal()
// and those functions look up the proper structure.
// 
// To handle structures that allow a null value, the upper bit of each marshal
// index indicates if the null value is allowed. This is the NULL_FLAG. It is defined
// in TableMarshalIndex.h because it is needed by code outside of the marshaling
// code.

// A structure will have a list of marshal indexes to indicate what to unmarshal. When
// that index appears in a structure/union, the value will contain a flag to indicate
// that the NULL_FLAG should be SET on the call to Unmarshal() to unmarshal the type.
// The caller simply takes the entry and passes it to Unmarshal() to indicate that the
// NULL_FLAG is SET. There is also the opportunity to SET the NULL_FLAG in the called
// structure if the NULL_FLAG was set in the call to the calling structure. This is
// indicated by:
#define NULL_MASK       ~(NULL_FLAG)

// When looking up the value to marshal, the upper bit of the marshal index is
// masked to yield the actual index. The MSb is the flag bit that indicates if a
// null flag is set. Code does not verify that the bit is clear when the called object
// does not take a flag as this is a benign error.

// the modifier byte as used by each MTYPE shown as a structure. They are expressed
// as a bit maps below. However, the code uses masking and not bit fields. The types
// show below are just to help in understanding.
// NOTE: LSb0 bit numbering is assumed in these typedefs.
//
// When used in an UINT_MTYPE
typedef struct integerModifier {
    unsigned            size : 2;
    unsigned            sign : 1;
    unsigned            unused : 7;
} integerModifier;

// When used in a VALUES_MTYPE
typedef struct valuesModifier {
    unsigned            size : 2;
    unsigned            sign : 1;
    unsigned            unused : 5;
    unsigned            takesNull : 1;
} valuesModifier;

// When used in a TABLE_MTYPE
typedef struct tableModifier {
    unsigned            size : 2;
    unsigned            sign : 1;
    unsigned            unused : 3;
    unsigned            hasBits : 1;
    unsigned            takesNull : 1;
} tableModifier;

// the modifier byte for MIN_MAX_MTYPE
typedef struct minMaxModifier {
    unsigned            size : 2;
    unsigned            sign : 1;
    unsigned            unused : 3;
    unsigned            hasBits : 1;
    unsigned            takesNull : 1;
} minMaxModifier;

// the modifier byte for ATTRIBUTES_MTYPE
typedef struct attributesModifier {
    unsigned            size : 2;
    unsigned            sign : 1;
    unsigned            unused : 5;
} attributesModifier;

// the modifier byte is not present in a STRUCTURE_MTYPE or an TPM2B_MTYPE

// the modifier byte for a TPM2BS_MTYPE
typedef struct tpm2bsModifier {
    unsigned            offset : 4;
    unsigned            unused : 2;
    unsigned            sizeEqual : 1;
    unsigned            propigateNull : 1;
} tpm2bsModifier;

// the modifier byte for a LIST_MTYPE
typedef struct listModifier {
    unsigned            offset : 4;
    unsigned            unused : 2;
    unsigned            sizeEqual : 1;
    unsigned            propigateNull : 1;
} listModifier;


//*** Modifier Octet Values
// These are in used in anything that is an integer value. Theses would not be in
// structure modifier bytes (they would be used in values in structures but not the
// STRUCTURE_MTYPE header.
#define ONE_BYTES           (0)
#define TWO_BYTES           (1)
#define FOUR_BYTES          (2)
#define EIGHT_BYTES         (3)
#define SIZE_MASK           (0x3)
#define IS_SIGNED           (1 << 2)    // when the unmarshaled type is a signed value
#define SIGNED_MASK         (SIZE_MASK | IS_SIGNED)

// This may be used for any type except a UINT_MTYPE
#define TAKES_NULL          (1 << 7)    // when the type takes a null

// When referencing a structure, this flag indicates if a null is to be propagated
// to the referenced structure or type.
#define PROPAGATE_NULL      (TAKES_NULL)

// Can be used in min-max or table structures.
#define HAS_BITS            (1 << 6)    // when bit mask is present 

// In a union, we need to know if this is a union of constant arrays.
#define IS_ARRAY_UNION      (1 << 6)

// In a TPM2BS_MTYPE
#define SIZE_EQUAL          (1 << 6)
#define OFFSET_MASK         (0xF)

// Right now, there are three spare bits in the modifiers field.

// Within the descriptor word of each entry in a StructMarsh_mst, there is a selector
// field to determine which of the sub-types the entry represents and a field that is
// used to reference another structure entry. This is a 6-bit field allowing a
// structure to have 64 entries. This should be more than enough as the structures are
// not that long. As of now, only 10-bits of the descriptor word leaving room for
// expansion.

// These are the values used in a STRUCTURE_MTYPE to identify the sub-type of the 
// thing being processed
#define SIMPLE_STYPE                0
#define UNION_STYPE                 1
#define ARRAY_STYPE                 2

// The code used GET_ to get the element type and the compiler uses SET_ to initialize
// the value. The element type is the three bits (2:0).
#define GET_ELEMENT_TYPE(val)       (val & 7)
#define SET_ELEMENT_TYPE(val)       (val & 7)

// When an entry is an array or union, this references the structure entry that
// contains the dimension or selector value. The code then uses this number to look up
// the structure entry for that element to find out what it and where is it in memory.
// When this is not a reference, it is a simple type and it could be used as an array
// value or a union selector. When a simple value, this field contains the size
// of the associated value (ONE_BYTES, TWO_BYTES ...)
//
// The entry size/number is 6 bits (13:8).
#define GET_ELEMENT_NUMBER(val)     (((val) >> 8) & 0x3F)
#define SET_ELEMENT_NUMBER(val)     (((val) & 0x3F) << 8)
#define GET_ELEMENT_SIZE(val)       GET_ELEMENT_NUMBER(val)
#define SET_ELEMENT_SIZE(val)       SET_ELEMENT_NUMBER(val)
// This determines if the null flag is propagated to this type. If generate, the
// NULL_FLAG is SET in the index value. This flag is one bit (7)
#define ELEMENT_PROPAGATE           (PROPAGATE_NULL)

#define INDEX_MASK                  ((UINT16)NULL_MASK)

// This is used in all bit-field checks. These are used when a value that is checked
// is conditional (dependent on the compilation). For example, if AES_128 is (NO),
// then the bit associated with AES_128 will be 0. In some cases, the bit value is
// found by checking that the input is within the range of the table, and then using
// the (val - min) value to index the bit. This would be used when verifying that
// a particular algorithm is implemented. In other cases, there is a bit for each
// value in a table. For example, if checking the key sizes, there is a list of
// possible key sizes allowed by the algorithm registry and a bit field to indicate 
// if that key size is allowed in the implementation. The smallest bit field has 
// 32-bits because it is implemented as part of the 'values' array in structures 
// that allow bit fields.
#define IS_BIT_SET32(bit, bits)                                                     \
                        ((((UINT32 *)bits)[bit >> 5] & (1 << (bit & 0x1F))) != 0)

// For a COMPOSITE_MTYPE, the qualifiers byte has an element size and count.
#define SET_ELEMENT_COUNT(count)    ((count & 0x1F) << 3)
#define GET_ELEMENT_COUNT(val)      ((val  >> 3) & 0x1F)

#endif // _TABLE_MARSHAL_H_