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