/*
 *  PSA ITS simulator over stdio files.
 */
/*  Copyright (C) 2018, ARM Limited, All Rights Reserved
 *  Copyright 2020 NXP
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 *  not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *  This file is part of mbed TLS (https://tls.mbed.org)
 */

#if defined(MBEDTLS_CONFIG_FILE)
#include MBEDTLS_CONFIG_FILE
#else
#include "mbedtls/config.h"
#endif

#if defined(MBEDTLS_PSA_ITS_FILE_C)

#if defined(MBEDTLS_PLATFORM_C)
#include "mbedtls/platform.h"
#else
#define mbedtls_snprintf   snprintf
#endif

#if defined(_WIN32)
#include <windows.h>
#endif

#include "psa_crypto_its.h"

#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
#include "psa_alt.h"
#endif

#if !defined(PSA_ITS_STORAGE_PREFIX)
#define PSA_ITS_STORAGE_PREFIX ""
#endif

#define PSA_ITS_STORAGE_FILENAME_PATTERN "%08lx%08lx"
#define PSA_ITS_STORAGE_SUFFIX ".psa_its"
#define PSA_ITS_STORAGE_FILENAME_LENGTH         \
    ( sizeof( PSA_ITS_STORAGE_PREFIX ) - 1 + /*prefix without terminating 0*/ \
      16 + /*UID (64-bit number in hex)*/                               \
      sizeof( PSA_ITS_STORAGE_SUFFIX ) - 1 + /*suffix without terminating 0*/ \
      1 /*terminating null byte*/ )
#define PSA_ITS_STORAGE_TEMP \
    PSA_ITS_STORAGE_PREFIX "tempfile" PSA_ITS_STORAGE_SUFFIX

/* The maximum value of psa_storage_info_t.size */
#define PSA_ITS_MAX_SIZE 0xffffffff

#define PSA_ITS_MAGIC_STRING "PSA\0ITS\0"
#define PSA_ITS_MAGIC_LENGTH 8

/* As rename fails on Windows if the new filepath already exists,
 * use MoveFileExA with the MOVEFILE_REPLACE_EXISTING flag instead.
 * Returns 0 on success, nonzero on failure. */
#if defined(_WIN32)
#define rename_replace_existing( oldpath, newpath ) \
    ( ! MoveFileExA( oldpath, newpath, MOVEFILE_REPLACE_EXISTING ) )
#else
#define rename_replace_existing( oldpath, newpath ) rename( oldpath, newpath )
#endif

typedef struct
{
    uint8_t magic[PSA_ITS_MAGIC_LENGTH];
    uint8_t size[sizeof( uint32_t )];
    uint8_t flags[sizeof( psa_storage_create_flags_t )];
} psa_its_file_header_t;

static void psa_its_fill_filename( psa_storage_uid_t uid, char *filename )
{
    /* Break up the UID into two 32-bit pieces so as not to rely on
     * long long support in snprintf. */
    mbedtls_snprintf( filename, PSA_ITS_STORAGE_FILENAME_LENGTH,
                      "%s" PSA_ITS_STORAGE_FILENAME_PATTERN "%s",
                      PSA_ITS_STORAGE_PREFIX,
                      (unsigned long) ( uid >> 32 ),
                      (unsigned long) ( uid & 0xffffffff ),
                      PSA_ITS_STORAGE_SUFFIX );
}

