email-core/email-core-tasks.c

   1 /*\r
   2 *  email-service\r
   3 *\r
   4 * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.\r
   5 *\r
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>\r
   7 *\r
   8 * Licensed under the Apache License, Version 2.0 (the "License");\r
   9 * you may not use this file except in compliance with the License.\r
  10 * You may obtain a copy of the License at\r
  11 *\r
  12 * http://www.apache.org/licenses/LICENSE-2.0\r
  13 *\r
  14 * Unless required by applicable law or agreed to in writing, software\r
  15 * distributed under the License is distributed on an "AS IS" BASIS,\r
  16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17 * See the License for the specific language governing permissions and\r
  18 * limitations under the License.\r
  19 *\r
  20 */\r
  21 /*\r
  22  * email-tasks.c\r
  23  *\r
  24  *  Created on: 2012. 11. 5.\r
  25  *      Author: kyuho.jo@samsung.com\r
  26  */\r
  27 #include <stdlib.h>\r
  28 #include <stdio.h>\r
  29 #include <string.h>\r
  30 \r
  31 \r
  32 #include "email-debug-log.h"\r
  33 #include "email-utilities.h"\r
  34 #include "email-internal-types.h"\r
  35 #include "email-core-tasks.h"\r
  36 #include "email-core-task-manager.h"\r
  37 #include "email-core-mail.h"\r
  38 #include "email-core-mailbox-sync.h"\r
  39 #include "email-core-signal.h"\r
  40 #include "tpl.h"\r
  41 \r
  42 /*-------------------------------------------------------------------------------------------*/\r
  43 /* to handle EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT */\r
  44 #define task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT "iiiB"\r
  45 \r
  46 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)\r
  47 {\r
  48         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);\r
  49 \r
  50         int err = EMAIL_ERROR_NONE;\r
  51         task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = input_task_parameter_struct;\r
  52         tpl_bin tb;\r
  53         tpl_node *tn = NULL;\r
  54         void  *result_data = NULL;\r
  55         size_t result_data_length = 0;\r
  56 \r
  57         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {\r
  58                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
  59                 err = EMAIL_ERROR_INVALID_PARAM;\r
  60                 goto FINISH_OFF;\r
  61         }\r
  62 \r
  63         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT\r
  64                         , &task_parameter->source_mailbox_id\r
  65                         , &task_parameter->target_mailbox_id\r
  66                         , &task_parameter->mail_id_count\r
  67                         , &tb);\r
  68         tb.sz   = sizeof(int) * task_parameter->mail_id_count;\r
  69         tb.addr = task_parameter->mail_id_array;\r
  70         tpl_pack(tn, 0);\r
  71         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);\r
  72         tpl_free(tn);\r
  73 \r
  74         *output_byte_stream = result_data;\r
  75         *output_stream_size = result_data_length;\r
  76 \r
  77 FINISH_OFF:\r
  78 \r
  79         EM_DEBUG_FUNC_END("err [%d]", err);\r
  80         return EMAIL_ERROR_NONE;\r
  81 }\r
  82 \r
  83 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)\r
  84 {\r
  85         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);\r
  86         int err = EMAIL_ERROR_NONE;\r
  87         tpl_bin tb;\r
  88         tpl_node *tn = NULL;\r
  89         task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = NULL;\r
  90 \r
  91         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {\r
  92                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
  93                 err = EMAIL_ERROR_INVALID_PARAM;\r
  94                 goto FINISH_OFF;\r
  95         }\r
  96 \r
  97         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT));\r
  98 \r
  99         if(task_parameter == NULL) {\r
 100                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");\r
 101                 err = EMAIL_ERROR_OUT_OF_MEMORY;\r
 102                 goto FINISH_OFF;\r
 103         }\r
 104 \r
 105         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT\r
 106                                 , &task_parameter->source_mailbox_id\r
 107                                 , &task_parameter->target_mailbox_id\r
 108                                 , &task_parameter->mail_id_count\r
 109                                 , &tb);\r
 110         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);\r
 111         tpl_unpack(tn, 0);\r
 112         if(task_parameter->mail_id_count <= 0 || tb.addr == NULL) {\r
 113                 EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb.addr);\r
 114         }\r
 115         else {\r
 116                 task_parameter->mail_id_array = tb.addr;\r
 117         }\r
 118 \r
 119         *output_task_parameter_struct = task_parameter;\r
 120 \r
 121 FINISH_OFF:\r
 122 \r
 123         if(tn)\r
 124                 tpl_free(tn);\r
 125 \r
 126         EM_DEBUG_FUNC_END("err [%d]", err);\r
 127         return EMAIL_ERROR_NONE;\r
 128 }\r
 129 \r
 130 INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_param)\r
 131 {\r
 132         EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param);\r
 133         int err = EMAIL_ERROR_NONE;\r
 134         int err_for_signal = EMAIL_ERROR_NONE;\r
 135         int i = 0;\r
 136         int task_id = THREAD_SELF();\r
 137         task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_param = input_param;\r
 138 \r
 139         for(i = 0; i < task_param->mail_id_count; i++) {\r
 140                 if((err = emcore_move_mail_to_another_account(task_param->mail_id_array[i], task_param->source_mailbox_id, task_param->target_mailbox_id, task_id)) != EMAIL_ERROR_NONE) {\r
 141                         EM_DEBUG_EXCEPTION("emcore_move_mail_to_another_account failed [%d]", err);\r
 142                         goto FINISH_OFF;\r
 143                 }\r
 144 \r
 145                 /* Send progress signal */\r
 146                 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)\r
 147                         EM_DEBUG_LOG("emcore_send_task_status_signal failed [%d]", err_for_signal);\r
 148         }\r
 149 \r
 150 FINISH_OFF:\r
 151         /* Free task parameter */\r
 152         EM_SAFE_FREE(task_param->mail_id_array);\r
 153         EM_SAFE_FREE(task_param);\r
 154 \r
 155         EM_DEBUG_FUNC_END("err [%d]", err);\r
 156         return NULL;\r
 157 }\r
 158 /*-------------------------------------------------------------------------------------------*/\r
 159 /* to handle EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX */\r
 160 #define task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX "iiBi"\r
 161 \r
 162 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)\r
 163 {\r
 164         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);\r
 165 \r
 166         int err = EMAIL_ERROR_NONE;\r
 167         task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = input_task_parameter_struct;\r
 168         tpl_bin tb;\r
 169         tpl_node *tn = NULL;\r
 170         void  *result_data = NULL;\r
 171         size_t result_data_length = 0;\r
 172 \r
 173         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {\r
 174                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
 175                 err = EMAIL_ERROR_INVALID_PARAM;\r
 176                 goto FINISH_OFF;\r
 177         }\r
 178 \r
 179         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX\r
 180                         , &task_parameter->account_id\r
 181                         , &task_parameter->mailbox_id_count\r
 182                         , &tb\r
 183                         , &task_parameter->on_server);\r
 184         tb.sz   = sizeof(int) * task_parameter->mailbox_id_count;\r
 185         tb.addr = task_parameter->mailbox_id_array;\r
 186         tpl_pack(tn, 0);\r
 187         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);\r
 188         tpl_free(tn);\r
 189 \r
 190         *output_byte_stream = result_data;\r
 191         *output_stream_size = result_data_length;\r
 192 \r
 193 FINISH_OFF:\r
 194 \r
 195         EM_DEBUG_FUNC_END("err [%d]", err);\r
 196         return EMAIL_ERROR_NONE;\r
 197 }\r
 198 \r
 199 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)\r
 200 {\r
 201         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);\r
 202         int err = EMAIL_ERROR_NONE;\r
 203         tpl_bin tb;\r
 204         tpl_node *tn = NULL;\r
 205         task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = NULL;\r
 206 \r
 207         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {\r
 208                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
 209                 err = EMAIL_ERROR_INVALID_PARAM;\r
 210                 goto FINISH_OFF;\r
 211         }\r
 212 \r
 213         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX));\r
 214 \r
 215         if(task_parameter == NULL) {\r
 216                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");\r
 217                 err = EMAIL_ERROR_OUT_OF_MEMORY;\r
 218                 goto FINISH_OFF;\r
 219         }\r
 220 \r
 221         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX\r
 222                                 , &task_parameter->account_id\r
 223                                 , &task_parameter->mailbox_id_count\r
 224                                 , &tb\r
 225                                 , &task_parameter->on_server);\r
 226         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);\r
 227         tpl_unpack(tn, 0);\r
 228         if(task_parameter->mailbox_id_count <= 0 || tb.addr == NULL) {\r
 229                 EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mailbox_id_count, tb.addr);\r
 230         }\r
 231         else {\r
 232                 task_parameter->mailbox_id_array = tb.addr;\r
 233         }\r
 234 \r
 235         *output_task_parameter_struct = task_parameter;\r
 236 \r
 237 FINISH_OFF:\r
 238 \r
 239         if(tn)\r
 240                 tpl_free(tn);\r
 241 \r
 242         EM_DEBUG_FUNC_END("err [%d]", err);\r
 243         return EMAIL_ERROR_NONE;\r
 244 }\r
 245 \r
 246 INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(void *input_param)\r
 247 {\r
 248         return NULL;\r
 249 }\r
 250 /*-------------------------------------------------------------------------------------------*/\r
 251 /* to handle EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL */\r
 252 #define task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL "i"\r
 253 \r
 254 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)\r
 255 {\r
 256         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);\r
 257 \r
 258         int err = EMAIL_ERROR_NONE;\r
 259         task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = input_task_parameter_struct;\r
 260         tpl_node *tn = NULL;\r
 261         void  *result_data = NULL;\r
 262         size_t result_data_length = 0;\r
 263 \r
 264         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {\r
 265                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
 266                 err = EMAIL_ERROR_INVALID_PARAM;\r
 267                 goto FINISH_OFF;\r
 268         }\r
 269 \r
 270         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL\r
 271                         , &task_parameter->mail_id);\r
 272         tpl_pack(tn, 0);\r
 273         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);\r
 274         tpl_free(tn);\r
 275 \r
 276         *output_byte_stream = result_data;\r
 277         *output_stream_size = result_data_length;\r
 278 \r
 279 FINISH_OFF:\r
 280 \r
 281         EM_DEBUG_FUNC_END("err [%d]", err);\r
 282         return EMAIL_ERROR_NONE;\r
 283 }\r
 284 \r
 285 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)\r
 286 {\r
 287         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);\r
 288         int err = EMAIL_ERROR_NONE;\r
 289         tpl_node *tn = NULL;\r
 290         task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = NULL;\r
 291 \r
 292         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {\r
 293                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");\r
 294                 err = EMAIL_ERROR_INVALID_PARAM;\r
 295                 goto FINISH_OFF;\r
 296         }\r
 297 \r
 298         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL));\r
 299 \r
 300         if(task_parameter == NULL) {\r
 301                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");\r
 302                 err = EMAIL_ERROR_OUT_OF_MEMORY;\r
 303                 goto FINISH_OFF;\r
 304         }\r
 305 \r
 306         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL\r
 307                                 , &task_parameter->mail_id);\r
 308         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);\r
 309         tpl_unpack(tn, 0);\r
 310 \r
 311         *output_task_parameter_struct = task_parameter;\r
 312 \r
 313 FINISH_OFF:\r
 314 \r
 315         if(tn)\r
 316                 tpl_free(tn);\r
 317 \r
 318         EM_DEBUG_FUNC_END("err [%d]", err);\r
 319         return EMAIL_ERROR_NONE;\r
 320 }\r
 321 \r
 322 INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(void *input_param)\r
 323 {\r
 324         return NULL;\r
 325 }\r
 326 /*-------------------------------------------------------------------------------------------*/\r