tools/manifest_tools/manifest_parser.py

"""
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the MIT license.
"""

from __future__ import print_function
from __future__ import unicode_literals
import re
import binascii
import traceback
import xml.etree.ElementTree as et
import manifest_types


XML_ATTESTATION_FAIL_RETRY_ATTRIB = "attestation_fail_retry"
XML_ATTESTATION_PROTOCOL_ATTRIB = "attestation_protocol"
XML_ATTESTATION_SUCCESS_RETRY_ATTRIB = "attestation_success_retry"
XML_ATTESTATION_RSP_NOT_READY_MAX_RETRY_ATTRIB = "attestation_rsp_not_ready_max_retry"
XML_ATTESTATION_RSP_NOT_READY_MAX_DURATION_ATTRIB = "attestation_rsp_not_ready_max_duration"
XML_CONNECTION_ATTRIB = "connection"
XML_COUNT_ATTRIB = "count"
XML_DISCOVERY_FAIL_RETRY_ATTRIB = "discovery_fail_retry"
XML_EMPTY_ATTRIB = "empty"
XML_ENTRY_ID_ATTRIB = "entry_id"
XML_ID_ATTRIB = "id"
XML_INDEX_ATTRIB = "index"
XML_MEASUREMENT_ID_ATTRIB = "measurement_id"
XML_LEVEL_ATTRIB = "level"
XML_MCTP_BRIDGE_ADDITIONAL_TIMEOUT_ATTRIB= "mctp_bridge_additional_timeout"
XML_MCTP_BRIDGE_GET_TABLE_WAIT_ATTRIB = "mctp_bridge_get_table_wait"
XML_MCTP_CTRL_TIMEOUT_ATTRIB = "mctp_ctrl_timeout"
XML_MEASUREMENT_HASH_TYPE_ATTRIB = "measurement_hash_type"
XML_PLATFORM_ATTRIB = "platform"
XML_PMR_ID_ATTRIB = "pmr_id"
XML_PORT_ATTRIB = "port"
XML_SKU_ATTRIB = "sku"
XML_SLOT_NUM_ATTRIB = "slot_num"
XML_TRANSCRIPT_HASH_TYPE_ATTRIB = "transcript_hash_type"
XML_TYPE_ATTRIB = "type"
XML_VERSION_ATTRIB = "version"

XML_ACTIVE_TAG = "Active"
XML_ADDRESS_TAG = "Address"
XML_ALLOWABLE_CFM_TAG = "AllowableCFM"
XML_ALLOWABLE_DATA_TAG = "AllowableData"
XML_ALLOWABLE_PCD_TAG = "AllowablePCD"
XML_ALLOWABLE_PFM_TAG = "AllowablePFM"
XML_BITMASK_TAG = "Bitmask"
XML_BRIDGE_ADDRESS_TAG = "BridgeAddress"
XML_BRIDGE_EID_TAG = "BridgeEID"
XML_BUS_TAG = "Bus"
XML_CHANNEL_TAG = "Channel"
XML_CHECK_TAG = "Check"
XML_COMPONENT_TAG = "Component"
XML_CFM_COMPONENT_TAG = "CFMComponent"
XML_COMPONENTS_TAG = "Components"
XML_DATA_TAG = "Data"
XML_DEVICE_ID_TAG = "DeviceID"
XML_DEVICETYPE_TAG = "DeviceType"
XML_DIGEST_TAG = "Digest"
XML_EID_TAG = "EID"
XML_END_ADDR_TAG = "EndAddr"
XML_ENDIANNESS_TAG = "Endianness"
XML_FAILURE_ACTION_TAG = "FailureAction"
XML_FW_TAG = "Firmware"
XML_FLASHMODE_TAG = "FlashMode"
XML_HASH_TAG = "Hash"
XML_HASH_TYPE_TAG = "HashType"
XML_HOSTRESETACTION_TAG = "HostResetAction"
XML_I2CMODE_TAG = "I2CMode"
XML_ID_TAG = "ID"
XML_INITIAL_VALUE_TAG = "InitialValue"
XML_INTERFACE_TAG = "Interface"
XML_MASK_TAG = "Mask"
XML_MANIFEST_ID_TAG = "ManifestID"
XML_MEASUREMENT_TAG = "Measurement"
XML_MEASUREMENT_DATA_TAG = "MeasurementData"
XML_MUX_TAG = "Mux"
XML_MUXES_TAG = "Muxes"
XML_OPERATION_ON_FAILURE_TAG = "OperationOnFailure"
XML_PMR_TAG = "PMR"
XML_PMR_DIGEST_TAG = "PMRDigest"
XML_POLICY_TAG = "Policy"
XML_PORT_TAG = "Port"
XML_PORTS_TAG = "Ports"
XML_POWER_CONTROLLER_TAG = "PowerController"
XML_PB_KEY_TAG = "PublicKey"
XML_PULSEINTERVAL_TAG = "PulseInterval"
XML_PWRCTRL_TAG = "PwrCtrl"
XML_RW_TAG = "ReadWrite"
XML_REGION_TAG = "Region"
XML_REGISTER_TAG = "Register"
XML_RESETCTRL_TAG = "ResetCtrl"
XML_ROOT_CA_DIGEST_TAG = "RootCADigest"
XML_ROT_TAG = "RoT"
XML_ROT_EID_TAG = "RoTEID"
XML_RUNTIME_UPDATE_TAG = "RuntimeUpdate"
XML_RUNTIMEVERIFICATION_TAG = "RuntimeVerification"
XML_SIG_TAG = "Signature"
XML_IMG_TAG = "SignedImage"
XML_SPIFREQ_TAG = "SPIFreq"
XML_START_ADDR_TAG = "StartAddr"
XML_SUB_DEVICE_ID_TAG = "SubsystemDeviceID"
XML_SUB_VENDOR_ID_TAG = "SubsystemVendorID"
XML_UNUSED_BYTE_TAG = "UnusedByte"
XML_WATCHDOGMONITORING_TAG = "WatchdogMonitoring"
XML_VALIDATE_TAG = "ValidateOnBoot"
XML_VENDOR_ID_TAG = "VendorID"
XML_VERSION_TAG = "Version"
XML_VERSION_ADDR_TAG = "VersionAddr"

