/*****************************************************************************
* FUNCTION
* mre_write_line_to_file
* DESCRIPTION
* Writes line to file
* PARAMETERS
* file_name just the name as string in root directory, line as string
* RETURNS
* MRE_FILE_NOT_WRITTEN if fail, MRE_SCILENT for success
TODO: Remove this. Already defined above.
*****************************************************************************/
VMINT mre_write_line_to_file2 (VMSTR file_name, VMSTR line)
{
/* local variables */
VMFILE file_handle;
VMCHAR file_path[MRE_FILE_NAME_SIZE];
VMWCHAR wfile_name[MRE_FILE_NAME_SIZE];
VMWCHAR wline[MRE_STR_SIZE_MAX + 1];
VMUINT written;
VMUINT bytes_written;
VMINT line_bytes;
//const VMINT line_size = sizeof (VMCHAR) * (vm_wstrlen (line)+1); //+2 for new line
//VMINT line_bytes = sizeof(VMCHAR) * (vm_strlen(line) + 1 )
//VMSTR line_new[1000];
//sprintf(line_new,"%s\n", line);
/* Open file */
sprintf(file_path,"%c:\\%s",mre_get_drv(),file_name);
vm_ascii_to_ucs2(wfile_name, MRE_STR_SIZE_MAX, file_path);
vm_ascii_to_ucs2(wline, MRE_STR_SIZE_MAX, line);
line_bytes = sizeof(VMWCHAR) *(vm_wstrlen (wline)+1);
//g_mre_textbox_text = (sizeof (VMWCHAR) * (vm_wstrlen (wline)+1));
//vm_wstrcpy (g_mre_textbox_text, text);
file_handle = vm_file_open(wfile_name, MODE_APPEND, FALSE);
if (file_handle < 0){
file_handle = vm_file_open(wfile_name, MODE_CREATE_ALWAYS_WRITE, FALSE);
}
if(file_handle < 0)
{
vertical_scrolling_text("Write to file fail....");
}else{
/* write to file */
bytes_written = vm_file_write (file_handle, wline, line_bytes, &written);
vm_log_debug("%d bytes has been written in file", bytes_written);
if (bytes_written == 0)
{
vm_file_close (file_handle);
return MRE_FILE_NOT_WRITTEN;
}
else
{
vm_file_close (file_handle);
//sprintf (show_text, "Written in file: success");
//mre_show_text (show_text);
return MRE_SCILENT;
}
}
/* Closing file */
vm_file_close(file_handle);
return MRE_FILE_NOT_WRITTEN;
}
/*****************************************************************************
* FUNCTION
* vm_load_library
* DESCRIPTION
*
* PARAMETERS
* VMINT
* RETURNS
*
*****************************************************************************/
VMINT vm_load_library(VMSTR name)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
VMINT ret = -1;
_vm_pcb_t* pcbPtr = NULL;
VMINT currAppR9 = vm_get_running_app_sb();
VMWCHAR w_name[MAX_APP_NAME_LEN+1];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if(name == NULL || strlen(name) == 0 || strlen(name) > MAX_APP_NAME_LEN)
return VM_SO_PARAM_ERROR;
if ((pcbPtr = vm_sh_pcb_in_pt(SH_TYPE_R9, currAppR9, NULL)) != NULL)
{
vm_ascii_to_ucs2((VMWSTR)w_name, MAX_APP_NAME_LEN, (VMSTR)name);
ret = vm_so_load_file(w_name,pcbPtr);
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_10, name, ret );
return ret;
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* FUNCTION
* does_this_file_exist
* DESCRIPTION
* Checks if the givenn filename exists
* PARAMETERS
* VMSTR filename [IN] filename in VMSTR
* RETURNS
* VMBOOL TRUE if file exists or FALSE if it doesnt
*****************************************************************************/
VMBOOL does_this_file_exist(VMSTR filename){
VMWSTR wfilename;
VMINT wfilename_size;
VMFILE test_handle;
wfilename_size = (strlen(filename) + 1) * 2;
wfilename = vm_malloc(wfilename_size);
vm_ascii_to_ucs2 (wfilename, MRE_STR_SIZE_MAX, filename);
return does_this_wfile_exist(wfilename);
return FALSE;
}
/*****************************************************************************
* FUNCTION
* mre_write_file
* DESCRIPTION
* This function writes on the file given
* PARAMETERS
* file name [IN] name of file
* RETURNS
* result [OUT] some code for error and success
*****************************************************************************/
VMINT mre_write_file (VMSTR file_name)
{
VMFILE f_write;
VMCHAR f_name[MRE_STR_SIZE_MAX + 1] ;
VMWCHAR f_wname[MRE_STR_SIZE_MAX + 1];
VMINT written_result;
VMUINT written;
VMCHAR show_text[MRE_STR_SIZE_MAX + 1];
vm_log_debug ("mre_write_file function starts with file name : %s ", file_name);
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);
/* file is opened here */
f_write = vm_file_open (f_wname, MODE_WRITE, FALSE);
vm_log_debug("file open hdl : %d", f_write);
if (f_write < 0)
{
return MRE_FILE_OPEN_FAILED;
}
written_result = vm_file_write (f_write,
//vm_gb2312_string (mre_get_textbox_text ()),
mre_get_textbox_text (),
sizeof (VMWCHAR) * (vm_wstrlen (mre_get_textbox_text ())+1),
& written);
vm_log_debug("file write result : %d", written_result);
vm_free (mre_get_textbox_text ());
if (written_result == 0)
{
vm_file_close (f_write);
return MRE_FILE_NOT_WRITTEN;
}
else
{
vm_file_close (f_write);
sprintf (show_text, "Written in file: success");
mre_show_text (show_text);
return MRE_SCILENT;
}
//vm_log_debug ("mre_write_file function exits");
}
/*****************************************************************************
*
* #define MODE_READ 1
* #define MODE_WRITE 2
* #define MODE_CREATE_ALWAYS_WRITE 4
* #define MODE_APPEND 8
*****************************************************************************/
VMFILE mre_open_file(VMSTR file_path, VMUINT mode, VMUINT binary){
VMFILE file_handle;
VMWSTR wfile_path;
VMINT wfile_size;
wfile_size = (strlen(file_path) + 1) * 2;
wfile_path = vm_malloc(wfile_size);
vm_ascii_to_ucs2 (wfile_path, MRE_STR_SIZE_MAX, file_path);
/* Opening the file */
file_handle = vm_file_open (wfile_path, mode, binary);
vm_log_debug("file open handle : %d", file_handle);
return file_handle;
}
/*****************************************************************************
* FUNCTION
* mre_create_file_for_write
*
* DESCRIPTION
* it create file in which response data has been written
*
* PARAMETERS
* VMSTR filename
* VMINT *layer_hdl
* RETURNS
* VOID
*****************************************************************************/
void mre_create_file_for_write(VMSTR filename, VMINT *layer_hdl)
{
VMFILE handle;
VMWCHAR wfile_name[MRE_FILE_NAME_MAX_SIZE ];
VMCHAR file_name[2 * MRE_FILE_NAME_MAX_SIZE];
sprintf(file_name,"%c:\\%s",mre_get_drv(),filename);
vm_ascii_to_ucs2(wfile_name, 100, file_name);
handle = vm_file_open(wfile_name, MODE_CREATE_ALWAYS_WRITE, TRUE);
if(handle < 0)
{
//mre_display_home_top_screen_ascii("File Handle Fail");
mre_display_home_top_screen_ascii("File Handle Fail", layer_hdl);
}
vm_file_close(handle);
}
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;
}
/*****************************************************************************
* FUNCTION
* mre_create_file
* DESCRIPTION
* This function creates a file with given name in a drive set earlier
* PARAMETERS
* file name [IN] name of file
* RETURNS
* result [OUT] some code for error and success
*****************************************************************************/
VMINT mre_create_file (VMSTR file_name)
{
VMFILE fc;
VMCHAR f_name[MRE_STR_SIZE_MAX + 1];
VMWCHAR f_wname[MRE_STR_SIZE_MAX + 1];
VMCHAR show_text[MRE_STR_SIZE_MAX + 1];
VMUINT written;
void *test_ptr;
int ptr_size;
vm_log_debug("mre_create_file function starts with file name : %s ", file_name);
//Testing only. Result: works
/*
ptr_size = 1024;
test_ptr = vm_malloc(ptr_size);
*/
sprintf (f_name, "%c:\\%s", mre_get_drv(), file_name);
vm_log_file("file name\n");
vm_log_file(f_name);
vm_log_file("\n");
/* string format conversion */
vm_ascii_to_ucs2 (f_wname, MRE_STR_SIZE_MAX, f_name);
/* file is created here */
fc = vm_file_open (f_wname, MODE_CREATE_ALWAYS_WRITE, FALSE);
vm_log_debug("file open hdl : %d", fc);
if (fc < 0)
{
vm_log_file ("mre_create_file function exits\n");
return MRE_FILE_CREATE_FAILED;
}
else
{
vm_file_write (fc, "", 1, & written);
vm_file_close (fc);
sprintf (show_text, "file created:%s", f_name);
mre_show_text (show_text);
vm_log_debug (" %s mre_create_file function exits", show_text);
return MRE_SCILENT;
}
}
int remove_mre(const char *file_path){
/*
MSC:
int remove(const char *file_path);
MRE:
VMINT vm_file_delete(const VMWSTR filename);
*/
int remove_result;
VMWCHAR wfile_path[MRE_STR_SIZE_MAX + 1];
/* VMSTR to VMWSTR string format conversion */
vm_ascii_to_ucs2 (wfile_path, MRE_STR_SIZE_MAX, file_path);
remove_result = vm_file_delete(wfile_path);
return remove_result;
}
/*****************************************************************************
* FUNCTION
* get_file_size
* DESCRIPTION
* Gets the file specified size.
* PARAMETERS
* f_name [IN] VMSTR Complete file name of the file
* RETURNS
* file_size [OUT] VMINT The file's size in int
*****************************************************************************/
VMINT get_file_size(VMSTR f_name){
VMFILE file_handle;
//VMCHAR f_name[MRE_STR_SIZE_MAX + 1] ;
VMWCHAR f_wname[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;
VMINT file_size;
vm_log_debug ("Entering get_file_size 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);
file_handle = vm_file_open(f_wname, MODE_WRITE, TRUE); //Mode as Binary cuz image, right?
vm_file_getfilesize(file_handle, &file_size);
vm_file_close(file_handle); //Don't need the file no more. Closing it.
return file_size;
}
int _open(const char *file, int flags, int mode)
{
VMUINT fs_mode;
VMWCHAR wfile_name[16];
vm_ascii_to_ucs2(wfile_name, sizeof(wfile_name), file);
if (flags & O_CREAT) {
fs_mode = MODE_CREATE_ALWAYS_WRITE;
} else if ((flags & O_RDWR) || (flags & O_WRONLY)) {
fs_mode = MODE_WRITE;
} else {
fs_mode = MODE_READ;
}
if (flags & O_APPEND) {
fs_mode |= MODE_APPEND;
}
return vm_file_open(wfile_name, fs_mode, 0);
}
/*****************************************************************************
* FUNCTION
* mre_dump_to_file
*
* DESCRIPTION
* Write response data to specified file. Show alert if failed.
*
* PARAMETERS
* tcp_buffer [IN] buffer pointer containing address of received buffer
* size [IN] size of received data
* VMINT *layer_hdl [IN]
*
* RETURNS
* VOID
*****************************************************************************/
void mre_dump_to_file(VMCHAR *tcp_buffer, VMINT size, VMINT *layer_hdl)
{
VMFILE handle;
VMWCHAR wfile_name[MRE_FILE_NAME_MAX_SIZE ];
VMCHAR file_name[2 * MRE_FILE_NAME_MAX_SIZE];
VMUINT length;
VMINT write_status;
sprintf(file_name,"%c:\\%s",mre_get_drv(),"TCP.txt");
vm_ascii_to_ucs2(wfile_name, 100, file_name);
handle = vm_file_open(wfile_name, MODE_APPEND, TRUE);
if(handle < 0)
{
//mre_display_home_top_screen_ascii("File Handle Fail");
mre_display_home_top_screen_ascii("File Handle Fail", layer_hdl);
//vertical_scrolling_text("File Handle Fail....");
}
if (handle)
{
/* log information */
vm_log_debug("File handle is %d.", handle);
/* write response to tcp_buffer.txt file */
write_status = vm_file_write(handle, tcp_buffer, size, &length);
if (write_status < 0)
{
vm_log_debug("unable to write");
}
/* log information */
vm_log_debug("%d bytes has been written to file.", length);
}
vm_file_close(handle);
}
/*****************************************************************************
* FUNCTION
* vm_so_load_file
* DESCRIPTION
* load so file
* PARAMETERS
* filename : [IN] so file name encoding with UCS format.
* RETURNS
* load so result.
*****************************************************************************/
VMINT vm_so_load_file(VMWSTR fileName,_vm_pcb_t* father_pcb)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
vm_so_node_t* node;
VMINT bufSize, ret = -1;
#ifdef __MRE_CORE_SAFETY__
VMINT certres = -1;
VMUCHAR* cert_buff;
VMINT buflen = 3072;
#endif
VMCHAR tmp_buf[24];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
node = (vm_so_node_t*)_vm_kernel_calloc(sizeof(vm_so_node_t));
if( node == NULL )
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_02);
return VM_PMNG_NO_MEM;
}
if (kal_wstrchr(fileName, '\\') == NULL)
{
if (!vm_so_get_path(vm_get_removeable_driver(), fileName, node->soname) )
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_03);
if (!vm_so_get_path(vm_get_system_driver(), fileName, node->soname) )
{
VMUINT i,appcount,smcount,socount;
VMWCHAR tempName[64];
VMCHAR tempName1[64];
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_04);
vm_init_default_game(&appcount, &smcount, &socount);
for(i = 0; i < socount; i++)
{
vm_ascii_to_ucs2((VMWSTR)tempName, 64, (VMSTR)mre_buildin_vso_array[i].file_name);
if(kal_wstrcmp(tempName, fileName) == 0)
{
sprintf(tempName1, "%c:\\%u.rom", 64, mre_buildin_vso_array[i].address);
vm_ascii_to_ucs2((VMWSTR)node->soname, 64, (VMSTR) tempName1);
return VM_SO_SUCCESS;
}
}
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_05);
return VM_SO_FILE_NOT_FOUND;
}
}
}
else
{
vm_wstrcpy(node->soname, fileName);
}
#ifdef __MRE_CORE_SAFETY__
if ((cert_buff = (VMUCHAR* )_vm_kernel_malloc(buflen)) == NULL)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_06);
return -1;
}
certres = vm_ce_auth_app_ex(node->soname, cert_buff, buflen, VERIFY_FULL);
_vm_kernel_free(cert_buff);
if (certres < VM_CE_VERIFY_OK )
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_07, certres);
return certres;
}
#endif
#ifndef MRE_ON_MODIS
ret = vm_so_read_file( node );
if( ret < 0)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_08, ret);
return ret;
}
#else
node->memIndex = vm_alloc_memory(1024*500);
node->heapBase = g_vsm_mem_info[node->memIndex].mem_base;
node->heapSize = 1024*500;
#endif
node->pcb = father_pcb;
_vm_so_list_insert(node);
node->base_name = (VMWSTR)wcsrchr((wchar_t *)node->soname, L'\\');
if (node->base_name != NULL)
{
node->base_name++;
}
else
{
node->base_name = node->soname;
}
bufSize = 24;
if (vm_get_vm_tag(node->soname, VM_CE_INFO_ISSUE, (void *)tmp_buf, &bufSize) == GET_TAG_TRUE)
{
node->build_id = (tmp_buf[4] << 24) + (tmp_buf[8] << 16) + (tmp_buf[12] << 8) + tmp_buf[16];
}
else
{
node->build_id = 0;
}
node->dtype = DEBUG_SHARED_OBJECT;
#ifndef MRE_ON_MODIS
if(node->file_type == VM_VSO_RVCT)
{
typedef VMINT (*vm_rvct_so_entry_fp)(VMUINT symtab);
vm_rvct_so_entry_fp so_entry;
so_entry = (vm_rvct_so_entry_fp)(node->entry);
so_entry((VMUINT)vm_get_sym_entry);
}
else if(node->file_type == VM_VSO_GCC)
{
typedef VMINT (*vm_gcc_so_entry_fp)(VMUINT symtab, VMUINT address, VMUINT count);
vm_gcc_so_entry_fp so_entry;
so_entry = (vm_gcc_so_entry_fp)(node->entry);
so_entry((VMUINT)vm_get_sym_entry, (VMUINT)node->sysv_node.sysv_init_array, node->sysv_node.sysv_init_count);
}
else
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSO, TRC_MRE_VMSO_09);
}
#else
node->memIndex = vm_entry_vso(node->soname, (unsigned int)vm_get_sym_entry);
#endif
if (node->sysEventHandler)
{
node->sysEventHandler(VM_SO_MSG_LOAD, 0);
}
return node->memIndex;
}
/*
* 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 );
}