static psa_status_t psa_its_read_file( psa_storage_uid_t uid,
                                       struct psa_storage_info_t *p_info,
                                       FILE **p_stream )
{
    char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
    psa_its_file_header_t header;
    size_t n;

    *p_stream = NULL;
    psa_its_fill_filename( uid, filename );
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
	psa_status_t psa_status = PSA_ERROR_STORAGE_FAILURE;
	uint8_t data[4096] = { 0 };
	size_t dataLen = sizeof(data);
    if (PSA_KEY_ID_NEEDS_ITS_SE(uid)) {
    	psa_status = psa_alt_read_se_its_file(uid, data, &dataLen);
    }
    else if (PSA_KEY_ID_NEEDS_ITS_FLASH(uid)) {
        psa_status = psa_alt_read_flash_its_file(uid, data, &dataLen);
    }
	if (psa_status != PSA_SUCCESS) {
		return psa_status;
	}
	memcpy(&header, &data[0], sizeof(header));
	n = sizeof(header);
#else

    *p_stream = fopen( filename, "rb" );
    if( *p_stream == NULL )
        return( PSA_ERROR_DOES_NOT_EXIST );

    n = fread( &header, 1, sizeof( header ), *p_stream );
#endif
	if( n != sizeof( header ) )
        return( PSA_ERROR_DATA_CORRUPT );
    if( memcmp( header.magic, PSA_ITS_MAGIC_STRING,
                PSA_ITS_MAGIC_LENGTH ) != 0 )
        return( PSA_ERROR_DATA_CORRUPT );

    p_info->size = ( header.size[0] |
                     header.size[1] << 8 |
                     header.size[2] << 16 |
                     header.size[3] << 24 );
    p_info->flags = ( header.flags[0] |
                      header.flags[1] << 8 |
                      header.flags[2] << 16 |
                      header.flags[3] << 24 );
    return( PSA_SUCCESS );
}

psa_status_t psa_its_get_info( psa_storage_uid_t uid,
                               struct psa_storage_info_t *p_info )
{
    psa_status_t status;
    FILE *stream = NULL;
    status = psa_its_read_file( uid, p_info, &stream );
    if( stream != NULL )
        fclose( stream );
    return( status );
}

psa_status_t psa_its_get( psa_storage_uid_t uid,
                          uint32_t data_offset,
                          uint32_t data_length,
                          void *p_data,
                          size_t *p_data_length )
{
    psa_status_t status;
    FILE *stream = NULL;
#if !defined(MBEDTLS_PSA_CRYPTO_SE_C)
    size_t n;
#endif
    struct psa_storage_info_t info;

    status = psa_its_read_file( uid, &info, &stream );
    if( status != PSA_SUCCESS )
        goto exit;
    status = PSA_ERROR_INVALID_ARGUMENT;
    if( data_offset + data_length < data_offset )
        goto exit;
#if SIZE_MAX < 0xffffffff
    if( data_offset + data_length > SIZE_MAX )
        goto exit;
#endif
    if( data_offset + data_length > info.size )
        goto exit;

    status = PSA_ERROR_STORAGE_FAILURE;
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
	psa_status_t psa_status = status;
	uint8_t data[4096] = { 0 };
	size_t dataLen = sizeof(data);
	size_t offset = 0;
    if (PSA_KEY_ID_NEEDS_ITS_SE(uid)) {
        psa_status = psa_alt_read_se_its_file(uid, data, &dataLen);
    }
    else if (PSA_KEY_ID_NEEDS_ITS_FLASH(uid)) {
    	psa_status = psa_alt_read_flash_its_file(uid, data, &dataLen);
    }
	if (psa_status != PSA_SUCCESS) {
		status = psa_status;
		goto exit;
	}
	if ( (data_offset + data_length ) > (dataLen - sizeof(psa_its_file_header_t)) ) {
		status = PSA_ERROR_INVALID_ARGUMENT;
		goto exit;
	}
	offset = sizeof(psa_its_file_header_t) + data_offset;
	memcpy(p_data, &data[offset], data_length);
	if (p_data_length != NULL) {
		*p_data_length = data_length;
	}

	status = PSA_SUCCESS;

#else
#if LONG_MAX < 0xffffffff
    while( data_offset > LONG_MAX )
    {
        if( fseek( stream, LONG_MAX, SEEK_CUR ) != 0 )
            goto exit;
        data_offset -= LONG_MAX;
    }
#endif
    if( fseek( stream, data_offset, SEEK_CUR ) != 0 )
        goto exit;
    n = fread( p_data, 1, data_length, stream );
    if( n != data_length )
        goto exit;
    status = PSA_SUCCESS;
    if( p_data_length != NULL )
        *p_data_length = n;
#endif
exit:
    if( stream != NULL )
        fclose( stream );
    return( status );
}