PCD_ROT_TYPE_PA_ROT = "PA-RoT"
PCD_ROT_TYPE_AC_ROT = "AC-RoT"
PCD_FLASH_MODE_SINGLE = "Single"
PCD_FLASH_MODE_DUAL = "Dual"
PCD_FLASH_MODE_SINGLE_FILTERED_BYPASS = "SingleFilteredBypass"
PCD_FLASH_MODE_DUAL_FILTERED_BYPASS = "DualFilteredBypass"
PCD_HOST_RESET_ACTION_NONE = "None"
PCD_HOST_RESET_ACTION_RESET_FLASH = "ResetFlash"
PCD_RESET_CTRL_NOTIFY = "Notify"
PCD_RESET_CTRL_RESET = "Reset"
PCD_RESET_CTRL_PULSE = "Pulse"
PCD_POLICY_ACTIVE = "Active"
PCD_POLICY_PASSIVE = "Passive"
PCD_INTERFACE_TYPE_I2C = "I2C"
PCD_INTERFACE_I2C_MODE_MM = "MultiMaster"
PCD_INTERFACE_I2C_MODE_MS = "MasterSlave"
PCD_COMPONENT_CONNECTION_DIRECT = "Direct"
PCD_COMPONENT_CONNECTION_MCTP_BRIDGE = "MCTPBridge"
PCD_ENABLED = "Enabled"
PCD_DISABLED = "Disabled"

CFM_CHECK_EQUAL = "Equal"
CFM_CHECK_NOT_EQUAL = "NotEqual"
CFM_CHECK_LESS_THAN = "LessThan"
CFM_CHECK_LESS_OR_EQUAL = "LessOrEqual"
CFM_CHECK_GREATER_THAN = "GreaterThan"
CFM_CHECK_GREATER_OR_EQUAL = "GreaterOrEqual"
CFM_ENDIANNESS_BIG_ENDIAN = "BigEndian"
CFM_ENDIANNESS_LITTLE_ENDIAN = "LittleEndian"


def xml_extract_attrib (root, attrib_name, string, xml_file, required=True):
    """
    Fetch attribute from an XML tag.

    :param root: XML tag to utilize
    :param attrib_name: Attribute to fetch
    :param string: A boolean indicating whether attribute value is expected to be a string
    :param xml_file: Filename of XML
    :param key: A boolean indicating whether attribute is required for a valid manifest XML

    :return Attribute value
    """

    attrib = root.attrib.get (attrib_name)
    if not attrib:
        if required:
            raise KeyError ("Missing {0} attribute in manifest {1}".format (attrib_name, xml_file))
        return None

    if string:
        attrib.encode ("utf8")

    return attrib.strip ()

def xml_find_single_tag (root, tag_name, xml_file, required=True):
    """
    Fetch an XML tag from XML.

    :param root: XML to utilize
    :param tag_name: Name of tag to fetch
    :param key: A boolean indicating whether tag is required for a valid manifest XML
    :param xml_file: Filename of XML

    :return Tag if found
    """

    tag = root.findall (tag_name)
    if not tag:
        if required:
            raise KeyError ("Missing {0} tag in manifest {1}".format (tag_name, xml_file))
        return None
    elif len (tag) > 1:
        raise ValueError ("Too many {0} tags in manifest {1}".format (tag_name, xml_file))

    return tag[0]

def xml_extract_single_value (root, requests, xml_file):
    """
    Fetch element values from XML tag.

    :param root: XML tag to utilize
    :param requests: A list of XML elements to get values of
    :param xml_file: Filename of XML

    :return Dictionary of elements and their values
    """

    result = {}

    for name, tag_name in requests.items ():
        tag = root.findall (tag_name)
        if not tag:
            raise KeyError ("Missing {0} tag in manifest {1}".format (tag_name, xml_file))
        elif len (tag) > 1:
            raise ValueError ("Too many {0} tags in manifest {1}".format (tag_name, xml_file))

        result.update ({name:tag[0].text.strip ()})

    return result

