def handle_interface_table(self, table, tpm_alg_ids):
        base_type = utils.find_tpm_base_type_name(table.short_name)
        new_type = utils.find_tpm_type_name(table.short_name)

        typedef_statement = "typedef  " + base_type + utils.indent(base_type) + new_type + ";\n"
        alg_dep = utils.find_alg_constraints(table.name)
        if alg_dep:
            alg_name = "TPM_ALG_" + alg_dep
            typedef_statement_alg_dep = ""

            # check for !ALG
            alg_ids_list = utils.expand_alg_macro(new_type, tpm_alg_ids, alg_dep)
            # if new type name contains algorithm type, create type definition for all corresponding IDs
            for alg in alg_ids_list:
                alg_name = alg.name
                final_new_type = utils.replace_alg_placeholder(new_type, alg.short_name)
                typedef_statement_alg_dep += "#ifdef      " + alg_name + "\n"  # for each algorithm
                typedef_statement_alg_dep += "typedef  " + base_type + utils.indent(base_type) + final_new_type + ";\n"
                typedef_statement_alg_dep += "#endif   // " + alg_name + "\n"  # for each algorithm

            # in case there is no !ALG, create type definition for type found in table name
            if not typedef_statement_alg_dep:
                typedef_statement_alg_dep = "#ifdef      " + alg_name + "\n"
                typedef_statement_alg_dep += "typedef  " + base_type + utils.indent(base_type) + new_type + ";\n"
                typedef_statement_alg_dep += "#endif   // " + alg_name + "\n"

            typedef_statement = typedef_statement_alg_dep

        self.tpm_types_h_file_content += typedef_statement

        self.marshaller.handle_interface_table(table, tpm_alg_ids)
Esempio n. 2
0
    def handle_typedef_table(self, table, tpm_alg_ids):
        table_dependence = utils.find_alg_constraints(table.short_name)
        if table_dependence:  # if table dependence {*} found in table name
            self.tpm_types_h_file_content += "#ifdef      TPM_ALG_" + table_dependence + "\n"

        for row in table.rows:
            base_type = row[0]
            name = row[1]

            # check for !ALG
            alg_ids_list = utils.expand_alg_macro(name, tpm_alg_ids,
                                                  table_dependence)
            # if new type name contains algorithm type, create type definition for all corresponding IDs
            if alg_ids_list:
                for alg in alg_ids_list:
                    new_type = utils.replace_alg_placeholder(
                        name, alg.short_name)
                    self.tpm_types_h_file_content += "typedef  " + base_type + utils.indent(
                        base_type) + new_type + ";\n"
            else:  # else create type definition for table name
                self.tpm_types_h_file_content += "typedef  " + base_type + utils.indent(
                    base_type) + name + ";\n"
        # end of loop - for row in table.rows:

        if table_dependence:  # if table dependence {*} found in table name
            self.tpm_types_h_file_content += "#endif   // TPM_ALG_" + table_dependence + "\n"
        # end of if else - if table dependence found

        self.marshaller.handle_simple_type_structures_new(table, tpm_alg_ids)
    def handle_typedef_table(self, table, tpm_alg_ids):
        table_dependence = utils.find_alg_constraints(table.short_name)
        if table_dependence:  # if table dependence {*} found in table name
            self.tpm_types_h_file_content += "#ifdef      TPM_ALG_" + table_dependence + "\n"

        for row in table.rows:
            base_type = row[0]
            name = row[1]

            # check for !ALG
            alg_ids_list = utils.expand_alg_macro(name, tpm_alg_ids, table_dependence)
            # if new type name contains algorithm type, create type definition for all corresponding IDs
            if alg_ids_list:
                for alg in alg_ids_list:
                    new_type = utils.replace_alg_placeholder(name, alg.short_name)
                    self.tpm_types_h_file_content += "typedef  " + base_type + utils.indent(base_type) + new_type + ";\n"
            else:  # else create type definition for table name
                self.tpm_types_h_file_content += "typedef  " + base_type + utils.indent(base_type) + name + ";\n"
        # end of loop - for row in table.rows:

        if table_dependence:  # if table dependence {*} found in table name
            self.tpm_types_h_file_content += "#endif   // TPM_ALG_" + table_dependence + "\n"
        # end of if else - if table dependence found

        self.marshaller.handle_simple_type_structures_new(table, tpm_alg_ids)
