4 * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
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"
39 #define fATTACHMENT 0x40
43 INTERNAL_FUNC int em_convert_account_to_account_tbl(email_account_t *account, emstorage_account_tbl_t *account_tbl)
45 EM_DEBUG_FUNC_BEGIN("account[%p], account_tbl[%p]", account, account_tbl);
48 account_tbl->account_name = EM_SAFE_STRDUP(account->account_name);
49 account_tbl->incoming_server_type = account->incoming_server_type;
50 account_tbl->incoming_server_address = EM_SAFE_STRDUP(account->incoming_server_address);
51 account_tbl->user_email_address = EM_SAFE_STRDUP(account->user_email_address);
52 account_tbl->incoming_server_user_name = EM_SAFE_STRDUP(account->incoming_server_user_name);
53 account_tbl->incoming_server_password = EM_SAFE_STRDUP(account->incoming_server_password);
54 account_tbl->retrieval_mode = account->retrieval_mode;
55 account_tbl->incoming_server_port_number = account->incoming_server_port_number;
56 account_tbl->incoming_server_secure_connection = account->incoming_server_secure_connection;
57 account_tbl->outgoing_server_type = account->outgoing_server_type;
58 account_tbl->outgoing_server_address = EM_SAFE_STRDUP(account->outgoing_server_address);
59 account_tbl->outgoing_server_port_number = account->outgoing_server_port_number;
60 account_tbl->outgoing_server_need_authentication = account->outgoing_server_need_authentication;
61 account_tbl->outgoing_server_secure_connection = account->outgoing_server_secure_connection;
62 account_tbl->outgoing_server_user_name = EM_SAFE_STRDUP(account->outgoing_server_user_name);
63 account_tbl->outgoing_server_password = EM_SAFE_STRDUP(account->outgoing_server_password);
64 account_tbl->user_display_name = EM_SAFE_STRDUP(account->user_display_name);
65 account_tbl->reply_to_address = EM_SAFE_STRDUP(account->reply_to_address);
66 account_tbl->return_address = EM_SAFE_STRDUP(account->return_address);
67 account_tbl->account_id = account->account_id;
68 account_tbl->keep_mails_on_pop_server_after_download = account->keep_mails_on_pop_server_after_download;
69 account_tbl->auto_download_size = account->auto_download_size;
70 account_tbl->outgoing_server_use_same_authenticator = account->outgoing_server_use_same_authenticator;
71 account_tbl->pop_before_smtp = account->pop_before_smtp;
72 account_tbl->incoming_server_requires_apop = account->incoming_server_requires_apop;
73 account_tbl->logo_icon_path = EM_SAFE_STRDUP(account->logo_icon_path);
75 account_tbl->user_data = em_memdup(account->user_data, account->user_data_length);
76 account_tbl->user_data_length = account->user_data_length;
78 account_tbl->options.priority = account->options.priority;
79 account_tbl->options.keep_local_copy = account->options.keep_local_copy;
80 account_tbl->options.req_delivery_receipt = account->options.req_delivery_receipt;
81 account_tbl->options.req_read_receipt = account->options.req_read_receipt;
82 account_tbl->options.download_limit = account->options.download_limit;
83 account_tbl->options.block_address = account->options.block_address;
84 account_tbl->options.block_subject = account->options.block_subject;
85 account_tbl->options.display_name_from = EM_SAFE_STRDUP(account->options.display_name_from);
86 account_tbl->options.reply_with_body = account->options.reply_with_body;
87 account_tbl->options.forward_with_files = account->options.forward_with_files;
88 account_tbl->options.add_myname_card = account->options.add_myname_card;
89 account_tbl->options.add_signature = account->options.add_signature;
90 account_tbl->options.signature = EM_SAFE_STRDUP(account->options.signature);
91 account_tbl->options.add_my_address_to_bcc = account->options.add_my_address_to_bcc;
92 account_tbl->check_interval = account->check_interval;
93 account_tbl->account_svc_id = account->account_svc_id;
94 account_tbl->sync_status = account->sync_status;
95 account_tbl->sync_disabled = account->sync_disabled;
96 account_tbl->default_mail_slot_size = account->default_mail_slot_size;
97 account_tbl->smime_type = account->smime_type;
98 account_tbl->certificate_path = EM_SAFE_STRDUP(account->certificate_path);
99 account_tbl->cipher_type = account->cipher_type;
100 account_tbl->digest_type = account->digest_type;
107 INTERNAL_FUNC int em_convert_account_tbl_to_account(emstorage_account_tbl_t *account_tbl, email_account_t *account)
109 EM_DEBUG_FUNC_BEGIN("account_tbl[%p], account[%p]", account_tbl, account);
112 account->account_name = EM_SAFE_STRDUP(account_tbl->account_name);
113 account->incoming_server_type = account_tbl->incoming_server_type;
114 account->incoming_server_address = EM_SAFE_STRDUP(account_tbl->incoming_server_address);
115 account->user_email_address = EM_SAFE_STRDUP(account_tbl->user_email_address);
116 account->incoming_server_user_name = EM_SAFE_STRDUP(account_tbl->incoming_server_user_name);
117 account->incoming_server_password = EM_SAFE_STRDUP(account_tbl->incoming_server_password);
118 account->retrieval_mode = account_tbl->retrieval_mode;
119 account->incoming_server_port_number = account_tbl->incoming_server_port_number;
120 account->incoming_server_secure_connection = account_tbl->incoming_server_secure_connection;
121 account->outgoing_server_type = account_tbl->outgoing_server_type;
122 account->outgoing_server_address = EM_SAFE_STRDUP(account_tbl->outgoing_server_address);
123 account->outgoing_server_port_number = account_tbl->outgoing_server_port_number;
124 account->outgoing_server_need_authentication = account_tbl->outgoing_server_need_authentication;
125 account->outgoing_server_secure_connection = account_tbl->outgoing_server_secure_connection;
126 account->outgoing_server_user_name = EM_SAFE_STRDUP(account_tbl->outgoing_server_user_name);
127 account->outgoing_server_password = EM_SAFE_STRDUP(account_tbl->outgoing_server_password);
128 account->user_display_name = EM_SAFE_STRDUP(account_tbl->user_display_name);
129 account->reply_to_address = EM_SAFE_STRDUP(account_tbl->reply_to_address);
130 account->return_address = EM_SAFE_STRDUP(account_tbl->return_address);
131 account->account_id = account_tbl->account_id;
132 account->keep_mails_on_pop_server_after_download = account_tbl->keep_mails_on_pop_server_after_download;
133 account->auto_download_size = account_tbl->auto_download_size;
134 account->outgoing_server_use_same_authenticator = account_tbl->outgoing_server_use_same_authenticator;
135 account->pop_before_smtp = account_tbl->pop_before_smtp;
136 account->incoming_server_requires_apop = account_tbl->incoming_server_requires_apop;
137 account->logo_icon_path = EM_SAFE_STRDUP(account_tbl->logo_icon_path);
138 account->user_data = em_memdup(account_tbl->user_data, account_tbl->user_data_length);
139 account->user_data_length = account_tbl->user_data_length;
140 account->options.priority = account_tbl->options.priority;
141 account->options.keep_local_copy = account_tbl->options.keep_local_copy;
142 account->options.req_delivery_receipt = account_tbl->options.req_delivery_receipt;
143 account->options.req_read_receipt = account_tbl->options.req_read_receipt;
144 account->options.download_limit = account_tbl->options.download_limit;
145 account->options.block_address = account_tbl->options.block_address;
146 account->options.block_subject = account_tbl->options.block_subject;
147 account->options.display_name_from = EM_SAFE_STRDUP(account_tbl->options.display_name_from);
148 account->options.reply_with_body = account_tbl->options.reply_with_body;
149 account->options.forward_with_files = account_tbl->options.forward_with_files;
150 account->options.add_myname_card = account_tbl->options.add_myname_card;
151 account->options.add_signature = account_tbl->options.add_signature;
152 account->options.signature = EM_SAFE_STRDUP(account_tbl->options.signature);
153 account->options.add_my_address_to_bcc = account_tbl->options.add_my_address_to_bcc;
154 account->check_interval = account_tbl->check_interval;
155 account->account_svc_id = account_tbl->account_svc_id;
156 account->sync_status = account_tbl->sync_status;
157 account->sync_disabled = account_tbl->sync_disabled;
158 account->default_mail_slot_size = account_tbl->default_mail_slot_size;
159 account->smime_type = account_tbl->smime_type;
160 account->certificate_path = EM_SAFE_STRDUP(account_tbl->certificate_path);
161 account->cipher_type = account_tbl->cipher_type;
162 account->digest_type = account_tbl->digest_type;
168 INTERNAL_FUNC int em_convert_mailbox_to_mailbox_tbl(email_mailbox_t *mailbox, emstorage_mailbox_tbl_t *mailbox_tbl)
170 EM_DEBUG_FUNC_BEGIN("mailbox[%p], mailbox_tbl[%p]", mailbox, mailbox_tbl);
173 mailbox_tbl->account_id = mailbox->account_id;
174 mailbox_tbl->mailbox_id = mailbox->mailbox_id;
175 mailbox_tbl->mailbox_name = EM_SAFE_STRDUP(mailbox->mailbox_name);
176 mailbox_tbl->alias = EM_SAFE_STRDUP(mailbox->alias);
177 mailbox_tbl->local_yn = mailbox->local;
178 mailbox_tbl->mailbox_type = mailbox->mailbox_type;
179 mailbox_tbl->unread_count = mailbox->unread_count;
180 mailbox_tbl->total_mail_count_on_local = mailbox->total_mail_count_on_local;
181 mailbox_tbl->total_mail_count_on_server = mailbox->total_mail_count_on_server;
182 mailbox_tbl->mail_slot_size = mailbox->mail_slot_size;
183 mailbox_tbl->no_select = mailbox->no_select;
184 mailbox_tbl->last_sync_time = mailbox->last_sync_time;
185 mailbox_tbl->deleted_flag = mailbox->deleted_flag;
191 INTERNAL_FUNC int em_convert_mailbox_tbl_to_mailbox(emstorage_mailbox_tbl_t *mailbox_tbl, email_mailbox_t *mailbox)
193 EM_DEBUG_FUNC_BEGIN("mailbox_tbl[%p], mailbox[%p]", mailbox_tbl, mailbox);
196 mailbox->account_id = mailbox_tbl->account_id;
197 mailbox->mailbox_id = mailbox_tbl->mailbox_id;
198 mailbox->mailbox_name = EM_SAFE_STRDUP(mailbox_tbl->mailbox_name);
199 mailbox->alias = EM_SAFE_STRDUP(mailbox_tbl->alias);
200 mailbox->local = mailbox_tbl->local_yn;
201 mailbox->mailbox_type = mailbox_tbl->mailbox_type;
202 mailbox->unread_count = mailbox_tbl->unread_count;
203 mailbox->total_mail_count_on_local = mailbox_tbl->total_mail_count_on_local;
204 mailbox->total_mail_count_on_server = mailbox_tbl->total_mail_count_on_server;
205 mailbox->mail_slot_size = mailbox_tbl->mail_slot_size;
206 mailbox->no_select = mailbox_tbl->no_select;
207 mailbox->last_sync_time = mailbox_tbl->last_sync_time;
208 mailbox->deleted_flag = mailbox_tbl->deleted_flag;
215 INTERNAL_FUNC int em_convert_mail_tbl_to_mail_data(emstorage_mail_tbl_t *mail_table_data, int item_count, email_mail_data_t **mail_data, int *error)
217 EM_DEBUG_FUNC_BEGIN("mail_table_data[%p], item_count [%d], mail_data[%p]", mail_table_data, item_count, mail_data);
218 int i, ret = false, err_code = EMAIL_ERROR_NONE;
219 email_mail_data_t *temp_mail_data = NULL;
221 if (!mail_table_data || !mail_data || !item_count) {
222 EM_DEBUG_EXCEPTION("Invalid parameter");
223 err_code = EMAIL_ERROR_INVALID_PARAM;
227 temp_mail_data = em_malloc(sizeof(email_mail_data_t) * item_count);
229 if(!temp_mail_data) {
230 EM_DEBUG_EXCEPTION("em_malloc failed");
231 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
235 for(i = 0; i < item_count; i++) {
236 temp_mail_data[i].mail_id = mail_table_data[i].mail_id;
237 temp_mail_data[i].account_id = mail_table_data[i].account_id;
238 temp_mail_data[i].mailbox_id = mail_table_data[i].mailbox_id;
239 temp_mail_data[i].mailbox_type = mail_table_data[i].mailbox_type;
240 temp_mail_data[i].subject = EM_SAFE_STRDUP(mail_table_data[i].subject);
241 temp_mail_data[i].date_time = mail_table_data[i].date_time;
242 temp_mail_data[i].server_mail_status = mail_table_data[i].server_mail_status;
243 temp_mail_data[i].server_mailbox_name = EM_SAFE_STRDUP(mail_table_data[i].server_mailbox_name);
244 temp_mail_data[i].server_mail_id = EM_SAFE_STRDUP(mail_table_data[i].server_mail_id);
245 temp_mail_data[i].message_id = EM_SAFE_STRDUP(mail_table_data[i].message_id);
246 temp_mail_data[i].reference_mail_id = mail_table_data[i].reference_mail_id;
247 temp_mail_data[i].full_address_from = EM_SAFE_STRDUP(mail_table_data[i].full_address_from);
248 temp_mail_data[i].full_address_reply = EM_SAFE_STRDUP(mail_table_data[i].full_address_reply);
249 temp_mail_data[i].full_address_to = EM_SAFE_STRDUP(mail_table_data[i].full_address_to);
250 temp_mail_data[i].full_address_cc = EM_SAFE_STRDUP(mail_table_data[i].full_address_cc);
251 temp_mail_data[i].full_address_bcc = EM_SAFE_STRDUP(mail_table_data[i].full_address_bcc);
252 temp_mail_data[i].full_address_return = EM_SAFE_STRDUP(mail_table_data[i].full_address_return);
253 temp_mail_data[i].email_address_sender = EM_SAFE_STRDUP(mail_table_data[i].email_address_sender);
254 temp_mail_data[i].email_address_recipient = EM_SAFE_STRDUP(mail_table_data[i].email_address_recipient);
255 temp_mail_data[i].alias_sender = EM_SAFE_STRDUP(mail_table_data[i].alias_sender);
256 temp_mail_data[i].alias_recipient = EM_SAFE_STRDUP(mail_table_data[i].alias_recipient);
257 temp_mail_data[i].body_download_status = mail_table_data[i].body_download_status;
258 temp_mail_data[i].file_path_plain = EM_SAFE_STRDUP(mail_table_data[i].file_path_plain);
259 temp_mail_data[i].file_path_html = EM_SAFE_STRDUP(mail_table_data[i].file_path_html);
260 temp_mail_data[i].file_path_mime_entity = EM_SAFE_STRDUP(mail_table_data[i].file_path_mime_entity);
261 temp_mail_data[i].mail_size = mail_table_data[i].mail_size;
262 temp_mail_data[i].flags_seen_field = mail_table_data[i].flags_seen_field;
263 temp_mail_data[i].flags_deleted_field = mail_table_data[i].flags_deleted_field;
264 temp_mail_data[i].flags_flagged_field = mail_table_data[i].flags_flagged_field;
265 temp_mail_data[i].flags_answered_field = mail_table_data[i].flags_answered_field;
266 temp_mail_data[i].flags_recent_field = mail_table_data[i].flags_recent_field;
267 temp_mail_data[i].flags_draft_field = mail_table_data[i].flags_draft_field;
268 temp_mail_data[i].flags_forwarded_field = mail_table_data[i].flags_forwarded_field;
269 temp_mail_data[i].DRM_status = mail_table_data[i].DRM_status;
270 temp_mail_data[i].priority = mail_table_data[i].priority;
271 temp_mail_data[i].save_status = mail_table_data[i].save_status;
272 temp_mail_data[i].lock_status = mail_table_data[i].lock_status;
273 temp_mail_data[i].report_status = mail_table_data[i].report_status;
274 temp_mail_data[i].attachment_count = mail_table_data[i].attachment_count;
275 temp_mail_data[i].inline_content_count = mail_table_data[i].inline_content_count;
276 temp_mail_data[i].thread_id = mail_table_data[i].thread_id;
277 temp_mail_data[i].thread_item_count = mail_table_data[i].thread_item_count;
278 temp_mail_data[i].preview_text = EM_SAFE_STRDUP(mail_table_data[i].preview_text);
279 temp_mail_data[i].meeting_request_status = mail_table_data[i].meeting_request_status;
280 temp_mail_data[i].message_class = mail_table_data[i].message_class;
281 temp_mail_data[i].digest_type = mail_table_data[i].digest_type;
282 temp_mail_data[i].smime_type = mail_table_data[i].smime_type;
283 temp_mail_data[i].scheduled_sending_time = mail_table_data[i].scheduled_sending_time;
284 temp_mail_data[i].eas_data_length = mail_table_data[i].eas_data_length;
285 if(mail_table_data[i].eas_data_length && mail_table_data[i].eas_data) {
286 if((temp_mail_data[i].eas_data = em_malloc(mail_table_data[i].eas_data_length)) == NULL) {
287 EM_DEBUG_EXCEPTION("em_malloc failed");
288 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
292 memcpy(temp_mail_data[i].eas_data, mail_table_data[i].eas_data, mail_table_data[i].eas_data_length);
295 *mail_data = temp_mail_data;
300 if(ret == false && temp_mail_data) {
301 emcore_free_mail_data_list(&temp_mail_data, item_count);
312 INTERNAL_FUNC int em_convert_mail_data_to_mail_tbl(email_mail_data_t *mail_data, int item_count, emstorage_mail_tbl_t **mail_table_data, int *error)
314 EM_DEBUG_FUNC_BEGIN("mail_data[%p], item_count [%d], mail_table_data[%p]", mail_data, item_count, mail_table_data);
315 int i, ret = false, err_code = EMAIL_ERROR_NONE;
316 emstorage_mail_tbl_t *temp_mail_tbl = NULL;
318 if (!mail_data || !mail_table_data || !item_count) {
319 EM_DEBUG_EXCEPTION("Invalid parameter");
320 err_code = EMAIL_ERROR_INVALID_PARAM;
324 temp_mail_tbl = em_malloc(sizeof(emstorage_mail_tbl_t) * item_count);
327 EM_DEBUG_EXCEPTION("em_malloc failed");
328 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
332 for(i = 0; i < item_count; i++) {
333 temp_mail_tbl[i].mail_id = mail_data[i].mail_id;
334 temp_mail_tbl[i].account_id = mail_data[i].account_id;
335 temp_mail_tbl[i].mailbox_id = mail_data[i].mailbox_id;
336 temp_mail_tbl[i].mailbox_type = mail_data[i].mailbox_type;
337 temp_mail_tbl[i].date_time = mail_data[i].date_time;
338 temp_mail_tbl[i].subject = EM_SAFE_STRDUP(mail_data[i].subject);
339 temp_mail_tbl[i].server_mail_status = mail_data[i].server_mail_status;
340 temp_mail_tbl[i].server_mailbox_name = EM_SAFE_STRDUP(mail_data[i].server_mailbox_name);
341 temp_mail_tbl[i].server_mail_id = EM_SAFE_STRDUP(mail_data[i].server_mail_id);
342 temp_mail_tbl[i].message_id = EM_SAFE_STRDUP(mail_data[i].message_id);
343 temp_mail_tbl[i].reference_mail_id = mail_data[i].reference_mail_id;
344 temp_mail_tbl[i].full_address_from = EM_SAFE_STRDUP(mail_data[i].full_address_from);
345 temp_mail_tbl[i].full_address_reply = EM_SAFE_STRDUP(mail_data[i].full_address_reply);
346 temp_mail_tbl[i].full_address_to = EM_SAFE_STRDUP(mail_data[i].full_address_to);
347 temp_mail_tbl[i].full_address_cc = EM_SAFE_STRDUP(mail_data[i].full_address_cc);
348 temp_mail_tbl[i].full_address_bcc = EM_SAFE_STRDUP(mail_data[i].full_address_bcc);
349 temp_mail_tbl[i].full_address_return = EM_SAFE_STRDUP(mail_data[i].full_address_return);
350 temp_mail_tbl[i].email_address_sender = EM_SAFE_STRDUP(mail_data[i].email_address_sender);
351 temp_mail_tbl[i].email_address_recipient = EM_SAFE_STRDUP(mail_data[i].email_address_recipient);
352 temp_mail_tbl[i].alias_sender = EM_SAFE_STRDUP(mail_data[i].alias_sender);
353 temp_mail_tbl[i].alias_recipient = EM_SAFE_STRDUP(mail_data[i].alias_recipient);
354 temp_mail_tbl[i].body_download_status = mail_data[i].body_download_status;
355 temp_mail_tbl[i].file_path_plain = EM_SAFE_STRDUP(mail_data[i].file_path_plain);
356 temp_mail_tbl[i].file_path_html = EM_SAFE_STRDUP(mail_data[i].file_path_html);
357 temp_mail_tbl[i].file_path_mime_entity = EM_SAFE_STRDUP(mail_data[i].file_path_mime_entity);
358 temp_mail_tbl[i].mail_size = mail_data[i].mail_size;
359 temp_mail_tbl[i].flags_seen_field = mail_data[i].flags_seen_field;
360 temp_mail_tbl[i].flags_deleted_field = mail_data[i].flags_deleted_field;
361 temp_mail_tbl[i].flags_flagged_field = mail_data[i].flags_flagged_field;
362 temp_mail_tbl[i].flags_answered_field = mail_data[i].flags_answered_field;
363 temp_mail_tbl[i].flags_recent_field = mail_data[i].flags_recent_field;
364 temp_mail_tbl[i].flags_draft_field = mail_data[i].flags_draft_field;
365 temp_mail_tbl[i].flags_forwarded_field = mail_data[i].flags_forwarded_field;
366 temp_mail_tbl[i].DRM_status = mail_data[i].DRM_status;
367 temp_mail_tbl[i].priority = mail_data[i].priority;
368 temp_mail_tbl[i].save_status = mail_data[i].save_status;
369 temp_mail_tbl[i].lock_status = mail_data[i].lock_status;
370 temp_mail_tbl[i].report_status = mail_data[i].report_status;
371 temp_mail_tbl[i].attachment_count = mail_data[i].attachment_count;
372 temp_mail_tbl[i].inline_content_count = mail_data[i].inline_content_count;
373 temp_mail_tbl[i].thread_id = mail_data[i].thread_id;
374 temp_mail_tbl[i].thread_item_count = mail_data[i].thread_item_count;
375 temp_mail_tbl[i].preview_text = EM_SAFE_STRDUP(mail_data[i].preview_text);
376 temp_mail_tbl[i].meeting_request_status = mail_data[i].meeting_request_status;
377 temp_mail_tbl[i].message_class = mail_data[i].message_class;
378 temp_mail_tbl[i].digest_type = mail_data[i].digest_type;
379 temp_mail_tbl[i].smime_type = mail_data[i].smime_type;
380 temp_mail_tbl[i].scheduled_sending_time = mail_data[i].scheduled_sending_time;
381 temp_mail_tbl[i].eas_data_length = mail_data[i].eas_data_length;
382 if(mail_data[i].eas_data_length && mail_data[i].eas_data) {
383 if((temp_mail_tbl[i].eas_data = em_malloc(mail_data[i].eas_data_length)) == NULL) {
384 EM_DEBUG_EXCEPTION("em_malloc failed");
385 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
388 emstorage_free_mail(&temp_mail_tbl, i, NULL);
390 EM_SAFE_FREE(temp_mail_tbl);
394 memcpy(temp_mail_tbl[i].eas_data, mail_data[i].eas_data, mail_data[i].eas_data_length);
397 *mail_table_data = temp_mail_tbl;
412 INTERNAL_FUNC int em_convert_string_to_time_t(char *input_datetime_string, time_t *output_time)
414 EM_DEBUG_FUNC_BEGIN("input_datetime_string[%s], output_time[%p]", input_datetime_string, output_time);
416 char buf[16] = { 0, };
417 struct tm temp_time_info = { 0 };
419 if (!input_datetime_string || !output_time) {
420 EM_DEBUG_EXCEPTION("input_datetime_string[%p], output_time[%p]", input_datetime_string, output_time);
421 return EMAIL_ERROR_INVALID_PARAM;
424 memset(buf, 0x00, sizeof(buf));
425 SNPRINTF(buf, sizeof(buf), "%.4s", input_datetime_string);
426 temp_time_info.tm_year = atoi(buf) - 1970;
428 memset(buf, 0x00, sizeof(buf));
429 SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 4);
430 temp_time_info.tm_mon = atoi(buf) - 1;
432 memset(buf, 0x00, sizeof(buf));
433 SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 6);
434 temp_time_info.tm_mday = atoi(buf);
436 memset(buf, 0x00, sizeof(buf));
437 SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 8);
438 temp_time_info.tm_hour = atoi(buf);
440 memset(buf, 0x00, sizeof(buf));
441 SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 10);
442 temp_time_info.tm_min = atoi(buf);
444 memset(buf, 0x00, sizeof(buf));
445 SNPRINTF(buf, sizeof(buf), "%.2s", input_datetime_string + 12);
446 temp_time_info.tm_sec = atoi(buf);
448 *output_time = timegm(&temp_time_info);
450 EM_DEBUG_LOG("*output_time [%d", *output_time);
452 EM_DEBUG_FUNC_END("err %d", EMAIL_ERROR_NONE);
453 return EMAIL_ERROR_NONE;
456 INTERNAL_FUNC int em_convert_time_t_to_string(time_t *input_time, char **output_datetime_string)
458 EM_DEBUG_FUNC_BEGIN("input_time[%p], output_datetime_string[%p]", input_time, output_datetime_string);
459 char temp_buffer[20] = { 0, };
460 struct tm *temp_time_info;
462 if (!input_time || !output_datetime_string) {
463 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
464 return EMAIL_ERROR_INVALID_PARAM;
467 temp_time_info = localtime(input_time);
469 if(!temp_time_info) {
470 EM_DEBUG_EXCEPTION("localtime failed.");
471 return EMAIL_ERROR_SYSTEM_FAILURE;
473 SNPRINTF(temp_buffer, sizeof(temp_buffer), "%04d%02d%02d%02d%02d%02d",
474 temp_time_info->tm_year + 1970, temp_time_info->tm_mon, temp_time_info->tm_mday, temp_time_info->tm_hour, temp_time_info->tm_min, temp_time_info->tm_sec);
476 *output_datetime_string = EM_SAFE_STRDUP(temp_buffer);
478 EM_DEBUG_FUNC_END("err %d", EMAIL_ERROR_NONE);
479 return EMAIL_ERROR_NONE;
482 static char* append_sized_data_to_stream(char *stream, int *stream_len, char *src, int src_len)
484 /* EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_length [%p], input_sized_data [%p], input_data_size [%d]", input_stream, input_output_stream_length, input_sized_data, input_data_size); */
485 char *new_stream = NULL;
487 if( !stream_len || src_len == 0 || src == NULL || (stream != NULL && *stream_len == 0) ||
488 (stream == NULL && *stream_len != 0) ) {
489 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
493 int old_stream_len = *stream_len;
495 /*TODO: don't increase stream buffer incrementally when appending new data */
496 new_stream = (char*)em_malloc(old_stream_len + src_len);
499 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
504 memcpy(new_stream, stream, old_stream_len);
506 memcpy(new_stream + old_stream_len, src, src_len);
508 *stream_len = old_stream_len + src_len;
510 EM_SAFE_FREE(stream);
511 /* EM_DEBUG_FUNC_END("*input_output_stream_length [%d]", *input_output_stream_length); */
516 static char* append_string_to_stream(char *input_stream, int *input_output_stream_length, char *input_source_string)
518 EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_length [%p] input_source_string[%p]", input_stream, input_output_stream_length, input_source_string);
519 char *new_stream = NULL;
522 if( !input_output_stream_length || (input_stream != NULL && *input_output_stream_length == 0) ||
523 (input_stream == NULL && *input_output_stream_length != 0) ) {
524 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
528 int source_stream_length = *input_output_stream_length;
530 data_length = EM_SAFE_STRLEN(input_source_string);
532 new_stream = (char*)em_malloc(source_stream_length + data_length + sizeof(int));
535 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
539 if(input_stream != NULL)
540 memcpy(new_stream, input_stream, source_stream_length);
542 /* write string length */
543 memcpy(new_stream + source_stream_length, (char*)&data_length, sizeof(int));
546 if(input_source_string)
547 memcpy(new_stream + source_stream_length + sizeof(int), input_source_string, data_length);
549 /* for example, "abc" is written to stream buffer with "3abc" */
550 *input_output_stream_length = source_stream_length + sizeof(int) + data_length;
552 EM_SAFE_FREE(input_stream);
553 EM_DEBUG_FUNC_END("*input_output_stream_length [%d]", *input_output_stream_length);
557 static int fetch_sized_data_from_stream(char *input_stream, int *input_output_stream_offset, int input_data_size, char *output_data)
559 /* EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_offset [%p] input_data_size [%d], output_data[%p]", input_stream, input_output_stream_offset, input_data_size, output_data); */
560 int stream_offset = 0;
562 if( !input_stream || !input_output_stream_offset || !input_data_size || !output_data) {
563 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
564 return EMAIL_ERROR_INVALID_PARAM;
567 stream_offset = *input_output_stream_offset;
569 memcpy(output_data, input_stream + stream_offset, input_data_size);
570 stream_offset += input_data_size;
572 *input_output_stream_offset = stream_offset;
574 /* EM_DEBUG_FUNC_END("stream_offset [%d]", stream_offset); */
575 return EMAIL_ERROR_NONE;
579 static int fetch_string_from_stream(char *input_stream, int *input_output_stream_offset, char **output_string)
581 /* EM_DEBUG_FUNC_BEGIN("input_stream [%p], input_output_stream_offset [%p] output_string[%p]", input_stream, input_output_stream_offset, output_string); */
582 int string_length = 0;
583 int stream_offset = 0;
584 char *result_string = NULL;
586 if( !input_stream || !input_output_stream_offset || !output_string) {
587 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
588 return EMAIL_ERROR_INVALID_PARAM;
591 stream_offset = *input_output_stream_offset;
592 /* EM_DEBUG_LOG("stream_offset [%d]", stream_offset); */
594 memcpy(&string_length, input_stream + stream_offset, sizeof(int));
595 stream_offset += sizeof(int);
597 /* EM_DEBUG_LOG("string_length [%d]", string_length); */
599 if(string_length != 0) {
600 result_string = (char*)em_malloc(string_length + 1);
602 memcpy(result_string, input_stream + stream_offset, string_length);
603 stream_offset += string_length;
608 EM_DEBUG_LOG("result_string [%s]", result_string);
611 *output_string = result_string;
612 *input_output_stream_offset = stream_offset;
614 /* EM_DEBUG_FUNC_END("stream_offset [%d]", stream_offset); */
615 return EMAIL_ERROR_NONE;
617 /* divide struct at binary field (void* user_data)*/
618 #define EMAIL_ACCOUNT_FMT "S(" "isiii" "is" ")" "B" "S(" "issss" "isiss" "iiiii" "isiss" "iii"\
619 "$(" "iiiii" "iisii" "iisi" ")" "iiisii" ")"
622 INTERNAL_FUNC char* em_convert_account_to_byte_stream(email_account_t* account, int *stream_len)
625 EM_IF_NULL_RETURN_VALUE(account, NULL);
630 tn = tpl_map(EMAIL_ACCOUNT_FMT, account, &tb, &(account->user_data_length));
631 tb.sz = account->user_data_length;
632 tb.addr = account->user_data;
635 /* write account to buffer */
638 tpl_dump(tn, TPL_MEM, &buf, &len);
647 INTERNAL_FUNC void em_convert_byte_stream_to_account(char *stream, int stream_len, email_account_t *account)
650 EM_NULL_CHECK_FOR_VOID(stream);
651 EM_NULL_CHECK_FOR_VOID(account);
656 tn = tpl_map(EMAIL_ACCOUNT_FMT, account, &tb, &(account->user_data_length));
657 tpl_load(tn, TPL_MEM, stream, stream_len);
661 /* tb will be destroyed at end of func, but tb.addr remains */
662 account->user_data = tb.addr;
667 #define EMAIL_MAIL_DATA_FMT "S(" "iiiis" "iisss" "issss" "sssss" "sisss"\
668 "icccc" "cccii" "iiiii" "iisii" "iiii)B"
670 INTERNAL_FUNC char* em_convert_mail_data_to_byte_stream(email_mail_data_t *mail_data, int *stream_len)
672 EM_DEBUG_FUNC_BEGIN("mail_data[%p] stream_len[%p]", mail_data, stream_len);
673 EM_IF_NULL_RETURN_VALUE(mail_data, NULL);
674 EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
679 EM_DEBUG_LOG("eas_data_length[%d]", mail_data->eas_data_length); /*prevent 44369*/
681 tn = tpl_map(EMAIL_MAIL_DATA_FMT, mail_data, &tb);
682 tb.sz = mail_data->eas_data_length;
683 tb.addr = mail_data->eas_data;
686 /* write account to buffer */
689 tpl_dump(tn, TPL_MEM, &buf, &len);
697 INTERNAL_FUNC void em_convert_byte_stream_to_mail_data(char *stream, int stream_len, email_mail_data_t *mail_data)
699 EM_DEBUG_FUNC_BEGIN("stream[%p] stream_len[%d] mail_data[%p]", stream, stream_len, mail_data);
700 EM_NULL_CHECK_FOR_VOID(stream);
701 EM_NULL_CHECK_FOR_VOID(mail_data);
706 tn = tpl_map(EMAIL_MAIL_DATA_FMT, mail_data, &tb);
708 EM_DEBUG_EXCEPTION("tpl_map failed");
712 tpl_load(tn, TPL_MEM, stream, stream_len);
715 if(mail_data->eas_data_length <= 0 || tb.addr == NULL) {
716 EM_DEBUG_LOG("No eas data. eas_data_length[%d] addr[%p]", mail_data->eas_data_length, tb.addr);
719 EM_DEBUG_LOG("eas_data_length[%d] addr[%p]", mail_data->eas_data_length, tb.addr);
720 mail_data->eas_data = tb.addr;
730 #define EMAIL_ATTACHMENT_DATA_FMT "A(S(" "issii" "iciii" "s" "))"
732 INTERNAL_FUNC char* em_convert_attachment_data_to_byte_stream(email_attachment_data_t *attachment, int attachment_count, int* stream_len)
734 EM_DEBUG_FUNC_BEGIN();
735 EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
737 EM_DEBUG_LOG("no attachment to be included");
743 email_attachment_data_t cur = {0};
746 /* tpl_map adds value at 2nd param addr to packing buffer iterately */
747 /* 2nd param value (not addr via pointer) should be modified at each iteration */
748 tn = tpl_map(EMAIL_ATTACHMENT_DATA_FMT, &cur);
750 for( ; i < attachment_count ; i++ ) {
751 memcpy(&cur, attachment+i, sizeof(cur)); /* copy data to cur : swallow copy */
752 tpl_pack(tn, 1); /* pack data at &cur: deep copy */
755 /* write data to buffer */
758 tpl_dump(tn, TPL_MEM, &buf, &len);
763 EM_DEBUG_LOG("stream_len: %d", len);
769 INTERNAL_FUNC void em_convert_byte_stream_to_attachment_data(char *stream, int stream_len, email_attachment_data_t **attachment_data, int *attachment_count)
771 EM_DEBUG_FUNC_BEGIN();
772 EM_NULL_CHECK_FOR_VOID(stream);
773 EM_NULL_CHECK_FOR_VOID(attachment_data);
774 EM_NULL_CHECK_FOR_VOID(attachment_count);
777 email_attachment_data_t cur = {0};
779 tn = tpl_map(EMAIL_ATTACHMENT_DATA_FMT, &cur);
780 tpl_load(tn, TPL_MEM, stream, stream_len);
782 /* tpl does not return the size of variable-length array, but we need variable-length array */
783 /* so, make list and get list count in the first phase, */
784 /* and then copy list to var array after allocating memory */
787 while( tpl_unpack(tn, 1) > 0) {
788 email_attachment_data_t* pdata = (email_attachment_data_t*) em_malloc(sizeof(email_attachment_data_t));
789 memcpy(pdata, &cur, sizeof(email_attachment_data_t)); /* copy unpacked data to list item */
790 head = g_list_prepend(head, pdata); /* add it to list */
791 memset(&cur, 0, sizeof(email_attachment_data_t)); /* initialize variable, used for unpacking */
796 /*finally we get the list count and allocate var length array */
797 email_attachment_data_t *attached = (email_attachment_data_t*) em_malloc(sizeof(email_attachment_data_t)*count);
799 /*write glist item into variable array*/
800 head = g_list_reverse(head);
801 GList *p = g_list_first(head);
803 for( ; p ; p = g_list_next(p), i++ ) {
804 email_attachment_data_t* pdata = (email_attachment_data_t*) g_list_nth_data(p, 0);
805 memcpy( attached+i, pdata, sizeof(email_attachment_data_t));
806 EM_SAFE_FREE(pdata); /*now, list item is useless */
811 *attachment_count = count;
812 *attachment_data = attached;
817 #define EMAIL_MAILBOX_FMT "S(" "isisi" "iiiii" "i" ")"
819 INTERNAL_FUNC char* em_convert_mailbox_to_byte_stream(email_mailbox_t *mailbox_data, int *stream_len)
821 EM_DEBUG_FUNC_BEGIN();
822 EM_IF_NULL_RETURN_VALUE(mailbox_data, NULL);
823 EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
827 tn = tpl_map(EMAIL_MAILBOX_FMT, mailbox_data);
830 /* write account to buffer */
833 tpl_dump(tn, TPL_MEM, &buf, &len);
837 EM_DEBUG_FUNC_END("serialized len: %d", len);
842 INTERNAL_FUNC void em_convert_byte_stream_to_mailbox(char *stream, int stream_len, email_mailbox_t *mailbox_data)
844 EM_DEBUG_FUNC_BEGIN();
845 EM_NULL_CHECK_FOR_VOID(stream);
846 EM_NULL_CHECK_FOR_VOID(mailbox_data);
850 tn = tpl_map(EMAIL_MAILBOX_FMT, mailbox_data);
851 tpl_load(tn, TPL_MEM, stream, stream_len);
855 EM_DEBUG_FUNC_END("deserialized len %d", stream_len);
858 #define EMAIL_OPTION_FMT "S(" "iiiii" "iisii" "iisi" ")"
860 INTERNAL_FUNC char* em_convert_option_to_byte_stream(email_option_t* option, int* stream_len)
862 EM_DEBUG_FUNC_BEGIN();
863 EM_IF_NULL_RETURN_VALUE(option, NULL);
864 EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
868 tn = tpl_map(EMAIL_OPTION_FMT, option);
871 /* write account to buffer */
874 tpl_dump(tn, TPL_MEM, &buf, &len);
878 EM_DEBUG_FUNC_END("serialized len: %d", len);
882 INTERNAL_FUNC void em_convert_byte_stream_to_option(char *stream, int stream_len, email_option_t *option)
884 EM_DEBUG_FUNC_BEGIN();
885 EM_NULL_CHECK_FOR_VOID(stream);
886 EM_NULL_CHECK_FOR_VOID(option);
890 tn = tpl_map(EMAIL_OPTION_FMT, option);
891 tpl_load(tn, TPL_MEM, stream, stream_len);
895 EM_DEBUG_FUNC_END("deserialized len %d", stream_len);
899 #define EMAIL_RULE_FMT "S(" "iiisi" "iii" ")"
901 INTERNAL_FUNC char* em_convert_rule_to_byte_stream(email_rule_t *rule, int *stream_len)
903 EM_DEBUG_FUNC_BEGIN();
904 EM_IF_NULL_RETURN_VALUE(rule, NULL);
905 EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
909 tn = tpl_map(EMAIL_RULE_FMT, rule);
912 /* write account to buffer */
915 tpl_dump(tn, TPL_MEM, &buf, &len);
919 EM_DEBUG_FUNC_END("serialized len: %d", len);
923 INTERNAL_FUNC void em_convert_byte_stream_to_rule(char *stream, int stream_len, email_rule_t *rule)
925 EM_DEBUG_FUNC_BEGIN();
926 EM_NULL_CHECK_FOR_VOID(stream);
927 EM_NULL_CHECK_FOR_VOID(rule);
931 tn = tpl_map(EMAIL_RULE_FMT, rule);
932 tpl_load(tn, TPL_MEM, stream, stream_len);
936 EM_DEBUG_FUNC_END("deserialized len %d", stream_len);
939 #define EMAIL_MEETING_REQUEST_FMT "iiBBs" "sic#Bi" "c#Bi"
941 INTERNAL_FUNC char* em_convert_meeting_req_to_byte_stream(email_meeting_request_t *meeting_req, int *stream_len)
945 EM_IF_NULL_RETURN_VALUE(meeting_req, NULL);
950 tn = tpl_map(EMAIL_MEETING_REQUEST_FMT,
951 &meeting_req->mail_id,
952 &meeting_req->meeting_response,
955 &meeting_req->location,
956 &meeting_req->global_object_id,
957 &meeting_req->time_zone.offset_from_GMT,
958 meeting_req->time_zone.standard_name, 32,
960 &meeting_req->time_zone.standard_bias,
961 meeting_req->time_zone.daylight_name, 32,
963 &meeting_req->time_zone.daylight_bias
965 tb[0].sz = tb[1].sz = tb[2].sz = tb[3].sz = sizeof(struct tm);
966 tb[0].addr = &meeting_req->start_time;
967 tb[1].addr = &meeting_req->end_time;
968 tb[2].addr = &meeting_req->time_zone.standard_time_start_date;
969 tb[3].addr = &meeting_req->time_zone.daylight_time_start_date;
974 /* write account to buffer */
977 tpl_dump(tn, TPL_MEM, &buf, &len);
986 INTERNAL_FUNC void em_convert_byte_stream_to_meeting_req(char *stream, int stream_len, email_meeting_request_t *meeting_req)
989 EM_NULL_CHECK_FOR_VOID(stream);
990 EM_NULL_CHECK_FOR_VOID(meeting_req);
995 tn = tpl_map(EMAIL_MEETING_REQUEST_FMT,
996 &meeting_req->mail_id,
997 &meeting_req->meeting_response,
1000 &meeting_req->location,
1001 &meeting_req->global_object_id,
1002 &meeting_req->time_zone.offset_from_GMT,
1003 meeting_req->time_zone.standard_name, 32,
1005 &meeting_req->time_zone.standard_bias,
1006 meeting_req->time_zone.daylight_name, 32,
1008 &meeting_req->time_zone.daylight_bias
1010 tpl_load(tn, TPL_MEM, stream, stream_len);
1014 /* tb will be destroyed at end of func, but tb.addr remains */
1015 memcpy(&meeting_req->start_time, tb[0].addr, sizeof(struct tm));
1016 memcpy(&meeting_req->end_time, tb[1].addr, sizeof(struct tm));
1017 memcpy(&meeting_req->time_zone.standard_time_start_date, tb[2].addr, sizeof(struct tm));
1018 memcpy(&meeting_req->time_zone.daylight_time_start_date, tb[3].addr, sizeof(struct tm));
1021 for(i=0; i< 4 ; i++)
1022 EM_SAFE_FREE(tb[i].addr);
1024 EM_DEBUG_FUNC_END();
1027 INTERNAL_FUNC char* em_convert_search_filter_to_byte_stream(email_search_filter_t *input_search_filter_list,
1028 int input_search_filter_count, int *output_stream_size)
1030 EM_DEBUG_FUNC_BEGIN("input_search_filter_list [%p] input_search_filter_count [%d]", input_search_filter_list, input_search_filter_count);
1032 char *result_stream = NULL;
1033 int stream_size = 0;
1036 EM_IF_NULL_RETURN_VALUE(input_search_filter_list, NULL);
1038 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_count), sizeof(int));
1040 for( i = 0; i < input_search_filter_count; i++) {
1041 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_type), sizeof(int));
1042 switch(input_search_filter_list->search_filter_type) {
1043 case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO :
1044 case EMAIL_SEARCH_FILTER_TYPE_UID :
1045 case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER :
1046 case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER :
1047 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED :
1048 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED :
1049 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT :
1050 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED :
1051 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT :
1052 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN :
1053 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_key_value.integer_type_key_value), sizeof(int));
1056 case EMAIL_SEARCH_FILTER_TYPE_BCC :
1057 case EMAIL_SEARCH_FILTER_TYPE_CC :
1058 case EMAIL_SEARCH_FILTER_TYPE_FROM :
1059 case EMAIL_SEARCH_FILTER_TYPE_KEYWORD :
1060 case EMAIL_SEARCH_FILTER_TYPE_SUBJECT :
1061 case EMAIL_SEARCH_FILTER_TYPE_TO :
1062 case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID :
1063 result_stream = append_string_to_stream(result_stream, &stream_size, input_search_filter_list->search_filter_key_value.string_type_key_value);
1066 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE :
1067 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON :
1068 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE :
1069 result_stream = append_sized_data_to_stream(result_stream, &stream_size, (char*)&(input_search_filter_list->search_filter_key_value.time_type_key_value), sizeof(struct tm));
1072 EM_DEBUG_EXCEPTION("Invalid filter type [%d]", input_search_filter_list->search_filter_type);
1077 *output_stream_size = stream_size;
1079 EM_DEBUG_FUNC_END();
1080 return result_stream;
1083 INTERNAL_FUNC void em_convert_byte_stream_to_search_filter(char *input_stream,
1084 email_search_filter_t **output_search_filter_list, int *output_search_filter_count)
1086 EM_DEBUG_FUNC_BEGIN("input_stream [%p] output_search_filter_list [%p] output_search_filter_count [%p]", input_stream, output_search_filter_list, output_search_filter_count);
1088 int stream_offset = 0;
1090 int local_search_filter_count = 0;
1091 email_search_filter_t *local_search_filter = NULL;
1093 EM_NULL_CHECK_FOR_VOID(input_stream);
1094 EM_NULL_CHECK_FOR_VOID(output_search_filter_list);
1095 EM_NULL_CHECK_FOR_VOID(output_search_filter_count);
1097 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter_count));
1099 if(local_search_filter_count == 0) {
1100 EM_DEBUG_EXCEPTION("local_search_filter_count is 0.");
1104 local_search_filter = em_malloc(sizeof(email_search_filter_t) * local_search_filter_count);
1106 if(local_search_filter == NULL) {
1107 EM_DEBUG_EXCEPTION("em_malloc for local_search_filter failed");
1111 *output_search_filter_count = local_search_filter_count;
1113 for( i = 0; i < local_search_filter_count; i++) {
1114 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter[i].search_filter_type));
1115 switch(local_search_filter[i].search_filter_type) {
1116 case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_NO :
1117 case EMAIL_SEARCH_FILTER_TYPE_UID :
1118 case EMAIL_SEARCH_FILTER_TYPE_SIZE_LARSER :
1119 case EMAIL_SEARCH_FILTER_TYPE_SIZE_SMALLER :
1120 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_ANSWERED :
1121 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DELETED :
1122 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_DRAFT :
1123 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_FLAGED :
1124 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_RECENT :
1125 case EMAIL_SEARCH_FILTER_TYPE_FLAGS_SEEN :
1126 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(int), (char*)&(local_search_filter[i].search_filter_key_value.integer_type_key_value));
1129 case EMAIL_SEARCH_FILTER_TYPE_BCC :
1130 case EMAIL_SEARCH_FILTER_TYPE_CC :
1131 case EMAIL_SEARCH_FILTER_TYPE_FROM :
1132 case EMAIL_SEARCH_FILTER_TYPE_KEYWORD :
1133 case EMAIL_SEARCH_FILTER_TYPE_SUBJECT :
1134 case EMAIL_SEARCH_FILTER_TYPE_TO :
1135 case EMAIL_SEARCH_FILTER_TYPE_MESSAGE_ID :
1136 fetch_string_from_stream(input_stream, &stream_offset, &(local_search_filter[i].search_filter_key_value.string_type_key_value));
1139 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_BEFORE :
1140 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_ON :
1141 case EMAIL_SEARCH_FILTER_TYPE_SENT_DATE_SINCE :
1142 fetch_sized_data_from_stream(input_stream, &stream_offset, sizeof(time_t), (char*)&(local_search_filter[i].search_filter_key_value.time_type_key_value));
1145 EM_DEBUG_EXCEPTION("Invalid filter type [%d]", local_search_filter[i].search_filter_type);
1150 *output_search_filter_list = local_search_filter;
1154 EM_DEBUG_FUNC_END();
1158 #define EMAIL_JOB_INFORMATION_FMT "A(S(iiii))"
1160 INTERNAL_FUNC char* em_convert_task_information_to_byte_stream(email_task_information_t *input_task_information, int input_task_information_count, int *stream_len)
1162 EM_DEBUG_FUNC_BEGIN("input_task_information[%p] input_task_information_count[%d] stream_len[%p]", input_task_information, input_task_information_count, stream_len);
1163 EM_IF_NULL_RETURN_VALUE(input_task_information, NULL);
1164 EM_IF_NULL_RETURN_VALUE(stream_len, NULL);
1166 email_task_information_t cur = {0};
1167 tpl_node *tn = NULL;
1170 tn = tpl_map(EMAIL_JOB_INFORMATION_FMT, &cur);
1172 for( ; i < input_task_information_count ; i++ ) {
1173 memcpy(&cur, input_task_information + i, sizeof(email_task_information_t));
1177 /* write data to buffer */
1180 tpl_dump(tn, TPL_MEM, &buf, &len);
1185 EM_DEBUG_FUNC_END("serialized len: %d", len);
1189 INTERNAL_FUNC void em_convert_byte_stream_to_task_information(char *input_stream, int input_stream_len, email_task_information_t **output_task_information, int *output_task_information_count)
1191 EM_DEBUG_FUNC_BEGIN("input_stream[%p] input_stream_len[%d] output_task_information[%p] output_task_information_count[%p]", input_stream, input_stream_len, output_task_information, output_task_information_count);
1192 EM_NULL_CHECK_FOR_VOID(input_stream);
1193 EM_NULL_CHECK_FOR_VOID(output_task_information);
1195 email_task_information_t cur = {0};
1196 tpl_node *tn = NULL;
1201 tn = tpl_map(EMAIL_JOB_INFORMATION_FMT, &cur);
1202 tpl_load(tn, TPL_MEM, input_stream, input_stream_len);
1204 while( tpl_unpack(tn, 1) > 0) {
1205 email_task_information_t* pdata = (email_task_information_t*) em_malloc(sizeof(email_task_information_t));
1206 memcpy(pdata, &cur, sizeof(email_task_information_t));
1207 head = g_list_prepend(head, pdata);
1208 memset(&cur, 0, sizeof(email_task_information_t));
1213 email_task_information_t *deserialized = (email_task_information_t*) em_malloc(sizeof(email_task_information_t)*count);
1215 head = g_list_reverse(head);
1216 GList *p = g_list_first(head);
1218 for( ; p ; p = g_list_next(p), i++ ) {
1219 email_task_information_t* pdata = (email_task_information_t*) g_list_nth_data(p, 0);
1220 memcpy( deserialized+i, pdata, sizeof(email_task_information_t));
1221 EM_SAFE_FREE(pdata);
1226 *output_task_information_count = count;
1227 *output_task_information = deserialized;
1229 EM_DEBUG_FUNC_END();
1232 INTERNAL_FUNC int em_convert_certificate_tbl_to_certificate(emstorage_certificate_tbl_t *certificate_tbl, email_certificate_t **certificate, int *error)
1234 EM_DEBUG_FUNC_BEGIN("certficate_tbl[%p], certificate[%p]", certificate_tbl, certificate);
1236 int err_code = EMAIL_ERROR_NONE;
1238 email_certificate_t *temp_certificate = NULL;
1240 if (!certificate_tbl || !certificate) {
1241 EM_DEBUG_EXCEPTION("Invalid parameter");
1242 err_code = EMAIL_ERROR_INVALID_PARAM;
1246 temp_certificate = em_malloc(sizeof(email_certificate_t)) ;
1247 if (!temp_certificate) {
1248 EM_DEBUG_EXCEPTION("em_malloc failed");
1249 err_code = EMAIL_ERROR_OUT_OF_MEMORY;
1253 temp_certificate->certificate_id = certificate_tbl->certificate_id;
1254 temp_certificate->issue_year = certificate_tbl->issue_year;
1255 temp_certificate->issue_month = certificate_tbl->issue_month;
1256 temp_certificate->issue_day = certificate_tbl->issue_day;
1257 temp_certificate->expiration_year = certificate_tbl->expiration_year;
1258 temp_certificate->expiration_month = certificate_tbl->expiration_month;
1259 temp_certificate->expiration_day = certificate_tbl->expiration_day;
1260 temp_certificate->issue_organization_name = EM_SAFE_STRDUP(certificate_tbl->issue_organization_name);
1261 temp_certificate->email_address = EM_SAFE_STRDUP(certificate_tbl->email_address);
1262 temp_certificate->subject_str = EM_SAFE_STRDUP(certificate_tbl->subject_str);
1263 temp_certificate->filepath = EM_SAFE_STRDUP(certificate_tbl->filepath);
1265 *certificate = temp_certificate;
1272 EM_DEBUG_FUNC_END();
1276 INTERNAL_FUNC int em_convert_certificate_to_certificate_tbl(email_certificate_t *certificate, emstorage_certificate_tbl_t *certificate_tbl)
1278 EM_DEBUG_FUNC_BEGIN("certficate[%p], certificate_tbl[%p]", certificate, certificate_tbl);
1280 certificate_tbl->certificate_id = certificate->certificate_id;
1281 certificate_tbl->issue_year = certificate->issue_year;
1282 certificate_tbl->issue_month = certificate->issue_month;
1283 certificate_tbl->issue_day = certificate->issue_day;
1284 certificate_tbl->expiration_year = certificate->expiration_year;
1285 certificate_tbl->expiration_month = certificate->expiration_month;
1286 certificate_tbl->expiration_day = certificate->expiration_day;
1287 certificate_tbl->issue_organization_name = EM_SAFE_STRDUP(certificate->issue_organization_name);
1288 certificate_tbl->email_address = EM_SAFE_STRDUP(certificate->email_address);
1289 certificate_tbl->subject_str = EM_SAFE_STRDUP(certificate->subject_str);
1290 certificate_tbl->filepath = EM_SAFE_STRDUP(certificate->filepath);
1292 EM_DEBUG_FUNC_END();