def process_pfm (root, xml_file):
    """
    Process PFM XML and generate list of element and attribute values.

    :param root: XML to utilize
    :param xml_file: Name of XML file to process

    :return List of PFM values, manifest version, a boolean False since PFM XMLs are never empty
    """

    def process_region (root, version_id, xml_file):
        region = {}

        addr = xml_find_single_tag (root, XML_START_ADDR_TAG, xml_file)
        region["start"] = addr.text.strip ()

        addr = xml_find_single_tag (root, XML_END_ADDR_TAG, xml_file)
        region["end"] = addr.text.strip ()

        return region

    xml = {}
    pfm_version = manifest_types.VERSION_1

    result = xml_extract_attrib (root, XML_VERSION_ATTRIB, True, xml_file)
    xml.update ({"version_id":result})

    result = xml_extract_attrib (root, XML_PLATFORM_ATTRIB, True, xml_file)
    xml.update ({"platform_id":result})

    firmware_type = xml_extract_attrib (root, XML_TYPE_ATTRIB, True, xml_file, False)
    if firmware_type is not None:
        pfm_version = manifest_types.VERSION_2
        xml["fw_type"] = firmware_type

        runtime_update = xml_find_single_tag (root, XML_RUNTIME_UPDATE_TAG, xml_file)

        xml["runtime_update"] = runtime_update.text.strip ().lower ()

    version_addr = xml_find_single_tag (root, XML_VERSION_ADDR_TAG, xml_file)

    xml["version_addr"] = version_addr.text.strip ()

    unused_byte = xml_find_single_tag (root, XML_UNUSED_BYTE_TAG, xml_file, False)
    if unused_byte is not None:
        xml["unused_byte"] = unused_byte.text.strip ()
    else:
        xml["unused_byte"] = "0xff"

    xml["rw_regions"] = []

    for rw in root.findall (XML_RW_TAG):
        for region in rw.findall (XML_REGION_TAG):
            processed_region = process_region (region, xml["version_id"], xml_file)
            if processed_region is None:
                raise ValueError ("Failed to process RW region")
            else:
                if pfm_version == manifest_types.VERSION_2:
                    fail_operation = xml_find_single_tag (region, XML_OPERATION_ON_FAILURE_TAG,
                        xml_file, False)
                    if fail_operation is None or fail_operation.text.strip () == "Nothing":
                        processed_region["operation_fail"] = "0x0"
                    elif fail_operation.text.strip () == "Erase":
                        processed_region["operation_fail"] = "0x2"
                    elif fail_operation.text.strip () == "Restore":
                        processed_region["operation_fail"] = "0x1"
                    else:
                        raise ValueError (
                            "Unknown operation on failure setting '{0}' for RW region (start: 0x{1}, end: 0x{2})".format (
                                fail_operation.text.strip (), processed_region["start"],
                                processed_region["end"]))

            xml["rw_regions"].append (processed_region)

    xml["signed_imgs"] = []

    for img in root.findall (XML_IMG_TAG):
        image = {}
        image["regions"] = []

        if pfm_version == manifest_types.VERSION_2:
            img_hash = xml_find_single_tag (img, XML_HASH_TAG, xml_file)
            image["hash"] = binascii.a2b_hex (re.sub ("\s", "", img_hash.text.strip ()))

            hash_type = xml_find_single_tag (img, XML_HASH_TYPE_TAG, xml_file, False)
            if hash_type is None or hash_type.text.strip () == "SHA256":
                image["hash_type"] = "0x0"
            elif hash_type.text.strip () == "SHA512":
                image["hash_type"] = "0x2"
            elif hash_type.text.strip () == "SHA384":
                image["hash_type"] = "0x1"
            else:
                raise ValueError ("Unknown hash type '{0}' in signed image".format (
                    hash_type.text.strip ()))
        else:
            pbkey = xml_find_single_tag (img, XML_PB_KEY_TAG, xml_file)
            image["pbkey"] = pbkey.text.strip ()

            sig = xml_find_single_tag (img, XML_SIG_TAG, xml_file)
            image["signature"] = binascii.a2b_hex (re.sub ("\s", "", sig.text.strip ()))

        for region in img.findall (XML_REGION_TAG):
            processed_region = process_region (region, xml["version_id"], xml_file)
            if processed_region is None:
                raise ValueError ("Failed to process signed image")

            image["regions"].append (processed_region)

        if not image["regions"]:
            raise ValueError ("No regions found for SignedImage, firmware: {0}".format (
                xml["version_id"]))

        prop = xml_find_single_tag (img, XML_VALIDATE_TAG, xml_file)
        image["validate"] = prop.text.strip ()

        xml["signed_imgs"].append (image)

    if not xml["signed_imgs"]:
        raise ValueError ("No signed images found for firmware: {0}".format (xml["version_id"]))

    return xml, pfm_version, False

def process_cfm_check (root, manifest_name, component_type, xml_file):
    result = xml_extract_single_value (root, {"check": XML_CHECK_TAG}, xml_file)
    if result["check"] is None or result["check"] == CFM_CHECK_EQUAL:
        return 0
    elif result["check"] == CFM_CHECK_NOT_EQUAL:
        return 1
    elif result["check"] == CFM_CHECK_LESS_THAN:
        return 2
    elif result["check"] == CFM_CHECK_LESS_OR_EQUAL:
        return 3
    elif result["check"] == CFM_CHECK_GREATER_THAN:
        return 4
    elif result["check"] == CFM_CHECK_GREATER_OR_EQUAL:
        return 5
    else:
        raise ValueError (
            "Unknown check type '{0}' in allowable {1} for component {2} in manifest {3}".format (
                result["check"], manifest_name, component_type, xml_file))

def process_cfm_allowable_manifest (root, manifest_name, component_type, xml_file):
    output = {}
    output["manifest_id"] = []

    for manifest_id in root.findall (XML_MANIFEST_ID_TAG):
        ids = []

        for id in manifest_id.findall (XML_ID_TAG):
            ids.append (int (id.text.strip (), 16))

        check = process_cfm_check (manifest_id, manifest_name, component_type, xml_file)

        endianness = 0
        endian_tag = xml_find_single_tag (manifest_id, XML_ENDIANNESS_TAG, xml_file, False)
        if endian_tag is not None:
            endian_text = endian_tag.text.strip ()
            if endian_text == CFM_ENDIANNESS_BIG_ENDIAN:
                endianness = 1

        output["manifest_id"].append ({"check": check, "endianness": endianness, "ids": ids})

    return output