Esempio n. 4
0
    def handle_typedef_union(self, table, typedef_name, tpm_alg_ids):
        self.tpm_types_h_file_content += "typedef union {\n"

        for row in table.rows:
            parameter = row[0]
            member_type = row[1].replace("+", "")
            selector = row[2]

            if member_type == "" or "null" in parameter:
                continue

            member_string = ""

            # check for !ALG (algorithm type)
            algs = utils.expand_alg_macro(parameter, tpm_alg_ids)
            for alg in algs:
                dependence = alg.dependence
                if len(dependence) == 0:
                    dependence = alg.short_name

                alg_placeholder = selector.replace("TPM_ALG_", "")  # !ALG.*
                base_type = utils.replace_alg_placeholder(
                    member_type, alg.short_name.upper())
                new_type = parameter.replace(
                    alg_placeholder + "_DIGEST_SIZE",
                    alg.short_name.upper() + "_DIGEST_SIZE").replace(" ", "")

                if alg_placeholder == "!ALG":  # fix for Table 2:144
                    new_type = alg.short_name.lower()
                else:
                    new_type = new_type.replace(alg_placeholder,
                                                alg.short_name.lower())

                member_string += "#ifdef      TPM_ALG_" + dependence + "\n"
                member_string += "    " + base_type + utils.indent(
                    member_type) + new_type + ";\n"
                member_string += "#endif   // TPM_ALG_" + dependence + "\n"
            # end of loop - for alg in algs:

            # in case there is no !ALG
            if not member_string:
                member_string = "    " + member_type + utils.indent(
                    member_type) + parameter + ";\n"

                if selector:  # enclose with ifdef + endif
                    member_string = "#ifdef      " + selector + "\n" + member_string
                    member_string += "#endif   // " + selector + "\n"
            # end of if - if not member_string:

            self.tpm_types_h_file_content += member_string
        # end of loop - for row in table.rows:
        self.tpm_types_h_file_content += "} " + typedef_name + ";\n"

        self.marshaller.handle_union_table(table, tpm_alg_ids)
    def handle_typedef_union(self, table, typedef_name, tpm_alg_ids):
        self.tpm_types_h_file_content += "typedef union {\n"

        for row in table.rows:
            parameter = row[0]
            member_type = row[1].replace("+", "")
            selector = row[2]

            if member_type == "" or "null" in parameter:
                continue

            member_string = ""

            # check for !ALG (algorithm type)
            algs = utils.expand_alg_macro(parameter, tpm_alg_ids)
            for alg in algs:
                dependence = alg.dependence
                if len(dependence) == 0:
                    dependence = alg.short_name

                alg_placeholder = selector.replace("TPM_ALG_", "")  # !ALG.*
                base_type = utils.replace_alg_placeholder(member_type, alg.short_name.upper())
                new_type = parameter.replace(alg_placeholder + "_DIGEST_SIZE", alg.short_name.upper() + "_DIGEST_SIZE").replace(" ", "")

                if alg_placeholder == "!ALG": # fix for Table 2:144
                    new_type = alg.short_name.lower()
                else:
                    new_type = new_type.replace(alg_placeholder, alg.short_name.lower())

                member_string += "#ifdef      TPM_ALG_" + dependence + "\n"
                member_string += "    " + base_type + utils.indent(member_type) + new_type + ";\n"
                member_string += "#endif   // TPM_ALG_" + dependence + "\n"
            # end of loop - for alg in algs:

            # in case there is no !ALG
            if not member_string:
                member_string = "    " + member_type + utils.indent(member_type) + parameter + ";\n"

                if selector:  # enclose with ifdef + endif
                    member_string = "#ifdef      " + selector + "\n" + member_string
                    member_string += "#endif   // " + selector + "\n"
            # end of if - if not member_string:

            self.tpm_types_h_file_content += member_string
        # end of loop - for row in table.rows:
        self.tpm_types_h_file_content += "} " + typedef_name + ";\n"

        self.marshaller.handle_union_table(table, tpm_alg_ids)
