email-common-use/email-convert.c

   1 /*
   2 *  email-service
   3 *
   4 * Copyright (c) 2000 - 2011 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
  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_flag_to_int(emf_mail_flag_t flag, int *i_flag, int *err_code)
  43 {
  44         EM_DEBUG_FUNC_BEGIN("i_flag[%p], err_code[%p]", i_flag, err_code);
  45
  46         if (!i_flag)  {
  47                 if (err_code != NULL)
  48                         *err_code = EMF_ERROR_INVALID_PARAM;
  49                 return false;
  50
  51         }
  52
  53         *i_flag =
  54                         (flag.seen           ? fSEEN       : 0) |
  55                         (flag.deleted        ? fDELETED    : 0) |
  56                         (flag.flagged        ? fFLAGGED    : 0) |
  57                         (flag.answered       ? fANSWERED   : 0) |
  58                         (flag.recent         ? fOLD        : 0) |
  59                         (flag.draft          ? fDRAFT      : 0) |
  60                         (flag.has_attachment ? fATTACHMENT : 0) |
  61                         (flag.forwarded      ? fFORWARD    : 0) ;
  62
  63         EM_DEBUG_FUNC_END();
  64         return true;
  65 }
  66
  67 INTERNAL_FUNC int em_convert_mail_int_to_flag(int i_flag, emf_mail_flag_t* flag, int* err_code)
  68 {
  69         EM_DEBUG_FUNC_BEGIN("i_flag[0x%02x], flag[%p], err_code[%p]", i_flag, flag, err_code);
  70
  71         if (!flag) {
  72                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
  73                 if (err_code != NULL)
  74                         *err_code = EMF_ERROR_INVALID_PARAM;
  75                 return false;
  76         }
  77
  78         flag->seen           = (i_flag & fSEEN ? 1 : 0);
  79         flag->deleted        = (i_flag & fDELETED ? 1 : 0);
  80         flag->flagged        = (i_flag & fFLAGGED ? 1 : 0);
  81         flag->answered       = (i_flag & fANSWERED ? 1 : 0);
  82         flag->recent         = (i_flag & fOLD ? 1 : 0);
  83         flag->draft          = (i_flag & fDRAFT ? 1 : 0);
  84         flag->has_attachment = (i_flag & fATTACHMENT ? 1 : 0);
  85         flag->forwarded      = (i_flag & fFORWARD    ? 1 : 0);
  86
  87         EM_DEBUG_FUNC_END("FLAGS : seen[%d], deleted[%d], flagged[%d], answered[%d], recent[%d], draft[%d], has_attachment[%d], forwarded[%d]",
  88                 flag->seen, flag->deleted, flag->flagged, flag->answered, flag->recent, flag->draft, flag->has_attachment, flag->forwarded);
  89
  90     return true;
  91 }
  92
  93 INTERNAL_FUNC int em_convert_mail_tbl_to_mail_status(emstorage_mail_tbl_t *mail_tbl_data, int *result_mail_status, int* err_code)
  94 {
  95         EM_DEBUG_FUNC_BEGIN("mail_tbl_data[%p], result_mail_status [%p], err_code[%p]", mail_tbl_data, result_mail_status, err_code);
  96         int ret = false, error_code = EMF_ERROR_NONE;
  97         int has_attachment = 0;
  98
  99         if(!mail_tbl_data || !result_mail_status) {
 100                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 101                 error_code = EMF_ERROR_INVALID_PARAM;
 102                 goto FINISH_OFF;
 103         }
 104
 105         has_attachment = (mail_tbl_data->attachment_count > mail_tbl_data->inline_content_count) ? 1 : 0;
 106
 107         *result_mail_status = (mail_tbl_data->flags_seen_field      ? fSEEN       : 0) |
 108                               (mail_tbl_data->flags_deleted_field   ? fDELETED    : 0) |
 109                               (mail_tbl_data->flags_flagged_field   ? fFLAGGED    : 0) |
 110                               (mail_tbl_data->flags_answered_field  ? fANSWERED   : 0) |
 111                               (mail_tbl_data->flags_recent_field    ? fOLD        : 0) |
 112                               (mail_tbl_data->flags_draft_field     ? fDRAFT      : 0) |
 113                               (has_attachment                       ? fATTACHMENT : 0) |
 114                               (mail_tbl_data->flags_forwarded_field ? fFORWARD    : 0);
 115
 116         ret = true;
 117 FINISH_OFF:
 118                 if (err_code != NULL)
 119                 *err_code = error_code;
 120
 121         EM_DEBUG_FUNC_END("ret [%d]", ret);
 122         return ret;
 123         }
 124
 125 INTERNAL_FUNC int em_convert_mail_status_to_mail_tbl(int mail_status, emstorage_mail_tbl_t *result_mail_tbl_data, int* err_code)
 126 {
 127         EM_DEBUG_FUNC_BEGIN("mail_status[%d], result_mail_tbl_data [%p], err_code[%p]", mail_status, result_mail_tbl_data, err_code);
 128         int ret = false, error_code = EMF_ERROR_NONE;
 129
 130         if(!result_mail_tbl_data) {
 131                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 132                 error_code = EMF_ERROR_INVALID_PARAM;
 133                 goto FINISH_OFF;
 134         }
 135
 136         result_mail_tbl_data->flags_seen_field           = (mail_status & fSEEN       ? 1 : 0);
 137         result_mail_tbl_data->flags_deleted_field        = (mail_status & fDELETED    ? 1 : 0);
 138         result_mail_tbl_data->flags_flagged_field        = (mail_status & fFLAGGED    ? 1 : 0);
 139         result_mail_tbl_data->flags_answered_field       = (mail_status & fANSWERED   ? 1 : 0);
 140         result_mail_tbl_data->flags_recent_field         = (mail_status & fOLD        ? 1 : 0);
 141         result_mail_tbl_data->flags_draft_field          = (mail_status & fDRAFT      ? 1 : 0);
 142         result_mail_tbl_data->flags_forwarded_field      = (mail_status & fFORWARD    ? 1 : 0);
 143
 144         ret = true;
 145 FINISH_OFF:
 146         if (err_code != NULL)
 147                 *err_code = error_code;
 148
 149         EM_DEBUG_FUNC_END("ret [%d]", ret);
 150         return ret;
 151 }
 152
 153 INTERNAL_FUNC int em_convert_mail_tbl_to_mail_flag(emstorage_mail_tbl_t *mail_tbl_data, emf_mail_flag_t *result_flag, int* err_code)
 154 {
 155         EM_DEBUG_FUNC_BEGIN("mail_tbl_data[%p], result_flag [%p], err_code[%p]", mail_tbl_data, result_flag, err_code);
 156         int ret = false, error_code = EMF_ERROR_NONE;
 157
 158         if(!mail_tbl_data || !result_flag) {
 159                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 160                 error_code = EMF_ERROR_INVALID_PARAM;
 161                 goto FINISH_OFF;
 162         }
 163
 164         result_flag->seen           = mail_tbl_data->flags_seen_field;
 165         result_flag->deleted        = mail_tbl_data->flags_deleted_field;
 166         result_flag->flagged        = mail_tbl_data->flags_flagged_field;
 167         result_flag->answered       = mail_tbl_data->flags_answered_field;
 168         result_flag->recent         = mail_tbl_data->flags_recent_field;
 169         result_flag->draft          = mail_tbl_data->flags_draft_field;
 170         result_flag->has_attachment = (mail_tbl_data->attachment_count > mail_tbl_data->inline_content_count) ? 1 : 0;
 171         result_flag->forwarded      = mail_tbl_data->flags_forwarded_field;
 172
 173         ret = true;
 174 FINISH_OFF:
 175         if (err_code != NULL)
 176                 *err_code = error_code;
 177
 178         EM_DEBUG_FUNC_END("ret [%d]", ret);
 179         return ret;
 180 }
 181
 182 INTERNAL_FUNC int em_convert_mail_flag_to_mail_tbl(emf_mail_flag_t *flag, emstorage_mail_tbl_t *result_mail_tbl_data,  int* err_code)
 183 {
 184         EM_DEBUG_FUNC_BEGIN("flag[%p], result_mail_tbl_data [%p], err_code[%p]", flag, result_mail_tbl_data, err_code);
 185         int ret = false, error_code = EMF_ERROR_NONE;
 186
 187         if(!flag || !result_mail_tbl_data) {
 188                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 189                 error_code = EMF_ERROR_INVALID_PARAM;
 190                 goto FINISH_OFF;
 191         }
 192
 193         result_mail_tbl_data->flags_seen_field           = flag->seen;
 194         result_mail_tbl_data->flags_deleted_field        = flag->deleted;
 195         result_mail_tbl_data->flags_flagged_field        = flag->flagged;
 196         result_mail_tbl_data->flags_answered_field       = flag->answered;
 197         result_mail_tbl_data->flags_recent_field         = flag->recent;
 198         result_mail_tbl_data->flags_draft_field          = flag->draft;
 199         result_mail_tbl_data->flags_forwarded_field      = flag->forwarded;
 200
 201         ret = true;
 202 FINISH_OFF:
 203         if (err_code != NULL)
 204                 *err_code = error_code;
 205
 206         EM_DEBUG_FUNC_END("ret [%d]", ret);
 207         return ret;
 208 }
 209
 210
 211 INTERNAL_FUNC int em_convert_account_to_account_tbl(emf_account_t *account, emstorage_account_tbl_t *account_tbl)
 212 {
 213         EM_DEBUG_FUNC_BEGIN("account[%p], account_tbl[%p]", account, account_tbl);
 214         int ret = 1;
 215
 216         account_tbl->account_bind_type = account->account_bind_type;
 217         account_tbl->account_name = EM_SAFE_STRDUP(account->account_name);
 218         account_tbl->receiving_server_type = account->receiving_server_type;
 219         account_tbl->receiving_server_addr = EM_SAFE_STRDUP(account->receiving_server_addr);
 220         account_tbl->email_addr = EM_SAFE_STRDUP(account->email_addr);
 221         account_tbl->user_name = EM_SAFE_STRDUP(account->user_name);
 222         account_tbl->password = EM_SAFE_STRDUP(account->password);
 223         account_tbl->retrieval_mode = account->retrieval_mode;
 224         account_tbl->port_num = account->port_num;
 225         account_tbl->use_security = account->use_security;
 226         account_tbl->sending_server_type = account->sending_server_type;
 227         account_tbl->sending_server_addr = EM_SAFE_STRDUP(account->sending_server_addr);
 228         account_tbl->sending_port_num = account->sending_port_num;
 229         account_tbl->sending_auth = account->sending_auth;
 230         account_tbl->sending_security = account->sending_security;
 231         account_tbl->sending_user = EM_SAFE_STRDUP(account->sending_user);
 232         account_tbl->sending_password = EM_SAFE_STRDUP(account->sending_password);
 233         account_tbl->display_name = EM_SAFE_STRDUP(account->display_name);
 234         account_tbl->reply_to_addr = EM_SAFE_STRDUP(account->reply_to_addr);
 235         account_tbl->return_addr = EM_SAFE_STRDUP(account->return_addr);
 236         account_tbl->account_id = account->account_id;
 237         account_tbl->keep_on_server = account->keep_on_server;
 238         account_tbl->flag1 = account->flag1;
 239         account_tbl->flag2 = account->flag2;
 240         account_tbl->pop_before_smtp = account->pop_before_smtp;
 241         account_tbl->apop =  account->apop;
 242         account_tbl->logo_icon_path = EM_SAFE_STRDUP(account->logo_icon_path);
 243         account_tbl->preset_account = account->preset_account;
 244         account_tbl->options.priority = account->options.priority;
 245         account_tbl->options.keep_local_copy = account->options.keep_local_copy;
 246         account_tbl->options.req_delivery_receipt = account->options.req_delivery_receipt;
 247         account_tbl->options.req_read_receipt = account->options.req_read_receipt;
 248         account_tbl->options.download_limit = account->options.download_limit;
 249         account_tbl->options.block_address = account->options.block_address;
 250         account_tbl->options.block_subject = account->options.block_subject;
 251         account_tbl->options.display_name_from = EM_SAFE_STRDUP(account->options.display_name_from);
 252         account_tbl->options.reply_with_body = account->options.reply_with_body;
 253         account_tbl->options.forward_with_files = account->options.forward_with_files;
 254         account_tbl->options.add_myname_card = account->options.add_myname_card;
 255         account_tbl->options.add_signature = account->options.add_signature;
 256         account_tbl->options.signature = EM_SAFE_STRDUP(account->options.signature);
 257         account_tbl->options.add_my_address_to_bcc = account->options.add_my_address_to_bcc;
 258         account_tbl->target_storage = account->target_storage;
 259         account_tbl->check_interval = account->check_interval;
 260         account_tbl->my_account_id = account->my_account_id;
 261         account_tbl->index_color = account->index_color;
 262
 263         EM_DEBUG_FUNC_END();
 264         return ret;
 265 }
 266
 267 INTERNAL_FUNC int em_convert_account_tbl_to_account(emstorage_account_tbl_t *account_tbl, emf_account_t *account)
 268 {
 269         EM_DEBUG_FUNC_BEGIN("account_tbl[%p], account[%p]", account_tbl, account);
 270         int ret = 1;
 271
 272         account->account_bind_type             = account_tbl->account_bind_type;
 273         account->account_name                  = EM_SAFE_STRDUP(account_tbl->account_name);
 274         account->receiving_server_type         = account_tbl->receiving_server_type;
 275         account->receiving_server_addr         = EM_SAFE_STRDUP(account_tbl->receiving_server_addr);
 276         account->email_addr                    = EM_SAFE_STRDUP(account_tbl->email_addr);
 277         account->user_name                     = EM_SAFE_STRDUP(account_tbl->user_name);
 278         account->password                      = EM_SAFE_STRDUP(account_tbl->password);
 279         account->retrieval_mode                = account_tbl->retrieval_mode;
 280         account->port_num                      = account_tbl->port_num;
 281         account->use_security                  = account_tbl->use_security;
 282         account->sending_server_type           = account_tbl->sending_server_type;
 283         account->sending_server_addr           = EM_SAFE_STRDUP(account_tbl->sending_server_addr);
 284         account->sending_port_num              = account_tbl->sending_port_num;
 285         account->sending_auth                  = account_tbl->sending_auth;
 286         account->sending_security              = account_tbl->sending_security;
 287         account->sending_user                  = EM_SAFE_STRDUP(account_tbl->sending_user);
 288         account->sending_password              = EM_SAFE_STRDUP(account_tbl->sending_password);
 289         account->display_name                  = EM_SAFE_STRDUP(account_tbl->display_name);
 290         account->reply_to_addr                 = EM_SAFE_STRDUP(account_tbl->reply_to_addr);
 291         account->return_addr                   = EM_SAFE_STRDUP(account_tbl->return_addr);
 292         account->account_id                    = account_tbl->account_id;
 293         account->keep_on_server                = account_tbl->keep_on_server;
 294         account->flag1                         = account_tbl->flag1;
 295         account->flag2                         = account_tbl->flag2;
 296         account->pop_before_smtp               = account_tbl->pop_before_smtp;
 297         account->apop                          = account_tbl->apop;
 298         account->logo_icon_path                = EM_SAFE_STRDUP(account_tbl->logo_icon_path);
 299         account->preset_account                = account_tbl->preset_account;
 300         account->options.priority              = account_tbl->options.priority;
 301         account->options.keep_local_copy       = account_tbl->options.keep_local_copy;
 302         account->options.req_delivery_receipt  = account_tbl->options.req_delivery_receipt;
 303         account->options.req_read_receipt      = account_tbl->options.req_read_receipt;
 304         account->options.download_limit        = account_tbl->options.download_limit;
 305         account->options.block_address         = account_tbl->options.block_address;
 306         account->options.block_subject         = account_tbl->options.block_subject;
 307         account->options.display_name_from     = EM_SAFE_STRDUP(account_tbl->options.display_name_from);
 308         account->options.reply_with_body       = account_tbl->options.reply_with_body;
 309         account->options.forward_with_files    = account_tbl->options.forward_with_files;
 310         account->options.add_myname_card       = account_tbl->options.add_myname_card;
 311         account->options.add_signature         = account_tbl->options.add_signature;
 312         account->options.signature             = EM_SAFE_STRDUP(account_tbl->options.signature);
 313         account->options.add_my_address_to_bcc = account_tbl->options.add_my_address_to_bcc;
 314         account->target_storage                = account_tbl->target_storage;
 315         account->check_interval                = account_tbl->check_interval;
 316         account->my_account_id                 = account_tbl->my_account_id;
 317         account->index_color                   = account_tbl->index_color;
 318
 319         EM_DEBUG_FUNC_END();
 320         return ret;
 321 }
 322
 323 INTERNAL_FUNC int em_convert_mail_tbl_to_mail_data(emstorage_mail_tbl_t *mail_table_data, int item_count, emf_mail_data_t **mail_data, int *error)
 324 {
 325         EM_DEBUG_FUNC_BEGIN("mail_table_data[%p], item_count [%d], mail_data[%p]", mail_table_data, item_count, mail_data);
 326         int i, ret = false, err_code = EMF_ERROR_NONE;
 327         emf_mail_data_t *temp_mail_data = NULL;
 328
 329         if (!mail_table_data || !mail_data || !item_count) {
 330                 EM_DEBUG_EXCEPTION("Invalid parameter");
 331                 err_code = EMF_ERROR_INVALID_PARAM;
 332                 goto FINISH_OFF;
 333         }
 334
 335         temp_mail_data = em_malloc(sizeof(emf_mail_data_t) * item_count);
 336
 337         if(!temp_mail_data) {
 338                 EM_DEBUG_EXCEPTION("em_malloc failed");
 339                 err_code = EMF_ERROR_OUT_OF_MEMORY;
 340                 goto FINISH_OFF;
 341         }
 342
 343         for(i = 0; i < item_count; i++) {
 344                 temp_mail_data[i].mail_id                 = mail_table_data[i].mail_id;
 345                 temp_mail_data[i].account_id              = mail_table_data[i].account_id;
 346                 temp_mail_data[i].mailbox_name            = EM_SAFE_STRDUP(mail_table_data[i].mailbox_name);
 347                 temp_mail_data[i].mailbox_type            = mail_table_data[i].mailbox_type;
 348                 temp_mail_data[i].subject                 = EM_SAFE_STRDUP(mail_table_data[i].subject);
 349                 temp_mail_data[i].date_time               = mail_table_data[i].date_time;
 350                 temp_mail_data[i].server_mail_status      = mail_table_data[i].server_mail_status;
 351                 temp_mail_data[i].server_mailbox_name     = EM_SAFE_STRDUP(mail_table_data[i].server_mailbox_name);
 352                 temp_mail_data[i].server_mail_id          = EM_SAFE_STRDUP(mail_table_data[i].server_mail_id);
 353                 temp_mail_data[i].message_id              = EM_SAFE_STRDUP(mail_table_data[i].message_id);
 354                 temp_mail_data[i].full_address_from       = EM_SAFE_STRDUP(mail_table_data[i].full_address_from);
 355                 temp_mail_data[i].full_address_reply      = EM_SAFE_STRDUP(mail_table_data[i].full_address_reply);
 356                 temp_mail_data[i].full_address_to         = EM_SAFE_STRDUP(mail_table_data[i].full_address_to);
 357                 temp_mail_data[i].full_address_cc         = EM_SAFE_STRDUP(mail_table_data[i].full_address_cc);
 358                 temp_mail_data[i].full_address_bcc        = EM_SAFE_STRDUP(mail_table_data[i].full_address_bcc);
 359                 temp_mail_data[i].full_address_return     = EM_SAFE_STRDUP(mail_table_data[i].full_address_return);
 360                 temp_mail_data[i].email_address_sender    = EM_SAFE_STRDUP(mail_table_data[i].email_address_sender);
 361                 temp_mail_data[i].email_address_recipient = EM_SAFE_STRDUP(mail_table_data[i].email_address_recipient);
 362                 temp_mail_data[i].alias_sender            = EM_SAFE_STRDUP(mail_table_data[i].alias_sender);
 363                 temp_mail_data[i].alias_recipient         = EM_SAFE_STRDUP(mail_table_data[i].alias_recipient);
 364                 temp_mail_data[i].body_download_status    = mail_table_data[i].body_download_status;
 365                 temp_mail_data[i].file_path_plain         = EM_SAFE_STRDUP(mail_table_data[i].file_path_plain);
 366                 temp_mail_data[i].file_path_html          = EM_SAFE_STRDUP(mail_table_data[i].file_path_html);
 367                 temp_mail_data[i].mail_size               = mail_table_data[i].mail_size;
 368                 temp_mail_data[i].flags_seen_field        = mail_table_data[i].flags_seen_field;
 369                 temp_mail_data[i].flags_deleted_field     = mail_table_data[i].flags_deleted_field;
 370                 temp_mail_data[i].flags_flagged_field     = mail_table_data[i].flags_flagged_field;
 371                 temp_mail_data[i].flags_answered_field    = mail_table_data[i].flags_answered_field;
 372                 temp_mail_data[i].flags_recent_field      = mail_table_data[i].flags_recent_field;
 373                 temp_mail_data[i].flags_draft_field       = mail_table_data[i].flags_draft_field;
 374                 temp_mail_data[i].flags_forwarded_field   = mail_table_data[i].flags_forwarded_field;
 375                 temp_mail_data[i].DRM_status              = mail_table_data[i].DRM_status;
 376                 temp_mail_data[i].priority                = mail_table_data[i].priority;
 377                 temp_mail_data[i].save_status             = mail_table_data[i].save_status;
 378                 temp_mail_data[i].lock_status             = mail_table_data[i].lock_status;
 379                 temp_mail_data[i].report_status           = mail_table_data[i].report_status;
 380                 temp_mail_data[i].attachment_count        = mail_table_data[i].attachment_count;
 381                 temp_mail_data[i].inline_content_count    = mail_table_data[i].inline_content_count;
 382                 temp_mail_data[i].thread_id               = mail_table_data[i].thread_id;
 383                 temp_mail_data[i].thread_item_count       = mail_table_data[i].thread_item_count;
 384                 temp_mail_data[i].preview_text            = EM_SAFE_STRDUP(mail_table_data[i].preview_text);
 385                 temp_mail_data[i].meeting_request_status  = mail_table_data[i].meeting_request_status;
 386         }
 387
 388         *mail_data = temp_mail_data;
 389
 390         ret = true;
 391 FINISH_OFF:
 392
 393         if(error)
 394                         *error = err_code;
 395
 396         EM_DEBUG_FUNC_END();
 397         return ret;
 398 }
 399
 400 INTERNAL_FUNC int   em_convert_mail_data_to_mail_tbl(emf_mail_data_t *mail_data, int item_count, emstorage_mail_tbl_t **mail_table_data, int *error)
 401 {
 402         EM_DEBUG_FUNC_BEGIN("mail_data[%p], item_count [%d], mail_table_data[%p]", mail_data, item_count, mail_table_data);
 403         int i, ret = false, err_code = EMF_ERROR_NONE;
 404         emstorage_mail_tbl_t *temp_mail_tbl = NULL;
 405
 406         if (!mail_data || !mail_table_data || !item_count) {
 407                 EM_DEBUG_EXCEPTION("Invalid parameter");
 408                 err_code = EMF_ERROR_INVALID_PARAM;
 409                 goto FINISH_OFF;
 410         }
 411
 412         temp_mail_tbl = em_malloc(sizeof(emstorage_mail_tbl_t) * item_count);
 413
 414         if(!temp_mail_tbl) {
 415                 EM_DEBUG_EXCEPTION("em_malloc failed");
 416                 err_code = EMF_ERROR_OUT_OF_MEMORY;
 417                 goto FINISH_OFF;
 418         }
 419
 420         for(i = 0; i < item_count; i++) {
 421                 temp_mail_tbl[i].mail_id                 = mail_data[i].mail_id;
 422                 temp_mail_tbl[i].account_id              = mail_data[i].account_id;
 423                 temp_mail_tbl[i].mailbox_name            = EM_SAFE_STRDUP(mail_data[i].mailbox_name);
 424                 temp_mail_tbl[i].mailbox_type            = mail_data[i].mailbox_type;
 425                 temp_mail_tbl[i].date_time               = mail_data[i].date_time;
 426                 temp_mail_tbl[i].subject                 = EM_SAFE_STRDUP(mail_data[i].subject);
 427                 temp_mail_tbl[i].server_mail_status      = mail_data[i].server_mail_status;
 428                 temp_mail_tbl[i].server_mailbox_name     = EM_SAFE_STRDUP(mail_data[i].server_mailbox_name);
 429                 temp_mail_tbl[i].server_mail_id          = EM_SAFE_STRDUP(mail_data[i].server_mail_id);
 430                 temp_mail_tbl[i].message_id              = EM_SAFE_STRDUP(mail_data[i].message_id);
 431                 temp_mail_tbl[i].full_address_from       = EM_SAFE_STRDUP(mail_data[i].full_address_from);
 432                 temp_mail_tbl[i].full_address_reply      = EM_SAFE_STRDUP(mail_data[i].full_address_reply);
 433                 temp_mail_tbl[i].full_address_to         = EM_SAFE_STRDUP(mail_data[i].full_address_to);
 434                 temp_mail_tbl[i].full_address_cc         = EM_SAFE_STRDUP(mail_data[i].full_address_cc);
 435                 temp_mail_tbl[i].full_address_bcc        = EM_SAFE_STRDUP(mail_data[i].full_address_bcc);
 436                 temp_mail_tbl[i].full_address_return     = EM_SAFE_STRDUP(mail_data[i].full_address_return);
 437                 temp_mail_tbl[i].email_address_sender    = EM_SAFE_STRDUP(mail_data[i].email_address_sender);
 438                 temp_mail_tbl[i].email_address_recipient = EM_SAFE_STRDUP(mail_data[i].email_address_recipient);
 439                 temp_mail_tbl[i].alias_sender            = EM_SAFE_STRDUP(mail_data[i].alias_sender);
 440                 temp_mail_tbl[i].alias_recipient         = EM_SAFE_STRDUP(mail_data[i].alias_recipient);
 441                 temp_mail_tbl[i].body_download_status    = mail_data[i].body_download_status;
 442                 temp_mail_tbl[i].file_path_plain         = EM_SAFE_STRDUP(mail_data[i].file_path_plain);
 443                 temp_mail_tbl[i].file_path_html          = EM_SAFE_STRDUP(mail_data[i].file_path_html);
 444                 temp_mail_tbl[i].mail_size               = mail_data[i].mail_size;
 445                 temp_mail_tbl[i].flags_seen_field        = mail_data[i].flags_seen_field;
 446                 temp_mail_tbl[i].flags_deleted_field     = mail_data[i].flags_deleted_field;
 447                 temp_mail_tbl[i].flags_flagged_field     = mail_data[i].flags_flagged_field;
 448                 temp_mail_tbl[i].flags_answered_field    = mail_data[i].flags_answered_field;
 449                 temp_mail_tbl[i].flags_recent_field      = mail_data[i].flags_recent_field;
 450                 temp_mail_tbl[i].flags_draft_field       = mail_data[i].flags_draft_field;
 451                 temp_mail_tbl[i].flags_forwarded_field   = mail_data[i].flags_forwarded_field;
 452                 temp_mail_tbl[i].DRM_status              = mail_data[i].DRM_status;
 453                 temp_mail_tbl[i].priority                = mail_data[i].priority;
 454                 temp_mail_tbl[i].save_status             = mail_data[i].save_status;
 455                 temp_mail_tbl[i].lock_status             = mail_data[i].lock_status;
 456                 temp_mail_tbl[i].report_status           = mail_data[i].report_status;
 457                 temp_mail_tbl[i].attachment_count        = mail_data[i].attachment_count;
 458                 temp_mail_tbl[i].inline_content_count    = mail_data[i].inline_content_count;
 459                 temp_mail_tbl[i].thread_id               = mail_data[i].thread_id;
 460                 temp_mail_tbl[i].thread_item_count       = mail_data[i].thread_item_count;
 461                 temp_mail_tbl[i].preview_text            = EM_SAFE_STRDUP(mail_data[i].preview_text);
 462                 temp_mail_tbl[i].meeting_request_status  = mail_data[i].meeting_request_status;
 463         }
 464
 465         *mail_table_data = temp_mail_tbl;
 466
 467         ret = true;
 468 FINISH_OFF:
 469
 470         if(error)
 471                         *error = err_code;
 472
 473         EM_DEBUG_FUNC_END();
 474         return ret;
 475
 476 }
 477
 478
 479
 480 INTERNAL_FUNC int em_convert_string_to_time_t(char *input_datetime_string, time_t *output_time)
 481 {
 482         EM_DEBUG_FUNC_BEGIN("input_datetime_string[%s], output_time[%p]", input_datetime_string, output_time);
 483
 484         char buf[16] = { 0, };
 485         struct tm temp_time_info = { 0 };
 486
 487         if (!input_datetime_string || !output_time) {
 488                 EM_DEBUG_EXCEPTION("input_datetime_string[%p], output_time[%p]", input_datetime_string, output_time);
 489                 return EMF_ERROR_INVALID_PARAM;
 490         }
 491
 492         memset(buf, 0x00, sizeof(buf));
 493         SNPRINTF(buf, sizeof(buf), "%.4s", input_datetime_string);
 494         temp_time_info.tm_year = atoi(buf) - 1970;
 495
 496         memset(buf, 0x00, sizeof(buf));
 497         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 4);
 498         temp_time_info.tm_mon = atoi(buf) - 1;
 499
 500         memset(buf, 0x00, sizeof(buf));
 501         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 6);
 502         temp_time_info.tm_mday = atoi(buf);
 503
 504         memset(buf, 0x00, sizeof(buf));
 505         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 8);
 506         temp_time_info.tm_hour = atoi(buf);
 507
 508         memset(buf, 0x00, sizeof(buf));
 509         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 10);
 510         temp_time_info.tm_min = atoi(buf);
 511
 512         memset(buf, 0x00, sizeof(buf));
 513         SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 12);
 514         temp_time_info.tm_sec = atoi(buf);
 515
 516         *output_time = timegm(&temp_time_info);
 517
 518         EM_DEBUG_LOG("*output_time [%d", *output_time);
 519
 520         EM_DEBUG_FUNC_END("err %d", EMF_ERROR_NONE);
 521         return EMF_ERROR_NONE;
 522 }
 523
 524 INTERNAL_FUNC int em_convert_time_t_to_string(time_t *input_time, char **output_datetime_string)
 525 {
 526         EM_DEBUG_FUNC_BEGIN("input_time[%p], output_datetime_string[%p]", input_time, output_datetime_string);
 527         char temp_buffer[20] = { 0, };
 528         struct tm *temp_time_info;
 529
 530         if (!input_time || !output_datetime_string) {
 531                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 532                 return EMF_ERROR_INVALID_PARAM;
 533         }
 534
 535         temp_time_info = localtime(input_time);
 536
 537         if(!temp_time_info) {
 538                 EM_DEBUG_EXCEPTION("localtime failed.");
 539                 return EMF_ERROR_SYSTEM_FAILURE;
 540         }
 541         SNPRINTF(temp_buffer, sizeof(temp_buffer), "%04d%02d%02d%02d%02d%02d",
 542                 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);
 543
 544         *output_datetime_string = EM_SAFE_STRDUP(temp_buffer);
 545
 546         EM_DEBUG_FUNC_END("err %d", EMF_ERROR_NONE);
 547         return EMF_ERROR_NONE;
 548 }
 549
 550 static char* append_sized_data_to_stream(char *input_stream, int *input_output_stream_length, char *input_sized_data, int input_data_size)
 551 {
 552         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);
 553         char *new_stream = NULL;
 554         int source_stream_length = 0;
 555
 556         if( !input_output_stream_length || input_data_size == 0 || input_sized_data == NULL||
 557                         (input_stream != NULL && *input_output_stream_length == 0) || (input_stream == NULL && *input_output_stream_length != 0) ) {
 558                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 559                 return NULL;
 560         }
 561
 562         source_stream_length = *input_output_stream_length;
 563
 564         new_stream = (char*)em_malloc((source_stream_length) * sizeof(char) + input_data_size);
 565
 566         if(!new_stream) {
 567                 EM_DEBUG_EXCEPTION("EMF_ERROR_OUT_OF_MEMORY");
 568                 return NULL;
 569         }
 570
 571         if(input_stream != NULL)
 572                 memcpy(new_stream, input_stream, source_stream_length * sizeof(char));
 573
 574         memcpy(new_stream + source_stream_length, input_sized_data, input_data_size);
 575
 576         *input_output_stream_length = source_stream_length + input_data_size;
 577
 578         EM_SAFE_FREE(input_stream);
 579         EM_DEBUG_FUNC_END("*input_output_stream_length [%d]", *input_output_stream_length);
 580         return new_stream;
 581 }
 582
 583 static char* append_string_to_stream(char *input_stream, int *input_output_stream_length, char *input_source_string)
 584 {
 585         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);
 586         char *new_stream = NULL;
 587         int   data_length = 0;
 588         int   source_stream_length = 0;
 589
 590         if( !input_output_stream_length || (input_stream != NULL && *input_output_stream_length == 0) || (input_stream == NULL && *input_output_stream_length != 0)) {
 591                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 592                 return NULL;
 593         }
 594
 595         source_stream_length = *input_output_stream_length;
 596
 597         if(input_source_string != NULL)
 598                 data_length = EM_SAFE_STRLEN(input_source_string);
 599
 600         new_stream = (char*)em_malloc((source_stream_length + data_length) * sizeof(char) + sizeof(int));
 601
 602         if(!new_stream) {
 603                 EM_DEBUG_EXCEPTION("EMF_ERROR_OUT_OF_MEMORY");
 604                 return NULL;
 605         }
 606
 607         if(input_stream != NULL)
 608                 memcpy(new_stream, input_stream, source_stream_length * sizeof(char));
 609
 610         memcpy(new_stream + source_stream_length, (char*)&data_length, sizeof(int));
 611
 612         if(input_source_string)
 613                 memcpy(new_stream + source_stream_length + sizeof(int), input_source_string, data_length);
 614
 615         *input_output_stream_length = source_stream_length + sizeof(int) + data_length;
 616
 617         EM_SAFE_FREE(input_stream);
 618         EM_DEBUG_FUNC_END("*input_output_stream_length [%d]", *input_output_stream_length);
 619         return new_stream;
 620 }
 621
 622 static int fetch_sized_data_from_stream(char *input_stream, int *input_output_stream_offset, int input_data_size, char *output_data)
 623 {
 624         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);
 625         int stream_offset = 0;
 626
 627         if( !input_stream || !input_output_stream_offset || !input_data_size || !output_data) {
 628                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 629                 return EMF_ERROR_INVALID_PARAM;
 630         }
 631
 632         stream_offset = *input_output_stream_offset;
 633
 634         memcpy(output_data, input_stream + stream_offset, input_data_size);
 635         stream_offset += input_data_size;
 636
 637         *input_output_stream_offset = stream_offset;
 638
 639         EM_DEBUG_FUNC_END("stream_offset [%d]", stream_offset);
 640         return EMF_ERROR_NONE;
 641 }
 642
 643 static int fetch_string_from_stream(char *input_stream, int *input_output_stream_offset, char **output_string)
 644 {
 645         EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_offset [%p] output_string[%p]", input_stream, input_output_stream_offset, output_string);
 646         int string_length = 0;
 647         int stream_offset = 0;
 648         char *result_string = NULL;
 649
 650         if( !input_stream || !input_output_stream_offset || !output_string) {
 651                 EM_DEBUG_EXCEPTION("EMF_ERROR_INVALID_PARAM");
 652                 return EMF_ERROR_INVALID_PARAM;
 653         }
 654
 655         stream_offset = *input_output_stream_offset;
 656         /*
 657         EM_DEBUG_LOG("stream_offset [%d]", stream_offset);
 658         */
 659
 660         memcpy(&string_length, input_stream + stream_offset, sizeof(int));
 661         stream_offset +=  sizeof(int);
 662
 663         /*
 664         EM_DEBUG_LOG("string_length [%d]", string_length);
 665         */
 666
 667         if(string_length != 0) {
 668                 result_string = (char*)em_malloc(string_length + 1);
 669                 if(result_string) {
 670                         memcpy(result_string, input_stream + stream_offset, string_length);
 671                         stream_offset += string_length;
 672                 }
 673         }
 674         /*
 675         if(result_string)
 676                 EM_DEBUG_LOG("result_string [%s]", result_string);
 677         */
 678
 679         *output_string              = result_string;
 680         *input_output_stream_offset = stream_offset;
 681
 682         EM_DEBUG_FUNC_END("stream_offset [%d]", stream_offset);
 683         return EMF_ERROR_NONE;
 684 }
 685
 686 INTERNAL_FUNC char* em_convert_account_to_byte_stream(emf_account_t* input_account, int *output_stream_size)
 687 {
 688         EM_DEBUG_FUNC_BEGIN("input_account [%p], output_stream_size [%p]", input_account, output_stream_size);
 689         char *result_stream = NULL;
 690         int stream_size = 0;
 691
 692         EM_IF_NULL_RETURN_VALUE(input_account, NULL);
 693
 694         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->account_bind_type), sizeof(int));
 695         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->account_name);
 696         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->receiving_server_type), sizeof(int));
 697         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->receiving_server_addr);
 698         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->email_addr);
 699         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->user_name);
 700         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->password);
 701         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->retrieval_mode), sizeof(int));
 702         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->port_num), sizeof(int));
 703         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->use_security), sizeof(int));
 704         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->sending_server_type), sizeof(int));
 705         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->sending_server_addr);
 706         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->sending_port_num), sizeof(int));
 707         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->sending_auth), sizeof(int));
 708         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->sending_security), sizeof(int));
 709         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->sending_user);
 710         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->sending_password);
 711         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->display_name);
 712         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->reply_to_addr);
 713         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->return_addr);
 714         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->account_id), sizeof(int));
 715         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->keep_on_server), sizeof(int));
 716         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->flag1), sizeof(int));
 717         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->flag2), sizeof(int));
 718         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->pop_before_smtp), sizeof(int));
 719         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->apop), sizeof(int));
 720         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->logo_icon_path);
 721         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->preset_account), sizeof(int));
 722         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.priority), sizeof(int));
 723         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.keep_local_copy), sizeof(int));
 724         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.req_delivery_receipt), sizeof(int));
 725         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.req_read_receipt), sizeof(int));
 726         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.download_limit), sizeof(int));
 727         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.block_address), sizeof(int));
 728         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.block_subject), sizeof(int));
 729         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->options.display_name_from);
 730         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.reply_with_body), sizeof(int));
 731         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.forward_with_files), sizeof(int));
 732         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.add_myname_card), sizeof(int));
 733         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.add_signature), sizeof(int));
 734         result_stream = append_string_to_stream(result_stream, &stream_size, input_account->options.signature);
 735         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->options.add_my_address_to_bcc), sizeof(int));
 736         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->target_storage), sizeof(int));
 737         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->check_interval), sizeof(int));
 738         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->my_account_id), sizeof(int));
 739         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_account->index_color), sizeof(int));
 740
 741         *output_stream_size = stream_size;
 742
 743         EM_DEBUG_FUNC_END("stream_size [%d]", stream_size);
 744         return result_stream;
 745 }
 746
 747
 748 INTERNAL_FUNC void em_convert_byte_stream_to_account(char *input_stream,  emf_account_t *output_account)
 749 {
 750         EM_DEBUG_FUNC_BEGIN();
 751         int stream_offset = 0;
 752
 753         EM_NULL_CHECK_FOR_VOID(input_stream);
 754         EM_NULL_CHECK_FOR_VOID(output_account);
 755
 756         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->account_bind_type);
 757         fetch_string_from_stream(input_stream, &stream_offset, &output_account->account_name);
 758         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->receiving_server_type);
 759         fetch_string_from_stream(input_stream, &stream_offset, &output_account->receiving_server_addr);
 760         fetch_string_from_stream(input_stream, &stream_offset, &output_account->email_addr);
 761         fetch_string_from_stream(input_stream, &stream_offset, &output_account->user_name);
 762         fetch_string_from_stream(input_stream, &stream_offset, &output_account->password);
 763         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->retrieval_mode);
 764         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->port_num);
 765         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->use_security);
 766         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->sending_server_type);
 767         fetch_string_from_stream(input_stream, &stream_offset, &output_account->sending_server_addr);
 768         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->sending_port_num);
 769         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->sending_auth);
 770         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->sending_security);
 771         fetch_string_from_stream(input_stream, &stream_offset, &output_account->sending_user);
 772         fetch_string_from_stream(input_stream, &stream_offset, &output_account->sending_password);
 773         fetch_string_from_stream(input_stream, &stream_offset, &output_account->display_name);
 774         fetch_string_from_stream(input_stream, &stream_offset, &output_account->reply_to_addr);
 775         fetch_string_from_stream(input_stream, &stream_offset, &output_account->return_addr);
 776         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->account_id);
 777         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->keep_on_server);
 778         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->flag1);
 779         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->flag2);
 780         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->pop_before_smtp);
 781         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->apop);
 782         fetch_string_from_stream(input_stream, &stream_offset, &output_account->logo_icon_path);
 783         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->preset_account);
 784         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.priority);
 785         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.keep_local_copy);
 786         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.req_delivery_receipt);
 787         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.req_read_receipt);
 788         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.download_limit);
 789         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.block_address);
 790         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.block_subject);
 791         fetch_string_from_stream(input_stream, &stream_offset, &output_account->options.display_name_from);
 792         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.reply_with_body);
 793         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.forward_with_files);
 794         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.add_myname_card);
 795         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.add_signature);
 796         fetch_string_from_stream(input_stream, &stream_offset, &output_account->options.signature);
 797         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->options.add_my_address_to_bcc);
 798         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->target_storage);
 799         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->check_interval);
 800         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->my_account_id);
 801         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&output_account->index_color);
 802
 803         EM_DEBUG_FUNC_END();
 804 }
 805
 806 INTERNAL_FUNC char* em_convert_attachment_info_to_byte_stream(emf_attachment_info_t *input_attachment_info, int *output_stream_size)
 807 {
 808         EM_DEBUG_FUNC_BEGIN();
 809
 810         char *result_stream = NULL;
 811         int stream_size = 0;
 812
 813         EM_IF_NULL_RETURN_VALUE(input_attachment_info, NULL);
 814         EM_IF_NULL_RETURN_VALUE(output_stream_size, NULL);
 815
 816         while(input_attachment_info) {
 817                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_info->inline_content, sizeof(int));
 818                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_info->attachment_id, sizeof(int));
 819                 result_stream = append_string_to_stream(result_stream, &stream_size, input_attachment_info->name);
 820                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_info->size, sizeof(int));
 821                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_info->downloaded, sizeof(int));
 822                 result_stream = append_string_to_stream(result_stream, &stream_size, input_attachment_info->savename);
 823                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_info->drm, sizeof(int));
 824
 825                 input_attachment_info = input_attachment_info->next;
 826         }
 827
 828         *output_stream_size = stream_size;
 829
 830         EM_DEBUG_FUNC_END();
 831         return result_stream;
 832 }
 833
 834 INTERNAL_FUNC void em_convert_byte_stream_to_attachment_info(char *input_stream, int attachment_count, emf_attachment_info_t **output_attachment_info)
 835 {
 836         EM_DEBUG_FUNC_BEGIN();
 837
 838         int i = 0;
 839         int stream_offset = 0;
 840         emf_attachment_info_t *temp_attachment_info = NULL;
 841         emf_attachment_info_t *current_attachment_info = NULL;
 842
 843         EM_NULL_CHECK_FOR_VOID(input_stream);
 844
 845         for(i = 0; i < attachment_count; i++) {
 846                 temp_attachment_info = (emf_attachment_info_t*)malloc(sizeof(emf_attachment_info_t));
 847
 848                 if(i == 0)
 849                         *output_attachment_info = current_attachment_info = temp_attachment_info;
 850                 else {
 851                         current_attachment_info->next = temp_attachment_info;
 852                         current_attachment_info = temp_attachment_info;
 853                 }
 854
 855                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&temp_attachment_info->inline_content);
 856                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&temp_attachment_info->attachment_id);
 857                 fetch_string_from_stream(input_stream, &stream_offset, &temp_attachment_info->name);
 858                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&temp_attachment_info->size);
 859                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&temp_attachment_info->downloaded);
 860                 fetch_string_from_stream(input_stream, &stream_offset, &temp_attachment_info->savename);
 861                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&temp_attachment_info->drm);
 862
 863                 temp_attachment_info->next = NULL;
 864         }
 865
 866         EM_DEBUG_FUNC_END();
 867 }
 868
 869 INTERNAL_FUNC char* em_convert_mail_data_to_byte_stream(emf_mail_data_t *input_mail_data, int input_mail_data_count, int *output_stream_size)
 870 {
 871         EM_DEBUG_FUNC_BEGIN("input_mail_data [%p], input_mail_data_count[%d], output_stream_size[%p]", input_mail_data, input_mail_data_count, output_stream_size);
 872
 873         char *result_stream = NULL;
 874         int stream_size = 0;
 875         int i = 0;
 876
 877         EM_IF_NULL_RETURN_VALUE(input_mail_data, NULL);
 878         EM_IF_NULL_RETURN_VALUE(output_stream_size, NULL);
 879
 880         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_mail_data_count, sizeof(int));
 881
 882         for(i = 0; i < input_mail_data_count; i++) {
 883                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].mail_id), sizeof(int));
 884                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].account_id), sizeof(int));
 885                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].mailbox_name);
 886                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].mailbox_type), sizeof(int));
 887                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].subject);
 888                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].date_time), sizeof(int));
 889                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].server_mail_status), sizeof(int));
 890                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].server_mailbox_name);
 891                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].server_mail_id);
 892                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].message_id);
 893                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].full_address_from);
 894                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].full_address_reply);
 895                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].full_address_to);
 896                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].full_address_cc);
 897                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].full_address_bcc);
 898                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].full_address_return);
 899                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].email_address_sender);
 900                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].email_address_recipient);
 901                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].alias_sender);
 902                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].alias_recipient);
 903                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].body_download_status), sizeof(int));
 904                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].file_path_plain);
 905                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].file_path_html);
 906                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].mail_size), sizeof(int));
 907                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_seen_field), sizeof(char));
 908                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_deleted_field), sizeof(char));
 909                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_flagged_field), sizeof(char));
 910                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_answered_field), sizeof(char));
 911                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_recent_field), sizeof(char));
 912                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_draft_field), sizeof(char));
 913                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].flags_forwarded_field), sizeof(char));
 914                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].DRM_status), sizeof(int));
 915                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].priority), sizeof(int));
 916                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].save_status), sizeof(int));
 917                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].lock_status), sizeof(int));
 918                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].report_status), sizeof(int));
 919                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].attachment_count), sizeof(int));
 920                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].inline_content_count), sizeof(int));
 921                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].thread_id), sizeof(int));
 922                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].thread_item_count), sizeof(int));
 923                 result_stream = append_string_to_stream(result_stream, &stream_size, input_mail_data[i].preview_text);
 924                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mail_data[i].meeting_request_status), sizeof(int));
 925         }
 926
 927         *output_stream_size = stream_size;
 928
 929         EM_DEBUG_FUNC_END("stream_size [%d]", stream_size);
 930         return result_stream;
 931 }
 932
 933 INTERNAL_FUNC void em_convert_byte_stream_to_mail_data(char *input_stream, emf_mail_data_t **output_mail_data, int *output_mail_data_count)
 934 {
 935         EM_DEBUG_FUNC_BEGIN("input_stream [%p], output_mail_data[%p], output_mail_data_count[%p]", input_stream, output_mail_data, output_mail_data_count);
 936
 937         int stream_offset = 0;
 938         int i = 0;
 939
 940         EM_NULL_CHECK_FOR_VOID(input_stream);
 941         EM_NULL_CHECK_FOR_VOID(output_mail_data);
 942         EM_NULL_CHECK_FOR_VOID(output_mail_data_count);
 943
 944         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)output_mail_data_count);
 945
 946         EM_DEBUG_LOG("*output_mail_data_count [%d]", *output_mail_data_count);
 947
 948         if(output_mail_data_count <= 0) {
 949                 EM_DEBUG_EXCEPTION("no mail data.");
 950                 return;
 951         }
 952
 953         *output_mail_data = (emf_mail_data_t*)em_malloc(sizeof(emf_mail_data_t) * (*output_mail_data_count));
 954
 955         if(!*output_mail_data) {
 956                 EM_DEBUG_EXCEPTION("em_malloc failed");
 957                 return;
 958         }
 959
 960         for(i = 0; i < *output_mail_data_count; i++) {
 961                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].mail_id);
 962                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].account_id);
 963                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].mailbox_name);
 964                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].mailbox_type);
 965                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].subject);
 966                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].date_time);
 967                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].server_mail_status);
 968                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].server_mailbox_name);
 969                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].server_mail_id);
 970                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].message_id);
 971                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].full_address_from);
 972                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].full_address_reply);
 973                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].full_address_to);
 974                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].full_address_cc);
 975                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].full_address_bcc);
 976                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].full_address_return);
 977                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].email_address_sender);
 978                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].email_address_recipient);
 979                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].alias_sender);
 980                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].alias_recipient);
 981                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].body_download_status);
 982                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].file_path_plain);
 983                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].file_path_html);
 984                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].mail_size);
 985                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_seen_field);
 986                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_deleted_field);
 987                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_flagged_field);
 988                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_answered_field);
 989                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_recent_field);
 990                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_draft_field);
 991                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(char), (char*)&(*output_mail_data)[i].flags_forwarded_field);
 992                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].DRM_status);
 993                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].priority);
 994                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].save_status);
 995                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].lock_status);
 996                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].report_status);
 997                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].attachment_count);
 998                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].inline_content_count);
 999                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].thread_id);
