email-common-use/email-convert.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 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include "string.h"
  25 #include "email-convert.h"
  26 #include "email-core-mail.h"
  27 #include "email-debug-log.h"
  28 #include "email-core-utils.h"
  29 #include "email-utilities.h"
  30 #include "email-storage.h"
  31 #include "tpl.h"
  32
  33 #define fSEEN 0x1
  34 #define fDELETED 0x2
  35 #define fFLAGGED 0x4
  36 #define fANSWERED 0x8
  37 #define fOLD 0x10
  38 #define fDRAFT 0x20
  39 #define fATTACHMENT 0x40
  40 #define fFORWARD    0x80
  41
  42
  43 INTERNAL_FUNC int em_convert_account_to_account_tbl(email_account_t *account, emstorage_account_tbl_t *account_tbl)
  44 {
  45         EM_DEBUG_FUNC_BEGIN("account[%p], account_tbl[%p]", account, account_tbl);
  46         int ret = 1;
  47
  48         account_tbl->account_name                             = EM_SAFE_STRDUP(account->account_name);
  49         account_tbl->incoming_server_type                     = account->incoming_server_type;
  50         account_tbl->incoming_server_address                  = EM_SAFE_STRDUP(account->incoming_server_address);
  51         account_tbl->user_email_address                       = EM_SAFE_STRDUP(account->user_email_address);
  52         account_tbl->incoming_server_user_name                = EM_SAFE_STRDUP(account->incoming_server_user_name);
  53         account_tbl->incoming_server_password                 = EM_SAFE_STRDUP(account->incoming_server_password);
  54         account_tbl->retrieval_mode                           = account->retrieval_mode;
  55         account_tbl->incoming_server_port_number              = account->incoming_server_port_number;
  56         account_tbl->incoming_server_secure_connection        = account->incoming_server_secure_connection;
  57         account_tbl->outgoing_server_type                     = account->outgoing_server_type;
  58         account_tbl->outgoing_server_address                  = EM_SAFE_STRDUP(account->outgoing_server_address);
  59         account_tbl->outgoing_server_port_number              = account->outgoing_server_port_number;
  60         account_tbl->outgoing_server_need_authentication      = account->outgoing_server_need_authentication;
  61         account_tbl->outgoing_server_secure_connection        = account->outgoing_server_secure_connection;
  62         account_tbl->outgoing_server_user_name                = EM_SAFE_STRDUP(account->outgoing_server_user_name);
  63         account_tbl->outgoing_server_password                 = EM_SAFE_STRDUP(account->outgoing_server_password);
  64         account_tbl->user_display_name                        = EM_SAFE_STRDUP(account->user_display_name);
  65         account_tbl->reply_to_address                         = EM_SAFE_STRDUP(account->reply_to_address);
  66         account_tbl->return_address                           = EM_SAFE_STRDUP(account->return_address);
  67         account_tbl->account_id                               = account->account_id;
  68         account_tbl->keep_mails_on_pop_server_after_download  = account->keep_mails_on_pop_server_after_download;
  69         account_tbl->auto_download_size                       = account->auto_download_size;
  70         account_tbl->outgoing_server_use_same_authenticator   = account->outgoing_server_use_same_authenticator;
  71         account_tbl->pop_before_smtp                          = account->pop_before_smtp;
  72         account_tbl->incoming_server_requires_apop            = account->incoming_server_requires_apop;
  73         account_tbl->logo_icon_path                           = EM_SAFE_STRDUP(account->logo_icon_path);
  74
  75         account_tbl->user_data                                = em_memdup(account->user_data, account->user_data_length);
  76         account_tbl->user_data_length                         = account->user_data_length;
  77
  78         account_tbl->options.priority                         = account->options.priority;
  79         account_tbl->options.keep_local_copy                  = account->options.keep_local_copy;
  80         account_tbl->options.req_delivery_receipt             = account->options.req_delivery_receipt;
  81         account_tbl->options.req_read_receipt                 = account->options.req_read_receipt;
  82         account_tbl->options.download_limit                   = account->options.download_limit;
  83         account_tbl->options.block_address                    = account->options.block_address;
  84         account_tbl->options.block_subject                    = account->options.block_subject;
  85         account_tbl->options.display_name_from                = EM_SAFE_STRDUP(account->options.display_name_from);
  86         account_tbl->options.reply_with_body                  = account->options.reply_with_body;
  87         account_tbl->options.forward_with_files               = account->options.forward_with_files;
  88         account_tbl->options.add_myname_card                  = account->options.add_myname_card;
  89         account_tbl->options.add_signature                    = account->options.add_signature;
  90         account_tbl->options.signature                        = EM_SAFE_STRDUP(account->options.signature);
  91         account_tbl->options.add_my_address_to_bcc            = account->options.add_my_address_to_bcc;
  92         account_tbl->check_interval                           = account->check_interval;
  93         account_tbl->account_svc_id                           = account->account_svc_id;
  94         account_tbl->sync_status                              = account->sync_status;
  95         account_tbl->sync_disabled                            = account->sync_disabled;
  96         account_tbl->default_mail_slot_size                   = account->default_mail_slot_size;
  97         account_tbl->smime_type                               = account->smime_type;
  98         account_tbl->certificate_path                         = EM_SAFE_STRDUP(account->certificate_path);
  99         account_tbl->cipher_type                              = account->cipher_type;
 100         account_tbl->digest_type                              = account->digest_type;
 101
 102
 103         EM_DEBUG_FUNC_END();
 104         return ret;
 105 }
 106
 107 INTERNAL_FUNC int em_convert_account_tbl_to_account(emstorage_account_tbl_t *account_tbl, email_account_t *account)
 108 {
 109         EM_DEBUG_FUNC_BEGIN("account_tbl[%p], account[%p]", account_tbl, account);
 110         int ret = 1;
 111
 112         account->account_name                             = EM_SAFE_STRDUP(account_tbl->account_name);
 113         account->incoming_server_type                     = account_tbl->incoming_server_type;
 114         account->incoming_server_address                  = EM_SAFE_STRDUP(account_tbl->incoming_server_address);
 115         account->user_email_address                       = EM_SAFE_STRDUP(account_tbl->user_email_address);
 116         account->incoming_server_user_name                = EM_SAFE_STRDUP(account_tbl->incoming_server_user_name);
 117         account->incoming_server_password                 = EM_SAFE_STRDUP(account_tbl->incoming_server_password);
 118         account->retrieval_mode                           = account_tbl->retrieval_mode;
 119         account->incoming_server_port_number              = account_tbl->incoming_server_port_number;
 120         account->incoming_server_secure_connection        = account_tbl->incoming_server_secure_connection;
 121         account->outgoing_server_type                     = account_tbl->outgoing_server_type;
 122         account->outgoing_server_address                  = EM_SAFE_STRDUP(account_tbl->outgoing_server_address);
 123         account->outgoing_server_port_number              = account_tbl->outgoing_server_port_number;
 124         account->outgoing_server_need_authentication      = account_tbl->outgoing_server_need_authentication;
 125         account->outgoing_server_secure_connection        = account_tbl->outgoing_server_secure_connection;
 126         account->outgoing_server_user_name                = EM_SAFE_STRDUP(account_tbl->outgoing_server_user_name);
 127         account->outgoing_server_password                 = EM_SAFE_STRDUP(account_tbl->outgoing_server_password);
 128         account->user_display_name                        = EM_SAFE_STRDUP(account_tbl->user_display_name);
 129         account->reply_to_address                         = EM_SAFE_STRDUP(account_tbl->reply_to_address);
 130         account->return_address                           = EM_SAFE_STRDUP(account_tbl->return_address);
 131         account->account_id                               = account_tbl->account_id;
 132         account->keep_mails_on_pop_server_after_download  = account_tbl->keep_mails_on_pop_server_after_download;
 133         account->auto_download_size                       = account_tbl->auto_download_size;
 134         account->outgoing_server_use_same_authenticator   = account_tbl->outgoing_server_use_same_authenticator;
 135         account->pop_before_smtp                          = account_tbl->pop_before_smtp;
 136         account->incoming_server_requires_apop            = account_tbl->incoming_server_requires_apop;
 137         account->logo_icon_path                           = EM_SAFE_STRDUP(account_tbl->logo_icon_path);
 138         account->user_data                     = em_memdup(account_tbl->user_data, account_tbl->user_data_length);
 139         account->user_data_length              = account_tbl->user_data_length;
 140         account->options.priority                         = account_tbl->options.priority;
 141         account->options.keep_local_copy                  = account_tbl->options.keep_local_copy;
 142         account->options.req_delivery_receipt             = account_tbl->options.req_delivery_receipt;
 143         account->options.req_read_receipt                 = account_tbl->options.req_read_receipt;
 144         account->options.download_limit                   = account_tbl->options.download_limit;
 145         account->options.block_address                    = account_tbl->options.block_address;
 146         account->options.block_subject                    = account_tbl->options.block_subject;
 147         account->options.display_name_from                = EM_SAFE_STRDUP(account_tbl->options.display_name_from);
 148         account->options.reply_with_body                  = account_tbl->options.reply_with_body;
 149         account->options.forward_with_files               = account_tbl->options.forward_with_files;
 150         account->options.add_myname_card                  = account_tbl->options.add_myname_card;
 151         account->options.add_signature                    = account_tbl->options.add_signature;
 152         account->options.signature                        = EM_SAFE_STRDUP(account_tbl->options.signature);
 153         account->options.add_my_address_to_bcc            = account_tbl->options.add_my_address_to_bcc;
 154         account->check_interval                           = account_tbl->check_interval;
 155         account->account_svc_id                           = account_tbl->account_svc_id;
 156         account->sync_status                              = account_tbl->sync_status;
 157         account->sync_disabled                            = account_tbl->sync_disabled;
 158         account->default_mail_slot_size                   = account_tbl->default_mail_slot_size;
 159         account->smime_type                               = account_tbl->smime_type;
 160         account->certificate_path                         = EM_SAFE_STRDUP(account_tbl->certificate_path);
 161         account->cipher_type                              = account_tbl->cipher_type;
 162         account->digest_type                              = account_tbl->digest_type;
 163
 164         EM_DEBUG_FUNC_END();
 165         return ret;
 166 }
 167
 168 INTERNAL_FUNC int em_convert_mailbox_to_mailbox_tbl(email_mailbox_t *mailbox, emstorage_mailbox_tbl_t *mailbox_tbl)
 169 {
 170         EM_DEBUG_FUNC_BEGIN("mailbox[%p], mailbox_tbl[%p]", mailbox, mailbox_tbl);
 171         int ret = 1;
 172
 173         mailbox_tbl->account_id                 = mailbox->account_id;
 174         mailbox_tbl->mailbox_id                 = mailbox->mailbox_id;
 175         mailbox_tbl->mailbox_name               = EM_SAFE_STRDUP(mailbox->mailbox_name);
 176         mailbox_tbl->alias                      = EM_SAFE_STRDUP(mailbox->alias);
 177         mailbox_tbl->local_yn                   = mailbox->local;
 178         mailbox_tbl->mailbox_type               = mailbox->mailbox_type;
 179         mailbox_tbl->unread_count               = mailbox->unread_count;
 180         mailbox_tbl->total_mail_count_on_local  = mailbox->total_mail_count_on_local;
 181         mailbox_tbl->total_mail_count_on_server = mailbox->total_mail_count_on_server;
 182         mailbox_tbl->mail_slot_size             = mailbox->mail_slot_size;
 183         mailbox_tbl->no_select                  = mailbox->no_select;
 184         mailbox_tbl->last_sync_time             = mailbox->last_sync_time;
 185         mailbox_tbl->deleted_flag               = mailbox->deleted_flag;
 186
 187         EM_DEBUG_FUNC_END();
 188         return ret;
 189 }
 190
 191 INTERNAL_FUNC int em_convert_mailbox_tbl_to_mailbox(emstorage_mailbox_tbl_t *mailbox_tbl, email_mailbox_t *mailbox)
 192 {
 193         EM_DEBUG_FUNC_BEGIN("mailbox_tbl[%p], mailbox[%p]", mailbox_tbl, mailbox);
 194         int ret = 1;
 195
 196         mailbox->account_id                 = mailbox_tbl->account_id;
 197         mailbox->mailbox_id                 = mailbox_tbl->mailbox_id;
 198         mailbox->mailbox_name               = EM_SAFE_STRDUP(mailbox_tbl->mailbox_name);
 199         mailbox->alias                      = EM_SAFE_STRDUP(mailbox_tbl->alias);
 200         mailbox->local                      = mailbox_tbl->local_yn;
 201         mailbox->mailbox_type               = mailbox_tbl->mailbox_type;
 202         mailbox->unread_count               = mailbox_tbl->unread_count;
 203         mailbox->total_mail_count_on_local  = mailbox_tbl->total_mail_count_on_local;
 204         mailbox->total_mail_count_on_server = mailbox_tbl->total_mail_count_on_server;
 205         mailbox->mail_slot_size             = mailbox_tbl->mail_slot_size;
 206         mailbox->no_select                  = mailbox_tbl->no_select;
 207         mailbox->last_sync_time             = mailbox_tbl->last_sync_time;
 208         mailbox->deleted_flag               = mailbox_tbl->deleted_flag;
 209
 210         EM_DEBUG_FUNC_END();
 211         return ret;
 212 }
 213
 214
 215 INTERNAL_FUNC int em_convert_mail_tbl_to_mail_data(emstorage_mail_tbl_t *mail_table_data, int item_count, email_mail_data_t **mail_data, int *error)
 216 {
 217         EM_DEBUG_FUNC_BEGIN("mail_table_data[%p], item_count [%d], mail_data[%p]", mail_table_data, item_count, mail_data);
 218         int i, ret = false, err_code = EMAIL_ERROR_NONE;
 219         email_mail_data_t *temp_mail_data = NULL;
 220
 221         if (!mail_table_data || !mail_data || !item_count) {
 222                 EM_DEBUG_EXCEPTION("Invalid parameter");
 223                 err_code = EMAIL_ERROR_INVALID_PARAM;
 224                 goto FINISH_OFF;
 225         }
 226
 227         temp_mail_data = em_malloc(sizeof(email_mail_data_t) * item_count);
 228
 229         if(!temp_mail_data) {
 230                 EM_DEBUG_EXCEPTION("em_malloc failed");
 231                 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
 232                 goto FINISH_OFF;
 233         }
 234
 235         for(i = 0; i < item_count; i++) {
 236                 temp_mail_data[i].mail_id                 = mail_table_data[i].mail_id;
 237                 temp_mail_data[i].account_id              = mail_table_data[i].account_id;
 238                 temp_mail_data[i].mailbox_id              = mail_table_data[i].mailbox_id;
 239                 temp_mail_data[i].mailbox_type            = mail_table_data[i].mailbox_type;
 240                 temp_mail_data[i].subject                 = EM_SAFE_STRDUP(mail_table_data[i].subject);
 241                 temp_mail_data[i].date_time               = mail_table_data[i].date_time;
 242                 temp_mail_data[i].server_mail_status      = mail_table_data[i].server_mail_status;
 243                 temp_mail_data[i].server_mailbox_name     = EM_SAFE_STRDUP(mail_table_data[i].server_mailbox_name);
 244                 temp_mail_data[i].server_mail_id          = EM_SAFE_STRDUP(mail_table_data[i].server_mail_id);
 245                 temp_mail_data[i].message_id              = EM_SAFE_STRDUP(mail_table_data[i].message_id);
 246                 temp_mail_data[i].reference_mail_id       = mail_table_data[i].reference_mail_id;
 247                 temp_mail_data[i].full_address_from       = EM_SAFE_STRDUP(mail_table_data[i].full_address_from);
 248                 temp_mail_data[i].full_address_reply      = EM_SAFE_STRDUP(mail_table_data[i].full_address_reply);
 249                 temp_mail_data[i].full_address_to         = EM_SAFE_STRDUP(mail_table_data[i].full_address_to);
 250                 temp_mail_data[i].full_address_cc         = EM_SAFE_STRDUP(mail_table_data[i].full_address_cc);
 251                 temp_mail_data[i].full_address_bcc        = EM_SAFE_STRDUP(mail_table_data[i].full_address_bcc);
 252                 temp_mail_data[i].full_address_return     = EM_SAFE_STRDUP(mail_table_data[i].full_address_return);
 253                 temp_mail_data[i].email_address_sender    = EM_SAFE_STRDUP(mail_table_data[i].email_address_sender);
 254                 temp_mail_data[i].email_address_recipient = EM_SAFE_STRDUP(mail_table_data[i].email_address_recipient);
 255                 temp_mail_data[i].alias_sender            = EM_SAFE_STRDUP(mail_table_data[i].alias_sender);
 256                 temp_mail_data[i].alias_recipient         = EM_SAFE_STRDUP(mail_table_data[i].alias_recipient);
 257                 temp_mail_data[i].body_download_status    = mail_table_data[i].body_download_status;
 258                 temp_mail_data[i].file_path_plain         = EM_SAFE_STRDUP(mail_table_data[i].file_path_plain);
 259                 temp_mail_data[i].file_path_html          = EM_SAFE_STRDUP(mail_table_data[i].file_path_html);
 260                 temp_mail_data[i].file_path_mime_entity   = EM_SAFE_STRDUP(mail_table_data[i].file_path_mime_entity);
 261                 temp_mail_data[i].mail_size               = mail_table_data[i].mail_size;
 262                 temp_mail_data[i].flags_seen_field        = mail_table_data[i].flags_seen_field;
 263                 temp_mail_data[i].flags_deleted_field     = mail_table_data[i].flags_deleted_field;
 264                 temp_mail_data[i].flags_flagged_field     = mail_table_data[i].flags_flagged_field;
 265                 temp_mail_data[i].flags_answered_field    = mail_table_data[i].flags_answered_field;
 266                 temp_mail_data[i].flags_recent_field      = mail_table_data[i].flags_recent_field;
 267                 temp_mail_data[i].flags_draft_field       = mail_table_data[i].flags_draft_field;
 268                 temp_mail_data[i].flags_forwarded_field   = mail_table_data[i].flags_forwarded_field;
 269                 temp_mail_data[i].DRM_status              = mail_table_data[i].DRM_status;
 270                 temp_mail_data[i].priority                = mail_table_data[i].priority;
 271                 temp_mail_data[i].save_status             = mail_table_data[i].save_status;
 272                 temp_mail_data[i].lock_status             = mail_table_data[i].lock_status;
 273                 temp_mail_data[i].report_status           = mail_table_data[i].report_status;
 274                 temp_mail_data[i].attachment_count        = mail_table_data[i].attachment_count;
 275                 temp_mail_data[i].inline_content_count    = mail_table_data[i].inline_content_count;
 276                 temp_mail_data[i].thread_id               = mail_table_data[i].thread_id;
 277                 temp_mail_data[i].thread_item_count       = mail_table_data[i].thread_item_count;
 278                 temp_mail_data[i].preview_text            = EM_SAFE_STRDUP(mail_table_data[i].preview_text);
 279                 temp_mail_data[i].meeting_request_status  = mail_table_data[i].meeting_request_status;
 280                 temp_mail_data[i].message_class           = mail_table_data[i].message_class;
 281                 temp_mail_data[i].digest_type             = mail_table_data[i].digest_type;
 282                 temp_mail_data[i].smime_type              = mail_table_data[i].smime_type;
 283                 temp_mail_data[i].scheduled_sending_time  = mail_table_data[i].scheduled_sending_time;
 284                 temp_mail_data[i].eas_data_length         = mail_table_data[i].eas_data_length;
 285                 if(mail_table_data[i].eas_data_length && mail_table_data[i].eas_data) {
 286                         if((temp_mail_data[i].eas_data = em_malloc(mail_table_data[i].eas_data_length)) == NULL) {
 287                                 EM_DEBUG_EXCEPTION("em_malloc failed");
 288                                 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
 289                                 goto FINISH_OFF;
 290                         }
 291                 }
 292                 memcpy(temp_mail_data[i].eas_data, mail_table_data[i].eas_data, mail_table_data[i].eas_data_length);
 293         }
 294
 295         *mail_data = temp_mail_data;
 296
 297         ret = true;
 298 FINISH_OFF:
 299
 300         if(ret == false && temp_mail_data) {
 301                 emcore_free_mail_data_list(&temp_mail_data, item_count);
 302         }
 303
 304
 305         if(error)
 306                 *error = err_code;
 307
 308         EM_DEBUG_FUNC_END();
 309         return ret;
 310 }
 311
 312 INTERNAL_FUNC int   em_convert_mail_data_to_mail_tbl(email_mail_data_t *mail_data, int item_count, emstorage_mail_tbl_t **mail_table_data, int *error)
 313 {
 314         EM_DEBUG_FUNC_BEGIN("mail_data[%p], item_count [%d], mail_table_data[%p]", mail_data, item_count, mail_table_data);
 315         int i, ret = false, err_code = EMAIL_ERROR_NONE;
 316         emstorage_mail_tbl_t *temp_mail_tbl = NULL;
 317
 318         if (!mail_data || !mail_table_data || !item_count) {
 319                 EM_DEBUG_EXCEPTION("Invalid parameter");
 320                 err_code = EMAIL_ERROR_INVALID_PARAM;
 321                 goto FINISH_OFF;
 322         }
 323
 324         temp_mail_tbl = em_malloc(sizeof(emstorage_mail_tbl_t) * item_count);
 325
 326         if(!temp_mail_tbl) {
 327                 EM_DEBUG_EXCEPTION("em_malloc failed");
 328                 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
 329                 goto FINISH_OFF;
 330         }
 331
 332         for(i = 0; i < item_count; i++) {
 333                 temp_mail_tbl[i].mail_id                 = mail_data[i].mail_id;
 334                 temp_mail_tbl[i].account_id              = mail_data[i].account_id;
 335                 temp_mail_tbl[i].mailbox_id              = mail_data[i].mailbox_id;
 336                 temp_mail_tbl[i].mailbox_type            = mail_data[i].mailbox_type;
 337                 temp_mail_tbl[i].date_time               = mail_data[i].date_time;
 338                 temp_mail_tbl[i].subject                 = EM_SAFE_STRDUP(mail_data[i].subject);
 339                 temp_mail_tbl[i].server_mail_status      = mail_data[i].server_mail_status;
 340                 temp_mail_tbl[i].server_mailbox_name     = EM_SAFE_STRDUP(mail_data[i].server_mailbox_name);
 341                 temp_mail_tbl[i].server_mail_id          = EM_SAFE_STRDUP(mail_data[i].server_mail_id);
 342                 temp_mail_tbl[i].message_id              = EM_SAFE_STRDUP(mail_data[i].message_id);
 343                 temp_mail_tbl[i].reference_mail_id       = mail_data[i].reference_mail_id;
 344                 temp_mail_tbl[i].full_address_from       = EM_SAFE_STRDUP(mail_data[i].full_address_from);
 345                 temp_mail_tbl[i].full_address_reply      = EM_SAFE_STRDUP(mail_data[i].full_address_reply);
 346                 temp_mail_tbl[i].full_address_to         = EM_SAFE_STRDUP(mail_data[i].full_address_to);
 347                 temp_mail_tbl[i].full_address_cc         = EM_SAFE_STRDUP(mail_data[i].full_address_cc);
 348                 temp_mail_tbl[i].full_address_bcc        = EM_SAFE_STRDUP(mail_data[i].full_address_bcc);
 349                 temp_mail_tbl[i].full_address_return     = EM_SAFE_STRDUP(mail_data[i].full_address_return);
 350                 temp_mail_tbl[i].email_address_sender    = EM_SAFE_STRDUP(mail_data[i].email_address_sender);
 351                 temp_mail_tbl[i].email_address_recipient = EM_SAFE_STRDUP(mail_data[i].email_address_recipient);
 352                 temp_mail_tbl[i].alias_sender            = EM_SAFE_STRDUP(mail_data[i].alias_sender);
 353                 temp_mail_tbl[i].alias_recipient         = EM_SAFE_STRDUP(mail_data[i].alias_recipient);
 354                 temp_mail_tbl[i].body_download_status    = mail_data[i].body_download_status;
 355                 temp_mail_tbl[i].file_path_plain         = EM_SAFE_STRDUP(mail_data[i].file_path_plain);
 356                 temp_mail_tbl[i].file_path_html          = EM_SAFE_STRDUP(mail_data[i].file_path_html);
 357                 temp_mail_tbl[i].file_path_mime_entity   = EM_SAFE_STRDUP(mail_data[i].file_path_mime_entity);
 358                 temp_mail_tbl[i].mail_size               = mail_data[i].mail_size;
 359                 temp_mail_tbl[i].flags_seen_field        = mail_data[i].flags_seen_field;
 360                 temp_mail_tbl[i].flags_deleted_field     = mail_data[i].flags_deleted_field;
 361                 temp_mail_tbl[i].flags_flagged_field     = mail_data[i].flags_flagged_field;
 362                 temp_mail_tbl[i].flags_answered_field    = mail_data[i].flags_answered_field;
 363                 temp_mail_tbl[i].flags_recent_field      = mail_data[i].flags_recent_field;
 364                 temp_mail_tbl[i].flags_draft_field       = mail_data[i].flags_draft_field;
 365                 temp_mail_tbl[i].flags_forwarded_field   = mail_data[i].flags_forwarded_field;
 366                 temp_mail_tbl[i].DRM_status              = mail_data[i].DRM_status;
 367                 temp_mail_tbl[i].priority                = mail_data[i].priority;
 368                 temp_mail_tbl[i].save_status             = mail_data[i].save_status;
 369                 temp_mail_tbl[i].lock_status             = mail_data[i].lock_status;
 370                 temp_mail_tbl[i].report_status           = mail_data[i].report_status;
 371                 temp_mail_tbl[i].attachment_count        = mail_data[i].attachment_count;
 372                 temp_mail_tbl[i].inline_content_count    = mail_data[i].inline_content_count;
 373                 temp_mail_tbl[i].thread_id               = mail_data[i].thread_id;
 374                 temp_mail_tbl[i].thread_item_count       = mail_data[i].thread_item_count;
 375                 temp_mail_tbl[i].preview_text            = EM_SAFE_STRDUP(mail_data[i].preview_text);
 376                 temp_mail_tbl[i].meeting_request_status  = mail_data[i].meeting_request_status;
 377                 temp_mail_tbl[i].message_class           = mail_data[i].message_class;
 378                 temp_mail_tbl[i].digest_type             = mail_data[i].digest_type;
 379                 temp_mail_tbl[i].smime_type              = mail_data[i].smime_type;
 380                 temp_mail_tbl[i].scheduled_sending_time  = mail_data[i].scheduled_sending_time;
 381                 temp_mail_tbl[i].eas_data_length         = mail_data[i].eas_data_length;
 382                 if(mail_data[i].eas_data_length && mail_data[i].eas_data) {
 383                         if((temp_mail_tbl[i].eas_data = em_malloc(mail_data[i].eas_data_length)) == NULL) {
 384                                 EM_DEBUG_EXCEPTION("em_malloc failed");
 385                                 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
 386                                 /*prevent 44357*/
 387                                 if (i > 0)
 388                                         emstorage_free_mail(&temp_mail_tbl, i, NULL);
 389                                 else
 390                                         EM_SAFE_FREE(temp_mail_tbl);
 391                                 goto FINISH_OFF;
 392                         }
 393                 }
 394                 memcpy(temp_mail_tbl[i].eas_data, mail_data[i].eas_data, mail_data[i].eas_data_length);
 395         }
 396
 397         *mail_table_data = temp_mail_tbl;
 398
 399         ret = true;
 400 FINISH_OFF:
 401
 402         if(error)
 403                 *error = err_code;
 404
 405         EM_DEBUG_FUNC_END();
 406         return ret;
 407
 408 }
 409
 410
 411
 412 INTERNAL_FUNC int em_convert_string_to_time_t(char *input_datetime_string, time_t *output_time)
 413 {
 414         EM_DEBUG_FUNC_BEGIN("input_datetime_string[%s], output_time[%p]", input_datetime_string, output_time);
 415
 416         char buf[16] = { 0, };
 417         struct tm temp_time_info = { 0 };
 418
 419         if (!input_datetime_string || !output_time) {
 420                 EM_DEBUG_EXCEPTION("input_datetime_string[%p], output_time[%p]", input_datetime_string, output_time);
 421                 return EMAIL_ERROR_INVALID_PARAM;
 422         }
 423
 424         memset(buf, 0x00, sizeof(buf));
 425         SNPRINTF(buf, sizeof(buf), "%.4s", input_datetime_string);
 426         temp_time_info.tm_year = atoi(buf) - 1970;
 427
 428         memset(buf, 0x00, sizeof(buf));
 429         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 4);
 430         temp_time_info.tm_mon = atoi(buf) - 1;
 431
 432         memset(buf, 0x00, sizeof(buf));
 433         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 6);
 434         temp_time_info.tm_mday = atoi(buf);
 435
 436         memset(buf, 0x00, sizeof(buf));
 437         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 8);
 438         temp_time_info.tm_hour = atoi(buf);
 439
 440         memset(buf, 0x00, sizeof(buf));
 441         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 10);
 442         temp_time_info.tm_min = atoi(buf);
 443
 444         memset(buf, 0x00, sizeof(buf));
 445         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 12);
 446         temp_time_info.tm_sec = atoi(buf);
 447
 448         *output_time = timegm(&temp_time_info);
 449
 450         EM_DEBUG_LOG("*output_time [%d", *output_time);
 451
 452         EM_DEBUG_FUNC_END("err %d", EMAIL_ERROR_NONE);
 453         return EMAIL_ERROR_NONE;
 454 }
 455
 456 INTERNAL_FUNC int em_convert_time_t_to_string(time_t *input_time, char **output_datetime_string)
 457 {
 458         EM_DEBUG_FUNC_BEGIN("input_time[%p], output_datetime_string[%p]", input_time, output_datetime_string);
 459         char temp_buffer[20] = { 0, };
 460         struct tm *temp_time_info;
 461
 462         if (!input_time || !output_datetime_string) {
 463                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 464                 return EMAIL_ERROR_INVALID_PARAM;
 465         }
 466
 467         temp_time_info = localtime(input_time);
 468
 469         if(!temp_time_info) {
 470                 EM_DEBUG_EXCEPTION("localtime failed.");
 471                 return EMAIL_ERROR_SYSTEM_FAILURE;
 472         }
 473         SNPRINTF(temp_buffer, sizeof(temp_buffer), "%04d%02d%02d%02d%02d%02d",
 474                 temp_time_info->tm_year + 1970, temp_time_info->tm_mon, temp_time_info->tm_mday, temp_time_info->tm_hour, temp_time_info->tm_min, temp_time_info->tm_sec);
 475
 476         *output_datetime_string = EM_SAFE_STRDUP(temp_buffer);
 477
 478         EM_DEBUG_FUNC_END("err %d", EMAIL_ERROR_NONE);
 479         return EMAIL_ERROR_NONE;
 480 }
 481
 482 static char* append_sized_data_to_stream(char *stream, int *stream_len, char *src, int src_len)
 483 {
 484         /* EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_length [%p], input_sized_data [%p], input_data_size [%d]", input_stream, input_output_stream_length, input_sized_data, input_data_size); */
 485         char *new_stream = NULL;
 486
 487         if( !stream_len || src_len == 0 || src == NULL || (stream != NULL && *stream_len == 0) ||
 488                         (stream == NULL && *stream_len != 0) ) {
 489                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 490                 return NULL;
 491         }
 492
 493         int old_stream_len = *stream_len;
 494
 495         /*TODO: don't increase stream buffer incrementally when appending new data */
 496         new_stream = (char*)em_malloc(old_stream_len + src_len);
 497
 498         if(!new_stream) {
 499                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 500                 return NULL;
 501         }
 502
 503         if(stream != NULL)
 504                 memcpy(new_stream, stream, old_stream_len);
 505
 506         memcpy(new_stream + old_stream_len, src, src_len);
 507
 508         *stream_len = old_stream_len + src_len;
 509
 510         EM_SAFE_FREE(stream);
 511         /* EM_DEBUG_FUNC_END("*input_output_stream_length [%d]", *input_output_stream_length); */
 512         return new_stream;
 513 }
 514
 515
 516 static char* append_string_to_stream(char *input_stream, int *input_output_stream_length, char *input_source_string)
 517 {
 518         EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_length [%p] input_source_string[%p]", input_stream, input_output_stream_length, input_source_string);
 519         char *new_stream = NULL;
 520         int   data_length = 0;
 521
 522         if( !input_output_stream_length || (input_stream != NULL && *input_output_stream_length == 0) ||
 523                 (input_stream == NULL && *input_output_stream_length != 0) ) {
 524                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 525                 return NULL;
 526         }
 527
 528         int source_stream_length = *input_output_stream_length;
 529
 530         data_length = EM_SAFE_STRLEN(input_source_string);
 531
 532         new_stream = (char*)em_malloc(source_stream_length + data_length + sizeof(int));
 533
 534         if(!new_stream) {
 535                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 536                 return NULL;
 537         }
 538
 539         if(input_stream != NULL)
 540                 memcpy(new_stream, input_stream, source_stream_length);
 541
 542         /* write string length */
 543         memcpy(new_stream + source_stream_length, (char*)&data_length, sizeof(int));
 544
 545         /* write string */
 546         if(input_source_string)
 547                 memcpy(new_stream + source_stream_length + sizeof(int), input_source_string, data_length);
 548
 549         /* for example, "abc" is written to stream buffer with "3abc" */
 550         *input_output_stream_length = source_stream_length + sizeof(int) + data_length;
 551
 552         EM_SAFE_FREE(input_stream);
 553         EM_DEBUG_FUNC_END("*input_output_stream_length [%d]", *input_output_stream_length);
 554         return new_stream;
 555 }
 556
 557 static int fetch_sized_data_from_stream(char *input_stream, int *input_output_stream_offset, int input_data_size, char *output_data)
 558 {
 559         /* EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_offset [%p] input_data_size [%d], output_data[%p]", input_stream, input_output_stream_offset, input_data_size, output_data); */
 560         int stream_offset = 0;
 561
 562         if( !input_stream || !input_output_stream_offset || !input_data_size || !output_data) {
 563                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 564                 return EMAIL_ERROR_INVALID_PARAM;
 565         }
 566
 567         stream_offset = *input_output_stream_offset;
 568
 569         memcpy(output_data, input_stream + stream_offset, input_data_size);
 570         stream_offset += input_data_size;
 571
 572         *input_output_stream_offset = stream_offset;
 573
 574         /* EM_DEBUG_FUNC_END("stream_offset [%d]", stream_offset); */
 575         return EMAIL_ERROR_NONE;
 576 }
 577
 578
 579 static int fetch_string_from_stream(char *input_stream, int *input_output_stream_offset, char **output_string)
 580 {
 581         /* EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_offset [%p] output_string[%p]", input_stream, input_output_stream_offset, output_string); */
 582         int string_length = 0;
 583         int stream_offset = 0;
 584         char *result_string = NULL;
 585
 586         if( !input_stream || !input_output_stream_offset || !output_string) {
 587                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 588                 return EMAIL_ERROR_INVALID_PARAM;
 589         }
 590
 591         stream_offset = *input_output_stream_offset;
 592         /*      EM_DEBUG_LOG("stream_offset [%d]", stream_offset);      */
 593
 594         memcpy(&string_length, input_stream + stream_offset, sizeof(int));
 595         stream_offset +=  sizeof(int);
 596
 597         /*      EM_DEBUG_LOG("string_length [%d]", string_length);      */
 598
 599         if(string_length != 0) {
 600                 result_string = (char*)em_malloc(string_length + 1);
 601                 if(result_string) {
 602                         memcpy(result_string, input_stream + stream_offset, string_length);
 603                         stream_offset += string_length;
 604                 }
 605         }
 606         /*
 607         if(result_string)
 608                 EM_DEBUG_LOG("result_string [%s]", result_string);
 609         */
 610
 611         *output_string              = result_string;
 612         *input_output_stream_offset = stream_offset;
 613
 614         /* EM_DEBUG_FUNC_END("stream_offset [%d]", stream_offset); */
 615         return EMAIL_ERROR_NONE;
 616 }
 617                                     /* divide struct at binary field (void* user_data)*/
 618 #define EMAIL_ACCOUNT_FMT   "S(" "isiii" "is" ")" "B" "S(" "issss"  "isiss" "iiiii" "isiss" "iii"\
 619                                  "$(" "iiiii" "iisii" "iisi" ")" "iiisii" ")"
 620
 621
 622 INTERNAL_FUNC char* em_convert_account_to_byte_stream(email_account_t* account, int *stream_len)
 623 {
 624         EM_DEBUG_FUNC_END();
 625         EM_IF_NULL_RETURN_VALUE(account, NULL);
 626
 627         tpl_node *tn = NULL;
 628         tpl_bin tb;
 629
 630         tn = tpl_map(EMAIL_ACCOUNT_FMT, account, &tb, &(account->user_data_length));
 631         tb.sz = account->user_data_length;
 632         tb.addr = account->user_data;
 633         tpl_pack(tn, 0);
 634
 635         /* write account to buffer */
 636         void *buf = NULL;
 637         size_t len = 0;
 638         tpl_dump(tn, TPL_MEM, &buf, &len);
 639         tpl_free(tn);
 640
 641         *stream_len = len;
 642         EM_DEBUG_FUNC_END();
 643         return (char*) buf;
 644 }
 645
 646
 647 INTERNAL_FUNC void em_convert_byte_stream_to_account(char *stream, int stream_len, email_account_t *account)
 648 {
 649         EM_DEBUG_FUNC_END();
 650         EM_NULL_CHECK_FOR_VOID(stream);
 651         EM_NULL_CHECK_FOR_VOID(account);
 652
 653         tpl_node *tn = NULL;
 654         tpl_bin tb;
 655
 656         tn = tpl_map(EMAIL_ACCOUNT_FMT, account, &tb, &(account->user_data_length));
 657         tpl_load(tn, TPL_MEM, stream, stream_len);
 658         tpl_unpack(tn, 0);
 659         tpl_free(tn);
 660
 661         /* tb will be destroyed at end of func, but tb.addr remains */
 662         account->user_data = tb.addr;
 663
 664         EM_DEBUG_FUNC_END();
 665 }
 666
 667 #define EMAIL_MAIL_DATA_FMT  "S(" "iiiis" "iisss" "issss" "sssss" "sisss"\
 668                             "icccc" "cccii" "iiiii" "iisii" "iiii)B"
 669
 670 INTERNAL_FUNC char* em_convert_mail_data_to_byte_stream(email_mail_data_t *mail_data, int *stream_len)
 671 {
 672         EM_DEBUG_FUNC_BEGIN("mail_data[%p] stream_len[%p]", mail_data, stream_len);
 673         EM_IF_NULL_RETURN_VALUE(mail_data, NULL);
 674         EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
 675
 676         tpl_node *tn = NULL;
 677         tpl_bin tb;
 678
 679         EM_DEBUG_LOG("eas_data_length[%d]", mail_data->eas_data_length); /*prevent 44369*/
 680
 681         tn      = tpl_map(EMAIL_MAIL_DATA_FMT, mail_data, &tb);
 682         tb.sz   = mail_data->eas_data_length;
 683         tb.addr = mail_data->eas_data;
 684         tpl_pack(tn, 0);
 685
 686         /* write account to buffer */
 687         void *buf = NULL;
 688         size_t len = 0;
 689         tpl_dump(tn, TPL_MEM, &buf, &len);
 690         tpl_free(tn);
 691
 692         *stream_len = len;
 693         EM_DEBUG_FUNC_END();
 694         return (char*) buf;
 695 }
 696
 697 INTERNAL_FUNC void em_convert_byte_stream_to_mail_data(char *stream, int stream_len, email_mail_data_t *mail_data)
 698 {
 699         EM_DEBUG_FUNC_BEGIN("stream[%p] stream_len[%d] mail_data[%p]", stream, stream_len, mail_data);
 700         EM_NULL_CHECK_FOR_VOID(stream);
 701         EM_NULL_CHECK_FOR_VOID(mail_data);
 702
 703         tpl_node *tn = NULL;
 704         tpl_bin tb;
 705
 706         tn = tpl_map(EMAIL_MAIL_DATA_FMT, mail_data, &tb);
 707         if(!tn) {
 708                 EM_DEBUG_EXCEPTION("tpl_map failed");
 709                 return;
 710         }
 711
 712         tpl_load(tn, TPL_MEM, stream, stream_len);
 713         tpl_unpack(tn, 0);
 714
 715         if(mail_data->eas_data_length <= 0 || tb.addr == NULL) {
 716                 EM_DEBUG_LOG("No eas data. eas_data_length[%d] addr[%p]", mail_data->eas_data_length, tb.addr);
 717         }
 718         else {
 719                 EM_DEBUG_LOG("eas_data_length[%d] addr[%p]", mail_data->eas_data_length, tb.addr);
 720                 mail_data->eas_data = tb.addr;
 721         }
 722
 723         if(tn)
 724                 tpl_free(tn);
 725
 726         EM_DEBUG_FUNC_END();
 727 }
 728
 729
 730 #define EMAIL_ATTACHMENT_DATA_FMT "A(S(" "issii" "iciii" "s" "))"
 731
 732 INTERNAL_FUNC char* em_convert_attachment_data_to_byte_stream(email_attachment_data_t *attachment, int attachment_count, int* stream_len)
 733 {
 734         EM_DEBUG_FUNC_BEGIN();
 735         EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
 736         if(!attachment) {
 737                 EM_DEBUG_LOG("no attachment to be included");
 738                 *stream_len = 0;
 739                 return NULL;
 740         }
 741
 742
 743         email_attachment_data_t cur = {0};
 744         tpl_node *tn = NULL;
 745
 746         /* tpl_map adds value at 2nd param addr to packing buffer iterately */
 747         /* 2nd param value (not addr via pointer) should be modified at each iteration */
 748         tn = tpl_map(EMAIL_ATTACHMENT_DATA_FMT, &cur);
 749         int i=0;
 750         for( ; i < attachment_count ; i++ ) {
 751                 memcpy(&cur, attachment+i, sizeof(cur)); /* copy data to cur : swallow copy */
 752                 tpl_pack(tn, 1);                        /* pack data at &cur: deep copy */
 753         }
 754
 755         /* write data to buffer */
 756         void *buf = NULL;
 757         size_t len = 0;
 758         tpl_dump(tn, TPL_MEM, &buf, &len);
 759         tpl_free(tn);
 760
 761         *stream_len = len;
 762
 763         EM_DEBUG_LOG("stream_len: %d", len);
 764
 765         EM_DEBUG_FUNC_END();
 766         return (char*) buf;
 767 }
 768
 769 INTERNAL_FUNC void em_convert_byte_stream_to_attachment_data(char *stream, int stream_len, email_attachment_data_t **attachment_data, int *attachment_count)
 770 {
 771         EM_DEBUG_FUNC_BEGIN();
 772         EM_NULL_CHECK_FOR_VOID(stream);
 773         EM_NULL_CHECK_FOR_VOID(attachment_data);
 774         EM_NULL_CHECK_FOR_VOID(attachment_count);
 775
 776
 777         email_attachment_data_t cur = {0};
 778         tpl_node *tn = NULL;
 779         tn = tpl_map(EMAIL_ATTACHMENT_DATA_FMT, &cur);
 780         tpl_load(tn, TPL_MEM, stream, stream_len);
 781
 782         /* tpl does not return the size of variable-length array, but we need variable-length array */
 783         /* so, make list and get list count in the first phase, */
 784         /* and then copy list to var array after allocating memory */
 785         GList *head = NULL;
 786         int count = 0;
 787         while( tpl_unpack(tn, 1) > 0) {
 788                 email_attachment_data_t* pdata = (email_attachment_data_t*) em_malloc(sizeof(email_attachment_data_t));
 789                 memcpy(pdata, &cur, sizeof(email_attachment_data_t)); /* copy unpacked data to list item */
 790                 head = g_list_prepend(head, pdata);                   /* add it to list */
 791                 memset(&cur, 0, sizeof(email_attachment_data_t));     /* initialize variable, used for unpacking */
 792                 count++;
 793         }
 794         tpl_free(tn);
 795
 796         /*finally we get the list count and allocate var length array */
 797         email_attachment_data_t *attached = (email_attachment_data_t*) em_malloc(sizeof(email_attachment_data_t)*count);
 798
 799         /*write glist item into variable array*/
 800         head = g_list_reverse(head);
 801         GList *p = g_list_first(head);
 802         int i=0;
 803         for( ; p ; p = g_list_next(p), i++ ) {
 804                 email_attachment_data_t* pdata = (email_attachment_data_t*) g_list_nth_data(p, 0);
 805                 memcpy( attached+i, pdata, sizeof(email_attachment_data_t));
 806                 EM_SAFE_FREE(pdata);    /*now, list item is useless */
 807         }
 808
 809         g_list_free(head);
 810
 811         *attachment_count = count;
 812         *attachment_data = attached;
 813         EM_DEBUG_FUNC_END();
 814 }
 815
 816
 817 #define EMAIL_MAILBOX_FMT  "S(" "isisi" "iiiii" "i" ")"
 818
 819 INTERNAL_FUNC char* em_convert_mailbox_to_byte_stream(email_mailbox_t *mailbox_data, int *stream_len)
 820 {
 821         EM_DEBUG_FUNC_BEGIN();
 822         EM_IF_NULL_RETURN_VALUE(mailbox_data, NULL);
 823         EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
 824
 825         tpl_node *tn = NULL;
 826
 827         tn = tpl_map(EMAIL_MAILBOX_FMT, mailbox_data);
 828         tpl_pack(tn, 0);
 829
 830         /* write account to buffer */
 831         void *buf = NULL;
 832         size_t len = 0;
 833         tpl_dump(tn, TPL_MEM, &buf, &len);
 834         tpl_free(tn);
 835
 836         *stream_len = len;
 837         EM_DEBUG_FUNC_END("serialized len: %d", len);
 838         return (char*) buf;
 839 }
 840
 841
 842 INTERNAL_FUNC void em_convert_byte_stream_to_mailbox(char *stream, int stream_len, email_mailbox_t *mailbox_data)
 843 {
 844         EM_DEBUG_FUNC_BEGIN();
 845         EM_NULL_CHECK_FOR_VOID(stream);
 846         EM_NULL_CHECK_FOR_VOID(mailbox_data);
 847
 848         tpl_node *tn = NULL;
 849
 850         tn = tpl_map(EMAIL_MAILBOX_FMT, mailbox_data);
 851         tpl_load(tn, TPL_MEM, stream, stream_len);
 852         tpl_unpack(tn, 0);
 853         tpl_free(tn);
 854
 855         EM_DEBUG_FUNC_END("deserialized len %d", stream_len);
 856 }
 857
 858 #define EMAIL_OPTION_FMT "S(" "iiiii" "iisii" "iisi" ")"
 859
 860 INTERNAL_FUNC char* em_convert_option_to_byte_stream(email_option_t* option, int* stream_len)
 861 {
 862         EM_DEBUG_FUNC_BEGIN();
 863         EM_IF_NULL_RETURN_VALUE(option, NULL);
 864         EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
 865
 866         tpl_node *tn = NULL;
 867
 868         tn = tpl_map(EMAIL_OPTION_FMT, option);
 869         tpl_pack(tn, 0);
 870
 871         /* write account to buffer */
 872         void *buf = NULL;
 873         size_t len = 0;
 874         tpl_dump(tn, TPL_MEM, &buf, &len);
 875         tpl_free(tn);
 876
 877         *stream_len = len;
 878         EM_DEBUG_FUNC_END("serialized len: %d", len);
 879         return (char*) buf;
 880 }
 881
 882 INTERNAL_FUNC void em_convert_byte_stream_to_option(char *stream, int stream_len, email_option_t *option)
 883 {
 884         EM_DEBUG_FUNC_BEGIN();
 885         EM_NULL_CHECK_FOR_VOID(stream);
 886         EM_NULL_CHECK_FOR_VOID(option);
 887
 888         tpl_node *tn = NULL;
 889
 890         tn = tpl_map(EMAIL_OPTION_FMT, option);
 891         tpl_load(tn, TPL_MEM, stream, stream_len);
 892         tpl_unpack(tn, 0);
 893         tpl_free(tn);
 894
 895         EM_DEBUG_FUNC_END("deserialized len %d", stream_len);
 896 }
 897
 898
 899 #define EMAIL_RULE_FMT "S(" "iiisi" "iii" ")"
 900
 901 INTERNAL_FUNC char* em_convert_rule_to_byte_stream(email_rule_t *rule, int *stream_len)
 902 {
 903         EM_DEBUG_FUNC_BEGIN();
 904         EM_IF_NULL_RETURN_VALUE(rule, NULL);
 905         EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
 906
 907         tpl_node *tn = NULL;
 908
 909         tn = tpl_map(EMAIL_RULE_FMT, rule);
 910         tpl_pack(tn, 0);
 911
 912         /* write account to buffer */
 913         void *buf = NULL;
 914         size_t len = 0;
 915         tpl_dump(tn, TPL_MEM, &buf, &len);
 916         tpl_free(tn);
 917
 918         *stream_len = len;
 919         EM_DEBUG_FUNC_END("serialized len: %d", len);
 920         return (char*) buf;
 921 }
 922
 923 INTERNAL_FUNC void em_convert_byte_stream_to_rule(char *stream, int stream_len, email_rule_t *rule)
 924 {
 925         EM_DEBUG_FUNC_BEGIN();
 926         EM_NULL_CHECK_FOR_VOID(stream);
 927         EM_NULL_CHECK_FOR_VOID(rule);
 928
 929         tpl_node *tn = NULL;
 930
 931         tn = tpl_map(EMAIL_RULE_FMT, rule);
 932         tpl_load(tn, TPL_MEM, stream, stream_len);
 933         tpl_unpack(tn, 0);
 934         tpl_free(tn);
 935
 936         EM_DEBUG_FUNC_END("deserialized len %d", stream_len);
 937 }
 938
 939 #define EMAIL_MEETING_REQUEST_FMT   "iiBBs" "sic#Bi" "c#Bi"
 940
 941 INTERNAL_FUNC char* em_convert_meeting_req_to_byte_stream(email_meeting_request_t *meeting_req, int *stream_len)
 942 {
 943
 944         EM_DEBUG_FUNC_END();
 945         EM_IF_NULL_RETURN_VALUE(meeting_req, NULL);
 946
 947         tpl_node *tn = NULL;
 948         tpl_bin tb[4];
 949
 950         tn = tpl_map(EMAIL_MEETING_REQUEST_FMT,
 951                                                 &meeting_req->mail_id,
 952                                                 &meeting_req->meeting_response,
 953                                                 &tb[0],
 954                                                 &tb[1],
 955                                                 &meeting_req->location,
 956                                                 &meeting_req->global_object_id,
 957                                                 &meeting_req->time_zone.offset_from_GMT,
 958                                                 meeting_req->time_zone.standard_name, 32,
 959                                                 &tb[2],
 960                                                 &meeting_req->time_zone.standard_bias,
 961                                                 meeting_req->time_zone.daylight_name, 32,
 962                                                 &tb[3],
 963                                                 &meeting_req->time_zone.daylight_bias
 964                                 );
 965         tb[0].sz = tb[1].sz = tb[2].sz = tb[3].sz = sizeof(struct tm);
 966         tb[0].addr = &meeting_req->start_time;
 967         tb[1].addr = &meeting_req->end_time;
 968         tb[2].addr = &meeting_req->time_zone.standard_time_start_date;
 969         tb[3].addr = &meeting_req->time_zone.daylight_time_start_date;
 970
 971
 972         tpl_pack(tn, 0);
 973
 974         /* write account to buffer */
 975         void *buf = NULL;
 976         size_t len = 0;
 977         tpl_dump(tn, TPL_MEM, &buf, &len);
 978         tpl_free(tn);
 979
 980         *stream_len = len;
 981         EM_DEBUG_FUNC_END();
 982         return (char*) buf;
 983 }
 984
 985
 986 INTERNAL_FUNC void em_convert_byte_stream_to_meeting_req(char *stream, int stream_len, email_meeting_request_t *meeting_req)
 987 {
 988         EM_DEBUG_FUNC_END();
 989         EM_NULL_CHECK_FOR_VOID(stream);
 990         EM_NULL_CHECK_FOR_VOID(meeting_req);
 991
 992         tpl_node *tn = NULL;
 993         tpl_bin tb[4];
 994
 995         tn = tpl_map(EMAIL_MEETING_REQUEST_FMT,
 996                                                 &meeting_req->mail_id,
 997                                                 &meeting_req->meeting_response,
 998                                                 &tb[0],
 999                                                 &tb[1],
1000                                                 &meeting_req->location,
1001                                                 &meeting_req->global_object_id,
1002                                                 &meeting_req->time_zone.offset_from_GMT,
1003                                                 meeting_req->time_zone.standard_name, 32,
1004                                                 &tb[2],
1005                                                 &meeting_req->time_zone.standard_bias,
1006                                                 meeting_req->time_zone.daylight_name, 32,
1007                                                 &tb[3],
1008                                                 &meeting_req->time_zone.daylight_bias
1009                                 );
1010         tpl_load(tn, TPL_MEM, stream, stream_len);
1011         tpl_unpack(tn, 0);
1012         tpl_free(tn);
1013
1014         /* tb will be destroyed at end of func, but tb.addr remains */
1015         memcpy(&meeting_req->start_time, tb[0].addr, sizeof(struct tm));
1016         memcpy(&meeting_req->end_time, tb[1].addr, sizeof(struct tm));
1017         memcpy(&meeting_req->time_zone.standard_time_start_date, tb[2].addr, sizeof(struct tm));
1018         memcpy(&meeting_req->time_zone.daylight_time_start_date, tb[3].addr, sizeof(struct tm));
1019
1020         int i=0;
1021         for(i=0; i< 4 ; i++)
1022                 EM_SAFE_FREE(tb[i].addr);
1023
1024         EM_DEBUG_FUNC_END();
1025 }
1026
1027 INTERNAL_FUNC char* em_convert_search_filter_to_byte_stream(email_search_filter_t *input_search_filter_list,
1028                                                                         int input_search_filter_count, int *output_stream_size)
1029 {
1030         EM_DEBUG_FUNC_BEGIN("input_search_filter_list [%p] input_search_filter_count [%d]", input_search_filter_list, input_search_filter_count);
1031
1032         char *result_stream = NULL;
1033         int   stream_size   = 0;
1034         int   i = 0;
1035
1036         EM_IF_NULL_RETURN_VALUE(input_search_filter_list, NULL);
1037
1038         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_count), sizeof(int));
1039
1040         for( i = 0; i < input_search_filter_count; i++) {
1041                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_type), sizeof(int));
1042                 switch(input_search_filter_list->search_filter_type) {
1043                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO       :
1044                         case EMAIL_SEARCH_FILTER_TYPE_UID              :
1045                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER      :
1046                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER     :
1047                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED   :
1048                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED    :
1049                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT      :
1050                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED     :
1051                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT     :
1052                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN       :
1053                                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_key_value.integer_type_key_value), sizeof(int));
1054                                 break;
1055
1056                         case EMAIL_SEARCH_FILTER_TYPE_BCC              :
1057                         case EMAIL_SEARCH_FILTER_TYPE_CC               :
1058                         case EMAIL_SEARCH_FILTER_TYPE_FROM             :
1059                         case EMAIL_SEARCH_FILTER_TYPE_KEYWORD          :
1060                         case EMAIL_SEARCH_FILTER_TYPE_SUBJECT          :
1061                         case EMAIL_SEARCH_FILTER_TYPE_TO               :
1062                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID       :
1063                                 result_stream = append_string_to_stream(result_stream, &stream_size, input_search_filter_list->search_filter_key_value.string_type_key_value);
1064                                 break;
1065
1066                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE :
1067                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON     :
1068                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE  :
1069                                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_key_value.time_type_key_value), sizeof(struct tm));
1070                                 break;
1071                         default :
1072                                 EM_DEBUG_EXCEPTION("Invalid filter type [%d]", input_search_filter_list->search_filter_type);
1073                                 break;
1074                 }
1075         }
1076
1077         *output_stream_size = stream_size;
1078
1079         EM_DEBUG_FUNC_END();
1080         return result_stream;
1081 }
1082
1083 INTERNAL_FUNC void em_convert_byte_stream_to_search_filter(char *input_stream,
1084                                 email_search_filter_t **output_search_filter_list, int *output_search_filter_count)
1085 {
1086         EM_DEBUG_FUNC_BEGIN("input_stream [%p] output_search_filter_list [%p] output_search_filter_count [%p]", input_stream, output_search_filter_list, output_search_filter_count);
1087
1088         int stream_offset = 0;
1089         int i = 0;
1090         int local_search_filter_count = 0;
1091         email_search_filter_t *local_search_filter = NULL;
1092
1093         EM_NULL_CHECK_FOR_VOID(input_stream);
1094         EM_NULL_CHECK_FOR_VOID(output_search_filter_list);
1095         EM_NULL_CHECK_FOR_VOID(output_search_filter_count);
1096
1097         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter_count));
1098
1099         if(local_search_filter_count == 0) {
1100                 EM_DEBUG_EXCEPTION("local_search_filter_count is 0.");
1101                 goto FINISH_OFF;
1102         }
1103
1104         local_search_filter = em_malloc(sizeof(email_search_filter_t) * local_search_filter_count);
1105
1106         if(local_search_filter == NULL) {
1107                 EM_DEBUG_EXCEPTION("em_malloc for local_search_filter failed");
1108                 goto FINISH_OFF;
1109         }
1110
1111         *output_search_filter_count = local_search_filter_count;
1112
1113         for( i = 0; i < local_search_filter_count; i++) {
1114                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter[i].search_filter_type));
1115                 switch(local_search_filter[i].search_filter_type) {
1116                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO       :
1117                         case EMAIL_SEARCH_FILTER_TYPE_UID              :
1118                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER      :
1119                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER     :
1120                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED   :
1121                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED    :
1122                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT      :
1123                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED     :
1124                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT     :
1125                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN       :
1126                                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter[i].search_filter_key_value.integer_type_key_value));
1127                                 break;
1128
1129                         case EMAIL_SEARCH_FILTER_TYPE_BCC              :
1130                         case EMAIL_SEARCH_FILTER_TYPE_CC               :
1131                         case EMAIL_SEARCH_FILTER_TYPE_FROM             :
1132                         case EMAIL_SEARCH_FILTER_TYPE_KEYWORD          :
1133                         case EMAIL_SEARCH_FILTER_TYPE_SUBJECT          :
1134                         case EMAIL_SEARCH_FILTER_TYPE_TO               :
1135                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID       :
1136                                 fetch_string_from_stream(input_stream, &stream_offset, &(local_search_filter[i].search_filter_key_value.string_type_key_value));
1137                                 break;
1138
1139                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE :
1140                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON     :
1141                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE  :
1142                                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(time_t), (char*)&(local_search_filter[i].search_filter_key_value.time_type_key_value));
1143                                 break;
1144                         default :
1145                                 EM_DEBUG_EXCEPTION("Invalid filter type [%d]", local_search_filter[i].search_filter_type);
1146                                 break;
1147                 }
1148         }
1149
1150         *output_search_filter_list = local_search_filter;
1151
1152 FINISH_OFF:
1153
1154         EM_DEBUG_FUNC_END();
1155 }
1156
1157 INTERNAL_FUNC int em_convert_certificate_tbl_to_certificate(emstorage_certificate_tbl_t *certificate_tbl, email_certificate_t **certificate, int *error)
1158 {
1159         EM_DEBUG_FUNC_BEGIN("certficate_tbl[%p], certificate[%p]", certificate_tbl, certificate);
1160
1161         int err_code = EMAIL_ERROR_NONE;
1162         int ret = false;
1163         email_certificate_t *temp_certificate = NULL;
1164
1165         if (!certificate_tbl || !certificate)  {
1166                 EM_DEBUG_EXCEPTION("Invalid parameter");
1167                 err_code = EMAIL_ERROR_INVALID_PARAM;
1168                 goto FINISH_OFF;
1169         }
1170
1171         temp_certificate = em_malloc(sizeof(email_certificate_t)) ;
1172         if (!temp_certificate) {
1173                 EM_DEBUG_EXCEPTION("em_malloc failed");
1174                 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
1175                 goto FINISH_OFF;
1176         }
1177
1178         temp_certificate->certificate_id = certificate_tbl->certificate_id;
1179         temp_certificate->issue_year = certificate_tbl->issue_year;
1180         temp_certificate->issue_month = certificate_tbl->issue_month;
1181         temp_certificate->issue_day = certificate_tbl->issue_day;
1182         temp_certificate->expiration_year = certificate_tbl->expiration_year;
1183         temp_certificate->expiration_month = certificate_tbl->expiration_month;
1184         temp_certificate->expiration_day = certificate_tbl->expiration_day;
1185         temp_certificate->issue_organization_name = EM_SAFE_STRDUP(certificate_tbl->issue_organization_name);
1186         temp_certificate->email_address = EM_SAFE_STRDUP(certificate_tbl->email_address);
1187         temp_certificate->subject_str = EM_SAFE_STRDUP(certificate_tbl->subject_str);
1188         temp_certificate->filepath = EM_SAFE_STRDUP(certificate_tbl->filepath);
1189
1190         *certificate = temp_certificate;
1191
1192         ret = true;
1193 FINISH_OFF:
1194         if (error)
1195                 *error = err_code;
1196
1197         EM_DEBUG_FUNC_END();
1198         return true;
1199 }
1200
1201 INTERNAL_FUNC int em_convert_certificate_to_certificate_tbl(email_certificate_t *certificate, emstorage_certificate_tbl_t *certificate_tbl)
1202 {
1203         EM_DEBUG_FUNC_BEGIN("certficate[%p], certificate_tbl[%p]", certificate, certificate_tbl);
1204
1205         certificate_tbl->certificate_id = certificate->certificate_id;
1206         certificate_tbl->issue_year = certificate->issue_year;
1207         certificate_tbl->issue_month = certificate->issue_month;
1208         certificate_tbl->issue_day = certificate->issue_day;
1209         certificate_tbl->expiration_year = certificate->expiration_year;
1210         certificate_tbl->expiration_month = certificate->expiration_month;
1211         certificate_tbl->expiration_day = certificate->expiration_day;
1212         certificate_tbl->issue_organization_name = EM_SAFE_STRDUP(certificate->issue_organization_name);
1213         certificate_tbl->email_address = EM_SAFE_STRDUP(certificate->email_address);
1214         certificate_tbl->subject_str = EM_SAFE_STRDUP(certificate->subject_str);
1215         certificate_tbl->filepath = EM_SAFE_STRDUP(certificate->filepath);
1216
1217         EM_DEBUG_FUNC_END();
1218         return true;
1219 }
1220