/*****************************************************************************
* 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
* 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");
}
/*****************************************************************************
* 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;
}
int fclose_mre(MZ_FILE *file_handle){
/*
MSC:
int fclose(FILE *file);
*/
VMINT close_result;
vm_file_close(*file_handle); //Doesn't return anything (void)
close_result = 0; //Going to have to override it as always close success.
return close_result;
}
void app_log_file(char *fmt, ...)
{
va_list args;
VMINT drv, hdl;
VMUINT written;
VMINT ret;
vm_time_t time = {0};
char buf[LOG_BUF_SIZE] = {0};
VMWCHAR wpath[FILE_PATH_SIZE] = {0};
VMCHAR path[FILE_PATH_SIZE] = {0};
buf[LOG_BUF_SIZE - 2] = '\r';
buf[LOG_BUF_SIZE - 1] = '\n';
va_start( args, fmt );
vm_get_time(&time);
vm_sprintf(buf+strlen(buf), "[%02d:%02d:%02d]", time.hour, time.min, time.sec);
vm_vsprintf(buf+strlen(buf), fmt, args);
drv = vm_get_removable_driver() > 0 ? vm_get_removeable_driver() : vm_get_system_driver();
vm_sprintf(path, "%c:\\%s", drv, BT_NAME".log");
vm_gb2312_to_ucs2(wpath, sizeof(wpath), path);
hdl = vm_file_open(wpath, MODE_APPEND, 0);
if (hdl < 0)
hdl = vm_file_open(wpath, MODE_CREATE_ALWAYS_WRITE, 0);
else
{
if (!flag_delete_log)
{
vm_file_close(hdl);
vm_file_delete(wpath);
flag_delete_log = 1;
hdl = vm_file_open(wpath, MODE_CREATE_ALWAYS_WRITE, 0);
}
}
vm_file_write(hdl, buf, LOG_BUF_SIZE, &written);
vm_file_close(hdl);
va_end( args );
}
// Freopen method : The effect of freopen is to reassign a handle to another source. ^VS
MZ_FILE *mz_freopen_mre(const char *pPath, const char *pMode, MZ_FILE *old_file_handle)
{
/*Do you think we should do something with the old_file_handle ?
Maybe close or flush etc ? ^VS */
//closing the old handle
vm_file_close(*old_file_handle);
/* Testing : If we can open a zip file with read write when already opened, etc */
return mz_fopen_mre(pPath, pMode);
}
/*****************************************************************************
* 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;
}
}
/*****************************************************************************
* FUNCTION
* does_this_wfile_exist
* DESCRIPTION
* Checks if the given filename(in VMWSTR) exists
* PARAMETERS
* VMWSTR wfilename [IN] filename in VMWSTR
* RETURNS
* VMBOOL TRUE if file exists or FALSE if it doesnt
*****************************************************************************/
VMBOOL does_this_wfile_exist(VMWSTR wfilename){
VMFILE test_handle;
/* Checking: Test that the file exists, we have access to it */
test_handle = vm_file_open(wfilename, MODE_READ, FALSE);
if(test_handle < 0)
{
// -2 is : VM_FILE_OPEN_ERROR
printf("File doesnt exist - file handle FAIL!\n");
return FALSE;
}else{
printf("File exists- file handle SUCCESS \n");
vm_file_close(test_handle); //MUST CLOSE FILE> MUST CLOSE FILE <MUST CLOSE FILE
return TRUE;
}
return FALSE;
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* 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);
}
extern int _close( int file )
{
vm_file_close(file);
return 0;
}
void close_mre(MZ_FILE *file_handle){ //Maybe you have to remove the pointer
vm_file_close(*file_handle);
}
/*
* 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 );
}
static void _vm_preload_read_data(vm_preload_ctx_t * ctx_p)
{
VMCHAR *body = (VMCHAR *)_vm_kernel_calloc(BUFFER_LEN);
//VMCHAR http_buffer[BUFFER_LEN] = {0};
VMINT len = 0, i = 0;
VMINT http_header_received = 0;
VMINT first_downloaded = 0;
VMINT http_header_len = 0;
VMINT file_handle = -1;
VMINT ret = 0;
VMBYTE * buf = NULL;
VMFILE f_handle = -1;
VMUINT written = 0;
vm_preload_recv_data_t data = {{E_PRELOAD_QUERYING, NULL}, 0, 0};
data.head.user_data = ctx_p->user_data;
//memset(buf, 0, sizeof(2*BUFFER_LEN));
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3358 , ctx_p->g_http_content_length);
// read the header
if (0 == ctx_p->g_http_content_length)
{
buf = (VMBYTE *)_vm_kernel_malloc(BUFFER_LEN);
if (NULL == buf)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_PRELOAD_E1, 7, __LINE__);
return;
}
memset(buf, 0, sizeof(BUFFER_LEN));
while ((ret = vm_tcp_read (ctx_p->soc_id, buf + len, BUFFER_LEN - len)) > 0)
{
len += ret;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3369 , ret, len);
}
for(i = 1; i < len; i++)
{
if (buf[i] == LF && buf[i - 1] == CR)
{
if (app_strnicmp((kal_char *)&buf[http_header_len], (kal_char *)CONTENT_LENGTH, strlen(CONTENT_LENGTH)) == 0)
{
buf[i - 1] = '\0';
first_downloaded = 0;
ctx_p->g_http_content_length = atoi((const char *)&buf[http_header_len] + strlen(CONTENT_LENGTH) + 1);
ctx_p->need_recv_len = ctx_p->g_http_content_length;
//data.total = http_content_length;I
ctx_p->update = 1;
}
http_header_len = i + 1;
if ((i + 2) < len &&
(buf[i + 2] == LF && buf[i + 1] == CR))
{
http_header_len += 2;
first_downloaded = len - http_header_len;
break;
}
}
}
//strncpy(body, buf + 2, first_downloaded);
memcpy(body, &buf[http_header_len], first_downloaded);
_vm_kernel_free(buf);
if (!vm_preload_is_url_valid(body, ctx_p, 0))
{
_vm_preload_try_download(ctx_p);
ctx_p->g_http_content_length = ctx_p->need_recv_len = 0;
//ctx_p->update = 0;
_vm_kernel_free(body);
return;
}
// preparing file
f_handle = vm_file_open(ctx_p->path, MODE_READ, 1);
if (0 <= f_handle)
{
vm_file_close(f_handle);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3411 );
vm_file_delete(ctx_p->path);
}
f_handle = vm_file_open(ctx_p->path, MODE_CREATE_ALWAYS_WRITE, 1);
}
// preparing file
if (0 > f_handle)
{
f_handle = vm_file_open(ctx_p->path, MODE_APPEND, 1);
}
if (0 > f_handle)
{
VMCHAR buf[260];
vm_ucs2_to_ascii(buf, 260, ctx_p->path);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3429 , buf);
data.head.state = E_PRELOAD_ERR_PATH;
ctx_p->status = E_PRELOAD_ERR_PATH;
_vm_preload_clean_and_free_ctx(ctx_p, &data);
_vm_kernel_free(body);
return;
}
// no disk space
{
VMWCHAR drv_wname[4] = {0};
VMUINT size = 0;
vm_wstrncpy(drv_wname, ctx_p->path, 1);
size = vm_get_disk_free_space(drv_wname);
if (size < (VMUINT)ctx_p->g_http_content_length)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3429 , (VMCHAR*)drv_wname);
data.head.state = E_PRELOAD_FAILURE;
ctx_p->status = E_PRELOAD_FAILURE;
if (0 <= f_handle)
{
vm_file_close(f_handle);
vm_file_delete(ctx_p->path);
}
_vm_preload_clean_and_free_ctx(ctx_p, &data);
_vm_kernel_free(body);
return;
}
}
do
{
len = first_downloaded;
while ((ret = vm_tcp_read (ctx_p->soc_id, body + len,
(ctx_p->g_http_content_length > BUFFER_LEN ? BUFFER_LEN : ctx_p->g_http_content_length) - len)) > 0)
{
// would block
if (0 == ret)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3448 );
break;
}
len += ret;
if (BUFFER_LEN == len)
{
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3454 );
break;
}
}
ctx_p->g_http_content_length -= len;
first_downloaded = 0;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3462 , len);
data.head.state = E_PRELOAD_DOWNLOADING;
ctx_p->status = (VMINT)E_PRELOAD_DOWNLOADING;
data.total = ctx_p->need_recv_len;
data.received = ctx_p->need_recv_len - ctx_p->g_http_content_length;
//data.buf = body;
//data.size = len;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3469 , data.received, data.total);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3470 );
vm_file_write(f_handle, body, len, &written);
PRELOAD_PMNG_WRAP_CALLBACK(ctx_p->p_hdl,
ctx_p->cb, ctx_p->res_id, (void*)&data);
} while (BUFFER_LEN == len && 0 != ret); // would block break
vm_file_close(f_handle);
if (0 == ctx_p->g_http_content_length)
{
data.head.state = E_PRELOAD_DOWNLOADED;
ctx_p->status = (VMINT)E_PRELOAD_DOWNLOADED;
data.total = ctx_p->g_http_content_length;
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3485 , data.total);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3486 );
_vm_preload_clean_and_free_ctx(ctx_p, &data);
}
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
_vm_kernel_free(body);
MMI_TRACE(MMI_MRE_TRC_MOD_VMSOCK, TRC_MRE_VMSOCK_3582 );
}
