From 922c841dc14b6a4021952113f2290ddcae9c2053 Mon Sep 17 00:00:00 2001 From: Sunghyun Kwon Date: Thu, 3 Sep 2015 11:28:41 +0900 Subject: [PATCH] Fixed the invalid casting and remove the flash noti Change-Id: Icb826abd987e4751cf8f473219e597e56009e2e2 --- email-common-use/email-convert.c | 4 +- email-common-use/email-utilities.c | 4 +- email-core/email-core-key-manager.c | 2 +- email-core/email-core-smtp.c | 5 +- email-core/email-core-task-manager.c | 1320 +++++++++++----------- email-core/email-core-tasks.c | 1306 ++++++++++----------- email-core/email-core-utils.c | 45 +- email-core/email-storage/email-storage.c | 31 +- email-core/email-storage/include/email-storage.h | 20 +- email-core/include/email-core-mail.h | 1 + email-core/include/email-core-task-manager.h | 2 +- email-core/include/email-core-utils.h | 2 - email-daemon/email-daemon-etc.c | 2 - email-daemon/email-daemon-mail.c | 13 +- email-daemon/main.c | 9 +- email-ipc/include/email-ipc.h | 1 + utilities/test-application/testapp-mail.c | 4 +- 17 files changed, 1417 insertions(+), 1354 deletions(-) diff --git a/email-common-use/email-convert.c b/email-common-use/email-convert.c index e48c02f..8299cd5 100755 --- a/email-common-use/email-convert.c +++ b/email-common-use/email-convert.c @@ -1236,7 +1236,7 @@ INTERNAL_FUNC void em_convert_byte_stream_to_rule(char *stream, int stream_len, converted_fmt = convert_format(EMAIL_RULE_FMT); if (converted_fmt == NULL) { EM_DEBUG_EXCEPTION("converting failed"); - return NULL; + return; } tn = tpl_map(converted_fmt, rule); @@ -1326,7 +1326,7 @@ INTERNAL_FUNC void em_convert_byte_stream_to_meeting_req(char *stream, int strea converted_fmt = convert_format(EMAIL_MEETING_REQUEST_FMT); if (converted_fmt == NULL) { EM_DEBUG_EXCEPTION("converting failed"); - return NULL; + return; } tn = tpl_map(converted_fmt, diff --git a/email-common-use/email-utilities.c b/email-common-use/email-utilities.c index 770aa85..9c86fb5 100755 --- a/email-common-use/email-utilities.c +++ b/email-common-use/email-utilities.c @@ -112,10 +112,10 @@ INTERNAL_FUNC char *em_trim_right(char *str) if (!str) return NULL; p = str+EM_SAFE_STRLEN(str)-1; - while (((int)p >= (int)str) && (*p == ' ' || *p == '\t' || *p == LF || *p == CR)) + while ((p >= str) && (*p == ' ' || *p == '\t' || *p == LF || *p == CR)) *p --= '\0'; - if ((int) p < (int)str) + if (p < str) return NULL; return str; diff --git a/email-core/email-core-key-manager.c b/email-core/email-core-key-manager.c index aed326b..ddd9ed5 100644 --- a/email-core/email-core-key-manager.c +++ b/email-core/email-core-key-manager.c @@ -124,7 +124,7 @@ INTERNAL_FUNC int emcore_get_password_in_key_manager(char *data_name, char **sto FINISH_OFF: if (stored_data) { - if (email_data) *stored_data = g_strndup(email_data->data, email_data->size); + if (email_data) *stored_data = g_strndup((const gchar *)email_data->data, email_data->size); } if (email_data) diff --git a/email-core/email-core-smtp.c b/email-core/email-core-smtp.c index 91f9d23..449bb32 100755 --- a/email-core/email-core-smtp.c +++ b/email-core/email-core-smtp.c @@ -2090,7 +2090,7 @@ INTERNAL_FUNC int emcore_send_saved_mail(char *multi_user_name, int account_id, int err2 = EMAIL_ERROR_NONE; int status = EMAIL_SEND_FAIL; int *mail_ids = NULL; - int handle = 0; + DB_STMT handle; int i = 0; int total = 0; int attachment_tbl_count = 0; @@ -4485,7 +4485,8 @@ INTERNAL_FUNC int emcore_schedule_sending_mail(char *multi_user_name, int input_ } FINISH_OFF: - if(mail_data) + + if (mail_data) emstorage_free_mail(&mail_data, 1, NULL); EM_DEBUG_FUNC_END("err [%d]", err); diff --git a/email-core/email-core-task-manager.c b/email-core/email-core-task-manager.c index 776ce33..2d2bc0a 100755 --- a/email-core/email-core-task-manager.c +++ b/email-core/email-core-task-manager.c @@ -1,659 +1,681 @@ -/* -* email-service -* -* Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. -* -* Contact: Kyuho Jo , Sunghyun Kwon -* -* 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. -* -*/ - -/* - * email-core-task-manager.c - * - * Created on: 2012. 11. 1. - * Author: kyuho.jo@samsung.com - */ - -#include -#include -#include -#include - -#include "email-internal-types.h" -#include "email-utilities.h" -#include "email-core-tasks.h" -#include "email-core-task-manager.h" -#include "email-core-signal.h" -#include "email-core-global.h" -#include "email-core-utils.h" -#include "email-debug-log.h" - -/* TODO : implement a function for removing a task from task pool */ -/* TODO : after fetching a task from DB, update status of the task. */ - - -#define REGISTER_TASK_BINDER(TASK_NAME) emcore_register_task_handler(TASK_NAME, task_handler_##TASK_NAME, email_encode_task_parameter_##TASK_NAME, email_decode_task_parameter_##TASK_NAME) - -/*- variables - begin --------------------------------------------------------*/ -static pthread_cond_t _task_available_signal = PTHREAD_COND_INITIALIZER; -static pthread_mutex_t _task_available_lock = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _task_manager_loop_lock = PTHREAD_MUTEX_INITIALIZER; -static pthread_mutex_t _active_task_pool_lock = PTHREAD_MUTEX_INITIALIZER; - -static email_active_task_t _active_task_pool[MAX_ACTIVE_TASK]; -static thread_t _thread_task_manager_loop; -static int _task_manager_loop_availability = 1; -/*- variables - end ----------------------------------------------------------*/ -static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id); -static int emcore_remove_task_from_active_task_pool(int input_task_id); -static int emcore_find_available_slot_in_active_task_pool(int *result_index); -static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status); -static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler); - -/*- task handlers helpers - begin --------------------------------------------*/ -static int emcore_initialize_async_task_handler(email_task_t *input_task) -{ - EM_DEBUG_FUNC_BEGIN("input_task [%p]", input_task); - int err = EMAIL_ERROR_NONE; - - if(input_task == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - /* insert task to _active_task_pool */ - emcore_insert_task_to_active_task_pool(input_task->active_task_id - , input_task->task_id - , input_task->task_type - , THREAD_SELF()); - - /* send notification for 'task start */ - if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, EMAIL_TASK_STATUS_STARTED, EMAIL_ERROR_NONE, 0)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err); - goto FINISH_OFF; - } - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -static int emcore_finalize_async_task_handler(email_task_t *input_task, int input_error_code) -{ - EM_DEBUG_FUNC_BEGIN("input_task [%p] input_error_code [%d]",input_task ,input_error_code); - int err = EMAIL_ERROR_NONE; - email_task_status_type_t task_status = EMAIL_TASK_STATUS_FINISHED; - - if(input_task == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - if(input_error_code != EMAIL_ERROR_NONE) { - task_status = EMAIL_TASK_STATUS_FAILED; - } - - /* remove task from task table */ - if( (err = emcore_remove_task_from_task_table(NULL, input_task->task_id)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err); - goto FINISH_OFF; - } - - /* remove task id from active task id array */ - if( (err = emcore_remove_task_from_active_task_pool(input_task->task_id)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err); - goto FINISH_OFF; - } - - /* send signal for 'task finish or failure */ - if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, task_status, input_error_code, 0)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err); - goto FINISH_OFF; - } - - ENTER_CRITICAL_SECTION(_task_available_lock); - WAKE_CONDITION_VARIABLE(_task_available_signal); - LEAVE_CRITICAL_SECTION(_task_available_lock); - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC void* emcore_default_async_task_handler(void *input_param) -{ - EM_DEBUG_FUNC_BEGIN("intput_param [%p]", input_param); - int err = EMAIL_ERROR_NONE; - email_task_t *task = input_param; - email_task_handler_t *task_handler = NULL; - void *decoded_task_parameter = NULL; - - if((err = emcore_initialize_async_task_handler(task)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_initialize_async_task_handler failed. [%d]", err); - goto FINISH_OFF; - } - - /* create a thread to do this task */ - if((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) { - EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err); - } - else { - /* Decode parameter */ - emcore_decode_task_parameter(task->task_type, task->task_parameter, task->task_parameter_length, &decoded_task_parameter); - task_handler->task_handler_function(decoded_task_parameter); - } - -FINISH_OFF: - emcore_finalize_async_task_handler(task, err); - - EM_SAFE_FREE(decoded_task_parameter); - - EM_DEBUG_FUNC_END("err [%d]", err); - return NULL; -} - -INTERNAL_FUNC void* emcore_default_sync_task_handler(void *intput_param) -{ - EM_DEBUG_FUNC_BEGIN("intput_param [%p]", intput_param); - int err = EMAIL_ERROR_NONE; - email_task_t *task = intput_param; - email_task_handler_t *task_handler = NULL; - void *decoded_task_parameter = NULL; - - /* create a thread to do this task */ - if((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) { - EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err); - } - else { - /* Decode parameter */ - emcore_decode_task_parameter(task->task_type, task->task_parameter, task->task_parameter_length, &decoded_task_parameter); - err = (int)task_handler->task_handler_function(decoded_task_parameter); - } - - EM_DEBUG_FUNC_END("err [%d]", err); - return (void*)err; -} -/*- task handlers helpers - end --------------------------------------------*/ - -int _task_handler_array_size; -email_task_handler_t **_task_handler_array; - -static int emcore_register_task_handler(email_task_type_t input_task_type, void* (*input_task_handler)(void *), int (*input_task_parameter_encoder)(void*,char**,int*), int (*input_task_parameter_decoder)(char*,int,void**)) -{ - EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_handler [%p] input_task_parameter_encoder [%p] input_task_parameter_decoder [%p]", input_task_type, input_task_handler, input_task_parameter_encoder, input_task_parameter_decoder); - int err = EMAIL_ERROR_NONE; - email_task_handler_t *new_task_handler = NULL; - - new_task_handler = malloc(sizeof(email_task_handler_t)); - - if (new_task_handler == NULL) { - err = EMAIL_ERROR_OUT_OF_MEMORY; - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - goto FINISH_OFF; - } - - new_task_handler->task_type = input_task_type; - new_task_handler->task_handler_function = input_task_handler; - new_task_handler->task_parameter_encoder = input_task_parameter_encoder; - new_task_handler->task_parameter_decoder = input_task_parameter_decoder; - - _task_handler_array_size++; - - if (_task_handler_array) { - _task_handler_array = realloc(_task_handler_array, sizeof(email_task_handler_t*) * _task_handler_array_size); - } - else { - _task_handler_array = malloc(sizeof(email_task_handler_t*) * _task_handler_array_size); - } - - if (_task_handler_array == NULL) { - err = EMAIL_ERROR_OUT_OF_MEMORY; - EM_SAFE_FREE(new_task_handler); - goto FINISH_OFF; - } - - _task_handler_array[_task_handler_array_size - 1] = new_task_handler; - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_init_task_handler_array() -{ - EM_DEBUG_FUNC_BEGIN(); - - if (_task_handler_array == NULL) { - _task_handler_array = NULL; - _task_handler_array_size = 0; - - REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT); - REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX); - REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL); - REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL); - REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE); - } - - EM_DEBUG_FUNC_END(); - return EMAIL_ERROR_NONE; -} - -INTERNAL_FUNC int emcore_free_task_handler_array() -{ - EM_DEBUG_FUNC_BEGIN(); - - int i = 0; - - for(i = 0; i < _task_handler_array_size; i++) { - EM_SAFE_FREE (_task_handler_array[i]); - } - - EM_SAFE_FREE (_task_handler_array); - _task_handler_array_size = 0; - - EM_DEBUG_FUNC_END(); - return EMAIL_ERROR_NONE; -} - -static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler) -{ - EM_DEBUG_FUNC_BEGIN("input_task_type [%d] output_task_handler [%p]", input_task_type, output_task_handler); - int i = 0; - int err = EMAIL_ERROR_NONE; - - if (output_task_handler == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - *output_task_handler = NULL; - for (i = 0; i < _task_handler_array_size; i++) { - if (_task_handler_array[i]->task_type == input_task_type) { - *output_task_handler = _task_handler_array[i]; - break; - } - } - - if (*output_task_handler == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_TASK_BINDER_NOT_FOUND"); - err = EMAIL_ERROR_TASK_BINDER_NOT_FOUND; - goto FINISH_OFF; - } - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_encode_task_parameter(email_task_type_t input_task_type, void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) -{ - EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_type, input_task_parameter_struct, output_byte_stream, output_stream_size); - int err = EMAIL_ERROR_NONE; - email_task_handler_t *task_handler = NULL; - int (*task_parameter_encoder)(void*, char**, int*); - - if (input_task_parameter_struct == NULL || output_byte_stream == NULL || output_stream_size == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err); - goto FINISH_OFF; - } - - task_parameter_encoder = task_handler->task_parameter_encoder; - - if ((err = task_parameter_encoder(input_task_parameter_struct, output_byte_stream, output_stream_size)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("task_parameter_encoder failed [%d]", err); - goto FINISH_OFF; - } - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_decode_task_parameter(email_task_type_t input_task_type, char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) -{ - EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_task_type, input_byte_stream, input_stream_size, output_task_parameter_struct); - int err = EMAIL_ERROR_NONE; - email_task_handler_t *task_handler = NULL; - int (*task_parameter_decoder)(char*, int, void**); - - if (input_byte_stream == NULL || output_task_parameter_struct == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err); - goto FINISH_OFF; - } - - task_parameter_decoder = task_handler->task_parameter_decoder; - +/* +* email-service +* +* Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. +* +* Contact: Kyuho Jo , Sunghyun Kwon +* +* 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. +* +*/ + +/* + * email-core-task-manager.c + * + * Created on: 2012. 11. 1. + * Author: kyuho.jo@samsung.com + */ + +#include +#include +#include +#include + +#include "email-internal-types.h" +#include "email-utilities.h" +#include "email-core-tasks.h" +#include "email-core-task-manager.h" +#include "email-core-signal.h" +#include "email-core-global.h" +#include "email-core-utils.h" +#include "email-debug-log.h" + +/* TODO : implement a function for removing a task from task pool */ +/* TODO : after fetching a task from DB, update status of the task. */ + + +#define REGISTER_TASK_BINDER(TASK_NAME) emcore_register_task_handler(TASK_NAME, task_handler_##TASK_NAME, email_encode_task_parameter_##TASK_NAME, email_decode_task_parameter_##TASK_NAME) + +/*- variables - begin --------------------------------------------------------*/ +static pthread_cond_t _task_available_signal = PTHREAD_COND_INITIALIZER; +static pthread_mutex_t _task_available_lock = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t _task_manager_loop_lock = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t _active_task_pool_lock = PTHREAD_MUTEX_INITIALIZER; + +static email_active_task_t _active_task_pool[MAX_ACTIVE_TASK]; +static thread_t _thread_task_manager_loop; +static int _task_manager_loop_availability = 1; +/*- variables - end ----------------------------------------------------------*/ +static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id); +static int emcore_remove_task_from_active_task_pool(int input_task_id); +static int emcore_find_available_slot_in_active_task_pool(int *result_index); +static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status); +static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler); + +/*- task handlers helpers - begin --------------------------------------------*/ +static int emcore_initialize_async_task_handler(email_task_t *input_task) +{ + EM_DEBUG_FUNC_BEGIN("input_task [%p]", input_task); + int err = EMAIL_ERROR_NONE; + + if(input_task == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + /* insert task to _active_task_pool */ + emcore_insert_task_to_active_task_pool(input_task->active_task_id + , input_task->task_id + , input_task->task_type + , THREAD_SELF()); + + /* send notification for 'task start */ + if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, EMAIL_TASK_STATUS_STARTED, EMAIL_ERROR_NONE, 0)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err); + goto FINISH_OFF; + } + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +static int emcore_finalize_async_task_handler(email_task_t *input_task, int input_error_code) +{ + EM_DEBUG_FUNC_BEGIN("input_task [%p] input_error_code [%d]",input_task ,input_error_code); + int err = EMAIL_ERROR_NONE; + email_task_status_type_t task_status = EMAIL_TASK_STATUS_FINISHED; + + if(input_task == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + if(input_error_code != EMAIL_ERROR_NONE) { + task_status = EMAIL_TASK_STATUS_FAILED; + } + + /* remove task from task table */ + if( (err = emcore_remove_task_from_task_table(NULL, input_task->task_id)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err); + goto FINISH_OFF; + } + + /* remove task id from active task id array */ + if( (err = emcore_remove_task_from_active_task_pool(input_task->task_id)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err); + goto FINISH_OFF; + } + + /* send signal for 'task finish or failure */ + if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, task_status, input_error_code, 0)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err); + goto FINISH_OFF; + } + + ENTER_CRITICAL_SECTION(_task_available_lock); + WAKE_CONDITION_VARIABLE(_task_available_signal); + LEAVE_CRITICAL_SECTION(_task_available_lock); + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC void* emcore_default_async_task_handler(void *input_param) +{ + EM_DEBUG_FUNC_BEGIN("intput_param [%p]", input_param); + int err = EMAIL_ERROR_NONE; + email_task_t *task = input_param; + email_task_handler_t *task_handler = NULL; + void *decoded_task_parameter = NULL; + + if((err = emcore_initialize_async_task_handler(task)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_initialize_async_task_handler failed. [%d]", err); + goto FINISH_OFF; + } + + /* create a thread to do this task */ + if ((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) { + EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err); + } + else { + /* Decode parameter */ + emcore_decode_task_parameter(task->task_type, + task->task_parameter, + task->task_parameter_length, + &decoded_task_parameter); + + task_handler->task_handler_function(decoded_task_parameter); + } + +FINISH_OFF: + emcore_finalize_async_task_handler(task, err); + + EM_SAFE_FREE(decoded_task_parameter); + + EM_DEBUG_FUNC_END("err [%d]", err); + return NULL; +} + +INTERNAL_FUNC int emcore_default_sync_task_handler(void *intput_param) +{ + EM_DEBUG_FUNC_BEGIN("intput_param [%p]", intput_param); + int err = EMAIL_ERROR_NONE; + int *return_err = NULL; + email_task_t *task = intput_param; + email_task_handler_t *task_handler = NULL; + void *decoded_task_parameter = NULL; + + /* create a thread to do this task */ + if ((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) { + EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err); + } else { + /* Decode parameter */ + emcore_decode_task_parameter(task->task_type, + task->task_parameter, + task->task_parameter_length, + &decoded_task_parameter); + + return_err = (int *)task_handler->task_handler_function(decoded_task_parameter); + } + + if (return_err) { + err = *return_err; + free(return_err); + } + + EM_SAFE_FREE(decoded_task_parameter); + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} +/*- task handlers helpers - end --------------------------------------------*/ + +int _task_handler_array_size; +email_task_handler_t **_task_handler_array; + +static int emcore_register_task_handler(email_task_type_t input_task_type, + void* (*input_task_handler)(void *), + int (*input_task_parameter_encoder)(void*,char**,int*), + int (*input_task_parameter_decoder)(char*,int,void**)) +{ + EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_handler [%p] " + "input_task_parameter_encoder [%p] input_task_parameter_decoder [%p]", + input_task_type, input_task_handler, + input_task_parameter_encoder, input_task_parameter_decoder); + + int err = EMAIL_ERROR_NONE; + email_task_handler_t *new_task_handler = NULL; + + new_task_handler = malloc(sizeof(email_task_handler_t)); + + if (new_task_handler == NULL) { + err = EMAIL_ERROR_OUT_OF_MEMORY; + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + goto FINISH_OFF; + } + + new_task_handler->task_type = input_task_type; + new_task_handler->task_handler_function = input_task_handler; + new_task_handler->task_parameter_encoder = input_task_parameter_encoder; + new_task_handler->task_parameter_decoder = input_task_parameter_decoder; + + _task_handler_array_size++; + + if (_task_handler_array) { + _task_handler_array = realloc(_task_handler_array, sizeof(email_task_handler_t*) * _task_handler_array_size); + } + else { + _task_handler_array = malloc(sizeof(email_task_handler_t*) * _task_handler_array_size); + } + + if (_task_handler_array == NULL) { + err = EMAIL_ERROR_OUT_OF_MEMORY; + EM_SAFE_FREE(new_task_handler); + goto FINISH_OFF; + } + + _task_handler_array[_task_handler_array_size - 1] = new_task_handler; + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_init_task_handler_array() +{ + EM_DEBUG_FUNC_BEGIN(); + + if (_task_handler_array == NULL) { + _task_handler_array = NULL; + _task_handler_array_size = 0; + + REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT); + REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX); + REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL); + REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL); + REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE); + } + + EM_DEBUG_FUNC_END(); + return EMAIL_ERROR_NONE; +} + +INTERNAL_FUNC int emcore_free_task_handler_array() +{ + EM_DEBUG_FUNC_BEGIN(); + + int i = 0; + + for(i = 0; i < _task_handler_array_size; i++) { + EM_SAFE_FREE (_task_handler_array[i]); + } + + EM_SAFE_FREE (_task_handler_array); + _task_handler_array_size = 0; + + EM_DEBUG_FUNC_END(); + return EMAIL_ERROR_NONE; +} + +static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler) +{ + EM_DEBUG_FUNC_BEGIN("input_task_type [%d] output_task_handler [%p]", input_task_type, output_task_handler); + int i = 0; + int err = EMAIL_ERROR_NONE; + + if (output_task_handler == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + *output_task_handler = NULL; + for (i = 0; i < _task_handler_array_size; i++) { + if (_task_handler_array[i]->task_type == input_task_type) { + *output_task_handler = _task_handler_array[i]; + break; + } + } + + if (*output_task_handler == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_TASK_BINDER_NOT_FOUND"); + err = EMAIL_ERROR_TASK_BINDER_NOT_FOUND; + goto FINISH_OFF; + } + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_encode_task_parameter(email_task_type_t input_task_type, void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) +{ + EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_type, input_task_parameter_struct, output_byte_stream, output_stream_size); + int err = EMAIL_ERROR_NONE; + email_task_handler_t *task_handler = NULL; + int (*task_parameter_encoder)(void*, char**, int*); + + if (input_task_parameter_struct == NULL || output_byte_stream == NULL || output_stream_size == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err); + goto FINISH_OFF; + } + + task_parameter_encoder = task_handler->task_parameter_encoder; + + if ((err = task_parameter_encoder(input_task_parameter_struct, output_byte_stream, output_stream_size)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("task_parameter_encoder failed [%d]", err); + goto FINISH_OFF; + } + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_decode_task_parameter(email_task_type_t input_task_type, char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) +{ + EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_task_type, input_byte_stream, input_stream_size, output_task_parameter_struct); + int err = EMAIL_ERROR_NONE; + email_task_handler_t *task_handler = NULL; + int (*task_parameter_decoder)(char*, int, void**); + + if (input_byte_stream == NULL || output_task_parameter_struct == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err); + goto FINISH_OFF; + } + + task_parameter_decoder = task_handler->task_parameter_decoder; + if ((err = task_parameter_decoder(input_byte_stream, input_stream_size, output_task_parameter_struct)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("task_parameter_decoder failed [%d]", err); - goto FINISH_OFF; - } - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -int emcore_fetch_task_from_task_pool(email_task_t **output_task) -{ - EM_DEBUG_FUNC_BEGIN("output_task [%p]", output_task); - int err = EMAIL_ERROR_NONE; - int output_task_count; - + EM_DEBUG_EXCEPTION("task_parameter_decoder failed [%d]", err); + goto FINISH_OFF; + } + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +int emcore_fetch_task_from_task_pool(email_task_t **output_task) +{ + EM_DEBUG_FUNC_BEGIN("output_task [%p]", output_task); + int err = EMAIL_ERROR_NONE; + int output_task_count; + if ((err = emstorage_query_task(NULL, "WHERE task_status == 1", "ORDER BY date_time ASC, task_priority ASC LIMIT 0, 1", output_task, &output_task_count)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emstorage_query_task failed [%d]", err); - goto FINISH_OFF; - } - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - - -/*-Task manager loop - begin -------------------------------------------------------------*/ - - -static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id) -{ - EM_DEBUG_FUNC_BEGIN("input_task_slot_index [%d] input_task_id [%d] input_task_type [%d] input_thread_id [%d]", input_task_slot_index, input_task_id, input_task_type, input_thread_id); - int err = EMAIL_ERROR_NONE; - - ENTER_CRITICAL_SECTION(_active_task_pool_lock); - _active_task_pool[input_task_slot_index].task_id = input_task_id; - _active_task_pool[input_task_slot_index].task_type = input_task_type; - _active_task_pool[input_task_slot_index].thread_id = input_thread_id; - LEAVE_CRITICAL_SECTION(_active_task_pool_lock); - - EM_DEBUG_LOG("_active_task_pool[%d].task_id [%d]", input_task_slot_index, _active_task_pool[input_task_slot_index].task_id); - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -static int emcore_remove_task_from_active_task_pool(int input_task_id) -{ - EM_DEBUG_FUNC_BEGIN(" input_task_id [%d]", input_task_id); - int err = EMAIL_ERROR_NONE; - int i = 0; - - ENTER_CRITICAL_SECTION(_active_task_pool_lock); - for(i = 0; i < MAX_ACTIVE_TASK; i++) { - if(_active_task_pool[i].task_id == input_task_id) { - _active_task_pool[i].task_id = 0; - _active_task_pool[i].task_type = 0; - _active_task_pool[i].thread_id = 0; - break; - } - } - LEAVE_CRITICAL_SECTION(_active_task_pool_lock); - - if(i >= MAX_ACTIVE_TASK) { - EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_task_id); - err = EMAIL_ERROR_TASK_NOT_FOUND; - } - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_get_active_task_by_thread_id(thread_t input_thread_id, email_active_task_t **output_active_task) -{ - EM_DEBUG_FUNC_BEGIN(" input_thread_id [%d] output_active_task [%p]", input_thread_id, output_active_task); - int err = EMAIL_ERROR_NONE; - int i = 0; - - if (output_active_task == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - for(i = 0; i < MAX_ACTIVE_TASK; i++) { - if(_active_task_pool[i].thread_id == input_thread_id) { - *output_active_task = _active_task_pool + i; - break; - } - } - - if(i >= MAX_ACTIVE_TASK) { - EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_thread_id); - err = EMAIL_ERROR_TASK_NOT_FOUND; - } - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - - -static int emcore_find_available_slot_in_active_task_pool(int *result_index) -{ - EM_DEBUG_FUNC_BEGIN("result_index [%p]", result_index); - int i = 0; - int err = EMAIL_ERROR_NONE; - - if (result_index == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - ENTER_CRITICAL_SECTION(_active_task_pool_lock); - for(i = 0; i < MAX_ACTIVE_TASK; i++) { - if(_active_task_pool[i].task_id == 0) { - break; - } - } - - if(i >= MAX_ACTIVE_TASK) { - EM_DEBUG_EXCEPTION("There is no available task slot"); - err = EMAIL_NO_AVAILABLE_TASK_SLOT; - } - else { - _active_task_pool[i].task_id = -1; - *result_index = i; - } - LEAVE_CRITICAL_SECTION(_active_task_pool_lock); - -FINISH_OFF : - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -void* thread_func_task_manager_loop(void *arg) -{ - EM_DEBUG_FUNC_BEGIN(); - int err = EMAIL_ERROR_NONE; - int thread_error; - int available_slot_index = 0; - email_task_t *new_task = NULL; - - /* while loop */ - while (_task_manager_loop_availability) { - /* fetch task from DB */ - if( ((err = emcore_fetch_task_from_task_pool(&new_task)) == EMAIL_ERROR_NONE) && - ((err = emcore_find_available_slot_in_active_task_pool(&available_slot_index)) == EMAIL_ERROR_NONE) ) { - - /* update task status as STARTED */ - if((err = emcore_update_task_status_on_task_table(NULL, new_task->task_id, EMAIL_TASK_STATUS_STARTED)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_update_task_status_on_task_table failed [%d]", err); - } - new_task->active_task_id = available_slot_index; - - /* create a thread to do this task */ - THREAD_CREATE(new_task->thread_id, emcore_default_async_task_handler, new_task, thread_error); - EM_DEBUG_LOG("pthread_create returns [%d]", thread_error); - - /* new_task and task_parameter will be free in task handler. */ + EM_DEBUG_EXCEPTION("emstorage_query_task failed [%d]", err); + goto FINISH_OFF; + } + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + + +/*-Task manager loop - begin -------------------------------------------------------------*/ + + +static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id) +{ + EM_DEBUG_FUNC_BEGIN("input_task_slot_index [%d] input_task_id [%d] input_task_type [%d] input_thread_id [%d]", input_task_slot_index, input_task_id, input_task_type, input_thread_id); + int err = EMAIL_ERROR_NONE; + + ENTER_CRITICAL_SECTION(_active_task_pool_lock); + _active_task_pool[input_task_slot_index].task_id = input_task_id; + _active_task_pool[input_task_slot_index].task_type = input_task_type; + _active_task_pool[input_task_slot_index].thread_id = input_thread_id; + LEAVE_CRITICAL_SECTION(_active_task_pool_lock); + + EM_DEBUG_LOG("_active_task_pool[%d].task_id [%d]", input_task_slot_index, _active_task_pool[input_task_slot_index].task_id); + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +static int emcore_remove_task_from_active_task_pool(int input_task_id) +{ + EM_DEBUG_FUNC_BEGIN(" input_task_id [%d]", input_task_id); + int err = EMAIL_ERROR_NONE; + int i = 0; + + ENTER_CRITICAL_SECTION(_active_task_pool_lock); + for(i = 0; i < MAX_ACTIVE_TASK; i++) { + if(_active_task_pool[i].task_id == input_task_id) { + _active_task_pool[i].task_id = 0; + _active_task_pool[i].task_type = 0; + _active_task_pool[i].thread_id = 0; + break; + } + } + LEAVE_CRITICAL_SECTION(_active_task_pool_lock); + + if(i >= MAX_ACTIVE_TASK) { + EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_task_id); + err = EMAIL_ERROR_TASK_NOT_FOUND; + } + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_get_active_task_by_thread_id(thread_t input_thread_id, email_active_task_t **output_active_task) +{ + EM_DEBUG_FUNC_BEGIN(" input_thread_id [%d] output_active_task [%p]", input_thread_id, output_active_task); + int err = EMAIL_ERROR_NONE; + int i = 0; + + if (output_active_task == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + for(i = 0; i < MAX_ACTIVE_TASK; i++) { + if(_active_task_pool[i].thread_id == input_thread_id) { + *output_active_task = _active_task_pool + i; + break; + } + } + + if(i >= MAX_ACTIVE_TASK) { + EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_thread_id); + err = EMAIL_ERROR_TASK_NOT_FOUND; + } + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + + +static int emcore_find_available_slot_in_active_task_pool(int *result_index) +{ + EM_DEBUG_FUNC_BEGIN("result_index [%p]", result_index); + int i = 0; + int err = EMAIL_ERROR_NONE; + + if (result_index == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + ENTER_CRITICAL_SECTION(_active_task_pool_lock); + for(i = 0; i < MAX_ACTIVE_TASK; i++) { + if(_active_task_pool[i].task_id == 0) { + break; + } + } + + if(i >= MAX_ACTIVE_TASK) { + EM_DEBUG_EXCEPTION("There is no available task slot"); + err = EMAIL_NO_AVAILABLE_TASK_SLOT; + } + else { + _active_task_pool[i].task_id = -1; + *result_index = i; + } + LEAVE_CRITICAL_SECTION(_active_task_pool_lock); + +FINISH_OFF : + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +void* thread_func_task_manager_loop(void *arg) +{ + EM_DEBUG_FUNC_BEGIN(); + int err = EMAIL_ERROR_NONE; + int thread_error; + int available_slot_index = 0; + email_task_t *new_task = NULL; + + /* while loop */ + while (_task_manager_loop_availability) { + /* fetch task from DB */ + if( ((err = emcore_fetch_task_from_task_pool(&new_task)) == EMAIL_ERROR_NONE) && + ((err = emcore_find_available_slot_in_active_task_pool(&available_slot_index)) == EMAIL_ERROR_NONE) ) { + + /* update task status as STARTED */ + if((err = emcore_update_task_status_on_task_table(NULL, new_task->task_id, EMAIL_TASK_STATUS_STARTED)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_update_task_status_on_task_table failed [%d]", err); + } + new_task->active_task_id = available_slot_index; + + /* create a thread to do this task */ + THREAD_CREATE(new_task->thread_id, emcore_default_async_task_handler, new_task, thread_error); + EM_DEBUG_LOG("pthread_create returns [%d]", thread_error); + + /* new_task and task_parameter will be free in task handler. */ EM_SAFE_FREE(new_task->task_parameter); EM_SAFE_FREE(new_task); - } - else { - /* If there is no task or no available slot, sleep until someone wake you up. */ - /* Wake up case 1 : by emcore_add_task_to_task_table */ - /* Wake up case 2 : when some task terminated */ - ENTER_CRITICAL_SECTION(_task_available_lock); - SLEEP_CONDITION_VARIABLE(_task_available_signal, _task_available_lock); - LEAVE_CRITICAL_SECTION(_task_available_lock); - EM_DEBUG_LOG("thread_func_task_manager_loop wake up!"); - } - } - - EM_DEBUG_FUNC_END(); - return NULL; -} - -INTERNAL_FUNC int emcore_start_task_manager_loop() -{ - EM_DEBUG_FUNC_BEGIN(); - int thread_error; - int err = EMAIL_ERROR_NONE; - - memset(&_active_task_pool, 0, sizeof(email_active_task_t) * MAX_ACTIVE_TASK); - - if (_thread_task_manager_loop) { - EM_DEBUG_EXCEPTION("service thread is already running..."); - err = EMAIL_ERROR_ALREADY_INITIALIZED; - goto FINISH_OFF; - } - - _task_manager_loop_availability = 10; - - /* create thread */ - THREAD_CREATE(_thread_task_manager_loop, thread_func_task_manager_loop, NULL, thread_error); - - if (thread_error != 0) { - EM_DEBUG_EXCEPTION("cannot create thread [%d]", thread_error); - err = EMAIL_ERROR_SYSTEM_FAILURE; - goto FINISH_OFF; - } - -FINISH_OFF : - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_stop_task_manager_loop() -{ - EM_DEBUG_FUNC_BEGIN(); - - int err = EMAIL_ERROR_NONE; - - if (!_thread_task_manager_loop) { - EM_DEBUG_LOG("_thread_task_manager_loop is NULL "); - err = EMAIL_ERROR_UNKNOWN; - return err; - } - - /* TODO : cancel tasks */ - - /* stop event_data loop */ - _task_manager_loop_availability = 0; - - ENTER_CRITICAL_SECTION(_task_manager_loop_lock); - WAKE_CONDITION_VARIABLE(_task_available_signal); - LEAVE_CRITICAL_SECTION(_task_manager_loop_lock); - - /* wait for thread finished */ - THREAD_JOIN(_thread_task_manager_loop); - - _thread_task_manager_loop = 0; - - DELETE_CRITICAL_SECTION(_task_manager_loop_lock); - DELETE_CONDITION_VARIABLE(_task_available_signal); - - /* Free _active_task_pool */ - - //FINISH_OFF : - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_add_task_to_task_table(char *multi_user_name, email_task_type_t input_task_type, email_task_priority_t input_task_priority, char *input_task_parameter, int input_task_parameter_length, int *output_task_id) -{ - EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_priority [%d] input_task_parameter [%p] input_task_parameter_length [%d] output_task_id [%p]", input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, output_task_id); - int err = EMAIL_ERROR_NONE; - - if((err = emstorage_add_task(multi_user_name, input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, false, output_task_id)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emstorage_add_task failed [%d]", err); - goto FINISH_OFF; - } - - ENTER_CRITICAL_SECTION(_task_available_lock); - WAKE_CONDITION_VARIABLE(_task_available_signal); - LEAVE_CRITICAL_SECTION(_task_available_lock); - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int emcore_remove_task_from_task_table(char *multi_user_name, int input_task_id) -{ - EM_DEBUG_FUNC_BEGIN("input_task_id [%d]", input_task_id); - int err = EMAIL_ERROR_NONE; - - if((err = emstorage_delete_task(multi_user_name, input_task_id, true)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emstorage_delete_task failed [%d]", err); - goto FINISH_OFF; - } - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status) -{ - EM_DEBUG_FUNC_BEGIN("input_task_id [%d] task_status [%d]", input_task_id, task_status); - int err = EMAIL_ERROR_NONE; - - if((err = emstorage_update_task_status(multi_user_name, input_task_id, task_status, true)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emstorage_update_task_status failed [%d]", err); - goto FINISH_OFF; - } - -FINISH_OFF: - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -/*-Task manager loop - end-------------------------------------------------------------*/ + } + else { + /* If there is no task or no available slot, sleep until someone wake you up. */ + /* Wake up case 1 : by emcore_add_task_to_task_table */ + /* Wake up case 2 : when some task terminated */ + ENTER_CRITICAL_SECTION(_task_available_lock); + SLEEP_CONDITION_VARIABLE(_task_available_signal, _task_available_lock); + LEAVE_CRITICAL_SECTION(_task_available_lock); + EM_DEBUG_LOG("thread_func_task_manager_loop wake up!"); + } + } + + EM_DEBUG_FUNC_END(); + return NULL; +} + +INTERNAL_FUNC int emcore_start_task_manager_loop() +{ + EM_DEBUG_FUNC_BEGIN(); + int thread_error; + int err = EMAIL_ERROR_NONE; + + memset(&_active_task_pool, 0, sizeof(email_active_task_t) * MAX_ACTIVE_TASK); + + if (_thread_task_manager_loop) { + EM_DEBUG_EXCEPTION("service thread is already running..."); + err = EMAIL_ERROR_ALREADY_INITIALIZED; + goto FINISH_OFF; + } + + _task_manager_loop_availability = 10; + + /* create thread */ + THREAD_CREATE(_thread_task_manager_loop, thread_func_task_manager_loop, NULL, thread_error); + + if (thread_error != 0) { + EM_DEBUG_EXCEPTION("cannot create thread [%d]", thread_error); + err = EMAIL_ERROR_SYSTEM_FAILURE; + goto FINISH_OFF; + } + +FINISH_OFF : + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_stop_task_manager_loop() +{ + EM_DEBUG_FUNC_BEGIN(); + + int err = EMAIL_ERROR_NONE; + + if (!_thread_task_manager_loop) { + EM_DEBUG_LOG("_thread_task_manager_loop is NULL "); + err = EMAIL_ERROR_UNKNOWN; + return err; + } + + /* TODO : cancel tasks */ + + /* stop event_data loop */ + _task_manager_loop_availability = 0; + + ENTER_CRITICAL_SECTION(_task_manager_loop_lock); + WAKE_CONDITION_VARIABLE(_task_available_signal); + LEAVE_CRITICAL_SECTION(_task_manager_loop_lock); + + /* wait for thread finished */ + THREAD_JOIN(_thread_task_manager_loop); + + _thread_task_manager_loop = 0; + + DELETE_CRITICAL_SECTION(_task_manager_loop_lock); + DELETE_CONDITION_VARIABLE(_task_available_signal); + + /* Free _active_task_pool */ + + //FINISH_OFF : + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_add_task_to_task_table(char *multi_user_name, email_task_type_t input_task_type, email_task_priority_t input_task_priority, char *input_task_parameter, int input_task_parameter_length, int *output_task_id) +{ + EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_priority [%d] input_task_parameter [%p] input_task_parameter_length [%d] output_task_id [%p]", input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, output_task_id); + int err = EMAIL_ERROR_NONE; + + if((err = emstorage_add_task(multi_user_name, input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, false, output_task_id)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emstorage_add_task failed [%d]", err); + goto FINISH_OFF; + } + + ENTER_CRITICAL_SECTION(_task_available_lock); + WAKE_CONDITION_VARIABLE(_task_available_signal); + LEAVE_CRITICAL_SECTION(_task_available_lock); + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int emcore_remove_task_from_task_table(char *multi_user_name, int input_task_id) +{ + EM_DEBUG_FUNC_BEGIN("input_task_id [%d]", input_task_id); + int err = EMAIL_ERROR_NONE; + + if((err = emstorage_delete_task(multi_user_name, input_task_id, true)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emstorage_delete_task failed [%d]", err); + goto FINISH_OFF; + } + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status) +{ + EM_DEBUG_FUNC_BEGIN("input_task_id [%d] task_status [%d]", input_task_id, task_status); + int err = EMAIL_ERROR_NONE; + + if((err = emstorage_update_task_status(multi_user_name, input_task_id, task_status, true)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emstorage_update_task_status failed [%d]", err); + goto FINISH_OFF; + } + +FINISH_OFF: + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +/*-Task manager loop - end-------------------------------------------------------------*/ diff --git a/email-core/email-core-tasks.c b/email-core/email-core-tasks.c index 2f6f209..065154d 100755 --- a/email-core/email-core-tasks.c +++ b/email-core/email-core-tasks.c @@ -1,119 +1,119 @@ -/* -* email-service -* -* Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. -* -* Contact: Kyuho Jo , Sunghyun Kwon -* -* 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. -* -*/ -/* - * email-tasks.c - * - * Created on: 2012. 11. 5. - * Author: kyuho.jo@samsung.com - */ -#include -#include -#include - - -#include "email-debug-log.h" -#include "email-utilities.h" -#include "email-internal-types.h" -#include "email-core-tasks.h" -#include "email-core-task-manager.h" -#include "email-core-mail.h" -#include "email-core-smtp.h" -#include "email-core-mailbox-sync.h" -#include "email-core-signal.h" -#include "email-core-utils.h" -#include "tpl.h" - -/*-------------------------------------------------------------------------------------------*/ -/* to handle EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT */ -#define task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT "iiiB" - -INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) -{ - EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); - - int err = EMAIL_ERROR_NONE; - task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = input_task_parameter_struct; - tpl_bin tb; - tpl_node *tn = NULL; - void *result_data = NULL; - size_t result_data_length = 0; - - if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT - , &task_parameter->source_mailbox_id - , &task_parameter->target_mailbox_id - , &task_parameter->mail_id_count - , &tb); +/* +* email-service +* +* Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. +* +* Contact: Kyuho Jo , Sunghyun Kwon +* +* 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. +* +*/ +/* + * email-tasks.c + * + * Created on: 2012. 11. 5. + * Author: kyuho.jo@samsung.com + */ +#include +#include +#include + + +#include "email-debug-log.h" +#include "email-utilities.h" +#include "email-internal-types.h" +#include "email-core-tasks.h" +#include "email-core-task-manager.h" +#include "email-core-mail.h" +#include "email-core-smtp.h" +#include "email-core-mailbox-sync.h" +#include "email-core-signal.h" +#include "email-core-utils.h" +#include "tpl.h" + +/*-------------------------------------------------------------------------------------------*/ +/* to handle EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT */ +#define task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT "iiiB" + +INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) +{ + EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); + + int err = EMAIL_ERROR_NONE; + task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = input_task_parameter_struct; + tpl_bin tb; + tpl_node *tn = NULL; + void *result_data = NULL; + size_t result_data_length = 0; + + if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT + , &task_parameter->source_mailbox_id + , &task_parameter->target_mailbox_id + , &task_parameter->mail_id_count + , &tb); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); err = EMAIL_ERROR_SYSTEM_FAILURE; goto FINISH_OFF; } - tb.sz = sizeof(int) * task_parameter->mail_id_count; - tb.addr = task_parameter->mail_id_array; - tpl_pack(tn, 0); - tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); - tpl_free(tn); - - *output_byte_stream = result_data; - *output_stream_size = result_data_length; - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) -{ - EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); - int err = EMAIL_ERROR_NONE; - tpl_bin tb; - tpl_node *tn = NULL; - task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = NULL; - - if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT)); + tb.sz = sizeof(int) * task_parameter->mail_id_count; + tb.addr = task_parameter->mail_id_array; + tpl_pack(tn, 0); + tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); + tpl_free(tn); + + *output_byte_stream = result_data; + *output_stream_size = result_data_length; + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) +{ + EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); + int err = EMAIL_ERROR_NONE; + tpl_bin tb; + tpl_node *tn = NULL; + task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = NULL; + + if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT)); if (task_parameter == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT - , &task_parameter->source_mailbox_id - , &task_parameter->target_mailbox_id - , &task_parameter->mail_id_count - , &tb); + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT + , &task_parameter->source_mailbox_id + , &task_parameter->target_mailbox_id + , &task_parameter->mail_id_count + , &tb); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); EM_SAFE_FREE(task_parameter); @@ -121,127 +121,127 @@ INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAI goto FINISH_OFF; } - tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); - tpl_unpack(tn, 0); - if(task_parameter->mail_id_count <= 0 || tb.addr == NULL) { - EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb.addr); - } - else { - task_parameter->mail_id_array = tb.addr; - } - - *output_task_parameter_struct = task_parameter; - -FINISH_OFF: - - if(tn) - tpl_free(tn); - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_param) -{ - EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param); - int err = EMAIL_ERROR_NONE; - int err_for_signal = EMAIL_ERROR_NONE; - int i = 0; - int task_id = THREAD_SELF(); - task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_param = input_param; - - for(i = 0; i < task_param->mail_id_count; i++) { - if((err = emcore_move_mail_to_another_account(task_param->multi_user_name, task_param->mail_id_array[i], task_param->source_mailbox_id, task_param->target_mailbox_id, task_id)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_move_mail_to_another_account failed [%d]", err); - goto FINISH_OFF; - } - - /* Send progress signal */ - if((err_for_signal = emcore_send_task_status_signal(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT, task_id, EMAIL_TASK_STATUS_IN_PROGRESS, i, task_param->mail_id_count)) != EMAIL_ERROR_NONE) - EM_DEBUG_LOG("emcore_send_task_status_signal failed [%d]", err_for_signal); - } - -FINISH_OFF: - /* Free task parameter */ - EM_SAFE_FREE(task_param->mail_id_array); - EM_SAFE_FREE(task_param); - - EM_DEBUG_FUNC_END("err [%d]", err); - return NULL; -} -/*-------------------------------------------------------------------------------------------*/ -/* to handle EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX */ -#define task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX "iiBi" - -INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) -{ - EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); - - int err = EMAIL_ERROR_NONE; - task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = input_task_parameter_struct; - tpl_bin tb; - tpl_node *tn = NULL; - void *result_data = NULL; - size_t result_data_length = 0; - - if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX - , &task_parameter->account_id - , &task_parameter->mailbox_id_count - , &tb - , &task_parameter->on_server); + tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); + tpl_unpack(tn, 0); + if(task_parameter->mail_id_count <= 0 || tb.addr == NULL) { + EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb.addr); + } + else { + task_parameter->mail_id_array = tb.addr; + } + + *output_task_parameter_struct = task_parameter; + +FINISH_OFF: + + if(tn) + tpl_free(tn); + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_param) +{ + EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param); + int err = EMAIL_ERROR_NONE; + int err_for_signal = EMAIL_ERROR_NONE; + int i = 0; + int task_id = THREAD_SELF(); + task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_param = input_param; + + for(i = 0; i < task_param->mail_id_count; i++) { + if((err = emcore_move_mail_to_another_account(task_param->multi_user_name, task_param->mail_id_array[i], task_param->source_mailbox_id, task_param->target_mailbox_id, task_id)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_move_mail_to_another_account failed [%d]", err); + goto FINISH_OFF; + } + + /* Send progress signal */ + if((err_for_signal = emcore_send_task_status_signal(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT, task_id, EMAIL_TASK_STATUS_IN_PROGRESS, i, task_param->mail_id_count)) != EMAIL_ERROR_NONE) + EM_DEBUG_LOG("emcore_send_task_status_signal failed [%d]", err_for_signal); + } + +FINISH_OFF: + /* Free task parameter */ + EM_SAFE_FREE(task_param->mail_id_array); + EM_SAFE_FREE(task_param); + + EM_DEBUG_FUNC_END("err [%d]", err); + return NULL; +} +/*-------------------------------------------------------------------------------------------*/ +/* to handle EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX */ +#define task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX "iiBi" + +INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) +{ + EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); + + int err = EMAIL_ERROR_NONE; + task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = input_task_parameter_struct; + tpl_bin tb; + tpl_node *tn = NULL; + void *result_data = NULL; + size_t result_data_length = 0; + + if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX + , &task_parameter->account_id + , &task_parameter->mailbox_id_count + , &tb + , &task_parameter->on_server); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); err = EMAIL_ERROR_SYSTEM_FAILURE; goto FINISH_OFF; } - tb.sz = sizeof(int) * task_parameter->mailbox_id_count; - tb.addr = task_parameter->mailbox_id_array; - tpl_pack(tn, 0); - tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); - tpl_free(tn); - - *output_byte_stream = result_data; - *output_stream_size = result_data_length; - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) -{ - EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); - int err = EMAIL_ERROR_NONE; - tpl_bin tb; - tpl_node *tn = NULL; - task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = NULL; - - if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX)); - if(task_parameter == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX - , &task_parameter->account_id - , &task_parameter->mailbox_id_count - , &tb - , &task_parameter->on_server); + tb.sz = sizeof(int) * task_parameter->mailbox_id_count; + tb.addr = task_parameter->mailbox_id_array; + tpl_pack(tn, 0); + tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); + tpl_free(tn); + + *output_byte_stream = result_data; + *output_stream_size = result_data_length; + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) +{ + EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); + int err = EMAIL_ERROR_NONE; + tpl_bin tb; + tpl_node *tn = NULL; + task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = NULL; + + if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX)); + if(task_parameter == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX + , &task_parameter->account_id + , &task_parameter->mailbox_id_count + , &tb + , &task_parameter->on_server); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); EM_SAFE_FREE(task_parameter); @@ -249,93 +249,93 @@ INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX goto FINISH_OFF; } - tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); - tpl_unpack(tn, 0); - if(task_parameter->mailbox_id_count <= 0 || tb.addr == NULL) { - EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mailbox_id_count, tb.addr); - } - else { - task_parameter->mailbox_id_array = tb.addr; - } - - *output_task_parameter_struct = task_parameter; - -FINISH_OFF: - - if(tn) - tpl_free(tn); - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(void *input_param) -{ - return NULL; -} -/*-------------------------------------------------------------------------------------------*/ -/* to handle EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL */ -#define task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL "i" - -INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) -{ - EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); - - int err = EMAIL_ERROR_NONE; - task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = input_task_parameter_struct; - tpl_node *tn = NULL; - void *result_data = NULL; - size_t result_data_length = 0; - - if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL - , &task_parameter->mail_id); + tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); + tpl_unpack(tn, 0); + if(task_parameter->mailbox_id_count <= 0 || tb.addr == NULL) { + EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mailbox_id_count, tb.addr); + } + else { + task_parameter->mailbox_id_array = tb.addr; + } + + *output_task_parameter_struct = task_parameter; + +FINISH_OFF: + + if(tn) + tpl_free(tn); + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(void *input_param) +{ + return NULL; +} +/*-------------------------------------------------------------------------------------------*/ +/* to handle EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL */ +#define task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL "i" + +INTERNAL_FUNC int email_encode_task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) +{ + EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); + + int err = EMAIL_ERROR_NONE; + task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = input_task_parameter_struct; + tpl_node *tn = NULL; + void *result_data = NULL; + size_t result_data_length = 0; + + if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL + , &task_parameter->mail_id); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); err = EMAIL_ERROR_SYSTEM_FAILURE; goto FINISH_OFF; } - tpl_pack(tn, 0); - tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); - tpl_free(tn); - - *output_byte_stream = result_data; - *output_stream_size = result_data_length; - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) -{ - EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); - int err = EMAIL_ERROR_NONE; - tpl_node *tn = NULL; - task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = NULL; - - if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL)); + tpl_pack(tn, 0); + tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); + tpl_free(tn); + + *output_byte_stream = result_data; + *output_stream_size = result_data_length; + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) +{ + EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); + int err = EMAIL_ERROR_NONE; + tpl_node *tn = NULL; + task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = NULL; + + if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL)); if (task_parameter == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL - , &task_parameter->mail_id); + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL + , &task_parameter->mail_id); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); EM_SAFE_FREE(task_parameter); @@ -343,87 +343,87 @@ INTERNAL_FUNC int email_decode_task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DO goto FINISH_OFF; } - tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); - tpl_unpack(tn, 0); - - *output_task_parameter_struct = task_parameter; - -FINISH_OFF: - - if(tn) - tpl_free(tn); - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(void *input_param) -{ - return NULL; -} -/*-------------------------------------------------------------------------------------------*/ -/* to handle EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL */ -#define task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL "ii" - -INTERNAL_FUNC int email_encode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) -{ - EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); - - int err = EMAIL_ERROR_NONE; - task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_parameter = input_task_parameter_struct; - tpl_node *tn = NULL; - void *result_data = NULL; - size_t result_data_length = 0; - - if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL - , &task_parameter->mail_id, &task_parameter->scheduled_time); + tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); + tpl_unpack(tn, 0); + + *output_task_parameter_struct = task_parameter; + +FINISH_OFF: + + if(tn) + tpl_free(tn); + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(void *input_param) +{ + return NULL; +} +/*-------------------------------------------------------------------------------------------*/ +/* to handle EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL */ +#define task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL "ii" + +INTERNAL_FUNC int email_encode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) +{ + EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); + + int err = EMAIL_ERROR_NONE; + task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_parameter = input_task_parameter_struct; + tpl_node *tn = NULL; + void *result_data = NULL; + size_t result_data_length = 0; + + if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL + , &task_parameter->mail_id, &task_parameter->scheduled_time); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); err = EMAIL_ERROR_SYSTEM_FAILURE; goto FINISH_OFF; } - tpl_pack(tn, 0); - tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); - tpl_free(tn); - - *output_byte_stream = result_data; - *output_stream_size = result_data_length; - -FINISH_OFF: - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) -{ - EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); - int err = EMAIL_ERROR_NONE; - tpl_node *tn = NULL; - task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_parameter = NULL; - - if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - task_parameter = em_malloc(sizeof(task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL)); - if(task_parameter == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL - , &task_parameter->mail_id, &task_parameter->scheduled_time); + tpl_pack(tn, 0); + tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); + tpl_free(tn); + + *output_byte_stream = result_data; + *output_stream_size = result_data_length; + +FINISH_OFF: + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) +{ + EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); + int err = EMAIL_ERROR_NONE; + tpl_node *tn = NULL; + task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_parameter = NULL; + + if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + task_parameter = em_malloc(sizeof(task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL)); + if(task_parameter == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL + , &task_parameter->mail_id, &task_parameter->scheduled_time); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); EM_SAFE_FREE(task_parameter); @@ -431,268 +431,308 @@ INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_M goto FINISH_OFF; } - tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); - tpl_unpack(tn, 0); - - *output_task_parameter_struct = task_parameter; - -FINISH_OFF: - - if(tn) - tpl_free(tn); - - EM_DEBUG_FUNC_END("err [%d]", err); - return err; -} - -INTERNAL_FUNC void* task_handler_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(void *input_param) -{ - EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param); - int err = EMAIL_ERROR_NONE; - task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_param = input_param; - - if((err = emcore_schedule_sending_mail(task_param->multi_user_name, task_param->mail_id, task_param->scheduled_time)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_schedule_sending_mail [%d]", err); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - -FINISH_OFF: - + tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); + tpl_unpack(tn, 0); + + *output_task_parameter_struct = task_parameter; + +FINISH_OFF: + + if(tn) + tpl_free(tn); + + EM_DEBUG_FUNC_END("err [%d]", err); + return err; +} + +INTERNAL_FUNC void* task_handler_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(void *input_param) +{ + EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param); + + int err = EMAIL_ERROR_NONE; + int *return_err = NULL; + task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_param = input_param; + + if ((err = emcore_schedule_sending_mail(task_param->multi_user_name, + task_param->mail_id, + task_param->scheduled_time)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_schedule_sending_mail [%d]", err); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + return_err = em_malloc(sizeof(int)); + if (return_err == NULL) { + EM_DEBUG_EXCEPTION("em_malloc failed"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + *return_err = err; + +FINISH_OFF: + EM_SAFE_FREE(task_param); - emcore_close_smtp_stream_list (); - EM_DEBUG_FUNC_END("err [%d]", err); - return (void*)err; -} -/*-------------------------------------------------------------------------------------------*/ -/* to handle EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE */ -#define task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE "iiBiiB" - -INTERNAL_FUNC int email_encode_task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) -{ - EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); - - int err = EMAIL_ERROR_NONE; - task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_parameter = input_task_parameter_struct; - email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; - tpl_bin tb_mail_id_array; - tpl_bin tb_value; - tpl_node *tn = NULL; - void *result_data = NULL; - size_t result_data_length = 0; - - if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - if ((err = emcore_get_mail_attribute_value_type(task_parameter->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err); - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE - , &task_parameter->account_id - , &task_parameter->mail_id_count - , &tb_mail_id_array - , &task_parameter->attribute_type - , &task_parameter->value_length - , &tb_value); + emcore_close_smtp_stream_list(); + EM_DEBUG_FUNC_END("err [%d]", err); + + return (void *)return_err; +} +/*-------------------------------------------------------------------------------------------*/ +/* to handle EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE */ +#define task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE "iiBiiB" + +INTERNAL_FUNC int email_encode_task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size) +{ + EM_DEBUG_FUNC_BEGIN("input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_parameter_struct, output_byte_stream, output_stream_size); + + int err = EMAIL_ERROR_NONE; + task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_parameter = input_task_parameter_struct; + email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; + tpl_bin tb_mail_id_array; + tpl_bin tb_value; + tpl_node *tn = NULL; + void *result_data = NULL; + size_t result_data_length = 0; + + if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + if ((err = emcore_get_mail_attribute_value_type(task_parameter->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err); + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE + , &task_parameter->account_id + , &task_parameter->mail_id_count + , &tb_mail_id_array + , &task_parameter->attribute_type + , &task_parameter->value_length + , &tb_value); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); err = EMAIL_ERROR_SYSTEM_FAILURE; goto FINISH_OFF; } - - tb_mail_id_array.sz = sizeof(int) * task_parameter->mail_id_count; - tb_mail_id_array.addr = task_parameter->mail_id_array; - - switch(attribute_value_type) { - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER : - task_parameter->value_length = 4; - tb_value.sz = task_parameter->value_length; - tb_value.addr = &task_parameter->value.integer_type_value; - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING : - task_parameter->value_length = EM_SAFE_STRLEN(task_parameter->value.string_type_value); - tb_value.sz = task_parameter->value_length; - tb_value.addr = task_parameter->value.string_type_value; - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME : - task_parameter->value_length = 4; - tb_value.sz = task_parameter->value_length; - tb_value.addr = &task_parameter->value.datetime_type_value; - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE : - default : - EM_DEBUG_EXCEPTION("invalid attribute value type [%d]", attribute_value_type); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - tpl_pack(tn, 0); - tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); - - *output_byte_stream = result_data; - *output_stream_size = result_data_length; - -FINISH_OFF: - - if(tn) - tpl_free(tn); - - EM_DEBUG_FUNC_END("err [%d]", err); - return EMAIL_ERROR_NONE; -} - -INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) -{ - EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); - int err = EMAIL_ERROR_NONE; - tpl_node *tn = NULL; - tpl_bin tb_mail_id_array; - tpl_bin tb_value; - task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_parameter = NULL; - email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; - - if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - task_parameter = em_malloc(sizeof(task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE)); - - if(task_parameter == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - - tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE - , &task_parameter->account_id - , &task_parameter->mail_id_count - , &tb_mail_id_array - , &task_parameter->attribute_type - , &task_parameter->value_length - , &tb_value); + + tb_mail_id_array.sz = sizeof(int) * task_parameter->mail_id_count; + tb_mail_id_array.addr = task_parameter->mail_id_array; + + switch(attribute_value_type) { + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER : + task_parameter->value_length = 4; + tb_value.sz = task_parameter->value_length; + tb_value.addr = &task_parameter->value.integer_type_value; + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING : + task_parameter->value_length = EM_SAFE_STRLEN(task_parameter->value.string_type_value); + tb_value.sz = task_parameter->value_length; + tb_value.addr = task_parameter->value.string_type_value; + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME : + task_parameter->value_length = 4; + tb_value.sz = task_parameter->value_length; + tb_value.addr = &task_parameter->value.datetime_type_value; + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE : + default : + EM_DEBUG_EXCEPTION("invalid attribute value type [%d]", attribute_value_type); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + tpl_pack(tn, 0); + tpl_dump(tn, TPL_MEM, &result_data, &result_data_length); + + *output_byte_stream = result_data; + *output_stream_size = result_data_length; + +FINISH_OFF: + + if(tn) + tpl_free(tn); + + EM_DEBUG_FUNC_END("err [%d]", err); + return EMAIL_ERROR_NONE; +} + +INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct) +{ + EM_DEBUG_FUNC_BEGIN("input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_byte_stream, input_stream_size, output_task_parameter_struct); + int err = EMAIL_ERROR_NONE; + tpl_node *tn = NULL; + tpl_bin tb_mail_id_array; + tpl_bin tb_value; + task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_parameter = NULL; + email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; + + if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + task_parameter = em_malloc(sizeof(task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE)); + + if(task_parameter == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE + , &task_parameter->account_id + , &task_parameter->mail_id_count + , &tb_mail_id_array + , &task_parameter->attribute_type + , &task_parameter->value_length + , &tb_value); if (tn == NULL) { EM_DEBUG_EXCEPTION("tpl_map failed"); err = EMAIL_ERROR_SYSTEM_FAILURE; goto FINISH_OFF; } - - tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); - tpl_unpack(tn, 0); - - if(task_parameter->mail_id_count <= 0 || tb_mail_id_array.addr == NULL) { - EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb_mail_id_array.addr); - } - else { - task_parameter->mail_id_array = tb_mail_id_array.addr; - } - - if(tb_value.addr) { - if ((err = emcore_get_mail_attribute_value_type(task_parameter->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err); - goto FINISH_OFF; - } - - switch(attribute_value_type) { - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER : - memcpy(&task_parameter->value.integer_type_value, tb_value.addr, tb_value.sz); - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING : - task_parameter->value.string_type_value = em_malloc(tb_value.sz + 1); - if(task_parameter->value.string_type_value == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); - err = EMAIL_ERROR_OUT_OF_MEMORY; - goto FINISH_OFF; - } - memcpy(&task_parameter->value.string_type_value, tb_value.addr, tb_value.sz); - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME : - memcpy(&task_parameter->value.datetime_type_value, tb_value.addr, tb_value.sz); - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE : - default : - EM_DEBUG_EXCEPTION("invalid attribute value type [%d]", attribute_value_type); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - } - - *output_task_parameter_struct = task_parameter; - -FINISH_OFF: - - if(tn) - tpl_free(tn); - - EM_DEBUG_FUNC_END("err [%d]", err); - return EMAIL_ERROR_NONE; -} - -INTERNAL_FUNC void* task_handler_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(void *input_param) -{ - EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param); - if(!input_param) { /*prevent 43681*/ - EM_DEBUG_EXCEPTION("NULL parameter"); - return NULL; - } - - int err = EMAIL_ERROR_NONE; - char *field_name = NULL; - task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_param = input_param; - email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; /*prevent 43700*/ - - if((field_name = emcore_get_mail_field_name_by_attribute_type(task_param->attribute_type)) == NULL) { - EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); - err = EMAIL_ERROR_INVALID_PARAM; - goto FINISH_OFF; - } - - if((err = emcore_get_mail_attribute_value_type(task_param->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) { - EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err); - goto FINISH_OFF; - } - - switch(attribute_value_type) { - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER : - if(!emstorage_set_field_of_mails_with_integer_value(task_param->multi_user_name, task_param->account_id, task_param->mail_id_array, task_param->mail_id_count, field_name, task_param->value.integer_type_value, true, &err)) { - EM_DEBUG_EXCEPTION("emstorage_set_field_of_mails_with_integer_value failed [%d]", err); - goto FINISH_OFF; - } - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING : - err = EMAIL_ERROR_NOT_SUPPORTED; - EM_DEBUG_LOG("EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING is not supported"); - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME : - if(!emstorage_set_field_of_mails_with_integer_value(task_param->multi_user_name, task_param->account_id, task_param->mail_id_array, task_param->mail_id_count, field_name, task_param->value.datetime_type_value, true, &err)) { - EM_DEBUG_EXCEPTION("emstorage_set_field_of_mails_with_integer_value failed [%d]", err); - goto FINISH_OFF; - } - break; - case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE : - default : - EM_DEBUG_LOG("EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE or default"); - err = EMAIL_ERROR_INVALID_PARAM; - break; - } - -FINISH_OFF: - - EM_SAFE_FREE(task_param->multi_user_name); - EM_SAFE_FREE(task_param->mail_id_array); - if (attribute_value_type == EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING) { - EM_SAFE_FREE(task_param->value.string_type_value); - } - - EM_SAFE_FREE (task_param); - - EM_DEBUG_FUNC_END("err [%d]", err); - return (void*)err; -} -/*-------------------------------------------------------------------------------------------*/ + + tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size); + tpl_unpack(tn, 0); + + if(task_parameter->mail_id_count <= 0 || tb_mail_id_array.addr == NULL) { + EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb_mail_id_array.addr); + } + else { + task_parameter->mail_id_array = tb_mail_id_array.addr; + } + + if(tb_value.addr) { + if ((err = emcore_get_mail_attribute_value_type(task_parameter->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err); + goto FINISH_OFF; + } + + switch(attribute_value_type) { + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER : + memcpy(&task_parameter->value.integer_type_value, tb_value.addr, tb_value.sz); + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING : + task_parameter->value.string_type_value = em_malloc(tb_value.sz + 1); + if(task_parameter->value.string_type_value == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + memcpy(&task_parameter->value.string_type_value, tb_value.addr, tb_value.sz); + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME : + memcpy(&task_parameter->value.datetime_type_value, tb_value.addr, tb_value.sz); + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE : + default : + EM_DEBUG_EXCEPTION("invalid attribute value type [%d]", attribute_value_type); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + } + + *output_task_parameter_struct = task_parameter; + +FINISH_OFF: + + if(tn) + tpl_free(tn); + + EM_DEBUG_FUNC_END("err [%d]", err); + return EMAIL_ERROR_NONE; +} + +INTERNAL_FUNC void *task_handler_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(void *input_param) +{ + EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param); + if (!input_param) { /*prevent 43681*/ + EM_DEBUG_EXCEPTION("NULL parameter"); + return NULL; + } + + int err = EMAIL_ERROR_NONE; + int *return_err = NULL; + char *field_name = NULL; + task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_param = input_param; + email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; /*prevent 43700*/ + + if ((field_name = emcore_get_mail_field_name_by_attribute_type(task_param->attribute_type)) == NULL) { + EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); + err = EMAIL_ERROR_INVALID_PARAM; + goto FINISH_OFF; + } + + if ((err = emcore_get_mail_attribute_value_type(task_param->attribute_type, + &attribute_value_type)) != EMAIL_ERROR_NONE) { + EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err); + goto FINISH_OFF; + } + + switch(attribute_value_type) { + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER : + if (!emstorage_set_field_of_mails_with_integer_value(task_param->multi_user_name, + task_param->account_id, + task_param->mail_id_array, + task_param->mail_id_count, + field_name, + task_param->value.integer_type_value, + true, + &err)) { + EM_DEBUG_EXCEPTION("emstorage_set_field_of_mails_with_integer_value failed [%d]", err); + goto FINISH_OFF; + } + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING : + err = EMAIL_ERROR_NOT_SUPPORTED; + EM_DEBUG_LOG("EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING is not supported"); + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME : + if (!emstorage_set_field_of_mails_with_integer_value(task_param->multi_user_name, + task_param->account_id, + task_param->mail_id_array, + task_param->mail_id_count, + field_name, + task_param->value.datetime_type_value, + true, + &err)) { + EM_DEBUG_EXCEPTION("emstorage_set_field_of_mails_with_integer_value failed [%d]", err); + goto FINISH_OFF; + } + break; + case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE : + default : + EM_DEBUG_LOG("EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE or default"); + err = EMAIL_ERROR_INVALID_PARAM; + break; + } + + return_err = em_malloc(sizeof(int)); + if (return_err == NULL) { + EM_DEBUG_EXCEPTION("em_malloc failed"); + err = EMAIL_ERROR_OUT_OF_MEMORY; + goto FINISH_OFF; + } + + *return_err = err; + +FINISH_OFF: + + EM_SAFE_FREE(task_param->multi_user_name); + EM_SAFE_FREE(task_param->mail_id_array); + if (attribute_value_type == EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING) { + EM_SAFE_FREE(task_param->value.string_type_value); + } + + EM_SAFE_FREE (task_param); + + EM_DEBUG_FUNC_END("err [%d]", err); + + return (void *)return_err; +} +/*-------------------------------------------------------------------------------------------*/ diff --git a/email-core/email-core-utils.c b/email-core/email-core-utils.c index e58f53f..f2573f4 100755 --- a/email-core/email-core-utils.c +++ b/email-core/email-core-utils.c @@ -2464,8 +2464,8 @@ int emcore_strip_mail_body_from_file(char *multi_user_name, emstorage_mail_tbl_t char *prefix_path = NULL; char real_html_path[255] = {0}; char real_plain_path[255] = {0}; - unsigned int byte_read = 0; - unsigned int byte_written = 0; + gsize byte_read = 0; + gsize byte_written = 0; GError *glib_error = NULL; FILE *fp_plain = NULL; struct stat st_buf; @@ -2581,7 +2581,7 @@ int emcore_strip_mail_body_from_file(char *multi_user_name, emstorage_mail_tbl_t } EM_DEBUG_LOG("Extract the preview text, again"); - utf8_encoded_string = (char *)g_convert(buf, byte_read, "UTF-8", encoding_type, &byte_read, &byte_written, &glib_error); + utf8_encoded_string = (char *)g_convert(buf, -1, "UTF-8", encoding_type, &byte_read, &byte_written, &glib_error); if (utf8_encoded_string == NULL) { EM_SAFE_FREE(*stripped_text); *stripped_text = EM_SAFE_STRDUP(buf); @@ -2624,8 +2624,8 @@ int emcore_get_preview_text_from_file(char *multi_user_name, const char *input_p EM_DEBUG_FUNC_BEGIN("input_plain_path[%p], input_html_path[%p], input_preview_buffer_length [%d], output_preview_buffer[%p]", input_plain_path, input_html_path, input_preview_buffer_length, output_preview_buffer); int err = EMAIL_ERROR_NONE; - unsigned int byte_read = 0; - unsigned int byte_written = 0; + gsize byte_read = 0; + gsize byte_written = 0; int local_preview_buffer_length = 0; char *local_preview_text = NULL; char *encoding_type = NULL; @@ -2633,8 +2633,8 @@ int emcore_get_preview_text_from_file(char *multi_user_name, const char *input_p FILE *fp_plain = NULL; GError *glib_error = NULL; struct stat st_buf; - char *prefix_path = NULL; - char real_file_path[255] = {0}; + char *prefix_path = NULL; + char real_file_path[255] = {0}; if (!output_preview_buffer) { EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM"); @@ -2735,7 +2735,7 @@ int emcore_get_preview_text_from_file(char *multi_user_name, const char *input_p encoding_type = EM_SAFE_STRDUP("EUC-KR"); } - utf8_encoded_string = (char*)g_convert (local_preview_text, -1, "UTF-8", encoding_type, &byte_read, &byte_written, &glib_error); + utf8_encoded_string = (char *)g_convert(local_preview_text, -1, "UTF-8", encoding_type, &byte_read, &byte_written, &glib_error); if(utf8_encoded_string == NULL) { if (!g_error_matches (glib_error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE)) { @@ -2743,7 +2743,7 @@ int emcore_get_preview_text_from_file(char *multi_user_name, const char *input_p } EM_DEBUG_LOG("Extract the preview text, again"); - utf8_encoded_string = (char *)g_convert(local_preview_text, byte_read, "UTF-8", encoding_type, &byte_read, &byte_written, &glib_error); + utf8_encoded_string = (char *)g_convert(local_preview_text, -1, "UTF-8", encoding_type, &byte_read, &byte_written, &glib_error); if (utf8_encoded_string == NULL) { EM_DEBUG_LOG("g_convert fail, again"); goto FINISH_OFF; @@ -5225,33 +5225,6 @@ FINISH_OFF: return mime_entity_path; } -/* Feedback LED api */ -INTERNAL_FUNC void emcore_set_flash_noti() -{ - EM_DEBUG_FUNC_BEGIN(); - int flash_error = FEEDBACK_ERROR_NONE; - - flash_error = feedback_initialize(); - if (flash_error != FEEDBACK_ERROR_NONE) { - EM_DEBUG_EXCEPTION("feedback_initialize failed : [%d]", flash_error); - return; - } - -#ifdef __FEATURE_FEEDBACK_TYPE_LED_ENABLE__ - flash_error = feedback_play_type(FEEDBACK_TYPE_LED, FEEDBACK_PATTERN_EMAIL); - if (flash_error != FEEDBACK_ERROR_NONE) { - EM_DEBUG_EXCEPTION("feedback_play_type failed : [%d]", flash_error); - } -#endif /* __FEATURE_FEEDBACK_TYPE_LED_ENABLE__ */ - - flash_error = feedback_deinitialize(); - if (flash_error != FEEDBACK_ERROR_NONE) { - EM_DEBUG_EXCEPTION("feedback_play_type failed : [%d]", flash_error); - } - - EM_DEBUG_FUNC_END(); -} - INTERNAL_FUNC int emcore_get_content_from_file(char *filename, char **contents, int *length) { EM_DEBUG_FUNC_BEGIN("filename[%s], contents[%p], length[%p]", filename, contents, length); diff --git a/email-core/email-storage/email-storage.c b/email-core/email-storage/email-storage.c index c2ce544..b2060c6 100755 --- a/email-core/email-storage/email-storage.c +++ b/email-core/email-storage/email-storage.c @@ -65,10 +65,7 @@ #include "email-core-container.h" #include "email-core-key-manager.h" -#define DB_STMT sqlite3_stmt * - #define SETTING_MEMORY_TEMP_FILE_PATH "/tmp/email_tmp_file" - #define CONTENT_DATA " 5 bytes */ #define FILE_MAX_BUFFER_SIZE 16 * 1024 /* 16 Kbyte */ +#define DB_STMT sqlite3_stmt * + typedef struct { int mail_id; @@ -1023,7 +1025,15 @@ INTERNAL_FUNC int emstorage_update_save_status(char *multi_user_name, int accoun * @remarks N/A * @return This function returns 0 on success or error code on failure. */ -INTERNAL_FUNC int emstorage_mail_search_start(char *multi_user_name, emstorage_search_filter_t *search, int account_id, int mailbox_id, int sorting, int *search_handle, int *searched, int transaction, int *err_code); +INTERNAL_FUNC int emstorage_mail_search_start(char *multi_user_name, + emstorage_search_filter_t *search, + int account_id, + int mailbox_id, + int sorting, + DB_STMT *search_handle, + int *searched, + int transaction, + int *err_code); /* * emstorage_mail_search_result @@ -1034,7 +1044,11 @@ INTERNAL_FUNC int emstorage_mail_search_start(char *multi_user_name, emstorage_s * mail : double pointer to hold mail * return : */ -INTERNAL_FUNC int emstorage_mail_search_result(int search_handle, emstorage_mail_field_type_t type, void **data, int transaction, int *err_code); +INTERNAL_FUNC int emstorage_mail_search_result(DB_STMT search_handle, + emstorage_mail_field_type_t type, + void **data, + int transaction, + int *err_code); /* * emstorage_mail_search_end @@ -1044,7 +1058,7 @@ INTERNAL_FUNC int emstorage_mail_search_result(int search_handle, emstorage_mail * search_handle : handle to be finished * return : */ -INTERNAL_FUNC int emstorage_mail_search_end(int search_handle, int transaction, int *err_code); +INTERNAL_FUNC int emstorage_mail_search_end(DB_STMT search_handle, int transaction, int *err_code); /* * emstorage_set_field_of_mails_with_integer_value diff --git a/email-core/include/email-core-mail.h b/email-core/include/email-core-mail.h index 52b41d1..73c1b69 100755 --- a/email-core/include/email-core-mail.h +++ b/email-core/include/email-core-mail.h @@ -340,6 +340,7 @@ INTERNAL_FUNC int emcore_sync_flag_with_server(char *multi_user_name, int mail INTERNAL_FUNC int emcore_sync_seen_flag_with_server(char *multi_user_name, int mail_ids[], int num, int event_handle, int *err_code); INTERNAL_FUNC int emcore_set_flags_field(char *multi_user_name, int account_id, int mail_ids[], int num, email_flags_field_type field_type, int value, int *err_code); +INTERNAL_FUNC char* emcore_convert_mutf7_to_utf8(char *mailbox_name); INTERNAL_FUNC int emcore_convert_string_to_structure(const char *encoded_string, void **struct_var, email_convert_struct_type_e type); INTERNAL_FUNC int emcore_save_mail_file(char *multi_user_name, int account_id, int mail_id, int attachment_id, char *src_file_path, char *file_name, char *full_path, char *virtual_path, int *err_code); diff --git a/email-core/include/email-core-task-manager.h b/email-core/include/email-core-task-manager.h index 4f7279f..c792ef2 100755 --- a/email-core/include/email-core-task-manager.h +++ b/email-core/include/email-core-task-manager.h @@ -43,7 +43,7 @@ INTERNAL_FUNC int emcore_remove_task_from_task_table(char *multi_user_name, int INTERNAL_FUNC int emcore_get_active_task_by_thread_id(thread_t input_thread_id, email_active_task_t **output_active_task); INTERNAL_FUNC void* emcore_default_async_task_handler(void *intput_param); -INTERNAL_FUNC void* emcore_default_sync_task_handler(void *intput_param); +INTERNAL_FUNC int emcore_default_sync_task_handler(void *intput_param); INTERNAL_FUNC int emcore_start_task_manager_loop(); INTERNAL_FUNC int emcore_stop_task_manager_loop(); diff --git a/email-core/include/email-core-utils.h b/email-core/include/email-core-utils.h index 3a6573f..b9c5cb8 100755 --- a/email-core/include/email-core-utils.h +++ b/email-core/include/email-core-utils.h @@ -111,8 +111,6 @@ INTERNAL_FUNC int emcore_add_notification_for_send(char *multi_user_name, int ac INTERNAL_FUNC void emcore_update_notification_for_send(int account_id, int mail_id, double progress); INTERNAL_FUNC int emcore_delete_notification_for_read_mail(int mail_id); INTERNAL_FUNC int emcore_delete_notification_by_account(char *multi_user_name, int account_id, int with_noti_tray); -INTERNAL_FUNC void emcore_set_flash_noti(); - INTERNAL_FUNC int emcore_show_user_message(char *multi_user_name, int id, email_action_t action, int error); diff --git a/email-daemon/email-daemon-etc.c b/email-daemon/email-daemon-etc.c index a3861a0..e4a98fc 100755 --- a/email-daemon/email-daemon-etc.c +++ b/email-daemon/email-daemon-etc.c @@ -463,8 +463,6 @@ INTERNAL_FUNC int emdaemon_finalize_sync(char *multi_user_name, int account_id, EM_DEBUG_LOG("The email app is topmost"); } else { - /* LED feature */ -// emcore_set_flash_noti(); if ((err = emcore_add_notification(multi_user_name, account_id, 0, unread_mail_count, vip_unread_mail_count, 1, EMAIL_ERROR_NONE, NOTIFICATION_DISPLAY_APP_ALL)) != EMAIL_ERROR_NONE) EM_DEBUG_EXCEPTION("emcore_add_notification failed : [%d]", err); diff --git a/email-daemon/email-daemon-mail.c b/email-daemon/email-daemon-mail.c index aa2d318..cc7ef17 100755 --- a/email-daemon/email-daemon-mail.c +++ b/email-daemon/email-daemon-mail.c @@ -587,7 +587,7 @@ void* thread_func_to_delete_mail(void *thread_argument) int account_id = 0; int from_server = 0; int noti_param_2 = 0; - int handle = 0; + int handle = 0; char *multi_user_name = NULL; email_event_t *event_data = (email_event_t*)thread_argument; @@ -597,15 +597,17 @@ void* thread_func_to_delete_mail(void *thread_argument) from_server = event_data->event_param_data_5; multi_user_name = event_data->multi_user_name; - if (!emcore_delete_mail(multi_user_name, account_id, mail_id_list, mail_id_count, EMAIL_DELETE_LOCALLY, EMAIL_DELETED_BY_COMMAND, noti_param_2, &err)) { - EM_DEBUG_EXCEPTION(" emcore_delete_mail failed [%d]", err); + if (!emcore_delete_mail(multi_user_name, account_id, mail_id_list, + mail_id_count, EMAIL_DELETE_LOCALLY, + EMAIL_DELETED_BY_COMMAND, noti_param_2, &err)) { + EM_DEBUG_EXCEPTION("emcore_delete_mail failed [%d]", err); emcore_free_event(event_data); /* prevent 17922 */ EM_SAFE_FREE(event_data); goto FINISH_OFF; } if (from_server == EMAIL_DELETE_LOCAL_AND_SERVER || from_server == EMAIL_DELETE_FROM_SERVER) { - if (!emcore_insert_event(event_data, (int*)handle, &err)) { + if (!emcore_insert_event(event_data, &handle, &err)) { EM_DEBUG_EXCEPTION("emcore_insert_event failed [%d]", err); /* if (from_server != EMAIL_DELETE_LOCAL_AND_SERVER && from_server != EMAIL_DELETE_FROM_SERVER) { EM_SAFE_FREE(event_data->event_param_data_3); @@ -756,7 +758,8 @@ int emdaemon_delete_mail_all(char *multi_user_name, int input_mailbox_id, int in } #ifdef __FEATURE_LOCAL_ACTIVITY__ - int i, total = 0 , search_handle = 0; + int i, total = 0; + DB_STMT search_handle = 0; int *mail_ids = NULL; emstorage_activity_tbl_t new_activity; int activityid = 0; diff --git a/email-daemon/main.c b/email-daemon/main.c index 783d05a..035f495 100755 --- a/email-daemon/main.c +++ b/email-daemon/main.c @@ -3368,7 +3368,12 @@ void stb_handle_task(int task_type, HIPC_API a_hAPI) if(is_async_task) { /* add async task */ - if((err = emcore_add_task_to_task_table(NULL, task_type, EMAIL_TASK_PRIORITY_MID, task_parameter, task_parameter_length, &task_id)) != EMAIL_ERROR_NONE) { + if((err = emcore_add_task_to_task_table(NULL, + task_type, + EMAIL_TASK_PRIORITY_MID, + task_parameter, + task_parameter_length, + &task_id)) != EMAIL_ERROR_NONE) { EM_DEBUG_EXCEPTION("emcore_add_task_to_task_pool failed [%d]", err); goto FINISH_OFF; } @@ -3383,7 +3388,7 @@ void stb_handle_task(int task_type, HIPC_API a_hAPI) sync_task.task_parameter = task_parameter; sync_task.task_parameter_length = task_parameter_length; - if((err = (int)emcore_default_sync_task_handler(&sync_task)) != EMAIL_ERROR_NONE) { + if((err = emcore_default_sync_task_handler(&sync_task)) != EMAIL_ERROR_NONE) { EM_DEBUG_EXCEPTION("emcore_default_sync_task_handler failed [%d]", err); goto FINISH_OFF; } diff --git a/email-ipc/include/email-ipc.h b/email-ipc/include/email-ipc.h index 3fb55aa..0a574b9 100755 --- a/email-ipc/include/email-ipc.h +++ b/email-ipc/include/email-ipc.h @@ -73,6 +73,7 @@ EXPORT_API void emipc_destroy_email_api(HIPC_API input_api_handle); EXPORT_API long emipc_get_api_id(HIPC_API input_api_handle); EXPORT_API long emipc_get_app_id(HIPC_API input_api_handle); +EXPORT_API long emipc_get_response_id(HIPC_API input_api_handle); EXPORT_API bool emipc_add_parameter(HIPC_API api, EPARAMETER_DIRECTION direction, void *data, int data_length); EXPORT_API bool emipc_add_dynamic_parameter(HIPC_API api, EPARAMETER_DIRECTION direction, void *data, int data_length); diff --git a/utilities/test-application/testapp-mail.c b/utilities/test-application/testapp-mail.c index af15c2a..32219c3 100755 --- a/utilities/test-application/testapp-mail.c +++ b/utilities/test-application/testapp-mail.c @@ -45,8 +45,8 @@ #include "email-core-utils.h" #include "email-core-mime.h" -#define MAIL_TEMP_BODY "/tmp/utf-8" -#define HTML_TEMP_BODY "/tmp/utf-8.htm" +#define MAIL_TEMP_BODY "/tmp/utf8" +#define HTML_TEMP_BODY "/tmp/utf8.htm" /* static void testapp_test_print_sorting_menu() -- 2.7.4