Esempio n. 6
0
    def handle_interface_table(self, table, tpm_alg_ids):
        base_type = utils.find_tpm_base_type_name(table.short_name)
        new_type = utils.find_tpm_type_name(table.short_name)

        typedef_statement = "typedef  " + base_type + utils.indent(
            base_type) + new_type + ";\n"
        alg_dep = utils.find_alg_constraints(table.name)
        if alg_dep:
            alg_name = "TPM_ALG_" + alg_dep
            typedef_statement_alg_dep = ""

            # check for !ALG
            alg_ids_list = utils.expand_alg_macro(new_type, tpm_alg_ids,
                                                  alg_dep)
            # if new type name contains algorithm type, create type definition for all corresponding IDs
            for alg in alg_ids_list:
                alg_name = alg.name
                final_new_type = utils.replace_alg_placeholder(
                    new_type, alg.short_name)
                typedef_statement_alg_dep += "#ifdef      " + alg_name + "\n"  # for each algorithm
                typedef_statement_alg_dep += "typedef  " + base_type + utils.indent(
                    base_type) + final_new_type + ";\n"
                typedef_statement_alg_dep += "#endif   // " + alg_name + "\n"  # for each algorithm

            # in case there is no !ALG, create type definition for type found in table name
            if not typedef_statement_alg_dep:
                typedef_statement_alg_dep = "#ifdef      " + alg_name + "\n"
                typedef_statement_alg_dep += "typedef  " + base_type + utils.indent(
                    base_type) + new_type + ";\n"
                typedef_statement_alg_dep += "#endif   // " + alg_name + "\n"

            typedef_statement = typedef_statement_alg_dep

        self.tpm_types_h_file_content += typedef_statement

        self.marshaller.handle_interface_table(table, tpm_alg_ids)
    def handle_simple_type_structures_new(self, table, tpm_alg_ids=None):

        self.create_header_comment(table)

        for row in table.rows:
            base_type = row[0]
            new_type = row[1]

            types_list = []

            # check for !ALG
            alg_dep = utils.find_alg_constraints(table.short_name)
            algs = utils.expand_alg_macro(new_type, tpm_alg_ids, alg_dep)
            for alg in algs:
                typedef = utils.replace_alg_placeholder(new_type, alg.short_name)
                types_list.append(typedef)
            # end of loop - for alg in alg_list:

            # in case there is no !ALG
            if not algs:
                types_list = [new_type]

            # handle the (list of) typ(es) in the current row
            for current_type in types_list:

                if alg_dep:
                    self.content += tpm2_partx_marshal_templates.IFDEF_ALG.format(alg_dep)
                    self.content_fp += tpm2_partx_marshal_templates.IFDEF_ALG.format(alg_dep)

                # check if type is a C base type and already in mapping dictionary
                base_type, c_base_type = self.handle_base_types(base_type)

                already_marshaled = base_type in tpm2_partx_type_mapping.dictionary.keys()
                unsigned_marshaled = "u"+base_type in tpm2_partx_type_mapping.dictionary.keys()

                if unsigned_marshaled:
                    base_type = "u"+base_type
                
                if c_base_type or already_marshaled or unsigned_marshaled:
                    # if original type was already marshaled somehow
                    # marshalling new type would be redundant - change to define for new type
                    orig_mrshl = tpm2_partx_type_mapping.dictionary[base_type]
                    orig_table_nr = orig_mrshl[1]

                    # recursive exploration of most basic base_type in mapping dictionary
                    base_type = utils.find_basic_base_type(base_type)

                    # add a comment that points to the origin of the type definition
                    self.content += "//   " + base_type + " definition used from Table 2:" + orig_table_nr + "\n"

                    self.content += tpm2_partx_marshal_templates.COMMENT_TYPE_Unmarshal_defined.format(current_type)
                    self.content += tpm2_partx_marshal_templates.COMMENT_TYPE_Marshal_defined.format(current_type)

                    self.content_fp += self.simple_marshaller.create_unmarshal_fp_define(current_type, base_type)
                    self.content_fp += self.simple_marshaller.create_marshal_fp_define(current_type, base_type)

                else:
                    # handle base types: figure out the size
                    size = utils.find_base_type_size(base_type)
                    if not size:  # skip base type without size (i.e. 'int', which is used for 'BOOL')
                        continue

                    self.content += self.simple_marshaller.create_unmarshal_code(current_type, int(size)/8)
                    self.content += self.simple_marshaller.create_marshal_code(current_type, int(size)/8)

                    self.content_fp += self.simple_marshaller.create_unmarshal_fp(current_type)
                    self.content_fp += self.simple_marshaller.create_marshal_fp(current_type)

                if unsigned_marshaled:
                    base_type = base_type[1:]

                tpm2_partx_type_mapping.dictionary[current_type] = [base_type, table.number]
                # done with the new type

                if alg_dep:
                    self.content += tpm2_partx_marshal_templates.ENDIF_ALG.format(alg_dep)
                    self.content_fp += tpm2_partx_marshal_templates.ENDIF_ALG.format(alg_dep)

                self.content += "\n"
                self.content_fp += "\n"