def process_cfm (root, xml_file, selection_list):
    """
    Process CFM XML and generate list of element and attribute values.

    :param root: XML to utilize
    :param xml_file: Filename of XML
    :param selection_list: List of component types to include

    :return List of CFM values, manifest version, boolean for whether manifest is for an empty CFM
    """

    xml = {}

    component_type = xml_extract_attrib (root, XML_TYPE_ATTRIB, True, xml_file)
    component_type = component_type.strip ('\"')

    if component_type not in selection_list:
        return None, manifest_types.VERSION_2, False

    xml[component_type] = {}
    component = xml[component_type]

    component["unique"] = -1

    for element in root:
        if element.tag == "Measurement":
            component["unique"] = 0
            break

        if element.tag == "MeasurementData":
            component["unique"] = 1
            break

    result = xml_extract_attrib (root, XML_ATTESTATION_PROTOCOL_ATTRIB, True, xml_file)
    if result.lower () == "cerberus":
        component["attestation_protocol"] = 0
    elif result.lower () == "spdm":
        component["attestation_protocol"] = 1
    else:
        raise ValueError ("Component {0} has unknown attestation protocol '{1}' in {2}".format (
            component_type, result, xml_file))

    component["slot_num"] = int (xml_extract_attrib (root, XML_SLOT_NUM_ATTRIB, False, xml_file))

    result = xml_extract_attrib (root, XML_TRANSCRIPT_HASH_TYPE_ATTRIB, True, xml_file)
    if result == "SHA256":
        component["transcript_hash_type"] = 0
    elif result == "SHA384":
        component["transcript_hash_type"] = 1
    elif result == "SHA512":
        component["transcript_hash_type"] = 2
    else:
        raise ValueError ("Component {0} has unknown transcript hash type '{1}' in {2}".format (
            component_type, result, xml_file))

    result = xml_extract_attrib (root, XML_MEASUREMENT_HASH_TYPE_ATTRIB, True, xml_file)
    if result == "SHA256":
        component["measurement_hash_type"] = 0
    elif result == "SHA384":
        component["measurement_hash_type"] = 1
    elif result == "SHA512":
        component["measurement_hash_type"] = 2
    else:
        raise ValueError ("Component {0} has unknown measurement hash type '{1}' in {2}".format (
            component_type, result, xml_file))

    for root_ca_digests in root.findall (XML_ROOT_CA_DIGEST_TAG):
        if "root_ca_digests" in component:
            raise ValueError ("Component {0} has multiple root CA digest entries in {1}".format (
                component_type, xml_file))

        component["root_ca_digests"] = {}
        component["root_ca_digests"]["allowable_digests"] = []

        for allowable_digest in root_ca_digests.findall (XML_DIGEST_TAG):
            component["root_ca_digests"]["allowable_digests"].append (
                binascii.a2b_hex (re.sub ("\s", "", allowable_digest.text.strip ())))

    for pmr in root.findall (XML_PMR_TAG):
        if "pmr" not in component:
            component["pmr"] = {}

        pmr_id = int (xml_extract_attrib (pmr, XML_PMR_ID_ATTRIB, False, xml_file))

        if pmr_id in component["pmr"]:
            raise ValueError (
                "Too many PMR elements for PMR ID {0} for component {1} in manifest {2}".format (
                    pmr_id, component_type, xml_file))

        component["pmr"][pmr_id] = xml_extract_single_value (pmr,
            {"initial_value": XML_INITIAL_VALUE_TAG}, xml_file)

        component["pmr"][pmr_id]["initial_value"] = binascii.a2b_hex (
            re.sub ("\s", "", component["pmr"][pmr_id]["initial_value"]))

    for pmr_digest in root.findall (XML_PMR_DIGEST_TAG):
        if "pmr_digests" not in component:
            component["pmr_digests"] = {}

        pmr_id = int (xml_extract_attrib (pmr_digest, XML_PMR_ID_ATTRIB, False, xml_file))

        if pmr_id in component["pmr_digests"]:
            raise ValueError (
                "Too many rules for PMR ID {0} digests for component {1} in manifest {2}".format (
                    pmr_id, component_type, xml_file))

        component["pmr_digests"][pmr_id] = {}
        component["pmr_digests"][pmr_id]["allowable_digests"] = []

        for allowable_digest in pmr_digest.findall (XML_DIGEST_TAG):
            component["pmr_digests"][pmr_id]["allowable_digests"].append (
                binascii.a2b_hex (re.sub ("\s", "", allowable_digest.text.strip ())))

    for measurement in root.findall (XML_MEASUREMENT_TAG):
        if "measurements" not in component:
            component["measurements"] = {}

        pmr_id = int (xml_extract_attrib (measurement, XML_PMR_ID_ATTRIB, False, xml_file))
        measurement_id = int (xml_extract_attrib (measurement, XML_MEASUREMENT_ID_ATTRIB, False,
            xml_file))

        if pmr_id in component["measurements"]:
            if measurement_id in component["measurements"][pmr_id]:
                raise ValueError (
                    "Too many rules for PMR ID {0} measurement ID {1} for component {2} in manifest {3}".format (
                        pmr_id, measurement_id, component_type, xml_file))
        else:
            component["measurements"][pmr_id] = {}

        component["measurements"][pmr_id][measurement_id] = {}
        component["measurements"][pmr_id][measurement_id]["allowable_digests"] = []

        for allowable_digest in measurement.findall (XML_DIGEST_TAG):
            component["measurements"][pmr_id][measurement_id]["allowable_digests"].append (
                binascii.a2b_hex (re.sub ("\s", "", allowable_digest.text.strip ())))

    for measurement_data in root.findall (XML_MEASUREMENT_DATA_TAG):
        if "measurement_data" not in component:
            component["measurement_data"] = {}

        pmr_id = int (xml_extract_attrib (measurement_data, XML_PMR_ID_ATTRIB, False, xml_file))
        measurement_id = int (xml_extract_attrib (measurement_data, XML_MEASUREMENT_ID_ATTRIB,
            False, xml_file))

        if pmr_id in component["measurement_data"]:
            if measurement_id in component["measurement_data"][pmr_id]:
                raise ValueError (
                    "Too many rules for PMR ID {0} measurement data ID {1} for component {2} in manifest {3}".format (
                        pmr_id, measurement_id, component_type, xml_file))
        else:
            component["measurement_data"][pmr_id] = {}

        component["measurement_data"][pmr_id][measurement_id] = {}
        component["measurement_data"][pmr_id][measurement_id]["allowable_data"] = []

        for allowable_data in measurement_data.findall (XML_ALLOWABLE_DATA_TAG):
            data_dict = {}
            data_dict["data"] = []

            bitmask_tag = xml_find_single_tag (allowable_data, XML_BITMASK_TAG, xml_file, False)

            if bitmask_tag is not None:
                bitmask_text = binascii.a2b_hex (re.sub ("\s", "", bitmask_tag.text.strip ()))
                data_dict["bitmask"] = bitmask_text
                data_dict["bitmask_length"] = len (bitmask_text)

            check = process_cfm_check (allowable_data, "data", component_type, xml_file)
            data_dict["check"] = check

            endianness_tag = xml_extract_single_value (allowable_data,
                {"endianness": XML_ENDIANNESS_TAG}, xml_file)
            if endianness_tag["endianness"] == CFM_ENDIANNESS_LITTLE_ENDIAN:
                data_dict["endianness"] = 0
            elif endianness_tag["endianness"] == CFM_ENDIANNESS_BIG_ENDIAN:
                data_dict["endianness"] = 1
            else:
                raise ValueError (
                    "Unknown endianness '{0}' in allowable data for component {1} in manifest {2}".format (
                        endianness_tag["endianness"], component_type, xml_file))

            for data in allowable_data.findall (XML_DATA_TAG):
                data_text = data.text.strip ()
                if data_text[0] == '"' and data_text[-1] == '"':
                    data_text = binascii.hexlify (data_text.strip ('\"').encode ())
                else:
                    data_text = re.sub ("\s", "", data_text)

                data_text = binascii.a2b_hex (data_text)

                if "data_len" in component["measurement_data"][pmr_id][measurement_id]:
                    data_len = component["measurement_data"][pmr_id][measurement_id]["data_len"]
                    if len (data_text) != data_len:
                        raise ValueError (
                            "Data {0} has different length than other data for component {1} in manifest {2}: {3} vs {4}".format (
                                data_text, component_type, xml_file, len (data_text), data_len))
                else:
                    component["measurement_data"][pmr_id][measurement_id]["data_len"] = \
                        len (data_text)

                if "bitmask" in data_dict and len (data_text) > len (data_dict["bitmask"]):
                    raise ValueError (
                        "Data {0} length should be no greater than bitmask {1} for component {2} in manifest {3}".format (
                            data_text, data_dict["bitmask"], component_type, xml_file))

                data_dict["data"].append (data_text)

            component["measurement_data"][pmr_id][measurement_id]["allowable_data"].append (
                data_dict)

    for allowable_pfm in root.findall (XML_ALLOWABLE_PFM_TAG):
        if "allowable_pfm" not in component:
            component["allowable_pfm"] = {}

        port_id = int (xml_extract_attrib (allowable_pfm, XML_PORT_ATTRIB, False, xml_file))
        platform = xml_extract_attrib (allowable_pfm, XML_PLATFORM_ATTRIB, True, xml_file)

        if port_id in component["allowable_pfm"]:
            raise ValueError ("Too many rules for port {0} PFMs for component {1} in manifest {2}".format (
                port_id, component_type, xml_file))

        component["allowable_pfm"][port_id] = process_cfm_allowable_manifest (allowable_pfm,
            "PFM", component_type, xml_file)
        component["allowable_pfm"][port_id]["platform"] = platform

    for allowable_cfm in root.findall (XML_ALLOWABLE_CFM_TAG):
        if "allowable_cfm" not in component:
            component["allowable_cfm"] = {}

        index = int (xml_extract_attrib (allowable_cfm, XML_INDEX_ATTRIB, False, xml_file))
        platform = xml_extract_attrib (allowable_cfm, XML_PLATFORM_ATTRIB, True, xml_file)

        if index in component["allowable_cfm"]:
            raise ValueError ("Too many rules for index {0} CFMs for component {1} in manifest {2}".format (
                index, component_type, xml_file))

        component["allowable_cfm"][index] = process_cfm_allowable_manifest (allowable_cfm,
            "CFM", component_type, xml_file)
        component["allowable_cfm"][index]["platform"] = platform

    allowable_pcd = xml_find_single_tag (root, XML_ALLOWABLE_PCD_TAG, xml_file, False)
    if allowable_pcd is not None:
        platform = xml_extract_attrib (allowable_pcd, XML_PLATFORM_ATTRIB, True, xml_file)
        component["allowable_pcd"] = process_cfm_allowable_manifest (allowable_pcd, "PCD",
            component_type, xml_file)
        component["allowable_pcd"]["platform"] = platform

    return xml, manifest_types.VERSION_2, False

