4 * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
29 #include <contacts_internal.h>
31 #include "email-convert.h"
32 #include "email-storage.h"
33 #include "email-network.h"
34 #include "email-device.h"
35 #include "email-utilities.h"
36 #include "email-daemon.h"
37 #include "email-daemon-auto-poll.h"
38 #include "email-core-global.h"
39 #include "email-core-account.h"
40 #include "email-core-event.h"
41 #include "email-core-utils.h"
42 #include "email-core-mailbox.h"
43 #include "email-core-imap-mailbox.h"
44 #include "email-core-mail.h"
45 #include "email-core-mailbox-sync.h"
46 #include "email-core-smtp.h"
47 #include "email-core-utils.h"
48 #include "email-core-signal.h"
49 #include "email-debug-log.h"
51 #include "email-types.h"
52 #include "email-internal-types.h"
54 extern thread_t g_srv_thread;
55 extern pthread_cond_t _event_available_signal;
56 extern pthread_mutex_t *_event_queue_lock;
57 extern pthread_mutex_t *_event_handle_map_lock;
58 extern pthread_mutex_t *_event_callback_table_lock;
59 extern GQueue *g_event_que;
60 extern int g_event_loop;
61 extern int recv_thread_run;
63 #ifdef __FEATURE_WIFI_AUTO_DOWNLOAD__
64 extern pthread_cond_t _auto_downalod_available_signal;
67 static void *worker_event_queue(void *arg);
68 static int event_handler_EMAIL_EVENT_SYNC_HEADER(char *multi_user_name, int input_account_id, int input_mailbox_id, int handle_to_be_published, int *error);
69 static int event_handler_EMAIL_EVENT_VALIDATE_AND_CREATE_ACCOUNT(char *multi_user_name, email_account_t *account, int handle_to_be_published, int *error);
70 static int event_handler_EMAIL_EVENT_VALIDATE_ACCOUNT_EX(char *multi_user_name, email_account_t *input_account, int input_handle_to_be_published);
71 static int event_handler_EMAIL_EVENT_VALIDATE_AND_UPDATE_ACCOUNT(char *multi_user_name, int account_id, email_account_t *new_account_info, int handle_to_be_published, int *error);
72 static int event_handler_EMAIL_EVENT_SET_MAIL_SLOT_SIZE(char *multi_user_name, int account_id, int mailbox_id, int new_slot_size, int handle_to_be_published, int *error);
73 static int event_handler_EMAIL_EVENT_EXPUNGE_MAILS_DELETED_FLAGGED(char *multi_user_name, int input_account_id, int input_mailbox_id);
74 static int event_handler_EMAIL_EVENT_DOWNLOAD_BODY(char *multi_user_name, int account_id, int mail_id, int option, int handle_to_be_published, int *error);
75 static int event_handler_EMAIL_EVENT_DOWNLOAD_ATTACHMENT(char *multi_user_name, int account_id, int mail_id, int attachment_no, int handle_to_be_published, int *error);
76 static int event_handler_EMAIL_EVENT_SYNC_FLAGS_FIELD_TO_SERVER(char *multi_user_name, int mail_ids[], int num, email_flags_field_type field_type, int value, int *error);
77 static int event_handler_EMAIL_EVENT_VALIDATE_ACCOUNT(char *multi_user_name, int account_id, int handle_to_be_published, int *error);
78 static int event_handler_EMAIL_EVENT_UPDATE_MAIL(char *multi_user_name, email_mail_data_t *input_mail_data, email_attachment_data_t *input_attachment_data_list, int input_attachment_count, email_meeting_request_t* input_meeting_request, int input_from_eas, int handle_to_be_published);
79 static int event_handler_EMAIL_EVENT_SAVE_MAIL(char *multi_user_name, int input_account_id, int input_mail_id, int input_handle_to_be_published);
80 static int event_handler_EMAIL_EVENT_MOVE_MAIL(char *multi_user_name, int account_id, int *mail_ids, int mail_id_count, int dest_mailbox_id, int src_mailbox_id, int handle_to_be_published, int *error);
81 static int event_handler_EMAIL_EVENT_DELETE_MAILBOX(char *multi_user_name, int mailbox_id, int on_server, int recursive, int handle_to_be_published);
82 static int event_handler_EMAIL_EVENT_CREATE_MAILBOX(char *multi_user_name, email_mailbox_t *input_new_mailbox, int on_server, int handle_to_be_published);
83 static int event_handler_EMAIL_EVENT_SYNC_MAIL_FLAG_TO_SERVER(char *multi_user_name, int mail_id, int event_handle, int *error);
84 static int event_handler_EMAIL_EVENT_DELETE_MAIL_ALL(char *multi_user_name, int input_account_id, int input_mailbox_id, int input_from_server, int *error);
85 static int event_handler_EMAIL_EVENT_DELETE_MAIL(char *multi_user_name, int account_id, int *mail_id_list, int mail_id_count, int from_server, int *error);
86 static int event_hanlder_EMAIL_EVENT_SYNC_HEADER_OMA(char *multi_user_name, int account_id, char *maibox_name, int handle_to_be_published, int *error);
87 static int event_handler_EMAIL_EVENT_SEARCH_ON_SERVER(char *multi_user_name, int account_id, int mailbox_id, email_search_filter_t *input_search_filter, int input_search_filter_count, int handle_to_be_published);
88 static int event_handler_EMAIL_EVENT_RENAME_MAILBOX_ON_IMAP_SERVER(char *multi_user_name, int input_account_id, int input_mailbox_id, char *input_old_mailbox_path, char *input_new_mailbox_path, char *input_new_mailbox_alias, int handle_to_be_published);
90 static void* worker_send_event_queue(void *arg);
92 extern thread_t g_send_srv_thread;
93 extern pthread_cond_t _send_event_available_signal;
94 extern pthread_mutex_t *_send_event_queue_lock;
95 extern pthread_mutex_t *_send_event_handle_map_lock;
97 extern GQueue *g_send_event_que;
98 extern int g_send_event_loop;
99 extern int send_thread_run;
101 extern thread_t g_partial_body_thd;
102 extern pthread_cond_t _partial_body_thd_cond;
103 extern pthread_mutex_t _partial_body_thd_event_queue_lock;
105 extern email_event_partial_body_thd g_partial_body_thd_event_que[TOTAL_PARTIAL_BODY_EVENTS];
106 extern email_event_partial_body_thd g_partial_body_bulk_dwd_que[BULK_PARTIAL_BODY_DOWNLOAD_COUNT];
107 extern int g_partial_body_thd_next_event_idx;
108 //extern int g_partial_body_thd_loop;
109 extern int g_partial_body_thd_queue_empty;
110 extern int g_partial_body_thd_queue_full;
111 extern int g_partial_body_bulk_dwd_queue_empty;
113 extern email_event_t *sync_failed_event_data;
115 static gpointer partial_body_download_thread(gpointer data);
117 #ifdef __FEATURE_OPEN_SSL_MULTIHREAD_HANDLE__
119 #include <openssl/crypto.h>
121 #define MAX_THREAD_NUMBER 100
123 static pthread_mutex_t *lock_cs;
124 static long *lock_count;
126 void pthreads_locking_callback(int mode, int type, char *file, int line)
128 if (mode & CRYPTO_LOCK) {
129 pthread_mutex_lock(&(lock_cs[type]));
133 pthread_mutex_unlock(&(lock_cs[type]));
137 unsigned long pthreads_thread_id(void)
139 return (unsigned long)pthread_self();
142 INTERNAL_FUNC void emdaemon_setup_handler_for_open_ssl_multithread(void)
144 EM_DEBUG_FUNC_BEGIN();
147 lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
148 lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
150 for (i = 0; i < CRYPTO_num_locks(); i++) {
152 pthread_mutex_init(&(lock_cs[i]),NULL);
155 CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
156 CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
160 INTERNAL_FUNC void emdaemon_cleanup_handler_for_open_ssl_multithread(void)
162 EM_DEBUG_FUNC_BEGIN();
165 CRYPTO_set_locking_callback(NULL);
166 for (i = 0; i < CRYPTO_num_locks(); i++)
168 pthread_mutex_destroy(&(lock_cs[i]));
169 EM_DEBUG_LOG("%8ld:%s",lock_count[i], CRYPTO_get_lock_name(i));
171 OPENSSL_free(lock_cs);
172 OPENSSL_free(lock_count);
177 #endif /* __FEATURE_OPEN_SSL_MULTIHREAD_HANDLE__ */
179 /* start api event_data loop */
180 INTERNAL_FUNC int emdaemon_start_event_loop(int *err_code)
182 EM_DEBUG_FUNC_BEGIN();
185 if (err_code != NULL)
186 *err_code = EMAIL_ERROR_NONE;
188 g_event_que = g_queue_new();
189 g_queue_init(g_event_que);
192 EM_DEBUG_EXCEPTION("service thread is already running...");
193 if (err_code != NULL)
194 *err_code = EMAIL_ERROR_UNKNOWN;
200 /* initialize lock */
201 INITIALIZE_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
202 INITIALIZE_RECURSIVE_CRITICAL_SECTION(_event_handle_map_lock);
203 INITIALIZE_RECURSIVE_CRITICAL_SECTION(_event_callback_table_lock);
205 emcore_initialize_event_callback_table();
208 THREAD_CREATE(g_srv_thread, worker_event_queue, NULL, thread_error);
210 if (thread_error != 0) {
211 EM_DEBUG_EXCEPTION("cannot create thread");
213 if (err_code != NULL)
214 *err_code = EMAIL_ERROR_SYSTEM_FAILURE;
218 if (err_code != NULL)
219 *err_code = EMAIL_ERROR_NONE;
224 /*Send event_data loop*/
225 INTERNAL_FUNC int emdaemon_start_event_loop_for_sending_mails(int *err_code)
227 EM_DEBUG_FUNC_BEGIN();
228 int thread_error = -1;
230 if (err_code != NULL)
231 *err_code = EMAIL_ERROR_NONE;
233 g_send_event_que = g_queue_new();
234 g_queue_init(g_send_event_que);
236 if (g_send_srv_thread) {
237 EM_DEBUG_EXCEPTION("send service thread is already running...");
238 if (err_code != NULL)
239 *err_code = EMAIL_ERROR_UNKNOWN;
243 g_send_event_loop = 1;
245 /* initialize lock */
246 INITIALIZE_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
247 INITIALIZE_RECURSIVE_CRITICAL_SECTION(_send_event_handle_map_lock);
248 INITIALIZE_CONDITION_VARIABLE(_send_event_available_signal);
251 THREAD_CREATE_JOINABLE(g_send_srv_thread, worker_send_event_queue, thread_error);
253 if (thread_error != 0) {
254 EM_DEBUG_EXCEPTION("cannot make thread...");
255 g_send_event_loop = 0;
256 if (err_code != NULL)
257 *err_code = EMAIL_ERROR_SYSTEM_FAILURE;
261 if (err_code != NULL)
262 *err_code = EMAIL_ERROR_NONE;
268 static void* worker_event_queue(void *arg)
270 EM_DEBUG_FUNC_BEGIN();
272 int err = EMAIL_ERROR_NONE;
273 int is_storage_full = false;
275 email_event_t *event_data = NULL;
276 email_event_t *started_event = NULL;
277 emstorage_account_tbl_t *account_tbl = NULL;
278 int handle_to_be_published = 0;
279 int pbd_thd_state = 0;
280 int send_event_que_state = 0;
282 if (!emstorage_open(NULL, &err)) {
283 EM_DEBUG_EXCEPTION("emstorage_open falied [%d]", err);
287 /* check that event_data loop is continuous */
288 while (emcore_event_loop_continue()) {
290 pbd_thd_state = emcore_get_pbd_thd_state();
291 send_event_que_state = emcore_is_send_event_queue_empty();
293 /* get a event_data from event_data queue */
294 ENTER_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
295 if (!emcore_retrieve_event(&event_data, &err)) {
296 /* no event_data pending */
297 if (err != EMAIL_ERROR_EVENT_QUEUE_EMPTY) {
298 LEAVE_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
303 emdevice_set_sleep_on_off(STAY_AWAKE_FLAG_FOR_RECEVING_WORKER, true, NULL);
305 #ifdef __FEATURE_WIFI_AUTO_DOWNLOAD__
307 if ((err = emnetwork_get_wifi_status(&wifi_status)) != EMAIL_ERROR_NONE) {
308 EM_DEBUG_EXCEPTION("emnetwork_get_wifi_status failed [%d]", err);
311 EM_DEBUG_LOG("WIFI Status [%d]", wifi_status);
313 if (!pbd_thd_state && send_event_que_state && wifi_status > 1) {
314 WAKE_CONDITION_VARIABLE(_auto_downalod_available_signal);
318 //go to sleep when queue is empty
319 SLEEP_CONDITION_VARIABLE(_event_available_signal, *_event_queue_lock);
320 EM_DEBUG_LOG("Wake up by _event_available_signal");
321 LEAVE_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
324 LEAVE_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
325 EM_DEBUG_LOG_DEV(">>>>>>>>>>>>>>> Got event_data !!! <<<<<<<<<<<<<<<");
327 emdevice_set_sleep_on_off(STAY_AWAKE_FLAG_FOR_RECEVING_WORKER, false, NULL);
329 handle_to_be_published = event_data->handle;
330 EM_DEBUG_LOG("Handle to be Published [%d]", handle_to_be_published);
333 /* Handling storage full */
334 is_storage_full = false;
335 if (event_data->type == EMAIL_EVENT_SYNC_HEADER ||
336 event_data->type == EMAIL_EVENT_SYNC_HEADER_OMA ||
337 event_data->type == EMAIL_EVENT_DOWNLOAD_BODY ||
338 event_data->type == EMAIL_EVENT_DOWNLOAD_ATTACHMENT) {
340 if ((err = emcore_is_storage_full()) == EMAIL_ERROR_MAIL_MEMORY_FULL) {
341 EM_DEBUG_EXCEPTION("Storage is full");
342 switch (event_data->type) {
343 case EMAIL_EVENT_SYNC_HEADER:
344 case EMAIL_EVENT_SYNC_HEADER_OMA:
345 noti_id = NOTI_DOWNLOAD_FAIL;
347 case EMAIL_EVENT_DOWNLOAD_BODY:
348 noti_id = NOTI_DOWNLOAD_BODY_FAIL;
350 case EMAIL_EVENT_DOWNLOAD_ATTACHMENT:
351 noti_id = NOTI_DOWNLOAD_ATTACH_FAIL;
357 if (!emcore_notify_network_event(noti_id, event_data->account_id, NULL, handle_to_be_published, err))
358 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [NOTI_DOWNLOAD_FAIL] Failed >>>> ");
359 is_storage_full = true;
365 if (event_data->account_id > 0) {
366 if (!emstorage_get_account_by_id(event_data->multi_user_name, event_data->account_id, EMAIL_ACC_GET_OPT_DEFAULT, &account_tbl, false, &err)) {
367 EM_DEBUG_EXCEPTION("emstorage_get_account_by_id [%d]", err);
372 EM_DEBUG_LOG("account_id : [%d], sync_disabled : [%d]", event_data->account_id, account_tbl->sync_disabled);
374 if (!account_tbl || account_tbl->sync_disabled == 0) {
375 switch (event_data->type) {
376 case EMAIL_EVENT_SYNC_IMAP_MAILBOX: /* get imap mailbox list */
377 if (!emcore_sync_mailbox_list(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_3, handle_to_be_published, &err))
378 EM_DEBUG_EXCEPTION("emcore_sync_mailbox_list failed [%d]", err);
381 case EMAIL_EVENT_SYNC_HEADER: /* synchronize mail header */
382 if (is_storage_full == false)
383 event_handler_EMAIL_EVENT_SYNC_HEADER(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_5, handle_to_be_published, &err);
386 case EMAIL_EVENT_SYNC_HEADER_OMA: /* synchronize mail header for OMA */
387 if (is_storage_full == false)
388 event_hanlder_EMAIL_EVENT_SYNC_HEADER_OMA(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_1, handle_to_be_published, &err);
391 case EMAIL_EVENT_DOWNLOAD_BODY: /* download mail body */
392 if (is_storage_full == false)
393 event_handler_EMAIL_EVENT_DOWNLOAD_BODY(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4, event_data->event_param_data_5, handle_to_be_published, &err);
396 case EMAIL_EVENT_DOWNLOAD_ATTACHMENT: /* download attachment */
397 if (is_storage_full == false)
398 event_handler_EMAIL_EVENT_DOWNLOAD_ATTACHMENT(event_data->multi_user_name, event_data->account_id, (int)event_data->event_param_data_4, event_data->event_param_data_5, handle_to_be_published, &err);
401 case EMAIL_EVENT_SYNC_FLAGS_FIELD_TO_SERVER: /* Sync flags field */
402 event_handler_EMAIL_EVENT_SYNC_FLAGS_FIELD_TO_SERVER(event_data->multi_user_name, (int*)event_data->event_param_data_3, event_data->event_param_data_4 , event_data->event_param_data_5, event_data->event_param_data_6, &err);
405 case EMAIL_EVENT_DELETE_MAIL: /* delete mails */
406 event_handler_EMAIL_EVENT_DELETE_MAIL(event_data->multi_user_name, event_data->account_id, (int*)event_data->event_param_data_3, event_data->event_param_data_4, event_data->event_param_data_5, &err);
409 case EMAIL_EVENT_DELETE_MAIL_ALL: /* delete all mails */
410 event_handler_EMAIL_EVENT_DELETE_MAIL_ALL(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4, (int)event_data->event_param_data_5, &err);
412 #ifdef __FEATURE_SYNC_CLIENT_TO_SERVER__
413 case EMAIL_EVENT_SYNC_MAIL_FLAG_TO_SERVER:
414 event_handler_EMAIL_EVENT_SYNC_MAIL_FLAG_TO_SERVER(event_data->multi_user_name, (int)event_data->event_param_data_4, handle_to_be_published, &err);
418 case EMAIL_EVENT_CREATE_MAILBOX:
419 err = event_handler_EMAIL_EVENT_CREATE_MAILBOX(event_data->multi_user_name, (email_mailbox_t *)event_data->event_param_data_1, event_data->event_param_data_4, handle_to_be_published);
422 case EMAIL_EVENT_DELETE_MAILBOX:
423 err = event_handler_EMAIL_EVENT_DELETE_MAILBOX(event_data->multi_user_name, event_data->event_param_data_4, event_data->event_param_data_5, event_data->event_param_data_6,handle_to_be_published);
426 case EMAIL_EVENT_SAVE_MAIL:
427 err = event_handler_EMAIL_EVENT_SAVE_MAIL(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4, handle_to_be_published);
430 case EMAIL_EVENT_MOVE_MAIL:
431 event_handler_EMAIL_EVENT_MOVE_MAIL(event_data->multi_user_name, event_data->account_id, (int *)event_data->event_param_data_3, event_data->event_param_data_4, event_data->event_param_data_5, event_data->event_param_data_8, handle_to_be_published, &err);
434 case EMAIL_EVENT_VALIDATE_ACCOUNT:
435 event_handler_EMAIL_EVENT_VALIDATE_ACCOUNT(event_data->multi_user_name, event_data->account_id, handle_to_be_published, &err);
438 case EMAIL_EVENT_VALIDATE_AND_CREATE_ACCOUNT: {
439 email_account_t *account = (email_account_t *)event_data->event_param_data_1;
440 event_handler_EMAIL_EVENT_VALIDATE_AND_CREATE_ACCOUNT(event_data->multi_user_name, account, handle_to_be_published, &err);
444 case EMAIL_EVENT_VALIDATE_ACCOUNT_EX: {
445 email_account_t *account = (email_account_t *)event_data->event_param_data_1;
446 err = event_handler_EMAIL_EVENT_VALIDATE_ACCOUNT_EX(event_data->multi_user_name, account, handle_to_be_published);
450 case EMAIL_EVENT_VALIDATE_AND_UPDATE_ACCOUNT: {
451 email_account_t *account = (email_account_t *)event_data->event_param_data_1;
452 event_handler_EMAIL_EVENT_VALIDATE_AND_UPDATE_ACCOUNT(event_data->multi_user_name, event_data->account_id, account, handle_to_be_published, &err);
456 case EMAIL_EVENT_UPDATE_MAIL:
457 event_handler_EMAIL_EVENT_UPDATE_MAIL(event_data->multi_user_name, (email_mail_data_t*)event_data->event_param_data_1, (email_attachment_data_t*)event_data->event_param_data_2, event_data->event_param_data_4, (email_meeting_request_t*)event_data->event_param_data_3, event_data->event_param_data_5, handle_to_be_published);
460 case EMAIL_EVENT_SET_MAIL_SLOT_SIZE:
461 event_handler_EMAIL_EVENT_SET_MAIL_SLOT_SIZE(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4, event_data->event_param_data_5, handle_to_be_published, &err);
464 case EMAIL_EVENT_EXPUNGE_MAILS_DELETED_FLAGGED:
465 err = event_handler_EMAIL_EVENT_EXPUNGE_MAILS_DELETED_FLAGGED(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4);
468 #ifdef __FEATURE_LOCAL_ACTIVITY__
469 case EMAIL_EVENT_LOCAL_ACTIVITY:
470 event_handler_EMAIL_EVENT_LOCAL_ACTIVITY(event_data->multi_user_name, event_data->account_id, handle_to_be_published, &err);
472 #endif /* __FEATURE_LOCAL_ACTIVITY__*/
474 case EMAIL_EVENT_SEARCH_ON_SERVER:
475 err = event_handler_EMAIL_EVENT_SEARCH_ON_SERVER(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4, (email_search_filter_t *)event_data->event_param_data_1, event_data->event_param_data_5, handle_to_be_published);
478 case EMAIL_EVENT_RENAME_MAILBOX_ON_IMAP_SERVER:
479 err = event_handler_EMAIL_EVENT_RENAME_MAILBOX_ON_IMAP_SERVER(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_4, (char*)event_data->event_param_data_1, (char*)event_data->event_param_data_2, (char*)event_data->event_param_data_3, handle_to_be_published);
482 case EMAIL_EVENT_QUERY_SMTP_MAIL_SIZE_LIMIT:
483 if (!emcore_query_mail_size_limit(event_data->multi_user_name, event_data->account_id, handle_to_be_published, &err))
484 EM_DEBUG_EXCEPTION("emcore_sync_mailbox_list failed [%d]", err);
492 if ((event_data->type == EMAIL_EVENT_SYNC_HEADER || event_data->type == EMAIL_EVENT_SYNC_IMAP_MAILBOX) && (err != EMAIL_ERROR_NONE)) {
493 EM_DEBUG_LOG("retry syncing");
494 /* for the retry syncing */
495 if (sync_failed_event_data) {
496 emcore_free_event(sync_failed_event_data);
497 EM_SAFE_FREE(sync_failed_event_data);
498 sync_failed_event_data = NULL;
501 sync_failed_event_data = em_malloc(sizeof(email_event_t));
502 if (sync_failed_event_data == NULL) {
503 EM_DEBUG_EXCEPTION("em_malloc failed");
504 err = EMAIL_ERROR_OUT_OF_MEMORY;
507 if (event_data->type == EMAIL_EVENT_SYNC_IMAP_MAILBOX && sync_failed_event_data) {
508 sync_failed_event_data->type = EMAIL_EVENT_SYNC_IMAP_MAILBOX;
509 sync_failed_event_data->account_id = event_data->account_id;
510 sync_failed_event_data->status = EMAIL_EVENT_STATUS_WAIT;
511 sync_failed_event_data->event_param_data_3 = EM_SAFE_STRDUP(event_data->event_param_data_3);
514 if (event_data->type == EMAIL_EVENT_SYNC_HEADER && sync_failed_event_data) {
515 sync_failed_event_data->type = EMAIL_EVENT_SYNC_HEADER;
516 sync_failed_event_data->account_id = event_data->account_id;
517 sync_failed_event_data->status = EMAIL_EVENT_STATUS_WAIT;
518 sync_failed_event_data->event_param_data_5 = event_data->event_param_data_5;
519 sync_failed_event_data->event_param_data_4 = event_data->event_param_data_4;
523 /* free internals in event */
524 emcore_free_event(event_data); /*detected by valgrind*/
527 emstorage_free_account(&account_tbl, 1, NULL);
531 if (!emcore_notify_response_to_api(event_data->type, handle_to_be_published, err))
532 EM_DEBUG_EXCEPTION("emcore_notify_response_to_api failed");
534 /* free event itself */
535 ENTER_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
536 started_event = g_queue_pop_head(g_event_que);
537 LEAVE_RECURSIVE_CRITICAL_SECTION(_event_queue_lock);
538 if (!started_event) {
539 EM_DEBUG_EXCEPTION("Failed to g_queue_pop_head");
542 emcore_return_handle(started_event->handle);
543 EM_SAFE_FREE(started_event);
549 if (!emstorage_close(&err))
550 EM_DEBUG_EXCEPTION("emstorage_close falied [%d]", err);
552 emcore_close_recv_stream_list();
557 static int event_handler_EMAIL_EVENT_SYNC_HEADER (char *multi_user_name, int input_account_id, int input_mailbox_id,
558 int handle_to_be_published, int *error)
560 EM_DEBUG_FUNC_BEGIN("input_account_id [%d], input_mailbox_id [%d], handle_to_be_published [%d], error[%p]",
561 input_account_id, input_mailbox_id, handle_to_be_published, error);
563 int err = EMAIL_ERROR_NONE, sync_type = 0, ret = false;
564 int mailbox_count = 0, account_count = 0;
565 int counter, account_index;
566 int unread = 0, total_unread = 0;
567 int vip_unread = 0, vip_total_unread = 0;
568 int vip_mail_count = 0, vip_total_mail = 0;
569 int mail_count = 0, total_mail = 0;
570 emcore_uid_list *uid_list = NULL;
571 emstorage_account_tbl_t *account_tbl_array = NULL;
572 emstorage_mailbox_tbl_t *mailbox_tbl_target = NULL, *mailbox_tbl_list = NULL;
573 #ifndef __FEATURE_KEEP_CONNECTION__
574 MAILSTREAM *stream = NULL;
576 char mailbox_id_param_string[10] = {0,};
577 char *input_mailbox_id_str = NULL;
579 if (input_mailbox_id == 0)
580 sync_type = EMAIL_SYNC_ALL_MAILBOX;
582 email_account_t *ref_account = NULL;
583 int sync_disabled = 0;
585 ref_account = emcore_get_account_reference(multi_user_name, input_account_id, false);
587 sync_disabled = ref_account->sync_disabled;
588 emcore_free_account(ref_account);
589 EM_SAFE_FREE(ref_account);
592 EM_DEBUG_LOG("sync_disabled[%d]", sync_disabled);
595 err = EMAIL_ERROR_ACCOUNT_SYNC_IS_DISALBED;
596 EM_DEBUG_LOG("Sync disabled for this account. Do not sync.");
600 if (!emstorage_get_mailbox_by_id(multi_user_name, input_mailbox_id, &mailbox_tbl_target) || !mailbox_tbl_target) {
601 EM_DEBUG_EXCEPTION("emstorage_get_mailbox_by_id failed [%d]", err);
605 if(mailbox_tbl_target)
606 SNPRINTF(mailbox_id_param_string, 10, "%d", mailbox_tbl_target->mailbox_id);
608 input_mailbox_id_str = (input_mailbox_id == 0)? NULL: mailbox_id_param_string;
610 /* if (!emcore_notify_network_event(NOTI_DOWNLOAD_START, input_account_id, input_mailbox_id_str, handle_to_be_published, 0))
611 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_DOWNLOAD_START] Failed >>>> ");
613 if (!emnetwork_check_network_status(&err)) {
614 EM_DEBUG_EXCEPTION("emnetwork_check_network_status error [%d]", err);
615 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FAIL, input_account_id, input_mailbox_id_str, handle_to_be_published, err))
616 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_DOWNLOAD_FAIL] Failed >>>> ");
620 if (sync_type != EMAIL_SYNC_ALL_MAILBOX) { /* Sync only particular mailbox */
621 EM_DEBUG_LOG_SEC ("sync start: account_id [%d] alias [%s]", input_account_id, mailbox_tbl_target->alias);
622 if ((err = emcore_update_sync_status_of_account(multi_user_name,
625 SYNC_STATUS_SYNCING)) != EMAIL_ERROR_NONE)
626 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed [%d]", err);
628 if (!emcore_sync_header (multi_user_name, mailbox_tbl_target, (void**) &stream,
629 &uid_list, &mail_count, &unread, &vip_mail_count,
630 &vip_unread, 1, handle_to_be_published, &err)) {
631 EM_DEBUG_EXCEPTION("emcore_sync_header failed [%d]", err);
632 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FAIL, mailbox_tbl_target->account_id, mailbox_id_param_string, handle_to_be_published, err))
633 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [NOTI_DOWNLOAD_FAIL] Failed >>>> ");
636 EM_DEBUG_LOG("emcore_sync_header succeeded [%d]", err);
637 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FINISH, mailbox_tbl_target->account_id, mailbox_id_param_string, handle_to_be_published, 0))
638 EM_DEBUG_EXCEPTION("emcore_notify_network_event [NOTI_DOWNLOAD_FINISH] Failed >>>> ");
641 stream = mail_close (stream);
643 total_unread += unread;
644 vip_total_unread += vip_unread;
645 total_mail += mail_count;
646 vip_total_mail += vip_mail_count;
648 if (total_unread > 0 && (emcore_update_sync_status_of_account(multi_user_name, input_account_id, SET_TYPE_UNION, SYNC_STATUS_HAVE_NEW_MAILS)) != EMAIL_ERROR_NONE) {
649 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed");
651 if ((err = emcore_update_sync_status_of_account(multi_user_name, input_account_id, SET_TYPE_MINUS, SYNC_STATUS_SYNCING)) != EMAIL_ERROR_NONE)
652 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed [%d]", err);
655 if (!emstorage_get_account_by_id(multi_user_name, input_account_id, EMAIL_ACC_GET_OPT_DEFAULT, &account_tbl_array, true, &err)) {
656 EM_DEBUG_EXCEPTION("emstorage_get_account_by_id failed [ %d ] ", err);
659 if (account_tbl_array && account_tbl_array->auto_download_size == 0) {
660 if (!emdaemon_finalize_sync(multi_user_name, input_account_id, 0, 0, 0, 0, true, NULL))
661 EM_DEBUG_EXCEPTION("emdaemon_finalize_sync failed");
664 if (account_tbl_array)
665 emstorage_free_account(&account_tbl_array, 1, NULL);
667 if (mailbox_tbl_target->mailbox_type == EMAIL_MAILBOX_TYPE_INBOX)
668 emcore_display_unread_in_badge(multi_user_name);
670 else /* All Folder */ {
671 EM_DEBUG_LOG ("sync start for all mailbox: account_id [%d]", input_account_id);
672 /* Sync of all mailbox */
674 if (input_account_id == ALL_ACCOUNT) {
675 if ((err = emcore_update_sync_status_of_account(multi_user_name, ALL_ACCOUNT, SET_TYPE_UNION, SYNC_STATUS_SYNCING)) != EMAIL_ERROR_NONE)
676 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed [%d]", err);
677 if (!emstorage_get_account_list(multi_user_name, &account_count, &account_tbl_array , true, false, &err)) {
678 EM_DEBUG_EXCEPTION("emstorage_get_account_list failed [ %d ] ", err);
679 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FAIL, input_account_id, NULL, handle_to_be_published, err))
680 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_DOWNLOAD_FAIL] Failed >>>> ");
685 if ((err = emcore_update_sync_status_of_account(multi_user_name, input_account_id, SET_TYPE_UNION, SYNC_STATUS_SYNCING)) != EMAIL_ERROR_NONE)
686 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed [%d]", err);
688 if (!emstorage_get_account_by_id(multi_user_name, input_account_id, EMAIL_ACC_GET_OPT_DEFAULT, &account_tbl_array, true, &err)) {
689 EM_DEBUG_EXCEPTION("emstorage_get_account_by_id failed [ %d ] ", err);
690 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FAIL, input_account_id, input_mailbox_id_str, handle_to_be_published, err))
691 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_DOWNLOAD_FAIL] Failed >>>> ");
697 for (account_index = 0 ; account_index < account_count; account_index++) {
698 if (account_tbl_array[account_index].incoming_server_type == EMAIL_SERVER_TYPE_ACTIVE_SYNC) {
699 EM_DEBUG_LOG ("account[%d] is for ActiveSync. Skip ", account_index);
703 if (account_tbl_array[account_index].sync_disabled == 1) {
704 EM_DEBUG_LOG ("account[%d] is sync-disabled. Skip ", account_index);
707 /* folder sync is also necessary */
708 if (!emstorage_get_mailbox_list (multi_user_name, account_tbl_array[account_index].account_id, 0,
709 EMAIL_MAILBOX_SORT_BY_TYPE_ASC, &mailbox_count, &mailbox_tbl_list, true, &err) ||
710 mailbox_count <= 0) {
711 EM_DEBUG_EXCEPTION ("emstorage_get_mailbox error [%d]", err);
712 if (!emcore_notify_network_event (NOTI_DOWNLOAD_FAIL, account_tbl_array[account_index].account_id,
713 input_mailbox_id_str, handle_to_be_published, err))
714 EM_DEBUG_EXCEPTION ("emcore_notify_network_event [NOTI_DOWNLOAD_FAIL] error >>>> ");
718 EM_DEBUG_LOG("emcore_get_mailbox_list_to_be_sync returns [%d] mailboxes", mailbox_count);
721 #ifndef __FEATURE_KEEP_CONNECTION__
722 if (account_tbl_array[account_index].incoming_server_type == EMAIL_SERVER_TYPE_IMAP4) {
723 memset(mailbox_id_param_string, 0, 10);
724 SNPRINTF(mailbox_id_param_string, 10, "%d", mailbox_tbl_list[0].mailbox_id);
725 if (!emcore_connect_to_remote_mailbox (multi_user_name, account_tbl_array[account_index].account_id,
726 mailbox_tbl_list[0].mailbox_id, (void **)&stream, &err)) {
727 EM_DEBUG_EXCEPTION("emcore_connect_to_remote_mailbox error [%d]", err);
728 if (err == EMAIL_ERROR_LOGIN_FAILURE)
729 EM_DEBUG_EXCEPTION("EMAIL_ERROR_LOGIN_FAILURE ");
731 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FAIL, account_tbl_array[account_index].account_id, mailbox_id_param_string, handle_to_be_published, err))
732 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [NOTI_DOWNLOAD_FAIL] Failed >>>> ");
735 EM_DEBUG_LOG ("emcore_connect_to_remote_mailbox returns [%d]", err);
738 stream = mail_close (stream);
741 for (counter = 0; counter < mailbox_count; counter++) {
743 EM_DEBUG_LOG_SEC("mailbox_name [%s], mailbox_id [%d], mailbox_type [%d]", mailbox_tbl_list[counter].mailbox_name, mailbox_tbl_list[counter].mailbox_id, mailbox_tbl_list[counter].mailbox_type);
744 vip_unread = unread = mail_count = 0;
745 if ( mailbox_tbl_list[counter].mailbox_type == EMAIL_MAILBOX_TYPE_ALL_EMAILS
746 || mailbox_tbl_list[counter].mailbox_type == EMAIL_MAILBOX_TYPE_TRASH
747 /*|| mailbox_tbl_list[counter].mailbox_type == EMAIL_MAILBOX_TYPE_SPAMBOX */) {
748 EM_DEBUG_LOG("Skipped for all emails or trash");
751 else if (!mailbox_tbl_list[counter].local_yn) {
752 EM_DEBUG_LOG_SEC("[%s] Syncing...", mailbox_tbl_list[counter].mailbox_name);
753 #ifdef __FEATURE_KEEP_CONNECTION__
754 if (!emcore_sync_header (multi_user_name,
755 (mailbox_tbl_list + counter),
759 &unread, &vip_mail_count, &vip_unread, 1, handle_to_be_published, &err))
760 #else /* __FEATURE_KEEP_CONNECTION__ */
761 if (!emcore_sync_header (multi_user_name,
762 (mailbox_tbl_list + counter),
766 &unread, &vip_mail_count, &vip_unread, 1, handle_to_be_published, &err))
767 #endif /* __FEATURE_KEEP_CONNECTION__ */
769 EM_DEBUG_EXCEPTION_SEC ("emcore_sync_header for %s(mailbox_id = %d) failed [%d]",
770 mailbox_tbl_list[counter].mailbox_name, mailbox_tbl_list[counter].mailbox_id, err);
772 #ifndef __FEATURE_KEEP_CONNECTION__
773 if (err == EMAIL_ERROR_CONNECTION_BROKEN || err == EMAIL_ERROR_NO_SUCH_HOST ||
774 err == EMAIL_ERROR_SOCKET_FAILURE)
775 stream = mail_close (stream);
776 #endif /* __FEATURE_KEEP_CONNECTION__ */
777 memset(mailbox_id_param_string, 0, 10);
778 SNPRINTF(mailbox_id_param_string, 10, "%d", mailbox_tbl_list[counter].mailbox_id);
779 if (!emcore_notify_network_event (NOTI_DOWNLOAD_FAIL,
780 account_tbl_array[account_index].account_id,
781 mailbox_id_param_string,
782 handle_to_be_published, err))
783 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_DOWNLOAD_FAIL] Failed >>>> ");
788 EM_DEBUG_LOG_SEC("---mailbox %s has unread %d / %d", mailbox_tbl_list[counter].mailbox_name,
790 total_unread += unread;
791 vip_total_unread += vip_unread;
792 total_mail += mail_count;
793 vip_total_mail += vip_mail_count;
795 if (mailbox_tbl_list[counter].mailbox_type == EMAIL_MAILBOX_TYPE_INBOX)
796 emcore_display_unread_in_badge(multi_user_name);
800 EM_DEBUG_LOG_SEC("Sync for account_id(%d) is completed....! (unread %d/%d)", account_tbl_array[account_index].account_id, total_unread, total_mail);
801 EM_DEBUG_LOG_SEC("Sync for account_id(%d) is completed....! (vip_unread %d/%d)", account_tbl_array[account_index].account_id, vip_total_unread, vip_total_mail);
803 if ((err == EMAIL_ERROR_NONE) && !emcore_notify_network_event(NOTI_DOWNLOAD_FINISH, account_tbl_array[account_index].account_id, NULL, handle_to_be_published, 0))
804 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_DOWNLOAD_FINISH] Failed >>>> ");
806 if ((total_unread > 0) && (emcore_update_sync_status_of_account(multi_user_name, account_tbl_array[account_index].account_id, SET_TYPE_UNION, SYNC_STATUS_HAVE_NEW_MAILS)) != EMAIL_ERROR_NONE) {
807 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed");
809 if ((err = emcore_update_sync_status_of_account(multi_user_name, input_account_id, SET_TYPE_MINUS, SYNC_STATUS_SYNCING)) != EMAIL_ERROR_NONE)
810 EM_DEBUG_EXCEPTION("emcore_update_sync_status_of_account failed [%d]", err);
813 if (account_tbl_array[account_index].auto_download_size == 0) {
814 if (!emdaemon_finalize_sync(multi_user_name, account_tbl_array[account_index].account_id, 0, 0, 0, 0, true, NULL))
815 EM_DEBUG_EXCEPTION("emdaemon_finalize_sync failed");
818 #ifndef __FEATURE_KEEP_CONNECTION__
820 stream = mail_close (stream);
822 if (mailbox_tbl_list) {
823 emstorage_free_mailbox(&mailbox_tbl_list, mailbox_count, NULL);
824 mailbox_tbl_list = NULL;
834 #ifndef __FEATURE_KEEP_CONNECTION__
836 stream = mail_close (stream);
841 if(mailbox_tbl_target)
842 emstorage_free_mailbox(&mailbox_tbl_target, 1, NULL);
844 if (mailbox_tbl_list)
845 emstorage_free_mailbox(&mailbox_tbl_list, mailbox_count, NULL);
847 if (account_tbl_array)
848 emstorage_free_account(&account_tbl_array, account_count, NULL);
854 static int event_handler_EMAIL_EVENT_VALIDATE_AND_CREATE_ACCOUNT(char *multi_user_name, email_account_t *account, int handle_to_be_published, int *error)
856 EM_DEBUG_FUNC_BEGIN("account [%p]", account);
857 int err, ret = false;
858 char *imap_cap_string = NULL;
861 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
862 err = EMAIL_ERROR_INVALID_PARAM;
866 EM_DEBUG_LOG_SEC("incoming_server_address : %s", account->incoming_server_address);
868 if (!emnetwork_check_network_status(&err)) {
869 emcore_delete_account_from_unvalidated_account_list(account->account_id);
870 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
871 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_CREATE_ACCOUNT_FAIL, account->account_id, NULL, handle_to_be_published, err))
872 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FAIL] Failed >>>> ");
876 EM_DEBUG_LOG_SEC("incoming_server_address : %s", account->incoming_server_address);
878 if (!emcore_validate_account_with_account_info(multi_user_name, account, EMAIL_EVENT_VALIDATE_AND_CREATE_ACCOUNT, &imap_cap_string, handle_to_be_published, &err)) {
879 emcore_delete_account_from_unvalidated_account_list(account->account_id);
880 EM_DEBUG_EXCEPTION("emcore_validate_account_with_account_info failed err : %d", err);
881 if (err == EMAIL_ERROR_CANCELLED) {
882 EM_DEBUG_EXCEPTION(" notify : NOTI_VALIDATE_AND_CREATE_ACCOUNT_CANCEL ");
883 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_CREATE_ACCOUNT_CANCEL, account->account_id, NULL, handle_to_be_published, err))
884 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_AND_CREATE_ACCOUNT_CANCEL] Failed");
891 emcore_delete_account_from_unvalidated_account_list(account->account_id);
893 if (emcore_create_account(multi_user_name, account, false, &err) == false) {
894 EM_DEBUG_EXCEPTION(" emdaemon_create_account failed - %d", err);
898 EM_DEBUG_LOG("incoming_server_type [%d]", account->incoming_server_type);
900 if ((EMAIL_SERVER_TYPE_IMAP4 == account->incoming_server_type)) {
901 if (!emcore_sync_mailbox_list(multi_user_name, account->account_id, "", handle_to_be_published, &err)) {
902 EM_DEBUG_EXCEPTION("emcore_get_mailbox_list_to_be_sync failed [%d]", err);
903 /* delete account whose mailbox couldn't be obtained from server */
904 emcore_delete_account(multi_user_name, account->account_id, false, NULL);
909 EM_DEBUG_LOG("validating and creating an account are succeeded for account id [%d] err [%d]", account->account_id, err);
910 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_CREATE_ACCOUNT_FINISH, account->account_id, imap_cap_string, handle_to_be_published, err))
911 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FINISH] Success");
918 if (ret == false && err != EMAIL_ERROR_CANCELLED && account) {
919 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_CREATE_ACCOUNT_FAIL, account->account_id, NULL, handle_to_be_published, err))
920 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_AND_CREATE_ACCOUNT_FAIL] Failed");
923 EM_SAFE_FREE(imap_cap_string);
932 static int event_handler_EMAIL_EVENT_VALIDATE_ACCOUNT_EX(char *multi_user_name, email_account_t *input_account, int input_handle_to_be_published)
934 EM_DEBUG_FUNC_BEGIN("input_account [%p]", input_account);
935 int err = EMAIL_ERROR_NONE;
936 char *server_capability_string = NULL;
939 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
940 err = EMAIL_ERROR_INVALID_PARAM;
944 EM_DEBUG_LOG_SEC("incoming_server_address [%s]", input_account->incoming_server_address);
946 if (!emnetwork_check_network_status(&err)) {
947 emcore_delete_account_from_unvalidated_account_list(input_account->account_id);
948 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
949 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_CREATE_ACCOUNT_FAIL, input_account->account_id, NULL, input_handle_to_be_published, err))
950 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FAIL] Failed >>>> ");
954 EM_DEBUG_LOG_SEC("incoming_server_address : %s", input_account->incoming_server_address);
956 if (!emcore_validate_account_with_account_info(multi_user_name, input_account, EMAIL_EVENT_VALIDATE_ACCOUNT_EX, &server_capability_string, input_handle_to_be_published, &err)) {
957 emcore_delete_account_from_unvalidated_account_list(input_account->account_id);
959 EM_DEBUG_EXCEPTION("emcore_validate_account_with_account_info failed err : %d", err);
961 if (err == EMAIL_ERROR_CANCELLED) {
962 EM_DEBUG_EXCEPTION(" notify : NOTI_VALIDATE_ACCOUNT_CANCEL ");
963 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_CANCEL, input_account->account_id, NULL, input_handle_to_be_published, err))
964 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_CANCEL] Failed");
971 emcore_delete_account_from_unvalidated_account_list(input_account->account_id);
973 EM_DEBUG_LOG("validating an account are succeeded for account id [%d] err [%d]", input_account->account_id, err);
974 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_FINISH, input_account->account_id, server_capability_string, input_handle_to_be_published, err))
975 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FINISH] Success");
980 if (err != EMAIL_ERROR_NONE && err != EMAIL_ERROR_CANCELLED && input_account) {
981 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_FAIL, input_account->account_id, NULL, input_handle_to_be_published, err))
982 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FAIL] Failed");
985 EM_SAFE_FREE(server_capability_string);
987 EM_DEBUG_FUNC_END("err[%d]", err);
991 static int event_handler_EMAIL_EVENT_VALIDATE_AND_UPDATE_ACCOUNT(char *multi_user_name, int account_id, email_account_t *new_account_info, int handle_to_be_published, int *error)
993 EM_DEBUG_FUNC_BEGIN("account_id [%d], new_account_info [%p]", account_id, new_account_info);
994 int err, ret = false;
995 char *imap_cap_string = NULL;
996 emstorage_account_tbl_t *old_account_tbl = NULL, *new_account_tbl = NULL;
997 email_account_t *duplicated_account_info = NULL, *old_account_info = NULL;
999 if (!new_account_info) {
1000 EM_DEBUG_EXCEPTION("Invalid Parameter");
1001 err = EMAIL_ERROR_INVALID_PARAM;
1005 if (!emnetwork_check_network_status(&err)) {
1006 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1008 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_UPDATE_ACCOUNT_FAIL, account_id, NULL, handle_to_be_published, err))
1009 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_AND_UPDATE_ACCOUNT_FAIL] Failed >>>> ");
1013 EM_DEBUG_LOG_SEC("incoming_server_address: (%s)", new_account_info->incoming_server_address);
1015 /* If the password fields are empty, fill the fields with password of old information*/
1016 if((old_account_info = emcore_get_account_reference(multi_user_name, account_id, true)) == NULL) {
1017 EM_DEBUG_EXCEPTION("emcore_get_account_reference failed ");
1021 EM_DEBUG_LOG_SEC("old_account_info->incoming_server_password [%s]", old_account_info->incoming_server_password);
1023 if( EM_SAFE_STRLEN (new_account_info->incoming_server_password) == 0 ) {
1024 EM_SAFE_FREE(new_account_info->incoming_server_password); /* be allocated but has zero length */
1025 EM_DEBUG_LOG_SEC("old_account_info->incoming_server_password [%s]", old_account_info->incoming_server_password);
1026 new_account_info->incoming_server_password = EM_SAFE_STRDUP(old_account_info->incoming_server_password);
1027 if(new_account_info->incoming_server_password == NULL) {
1028 EM_DEBUG_EXCEPTION("allocation for new_account_info->password failed");
1029 err = EMAIL_ERROR_OUT_OF_MEMORY;
1034 EM_DEBUG_LOG_SEC("old_account_info->outgoing_server_password [%s]", old_account_info->outgoing_server_password);
1036 if( EM_SAFE_STRLEN (new_account_info->outgoing_server_password) == 0 ) {
1037 EM_SAFE_FREE(new_account_info->outgoing_server_password);
1038 if(old_account_info->outgoing_server_password) {
1039 new_account_info->outgoing_server_password = EM_SAFE_STRDUP(old_account_info->outgoing_server_password);
1040 if(new_account_info->outgoing_server_password == NULL) {
1041 EM_DEBUG_EXCEPTION("allocation for new_account_info->outgoing_server_password failed");
1042 err = EMAIL_ERROR_OUT_OF_MEMORY;
1048 emcore_duplicate_account(new_account_info, &duplicated_account_info, &err);
1049 if (err != EMAIL_ERROR_NONE ) {
1050 EM_DEBUG_EXCEPTION("emcore_duplicate_account failed [%d]", err);
1054 if((err = emcore_add_account_to_unvalidated_account_list(duplicated_account_info)) != EMAIL_ERROR_NONE) {
1055 EM_DEBUG_EXCEPTION("emcore_add_account_to_unvalidated_account_list failed [%d]", err);
1059 if (!emcore_validate_account_with_account_info(multi_user_name, duplicated_account_info, EMAIL_EVENT_VALIDATE_AND_UPDATE_ACCOUNT, &imap_cap_string, handle_to_be_published, &err)) {
1060 EM_DEBUG_EXCEPTION("emcore_validate_account_with_account_info() failed err : %d", err);
1061 if (err == EMAIL_ERROR_CANCELLED) {
1062 EM_DEBUG_EXCEPTION(" notify : NOTI_VALIDATE_AND_CREATE_ACCOUNT_CANCEL ");
1063 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_UPDATE_ACCOUNT_CANCEL, account_id, NULL, handle_to_be_published, err))
1064 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_AND_UPDATE_ACCOUNT_CANCEL] Failed");
1072 if (!emstorage_get_account_by_id(multi_user_name, account_id, WITHOUT_OPTION, &old_account_tbl, true, &err)) {
1073 EM_DEBUG_EXCEPTION("emstorage_get_account_by_id failed [%d]", err);
1074 /* goto FINISH_OFF; */
1076 duplicated_account_info->account_id = account_id;
1078 new_account_tbl = em_malloc(sizeof(emstorage_account_tbl_t));
1079 if (!new_account_tbl) {
1080 EM_DEBUG_EXCEPTION("allocation failed");
1081 err = EMAIL_ERROR_OUT_OF_MEMORY;
1085 em_convert_account_to_account_tbl(duplicated_account_info, new_account_tbl);
1087 if (!emstorage_update_account(multi_user_name, account_id, new_account_tbl, true, &err)) {
1088 EM_DEBUG_EXCEPTION("emstorage_update_account failed : [%d]", err);
1091 EM_DEBUG_LOG("validating and updating an account are succeeded for account id [%d], err [%d]", duplicated_account_info->account_id, err);
1092 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_UPDATE_ACCOUNT_FINISH, new_account_info->account_id, imap_cap_string, handle_to_be_published, err))
1093 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [NOTI_VALIDATE_AND_UPDATE_ACCOUNT_FINISH] Success");
1101 if (duplicated_account_info) {
1102 if (duplicated_account_info->account_id < 0)
1103 emcore_delete_account_from_unvalidated_account_list(duplicated_account_info->account_id);
1105 emcore_free_account(duplicated_account_info);
1106 EM_SAFE_FREE(duplicated_account_info);
1110 if (old_account_info) {
1111 emcore_free_account(old_account_info);
1112 EM_SAFE_FREE(old_account_info);
1115 if (old_account_tbl)
1116 emstorage_free_account(&old_account_tbl, 1, NULL);
1117 if (new_account_tbl)
1118 emstorage_free_account(&new_account_tbl, 1, NULL);
1120 if (ret == false && err != EMAIL_ERROR_CANCELLED) {
1121 if (!emcore_notify_network_event(NOTI_VALIDATE_AND_UPDATE_ACCOUNT_FAIL, account_id, NULL, handle_to_be_published, err))
1122 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_AND_CREATE_ACCOUNT_FAIL] Failed");
1125 EM_SAFE_FREE(imap_cap_string);
1130 EM_DEBUG_FUNC_END();
1134 static int event_handler_EMAIL_EVENT_SET_MAIL_SLOT_SIZE(char *multi_user_name, int account_id, int mailbox_id, int new_slot_size, int handle_to_be_published, int *error)
1136 EM_DEBUG_FUNC_BEGIN();
1138 emcore_set_mail_slot_size(multi_user_name, account_id, mailbox_id, new_slot_size, error);
1140 EM_DEBUG_FUNC_END();
1144 static int event_handler_EMAIL_EVENT_EXPUNGE_MAILS_DELETED_FLAGGED(char *multi_user_name, int input_account_id, int input_mailbox_id)
1146 EM_DEBUG_FUNC_BEGIN("input_account_id [%d], input_mailbox_id [%d]", input_account_id, input_mailbox_id);
1147 int err = EMAIL_ERROR_NONE;
1149 if ( (err = emcore_expunge_mails_deleted_flagged_from_remote_server(multi_user_name, input_account_id, input_mailbox_id)) != EMAIL_ERROR_NONE) {
1150 EM_DEBUG_EXCEPTION("emcore_expunge_mails_deleted_flagged_from_remote_server failed [%d]", err);
1154 if ( (err = emcore_expunge_mails_deleted_flagged_from_local_storage(multi_user_name, input_mailbox_id)) != EMAIL_ERROR_NONE) {
1155 EM_DEBUG_EXCEPTION("emcore_expunge_mails_deleted_flagged_from_local_storage failed [%d]", err);
1161 EM_DEBUG_FUNC_END("err [%d]", err);
1165 #ifdef __FEATURE_LOCAL_ACTIVITY__
1166 static int event_handler_EMAIL_EVENT_LOCAL_ACTIVITY(char *multi_user_name, int account_id, int event,handle, int *error)
1168 EM_DEBUG_FUNC_BEGIN();
1170 int err = EMAIL_ERROR_NONE;
1171 email_mailbox_t mailbox;
1172 emstorage_activity_tbl_t *local_activity = NULL;
1173 int activity_id_count = 0;
1174 int activity_chunk_count = 0;
1175 int *activity_id_list = NULL;
1178 if (!emnetwork_check_network_status(&err))
1179 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1181 if (false == emstorage_get_activity_id_list(multi_user_name, account_id, &activity_id_list, &activity_id_count, ACTIVITY_DELETEMAIL, ACTIVITY_COPYMAIL, true, &err)) {
1182 EM_DEBUG_EXCEPTION("emstorage_get_activity_id_list failed [%d]", err);
1185 for (i = 0; i < activity_id_count; ++i) {
1186 if ((false == emstorage_get_activity(account_id , activity_id_list[i], &local_activity, &activity_chunk_count, true, &err)) || (NULL == local_activity) || (0 == activity_chunk_count))
1187 EM_DEBUG_EXCEPTION(" emstorage_get_activity Failed [ %d] or local_activity is NULL [%p] or activity_chunk_count is 0[%d]", err, local_activity, activity_chunk_count);
1189 EM_DEBUG_LOG("Found local activity type - %d", local_activity[0].activity_type);
1190 switch (local_activity[0].activity_type) {
1191 case ACTIVITY_MODIFYFLAG: {
1192 if (emcore_sync_flag_with_server(multi_user_name, local_activity[0].mail_id , &err)) {
1193 if (!emcore_delete_activity(&local_activity[0], &err))
1194 EM_DEBUG_EXCEPTION(">>>>>>Local Activity [ACTIVITY_MODIFYFLAG] [%d] ", err);
1199 case ACTIVITY_DELETEMAIL:
1200 case ACTIVITY_MOVEMAIL:
1201 case ACTIVITY_MODIFYSEENFLAG:
1202 case ACTIVITY_COPYMAIL: {
1205 int total_mail_ids = activity_chunk_count;
1207 int *mail_id_list = NULL;
1209 mail_id_list = (int *)em_malloc(sizeof(int) * total_mail_ids);
1210 if (mail_id_list == NULL) {
1211 EM_DEBUG_EXCEPTION("em_malloc failed");
1212 err = EMAIL_ERROR_OUT_OF_MEMORY;
1216 if (NULL == mail_id_list) {
1217 EM_DEBUG_EXCEPTION("malloc failed... ");
1223 for (j = 0; j < BULK_OPERATION_COUNT && (k < total_mail_ids); ++j, ++k)
1224 mail_id_list[j] = local_activity[k].mail_id;
1226 switch (local_activity[k-1].activity_type) {
1227 case ACTIVITY_DELETEMAIL: {
1228 if (!emcore_delete_mail(multi_user_name,
1229 local_activity[k-1].account_id,
1232 EMAIL_DELETE_LOCAL_AND_SERVER,
1233 EMAIL_DELETED_BY_COMMAND,
1236 EM_DEBUG_LOG("\t emcore_delete_mail failed - %d", err);
1240 case ACTIVITY_MOVEMAIL: {
1241 if (!emcore_move_mail_on_server_ex(multi_user_name, local_activity[k-1].account_id ,
1242 local_activity[k-1].src_mbox,
1245 local_activity[k-1].dest_mbox,
1247 EM_DEBUG_LOG("\t emcore_move_mail_on_server_ex failed - %d", err);
1250 case ACTIVITY_MODIFYSEENFLAG: {
1251 int seen_flag = atoi(local_activity[0].src_mbox);
1252 if (!emcore_sync_seen_flag_with_server_ex(multi_user_name, mail_id_list, j , seen_flag , &err)) /* local_activity[0].src_mbox points to the seen flag */
1253 EM_DEBUG_EXCEPTION("\t emcore_sync_seen_flag_with_server_ex failed - %d", err);
1258 } while (k < total_mail_ids);
1260 EM_SAFE_FREE(mail_id_list);
1266 EM_DEBUG_LOG(">>>> No such Local Activity Handled by this thread [ %d ] >>> ", local_activity[0].activity_type);
1270 emstorage_free_local_activity(&local_activity, activity_chunk_count, NULL);
1272 if (g_local_activity_run == 1) {
1273 EM_DEBUG_LOG(" Network event_data found.. Local sync Stopped..! ");
1280 if (activity_id_list) {
1281 if (false == emstorage_free_activity_id_list(activity_id_list, &err))
1282 EM_DEBUG_EXCEPTION("emstorage_free_activity_id_list failed");
1288 EM_DEBUG_FUNC_END();
1292 #endif /* __FEATURE_LOCAL_ACTIVITY__ */
1294 static int event_handler_EMAIL_EVENT_DOWNLOAD_BODY(char *multi_user_name, int account_id, int mail_id, int option, int handle_to_be_published, int *error)
1296 EM_DEBUG_FUNC_BEGIN();
1298 int err = EMAIL_ERROR_NONE;
1299 email_mailbox_t mailbox;
1301 memset(&mailbox, 0x00, sizeof(mailbox));
1302 mailbox.account_id = account_id;
1304 if (!emnetwork_check_network_status(&err)) {
1305 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1307 emcore_notify_network_event(NOTI_DOWNLOAD_BODY_FAIL, mail_id, NULL, handle_to_be_published, err);
1309 emstorage_mail_tbl_t *mail = NULL;
1310 MAILSTREAM *tmp_stream = NULL;
1312 if (!emstorage_get_mail_by_id (multi_user_name, mail_id, &mail, true, &err) || !mail) {
1313 EM_DEBUG_EXCEPTION("emstorage_get_mail_by_id failed [%d]", err);
1314 emcore_notify_network_event(NOTI_DOWNLOAD_BODY_FAIL, mail_id, NULL, handle_to_be_published, err);
1319 if (!emcore_connect_to_remote_mailbox(multi_user_name, account_id, mail->mailbox_id, (void **)&tmp_stream, &err) || !tmp_stream) {
1320 EM_DEBUG_EXCEPTION("emcore_connect_to_remote_mailbox failed [%d]", err);
1321 if(err == EMAIL_ERROR_NO_SUCH_HOST)
1322 err = EMAIL_ERROR_CONNECTION_FAILURE;
1325 emstorage_free_mail(&mail, 1, NULL);
1327 emcore_notify_network_event(NOTI_DOWNLOAD_BODY_FAIL, mail_id, NULL, handle_to_be_published, err);
1332 if (!emcore_gmime_download_body_sections(multi_user_name, tmp_stream, mailbox.account_id, mail_id,
1333 option & 0x01, NO_LIMITATION, handle_to_be_published, 1, 0, &err))
1334 EM_DEBUG_EXCEPTION("emcore_gmime_download_body_sections failed - %d", err);
1337 tmp_stream = mail_close (tmp_stream);
1341 emstorage_free_mail(&mail, 1, NULL);
1349 EM_DEBUG_FUNC_END();
1353 static int event_handler_EMAIL_EVENT_DOWNLOAD_ATTACHMENT(char *multi_user_name, int account_id, int mail_id, int attachment_no, int handle_to_be_published, int *error)
1355 EM_DEBUG_FUNC_BEGIN();
1357 int err = EMAIL_ERROR_NONE;
1359 EM_DEBUG_LOG("attachment_no is %d", attachment_no);
1361 if (!emnetwork_check_network_status(&err)) {
1362 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1363 emcore_notify_network_event(NOTI_DOWNLOAD_ATTACH_FAIL, mail_id, NULL, attachment_no, err);
1367 #ifdef __ATTACHMENT_OPTI__
1368 if (!emcore_download_attachment_bulk(account_id, mail_id, attachment_no, handle_to_be_published, &err))
1369 EM_DEBUG_EXCEPTION("\t emcore_download_attachment_bulk failed [%d]", err);
1372 if (!emcore_gmime_download_attachment(multi_user_name, mail_id, attachment_no, 1, handle_to_be_published, 0, &err))
1373 EM_DEBUG_EXCEPTION("emcore_gmime_download_attachment failed [%d]", err);
1380 EM_DEBUG_FUNC_END();
1384 static int event_handler_EMAIL_EVENT_SYNC_FLAGS_FIELD_TO_SERVER(char *multi_user_name, int mail_ids[], int num, email_flags_field_type field_type, int value, int *error)
1386 EM_DEBUG_FUNC_BEGIN();
1388 int err = EMAIL_ERROR_NONE;
1390 if (!emnetwork_check_network_status(&err))
1391 EM_DEBUG_EXCEPTION("dnet_init failed [%d]", err);
1392 else if (!emcore_sync_flags_field_with_server(multi_user_name, mail_ids, num, field_type, value, &err))
1393 EM_DEBUG_EXCEPTION("emcore_sync_flags_field_with_server failed [%d]", err);
1398 EM_DEBUG_FUNC_END();
1402 static int event_handler_EMAIL_EVENT_VALIDATE_ACCOUNT(char *multi_user_name, int account_id, int handle_to_be_published, int *error)
1404 EM_DEBUG_FUNC_BEGIN();
1406 int err = EMAIL_ERROR_NONE;
1408 if (!emnetwork_check_network_status(&err)) {
1409 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1411 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_FAIL, account_id, NULL, handle_to_be_published, err))
1412 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FAIL] Failed >>>>");
1416 if (!emcore_validate_account(multi_user_name, account_id, handle_to_be_published, &err)) {
1417 EM_DEBUG_EXCEPTION("emcore_validate_account failed account id : %d err : %d", account_id, err);
1419 if (err == EMAIL_ERROR_CANCELLED) {
1420 EM_DEBUG_EXCEPTION("notify : NOTI_VALIDATE_ACCOUNT_CANCEL ");
1421 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_CANCEL, account_id, NULL, handle_to_be_published, err))
1422 EM_DEBUG_EXCEPTION(" emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_CANCEL] Failed >>>> ");
1425 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_FAIL, account_id, NULL, handle_to_be_published, err))
1426 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FAIL] Failed >>>> ");
1430 email_account_t *account_ref = NULL;
1431 account_ref = emcore_get_account_reference(multi_user_name, account_id, false);
1434 EM_DEBUG_LOG("account_ref->incoming_server_type[%d]", account_ref->incoming_server_type);
1435 if ( EMAIL_SERVER_TYPE_IMAP4 == account_ref->incoming_server_type ) {
1437 if (!emcore_check_event_thread_status(&dummy, handle_to_be_published)) {
1438 EM_DEBUG_LOG("canceled type [%d]", dummy);
1439 err = EMAIL_ERROR_CANCELLED;
1441 else if (!emcore_sync_mailbox_list(multi_user_name, account_id, "", handle_to_be_published, &err))
1442 EM_DEBUG_EXCEPTION("\t emcore_get_mailbox_list_to_be_sync falied - %d", err);
1446 EM_DEBUG_EXCEPTION("emcore_validate_account succeeded account id : %d err : %d", account_id, err);
1447 if (!emcore_notify_network_event(NOTI_VALIDATE_ACCOUNT_FINISH, account_id, NULL, handle_to_be_published, err))
1448 EM_DEBUG_EXCEPTION("emcore_notify_network_event [ NOTI_VALIDATE_ACCOUNT_FINISH] Success >>>>");
1451 emcore_free_account(account_ref);
1452 EM_SAFE_FREE(account_ref);
1460 EM_DEBUG_FUNC_END();
1464 static int event_handler_EMAIL_EVENT_UPDATE_MAIL(char *multi_user_name, email_mail_data_t *input_mail_data, email_attachment_data_t *input_attachment_data_list, int input_attachment_count, email_meeting_request_t* input_meeting_request, int input_from_eas, int handle_to_be_published)
1466 EM_DEBUG_FUNC_BEGIN("input_mail_data[%p], input_attachment_data_list[%p], input_attachment_count[%d], input_meeting_request[%p], input_from_eas[%d]", input_mail_data, input_attachment_data_list, input_attachment_count, input_meeting_request, input_from_eas);
1467 int err = EMAIL_ERROR_NONE;
1469 if ( (err = emcore_update_mail(multi_user_name, input_mail_data, input_attachment_data_list, input_attachment_count, input_meeting_request, input_from_eas)) != EMAIL_ERROR_NONE)
1470 EM_DEBUG_EXCEPTION("emcore_update_mail failed [%d]", err);
1472 EM_DEBUG_FUNC_END("err [%d", err);
1476 static int event_handler_EMAIL_EVENT_SAVE_MAIL(char *multi_user_name, int input_account_id, int input_mail_id, int input_handle_to_be_published)
1478 EM_DEBUG_FUNC_BEGIN("input_account_id [%d] input_mail_id [%d] input_handle_to_be_published [%d]", input_account_id, input_mail_id, input_handle_to_be_published);
1479 int err = EMAIL_ERROR_NONE;
1481 err = emcore_sync_mail_from_client_to_server(multi_user_name, input_mail_id);
1483 EM_DEBUG_FUNC_END("err [%d]", err);
1487 static int event_handler_EMAIL_EVENT_MOVE_MAIL(char *multi_user_name, int account_id, int *mail_ids, int mail_id_count, int dest_mailbox_id, int src_mailbox_id, int handle_to_be_published, int *error)
1489 EM_DEBUG_FUNC_BEGIN();
1490 int err = EMAIL_ERROR_NONE, ret = false;
1491 email_account_t *account_ref = NULL;
1493 if (!(account_ref = emcore_get_account_reference(multi_user_name, account_id, false))) {
1494 EM_DEBUG_EXCEPTION("emcore_get_account_reference failed [%d]", account_id);
1495 err = EMAIL_ERROR_INVALID_ACCOUNT;
1499 /* Move mail local */
1501 if (!emcore_mail_move(mail_ids, mail_id_count, dest_mailbox.mailbox_name, EMAIL_MOVED_BY_COMMAND, 0, &err)) {
1502 EM_DEBUG_EXCEPTION("emcore_mail_move failed [%d]", err);
1507 if (account_ref->incoming_server_type == EMAIL_SERVER_TYPE_IMAP4) {
1508 /* Move mail on server */
1509 if (!emnetwork_check_network_status(&err))
1510 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1512 #ifdef __FEATURE_BULK_DELETE_MOVE_UPDATE_REQUEST_OPTI__
1513 if (!emcore_move_mail_on_server_ex(multi_user_name, account_id , src_mailbox_id, mail_ids, mail_id_count, dest_mailbox_id, &err))
1514 EM_DEBUG_EXCEPTION("emcore_move_mail_on_server_ex failed - %d", err);
1516 if (!emcore_move_mail_on_server(multi_user_name, account_id , src_mailbox_id, mail_ids, mail_id_count, dest_mailbox_id, &err))
1517 EM_DEBUG_EXCEPTION("\t emcore_move_mail_on_server failed - %d", err);
1526 emcore_free_account(account_ref);
1527 EM_SAFE_FREE(account_ref);
1533 EM_DEBUG_FUNC_END();
1537 static int event_handler_EMAIL_EVENT_DELETE_MAILBOX(char *multi_user_name, int mailbox_id, int on_server, int recursive, int handle_to_be_published)
1539 EM_DEBUG_FUNC_BEGIN("mailbox_id[%d] on_server[%d] recursive[%d] handle_to_be_published[%d]", mailbox_id, on_server, recursive, handle_to_be_published);
1540 int err = EMAIL_ERROR_NONE;
1542 if ((err = emcore_delete_mailbox(multi_user_name, mailbox_id, on_server, recursive)) != EMAIL_ERROR_NONE)
1543 EM_DEBUG_EXCEPTION("emcore_delete failed [%d]", err);
1545 EM_DEBUG_FUNC_END("err [%d]", err);
1549 static int event_handler_EMAIL_EVENT_CREATE_MAILBOX(char *multi_user_name, email_mailbox_t *input_new_mailbox, int on_server, int handle_to_be_published)
1551 EM_DEBUG_FUNC_BEGIN();
1552 int err = EMAIL_ERROR_NONE;
1554 if (!emcore_create_mailbox(multi_user_name, input_new_mailbox, on_server, -1, -1, &err))
1555 EM_DEBUG_EXCEPTION("emcore_create failed - %d", err);
1557 EM_DEBUG_FUNC_END("err [%d]", err);
1561 static int event_handler_EMAIL_EVENT_SYNC_MAIL_FLAG_TO_SERVER(char *multi_user_name, int mail_id, int event_handle, int *error)
1563 EM_DEBUG_FUNC_BEGIN("mail_id [%d], error [%p]", mail_id, error);
1565 int err = EMAIL_ERROR_NONE;
1567 if (!emnetwork_check_network_status(&err))
1568 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1570 if (!emcore_sync_flag_with_server(multi_user_name, mail_id, event_handle, &err))
1571 EM_DEBUG_EXCEPTION("emcore_sync_flag_with_server failed [%d]", err);
1572 #ifdef __FEATURE_LOCAL_ACTIVITY__
1574 emstorage_activity_tbl_t new_activity;
1575 memset(&new_activity, 0x00, sizeof(emstorage_activity_tbl_t));
1576 new_activity.activity_type = ACTIVITY_MODIFYFLAG;
1577 new_activity.account_id = event_data.account_id;
1578 new_activity.mail_id = event_data.event_param_data_4;
1579 new_activity.dest_mbox = NULL;
1580 new_activity.server_mailid = NULL;
1581 new_activity.src_mbox = NULL;
1583 if (!emcore_delete_activity(&new_activity, &err))
1584 EM_DEBUG_EXCEPTION(">>>>>>Local Activity [ACTIVITY_MODIFYFLAG] [%d] ", err);
1586 #endif /* __FEATURE_LOCAL_ACTIVITY__ */
1592 EM_DEBUG_FUNC_END();
1596 static int event_handler_EMAIL_EVENT_DELETE_MAIL_ALL(char *multi_user_name, int input_account_id, int input_mailbox_id, int input_from_server, int *error)
1598 EM_DEBUG_FUNC_BEGIN("input_account_id [%d] input_mailbox_id [%d], input_from_server [%d], error [%p]", input_account_id, input_mailbox_id, input_from_server, error);
1599 int err = EMAIL_ERROR_NONE;
1601 if (!emcore_delete_all_mails_of_mailbox(multi_user_name, input_account_id, input_mailbox_id, input_from_server, &err))
1602 EM_DEBUG_EXCEPTION("emcore_delete_all_mails_of_mailbox failed [%d]", err);
1607 EM_DEBUG_FUNC_END("err [%d]", err);
1611 static int event_handler_EMAIL_EVENT_DELETE_MAIL(char *multi_user_name, int account_id, int *mail_id_list, int mail_id_count, int from_server, int *error)
1613 EM_DEBUG_FUNC_BEGIN();
1614 int err = EMAIL_ERROR_NONE;
1616 email_account_t *account_ref = NULL;
1618 if (!(account_ref = emcore_get_account_reference(multi_user_name, account_id, false))) {
1619 EM_DEBUG_EXCEPTION("emcore_get_account_reference failed [%d]", account_id);
1620 err = EMAIL_ERROR_INVALID_ACCOUNT;
1624 if (!emcore_delete_mail(multi_user_name, account_id, mail_id_list, mail_id_count, from_server, EMAIL_DELETED_BY_COMMAND, false, &err)) {
1625 EM_DEBUG_EXCEPTION("emcore_delete_mail failed [%d]", err);
1633 emcore_free_account(account_ref);
1634 EM_SAFE_FREE(account_ref);
1640 EM_DEBUG_FUNC_END();
1644 static int event_hanlder_EMAIL_EVENT_SYNC_HEADER_OMA(char *multi_user_name, int account_id, char *maibox_name, int handle_to_be_published, int *error)
1646 EM_DEBUG_FUNC_BEGIN();
1647 int err = EMAIL_ERROR_NONE;
1649 if (!emnetwork_check_network_status(&err)) {
1650 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);
1651 if (!emcore_notify_network_event(NOTI_DOWNLOAD_FAIL, account_id, maibox_name, 0, err))
1652 EM_DEBUG_EXCEPTION("emcore_notify_network_event [NOTI_DOWNLOAD_FAIL] Failed");
1655 EM_DEBUG_LOG("Sync of all mailbox");
1656 if (!emcore_sync_mailbox_list(multi_user_name, account_id, "", handle_to_be_published, &err))
1657 EM_DEBUG_EXCEPTION("emcore_sync_mailbox_list failed [%d]", err);
1663 EM_DEBUG_FUNC_END();
1667 static int event_handler_EMAIL_EVENT_SEARCH_ON_SERVER(char *multi_user_name, int account_id, int mailbox_id, email_search_filter_t *input_search_filter, int input_search_filter_count, int handle_to_be_published)
1669 EM_DEBUG_FUNC_BEGIN("account_id : [%d], mailbox_id : [%d], input_search_filter : [%p], input_search_filter_count : [%d], handle_to_be_published [%d]", account_id, mailbox_id, input_search_filter, input_search_filter_count, handle_to_be_published);
1670 int err = EMAIL_ERROR_NONE;
1672 if (err == EMAIL_ERROR_NONE) {
1673 if ((err = emcore_search_on_server(multi_user_name, account_id, mailbox_id, input_search_filter, input_search_filter_count, handle_to_be_published)) != EMAIL_ERROR_NONE) {
1674 EM_DEBUG_EXCEPTION("emcore_search_on_server failed [%d]", err);
1678 EM_DEBUG_FUNC_END();
1682 static int event_handler_EMAIL_EVENT_RENAME_MAILBOX_ON_IMAP_SERVER(char *multi_user_name,
1683 int input_account_id,
1684 int input_mailbox_id,
1685 char *input_old_mailbox_path,
1686 char *input_new_mailbox_path,
1687 char *input_new_mailbox_alias,
1688 int handle_to_be_published)
1690 EM_DEBUG_FUNC_BEGIN_SEC("input_account_id [%d], input_mailbox_id [%d], input_old_mailbox_path %s], input_new_mailbox_path [%s], input_new_mailbox_alias [%s], handle_to_be_published [%d]", input_account_id, input_mailbox_id, input_old_mailbox_path, input_new_mailbox_path, input_new_mailbox_alias, handle_to_be_published);
1691 int err = EMAIL_ERROR_NONE;
1694 if (err == EMAIL_ERROR_NONE) {
1695 if ((err = emcore_rename_mailbox(multi_user_name, input_mailbox_id, input_new_mailbox_path, input_new_mailbox_alias, NULL, 0, true, true, handle_to_be_published)) != EMAIL_ERROR_NONE) {
1696 EM_DEBUG_EXCEPTION("emcore_rename_mailbox failed [%d]", err);
1700 EM_DEBUG_FUNC_END("err [%d]", err);
1704 static void* worker_send_event_queue(void *arg)
1706 EM_DEBUG_FUNC_BEGIN();
1707 int err = EMAIL_ERROR_NONE;
1708 email_event_t *event_data = NULL;
1709 email_event_t *started_event = NULL;
1710 int pbd_thd_state = 0;
1711 int event_que_state = 0;
1713 if (!emstorage_open(NULL, &err)) {
1714 EM_DEBUG_EXCEPTION("emstorage_open falied [%d]", err);
1718 while (g_send_event_loop) {
1720 pbd_thd_state = emcore_get_pbd_thd_state();
1721 event_que_state = emcore_is_event_queue_empty();
1723 /* get a event_data from event_data send queue */
1724 ENTER_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
1725 if (!emcore_retrieve_send_event(&event_data, &err)) {
1726 /* no event_data pending */
1727 if (err != EMAIL_ERROR_EVENT_QUEUE_EMPTY) {
1728 LEAVE_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
1732 send_thread_run = 0;
1734 emdevice_set_sleep_on_off(STAY_AWAKE_FLAG_FOR_SENDING_WORKER, true, NULL);
1736 #ifdef __FEATURE_WIFI_AUTO_DOWNLOAD__
1737 int wifi_status = 0;
1738 if ((err = emnetwork_get_wifi_status(&wifi_status)) != EMAIL_ERROR_NONE) {
1739 EM_DEBUG_EXCEPTION("emnetwork_get_wifi_status failed [%d]", err);
1741 EM_DEBUG_LOG("WIFI Status [%d]", wifi_status);
1743 if (!pbd_thd_state && event_que_state && wifi_status > 1) {
1744 WAKE_CONDITION_VARIABLE(_auto_downalod_available_signal);
1748 //go to sleep when queue is empty
1749 SLEEP_CONDITION_VARIABLE(_send_event_available_signal, *_send_event_queue_lock);
1750 EM_DEBUG_LOG("Wake up by _send_event_available_signal");
1751 LEAVE_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
1753 LEAVE_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
1754 EM_DEBUG_LOG(">>>>>>>>>>>>>>Got SEND event_data>>>>>>>>>>>>>>>>");
1755 emdevice_set_sleep_on_off(STAY_AWAKE_FLAG_FOR_SENDING_WORKER, false, NULL);
1756 send_thread_run = 1;
1758 switch (event_data->type) {
1760 case EMAIL_EVENT_SEND_MAIL:
1761 if (!emcore_send_mail(event_data->multi_user_name, event_data->event_param_data_4, &err))
1762 EM_DEBUG_EXCEPTION("emcore_send_mail failed [%d]", err);
1765 case EMAIL_EVENT_SEND_MAIL_SAVED:
1766 /* send mails to been saved in off-line mode */
1767 if (!emcore_send_saved_mail(event_data->multi_user_name, event_data->account_id, event_data->event_param_data_3, &err))
1768 EM_DEBUG_EXCEPTION("emcore_send_saved_mail failed - %d", err);
1771 #ifdef __FEATURE_LOCAL_ACTIVITY__
1772 case EMAIL_EVENT_LOCAL_ACTIVITY: {
1773 emdevice_set_sleep_on_off(false, NULL);
1774 emstorage_activity_tbl_t *local_activity = NULL;
1775 int activity_id_count = 0;
1776 int activity_chunk_count = 0;
1777 int *activity_id_list = NULL;
1780 if (false == emstorage_get_activity_id_list(event_data->account_id, &activity_id_list, &activity_id_count, ACTIVITY_SAVEMAIL, ACTIVITY_DELETEMAIL_SEND, true, &err)) {
1781 EM_DEBUG_EXCEPTION("emstorage_get_activity_id_list failed [%d]", err);
1784 for (i = 0; i < activity_id_count; ++i) {
1785 if ((false == emstorage_get_activity(event_data->account_id, activity_id_list[i], &local_activity, &activity_chunk_count, true, &err)) || (NULL == local_activity) || (0 == activity_chunk_count)) {
1786 EM_DEBUG_EXCEPTION(" emstorage_get_activity Failed [ %d] or local_activity is NULL [%p] or activity_chunk_count is 0[%d]", err, local_activity, activity_chunk_count);
1789 EM_DEBUG_LOG("Found local activity type - %d", local_activity[0].activity_type);
1790 switch (local_activity[0].activity_type) {
1791 case ACTIVITY_SAVEMAIL: {
1792 if (!emcore_sync_mail_from_client_to_server(event_data->multi_user_name, event_data->account_id, local_activity[0].mail_id, &err)) {
1793 EM_DEBUG_EXCEPTION("emcore_sync_mail_from_client_to_server failed - %d ", err);
1798 case ACTIVITY_DELETEMAIL_SEND: /* New Activity Type Added for Race Condition and Crash Fix */ {
1799 if (!emcore_delete_mail(local_activity[0].multi_user_name,
1800 local_activity[0].account_id,
1801 &local_activity[0].mail_id,
1802 EMAIL_DELETE_FOR_SEND_THREAD,
1804 EMAIL_DELETED_BY_COMMAND,
1807 EM_DEBUG_LOG("\t emcore_delete_mail failed - %d", err);
1813 EM_DEBUG_LOG(">>>> No such Local Activity Handled by this thread [ %d ] >>> ", local_activity[0].activity_type);
1818 emstorage_free_local_activity(&local_activity, activity_chunk_count, NULL);
1820 if (g_save_local_activity_run == 1) {
1821 EM_DEBUG_LOG(" Network event_data found.. Local sync Stopped..! ");
1827 if (false == emstorage_free_activity_id_list(activity_id_list, &err)) {
1828 EM_DEBUG_LOG("emstorage_free_activity_id_list failed");
1832 emdevice_set_sleep_on_off(true, NULL);
1835 #endif /* __FEATURE_LOCAL_ACTIVITY__ */
1838 EM_DEBUG_LOG("Others not supported by Send Thread..! [%d]", event_data->type);
1842 ENTER_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
1843 started_event = g_queue_pop_head(g_send_event_que);
1844 LEAVE_RECURSIVE_CRITICAL_SECTION(_send_event_queue_lock);
1845 if (!started_event) {
1846 EM_DEBUG_EXCEPTION("Failed to g_queue_pop_head");
1848 emcore_return_send_handle(started_event->handle);
1849 emcore_free_event(started_event);
1850 EM_SAFE_FREE(started_event);
1855 if (!emstorage_close(&err))
1856 EM_DEBUG_EXCEPTION("emstorage_close falied [%d]", err);
1858 emcore_close_smtp_stream_list();
1859 EM_DEBUG_FUNC_END("err [%d]", err);
1863 INTERNAL_FUNC int emdaemon_start_thread_for_downloading_partial_body(int *err_code)
1865 EM_DEBUG_FUNC_BEGIN();
1867 int i = 0, thread_error = -1;
1869 /* Clear Partial Body Event Queue*/
1870 memset(&g_partial_body_thd_event_que, 0x00, sizeof(g_partial_body_thd_event_que));
1872 for (i = 0; i < TOTAL_PARTIAL_BODY_EVENTS; ++i) {
1873 g_partial_body_thd_event_que[i].mailbox_name = NULL;
1874 g_partial_body_thd_event_que[i].mailbox_id = 0;
1877 if (g_partial_body_thd) {
1878 EM_DEBUG_EXCEPTION("partial body thread is already running...");
1879 if (err_code != NULL)
1880 *err_code = EMAIL_ERROR_UNKNOWN;
1886 ENTER_CRITICAL_SECTION(_partial_body_thd_event_queue_lock);
1887 g_partial_body_thd_next_event_idx = 0;
1888 // g_partial_body_thd_loop = 1;
1889 g_partial_body_thd_queue_empty = true;
1890 g_partial_body_thd_queue_full = false;
1891 LEAVE_CRITICAL_SECTION(_partial_body_thd_event_queue_lock);
1893 INITIALIZE_CONDITION_VARIABLE(_partial_body_thd_cond);
1896 /* THREAD_CREATE_JOINABLE(g_partial_body_thd, partial_body_download_thread, thread_error); */
1897 THREAD_CREATE(g_partial_body_thd, partial_body_download_thread, NULL, thread_error);
1899 if (thread_error != 0) {
1900 EM_DEBUG_EXCEPTION("cannot make thread...");
1901 if (err_code != NULL)
1902 *err_code = EMAIL_ERROR_UNKNOWN;
1906 if (err_code != NULL)
1907 *err_code = EMAIL_ERROR_NONE;
1914 static gpointer partial_body_download_thread(gpointer data)
1916 EM_DEBUG_FUNC_BEGIN();
1918 int err = EMAIL_ERROR_NONE;
1919 email_session_t *session = NULL;
1920 email_event_partial_body_thd partial_body_thd_event;
1921 int i, account_count = 0;
1922 emstorage_account_tbl_t *account_list = NULL;
1923 int event_que_state = 0;
1924 int send_event_que_state = 0;
1926 EM_DEBUG_LOG_DEV(" ************ PB THREAD ID IS ALIVE. ID IS [%d] ********************" , THREAD_SELF());
1928 /* Open connection with DB */
1930 if (false == emstorage_open(NULL, &err)) {
1931 EM_DEBUG_EXCEPTION("emstorage_open failed [%d]", err);
1935 /* refactoring session required */
1936 if (!emcore_get_empty_session(&session)) {
1937 EM_DEBUG_EXCEPTION("emcore_get_empty_session failed...");
1942 memset(&partial_body_thd_event, 0, sizeof(email_event_partial_body_thd));
1944 if (false == emcore_retrieve_partial_body_thread_event(&partial_body_thd_event, &err)) {
1945 if (EMAIL_ERROR_EVENT_QUEUE_EMPTY != err)
1946 EM_DEBUG_EXCEPTION("emcore_retrieve_partial_body_thread_event failed [%d]", err);
1948 EM_DEBUG_LOG(" partial body thread event_data queue is empty.");
1950 #ifdef __FEATURE_WIFI_AUTO_DOWNLOAD__
1951 int wifi_status = 0;
1954 /* Flush the que before starting local activity sync to clear the events in queue which are less than 10 in count */
1955 if (!g_partial_body_bulk_dwd_queue_empty) {
1956 partial_body_thd_event.event_type = 0;
1957 partial_body_thd_event.account_id = g_partial_body_bulk_dwd_que[0].account_id;
1958 partial_body_thd_event.mailbox_id = g_partial_body_bulk_dwd_que[0].mailbox_id;
1959 partial_body_thd_event.mailbox_name = EM_SAFE_STRDUP(g_partial_body_bulk_dwd_que[0].mailbox_name); /* need to be freed */
1960 partial_body_thd_event.multi_user_name = EM_SAFE_STRDUP(g_partial_body_bulk_dwd_que[0].multi_user_name); /* need to be freed */
1963 if (false == emcore_mail_partial_body_download(&partial_body_thd_event, &err))
1964 EM_DEBUG_EXCEPTION("emcore_mail_partial_body_download from event_data queue failed [%d]", err);
1966 emcore_pb_thd_set_local_activity_continue(true);
1969 if (true == emcore_pb_thd_can_local_activity_continue()) {
1970 /*Check for local Activities */
1971 int is_local_activity_event_inserted = false;
1973 if (false == emcore_partial_body_thd_local_activity_sync(partial_body_thd_event.multi_user_name, &is_local_activity_event_inserted, &err)) {
1974 EM_DEBUG_EXCEPTION("emcore_partial_body_thd_local_activity_sync failed [%d]", err);
1977 if (true == is_local_activity_event_inserted) {
1978 emcore_pb_thd_set_local_activity_continue(false);
1980 /* emcore_clear_session(session);*/
1982 if (false == emcore_free_partial_body_thd_event(&partial_body_thd_event, &err))
1983 EM_DEBUG_EXCEPTION("emcore_free_partial_body_thd_event_cell failed [%d]", err);
1990 EM_DEBUG_LOG_DEV(" Partial Body Thread is going to sleep");
1994 account_list = NULL;
1995 if (!emstorage_get_account_list(NULL, &account_count, &account_list, false, false, &err)) {
1996 EM_DEBUG_EXCEPTION("emstorage_get_account_list failed : [%d]", err);
1999 for (i = 0; i < account_count; i++) {
2000 if (!emdaemon_finalize_sync(partial_body_thd_event.multi_user_name, account_list[i].account_id, 0, 0, 0, 0, true, NULL))
2001 EM_DEBUG_EXCEPTION("emdaemon_finalize_sync failed");
2005 emstorage_free_account(&account_list, account_count, NULL);
2007 emcore_set_pbd_thd_state(false);
2009 #ifdef __FEATURE_WIFI_AUTO_DOWNLOAD__
2010 if ((err = emnetwork_get_wifi_status(&wifi_status)) != EMAIL_ERROR_NONE) {
2011 EM_DEBUG_EXCEPTION("emnetwork_get_wifi_status failed [%d]", err);
2014 EM_DEBUG_LOG("WIFI Status [%d]", wifi_status);
2016 event_que_state = emcore_is_event_queue_empty();
2017 send_event_que_state = emcore_is_send_event_queue_empty();
2019 /*check: refactoring required*/
2020 ENTER_CRITICAL_SECTION(_partial_body_thd_event_queue_lock);
2021 #ifdef __FEATURE_WIFI_AUTO_DOWNLOAD__
2022 if (event_que_state && send_event_que_state && wifi_status > 1) {
2023 WAKE_CONDITION_VARIABLE(_auto_downalod_available_signal);
2026 SLEEP_CONDITION_VARIABLE(_partial_body_thd_cond, _partial_body_thd_event_queue_lock);
2027 LEAVE_CRITICAL_SECTION(_partial_body_thd_event_queue_lock);
2029 EM_DEBUG_LOG(" Partial Body Thread wakes up ");
2031 emcore_set_pbd_thd_state(true);
2036 EM_DEBUG_LOG(" Event Received from Partial Body Event Queue ");
2038 /* Since all events are network operations dnet init and sleep control is
2039 done before entering switch block*/
2041 emdevice_set_sleep_on_off(STAY_AWAKE_FLAG_FOR_PARTIAL_BODY_WORKER, false, NULL);
2043 if (!emnetwork_check_network_status( &err)) {
2044 EM_DEBUG_EXCEPTION("emnetwork_check_network_status failed [%d]", err);;
2047 /* Process events */
2048 EM_DEBUG_LOG("partial_body_thd_event.account_id[%d]", partial_body_thd_event.account_id);
2050 switch (partial_body_thd_event.event_type) {
2051 case EMAIL_EVENT_BULK_PARTIAL_BODY_DOWNLOAD: {
2052 if (false == emcore_mail_partial_body_download(&partial_body_thd_event, &err)) {
2053 EM_DEBUG_EXCEPTION("emcore_mail_partial_body_download from event_data queue failed [%d]", err);
2057 case EMAIL_EVENT_LOCAL_ACTIVITY_SYNC_BULK_PBD: {
2058 partial_body_thd_event.event_type = 0;
2060 /* Both the checks below make sure that before starting local activity there is no new/pending event_data in
2061 * g_partial_body_thd_event_que and g_partial_body_bulk_dwd_que */
2062 if (false == emcore_is_partial_body_thd_que_empty())
2064 if (!g_partial_body_bulk_dwd_queue_empty)
2067 if (false == emcore_mail_partial_body_download(&partial_body_thd_event, &err))
2068 EM_DEBUG_EXCEPTION("emcore_mail_partial_body_download from activity table failed [%d]", err);
2072 EM_DEBUG_EXCEPTION(" Warning : Default case entered. This should not happen ");
2077 if (false == emcore_free_partial_body_thd_event(&partial_body_thd_event, NULL))
2078 EM_DEBUG_EXCEPTION("emcore_free_partial_body_thd_event_cell failed");
2080 emdevice_set_sleep_on_off(STAY_AWAKE_FLAG_FOR_PARTIAL_BODY_WORKER, true, NULL);
2083 /* emcore_clear_session(session); */
2086 emcore_close_recv_stream_list();
2087 emcore_clear_session(session);