psa_status_t psa_its_set( psa_storage_uid_t uid,
                          uint32_t data_length,
                          const void *p_data,
                          psa_storage_create_flags_t create_flags )
{
    psa_status_t status = PSA_ERROR_STORAGE_FAILURE;
    char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
#if !defined(MBEDTLS_PSA_CRYPTO_SE_C)
    FILE *stream = NULL;
	size_t n;
#endif
    psa_its_file_header_t header;

    memcpy( header.magic, PSA_ITS_MAGIC_STRING, PSA_ITS_MAGIC_LENGTH );
    header.size[0] = data_length & 0xff;
    header.size[1] = ( data_length >> 8 ) & 0xff;
    header.size[2] = ( data_length >> 16 ) & 0xff;
    header.size[3] = ( data_length >> 24 ) & 0xff;
    header.flags[0] = create_flags & 0xff;
    header.flags[1] = ( create_flags >> 8 ) & 0xff;
    header.flags[2] = ( create_flags >> 16 ) & 0xff;
    header.flags[3] = ( create_flags >> 24 ) & 0xff;

    psa_its_fill_filename( uid, filename );
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
	uint8_t *p_store_data = (uint8_t *) malloc(sizeof(header) + data_length);// [4096] = { 0 };
	memcpy(p_store_data, &header, sizeof(header));
	memcpy(p_store_data + sizeof(header), p_data, data_length);
	size_t dataLen = sizeof(header) + data_length;
    if (PSA_KEY_ID_NEEDS_ITS_SE(uid)) {
        status = psa_alt_store_se_its_file(uid, p_store_data, dataLen);
    }
    else if (PSA_KEY_ID_NEEDS_ITS_FLASH(uid)) {
    	status = psa_alt_store_flash_its_file(uid, p_store_data, dataLen);
    }
    if(p_store_data) {
        free(p_store_data);
    }
#else
    stream = fopen( PSA_ITS_STORAGE_TEMP, "wb" );
    if( stream == NULL )
        goto exit;

    status = PSA_ERROR_INSUFFICIENT_STORAGE;
    n = fwrite( &header, 1, sizeof( header ), stream );
    if( n != sizeof( header ) )
        goto exit;
    if( data_length != 0 )
    {
        n = fwrite( p_data, 1, data_length, stream );
        if( n != data_length )
            goto exit;
    }
    status = PSA_SUCCESS;

exit:
    if( stream != NULL )
    {
        int ret = fclose( stream );
        if( status == PSA_SUCCESS && ret != 0 )
            status = PSA_ERROR_INSUFFICIENT_STORAGE;
    }
    if( status == PSA_SUCCESS )
    {
        if( rename_replace_existing( PSA_ITS_STORAGE_TEMP, filename ) != 0 )
            status = PSA_ERROR_STORAGE_FAILURE;
    }
    remove( PSA_ITS_STORAGE_TEMP );
#endif
    return( status );
}

psa_status_t psa_its_remove( psa_storage_uid_t uid )
{
    char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
#if !defined(MBEDTLS_PSA_CRYPTO_SE_C)
    FILE *stream;
#endif
    psa_its_fill_filename( uid, filename );
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
	psa_status_t psa_status = PSA_ERROR_DOES_NOT_EXIST;
    if (PSA_KEY_ID_NEEDS_ITS_SE(uid)) {
        psa_status = psa_alt_remove_se_its_file(uid);
    }
    else if (PSA_KEY_ID_NEEDS_ITS_FLASH(uid)) {
    	psa_status = psa_alt_remove_flash_its_file(uid);
    }
	return psa_status;
#else
    stream = fopen( filename, "rb" );
    if( stream == NULL )
        return( PSA_ERROR_DOES_NOT_EXIST );
    fclose( stream );
    if( remove( filename ) != 0 )
        return( PSA_ERROR_STORAGE_FAILURE );
    return( PSA_SUCCESS );
#endif
}

#endif /* MBEDTLS_PSA_ITS_FILE_C */