def process_pcd (root, xml_file):
    """
    Process PCD XML and generate list of element and attribute values.

    :param root: XML to utilize
    :param xml_file: Filename of XML

    :return List of PCD values, manifest version, boolean for whether manifest is for an empty PCD
    """

    xml = {}

    result = xml_extract_attrib (root, XML_SKU_ATTRIB, True, xml_file)
    xml.update ({"platform_id":result})

    result = xml_extract_attrib (root, XML_VERSION_ATTRIB, False, xml_file)
    xml.update ({"version":int (result, 16)})

    result = xml_extract_attrib (root, XML_EMPTY_ATTRIB, True, xml_file, False)
    if result and result.lower () == "true":
        return xml, manifest_types.VERSION_2, True

    rot = xml_find_single_tag (root, XML_ROT_TAG, xml_file)

    xml["rot"] = {}

    result = xml_extract_attrib (rot, XML_TYPE_ATTRIB, True, xml_file)
    if result == PCD_ROT_TYPE_PA_ROT:
        result = 0
    elif result == PCD_ROT_TYPE_AC_ROT:
        result = 1
    else:
        raise ValueError ("Unknown RoT type: {0}".format (result))

    xml["rot"].update ({"type":result})

    result = xml_extract_attrib (rot, XML_MCTP_CTRL_TIMEOUT_ATTRIB, False, xml_file)
    xml["rot"].update ({"mctp_ctrl_timeout":int (result)})

    result = xml_extract_attrib (rot, XML_MCTP_BRIDGE_GET_TABLE_WAIT_ATTRIB, False, xml_file)
    xml["rot"].update ({"mctp_bridge_get_table_wait":int (result)})

    ports = xml_find_single_tag (rot, XML_PORTS_TAG, xml_file, False)
    if ports is not None:
        xml["rot"]["ports"] = {}

        for port in ports.findall (XML_PORT_TAG):
            port_id = xml_extract_attrib (port, XML_ID_ATTRIB, False, xml_file)
            xml["rot"]["ports"][port_id] = {}

            result = xml_extract_single_value (port, {"spi_freq": XML_SPIFREQ_TAG,
                "flash_mode": XML_FLASHMODE_TAG, "reset_ctrl": XML_RESETCTRL_TAG,
                "policy": XML_POLICY_TAG, "pulse_interval": XML_PULSEINTERVAL_TAG,
                "runtime_verification": XML_RUNTIMEVERIFICATION_TAG,
                "watchdog_monitoring": XML_WATCHDOGMONITORING_TAG,
                "host_reset_action": XML_HOSTRESETACTION_TAG}, xml_file)

            if result["flash_mode"] == PCD_FLASH_MODE_DUAL:
                result["flash_mode"] = 0
            elif result["flash_mode"] == PCD_FLASH_MODE_SINGLE:
                result["flash_mode"] = 1
            elif result["flash_mode"] == PCD_FLASH_MODE_DUAL_FILTERED_BYPASS:
                result["flash_mode"] = 2
            elif result["flash_mode"] == PCD_FLASH_MODE_SINGLE_FILTERED_BYPASS:
                result["flash_mode"] = 3
            else:
                raise ValueError ("Unknown port {0} flash mode: {1}".format (port_id,
                    result["flash_mode"]))

            if result["reset_ctrl"] == PCD_RESET_CTRL_NOTIFY:
                result["reset_ctrl"] = 0
            elif result["reset_ctrl"] == PCD_RESET_CTRL_RESET:
                result["reset_ctrl"] = 1
            elif result["reset_ctrl"] == PCD_RESET_CTRL_PULSE:
                result["reset_ctrl"] = 2
            else:
                raise ValueError ("Unknown port {0} reset control: {1}".format (port_id,
                    result["reset_ctrl"]))

            if result["policy"] == PCD_POLICY_PASSIVE:
                result["policy"] = 0
            elif result["policy"] == PCD_POLICY_ACTIVE:
                result["policy"] = 1
            else:
                raise ValueError ("Unknown port {0} policy: {1}".format (port_id, result["policy"]))

            if result["runtime_verification"] == PCD_DISABLED:
                result["runtime_verification"] = 0
            elif result["runtime_verification"] == PCD_ENABLED:
                result["runtime_verification"] = 1
            else:
                raise ValueError ("Unknown port {0} runtime verification setting: {1}".format (
                    port_id, result["runtime_verification"]))

            if result["watchdog_monitoring"] == PCD_DISABLED:
                result["watchdog_monitoring"] = 0
            elif result["watchdog_monitoring"] == PCD_ENABLED:
                result["watchdog_monitoring"] = 1
            else:
                raise ValueError ("Unknown port {0} watchdog monitoring setting: {1}".format (
                    port_id, result["watchdog_monitoring"]))

            if result["host_reset_action"] == PCD_HOST_RESET_ACTION_NONE:
                result["host_reset_action"] = 0
            elif result["host_reset_action"] == PCD_HOST_RESET_ACTION_RESET_FLASH:
                result["host_reset_action"] = 1
            else:
                raise ValueError ("Unknown port {0} host reset action: {1}".format (port_id,
                    result["host_reset_action"]))

            xml["rot"]["ports"].update ({port_id:result})

    interface = xml_find_single_tag (rot, XML_INTERFACE_TAG, xml_file)

    xml["rot"]["interface"] = {}

    interface_type = xml_extract_attrib (interface, XML_TYPE_ATTRIB, True, xml_file)
    if interface_type == PCD_INTERFACE_TYPE_I2C:
        interface_type = 0
    else:
        raise ValueError ("Unknown RoT interface type: {0}".format (interface_type))

    xml["rot"]["interface"].update ({"type":interface_type})

    result = xml_extract_single_value (interface, {"address": XML_ADDRESS_TAG,
        "rot_eid": XML_ROT_EID_TAG, "bridge_eid": XML_BRIDGE_EID_TAG,
        "bridge_address": XML_BRIDGE_ADDRESS_TAG}, xml_file)

    result["address"] = int (result["address"], 16)
    result["rot_eid"] = int (result["rot_eid"], 16)
    result["bridge_eid"] = int (result["bridge_eid"], 16)
    result["bridge_address"] = int (result["bridge_address"], 16)

    xml["rot"]["interface"].update (result)

    power_controller = xml_find_single_tag (root, XML_POWER_CONTROLLER_TAG, xml_file, False)
    if power_controller is not None:
        xml["power_controller"] = {}

        interface = xml_find_single_tag (power_controller, XML_INTERFACE_TAG, xml_file)

        xml["power_controller"]["interface"] = {}

        interface_type = xml_extract_attrib (interface, XML_TYPE_ATTRIB, True, xml_file)
        if interface_type == PCD_INTERFACE_TYPE_I2C:
            interface_type = 0
        else:
            print ("Unknown PowerController interface type: {0}".format (interface_type))

        xml["power_controller"]["interface"].update ({"type":interface_type})

        result = xml_extract_single_value (interface, {"bus": XML_BUS_TAG,
            "eid": XML_EID_TAG, "address": XML_ADDRESS_TAG, "i2c_mode": XML_I2CMODE_TAG}, xml_file)

        result["eid"] = int (result["eid"], 16)
        result["address"] = int (result["address"], 16)

        if result["i2c_mode"] is None:
            raise ValueError ("PowerController missing I2C mode")
        if result["i2c_mode"] == PCD_INTERFACE_I2C_MODE_MM:
            result["i2c_mode"] = 0
        elif result["i2c_mode"] == PCD_INTERFACE_I2C_MODE_MS:
            result["i2c_mode"] = 1
        else:
            raise ValueError ("Unknown PowerController interface I2C mode: {0}".format (
                result["i2c_mode"]))

        xml["power_controller"]["interface"].update (result)

        muxes = xml_find_single_tag (interface, XML_MUXES_TAG, xml_file, False)
        if muxes is not None:
            xml["power_controller"]["interface"]["muxes"] = {}

            for mux in muxes.findall (XML_MUX_TAG):
                level = xml_extract_attrib (mux, XML_LEVEL_ATTRIB, False, xml_file)

                result = xml_extract_single_value (mux, {"address": XML_ADDRESS_TAG,
                    "channel": XML_CHANNEL_TAG}, xml_file)

                result["address"] = int (result["address"], 16)

                xml["power_controller"]["interface"]["muxes"].update ({level:result})

    components = xml_find_single_tag (root, XML_COMPONENTS_TAG, xml_file, False)
    if components is not None:
        xml["components"]= []

        for component in components.findall (XML_COMPONENT_TAG):
            curr_component = {}

            result = xml_extract_attrib (component, XML_TYPE_ATTRIB, True, xml_file)
            curr_component.update ({"type":result})

            result = xml_extract_attrib (component, XML_ATTESTATION_SUCCESS_RETRY_ATTRIB,
                False, xml_file)
            curr_component.update ({"attestation_success_retry":int (result)})

            result = xml_extract_attrib (component, XML_ATTESTATION_FAIL_RETRY_ATTRIB, False,
                xml_file)
            curr_component.update ({"attestation_fail_retry":int (result)})

            result = xml_extract_attrib (component,
                XML_ATTESTATION_RSP_NOT_READY_MAX_DURATION_ATTRIB, False, xml_file)
            curr_component.update ({"attestation_rsp_not_ready_max_duration":int (result)})

            result = xml_extract_attrib (component, XML_ATTESTATION_RSP_NOT_READY_MAX_RETRY_ATTRIB,
                False, xml_file)
            curr_component.update ({"attestation_rsp_not_ready_max_retry":int (result)})

            cnxn_type = xml_extract_attrib (component, XML_CONNECTION_ATTRIB, True, xml_file)
            if cnxn_type == PCD_COMPONENT_CONNECTION_DIRECT:
                curr_component.update ({"connection":PCD_COMPONENT_CONNECTION_DIRECT})

                interface = xml_find_single_tag (component, XML_INTERFACE_TAG, xml_file)

                curr_component["interface"] = {}

                interface_type = xml_extract_attrib (interface, XML_TYPE_ATTRIB, True, xml_file)
                if interface_type == PCD_INTERFACE_TYPE_I2C:
                    interface_type = 0
                else:
                    raise ValueError ("Unknown component {0} interface type: {1}".format (
                        curr_component["type"], interface_type))

                curr_component["interface"].update ({"type":interface_type})

                result = xml_extract_single_value (interface, {"bus": XML_BUS_TAG,
                    "eid": XML_EID_TAG, "address": XML_ADDRESS_TAG, "i2c_mode": XML_I2CMODE_TAG},
                    xml_file)

                result["eid"] = int (result["eid"], 16)
                result["address"] = int (result["address"], 16)

                if result["i2c_mode"] is None:
                    raise ValueError ("Component {0} missing I2C mode".format (
                        curr_component["type"]))
                if result["i2c_mode"] == PCD_INTERFACE_I2C_MODE_MM:
                    result["i2c_mode"] = 0
                elif result["i2c_mode"] == PCD_INTERFACE_I2C_MODE_MS:
                    result["i2c_mode"] = 1
                else:
                    print ("Unknown component {0} interface I2C mode: {1}".format (
                        curr_component["type"], result["i2c_mode"]))

                curr_component["interface"].update (result)

                muxes = xml_find_single_tag (interface, XML_MUXES_TAG, xml_file, False)
                if muxes is not None:
                    curr_component["interface"]["muxes"] = {}

                    for mux in muxes.findall (XML_MUX_TAG):
                        level = xml_extract_attrib (mux, XML_LEVEL_ATTRIB, False, xml_file)
                        result = xml_extract_single_value (mux, {"address": XML_ADDRESS_TAG,
                            "channel": XML_CHANNEL_TAG}, xml_file)

                        result["address"] = int (result["address"], 16)

                        curr_component["interface"]["muxes"].update ({level:result})

            elif cnxn_type == PCD_COMPONENT_CONNECTION_MCTP_BRIDGE:
                curr_component.update ({"connection":PCD_COMPONENT_CONNECTION_MCTP_BRIDGE})

                count = xml_extract_attrib (component, XML_COUNT_ATTRIB, False, xml_file)
                curr_component.update ({"count": int (count)})

                result = xml_extract_attrib (component, XML_DISCOVERY_FAIL_RETRY_ATTRIB, False,
                    xml_file)
                curr_component.update ({"discovery_fail_retry":int (result)})

                result = xml_extract_attrib (component, XML_MCTP_BRIDGE_ADDITIONAL_TIMEOUT_ATTRIB,
                    False, xml_file)
                curr_component.update ({"mctp_bridge_additional_timeout":int (result)})

                result = xml_extract_single_value (component, {"eid": XML_EID_TAG,
                    "deviceid": XML_DEVICE_ID_TAG, "vendorid": XML_VENDOR_ID_TAG,
                    "subdeviceid": XML_SUB_DEVICE_ID_TAG, "subvendorid": XML_SUB_VENDOR_ID_TAG},
                    xml_file)

                result["eid"] = int (result["eid"], 16)
                result["deviceid"] = int (result["deviceid"], 16)
                result["vendorid"] = int (result["vendorid"], 16)
                result["subdeviceid"] = int (result["subdeviceid"], 16)
                result["subvendorid"] = int (result["subvendorid"], 16)

                curr_component.update (result)
            else:
                raise ValueError ("Unknown component {0} connection type: {1}".format (
                    curr_component["type"], cnxn_type))

            result = xml_extract_single_value (component, {"policy": XML_POLICY_TAG}, xml_file)
            if result["policy"] == PCD_POLICY_PASSIVE:
                result["policy"] = 0
            elif result["policy"] == PCD_POLICY_ACTIVE:
                result["policy"] = 1
            else:
                raise ValueError ("Unknown component {0} policy: {1}".format (
                    curr_component["type"], result["policy"]))

            curr_component.update (result)

            powerctrl = xml_find_single_tag (component, XML_PWRCTRL_TAG, xml_file)

            curr_component["powerctrl"] = {}

            result = xml_extract_single_value (powerctrl, {"register": XML_REGISTER_TAG,
                "mask": XML_MASK_TAG}, xml_file)

            result["register"] = int (result["register"], 16)
            result["mask"] = int (result["mask"], 16)

            curr_component["powerctrl"].update (result)

            xml["components"].append (curr_component)

    return xml, manifest_types.VERSION_2, False