Esempio n. 8
0
    def handle_simple_type_structures_new(self, table, tpm_alg_ids=None):

        self.create_header_comment(table)

        for row in table.rows:
            base_type = row[0]
            new_type = row[1]

            types_list = []

            # check for !ALG
            alg_dep = utils.find_alg_constraints(table.short_name)
            algs = utils.expand_alg_macro(new_type, tpm_alg_ids, alg_dep)
            for alg in algs:
                typedef = utils.replace_alg_placeholder(
                    new_type, alg.short_name)
                types_list.append(typedef)
            # end of loop - for alg in alg_list:

            # in case there is no !ALG
            if not algs:
                types_list = [new_type]

            # handle the (list of) typ(es) in the current row
            for current_type in types_list:

                if alg_dep:
                    self.content += tpm2_partx_marshal_templates.IFDEF_ALG.format(
                        alg_dep)
                    self.content_fp += tpm2_partx_marshal_templates.IFDEF_ALG.format(
                        alg_dep)

                # check if type is a C base type and already in mapping dictionary
                base_type, c_base_type = self.handle_base_types(base_type)

                already_marshaled = base_type in tpm2_partx_type_mapping.dictionary.keys(
                )
                unsigned_marshaled = "u" + base_type in tpm2_partx_type_mapping.dictionary.keys(
                )

                if unsigned_marshaled:
                    base_type = "u" + base_type

                if c_base_type or already_marshaled or unsigned_marshaled:
                    # if original type was already marshaled somehow
                    # marshalling new type would be redundant - change to define for new type
                    orig_mrshl = tpm2_partx_type_mapping.dictionary[base_type]
                    orig_table_nr = orig_mrshl[1]

                    # recursive exploration of most basic base_type in mapping dictionary
                    base_type = utils.find_basic_base_type(base_type)

                    # add a comment that points to the origin of the type definition
                    self.content += "//   " + base_type + " definition used from Table 2:" + orig_table_nr + "\n"

                    self.content += tpm2_partx_marshal_templates.COMMENT_TYPE_Unmarshal_defined.format(
                        current_type)
                    self.content += tpm2_partx_marshal_templates.COMMENT_TYPE_Marshal_defined.format(
                        current_type)

                    self.content_fp += self.simple_marshaller.create_unmarshal_fp_define(
                        current_type, base_type)
                    self.content_fp += self.simple_marshaller.create_marshal_fp_define(
                        current_type, base_type)

                else:
                    # handle base types: figure out the size
                    size = utils.find_base_type_size(base_type)
                    if not size:  # skip base type without size (i.e. 'int', which is used for 'BOOL')
                        continue

                    self.content += self.simple_marshaller.create_unmarshal_code(
                        current_type,
                        int(size) / 8)
                    self.content += self.simple_marshaller.create_marshal_code(
                        current_type,
                        int(size) / 8)

                    self.content_fp += self.simple_marshaller.create_unmarshal_fp(
                        current_type)
                    self.content_fp += self.simple_marshaller.create_marshal_fp(
                        current_type)

                if unsigned_marshaled:
                    base_type = base_type[1:]

                tpm2_partx_type_mapping.dictionary[current_type] = [
                    base_type, table.number
                ]
                # done with the new type

                if alg_dep:
                    self.content += tpm2_partx_marshal_templates.ENDIF_ALG.format(
                        alg_dep)
                    self.content_fp += tpm2_partx_marshal_templates.ENDIF_ALG.format(
                        alg_dep)

                self.content += "\n"
                self.content_fp += "\n"