| """Module for processing TCG TPM2 library object descriptions. |
| |
| The descriptions are scraped from the tables of parts 2 and 3 of the |
| specification by a different module and fed through this module for |
| processing. |
| """ |
| |
| from __future__ import print_function |
| |
| import re |
| import sys |
| |
| from command_generator import Command |
| from structure_generator import AttributeStructure |
| from structure_generator import ConstantType |
| from structure_generator import Field |
| from structure_generator import Interface |
| from structure_generator import Structure |
| from structure_generator import Typedef |
| from structure_generator import Union |
| |
| |
| def _DebugLog(*args, **kwargs): |
| """When used - sends its inputs to stderr. |
| |
| This function can be used when debugging this module. Its footprint is |
| similar to print(), but the default destination is sys.stderr, which is |
| handy when the script generates stdio output redirected into a file. |
| |
| Args: |
| *args: a list of items of various types to print. Printed space separated, |
| each one converted to str before being printed. |
| **kwargs: a dictionary of variables to pass to print(), if any. In fact the |
| only key this function cares about is 'endl', which allows to |
| suppress adding a newline to the printed string. |
| """ |
| endl = kwargs.get('endl', '\n') |
| print(' '.join(str(x) for x in args), end=endl, file=sys.stderr) |
| |
| |
| class Table(object): |
| """Representation of TCG TPM2 library specification tables. |
| |
| The purpose of this class is to both generate new TPM2 objects and to keep |
| track of the previously generated objects for post processing (generating C |
| code). |
| |
| The HTML scraper finds tables in the specifications and builds up the |
| tables' contents in this object, one at a time. This object's table |
| representation includes table title, table header and one or more then table |
| rows. |
| |
| The table title must start with 'Table ### xxx', where ### is monotonously |
| increasing table number and xxx is some description allowing to deduce the |
| type of the object defined by this table. |
| |
| The cells of the table include names and types of the components, various |
| decorations are used to convey additional information: array boundaries, |
| values' limits, return values, selectors, etc, etc. |
| |
| Once the entire table is scraped, the scraper invokes a method to process it |
| (ProcessTable). The title of the table is examined by this module and the |
| appropriate processing method is invoked to actually convert the internal |
| table representation into a TPM2 object. |
| |
| Two maps are maintained persistently over the life time of this object, the |
| map of types (keyed by the type name scraped from part 2) and map of |
| commands (keyed by the command name, scraped from part 3). |
| |
| One other thing this module produces is the text for the .h file defining |
| all structures and types this module encountered. |
| |
| Attributes: |
| |
| _alg_id_table: actual table of various TPM2 algorithms, a copy of Table 9 |
| from part 2. It is used to convert encoded algorithm specs |
| used in other tables into a list of matching algorithms. |
| _h_file: a multiline string, the accumulated .h file defining all TPM |
| objects processed so far. |
| _type_map: a dictionary of various TPM types, keyed by the string - the |
| type name |
| _command_map: a dictionary of command_generator.Command objects, keyed by |
| the string, the command name |
| skip_tables: a tuple of integers, the numbers of tables which should not |
| be included in the .h file, as the same information was |
| derived from part 4 earlier. |
| _title: a string, title of the currently being processed specification |
| table |
| _title_type: a string, base type of the object defined by the currently |
| being processed specification table |
| _alg_type: a string, in some tables included in the title in curly |
| brackets, to indicate what type of the algorithm this table |
| deals with (usually RSA or ECC) |
| _body: a list of strings, rows of the currently being processed |
| specification table |
| _has_selector_column: a Boolean, set to True if the third column of the |
| table is the selector to be used to process this row (as in |
| picking the object type when the table represents a union) |
| _skip_printing: a Boolean, set to True if the table contents should not be |
| included on tpm_types.h - some tables are also defined in |
| files extracted from Part 4 of the specification. |
| |
| """ |
| |
| # Match table titles with processing routines. |
| TABLE_ROUTER = ( |
| (re.compile('(Constants|Defines for Logic Values)'), '_ProcessConstants'), |
| (re.compile('(of Types for|Base Types)'), '_ProcessTypes'), |
| (re.compile('Definition of .* Type'), '_ProcessInterfaceOrType'), |
| (re.compile('Unmarshaling Errors'), '_ProcessEnum'), |
| (re.compile(r'Definition of [\S]+ (Structure|Union)'), |
| '_ProcessStructureOrUnion'), |
| (re.compile('Definition of .* Bits'), '_ProcessBits'), |
| (re.compile(r' TPM2_\S+ (Command|Response)'), '_ProcessCommand'), |
| ) |
| |
| |
| # The TCG spec in some cases uses so called 'Algorithm macros' to describe |
| # all algorithms a type should apply to. The macros are described in details |
| # in section 4.12 of part 2 of the spec. |
| # |
| # Basically, the macro consists of the prefix '!ALG' followed by dot |
| # separated descriptions of algorithm types this marco applies to. |
| # |
| # The algorithm types are expressed as sequences or lower or upper case |
| # letters, and should match the third column of Table 9 either inclusively |
| # (in case the type letters are in upper case, or exclusively, in case the |
| # type letters are in lower case. |
| _alg_macro = re.compile(r'!ALG\.([a-z\.]+)', re.IGNORECASE) |
| |
| def __init__(self): |
| """Create a Table class instance.""" |
| self._alg_id_table = [] |
| # Allow re-initializing attributes outside __init__() (in Init()) |
| self.Init() |
| self._h_file = '' |
| self._type_map = {} |
| self._command_map = {} |
| self.skip_tables = () |
| |
| def Init(self, title=''): |
| """Initialize a new table. |
| |
| This function is invoked each time a new table is encountered in the spec. |
| |
| A typical table header could look like this: |
| |
| 'Table 10 - Definition of (UINT16) {ECC} TPM_ECC_CURVE Constants' |
| |
| The algorithm type in curly brackets, if present, is redundant, it is |
| stripped off before the table header comment is generated for the .h file. |
| |
| Some titles include the parenthesized base type the defined object should |
| be typedef'ed from. |
| |
| Args: |
| title: a string, the title of the table as included in the TCG spec. |
| """ |
| title_bracket_filter = re.compile(r'({.*?}) ?') |
| title_type_filter = re.compile(r'(\(.*?\)) ?') |
| # Retrieve base type, if present in the table title. |
| m = title_type_filter.search(title) |
| if m: |
| # the header shown in the docstring above would result in the match of |
| # '(UINT16)', remove the parenthesis and save the base type. |
| self._title_type = m.groups()[0][1:-1] |
| self._title = title_type_filter.sub('', title).strip() |
| else: |
| self._title_type = '' |
| self._title = title.strip() |
| # Now retrieve algorithm type, if present in the table title. |
| m = title_bracket_filter.search(self._title) |
| self._alg_type = '' |
| if m: |
| self._title = title_bracket_filter.sub('', self._title).strip() |
| alg_type = m.groups()[0][1:-1].strip() |
| if not alg_type.startswith('!'): |
| self._alg_type = alg_type |
| self._body = [] |
| self._has_selector_column = False |
| self._skip_printing = False |
| |
| def _SplitByAlg(self, word): |
| """Split the passed in word by the regex used to pick TPM algorithms. |
| |
| The TPM algorithm regex is used all over the spec in situations where |
| similar code needs to be generated for different algorithms of a certain |
| type. |
| |
| A string in the spec might look like one of the following: |
| TPMI_!ALG.S_KEY_BITS or !ALG.S_KEY_SIZES_BITS. |
| |
| The split would result in a three element list: the part before !ALG |
| (could be empty), the letters between '!ALG.' and _ or end of the string, |
| and the part after the letters included in the algorithm regex. |
| |
| TPMI_!ALG.S_KEY_BITS => ['TPMI_', 'S', '_KEY_BITS'] |
| !ALG.S_KEY_SIZES_BITS => ['', 'S', '_KEY_SIZES_BITS'] |
| |
| The first and last elements of the split are used as the prefix and suffix |
| of the type names included in the generated file. |
| |
| In some cases there is no regex suffix present, only the !ALG string, as |
| in the selector column in table 127 (TPM_ALG_!ALG) In this case the split |
| by the !ALG string is attempted, and the generated list has just two |
| elements. |
| |
| In yet some other cases, say in Table 126 where the type field does not |
| change at all set to TPMI_ALG_SYM_MODE for all fields. In such cases the |
| split returns a single element list, the second element set to None is |
| added to the list. |
| |
| Args: |
| word: a string, the encoded algorithm string to be split. |
| |
| Returns: |
| a tuple of two strings, first and last elements of the split, either one |
| could be empty. |
| |
| """ |
| parts = self._alg_macro.split(word) |
| if len(parts) == 1: |
| parts = word.split('!ALG') |
| if len(parts) == 1: |
| return word, None |
| return parts[0].strip('_'), parts[-1].strip('_') |
| |
| def SetSkipTables(self, skip_tables): |
| """Set the tuple of table numbers to be ignored by the parser.""" |
| self.skip_tables = skip_tables |
| |
| def _AddToHfile(self, text=''): |
| self._h_file += text + '\n' |
| |
| def _SetBaseType(self, old_type, tpm_obj): |
| """Set the base type for a new object. |
| |
| Many TPM objects are typedefed hierarchically, for instance |
| |
| uint16_t => UINT16 => TPM_ALG_ID_Marshal => TPMI_ALG_HASH_Marshal |
| |
| This causes excessive nesting when marshaling and unmarshaling, which is |
| bad from both performance and stack size requirements point of view. |
| |
| This function will discover the 'basest' type and set it in the tpm |
| object, this would help to generate direct marshaling/unmarshaling |
| functions. |
| |
| Args: |
| old_type: a string, name of the immediate type this tpm object typedefed |
| from. |
| tpm_obj: a tpm object, derived from TPMType |
| """ |
| base_type = old_type |
| while base_type in self._type_map: |
| try: |
| base_type = self._type_map[base_type].old_type |
| except AttributeError: |
| break # The underlying type is not a typedef |
| tpm_obj.SetBaseType(base_type) |
| |
| def _AddTypedef(self, old_type, new_type): |
| if not self._skip_printing: |
| self._AddToHfile('typedef %s %s;' % (old_type, new_type)) |
| # No need to generate marshaling/unmarshaling code for BOOL type. |
| if new_type != 'BOOL': |
| self._type_map[new_type] = Typedef(old_type, new_type) |
| self._SetBaseType(old_type, self._type_map[new_type]) |
| |
| def InProgress(self): |
| """Return True when the parser is in the middle of a table.""" |
| return self._title |
| |
| def _GetMaxLengths(self, table): |
| """Find out maximum lengths of the table columns. |
| |
| This function helps to generate nicely aligned definitions in the output |
| .h file, by making sure that each field's name starts in the same column, |
| far enough for all fields' types to fit. |
| |
| Args: |
| table: a list of string lists. Each component consists of at least two |
| elements, the first one the field or constant type, the |
| second one the field name or constant value. |
| |
| Returns: |
| a tuple of two integers, the first one - the length of the longest |
| string in the first colume, the second one - the length of the |
| longest string in the second column. |
| """ |
| lengths = [0, 0] |
| for row in table: |
| for i in range(len(lengths)): |
| if len(row[i]) > lengths[i]: |
| lengths[i] = len(row[i]) |
| return tuple(lengths) |
| |
| def NewRow(self): |
| """Start a new row in the internal table representation.""" |
| self._body.append([]) |
| |
| def NewCell(self): |
| """Start a new cell in the last row.""" |
| self._body[-1].append('') |
| |
| def AddData(self, data): |
| """Add data to the last cell of the last row.""" |
| if not self._body: |
| return # Ignore end of line and whitespace formatting. |
| self._body[-1][-1] += data |
| |
| def ProcessTable(self): |
| """Process accumulated table contents. |
| |
| This function is invoked when the parser state machine detects that the |
| entire HTML table has been processed. The received contents is handled |
| based on the table title by finding the matching entry in TABLE_ROUTER |
| tuple. |
| |
| The result of processing is adding a new TPM type to the _type_map |
| dictionary, or a new command descriptor to the _command_map dictionary. |
| """ |
| |
| # The table has a selector column if it has at least three columns, and |
| # the third column is titled 'Selector'. |
| self._has_selector_column = (len(self._body[0]) >= 3 and |
| self._body[0][2].strip() == 'Selector') |
| # Preprocess representation of the table scraped from the spec. Namely, |
| # remove the header row, and strip all other cells before adding them to |
| # self._body[], which becomes a list including all scraped table cells, |
| # stripped. |
| self._body = [[cell.strip() for cell in row] for row in self._body[1:]] |
| if 'TPM_ALG_ID Constants' in self._title: |
| self._alg_id_table = [[x[0], x[2].replace(' ', ''), x[3]] |
| for x in self._body] |
| |
| # The name of the type defined in the table, when present, is always the |
| # fifth element in the stripped header, for instance: |
| # 'Table 10 - Definition of TPM_ECC_CURVE Constants' |
| try: |
| type_name = self._title.split()[4] |
| except IndexError: |
| type_name = '' |
| |
| # Based on the table title, find the function to process the table and |
| # generate a TPM specification object of a certain type. |
| table_func = '' |
| for regex, func in self.TABLE_ROUTER: |
| if regex.search(self._title): |
| table_func = func |
| break |
| else: |
| self._AddToHfile('// Unprocessed: %s' % self._title) |
| return |
| |
| if int(self._title.split()[1]) in self.skip_tables: |
| self._skip_printing = True |
| self._AddToHfile('// Skipped: %s' % self._title) |
| else: |
| self._AddToHfile('// %s' % self._title) |
| |
| # Invoke a TPM type specific processing function. |
| getattr(self, table_func)(type_name) |
| |
| def _ProcessCommand(self, _): |
| """Process command description table from part 3. |
| |
| Each TPM command has two tables associated with it, one describing the |
| request structure, and another one describing the response structure. The |
| first time a TPM command is encountered, a Command object is created and |
| its 'request_args' property is set, the second time it is encountered - |
| the existing object's 'response_args' property is set. |
| """ |
| command_name = self._title.split()[2] |
| if command_name not in self._command_map: |
| command = Command(command_name) |
| self._command_map[command_name] = command |
| else: |
| command = self._command_map[command_name] |
| params = [] |
| # The first three fields in each request and response are always the same |
| # and are not included in the generated structures. Let's iterate over the |
| # rest of the fields. |
| for row in self._body[3:]: |
| # A dictionary describing a request or response structure field. |
| field = {} |
| # Ignore the '@' decoration for now. |
| field_type, field['name'] = row[0], row[1].lstrip('@') |
| # The '+' decoration means this field can be conditional. |
| if field_type.endswith('+'): |
| field_type = field_type[:-1] |
| field['has_conditional'] = 'TRUE' |
| else: |
| field['has_conditional'] = 'FALSE' |
| field['type'] = field_type |
| if len(row) > 2: |
| field['description'] = row[2] |
| else: |
| field['description'] = '' |
| # Add the new field to the list of request or response fields. |
| params.append(field) |
| if ' Command' in self._title: |
| command.request_args = params |
| else: |
| command.response_args = params |
| |
| def _PickAlgEntries(self, alg_type_str): |
| """Process algorithm id table and find all matching entries. |
| |
| See comments to _alg_macro above. |
| |
| Args: |
| alg_type_str: a string, one or more dot separated encoded algorithm types. |
| |
| Returns: |
| A table of alg_type (Table 9 of part 2) entries matching the passed in |
| encoded type string. |
| """ |
| filtered_table = [] |
| for alg_type in alg_type_str.split('.'): |
| if re.match('^[A-Z]+$', alg_type): |
| # Exclusive selection, must exactly match algorithm type from table 9 |
| # (which is in the second column). Add to the return value all |
| # matching rows of table 9. |
| extension = [] |
| for row in self._alg_id_table: |
| if row[1] == alg_type: |
| if self._alg_type and self._alg_type != row[2]: |
| continue |
| extension.append(row) |
| filtered_table.extend(extension) |
| elif re.match('^[a-z]+$', alg_type): |
| # Inclusive selection. All type letters must be present in the type |
| # column, but no exact match is required. |
| for row in self._alg_id_table: |
| for char in alg_type.upper(): |
| if char not in row[1]: |
| break |
| else: |
| if not self._alg_type or self._alg_type == row[2]: |
| filtered_table.append(row) |
| return filtered_table |
| |
| def _ParseAlgorithmRegex(self, token): |
| """Process a token as an algorithm regex. |
| |
| This function tries to interpret the passed in token as an encoded |
| algorithm specification. |
| |
| In case the encoded algorithm regex matches, the function splits the token |
| into prefix, algorithm description and suffix, and then retrieves the list |
| of all algorithms matching the algorithm description. |
| |
| Args: |
| token: a string, potentially including the algorithm regex. |
| |
| Returns: |
| in case the regex matched returns a tri-tuple of two strings (prefix and |
| suffix, either one could be empty) and a list of matching algorithms |
| from the algorithm descriptors table. If there has been no match - |
| returns None. |
| """ |
| elements = self._alg_macro.split(token) |
| if len(elements) == 3: |
| # The token matched the algorithm regex, Find out prefix and suffix to |
| # be used on the generated type names, and the algorithm regex suffix to |
| # use to find matching entries in the algorithm table. |
| name_prefix, alg_suffix, name_suffix = tuple(elements) |
| name_prefix = name_prefix.strip('_') |
| name_suffix = name_suffix.strip('_') |
| return name_prefix, name_suffix, self._PickAlgEntries(alg_suffix) |
| |
| def _ProcessInterface(self, type_name): |
| """Processes spec tables describing interfaces.""" |
| result = self._ParseAlgorithmRegex(type_name) |
| if result: |
| name_prefix, name_suffix, alg_list = tuple(result) |
| # Process all matching algorithm types |
| for alg_desc in alg_list: |
| alg_base = alg_desc[0].replace('TPM_ALG_', '') |
| new_name = '_'.join([name_prefix, |
| alg_base, name_suffix]).strip('_') |
| new_if = Interface(self._title_type, new_name) |
| self._AddTypedef(self._title_type, new_name) |
| for row in self._body: |
| new_value = row[0] |
| if new_value.startswith('$!ALG'): |
| new_if.supported_values = alg_base + '_' + '_'.join( |
| new_value.split('_')[1:]) |
| elif new_value.startswith('$'): |
| new_if.supported_values = new_value[1:] |
| elif new_value.startswith('#'): |
| new_if.error_code = new_value[1:] |
| self._type_map[new_name] = new_if |
| self._AddToHfile('\n') |
| return |
| new_if = Interface(self._title_type, type_name) |
| self._AddTypedef(self._title_type, type_name) |
| self._type_map[type_name] = new_if |
| self._SetBaseType(type_name, new_if) |
| for row in self._body: |
| new_value = row[0] |
| result = self._ParseAlgorithmRegex(new_value) |
| if result: |
| # The field is described using the algorithm regex. The above comment |
| # applies. |
| name_prefix, name_suffix, alg_list = tuple(result) |
| for alg_desc in alg_list: |
| alg_base = alg_desc[0].replace('TPM_ALG_', '') |
| new_if.valid_values.append('_'.join( |
| [name_prefix, alg_base, name_suffix]).strip('_')) |
| else: |
| if new_value.startswith('{'): |
| bounds = tuple( |
| [x.strip() for x in new_value[1:-1].strip().split(':')]) |
| new_if.bounds.append(bounds) |
| elif new_value.startswith('+'): |
| new_if.conditional_value = new_value[1:] |
| elif new_value.startswith('#'): |
| new_if.error_code = new_value[1:] |
| elif new_value.startswith('$'): |
| new_if.supported_values = new_value[1:] |
| else: |
| new_if.valid_values.append(new_value) |
| return |
| |
| def _ProcessTypedefs(self, type_name): |
| """Processes spec tables defining new types.""" |
| result = self._ParseAlgorithmRegex(type_name) |
| if result: |
| name_prefix, name_suffix, alg_list = tuple(result) |
| for alg_desc in alg_list: |
| alg_base = alg_desc[0].replace('TPM_ALG_', '') |
| new_type = '%s_%s_%s' % (name_prefix, alg_base, name_suffix) |
| self._AddTypedef(self._title_type, new_type) |
| self._AddToHfile('\n') |
| else: |
| self._AddTypedef(self._title_type, type_name) |
| |
| def _ProcessBits(self, type_name): |
| """Processes spec tables describing attributes (bit fields).""" |
| bits_lines = [] |
| base_bit = 0 |
| tpm_obj = AttributeStructure(self._title_type, type_name) |
| self._type_map[type_name] = tpm_obj |
| self._SetBaseType(self._title_type, tpm_obj) |
| for bits_line in self._body: |
| field, name = tuple(bits_line[:2]) |
| if not field: |
| continue |
| if name.startswith('TPM_'): |
| # Spec inconsistency fix. |
| name_pieces = [x.lower() for x in name.split('_')[1:]] |
| name = name_pieces[0] |
| for piece in name_pieces[1:]: |
| name += piece[0].upper() + piece[1:] |
| bit_range = [x.replace(' ', '') for x in field.split(':')] |
| field_base = int(bit_range[-1]) |
| if field_base != base_bit: |
| field_name = 'reserved%d' % base_bit |
| field_width = field_base - base_bit |
| if field_width > 1: |
| field_name += '_%d' % (field_base - 1) |
| bits_lines.append(['%s : %d' % (field_name, field_width)]) |
| tpm_obj.reserved.append(field_name.replace('reserved', '')) |
| if len(bit_range) > 1: |
| field_width = int(bit_range[0]) - field_base + 1 |
| else: |
| field_width = 1 |
| if re.match('reserved', name, re.IGNORECASE): |
| name = 'reserved%d' % field_base |
| if field_width > 1: |
| name += '_%d' % (field_base + field_width - 1) |
| tpm_obj.reserved.append(name.replace('reserved', '')) |
| bits_lines.append([name, ': %d' % field_width]) |
| base_bit = field_base + field_width |
| max_type_len, _ = self._GetMaxLengths(bits_lines) |
| self._AddToHfile('typedef struct {') |
| for bits_line in bits_lines: |
| self._AddToHfile(' %s %-*s %s;' % (self._title_type, max_type_len, |
| bits_line[0], bits_line[1])) |
| self._AddToHfile('} %s;\n' % type_name) |
| |
| def _ExpandAlgs(self, row): |
| """Find all algorithms encoded in the variable name. |
| |
| Args: |
| row: a list of strings, a row of a structure or union table scraped from |
| part 2. |
| |
| Returns: |
| A list for structure_generator.Field objects, one per expanded |
| algorithm. |
| |
| """ |
| alg_spec = row[0].split() |
| expansion = [] |
| m = self._alg_macro.search(alg_spec[0]) |
| if m: |
| alg_type = m.groups()[0] |
| # Find all algorithms of this type in the alg id table |
| alg_entries = self._PickAlgEntries(alg_type) |
| if len(alg_spec) == 2 and alg_spec[1][0] == '[': |
| # This is the case of a union of arrays. |
| raw_size_parts = self._alg_macro.split(alg_spec[1][1:-1]) |
| size_prefix = raw_size_parts[0].strip('_') |
| size_suffix = raw_size_parts[2].strip('_') |
| for alg_desc in alg_entries: |
| alg_base = alg_desc[0].replace('TPM_ALG_', '') |
| size = '_'.join([size_prefix, alg_base, size_suffix]).strip('_') |
| if self._has_selector_column: |
| selector_parts = self._alg_macro.split(row[2]) |
| selector_prefix = selector_parts[0].strip('_') |
| selector_suffix = selector_parts[2].strip('_') |
| selector = '_'.join([selector_prefix, |
| alg_base, selector_suffix]).strip('_') |
| else: |
| selector = '' |
| expansion.append(Field(row[1], alg_base.lower(), |
| selector=selector, array_size=size)) |
| else: |
| type_prefix, type_suffix = self._SplitByAlg(row[1]) |
| if self._has_selector_column: |
| selector_prefix, selector_suffix = self._SplitByAlg(row[2]) |
| else: |
| selector = '' |
| for alg_desc in alg_entries: |
| alg_base = alg_desc[0].replace('TPM_ALG_', '') |
| if type_suffix is not None: |
| var_type = '_'.join([type_prefix, alg_base, type_suffix]).strip('_') |
| else: |
| var_type = type_prefix |
| if self._has_selector_column: |
| selector = '_'.join([selector_prefix, alg_base, |
| selector_suffix]).strip('_') |
| expansion.append(Field(var_type, alg_base.lower(), |
| selector=selector)) |
| return expansion |
| |
| def _ProcessInterfaceOrType(self, type_name): |
| if type_name.startswith('TPMI_'): |
| self._ProcessInterface(type_name) |
| else: |
| self._ProcessTypedefs(type_name) |
| |
| def _StructOrUnionToHfile(self, body_fields, type_name, union_mode, tpm_obj): |
| body_lines = [] |
| for field in body_fields: |
| tpm_obj.AddField(field) |
| body_lines.append([field.field_type, field.field_name]) |
| if field.array_size: |
| body_lines[-1][-1] += '[%s]' % field.array_size |
| if field.selector_value: |
| body_lines[-1].append(field.selector_value) |
| max_type_len, _ = self._GetMaxLengths(body_lines) |
| tpm2b_mode = type_name.startswith('TPM2B_') |
| space_prefix = '' |
| if union_mode: |
| self._AddToHfile('typedef union {') |
| else: |
| if tpm2b_mode: |
| self._AddToHfile('typedef union {') |
| space_prefix = ' ' |
| self._AddToHfile(' struct {') |
| else: |
| self._AddToHfile('typedef struct {') |
| for line in body_lines: |
| guard_required = len(line) > 2 and line[2].startswith('TPM_ALG_') |
| if not line[1]: |
| continue |
| if guard_required: |
| self._AddToHfile('#ifdef %s' % line[2]) |
| self._AddToHfile(space_prefix + ' %-*s %s;' % ( |
| max_type_len, line[0], line[1])) |
| if guard_required: |
| self._AddToHfile('#endif') |
| if tpm2b_mode: |
| self._AddToHfile(' } t;') |
| self._AddToHfile(' TPM2B b;') |
| self._AddToHfile('} %s;\n' % type_name) |
| self._type_map[type_name] = tpm_obj |
| |
| |
| def _ProcessStructureOrUnion(self, type_name): |
| """Processes spec tables describing structure and unions. |
| |
| Both of these object types share a lot of similarities. Union types have |
| the word 'Union' in the table title. |
| |
| Args: |
| type_name: a string, name of the TPM object type |
| """ |
| union_mode = 'Union' in self._title |
| if union_mode: |
| tpm_obj = Union(type_name) |
| else: |
| tpm_obj = Structure(type_name) |
| body_fields = [] |
| for row in self._body: |
| if row[0].startswith('#'): |
| tpm_obj.error_code = row[0][1:] |
| continue |
| if (len(row) < 2 or |
| row[1].startswith('#') or |
| row[0].startswith('//')): |
| continue |
| value = row[0] |
| if value.endswith('='): |
| value = value[:-1] |
| tpm_obj.size_check = True |
| if self._alg_macro.search(value): |
| body_fields.extend(self._ExpandAlgs(row)) |
| continue |
| array_size = None |
| run_time_size = None |
| vm = re.search(r'^(\S+)\s*\[(\S+)\]\s*\{(.*:*)\}', value) |
| selector = '' |
| if vm: |
| value, run_time_size, bounds = vm.groups() |
| lower, upper = [x.strip() for x in bounds.split(':')] |
| if upper: |
| array_size = upper |
| tpm_obj.AddUpperBound(run_time_size, upper) |
| else: |
| array_size = run_time_size |
| if lower: |
| tpm_obj.AddLowerBound(run_time_size, lower) |
| else: |
| vm = re.search(r'^\[(\S+)\]\s*(\S+)', value) |
| if vm: |
| selector, value = vm.groups() |
| else: |
| vm = re.search(r'^(\S+)\s*\{(.+)\}', value) |
| if vm: |
| value, bounds = vm.groups() |
| if ':' in bounds: |
| lower, upper = [x.strip() for x in bounds.split(':')] |
| if upper: |
| tpm_obj.AddUpperBound(value, upper) |
| if lower: |
| tpm_obj.AddLowerBound(value, lower) |
| if self._has_selector_column: |
| selector = row[2] |
| field_type = row[1] |
| if field_type.startswith('+') or field_type.endswith('+'): |
| field_type = field_type.strip('+') |
| conditional = 'TRUE' |
| else: |
| conditional = 'FALSE' |
| if field_type or value: |
| body_fields.append(Field(field_type, |
| value, |
| array_size=array_size, |
| run_time_size=run_time_size, |
| selector=selector, |
| conditional_value=conditional)) |
| |
| self._StructOrUnionToHfile(body_fields, type_name, union_mode, tpm_obj) |
| |
| def _ProcessEnum(self, _): |
| """Processes spec tables describing enums.""" |
| if self._skip_printing: |
| return |
| self._AddToHfile('enum {') |
| for value, row in enumerate(self._body): |
| self._AddToHfile(' %s = %d,' % (row[0], value + 1)) |
| self._AddToHfile('};\n') |
| |
| def _ProcessTypes(self, _): |
| """Processes spec tables describing new types.""" |
| for type_, name_, _ in self._body: |
| m = self._alg_macro.search(name_) |
| if not m: |
| self._AddTypedef(type_, name_) |
| continue |
| qualifier = [x for x in ('ECC', 'RSA') if x == type_.split('_')[-1]] |
| alg_suffix = m.groups()[0] |
| type_base = self._alg_macro.split(name_)[0] |
| for alg_desc in self._PickAlgEntries(alg_suffix): |
| if qualifier and alg_desc[2] != qualifier[0]: |
| continue |
| self._AddTypedef(type_, alg_desc[0].replace('TPM_ALG_', type_base)) |
| self._AddToHfile() |
| |
| def _ProcessConstants(self, type_name): |
| """Processes spec tables describing constants.""" |
| if self._title_type: |
| self._AddTypedef(self._title_type, type_name) |
| constant_defs = [] |
| tpm_obj = ConstantType(self._title_type, type_name) |
| for row in self._body: |
| name = row[0].strip() |
| if not name: |
| continue |
| if name.startswith('#'): |
| tpm_obj.error_code = name[1:] |
| continue |
| if name == 'reserved' or len(row) < 2: |
| continue |
| value = row[1].strip() |
| rm = re.match(r'^(\(.*?\))', value) |
| if rm: |
| value = '%s' % rm.groups()[0] |
| else: |
| v_list = value.split() |
| if len(v_list) > 2 and v_list[1] == '+': |
| value = '((%s)(%s))' % (type_name, ' '.join(v_list[:3])) |
| if ' ' in value and not value.startswith('('): |
| value = '(%s)' % value |
| constant_defs.append([name, value]) |
| tpm_obj.valid_values.append(name) |
| if self._title_type: |
| self._type_map[type_name] = tpm_obj |
| self._SetBaseType(self._title_type, tpm_obj) |
| if self._skip_printing: |
| return |
| max_name_len, max_value_len = self._GetMaxLengths(constant_defs) |
| for row in constant_defs: |
| self._AddToHfile('#define %-*s %*s' % (max_name_len, row[0], |
| max_value_len, row[1])) |
| self._AddToHfile() |
| |
| def GetHFile(self): |
| return self._h_file |
| |
| def GetCommandList(self): |
| return sorted(self._command_map.values(), |
| cmp=lambda x, y: cmp(x.name, y.name)) |
| |
| def GetTypeMap(self): |
| return self._type_map |