1000                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].thread_item_count);
1001                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_mail_data)[i].preview_text);
1002                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(*output_mail_data)[i].meeting_request_status);
1003         }
1004
1005         EM_DEBUG_FUNC_END();
1006 }
1007
1008 INTERNAL_FUNC char* em_convert_attachment_data_to_byte_stream(emf_attachment_data_t *input_attachment_data, int input_attachment_count, int* output_stream_size)
1009 {
1010         EM_DEBUG_FUNC_BEGIN("input_attachment_data [%p], input_attachment_count [%d], output_stream_size [%p]", input_attachment_data, input_attachment_count, output_stream_size);
1011
1012         char *result_stream = NULL;
1013         int stream_size = 0;
1014         int i = 0;
1015
1016         if(input_attachment_count > 0)
1017                 EM_IF_NULL_RETURN_VALUE(input_attachment_data, NULL);
1018         EM_IF_NULL_RETURN_VALUE(output_stream_size, NULL);
1019
1020         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_count, sizeof(int));
1021
1022         for(i = 0; i < input_attachment_count; i++) {
1023                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].attachment_id, sizeof(int));
1024                 result_stream = append_string_to_stream(result_stream, &stream_size, input_attachment_data[i].attachment_name);
1025                 result_stream = append_string_to_stream(result_stream, &stream_size, input_attachment_data[i].attachment_path);
1026                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].attachment_size, sizeof(int));
1027                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].mail_id, sizeof(int));
1028                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].account_id, sizeof(int));
1029                 result_stream = append_string_to_stream(result_stream, &stream_size, input_attachment_data[i].mailbox_name);
1030                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].save_status, sizeof(int));
1031                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].drm_status, sizeof(int));
1032                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_attachment_data[i].inline_content_status,sizeof(int));
1033         }
1034
1035         *output_stream_size = stream_size;
1036
1037         EM_DEBUG_FUNC_END("stream_size [%d]", stream_size);
1038         return result_stream;
1039 }
1040
1041 INTERNAL_FUNC void em_convert_byte_stream_to_attachment_data(char *input_stream, emf_attachment_data_t **output_attachment_data, int *output_attachment_count)
1042 {
1043         EM_DEBUG_FUNC_BEGIN("input_stream [%p], output_attachment_data[%p]", input_stream, output_attachment_data);
1044
1045         int stream_offset = 0;
1046         int i = 0;
1047
1048         EM_NULL_CHECK_FOR_VOID(input_stream);
1049         EM_NULL_CHECK_FOR_VOID(output_attachment_data);
1050         EM_NULL_CHECK_FOR_VOID(output_attachment_count);
1051
1052         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)output_attachment_count);
1053
1054         EM_DEBUG_LOG("*output_attachment_count [%d]", *output_attachment_count);
1055
1056         if(output_attachment_count <= 0) {
1057                 EM_DEBUG_EXCEPTION("no attachment data.");
1058                 return;
1059         }
1060
1061         *output_attachment_data = (emf_attachment_data_t*)em_malloc(sizeof(emf_attachment_data_t) * (*output_attachment_count));
1062
1063         if(!*output_attachment_data) {
1064                 EM_DEBUG_EXCEPTION("em_malloc failed");
1065                 return;
1066         }
1067
1068         for(i = 0; i < *output_attachment_count; i++) {
1069                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].attachment_id));
1070                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_attachment_data)[i].attachment_name);
1071                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_attachment_data)[i].attachment_path);
1072                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].attachment_size));
1073                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].mail_id));
1074                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].account_id));
1075                 fetch_string_from_stream(input_stream, &stream_offset, &(*output_attachment_data)[i].mailbox_name);
1076                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].save_status));
1077                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].drm_status));
1078                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&((*output_attachment_data)[i].inline_content_status));
1079         }
1080
1081         EM_DEBUG_FUNC_END();
1082 }
1083
1084
1085
1086 INTERNAL_FUNC char* em_convert_mailbox_to_byte_stream(emf_mailbox_t *input_mailbox_data, int *output_stream_size)
1087 {
1088         EM_DEBUG_FUNC_BEGIN("input_mailbox_data [%p], output_stream_size [%p]", input_mailbox_data, output_stream_size);
1089
1090         char *result_stream = NULL;
1091         int   stream_size       =  0;
1092
1093         EM_IF_NULL_RETURN_VALUE(input_mailbox_data, NULL);
1094         EM_IF_NULL_RETURN_VALUE(output_stream_size, NULL);
1095
1096         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->mailbox_id), sizeof(int));
1097         result_stream = append_string_to_stream(result_stream, &stream_size, input_mailbox_data->name);
1098         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->mailbox_type), sizeof(int));
1099         result_stream = append_string_to_stream(result_stream, &stream_size, input_mailbox_data->alias);
1100         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->unread_count), sizeof(int));
1101         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->total_mail_count_on_local), sizeof(int));
1102         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->total_mail_count_on_server), sizeof(int));
1103         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->hold_connection), sizeof(int));
1104         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->local), sizeof(int));
1105         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->synchronous), sizeof(int));
1106         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->account_id), sizeof(int));
1107         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->user_data), sizeof(int));
1108         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->mail_stream), sizeof(int));
1109         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->has_archived_mails), sizeof(int));
1110         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_mailbox_data->mail_slot_size), sizeof(int));
1111         result_stream = append_string_to_stream(result_stream, &stream_size, input_mailbox_data->account_name);
1112
1113         *output_stream_size = stream_size;
1114
1115         EM_DEBUG_FUNC_END();
1116
1117         return result_stream;
1118 }
1119
1120
1121 INTERNAL_FUNC void em_convert_byte_stream_to_mailbox(char *input_stream, emf_mailbox_t *output_mailbox_data)
1122 {
1123         EM_DEBUG_FUNC_BEGIN("input_stream [%p], output_mailbox_data [%p]", input_stream, output_mailbox_data);
1124         int             stream_offset   = 0;
1125
1126         EM_NULL_CHECK_FOR_VOID(input_stream);
1127         EM_NULL_CHECK_FOR_VOID(output_mailbox_data);
1128
1129         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->mailbox_id));
1130         fetch_string_from_stream(input_stream, &stream_offset, &output_mailbox_data->name);
1131         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->mailbox_type));
1132         fetch_string_from_stream(input_stream, &stream_offset, &output_mailbox_data->alias);
1133         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->unread_count));
1134         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->total_mail_count_on_local));
1135         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->total_mail_count_on_server));
1136         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->hold_connection));
1137         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->local));
1138         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->synchronous));
1139         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->account_id));
1140         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->user_data));
1141         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->mail_stream));
1142         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->has_archived_mails));
1143         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_mailbox_data->mail_slot_size));
1144         fetch_string_from_stream(input_stream, &stream_offset, &output_mailbox_data->account_name);
1145         EM_DEBUG_FUNC_END();
1146 }
1147
1148
1149 INTERNAL_FUNC char* em_convert_option_to_byte_stream(emf_option_t* input_option, int* output_stream_size)
1150 {
1151         EM_DEBUG_FUNC_BEGIN();
1152         char *result_stream = NULL;
1153         int stream_size = 0;
1154
1155         EM_IF_NULL_RETURN_VALUE(input_option, NULL);
1156
1157         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->priority), sizeof(int));
1158         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->keep_local_copy), sizeof(int));
1159         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->req_delivery_receipt), sizeof(int));
1160         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->req_read_receipt), sizeof(int));
1161         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->download_limit), sizeof(int));
1162         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->block_address), sizeof(int));
1163         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->block_subject), sizeof(int));
1164         result_stream = append_string_to_stream(result_stream, &stream_size, input_option->display_name_from);
1165         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->reply_with_body), sizeof(int));
1166         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->forward_with_files), sizeof(int));
1167         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->add_myname_card), sizeof(int));
1168         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->add_signature), sizeof(int));
1169         result_stream = append_string_to_stream(result_stream, &stream_size, input_option->signature);
1170         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_option->add_my_address_to_bcc), sizeof(int));
1171         *output_stream_size = stream_size;
1172
1173         EM_DEBUG_FUNC_END();
1174         return result_stream;
1175
1176 }
1177
1178 INTERNAL_FUNC void em_convert_byte_stream_to_option(char *input_stream, emf_option_t *output_option)
1179 {
1180         EM_DEBUG_FUNC_BEGIN();
1181         int stream_offset = 0;
1182
1183         EM_NULL_CHECK_FOR_VOID(input_stream);
1184
1185         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->priority));
1186         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->keep_local_copy));
1187         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->req_delivery_receipt));
1188         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->req_read_receipt));
1189         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->download_limit));
1190         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->block_address));
1191         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->block_subject));
1192         fetch_string_from_stream(input_stream, &stream_offset, &output_option->display_name_from);
1193         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->reply_with_body));
1194         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->forward_with_files));
1195         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->add_myname_card));
1196         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->add_signature));
1197         fetch_string_from_stream(input_stream, &stream_offset, &output_option->signature);
1198         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_option->add_my_address_to_bcc));
1199
1200         EM_DEBUG_FUNC_END();
1201 }
1202
1203 INTERNAL_FUNC char* em_convert_rule_to_byte_stream(emf_rule_t *input_rule, int *output_stream_size)
1204 {
1205         EM_DEBUG_FUNC_BEGIN();
1206         char *result_stream = NULL;
1207         int stream_size = 0;
1208
1209         EM_IF_NULL_RETURN_VALUE(input_rule, NULL);
1210         EM_IF_NULL_RETURN_VALUE(output_stream_size, NULL);
1211
1212         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_rule->account_id), sizeof(int));
1213         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_rule->filter_id), sizeof(int));
1214         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_rule->type), sizeof(int));
1215         result_stream = append_string_to_stream(result_stream, &stream_size, input_rule->value);
1216         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_rule->faction), sizeof(int));
1217         result_stream = append_string_to_stream(result_stream, &stream_size, input_rule->mailbox);
1218         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_rule->flag1), sizeof(int));
1219         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_rule->flag2), sizeof(int));
1220
1221         *output_stream_size = stream_size;
1222
1223         EM_DEBUG_FUNC_END();
1224         return result_stream;
1225 }
1226
1227 INTERNAL_FUNC void em_convert_byte_stream_to_rule(char *input_stream, emf_rule_t *output_rule)
1228 {
1229         EM_DEBUG_FUNC_BEGIN();
1230         int stream_offset = 0;
1231
1232         EM_NULL_CHECK_FOR_VOID(input_stream);
1233         EM_NULL_CHECK_FOR_VOID(output_rule);
1234
1235         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_rule->account_id));
1236         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_rule->filter_id));
1237         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_rule->type));
1238         fetch_string_from_stream(input_stream, &stream_offset, &output_rule->value);
1239         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_rule->faction));
1240         fetch_string_from_stream(input_stream, &stream_offset, &output_rule->mailbox);
1241         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_rule->flag1));
1242         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_rule->flag2));
1243
1244         EM_DEBUG_FUNC_END();
1245 }
1246
1247 INTERNAL_FUNC char* em_convert_extra_flags_to_byte_stream(emf_extra_flag_t input_extra_flag, int *output_stream_size)
1248 {
1249         EM_DEBUG_FUNC_BEGIN();
1250         char *result_stream = NULL;
1251         int   stream_size = 0;
1252         int   extra_flag_field = 0;
1253
1254         EM_IF_NULL_RETURN_VALUE(output_stream_size, NULL);
1255
1256         extra_flag_field = input_extra_flag.priority;
1257         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1258         extra_flag_field = input_extra_flag.status;
1259         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1260         extra_flag_field = input_extra_flag.noti;
1261         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1262         extra_flag_field = input_extra_flag.lock;
1263         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1264         extra_flag_field = input_extra_flag.report;
1265         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1266         extra_flag_field = input_extra_flag.drm;
1267         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1268         extra_flag_field = input_extra_flag.text_download_yn;
1269         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&extra_flag_field, sizeof(int));
1270
1271         *output_stream_size = stream_size;
1272
1273         EM_DEBUG_FUNC_END();
1274
1275         return result_stream;
1276 }
1277
1278 INTERNAL_FUNC void em_convert_byte_stream_to_extra_flags(char *input_stream, emf_extra_flag_t *output_extra_flag)
1279 {
1280         EM_DEBUG_FUNC_BEGIN();
1281
1282         int stream_offset = 0;
1283         int extra_flag_field = 0;
1284
1285         EM_NULL_CHECK_FOR_VOID(input_stream);
1286         EM_NULL_CHECK_FOR_VOID(output_extra_flag);
1287
1288         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1289         output_extra_flag->priority = extra_flag_field;
1290         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1291         output_extra_flag->status = extra_flag_field;
1292         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1293         output_extra_flag->noti = extra_flag_field;
1294         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1295         output_extra_flag->lock = extra_flag_field;
1296         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1297         output_extra_flag->report = extra_flag_field;
1298         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1299         output_extra_flag->drm = extra_flag_field;
1300         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&extra_flag_field);
1301         output_extra_flag->text_download_yn = extra_flag_field;
1302
1303         EM_DEBUG_FUNC_END();
1304 }
1305
1306 INTERNAL_FUNC char* em_convert_meeting_req_to_byte_stream(emf_meeting_request_t *input_meeting_req, int *output_stream_size)
1307 {
1308         EM_DEBUG_FUNC_BEGIN();
1309
1310         char *result_stream = NULL;
1311         int   stream_size        = 0;
1312
1313         EM_IF_NULL_RETURN_VALUE(input_meeting_req, NULL);
1314
1315         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->mail_id), sizeof(int));
1316         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->meeting_response), sizeof(int));
1317         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->start_time), sizeof(struct tm));
1318         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->end_time), sizeof(struct tm));
1319         result_stream = append_string_to_stream    (result_stream, &stream_size, input_meeting_req->location);
1320         result_stream = append_string_to_stream    (result_stream, &stream_size, input_meeting_req->global_object_id);
1321         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->time_zone.offset_from_GMT), sizeof(int));
1322         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_meeting_req->time_zone.standard_name, 32);
1323         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->time_zone.standard_time_start_date), sizeof(struct tm));
1324         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->time_zone.standard_bias), sizeof(int));
1325         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&input_meeting_req->time_zone.daylight_name, 32);
1326         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->time_zone.daylight_time_start_date), sizeof(struct tm));
1327         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_meeting_req->time_zone.daylight_bias), sizeof(int));
1328
1329         *output_stream_size = stream_size;
1330
1331         EM_DEBUG_FUNC_END();
1332         return result_stream;
1333 }
1334
1335
1336 INTERNAL_FUNC void em_convert_byte_stream_to_meeting_req(char *input_stream,  emf_meeting_request_t *output_meeting_req)
1337 {
1338         EM_DEBUG_FUNC_BEGIN();
1339         int stream_offset = 0;
1340
1341         EM_NULL_CHECK_FOR_VOID(input_stream);
1342         EM_NULL_CHECK_FOR_VOID(output_meeting_req);
1343
1344         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_meeting_req->mail_id));
1345         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_meeting_req->meeting_response));
1346         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(struct tm), (char*)&(output_meeting_req->start_time));
1347         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(struct tm), (char*)&(output_meeting_req->end_time));
1348         fetch_string_from_stream    (input_stream, &stream_offset, &output_meeting_req->location);
1349         fetch_string_from_stream    (input_stream, &stream_offset, &output_meeting_req->global_object_id);
1350         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_meeting_req->time_zone.offset_from_GMT));
1351         fetch_sized_data_from_stream(input_stream, &stream_offset, 32, output_meeting_req->time_zone.standard_name);
1352         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(struct tm), (char*)&(output_meeting_req->time_zone.standard_time_start_date));
1353         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_meeting_req->time_zone.standard_bias));
1354         fetch_sized_data_from_stream(input_stream, &stream_offset, 32, output_meeting_req->time_zone.daylight_name);
1355         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(struct tm), (char*)&(output_meeting_req->time_zone.daylight_time_start_date));
1356         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(output_meeting_req->time_zone.daylight_bias));
1357
1358         EM_DEBUG_FUNC_END();
1359 }
1360
1361 INTERNAL_FUNC char* em_convert_search_filter_to_byte_stream(email_search_filter_t *input_search_filter_list, int input_search_filter_count, int *output_stream_size)
1362 {
1363         EM_DEBUG_FUNC_BEGIN("input_search_filter_list [%p] input_search_filter_count [%d]", input_search_filter_list, input_search_filter_count);
1364
1365         char *result_stream = NULL;
1366         int   stream_size   = 0;
1367         int   i = 0;
1368
1369         EM_IF_NULL_RETURN_VALUE(input_search_filter_list, NULL);
1370
1371         result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_count), sizeof(int));
1372
1373         for( i = 0; i < input_search_filter_count; i++) {
1374                 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_type), sizeof(int));
1375                 switch(input_search_filter_list->search_filter_type) {
1376                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO       :
1377                         case EMAIL_SEARCH_FILTER_TYPE_UID              :
1378                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER      :
1379                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER     :
1380                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED   :
1381                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED    :
1382                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT      :
1383                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED     :
1384                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT     :
1385                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN       :
1386                                 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));
1387                                 break;
1388
1389                         case EMAIL_SEARCH_FILTER_TYPE_BCC              :
1390                         case EMAIL_SEARCH_FILTER_TYPE_CC               :
1391                         case EMAIL_SEARCH_FILTER_TYPE_FROM             :
1392                         case EMAIL_SEARCH_FILTER_TYPE_KEYWORD          :
1393                         case EMAIL_SEARCH_FILTER_TYPE_SUBJECT          :
1394                         case EMAIL_SEARCH_FILTER_TYPE_TO               :
1395                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID       :
1396                                 result_stream = append_string_to_stream(result_stream, &stream_size, input_search_filter_list->search_filter_key_value.string_type_key_value);
1397                                 break;
1398
1399                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE :
1400                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON     :
1401                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE  :
1402                                 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));
1403                                 break;
1404                         default :
1405                                 EM_DEBUG_EXCEPTION("Invalid filter type [%d]", input_search_filter_list->search_filter_type);
1406                                 break;
1407                 }
1408         }
1409
1410         *output_stream_size = stream_size;
1411
1412         EM_DEBUG_FUNC_END();
1413         return result_stream;
1414 }
1415
1416 INTERNAL_FUNC void em_convert_byte_stream_to_search_filter(char *input_stream, email_search_filter_t **output_search_filter_list, int *output_search_filter_count)
1417 {
1418         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);
1419
1420         int stream_offset = 0;
1421         int i = 0;
1422         int local_search_filter_count = 0;
1423         email_search_filter_t *local_search_filter = NULL;
1424
1425         EM_NULL_CHECK_FOR_VOID(input_stream);
1426         EM_NULL_CHECK_FOR_VOID(output_search_filter_list);
1427         EM_NULL_CHECK_FOR_VOID(output_search_filter_count);
1428
1429         fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter_count));
1430
1431         if(local_search_filter_count == 0) {
1432                 EM_DEBUG_EXCEPTION("local_search_filter_count is 0.");
1433                 goto FINISH_OFF;
1434         }
1435
1436         local_search_filter = em_malloc(sizeof(email_search_filter_t) * local_search_filter_count);
1437
1438         if(local_search_filter == NULL) {
1439                 EM_DEBUG_EXCEPTION("em_malloc for local_search_filter failed");
1440                 goto FINISH_OFF;
1441         }
1442
1443         *output_search_filter_count = local_search_filter_count;
1444
1445         for( i = 0; i < local_search_filter_count; i++) {
1446                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter[i].search_filter_type));
1447                 switch(local_search_filter[i].search_filter_type) {
1448                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO       :
1449                         case EMAIL_SEARCH_FILTER_TYPE_UID              :
1450                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER      :
1451                         case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER     :
1452                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED   :
1453                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED    :
1454                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT      :
1455                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED     :
1456                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT     :
1457                         case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN       :
1458                                 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter[i].search_filter_key_value.integer_type_key_value));
1459                                 break;
1460
1461                         case EMAIL_SEARCH_FILTER_TYPE_BCC              :
1462                         case EMAIL_SEARCH_FILTER_TYPE_CC               :
1463                         case EMAIL_SEARCH_FILTER_TYPE_FROM             :
1464                         case EMAIL_SEARCH_FILTER_TYPE_KEYWORD          :
1465                         case EMAIL_SEARCH_FILTER_TYPE_SUBJECT          :
1466                         case EMAIL_SEARCH_FILTER_TYPE_TO               :
1467                         case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID       :
1468                                 fetch_string_from_stream(input_stream, &stream_offset, &(local_search_filter[i].search_filter_key_value.string_type_key_value));
1469                                 break;
1470
1471                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE :
1472                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON     :
1473                         case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE  :
1474                                 fetch_sized_data_from_stream(input_stream, &stream_offset, 32, (char*)&(local_search_filter[i].search_filter_key_value.time_type_key_value));
1475                                 break;
1476                         default :
1477                                 EM_DEBUG_EXCEPTION("Invalid filter type [%d]", local_search_filter[i].search_filter_type);
1478                                 break;
1479                 }
1480         }
1481
1482         *output_search_filter_list = local_search_filter;
1483
1484 FINISH_OFF:
1485
1486         EM_DEBUG_FUNC_END();
1487 }