def load_and_process_xml (xml_file, xml_type, selection_list=None):
    """
    Process XML and generate list of element and attribute values.

    :param xml_file: XML to utilize
    :param xml_type: Type of manifest
    :param selection_list: Optional list of units to select and include in manifest

    :return List of manifest values, manifest version, boolean for whether XML is for an empty
        manifest
    """

    root = et.parse (xml_file).getroot ()

    if xml_type is manifest_types.PFM:
        return process_pfm (root, xml_file)
    elif xml_type is manifest_types.CFM:
        return process_cfm (root, xml_file, selection_list["selection"])
    elif xml_type is manifest_types.PCD:
        return process_pcd (root, xml_file)
    else:
        raise ValueError ("Unknown XML type: {0}".format (xml_type))

def load_and_process_selection_xml (xml_file):
    """
    Process XML and generate dictionary of platform ID and selection list.

    :param xml_file: XML to utilize

    :return selection dictionary
    """

    result_dict = {}

    root = et.parse (xml_file).getroot ()

    result = xml_extract_attrib (root, XML_SKU_ATTRIB, True, xml_file)
    result_dict.update ({"platform_id":result})

    result_dict["selection"] = []

    for component in root.findall (XML_COMPONENT_TAG):
        component_text = component.text.strip ().strip ("\"")
        result_dict["selection"].append (component_text)

    return result_dict