/*****************************************************************************
* FUNCTION DEFINITION
* mre_read_file
* DESCRIPTION
* This function reads the file's contents and returns it
* PARAMETERS
* file name [IN] name of file
*
* RETURNS
* result [OUT] some code for error and success
*****************************************************************************/
VMINT mre_read_file(VMSTR file_name, VMCHAR *data){
VMFILE f_read;
VMCHAR f_name[MRE_STR_SIZE_MAX + 1] ;
VMWCHAR f_wname[MRE_STR_SIZE_MAX + 1];
//VMCHAR data[MRE_STR_SIZE_MAX + 1];
VMCHAR show_data[MRE_STR_SIZE_MAX + 1 + 10];
VMWCHAR default_ucs[MRE_STR_SIZE_MAX + 1];
VMCHAR show_text[MRE_STR_SIZE_MAX + 1];
VMUINT nread;
vm_log_debug ("Entering mre_read_file function ");
sprintf (f_name, "%c:\\%s", mre_get_drv(), file_name);
vm_log_debug("file name : %s", f_name);
/* string format conversion */
vm_ascii_to_ucs2 (f_wname, MRE_STR_SIZE_MAX, f_name);
/* reading from file */
f_read = vm_file_open (f_wname, MODE_READ, FALSE);
vm_log_debug("file read hdl : %d", f_read);
vm_file_read (f_read, data, MRE_STR_SIZE_MAX, & nread);
data[nread] = '\0';
vm_file_close (f_read);
if (f_read < 0)
{
return MRE_FILE_OPEN_FAILED;
}
return MRE_SCILENT;
}
boolean vm_hashsum(const char* name, char* digest, vm_che_type type, VMUINT type_size) {
VMWCHAR src[OTA_MAX_PATH_LEN];
VMFILE handle;
VMUINT size, read, done;
vm_stche che_ctx;
uint8_t buffer[DIGEST_SIZE_BUFFER];
uint8_t che_hash[DIGEST_SIZE_MAX];
boolean result = true;
LOTAUPDATE_DEBUG("vm_md5sum - checking file %s\r\n", name);
if (vm_ascii_to_ucs2(src, OTA_MAX_PATH_LEN*sizeof(VMWCHAR), (VMSTR) name) < 0) {
LOTAUPDATE_DEBUG("vm_md5sum - error converting path to VMWCHAR\r\n");
return false;
}
if((handle = vm_file_open(src, MODE_READ, true)) < 0) {
LOTAUPDATE_DEBUG("vm_md5sum - error opening file\r\n");
return false;
}
if(vm_file_getfilesize(handle, &size) != 0) {
LOTAUPDATE_DEBUG("vm_md5sum - error getting file size");
result = false;
goto vm_md5sum_cleanup;
}
// initialize the che context and hash
memset(che_hash, 0, type_size);
vm_che_init(&che_ctx, type);
done = 0;
while(done < size) {
vm_file_read(handle, buffer, DIGEST_SIZE_BUFFER, &read);
done += read;
vm_che_process(&che_ctx, type, VM_CHE_MODE_NULL, VM_CHE_HASH, buffer, che_hash, read, done == size);
}
for(int i=0; i<type_size; i++) {
sprintf(&digest[i*2], "%02x", che_hash[i]);
}
digest[2*type_size] = 0;
result = true;
vm_che_deinit(&che_ctx);
vm_md5sum_cleanup:
vm_file_close(handle);
return result;
}
/* fread to mre's implementation of file read*/
size_t fread_mre(void *pBuf, int elementSize, size_t n, MZ_FILE *pFile){
/*
A typical fread function is like so:
return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);
which is fread(data, 1 byte, size in (1 byte), file handle);
MRE has vm_file_read
vm_file_read(file handle, data, size in bytes, read_bytes);
*/
VMUINT read_bytes;
VMINT file_read_result;
file_read_result = vm_file_read(*pFile, pBuf, n, &read_bytes);
/* Check file_read_result value */
if (file_read_result == 0){
printf("\nError or end of file reached.\n");
}
return (size_t) read_bytes; //convert to size_t which is basically unsigned int
}
extern int _read(int file, char *ptr, int len)
{
if (file < 3) {
int i;
for (i = 0; i < len; i++) {
*ptr = retarget_getc();
ptr++;
}
return len;
} else {
int read_bytes = len;
int bytes;
bytes = vm_file_read(file, ptr, len, &read_bytes);
// printf("_read() - file: %d, content: %X, len: %d, read: %d, read2: %d\n", file, (int)ptr, len, bytes, read_bytes);
return bytes;
}
}
/*
* Load all data from a file into a given buffer.
*
* The file is expected to contain either PEM or DER encoded data.
* A terminating null byte is always appended. It is included in the announced
* length only if the data looks like it is PEM encoded.
*/
int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n )
{
int ret = 0;
long size;
VM_FS_HANDLE file_handle;
VMWCHAR file_name[100 + 1];
VMSTR cert_paths[2];
VMUINT8* cert_buffer;
VMUINT read_size;
VMINT drv;
VMWCHAR wpath[FILE_PATH_SIZE] = {0};
VMCHAR path_cert[FILE_PATH_SIZE] = {0};
cert_paths[0] = (VMSTR)path;
memset(file_name, 0, sizeof(file_name));
vm_ascii_to_ucs2(file_name, SSL_CERT_PATH_MAX_LENGTH, cert_paths[0]);
file_handle = vm_file_open(file_name, MODE_READ, VM_TRUE);
if(!(VM_IS_SUCCEEDED(file_handle)))
{
return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
}
ret = vm_file_seek(file_handle, 0, BASE_END);
if (ret < 0){
return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
}
size = vm_file_tell(file_handle);
if (size < 0){
return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
}
ret = vm_file_seek(file_handle, 0, BASE_BEGIN);
if (ret < 0){
return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
}
*n = (size_t) size;
if( *n + 1 == 0 ||
( *buf = mbedtls_calloc( *n + 1 ) ) == NULL )
{
vm_file_close( file_handle );
return( MBEDTLS_ERR_PK_ALLOC_FAILED );
}
vm_file_read(file_handle, *buf, *n, &read_size);
if(read_size != *n)
{
vm_file_close( file_handle );
vm_free( *buf );
return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
}
vm_file_close( file_handle );
(*buf)[*n] = '\0';
if( strstr( (const char *) *buf, "-----BEGIN " ) != NULL )
++*n;
return( 0 );
// FILE *f;
// long size;
// if( ( f = fopen( path, "rb" ) ) == NULL )
// return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
// fseek( f, 0, SEEK_END );
// if( ( size = ftell( f ) ) == -1 )
// {
// fclose( f );
// return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
// }
// fseek( f, 0, SEEK_SET );
// *n = (size_t) size;
// if( *n + 1 == 0 ||
// ( *buf = mbedtls_calloc( 1, *n + 1 ) ) == NULL )
// {
// fclose( f );
// return( MBEDTLS_ERR_PK_ALLOC_FAILED );
// }
// if( fread( *buf, 1, *n, f ) != *n )
// {
// fclose( f );
// mbedtls_free( *buf );
// return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
// }
// fclose( f );
// (*buf)[*n] = '\0';
// if( strstr( (const char *) *buf, "-----BEGIN " ) != NULL )
// ++*n;
// return( 0 );
}
