mirror of
https://github.com/ARM-software/arm-trusted-firmware.git
synced 2025-04-08 05:43:53 +00:00
09d40e0e08
Enforce full include path for includes. Deprecate old paths.
The following folders inside include/lib have been left unchanged:
- include/lib/cpus/${ARCH}
- include/lib/el3_runtime/${ARCH}
The reason for this change is that having a global namespace for
includes isn't a good idea. It defeats one of the advantages of having
folders and it introduces problems that are sometimes subtle (because
you may not know the header you are actually including if there are two
of them).
For example, this patch had to be created because two headers were
called the same way: e0ea0928d5 ("Fix gpio includes of mt8173 platform
to avoid collision."). More recently, this patch has had similar
problems: 46f9b2c3a2 ("drivers: add tzc380 support").
This problem was introduced in commit 4ecca33988 ("Move include and
source files to logical locations"). At that time, there weren't too
many headers so it wasn't a real issue. However, time has shown that
this creates problems.
Platforms that want to preserve the way they include headers may add the
removed paths to PLAT_INCLUDES, but this is discouraged.
Change-Id: I39dc53ed98f9e297a5966e723d1936d6ccf2fc8f
Signed-off-by: Antonio Nino Diaz <antonio.ninodiaz@arm.com>
127 lines
3.5 KiB
C
127 lines
3.5 KiB
C
/*
|
|
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
#include <common/debug.h>
|
|
#include <drivers/auth/auth_common.h>
|
|
#include <drivers/auth/img_parser_mod.h>
|
|
#include <lib/utils_def.h>
|
|
|
|
IMPORT_SYM(uintptr_t, __PARSER_LIB_DESCS_START__, PARSER_LIB_DESCS_START);
|
|
IMPORT_SYM(uintptr_t, __PARSER_LIB_DESCS_END__, PARSER_LIB_DESCS_END);
|
|
static unsigned int parser_lib_indices[IMG_MAX_TYPES];
|
|
static img_parser_lib_desc_t *parser_lib_descs;
|
|
|
|
#define INVALID_IDX UINT_MAX
|
|
|
|
static void validate_desc(img_parser_lib_desc_t *desc)
|
|
{
|
|
assert(desc != NULL);
|
|
assert(desc->init != NULL);
|
|
assert(desc->name != NULL);
|
|
assert(desc->check_integrity != NULL);
|
|
assert(desc->get_auth_param != NULL);
|
|
}
|
|
|
|
void img_parser_init(void)
|
|
{
|
|
unsigned int index, mod_num;
|
|
|
|
/* Initialise internal variables to invalid state */
|
|
for (index = 0; index < IMG_MAX_TYPES; index++) {
|
|
parser_lib_indices[index] = INVALID_IDX;
|
|
}
|
|
|
|
/* Calculate how many image parsers are registered. At least one parser
|
|
* must be present */
|
|
mod_num = PARSER_LIB_DESCS_END - PARSER_LIB_DESCS_START;
|
|
mod_num /= sizeof(img_parser_lib_desc_t);
|
|
assert(mod_num > 0);
|
|
|
|
parser_lib_descs = (img_parser_lib_desc_t *) PARSER_LIB_DESCS_START;
|
|
for (index = 0; index < mod_num; index++) {
|
|
|
|
/* Check that the image parser library descriptor is valid */
|
|
validate_desc(&parser_lib_descs[index]);
|
|
|
|
/* Initialize image parser */
|
|
parser_lib_descs[index].init();
|
|
|
|
/* Ensure only one parser is registered for each image type */
|
|
assert(parser_lib_indices[parser_lib_descs[index].img_type] ==
|
|
INVALID_IDX);
|
|
|
|
/* Keep the index of this hash calculator */
|
|
parser_lib_indices[parser_lib_descs[index].img_type] = index;
|
|
}
|
|
}
|
|
|
|
int img_parser_check_integrity(img_type_t img_type,
|
|
void *img_ptr, unsigned int img_len)
|
|
{
|
|
unsigned int idx;
|
|
|
|
assert(img_ptr != NULL);
|
|
assert(img_len != 0);
|
|
|
|
/* No integrity checks on raw images */
|
|
if (img_type == IMG_RAW) {
|
|
return IMG_PARSER_OK;
|
|
}
|
|
|
|
/* Find the index of the required image parser */
|
|
idx = parser_lib_indices[img_type];
|
|
assert(idx != INVALID_IDX);
|
|
|
|
/* Call the function to check the image integrity */
|
|
return parser_lib_descs[idx].check_integrity(img_ptr, img_len);
|
|
}
|
|
|
|
/*
|
|
* Extract an authentication parameter from an image
|
|
*
|
|
* Parameters:
|
|
* img_type: image type (certificate, raw image, etc)
|
|
* type_desc: provides info to obtain the parameter
|
|
* img_ptr: pointer to image data
|
|
* img_len: image length
|
|
* param_ptr: [out] stores a pointer to the parameter
|
|
* param_len: [out] stores the length of the parameter
|
|
*/
|
|
int img_parser_get_auth_param(img_type_t img_type,
|
|
const auth_param_type_desc_t *type_desc,
|
|
void *img_ptr, unsigned int img_len,
|
|
void **param_ptr, unsigned int *param_len)
|
|
{
|
|
unsigned int idx;
|
|
|
|
assert(type_desc != NULL);
|
|
assert(img_ptr != NULL);
|
|
assert(img_len != 0);
|
|
assert(param_ptr != NULL);
|
|
assert(param_len != NULL);
|
|
|
|
/* In a raw image we can only get the data itself */
|
|
if (img_type == IMG_RAW) {
|
|
assert(type_desc->type == AUTH_PARAM_RAW_DATA);
|
|
*param_ptr = img_ptr;
|
|
*param_len = img_len;
|
|
return IMG_PARSER_OK;
|
|
}
|
|
|
|
/* Find the index of the required image parser library */
|
|
idx = parser_lib_indices[img_type];
|
|
assert(idx != INVALID_IDX);
|
|
|
|
/* Call the function to obtain the parameter */
|
|
return parser_lib_descs[idx].get_auth_param(type_desc, img_ptr, img_len,
|
|
param_ptr, param_len);
|
|
}
|