email-core/email-core-tasks.c

   1 /*
   2 *  email-service
   3 *
   4 * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5 *
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
   7 *
   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
  11 *
  12 * http://www.apache.org/licenses/LICENSE-2.0
  13 *
  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.
  19 *
  20 */
  21 /*
  22  * email-tasks.c
  23  *
  24  *  Created on: 2012. 11. 5.
  25  *      Author: kyuho.jo@samsung.com
  26  */
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31
  32 #include "email-debug-log.h"
  33 #include "email-utilities.h"
  34 #include "email-internal-types.h"
  35 #include "email-core-tasks.h"
  36 #include "email-core-task-manager.h"
  37 #include "email-core-mail.h"
  38 #include "email-core-smtp.h"
  39 #include "email-core-mailbox-sync.h"
  40 #include "email-core-signal.h"
  41 #include "email-core-utils.h"
  42 #include "tpl.h"
  43
  44 /*-------------------------------------------------------------------------------------------*/
  45 /* to handle EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT */
  46 #define task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT "iiiB"
  47
  48 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)
  49 {
  50         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);
  51
  52         int err = EMAIL_ERROR_NONE;
  53         task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = input_task_parameter_struct;
  54         tpl_bin tb;
  55         tpl_node *tn = NULL;
  56         void  *result_data = NULL;
  57         size_t result_data_length = 0;
  58
  59         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
  60                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
  61                 err = EMAIL_ERROR_INVALID_PARAM;
  62                 goto FINISH_OFF;
  63         }
  64
  65         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT
  66                         , &task_parameter->source_mailbox_id
  67                         , &task_parameter->target_mailbox_id
  68                         , &task_parameter->mail_id_count
  69                         , &tb);
  70         if (tn == NULL) {
  71                 EM_DEBUG_EXCEPTION("tpl_map failed");
  72                 err = EMAIL_ERROR_SYSTEM_FAILURE;
  73                 goto FINISH_OFF;
  74         }
  75
  76         tb.sz   = sizeof(int) * task_parameter->mail_id_count;
  77         tb.addr = task_parameter->mail_id_array;
  78         tpl_pack(tn, 0);
  79         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);
  80         tpl_free(tn);
  81
  82         *output_byte_stream = result_data;
  83         *output_stream_size = result_data_length;
  84
  85 FINISH_OFF:
  86
  87         EM_DEBUG_FUNC_END("err [%d]", err);
  88         return err;
  89 }
  90
  91 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)
  92 {
  93         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);
  94         int err = EMAIL_ERROR_NONE;
  95         tpl_bin tb;
  96         tpl_node *tn = NULL;
  97         task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_parameter = NULL;
  98
  99         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {
 100                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 101                 err = EMAIL_ERROR_INVALID_PARAM;
 102                 goto FINISH_OFF;
 103         }
 104
 105         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT));
 106         if (task_parameter == NULL) {
 107                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 108                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 109                 goto FINISH_OFF;
 110         }
 111
 112         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT
 113                                 , &task_parameter->source_mailbox_id
 114                                 , &task_parameter->target_mailbox_id
 115                                 , &task_parameter->mail_id_count
 116                                 , &tb);
 117         if (tn == NULL) {
 118                 EM_DEBUG_EXCEPTION("tpl_map failed");
 119                 EM_SAFE_FREE(task_parameter);
 120                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 121                 goto FINISH_OFF;
 122         }
 123
 124         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);
 125         tpl_unpack(tn, 0);
 126         if(task_parameter->mail_id_count <= 0 || tb.addr == NULL) {
 127                 EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb.addr);
 128         }
 129         else {
 130                 task_parameter->mail_id_array = tb.addr;
 131         }
 132
 133         *output_task_parameter_struct = task_parameter;
 134
 135 FINISH_OFF:
 136
 137         if(tn)
 138                 tpl_free(tn);
 139
 140         EM_DEBUG_FUNC_END("err [%d]", err);
 141         return err;
 142 }
 143
 144 INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT(void *input_param)
 145 {
 146         EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param);
 147         int err = EMAIL_ERROR_NONE;
 148         int err_for_signal = EMAIL_ERROR_NONE;
 149         int i = 0;
 150         int task_id = THREAD_SELF();
 151         task_parameter_EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT *task_param = input_param;
 152
 153         for(i = 0; i < task_param->mail_id_count; i++) {
 154                 if((err = emcore_move_mail_to_another_account(task_param->multi_user_name, task_param->mail_id_array[i], task_param->source_mailbox_id, task_param->target_mailbox_id, task_id)) != EMAIL_ERROR_NONE) {
 155                         EM_DEBUG_EXCEPTION("emcore_move_mail_to_another_account failed [%d]", err);
 156                         goto FINISH_OFF;
 157                 }
 158
 159                 /* Send progress signal */
 160                 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)
 161                         EM_DEBUG_LOG("emcore_send_task_status_signal failed [%d]", err_for_signal);
 162         }
 163
 164 FINISH_OFF:
 165         /* Free task parameter */
 166         EM_SAFE_FREE(task_param->mail_id_array);
 167         EM_SAFE_FREE(task_param);
 168
 169         EM_DEBUG_FUNC_END("err [%d]", err);
 170         return NULL;
 171 }
 172 /*-------------------------------------------------------------------------------------------*/
 173 /* to handle EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX */
 174 #define task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX "iiBi"
 175
 176 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)
 177 {
 178         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);
 179
 180         int err = EMAIL_ERROR_NONE;
 181         task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = input_task_parameter_struct;
 182         tpl_bin tb;
 183         tpl_node *tn = NULL;
 184         void  *result_data = NULL;
 185         size_t result_data_length = 0;
 186
 187         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
 188                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 189                 err = EMAIL_ERROR_INVALID_PARAM;
 190                 goto FINISH_OFF;
 191         }
 192
 193         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX
 194                         , &task_parameter->account_id
 195                         , &task_parameter->mailbox_id_count
 196                         , &tb
 197                         , &task_parameter->on_server);
 198         if (tn == NULL) {
 199                 EM_DEBUG_EXCEPTION("tpl_map failed");
 200                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 201                 goto FINISH_OFF;
 202         }
 203
 204         tb.sz   = sizeof(int) * task_parameter->mailbox_id_count;
 205         tb.addr = task_parameter->mailbox_id_array;
 206         tpl_pack(tn, 0);
 207         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);
 208         tpl_free(tn);
 209
 210         *output_byte_stream = result_data;
 211         *output_stream_size = result_data_length;
 212
 213 FINISH_OFF:
 214
 215         EM_DEBUG_FUNC_END("err [%d]", err);
 216         return err;
 217 }
 218
 219 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)
 220 {
 221         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);
 222         int err = EMAIL_ERROR_NONE;
 223         tpl_bin tb;
 224         tpl_node *tn = NULL;
 225         task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX *task_parameter = NULL;
 226
 227         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {
 228                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 229                 err = EMAIL_ERROR_INVALID_PARAM;
 230                 goto FINISH_OFF;
 231         }
 232
 233         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX));
 234         if(task_parameter == NULL) {
 235                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 236                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 237                 goto FINISH_OFF;
 238         }
 239
 240         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX
 241                                 , &task_parameter->account_id
 242                                 , &task_parameter->mailbox_id_count
 243                                 , &tb
 244                                 , &task_parameter->on_server);
 245         if (tn == NULL) {
 246                 EM_DEBUG_EXCEPTION("tpl_map failed");
 247                 EM_SAFE_FREE(task_parameter);
 248                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 249                 goto FINISH_OFF;
 250         }
 251
 252         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);
 253         tpl_unpack(tn, 0);
 254         if(task_parameter->mailbox_id_count <= 0 || tb.addr == NULL) {
 255                 EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mailbox_id_count, tb.addr);
 256         }
 257         else {
 258                 task_parameter->mailbox_id_array = tb.addr;
 259         }
 260
 261         *output_task_parameter_struct = task_parameter;
 262
 263 FINISH_OFF:
 264
 265         if(tn)
 266                 tpl_free(tn);
 267
 268         EM_DEBUG_FUNC_END("err [%d]", err);
 269         return err;
 270 }
 271
 272 INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX(void *input_param)
 273 {
 274         return NULL;
 275 }
 276 /*-------------------------------------------------------------------------------------------*/
 277 /* to handle EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL */
 278 #define task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL "i"
 279
 280 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)
 281 {
 282         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);
 283
 284         int err = EMAIL_ERROR_NONE;
 285         task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = input_task_parameter_struct;
 286         tpl_node *tn = NULL;
 287         void  *result_data = NULL;
 288         size_t result_data_length = 0;
 289
 290         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
 291                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 292                 err = EMAIL_ERROR_INVALID_PARAM;
 293                 goto FINISH_OFF;
 294         }
 295
 296         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL
 297                         , &task_parameter->mail_id);
 298         if (tn == NULL) {
 299                 EM_DEBUG_EXCEPTION("tpl_map failed");
 300                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 301                 goto FINISH_OFF;
 302         }
 303
 304         tpl_pack(tn, 0);
 305         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);
 306         tpl_free(tn);
 307
 308         *output_byte_stream = result_data;
 309         *output_stream_size = result_data_length;
 310
 311 FINISH_OFF:
 312
 313         EM_DEBUG_FUNC_END("err [%d]", err);
 314         return err;
 315 }
 316
 317 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)
 318 {
 319         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);
 320         int err = EMAIL_ERROR_NONE;
 321         tpl_node *tn = NULL;
 322         task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL *task_parameter = NULL;
 323
 324         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {
 325                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 326                 err = EMAIL_ERROR_INVALID_PARAM;
 327                 goto FINISH_OFF;
 328         }
 329
 330         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL));
 331         if (task_parameter == NULL) {
 332                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 333                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 334                 goto FINISH_OFF;
 335         }
 336
 337         tn = tpl_map(task_parameter_format_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL
 338                                 , &task_parameter->mail_id);
 339         if (tn == NULL) {
 340                 EM_DEBUG_EXCEPTION("tpl_map failed");
 341                 EM_SAFE_FREE(task_parameter);
 342                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 343                 goto FINISH_OFF;
 344         }
 345
 346         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);
 347         tpl_unpack(tn, 0);
 348
 349         *output_task_parameter_struct = task_parameter;
 350
 351 FINISH_OFF:
 352
 353         if(tn)
 354                 tpl_free(tn);
 355
 356         EM_DEBUG_FUNC_END("err [%d]", err);
 357         return err;
 358 }
 359
 360 INTERNAL_FUNC void* task_handler_EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL(void *input_param)
 361 {
 362         return NULL;
 363 }
 364 /*-------------------------------------------------------------------------------------------*/
 365 /* to handle EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL */
 366 #define task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL "ii"
 367
 368 INTERNAL_FUNC int email_encode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size)
 369 {
 370         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);
 371
 372         int err = EMAIL_ERROR_NONE;
 373         task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_parameter = input_task_parameter_struct;
 374         tpl_node *tn = NULL;
 375         void  *result_data = NULL;
 376         size_t result_data_length = 0;
 377
 378         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
 379                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 380                 err = EMAIL_ERROR_INVALID_PARAM;
 381                 goto FINISH_OFF;
 382         }
 383
 384         tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL
 385                         , &task_parameter->mail_id, &task_parameter->scheduled_time);
 386         if (tn == NULL) {
 387                 EM_DEBUG_EXCEPTION("tpl_map failed");
 388                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 389                 goto FINISH_OFF;
 390         }
 391
 392         tpl_pack(tn, 0);
 393         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);
 394         tpl_free(tn);
 395
 396         *output_byte_stream = result_data;
 397         *output_stream_size = result_data_length;
 398
 399 FINISH_OFF:
 400
 401         EM_DEBUG_FUNC_END("err [%d]", err);
 402         return err;
 403 }
 404
 405 INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct)
 406 {
 407         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);
 408         int err = EMAIL_ERROR_NONE;
 409         tpl_node *tn = NULL;
 410         task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_parameter = NULL;
 411
 412         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {
 413                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 414                 err = EMAIL_ERROR_INVALID_PARAM;
 415                 goto FINISH_OFF;
 416         }
 417
 418         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL));
 419         if(task_parameter == NULL) {
 420                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 421                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 422                 goto FINISH_OFF;
 423         }
 424
 425         tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL
 426                                 , &task_parameter->mail_id, &task_parameter->scheduled_time);
 427         if (tn == NULL) {
 428                 EM_DEBUG_EXCEPTION("tpl_map failed");
 429                 EM_SAFE_FREE(task_parameter);
 430                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 431                 goto FINISH_OFF;
 432         }
 433
 434         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);
 435         tpl_unpack(tn, 0);
 436
 437         *output_task_parameter_struct = task_parameter;
 438
 439 FINISH_OFF:
 440
 441         if(tn)
 442                 tpl_free(tn);
 443
 444         EM_DEBUG_FUNC_END("err [%d]", err);
 445         return err;
 446 }
 447
 448 INTERNAL_FUNC void* task_handler_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL(void *input_param)
 449 {
 450         EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param);
 451
 452         int err = EMAIL_ERROR_NONE;
 453         int *return_err = NULL;
 454         task_parameter_EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL *task_param = input_param;
 455
 456         if ((err = emcore_schedule_sending_mail(task_param->multi_user_name,
 457                                                                                         task_param->mail_id,
 458                                                                                         task_param->scheduled_time)) != EMAIL_ERROR_NONE) {
 459                 EM_DEBUG_EXCEPTION("emcore_schedule_sending_mail [%d]", err);
 460                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 461                 goto FINISH_OFF;
 462         }
 463
 464         return_err = em_malloc(sizeof(int));
 465         if (return_err == NULL) {
 466                 EM_DEBUG_EXCEPTION("em_malloc failed");
 467                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 468                 goto FINISH_OFF;
 469         }
 470
 471         *return_err = err;
 472
 473 FINISH_OFF:
 474
 475         EM_SAFE_FREE(task_param);
 476         emcore_close_smtp_stream_list();
 477         EM_DEBUG_FUNC_END("err [%d]", err);
 478
 479         return (void *)return_err;
 480 }
 481 /*-------------------------------------------------------------------------------------------*/
 482 /* to handle EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE */
 483 #define task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE "iiBiiB"
 484
 485 INTERNAL_FUNC int email_encode_task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size)
 486 {
 487         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);
 488
 489         int err = EMAIL_ERROR_NONE;
 490         task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_parameter = input_task_parameter_struct;
 491         email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE;
 492         tpl_bin tb_mail_id_array;
 493         tpl_bin tb_value;
 494         tpl_node *tn = NULL;
 495         void  *result_data = NULL;
 496         size_t result_data_length = 0;
 497
 498         if (task_parameter == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
 499                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 500                 err = EMAIL_ERROR_INVALID_PARAM;
 501                 goto FINISH_OFF;
 502         }
 503
 504         if ((err = emcore_get_mail_attribute_value_type(task_parameter->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) {
 505                 EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err);
 506                 goto FINISH_OFF;
 507         }
 508
 509         tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE
 510                                 , &task_parameter->account_id
 511                                 , &task_parameter->mail_id_count
 512                                 , &tb_mail_id_array
 513                                 , &task_parameter->attribute_type
 514                                 , &task_parameter->value_length
 515                                 , &tb_value);
 516         if (tn == NULL) {
 517                 EM_DEBUG_EXCEPTION("tpl_map failed");
 518                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 519                 goto FINISH_OFF;
 520         }
 521
 522         tb_mail_id_array.sz   = sizeof(int) * task_parameter->mail_id_count;
 523         tb_mail_id_array.addr = task_parameter->mail_id_array;
 524
 525         switch(attribute_value_type) {
 526                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER :
 527                         task_parameter->value_length = 4;
 528                         tb_value.sz                  = task_parameter->value_length;
 529                         tb_value.addr                = &task_parameter->value.integer_type_value;
 530                         break;
 531                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING :
 532                         task_parameter->value_length = EM_SAFE_STRLEN(task_parameter->value.string_type_value);
 533                         tb_value.sz                  = task_parameter->value_length;
 534                         tb_value.addr                = task_parameter->value.string_type_value;
 535                         break;
 536                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME :
 537                         task_parameter->value_length = 4;
 538                         tb_value.sz                  = task_parameter->value_length;
 539                         tb_value.addr                = &task_parameter->value.datetime_type_value;
 540                         break;
 541                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE :
 542                 default :
 543                         EM_DEBUG_EXCEPTION("invalid attribute value type [%d]", attribute_value_type);
 544                         err = EMAIL_ERROR_INVALID_PARAM;
 545                         goto FINISH_OFF;
 546         }
 547
 548         tpl_pack(tn, 0);
 549         tpl_dump(tn, TPL_MEM, &result_data, &result_data_length);
 550
 551         *output_byte_stream = result_data;
 552         *output_stream_size = result_data_length;
 553
 554 FINISH_OFF:
 555
 556         if(tn)
 557                 tpl_free(tn);
 558
 559         EM_DEBUG_FUNC_END("err [%d]", err);
 560         return EMAIL_ERROR_NONE;
 561 }
 562
 563 INTERNAL_FUNC int email_decode_task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct)
 564 {
 565         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);
 566         int err = EMAIL_ERROR_NONE;
 567         tpl_node *tn = NULL;
 568         tpl_bin tb_mail_id_array;
 569         tpl_bin tb_value;
 570         task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_parameter = NULL;
 571         email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE;
 572
 573         if (input_byte_stream == NULL || input_stream_size == 0 || output_task_parameter_struct == NULL) {
 574                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 575                 err = EMAIL_ERROR_INVALID_PARAM;
 576                 goto FINISH_OFF;
 577         }
 578
 579         task_parameter = em_malloc(sizeof(task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE));
 580
 581         if(task_parameter == NULL) {
 582                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 583                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 584                 goto FINISH_OFF;
 585         }
 586
 587         tn = tpl_map(task_parameter_format_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE
 588                         , &task_parameter->account_id
 589                         , &task_parameter->mail_id_count
 590                         , &tb_mail_id_array
 591                         , &task_parameter->attribute_type
 592                         , &task_parameter->value_length
 593                         , &tb_value);
 594         if (tn == NULL) {
 595                 EM_DEBUG_EXCEPTION("tpl_map failed");
 596                 err = EMAIL_ERROR_SYSTEM_FAILURE;
 597                 goto FINISH_OFF;
 598         }
 599
 600         tpl_load(tn, TPL_MEM, input_byte_stream, input_stream_size);
 601         tpl_unpack(tn, 0);
 602
 603         if(task_parameter->mail_id_count <= 0 || tb_mail_id_array.addr == NULL) {
 604                 EM_DEBUG_LOG("No mail id list. mail_id_count[%d] addr[%p]", task_parameter->mail_id_count, tb_mail_id_array.addr);
 605         }
 606         else {
 607                 task_parameter->mail_id_array = tb_mail_id_array.addr;
 608         }
 609
 610         if(tb_value.addr) {
 611                 if ((err = emcore_get_mail_attribute_value_type(task_parameter->attribute_type, &attribute_value_type)) != EMAIL_ERROR_NONE) {
 612                         EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err);
 613                         goto FINISH_OFF;
 614                 }
 615
 616                 switch(attribute_value_type) {
 617                         case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER :
 618                                 memcpy(&task_parameter->value.integer_type_value, tb_value.addr, tb_value.sz);
 619                                 break;
 620                         case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING :
 621                                 task_parameter->value.string_type_value = em_malloc(tb_value.sz + 1);
 622                                 if(task_parameter->value.string_type_value == NULL) {
 623                                         EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 624                                         err = EMAIL_ERROR_OUT_OF_MEMORY;
 625                                         goto FINISH_OFF;
 626                                 }
 627                                 memcpy(&task_parameter->value.string_type_value, tb_value.addr, tb_value.sz);
 628                                 break;
 629                         case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME :
 630                                 memcpy(&task_parameter->value.datetime_type_value, tb_value.addr, tb_value.sz);
 631                                 break;
 632                         case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE :
 633                         default :
 634                                 EM_DEBUG_EXCEPTION("invalid attribute value type [%d]", attribute_value_type);
 635                                 err = EMAIL_ERROR_INVALID_PARAM;
 636                                 goto FINISH_OFF;
 637                 }
 638         }
 639
 640         *output_task_parameter_struct = task_parameter;
 641
 642 FINISH_OFF:
 643
 644         if(tn)
 645                 tpl_free(tn);
 646
 647         EM_DEBUG_FUNC_END("err [%d]", err);
 648         return EMAIL_ERROR_NONE;
 649 }
 650
 651 INTERNAL_FUNC void *task_handler_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE(void *input_param)
 652 {
 653         EM_DEBUG_FUNC_BEGIN("input_param [%p]", input_param);
 654         if (!input_param) { /*prevent 43681*/
 655                 EM_DEBUG_EXCEPTION("NULL parameter");
 656                 return NULL;
 657         }
 658
 659         int err = EMAIL_ERROR_NONE;
 660         int *return_err = NULL;
 661         char *field_name = NULL;
 662         task_parameter_EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE *task_param = input_param;
 663         email_mail_attribute_value_type attribute_value_type = EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE; /*prevent 43700*/
 664
 665         if ((field_name = emcore_get_mail_field_name_by_attribute_type(task_param->attribute_type)) == NULL) {
 666                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 667                 err = EMAIL_ERROR_INVALID_PARAM;
 668                 goto FINISH_OFF;
 669         }
 670
 671         if ((err = emcore_get_mail_attribute_value_type(task_param->attribute_type,
 672                                                                                                         &attribute_value_type)) != EMAIL_ERROR_NONE) {
 673                 EM_DEBUG_EXCEPTION("emcore_get_mail_attribute_value_type failed [%d]", err);
 674                 goto FINISH_OFF;
 675         }
 676
 677         switch(attribute_value_type) {
 678                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_INTEGER :
 679                         if (!emstorage_set_field_of_mails_with_integer_value(task_param->multi_user_name,
 680                                                                                                                                 task_param->account_id,
 681                                                                                                                                 task_param->mail_id_array,
 682                                                                                                                                 task_param->mail_id_count,
 683                                                                                                                                 field_name,
 684                                                                                                                                 task_param->value.integer_type_value,
 685                                                                                                                                 true,
 686                                                                                                                                 &err)) {
 687                                 EM_DEBUG_EXCEPTION("emstorage_set_field_of_mails_with_integer_value failed [%d]", err);
 688                                 goto FINISH_OFF;
 689                         }
 690                         break;
 691                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING :
 692                         err = EMAIL_ERROR_NOT_SUPPORTED;
 693                         EM_DEBUG_LOG("EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING is not supported");
 694                         break;
 695                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_TIME :
 696                         if (!emstorage_set_field_of_mails_with_integer_value(task_param->multi_user_name,
 697                                                                                                                                 task_param->account_id,
 698                                                                                                                                 task_param->mail_id_array,
 699                                                                                                                                 task_param->mail_id_count,
 700                                                                                                                                 field_name,
 701                                                                                                                                 task_param->value.datetime_type_value,
 702                                                                                                                                 true,
 703                                                                                                                                 &err)) {
 704                                 EM_DEBUG_EXCEPTION("emstorage_set_field_of_mails_with_integer_value failed [%d]", err);
 705                                 goto FINISH_OFF;
 706                         }
 707                         break;
 708                 case EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE :
 709                 default :
 710                         EM_DEBUG_LOG("EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_NONE or default");
 711                         err = EMAIL_ERROR_INVALID_PARAM;
 712                         break;
 713         }
 714
 715         return_err = em_malloc(sizeof(int));
 716         if (return_err == NULL) {
 717                 EM_DEBUG_EXCEPTION("em_malloc failed");
 718                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 719                 goto FINISH_OFF;
 720         }
 721
 722         *return_err = err;
 723
 724 FINISH_OFF:
 725
 726         EM_SAFE_FREE(task_param->multi_user_name);
 727         EM_SAFE_FREE(task_param->mail_id_array);
 728         if (attribute_value_type == EMAIL_MAIL_ATTRIBUTE_VALUE_TYPE_STRING) {
 729                 EM_SAFE_FREE(task_param->value.string_type_value);
 730         }
 731
 732         EM_SAFE_FREE (task_param);
 733
 734         EM_DEBUG_FUNC_END("err [%d]", err);
 735
 736         return (void *)return_err;
 737 }
 738 /*-------------------------------------------------------------------------------------------*/