| #!/usr/bin/env python2.7 |
| |
| ''' |
| This program will take truseted application's manifest config JSON file as |
| input. Processes the JSON config file and creates packed data |
| mapping to C structures and dumps in binary format. |
| |
| USAGE: |
| manifest_compiler.py --input <input_filename> --output <output_filename> \ |
| --constants <config_constants_file_1> \ |
| --constants <config_constants_file_2> \ |
| --header-dir <header_file_path> |
| |
| Arguments: |
| input_filename - Trusted app manifest config file in JSON format. |
| output_filename - Binary file containing packed manifest config data mapped |
| to C structres. |
| config_constant_file - This is optional |
| Config file with constants in JSON format |
| Corresponding header file will be |
| created with its constants defined in it |
| header_file_path - Directory in which header files to be generated. |
| |
| example: |
| manifest_compiler.py --input manifest.json --output output.bin \ |
| --constants manifest_constants.json \ |
| --header-dir \ |
| <build_dir>/user_tasks/trusty/user/app/sample/hwcrypto/include |
| |
| |
| Input sample JSON Manifest config file content - |
| { |
| "uuid": "SECURE_STORAGE_SERVER_APP_UUID", |
| "min_heap": 4096, |
| "min_stack": 4096, |
| "mem_map": [{"id": 1, "addr": "0x70000000", "size": "0x1000"}, \ |
| {"id": 2, "addr": "0x70010000", "size": "0x100"}, \ |
| {"id": 3, "addr": "0x70020000", "size": "0x4", |
| "type": "uncached_device", "non_secure": false}], |
| "mgmt_flags": {"restart_on_exit": true, \ |
| "deferred_start": false, \ |
| "non_critical_app": false}, |
| "start_ports": [{"name": "LOADABLE_START_PORT", \ |
| "flags": {"allow_ta_connect": true, "allow_ns_connect": false}}] |
| } |
| |
| JSON manifest constant config - |
| { |
| "header": "storage_constants.h", |
| "constants": [{ |
| "name": "LOADABLE_START_PORT", |
| "value": "com.android.trusty.appmgmt.loadable.start", |
| "type": "port" |
| }, |
| { |
| "name": "SECURE_STORAGE_SERVER_APP_UUID", |
| "value": "eca48f94-00aa-560e-8f8c-d94b50d484f3", |
| "type": "uuid" |
| }] |
| } |
| ''' |
| |
| import argparse |
| import cStringIO |
| import json |
| import optparse |
| import os.path |
| import struct |
| import sys |
| |
| |
| # Manifest properties |
| UUID = "uuid" |
| MIN_HEAP = "min_heap" |
| MIN_STACK = "min_stack" |
| MEM_MAP = "mem_map" |
| MEM_MAP_ID = "id" |
| MEM_MAP_ADDR = "addr" |
| MEM_MAP_SIZE = "size" |
| MEM_MAP_TYPE = "type" |
| MEM_MAP_TYPE_CACHED = "cached" |
| MEM_MAP_TYPE_UNCACHED = "uncached" |
| MEM_MAP_TYPE_UNCACHED_DEVICE = "uncached_device" |
| MEM_MAP_NON_SECURE = "non_secure" |
| MGMT_FLAGS = "mgmt_flags" |
| MGMT_FLAG_RESTART_ON_EXIT = "restart_on_exit" |
| MGMT_FLAG_DEFERRED_START = "deferred_start" |
| MGMT_FLAG_NON_CRITICAL_APP = "non_critical_app" |
| START_PORTS = "start_ports" |
| START_PORT_FLAGS = "flags" |
| START_PORT_NAME = "name" |
| START_PORT_ALLOW_TA_CONNECT = "allow_ta_connect" |
| START_PORT_ALLOW_NS_CONNECT = "allow_ns_connect" |
| APP_NAME = "app_name" |
| |
| # constants configs |
| CONSTANTS = "constants" |
| HEADER = "header" |
| CONST_NAME = "name" |
| CONST_VALUE = "value" |
| CONST_TYPE = "type" |
| CONST_UNSIGNED = "unsigned" |
| CONST_PORT = "port" |
| CONST_UUID = "uuid" |
| CONST_INT = "int" |
| CONST_BOOL = "bool" |
| |
| # CONFIG TAGS |
| # These values need to be kept in sync with uapi/trusty_app_manifest_types.h |
| TRUSTY_APP_CONFIG_KEY_MIN_STACK_SIZE = 1 |
| TRUSTY_APP_CONFIG_KEY_MIN_HEAP_SIZE = 2 |
| TRUSTY_APP_CONFIG_KEY_MAP_MEM = 3 |
| TRUSTY_APP_CONFIG_KEY_MGMT_FLAGS = 4 |
| TRUSTY_APP_CONFIG_KEY_START_PORT = 5 |
| |
| # MEM_MAP ARCH_MMU_FLAGS |
| # These values need to be kept in sync with external/lk/include/arch/mmu.h |
| ARCH_MMU_FLAG_CACHED = 0 << 0 |
| ARCH_MMU_FLAG_UNCACHED = 1 << 0 |
| ARCH_MMU_FLAG_UNCACHED_DEVICE = 2 << 0 |
| ARCH_MMU_FLAG_CACHE_MASK = 3 << 0 |
| ARCH_MMU_FLAG_NS = 1 << 5 |
| |
| # MGMT FLAGS |
| # These values need to be kept in sync with uapi/trusty_app_manifest_types.h |
| TRUSTY_APP_MGMT_FLAGS_NONE = 0 |
| TRUSTY_APP_MGMT_FLAGS_RESTART_ON_EXIT = 1 << 0 |
| TRUSTY_APP_MGMT_FLAGS_DEFERRED_START = 1 << 1 |
| TRUSTY_APP_MGMT_FLAGS_NON_CRITICAL_APP = 1 << 2 |
| |
| # START_PORT flags |
| # These values need to be kept in sync with user/base/include/user/trusty_ipc.h |
| IPC_PORT_ALLOW_TA_CONNECT = 0x1 |
| IPC_PORT_ALLOW_NS_CONNECT = 0x2 |
| |
| IPC_PORT_PATH_MAX = 64 |
| |
| |
| class Constant(object): |
| def __init__(self, name, value, type_, unsigned=False, hex_num=False): |
| self.name = name |
| self.value = value |
| self.type = type_ |
| self.unsigned = unsigned |
| self.hex_num = hex_num |
| |
| |
| class ConfigConstants(object): |
| def __init__(self, constants, header): |
| self.constants = constants |
| self.header = header |
| |
| |
| class StartPortFlags(object): |
| def __init__(self, allow_ta_connect, allow_ns_connect): |
| self.allow_ta_connect = allow_ta_connect |
| self.allow_ns_connect = allow_ns_connect |
| |
| |
| class StartPort(object): |
| def __init__(self, name, name_size, start_port_flags): |
| self.name = name |
| self.name_size = name_size |
| self.start_port_flags = start_port_flags |
| |
| |
| class MemIOMap(object): |
| def __init__(self, id_, addr, size, type, non_secure): |
| self.id = id_ |
| self.addr = addr |
| self.size = size |
| self.type = type |
| self.non_secure = non_secure |
| |
| |
| class MgmtFlags(object): |
| def __init__(self, restart_on_exit, deferred_start, non_critical_app): |
| self.restart_on_exit = restart_on_exit |
| self.deferred_start = deferred_start |
| self.non_critical_app = non_critical_app |
| |
| |
| ''' |
| Holds Manifest data to be used for packing |
| ''' |
| class Manifest(object): |
| def __init__( |
| self, |
| uuid, |
| app_name, |
| min_heap, |
| min_stack, |
| mem_io_maps, |
| mgmt_flags, |
| start_ports |
| ): |
| self.uuid = uuid |
| self.app_name = app_name |
| self.min_heap = min_heap |
| self.min_stack = min_stack |
| self.mem_io_maps = mem_io_maps |
| self.mgmt_flags = mgmt_flags |
| self.start_ports = start_ports |
| |
| |
| ''' |
| Tracks errors during manifest compilation |
| ''' |
| class Log(object): |
| def __init__(self): |
| self.error_count = 0 |
| |
| def error(self, msg): |
| sys.stderr.write("Error: {}\n".format(msg)) |
| self.error_count += 1 |
| |
| def error_occurred(self): |
| return self.error_count > 0 |
| |
| |
| ''' |
| For the given manifest JSON field it returns its literal value type mapped. |
| ''' |
| def get_string_sub_type(field): |
| if field == UUID: |
| return CONST_UUID |
| elif field == START_PORT_NAME: |
| return CONST_PORT |
| else: |
| # field with string value but doesn't support a constant |
| return None |
| |
| |
| def get_constant(constants, key, type_, log): |
| const = constants.get(key) |
| if const is None: |
| return None |
| |
| if const.type != type_: |
| log.error("{} constant type mismatch, expected type is {}" |
| .format(key, type_)) |
| return None |
| |
| return const.value |
| |
| |
| ''' |
| Determines whether the value for the given key in dictionary is of type string |
| and if it is a string then returns the value. |
| ''' |
| def get_string(manifest_dict, key, constants, log, optional=False, |
| default=None): |
| if key not in manifest_dict: |
| if not optional: |
| log.error("Manifest is missing required attribute - {}" |
| .format(key)) |
| return default |
| |
| value = manifest_dict.pop(key) |
| |
| # try to check is this field holding a constant |
| type_ = get_string_sub_type(key) |
| if type_: |
| const_value = get_constant(constants, value, type_, log) |
| if const_value is not None: |
| return const_value |
| |
| return coerce_to_string(value, key, log) |
| |
| |
| def coerce_to_string(value, key, log): |
| if not isinstance(value, str) and \ |
| not isinstance(value, unicode): |
| log.error( |
| "Invalid value for" + |
| " {} - \"{}\", Valid string value is expected" |
| .format(key, value)) |
| return None |
| |
| return value |
| |
| |
| ''' |
| Determines whether the value for the given key in dictionary is of type integer |
| and if it is int then returns the value |
| ''' |
| def get_int(manifest_dict, key, constants, log, optional=False, |
| default=None): |
| if key not in manifest_dict: |
| if not optional: |
| log.error("Manifest is missing required attribute - {}" |
| .format(key)) |
| return default |
| |
| value = manifest_dict.pop(key) |
| const_value = get_constant(constants, value, CONST_INT, log) |
| if const_value is not None: |
| return const_value |
| |
| return coerce_to_int(value, key,log) |
| |
| |
| def coerce_to_int(value, key, log): |
| if isinstance(value, int) and \ |
| not isinstance(value, bool): |
| return value |
| elif isinstance(value, basestring): |
| try: |
| return int(value, 0) |
| except ValueError as ex: |
| log.error("Invalid value for" + |
| " {} - \"{}\", valid integer or hex string is expected" |
| .format(key, value)) |
| return None |
| else: |
| log.error("Invalid value for" + |
| " {} - \"{}\", valid integer value is expected" |
| .format(key, value)) |
| return None |
| |
| |
| ''' |
| Determines whether the value for the given key in dictionary is of type List |
| and if it is List then returns the value |
| ''' |
| def get_list(manifest_dict, key, log, optional=False, default=None): |
| if key not in manifest_dict: |
| if not optional: |
| log.error("Manifest is missing required attribute - {}" |
| .format(key)) |
| return default |
| |
| return coerce_to_list(manifest_dict.pop(key), key, log) |
| |
| |
| def coerce_to_list(value, key, log): |
| if not isinstance(value, list): |
| log.error("Invalid value for" + |
| " {} - \"{}\", valid list is expected" |
| .format(key, value)) |
| return None |
| |
| return value |
| |
| |
| ''' |
| Determines whether the value for the given |
| key in dictionary is of type Dictionary |
| and if it is Dictionary then returns the value |
| ''' |
| def get_dict(manifest_dict, key, log, optional=False, default=None): |
| if key not in manifest_dict: |
| if not optional: |
| log.error("Manifest is missing required attribute - {}" |
| .format(key)) |
| return default |
| |
| return coerce_to_dict(manifest_dict.pop(key), key, log) |
| |
| |
| def coerce_to_dict(value, key, log): |
| if not isinstance(value, dict): |
| log.error("Invalid value for" + |
| " {} - \"{}\", valid dict is expected" |
| .format(key, value)) |
| return None |
| |
| return value |
| |
| |
| ''' |
| Determines whether the value for the given key in dictionary is of type boolean |
| and if it is boolean then returns the value |
| ''' |
| def get_boolean(manifest_dict, key, constants, log, optional=False, |
| default=None): |
| if key not in manifest_dict: |
| if not optional: |
| log.error("Manifest is missing required attribute - {}" |
| .format(key)) |
| return default |
| |
| value = manifest_dict.pop(key) |
| const_value = get_constant(constants, value, CONST_BOOL, log) |
| if const_value is not None: |
| return const_value |
| |
| return coerce_to_boolean(value, key, log) |
| |
| |
| def coerce_to_boolean(value, key, log): |
| if not isinstance(value, bool): |
| log.error( |
| "Invalid value for" + |
| " {} - \"{}\", Valid boolean value is expected" |
| .format(key, value)) |
| return None |
| |
| return value |
| |
| |
| def get_uuid(manifest_dict, key, constants, log, optional=False, default=None): |
| if key not in manifest_dict: |
| if not optional: |
| log.error("Manifest is missing required attribute - {}" |
| .format(key)) |
| return default |
| |
| uuid = get_string(manifest_dict, key, {}, log, optional, default) |
| const_value = get_constant(constants, uuid, CONST_UUID, log) |
| if const_value is not None: |
| return const_value |
| |
| return parse_uuid(uuid, log) |
| |
| |
| def get_port(port, key, constants, log, optional=False, default=None): |
| return get_string(port, key, constants, log, optional, default) |
| |
| |
| ''' |
| Validate and arrange UUID byte order |
| If its valid UUID then returns 16 byte UUID |
| ''' |
| def parse_uuid(uuid, log): |
| if uuid is None: |
| return None |
| |
| # Example UUID: "5f902ace-5e5c-4cd8-ae54-87b88c22ddaf" |
| if len(uuid) != 36: |
| log.error( |
| "Invalid UUID " + |
| "{}, uuid should be of length 16 bytes of hex values" |
| .format(uuid)) |
| return None |
| |
| uuid_data = uuid.split("-") |
| if len(uuid_data) != 5: |
| log.error( |
| "Invalid UUID {}".format(uuid) + |
| "uuid should be of length 16 bytes of hex divided into 5 groups" |
| ) |
| return None |
| |
| try: |
| uuid_data = [part.decode("hex") for part in uuid_data] |
| except TypeError as ex: |
| log.error("Invalid UUID {}, {}".format(uuid, ex)) |
| return None |
| |
| if len(uuid_data[0]) != 4 or \ |
| len(uuid_data[1]) != 2 or \ |
| len(uuid_data[2]) != 2 or \ |
| len(uuid_data[3]) != 2 or \ |
| len(uuid_data[4]) != 6: |
| log.error("Wrong grouping of UUID - {}".format(uuid)) |
| return None |
| |
| return "".join(uuid_data) |
| |
| |
| ''' |
| Validate memory size value. |
| if success return memory size value else return None |
| ''' |
| def parse_memory_size(memory_size, log): |
| if memory_size is None: |
| return None |
| |
| if memory_size <= 0 or memory_size % 4096 != 0: |
| log.error( |
| "{}: {}, Minimum memory size should be " |
| .format(MIN_STACK, memory_size) + |
| "non-negative multiple of 4096") |
| return None |
| |
| return memory_size |
| |
| |
| def parse_mem_map_type(mem_map_type, log): |
| if mem_map_type not in {MEM_MAP_TYPE_CACHED, |
| MEM_MAP_TYPE_UNCACHED, |
| MEM_MAP_TYPE_UNCACHED_DEVICE}: |
| log.error("Unknown mem_map.type entry in manifest: {} " |
| .format(mem_map_type)) |
| |
| return mem_map_type |
| |
| |
| def parse_mem_map(mem_maps, key, constants, log): |
| if mem_maps is None: |
| return None |
| |
| mem_io_maps = [] |
| for mem_map_entry in mem_maps: |
| mem_map_entry = coerce_to_dict(mem_map_entry, key, log) |
| if mem_map_entry is None: |
| continue |
| mem_map = MemIOMap( |
| get_int(mem_map_entry, MEM_MAP_ID, constants, log), |
| get_int(mem_map_entry, MEM_MAP_ADDR, constants, log), |
| get_int(mem_map_entry, MEM_MAP_SIZE, constants, log), |
| parse_mem_map_type( |
| get_string(mem_map_entry, MEM_MAP_TYPE, constants, log, |
| optional=True, |
| default=MEM_MAP_TYPE_UNCACHED_DEVICE), log), |
| get_boolean(mem_map_entry, MEM_MAP_NON_SECURE, constants, log, |
| optional=True) |
| ) |
| if mem_map_entry: |
| log.error("Unknown atributes in mem_map entries in manifest: {} " |
| .format(mem_map_entry)) |
| mem_io_maps.append(mem_map) |
| |
| return mem_io_maps |
| |
| |
| def parse_mgmt_flags(flags, constants, log): |
| if flags is None: |
| return None |
| |
| mgmt_flags = MgmtFlags( |
| get_boolean(flags, MGMT_FLAG_RESTART_ON_EXIT, constants, log, optional=True), |
| get_boolean(flags, MGMT_FLAG_DEFERRED_START, constants, log, optional=True), |
| get_boolean(flags, MGMT_FLAG_NON_CRITICAL_APP, constants, log, optional=True)) |
| |
| if flags: |
| log.error("Unknown atributes in mgmt_flags entries in manifest: {} " |
| .format(flags)) |
| |
| return mgmt_flags |
| |
| |
| def parse_app_start_ports(start_port_list, key, constants, log): |
| start_ports = [] |
| |
| for port_entry in start_port_list: |
| port_entry = coerce_to_dict(port_entry, key, log) |
| if port_entry is None: |
| continue |
| |
| name = get_port(port_entry, START_PORT_NAME, constants, log) |
| if len(name) >= IPC_PORT_PATH_MAX: |
| log.error("Length of start port name should be less than {}" |
| .format(IPC_PORT_PATH_MAX)) |
| |
| flags = get_dict(port_entry, START_PORT_FLAGS, log) |
| start_ports_flag = None |
| if flags: |
| start_ports_flag = StartPortFlags( |
| get_boolean(flags, START_PORT_ALLOW_TA_CONNECT, constants, |
| log), |
| get_boolean(flags, START_PORT_ALLOW_NS_CONNECT, constants, |
| log)) |
| |
| if port_entry: |
| log.error("Unknown atributes in start_ports entries" + |
| " in manifest: {} ".format(port_entry)) |
| if flags: |
| log.error("Unknown atributes in start_ports.flags entries" + |
| " in manifest: {} ".format(flags)) |
| |
| start_ports.append(StartPort(name, len(name), start_ports_flag)) |
| |
| return start_ports |
| |
| |
| def parse_app_name(app_name, log): |
| if app_name is None: |
| return None |
| |
| if not app_name: |
| log.error("empty app-name is not allowed in manifest") |
| return None |
| |
| return app_name.strip() |
| |
| |
| ''' |
| validate the manifest config and extract key, values |
| ''' |
| def parse_manifest_config(manifest_dict, constants, default_app_name, log): |
| # UUID |
| uuid = get_uuid(manifest_dict, UUID, constants, log) |
| |
| # MIN_HEAP |
| min_heap = parse_memory_size(get_int(manifest_dict, MIN_HEAP, constants, |
| log), log) |
| |
| # MIN_STACK |
| min_stack = parse_memory_size(get_int(manifest_dict, MIN_STACK, constants, |
| log), log) |
| |
| # MEM_MAP |
| mem_io_maps = parse_mem_map( |
| get_list(manifest_dict, MEM_MAP, log, optional=True, default=[]), |
| MEM_MAP, |
| constants, log) |
| |
| # MGMT_FLAGS |
| mgmt_flags = parse_mgmt_flags( |
| get_dict(manifest_dict, MGMT_FLAGS, log, optional=True, |
| default={ |
| MGMT_FLAG_RESTART_ON_EXIT: False, |
| MGMT_FLAG_DEFERRED_START: False, |
| MGMT_FLAG_NON_CRITICAL_APP: False}), |
| constants, log) |
| |
| # START_PORTS |
| start_ports = parse_app_start_ports( |
| get_list(manifest_dict, START_PORTS, log, |
| optional=True, default=[]), |
| START_PORTS, |
| constants, |
| log) |
| |
| #APP_NAME |
| app_name = parse_app_name( |
| get_string(manifest_dict, APP_NAME, constants, log, |
| optional=True, default=default_app_name), log) |
| |
| # look for any extra attributes |
| if manifest_dict: |
| log.error("Unknown atributes in manifest: {} ".format(manifest_dict)) |
| |
| if log.error_occurred(): |
| return None |
| |
| return Manifest(uuid, app_name, min_heap, min_stack, mem_io_maps, mgmt_flags, |
| start_ports) |
| |
| |
| ''' |
| This script represents UUIDs in a purely big endian order. |
| Trusty stores the first three components of the UUID in little endian order. |
| Rearrange the byte order accordingly by doing inverse |
| on first three components of UUID |
| ''' |
| def swap_uuid_bytes(uuid): |
| return uuid[3::-1] + uuid[5:3:-1] + uuid[7:5:-1] + uuid[8:] |
| |
| |
| def pack_mem_map_arch_mmu_flags(mem_map): |
| arch_mmu_flags = 0 |
| |
| if mem_map.type == MEM_MAP_TYPE_CACHED: |
| arch_mmu_flags |= ARCH_MMU_FLAG_CACHED |
| elif mem_map.type == MEM_MAP_TYPE_UNCACHED: |
| arch_mmu_flags |= ARCH_MMU_FLAG_UNCACHED |
| elif mem_map.type == MEM_MAP_TYPE_UNCACHED_DEVICE: |
| arch_mmu_flags |= ARCH_MMU_FLAG_UNCACHED_DEVICE |
| |
| if mem_map.non_secure: |
| arch_mmu_flags |= ARCH_MMU_FLAG_NS |
| |
| return arch_mmu_flags |
| |
| |
| def pack_mgmt_flags(mgmt_flags): |
| flags = TRUSTY_APP_MGMT_FLAGS_NONE |
| if mgmt_flags.restart_on_exit: |
| flags |= TRUSTY_APP_MGMT_FLAGS_RESTART_ON_EXIT |
| if mgmt_flags.deferred_start: |
| flags |= TRUSTY_APP_MGMT_FLAGS_DEFERRED_START |
| if mgmt_flags.non_critical_app: |
| flags |= TRUSTY_APP_MGMT_FLAGS_NON_CRITICAL_APP |
| |
| return flags |
| |
| |
| def pack_start_port_flags(flags): |
| start_port_flags = TRUSTY_APP_MGMT_FLAGS_NONE |
| if flags.allow_ta_connect: |
| start_port_flags |= IPC_PORT_ALLOW_TA_CONNECT |
| if flags.allow_ns_connect: |
| start_port_flags |= IPC_PORT_ALLOW_NS_CONNECT |
| |
| return start_port_flags |
| |
| |
| ''' |
| Pack a given string with null padding to make its size |
| multiple of 4. |
| packed data includes length + string + null + padding |
| ''' |
| def pack_inline_string(value): |
| size = len(value) + 1 |
| pad_len = 3 - (size + 3) % 4 |
| packed = struct.pack("I", size) + value + '\0' + pad_len * '\0' |
| assert len(packed) % 4 == 0 |
| return packed |
| |
| |
| ''' |
| Creates Packed data from extracted manifest data |
| Writes the packed data to binary file |
| ''' |
| def pack_manifest_data(manifest, log): |
| # PACK { |
| # uuid, app_name_size, app_name, |
| # TRUSTY_APP_CONFIG_KEY_MIN_HEAP_SIZE, min_heap, |
| # TRUSTY_APP_CONFIG_KEY_MIN_STACK_SIZE, min_stack, |
| # TRUSTY_APP_CONFIG_KEY_MAP_MEM, id, addr, size, |
| # TRUSTY_APP_CONFIG_KEY_MAP_MEM, id, addr, size, |
| # TRUSTY_APP_CONFIG_KEY_MGMT_FLAGS, mgmt_flags |
| # TRUSTY_APP_CONFIG_KEY_START_PORT, flag, name_size, name |
| # } |
| out = cStringIO.StringIO() |
| |
| uuid = swap_uuid_bytes(manifest.uuid) |
| out.write(uuid) |
| |
| out.write(pack_inline_string(manifest.app_name)) |
| |
| if manifest.min_heap is not None: |
| out.write(struct.pack("II",TRUSTY_APP_CONFIG_KEY_MIN_HEAP_SIZE, |
| manifest.min_heap)) |
| |
| if manifest.min_stack is not None: |
| out.write(struct.pack("II", TRUSTY_APP_CONFIG_KEY_MIN_STACK_SIZE, |
| manifest.min_stack)) |
| |
| for memio_map in manifest.mem_io_maps: |
| out.write(struct.pack("IIQQI", |
| TRUSTY_APP_CONFIG_KEY_MAP_MEM, |
| memio_map.id, |
| memio_map.addr, |
| memio_map.size, |
| pack_mem_map_arch_mmu_flags(memio_map))) |
| |
| if manifest.mgmt_flags is not None: |
| out.write(struct.pack("II", |
| TRUSTY_APP_CONFIG_KEY_MGMT_FLAGS, |
| pack_mgmt_flags(manifest.mgmt_flags))) |
| |
| for port_entry in manifest.start_ports: |
| out.write(struct.pack("II", |
| TRUSTY_APP_CONFIG_KEY_START_PORT, |
| pack_start_port_flags( |
| port_entry.start_port_flags))) |
| out.write(pack_inline_string(port_entry.name)) |
| |
| return out.getvalue() |
| |
| |
| ''' |
| Creates manifest JSON string from packed manifest data |
| ''' |
| def unpack_binary_manifest_to_json(packed_data): |
| return manifest_data_to_json(unpack_binary_manifest_to_data(packed_data)) |
| |
| |
| def manifest_data_to_json(manifest): |
| return json.dumps(manifest, sort_keys=True, indent=4) |
| |
| |
| ''' |
| This method can be used for extracting manifest data from packed binary. |
| UUID should be present in packed data. |
| ''' |
| def unpack_binary_manifest_to_data(packed_data): |
| manifest = {} |
| |
| # Extract UUID |
| uuid, packed_data = packed_data[:16], packed_data[16:] |
| uuid = swap_uuid_bytes(uuid) |
| uuid = uuid.encode("hex") |
| uuid = uuid[:8] + "-" \ |
| + uuid[8:12] + "-" \ |
| + uuid[12:16] + "-" \ |
| + uuid[16:20] + "-" \ |
| + uuid[20:] |
| |
| manifest[UUID] = uuid |
| |
| # Extract APP_NAME |
| # read size of the name, this includes a null character |
| (name_size,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| # read the name without a trailing null character |
| manifest[APP_NAME], packed_data = \ |
| packed_data[:name_size-1], packed_data[name_size-1:] |
| # discard trailing null characters |
| # it includes trailing null character of a string and null padding |
| pad_len = 1 + 3 - (name_size + 3) % 4 |
| packed_data = packed_data[pad_len:] |
| |
| # Extract remaining app configurations |
| while len(packed_data) > 0: |
| (tag,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| |
| if tag == TRUSTY_APP_CONFIG_KEY_MIN_HEAP_SIZE: |
| assert MIN_HEAP not in manifest |
| (manifest[MIN_HEAP],), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| elif tag == TRUSTY_APP_CONFIG_KEY_MIN_STACK_SIZE: |
| assert MIN_STACK not in manifest |
| (manifest[MIN_STACK],), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| elif tag == TRUSTY_APP_CONFIG_KEY_MAP_MEM: |
| if MEM_MAP not in manifest: |
| manifest[MEM_MAP] = [] |
| mem_map_entry = {} |
| (id_,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| (addr,), packed_data = struct.unpack( |
| "Q", packed_data[:8]), packed_data[8:] |
| (size,), packed_data = struct.unpack( |
| "Q", packed_data[:8]), packed_data[8:] |
| (arch_mmu_flags,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| mem_map_entry[MEM_MAP_ID] = id_ |
| mem_map_entry[MEM_MAP_ADDR] = hex(addr) |
| mem_map_entry[MEM_MAP_SIZE] = hex(size) |
| mem_map_entry[MEM_MAP_TYPE] = { |
| ARCH_MMU_FLAG_CACHED: MEM_MAP_TYPE_CACHED, |
| ARCH_MMU_FLAG_UNCACHED: MEM_MAP_TYPE_UNCACHED, |
| ARCH_MMU_FLAG_UNCACHED_DEVICE: MEM_MAP_TYPE_UNCACHED_DEVICE, |
| }[arch_mmu_flags & ARCH_MMU_FLAG_CACHE_MASK] |
| mem_map_entry[MEM_MAP_NON_SECURE] = bool(arch_mmu_flags & |
| ARCH_MMU_FLAG_NS) |
| manifest[MEM_MAP].append(mem_map_entry) |
| elif tag == TRUSTY_APP_CONFIG_KEY_MGMT_FLAGS: |
| (flag,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| mgmt_flag = { |
| MGMT_FLAG_RESTART_ON_EXIT: False, |
| MGMT_FLAG_DEFERRED_START: False, |
| MGMT_FLAG_NON_CRITICAL_APP: False |
| } |
| if flag & TRUSTY_APP_MGMT_FLAGS_RESTART_ON_EXIT: |
| mgmt_flag[MGMT_FLAG_RESTART_ON_EXIT] = True |
| if flag & TRUSTY_APP_MGMT_FLAGS_DEFERRED_START: |
| mgmt_flag[MGMT_FLAG_DEFERRED_START] = True |
| if flag & TRUSTY_APP_MGMT_FLAGS_NON_CRITICAL_APP: |
| mgmt_flag[MGMT_FLAG_NON_CRITICAL_APP] = True |
| manifest[MGMT_FLAGS] = mgmt_flag |
| elif tag == TRUSTY_APP_CONFIG_KEY_START_PORT: |
| if START_PORTS not in manifest: |
| manifest[START_PORTS] = [] |
| start_port_entry = {} |
| |
| (flag,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| |
| # read size of the name, this includes a null character |
| (name_size,), packed_data = struct.unpack( |
| "I", packed_data[:4]), packed_data[4:] |
| # read the name without a trailing null character |
| start_port_entry[START_PORT_NAME], packed_data = \ |
| packed_data[:name_size-1], packed_data[name_size-1:] |
| # discard trailing null characters |
| # it includes trailing null character of a string and null padding |
| pad_len = 1 + 3 - (name_size + 3) % 4 |
| packed_data = packed_data[pad_len:] |
| |
| start_port_flags = { |
| START_PORT_ALLOW_TA_CONNECT: False, |
| START_PORT_ALLOW_NS_CONNECT: False |
| } |
| if flag & IPC_PORT_ALLOW_TA_CONNECT: |
| start_port_flags[START_PORT_ALLOW_TA_CONNECT] = True |
| if flag & IPC_PORT_ALLOW_NS_CONNECT: |
| start_port_flags[IPC_PORT_ALLOW_NS_CONNECT] = True |
| start_port_entry[START_PORT_FLAGS] = start_port_flags |
| |
| manifest[START_PORTS].append(start_port_entry) |
| else: |
| raise Exception("Unknown tag: {}".format(tag)) |
| |
| return manifest |
| |
| |
| def write_packed_data_to_bin_file(packed_data, output_file, log): |
| # Write packed data to binary file |
| try: |
| with open(output_file, "wb") as out_file: |
| out_file.write(packed_data) |
| out_file.close() |
| except IOError as ex: |
| log.error( |
| "Unable to write to output file: {}" |
| .format(output_file) + "\n" + str(ex)) |
| |
| |
| def read_json_config_file(input_file, log): |
| try: |
| read_file = open(input_file, "r") |
| except IOError as ex: |
| log.error( |
| "Unable to open input file: {}" |
| .format(input_file) + "\n" + str(ex)) |
| return None |
| |
| try: |
| manifest_dict = json.load(read_file) |
| return manifest_dict |
| except ValueError as ex: |
| log.error( |
| "Unable to parse config JSON - {}" |
| .format(str(ex))) |
| return None |
| |
| |
| def read_config_constants(const_config_files, log): |
| const_configs_list = [] |
| for const_file in const_config_files: |
| const_configs_list.append(read_json_config_file(const_file, log)) |
| |
| return const_configs_list |
| |
| |
| def define_integer_const_entry(const, log): |
| text = hex(const.value) if const.hex_num else str(const.value) |
| if const.unsigned: |
| text += "U" |
| |
| return "#define {} ({})\n".format(const.name, text) |
| |
| |
| def define_string_const_entry(const, log): |
| return "#define {} {}\n".format(const.name, json.dumps(const.value)) |
| |
| |
| def define_bool_const_entry(const, log): |
| return "#define {} ({})\n".format(const.name, json.dumps(const.value)) |
| |
| |
| def define_uuid_const_entry(const, log): |
| uuid = const.value.encode("hex") |
| |
| part = ", ".join( |
| ["0x" + uuid[index:index+2] for index in range(16, len(uuid), 2)]) |
| |
| value = "{{0x{}, 0x{}, 0x{}, {{ {} }}}}\n".format( |
| uuid[:8], uuid[8:12], uuid[12:16], part) |
| |
| return "#define {} {}".format(const.name, value) |
| |
| |
| def create_header_entry(constant, log): |
| if constant.type == CONST_PORT: |
| return define_string_const_entry(constant, log) |
| elif constant.type == CONST_UUID: |
| return define_uuid_const_entry(constant, log) |
| elif constant.type == CONST_INT: |
| return define_integer_const_entry(constant, log) |
| elif constant.type == CONST_BOOL: |
| return define_bool_const_entry(constant, log) |
| else: |
| raise Exception("Unknown tag: {}".format(const_type)) |
| |
| |
| ''' |
| Writes given constants to header file in given header directory. |
| ''' |
| def write_consts_to_header_file(const_config, header_dir, log): |
| # Construct header file path |
| header_file = os.path.join(header_dir, const_config.header) |
| # Check whether the output directory of header file exist |
| # If it not exists create it. |
| dir_name = os.path.dirname(header_file) |
| if dir_name and not os.path.exists(dir_name): |
| os.makedirs(dir_name) |
| |
| try: |
| with open(header_file, "w") as out_file: |
| out_file.write("#pragma once\n") |
| out_file.write("#include <stdbool.h>\n\n") |
| for const in const_config.constants: |
| header_entries = create_header_entry(const, log) |
| out_file.write(header_entries) |
| except IOError as ex: |
| log.error( |
| "Unable to write to header file: {}" |
| .format(header_file) + "\n" + str(ex)) |
| |
| |
| ''' |
| Parse a give JSON constant data structure |
| ''' |
| def parse_constant(constant, log): |
| const_type = get_string(constant, CONST_TYPE, {}, log) |
| if const_type is None: |
| return None |
| |
| name = get_string(constant, CONST_NAME, {}, log) |
| if const_type == CONST_PORT: |
| value = get_string(constant, CONST_VALUE, {}, log) |
| return Constant(name, value, const_type) |
| elif const_type == CONST_UUID: |
| value = get_string(constant, CONST_VALUE, {}, log) |
| return Constant(name, parse_uuid(value, log), const_type) |
| elif const_type == CONST_INT: |
| unsigned = get_boolean(constant, CONST_UNSIGNED, {}, log) |
| text_value = constant.get(CONST_VALUE) |
| hex_num = isinstance(text_value, basestring) and \ |
| text_value.startswith("0x") |
| value = get_int(constant, CONST_VALUE, {}, log) |
| return Constant(name, value, const_type, unsigned, hex_num) |
| elif const_type == CONST_BOOL: |
| value = get_boolean(constant, CONST_VALUE, {}, log) |
| return Constant(name, value, const_type) |
| else: |
| log.error("Unknown constant type: {}".format(const_type)) |
| |
| |
| ''' |
| Parse a given JSON constant-config data structure containing |
| a header and list of constants |
| ''' |
| def parse_config_constant(const_config, log): |
| header_file = get_string(const_config, HEADER, {}, log) |
| |
| const_list = get_list(const_config, CONSTANTS, log, optional=False, |
| default=[]) |
| |
| constants = [] |
| for item in const_list: |
| item = coerce_to_dict(item, CONSTANTS, log) |
| if item is None: |
| continue |
| constants.append(parse_constant(item, log)) |
| if item: |
| log.error("Unknown atributes in constant: {} " |
| .format(item)) |
| |
| if const_config: |
| log.error("Unknown atributes in constants config: {} " |
| .format(const_config)) |
| |
| return ConfigConstants(constants, header_file) |
| |
| |
| ''' |
| Collects ConfigConstant(s) from list of JSON config constants data |
| ''' |
| def extract_config_constants(config_consts_list, log): |
| config_constants = [] |
| |
| for config_const in config_consts_list: |
| config_constants.append(parse_config_constant(config_const, log)) |
| |
| return config_constants |
| |
| |
| ''' |
| Parse JSON config constants and creates separate header files with constants |
| for each JSON config |
| ''' |
| def process_config_constants(const_config_files, header_dir, log): |
| if const_config_files is None: |
| return [] |
| |
| config_consts_list = read_config_constants(const_config_files, log) |
| if log.error_occurred(): |
| return [] |
| |
| config_constants = extract_config_constants(config_consts_list, log) |
| if log.error_occurred(): |
| return [] |
| |
| # generate header files |
| for const_config in config_constants: |
| write_consts_to_header_file(const_config, header_dir, log) |
| |
| return config_constants |
| |
| |
| def index_constants(config_constants, log): |
| constants = {} |
| for const_config in config_constants: |
| for const in const_config.constants: |
| constants[const.name] = const |
| |
| return constants |
| |
| |
| ''' |
| START OF THE PROGRAM |
| Handles the command line arguments |
| Parses the given manifest input file and creates packed data |
| Writes the packed data to binary output file. |
| ''' |
| def main(argv): |
| parser = argparse.ArgumentParser(); |
| parser.add_argument( |
| "-i", "--input", |
| dest="input_filename", |
| required=True, |
| type=str, |
| help="It should be trust app manifest config JSON file" |
| ) |
| parser.add_argument( |
| "-o", "--output", |
| dest="output_filename", |
| required=True, |
| type=str, |
| help="It will be binary file with packed manifest data" |
| ) |
| parser.add_argument( |
| "-c", "--constants", |
| dest="constants", |
| required=False, |
| action="append", |
| help="JSON file with manifest config constants" |
| ) |
| parser.add_argument( |
| "--header-dir", |
| dest="header_dir", |
| required=False, |
| type=str, |
| help="Directory path for generating headers" |
| ) |
| # Parse the command line arguments |
| args = parser.parse_args() |
| if args.constants and not args.header_dir: |
| args.error("--header-dir is required if --constants are specified") |
| |
| log = Log() |
| |
| # collect config constants and create header files for each const config |
| config_constants = process_config_constants(args.constants, |
| args.header_dir, log) |
| if log.error_occurred(): |
| return 1 |
| constants = index_constants(config_constants, log) |
| |
| if not os.path.exists(args.input_filename): |
| log.error( |
| "Manifest config JSON file doesn't exist: {}" |
| .format(args.input_filename)) |
| return 1 |
| |
| manifest_dict = read_json_config_file(args.input_filename, log) |
| if log.error_occurred(): |
| return 1 |
| |
| # By default app directory name will be used as app-name |
| default_app_name = os.path.basename(os.path.dirname(args.input_filename)) |
| |
| # parse the manifest config |
| manifest = parse_manifest_config(manifest_dict, constants, default_app_name, |
| log) |
| if log.error_occurred(): |
| return 1 |
| |
| # Pack the data as per c structures |
| packed_data = pack_manifest_data(manifest, log) |
| if log.error_occurred(): |
| return 1 |
| |
| # Write to file. |
| write_packed_data_to_bin_file(packed_data, args.output_filename, log) |
| if log.error_occurred(): |
| return 1 |
| |
| return 0 |
| |
| |
| if __name__ == "__main__": |
| sys.exit(main(sys.argv[1:])) |
