map-agent/bluetooth_map_email.c

   1 /*
   2  * Bluetooth-agent
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Syam Sidhardhan <s.syam@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include "email-types.h"
  25 #include "email-api-init.h"
  26 #include "email-api-account.h"
  27 #include "email-api-mailbox.h"
  28 #include "email-api-mail.h"
  29 #include "email-api-network.h"
  30 #include <email-api.h>
  31
  32 #include <bluetooth_map_agent.h>
  33 #include <map_bmessage.h>
  34
  35 #include <glib.h>
  36 #include <gio/gio.h>
  37 #include <stdlib.h>
  38 #ifdef ARCH64
  39 #include <stdint.h>
  40 #endif
  41
  42 #define BT_MAIL_ID_MAX_LENGTH 50
  43 #define BT_MAP_TIMESTAMP_MAX_LEN 16
  44 #define BT_MAIL_TEMP_BODY "/tmp/bt_mail.txt"
  45 #define BT_MAP_MSG_HANDLE_MAX 21
  46 #define BT_EMAIL_STORAGE_INTERFACE "User.Email.StorageChange"
  47 #define BT_EMAIL_STORAGE_PATH "/User/Email/StorageChange"
  48 #define BT_EMAIL_STORAGE_SIGNAL "email"
  49
  50 #define BEGIN_BMSEG "BEGIN:BMSG\r\n"
  51 #define END_BMSEG "END:BMSG\r\n"
  52 #define BMSEG_VERSION "VERSION:1.0\r\n"
  53 #define MSEG_STATUS "STATUS:%s\r\n"
  54 #define MSEG_TYPE "TYPE:%s\r\n"
  55 #define FOLDER_PATH "FOLDER:%s\r\n"
  56 #define EMAIL_VCARD "BEGIN:VCARD\r\nVERSION:2.1\r\nN:%s\r\nEMAIL:%s\r\nEND:VCARD\r\n"
  57 #define BEGIN_BENV "BEGIN:BENV\r\n"
  58 #define END_BENV "END:BENV\r\n"
  59 #define BEGIN_BBODY "BEGIN:BBODY\r\n"
  60 #define END_BBODY "END:BBODY\r\n"
  61 #define ENCODING "ENCODING:%s\r\n"
  62 #define CHARSET "CHARSET:%s\r\n"
  63 #define LANGUAGE "LANGUAGE:%s\r\n"
  64 #define LENGTH "LENGTH:%d\r\n"
  65 #define MSG_BODY "BEGIN:MSG\r\n%s\r\nEND:MSG\r\n"
  66 #define MSG_BODY_BEGIN "BEGIN:MSG\r\n"
  67 #define MSG_BODY_END "\r\nEND:MSG\r\n"
  68
  69 extern guint64 current_push_map_id;
  70
  71 /* LCOV_EXCL_START */
  72 static void __bt_map_parse_moved_mails(char *inbuf, int *from_box_id,
  73                                 int *to_box_id, GList **mail_list)
  74 {
  75         if (!inbuf)
  76                 return;
  77
  78         DBG("inbuf = %s", inbuf);
  79
  80         /* notification format: <from_box_id><0x01><to_box_id><0x01><<mail_id><,><mail_id>>*/
  81         gchar **outer_tok;
  82         char delimiter[2] = { 0x01, 0x00 };
  83         outer_tok = g_strsplit_set(inbuf, delimiter, -1);
  84         if (outer_tok == NULL) {
  85                 ERR("outer_tok == NULL");
  86                 return;
  87         }
  88         if (outer_tok[0] && strlen(outer_tok[0]) > 0)
  89                 *from_box_id = atoi(outer_tok[0]);
  90         if (outer_tok[1] && strlen(outer_tok[1]) > 0)
  91                 *to_box_id = atoi(outer_tok[1]);
  92         if (outer_tok[2] && strlen(outer_tok[2]) > 0) {
  93                 gchar **inner_tok;
  94                 inner_tok = g_strsplit_set(outer_tok[2], ",", -1);
  95                 if (g_strv_length(inner_tok) == 1) { // only one mail_id exists without ","
  96                         int mail_id = atoi(outer_tok[2]);
  97 #ifdef ARCH64
  98                         *mail_list = g_list_append(*mail_list, (void *)(uintptr_t) mail_id);
  99 #else
 100                         *mail_list = g_list_append(*mail_list, (void *) mail_id);
 101 #endif
 102                 } else {
 103                         int i;
 104                         for (i = 0; i < g_strv_length(inner_tok); ++i) {
 105                                 if (!strcmp(inner_tok[i], "\"")) /* skip the empty token */
 106                                         continue;
 107                                 else {
 108                                         int mail_id = atoi(inner_tok[i]);
 109 #ifdef ARCH64
 110                                         *mail_list = g_list_prepend(*mail_list, (void *)(uintptr_t) mail_id);
 111 #else
 112                                         *mail_list = g_list_prepend(*mail_list, (void *) mail_id);
 113 #endif
 114                                 }
 115                         }
 116                 }
 117                 g_strfreev(inner_tok);
 118         }
 119         g_strfreev(outer_tok);
 120
 121         *mail_list = g_list_reverse(*mail_list);
 122 }
 123
 124 char *__bt_email_get_path(int mailboxtype)
 125 {
 126         switch (mailboxtype) {
 127         case EMAIL_MAILBOX_TYPE_INBOX:
 128                 return g_strdup("TELECOM/MSG/INBOX");
 129         case EMAIL_MAILBOX_TYPE_SENTBOX:
 130                 return g_strdup("TELECOM/MSG/SENT");
 131         case EMAIL_MAILBOX_TYPE_TRASH:
 132                 return g_strdup("TELECOM/MSG/DELETED");
 133         case EMAIL_MAILBOX_TYPE_DRAFT:
 134                 return g_strdup("TELECOM/MSG/DRAFT");
 135         case EMAIL_MAILBOX_TYPE_OUTBOX:
 136                 return g_strdup("TELECOM/MSG/OUTBOX");
 137         }
 138         return g_strdup("");
 139 }
 140
 141 static void __bt_email_subscription_callback(GDBusConnection *connection,
 142                 const gchar *sender_name, const gchar *object_path,
 143                 const gchar *interface_name, const gchar *signal_name,
 144                 GVariant *parameters, gpointer data)
 145 {
 146         int subtype = 0;
 147         int data1 = 0;
 148         int data2 = 0;
 149         char *data3 = NULL;
 150         int data4 = 0;
 151
 152         g_variant_get(parameters, "(iii&si)", &subtype, &data1,
 153                         &data2, &data3, &data4);
 154
 155         if ((g_strcmp0(object_path, BT_EMAIL_STORAGE_PATH)) ||
 156                         (g_strcmp0(signal_name, BT_EMAIL_STORAGE_SIGNAL)))
 157                 return;
 158
 159         if (subtype == NOTI_MAIL_ADD) {
 160                 /* Received values from Signal*/
 161                 int account_id = data1;
 162                 int mailid = data2;
 163                 int mailbox_id = atoi(data3);
 164                 /* Fetch Values */
 165                 int default_account_id = -1;
 166                 email_mailbox_t *mailbox = NULL;
 167                 guint64 handle;
 168
 169                 DBG("Mail Added[AccountID: %d, MailID:%d, MailBoxID:%d]",
 170                                 account_id, mailid, mailbox_id);
 171
 172                 if (email_load_default_account_id(&default_account_id)
 173                                                 != EMAIL_ERROR_NONE) {
 174                         ERR("Could not load default account");
 175                         return;
 176                 }
 177                 DBG("Default account_id: %d", default_account_id);
 178                 if (default_account_id != account_id) {
 179                         ERR("Event not meant for default email account");
 180                         return;
 181                 }
 182
 183                 if (email_get_mailbox_by_mailbox_id(mailbox_id,
 184                                 &mailbox) != EMAIL_ERROR_NONE) {
 185                         ERR("Could not get mailbox info");
 186                         return;
 187                 }
 188
 189                 handle = _bt_add_id(mailid, BT_MAP_ID_EMAIL);
 190                 if (mailbox) {
 191                         if (mailbox->mailbox_type == EMAIL_MAILBOX_TYPE_INBOX) {
 192                                 _bt_mns_client_event_notify("NewMessage", handle,
 193                                                 "TELECOM/MSG/INBOX", "",
 194                                                 "EMAIL");
 195                         }
 196                         email_free_mailbox(&mailbox, 1);
 197                 }
 198
 199         } else if (subtype == NOTI_MAIL_MOVE_FINISH) {
 200                 /* Received values from Signal*/
 201                 /* DATA1[account_id] DATA2[move_type] DATA4[??]
 202                  * DATA3[mailbox_id0x01updated_value0x01mail_id] */
 203                 int account_id = data1;
 204                 int from_mailbox_id = -1;
 205                 int to_mailbox_id = -1;
 206                 GList *mail_ids = NULL;
 207
 208                 /* Fetch Values */
 209                 int default_account_id = -1;
 210                 email_mailbox_t *mailbox_from = NULL;
 211                 email_mailbox_t *mailbox_to = NULL;
 212                 guint64 handle;
 213
 214                 __bt_map_parse_moved_mails(data3, &from_mailbox_id,
 215                                         &to_mailbox_id, &mail_ids);
 216
 217                 DBG("Mail Moved[AccountID:%d From:%d, To:%d]", account_id,
 218                                 from_mailbox_id, to_mailbox_id);
 219
 220                 if (email_load_default_account_id(&default_account_id)
 221                                                 != EMAIL_ERROR_NONE) {
 222                         ERR("Could not load default account");
 223                         return;
 224                 }
 225                 DBG("Default account_id: %d", default_account_id);
 226                 if (default_account_id != account_id) {
 227                         ERR("Event not meant for default email account");
 228                         return;
 229                 }
 230                 if (email_get_mailbox_by_mailbox_id(from_mailbox_id, &mailbox_from)
 231                                                         != EMAIL_ERROR_NONE) {
 232                         ERR("Could not get mailbox info");
 233                         return;
 234                 }
 235                 if (email_get_mailbox_by_mailbox_id(to_mailbox_id, &mailbox_to)
 236                                                         != EMAIL_ERROR_NONE) {
 237                         ERR("Could not get mailbox info");
 238                         if (from_mailbox_id)
 239                                 email_free_mailbox(&mailbox_from, 1);
 240                         return;
 241                 }
 242
 243                 if (mailbox_to->mailbox_type == EMAIL_MAILBOX_TYPE_TRASH) {
 244                         while (mail_ids) {
 245 #ifdef ARCH64
 246                                 int mailid = (int)(uintptr_t)(void*) mail_ids->data;
 247 #else
 248                                 int mailid = (int) mail_ids->data;
 249 #endif
 250                                 char *old_folder;
 251                                 DBG("Mail ID[%d]", mailid);
 252                                 if (mailid == 0)
 253                                         break;
 254
 255                                 old_folder = __bt_email_get_path(mailbox_from->mailbox_type);
 256                                 handle = _bt_add_id(mailid, BT_MAP_ID_EMAIL);
 257                                 DBG("[MessageDeleted] Handle:%llu", (unsigned long long int)handle);
 258                                 _bt_mns_client_event_notify("MessageShift", handle,
 259                                                 "TELECOM/MSG/DELETED", old_folder, "EMAIL");
 260                                 g_free(old_folder);
 261                                 mail_ids = g_list_next(mail_ids);
 262                         }
 263                 } else if (mailbox_to->mailbox_type == EMAIL_MAILBOX_TYPE_SENTBOX
 264                                 && mailbox_from->mailbox_type == EMAIL_MAILBOX_TYPE_OUTBOX) {
 265                         while (mail_ids) {
 266 #ifdef ARCH64
 267                                 int mailid = (int)(uintptr_t)(void*) mail_ids->data;
 268 #else
 269                                 int mailid = (int) mail_ids->data;
 270 #endif
 271                                 DBG("Mail ID[%d]", mailid);
 272                                 if (mailid == 0)
 273                                         break;
 274
 275                                 handle = _bt_add_id(mailid, BT_MAP_ID_EMAIL);
 276                                 DBG("[SendingSuccess] Handle:%llu", (unsigned long long int)handle);
 277
 278                                 _bt_mns_client_event_notify("MessageShift", handle,
 279                                                 "TELECOM/MSG/SENT", "TELECOM/MSG/OUTBOX", "EMAIL");
 280
 281                                 _bt_mns_client_event_notify("SendingSuccess", handle,
 282                                                 "TELECOM/MSG/SENT", "", "EMAIL");
 283                                 mail_ids = g_list_next(mail_ids);
 284                         }
 285                 }
 286
 287                 email_free_mailbox(&mailbox_to, 1);
 288                 email_free_mailbox(&mailbox_from, 1);
 289         }
 290 }
 291 /* LCOV_EXCL_STOP */
 292
 293 gboolean _bt_map_start_email_service(void)
 294 {
 295         int err;
 296         GDBusConnection *dbus_conn = NULL;
 297         GError *error = NULL;
 298         int signal_handler_storage = -1;
 299         err = email_service_begin();
 300         if (err != EMAIL_ERROR_NONE) {
 301                 ERR("email_service_begin fail  error = %d\n", err);
 302                 return FALSE;
 303         }
 304
 305         /* LCOV_EXCL_START */
 306         dbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 307         if (error) {
 308                 ERR("g_bus_get_sync() failed (%s)", error->message);
 309                 g_error_free(error);
 310                 email_service_end();
 311                 return FALSE;
 312         }
 313
 314         signal_handler_storage = g_dbus_connection_signal_subscribe(dbus_conn,
 315                         NULL, BT_EMAIL_STORAGE_INTERFACE, BT_EMAIL_STORAGE_SIGNAL,
 316                         BT_EMAIL_STORAGE_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
 317                         __bt_email_subscription_callback, NULL, NULL);
 318
 319         if (signal_handler_storage == -1) {
 320                 ERR("Failed to g_dbus_connection_signal_subscribe()");
 321                 g_object_unref(dbus_conn);
 322                 email_service_end();
 323                 return FALSE;
 324         }
 325
 326         /* LCOV_EXCL_STOP */
 327         return TRUE;
 328 }
 329
 330 gboolean _bt_map_stop_email_service(void)
 331 {
 332         int err;
 333
 334         err = email_service_end();
 335         if (err != EMAIL_ERROR_NONE) {
 336                 /* LCOV_EXCL_START */
 337                 ERR("email_service_end fail  error = %d\n", err);
 338                 return FALSE;
 339                 /* LCOV_EXCL_STOP */
 340         }
 341
 342         return TRUE;
 343 }
 344
 345 gboolean _bt_map_email_get_supported_folders(gboolean folders[FOLDER_COUNT][MSG_TYPES])
 346 {
 347         DBG("");
 348         int account_id = 0;
 349         int mailbox_count = 0;
 350         int err;
 351         int i;
 352         email_mailbox_t *mailbox_list = NULL;
 353         email_mailbox_t *temp = NULL;
 354
 355         err = email_load_default_account_id(&account_id);
 356         if (err != EMAIL_ERROR_NONE)
 357                 return FALSE;
 358
 359         /* LCOV_EXCL_START */
 360         err = email_get_mailbox_list(account_id, EMAIL_MAILBOX_ALL,
 361                                 &mailbox_list, &mailbox_count);
 362         if (err != EMAIL_ERROR_NONE)
 363                 return FALSE;
 364
 365         DBG("Count: %d", mailbox_count);
 366         for (i = 0, temp = mailbox_list; i < mailbox_count; i++, temp++) {
 367                 DBG("Folder:%s", temp->mailbox_name);
 368                 if (!g_ascii_strncasecmp(temp->mailbox_name, "SENT", strlen("SENT"))) {
 369                         folders[BT_MSG_SENT][BT_MSG_SOURCE_EMAIL] = TRUE;
 370                         DBG("SENT");
 371                 } else if (!g_ascii_strncasecmp(temp->mailbox_name, "DRAFT", strlen("DRAFT"))) {
 372                         folders[BT_MSG_DRAFT][BT_MSG_SOURCE_EMAIL] = TRUE;
 373                         DBG("DRAFT");
 374                 } else if (!g_ascii_strncasecmp(temp->mailbox_name, "DELETED", strlen("DELETED")) ||
 375                                 !g_ascii_strncasecmp(temp->mailbox_name, "TRASH", strlen("TRASH"))) {
 376                         folders[BT_MSG_DELETED][BT_MSG_SOURCE_EMAIL] = TRUE;
 377                         DBG("DELETED");
 378                 } else if (!g_ascii_strncasecmp(temp->mailbox_name, "INBOX", strlen("INBOX"))) {
 379                         folders[BT_MSG_INBOX][BT_MSG_SOURCE_EMAIL] = TRUE;
 380                         DBG("INBOX");
 381                 } else if (!g_ascii_strncasecmp(temp->mailbox_name, "OUTBOX", strlen("OUTBOX"))) {
 382                         folders[BT_MSG_OUTBOX][BT_MSG_SOURCE_EMAIL] = TRUE;
 383                         DBG("OUTBOX");
 384                 } else if (!g_ascii_strncasecmp(temp->mailbox_name, "[gmail]", strlen("[gmail]"))) {
 385                         DBG("GMAIL Folder");
 386                         if (!g_ascii_strncasecmp(temp->mailbox_name, "[Gmail]/Drafts", strlen("[Gmail]/Drafts"))) {
 387                                 folders[BT_MSG_DRAFT][BT_MSG_SOURCE_EMAIL] = TRUE;
 388                                 DBG("[Gmail]/DRAFT");
 389                         } else if (!g_ascii_strncasecmp(temp->mailbox_name, "[Gmail]/Sent", strlen("[Gmail]/Sent"))) {
 390                                 folders[BT_MSG_SENT][BT_MSG_SOURCE_EMAIL] = TRUE;
 391                                 DBG("[Gmail]/SENT");
 392                         } else if (!g_ascii_strncasecmp(temp->mailbox_name, "[Gmail]/Trash", strlen("[Gmail]/Trash"))) {
 393                                 folders[BT_MSG_DELETED][BT_MSG_SOURCE_EMAIL] = TRUE;
 394                                 DBG("[Gmail]/Trash");
 395                         }
 396                 }
 397         }
 398
 399         if (mailbox_list != NULL)
 400                 email_free_mailbox(&mailbox_list, mailbox_count);
 401
 402         /* LCOV_EXCL_STOP */
 403         return TRUE;
 404 }
 405
 406 /* LCOV_EXCL_START */
 407 static message_info_t *__bt_email_info_get(email_mail_list_item_t *email_struct,
 408                                                         guint8 subject_len)
 409 {
 410         message_info_t *email_info = NULL;
 411         email_mail_data_t *mail_data;
 412         guint64 uid = 0;
 413         time_t dptime;
 414         char email_handle[BT_MAP_MSG_HANDLE_MAX] = {0,};
 415         char msg_datetime[BT_MAP_TIMESTAMP_MAX_LEN] = {0,};
 416         email_info = g_new0(message_info_t, 1);
 417
 418         uid = _bt_add_id(email_struct->mail_id, BT_MAP_ID_EMAIL);
 419 #ifdef ARCH64
 420         snprintf(email_handle, sizeof(email_handle), "%lx", uid);
 421 #else
 422         snprintf(email_handle, sizeof(email_handle), "%llx", uid);
 423 #endif
 424         DBG("******* MAP ID:%llu, MailID:%d **********", (unsigned long long int)uid, email_struct->mail_id);
 425         email_info->handle = g_strdup(email_handle);
 426
 427         dptime = email_struct->date_time;
 428         _get_msg_timestamp(&dptime, msg_datetime);
 429
 430         email_info->sender_name = g_strdup(email_struct->email_address_sender);
 431         email_info->sender_addressing = g_strdup(email_struct->email_address_sender);
 432         email_info->recipient_name = g_strdup(email_struct->email_address_recipient);
 433         email_info->recipient_addressing = g_strdup(email_struct->email_address_recipient);
 434
 435         email_info->subject = g_strndup(email_struct->subject, subject_len);
 436         email_info->datetime = g_strdup(msg_datetime);
 437         email_info->time = dptime; // for sorting
 438         email_info->type = g_strdup("EMAIL");
 439         email_info->size = g_strdup_printf("%d", email_struct->mail_size);
 440         email_info->reception_status = g_strdup("complete");
 441         email_info->attachment_size = g_strdup("0");
 442         email_info->replyto_addressing = g_strdup(
 443                         email_struct->email_address_sender);
 444
 445         DBG("Seen Status: %d", email_struct->flags_seen_field);
 446         if (email_struct->flags_seen_field)
 447                 email_info->read = TRUE;
 448         else
 449                 email_info->read = FALSE;
 450
 451         DBG("Priority: %d", email_struct->priority);
 452         if (email_struct->priority == EMAIL_MAIL_PRIORITY_HIGH)
 453                 email_info->priority = TRUE;
 454         else
 455                 email_info->priority = FALSE;
 456
 457         email_info->text = FALSE;
 458         email_info->protect = FALSE;
 459
 460         if (email_get_mail_data(email_struct->mail_id, &mail_data) != EMAIL_ERROR_NONE) {
 461                 ERR("email_get_mail_data failed\n");
 462                 return email_info;
 463         }
 464
 465         if (mail_data->alias_sender) {
 466                 g_free(email_info->sender_name);
 467                 email_info->sender_name = g_strdup(mail_data->alias_sender);
 468         }
 469
 470         if (mail_data->alias_recipient) {
 471                 g_free(email_info->recipient_name);
 472                 email_info->recipient_name = g_strdup(mail_data->alias_recipient);
 473         }
 474
 475         if (mail_data->email_address_recipient) {
 476                 g_free(email_info->recipient_addressing);
 477                 email_info->recipient_addressing = g_strdup(mail_data->email_address_recipient);
 478         }
 479
 480         return email_info;
 481 }
 482
 483 static gboolean __bt_map_email_compare_folders(char *alias, char *folder)
 484 {
 485         DBG("Folder:%s, Alias:%s", folder, alias);
 486
 487         char *map_folder = NULL;
 488
 489         if (!g_ascii_strncasecmp(alias, "SENT", strlen("SENT"))) {
 490                 map_folder = "SENT";
 491         } else if (!g_ascii_strncasecmp(alias, "DRAFT", strlen("DRAFT"))) {
 492                 map_folder = "DRAFT";
 493         } else if (!g_ascii_strncasecmp(alias, "DELETED", strlen("DELETED")) ||
 494                         !g_ascii_strncasecmp(alias, "TRASH", strlen("TRASH"))) {
 495                 map_folder = "DELETED";
 496         } else if (!g_ascii_strncasecmp(alias, "INBOX", strlen("INBOX"))) {
 497                 map_folder = "INBOX";
 498         } else if (!g_ascii_strncasecmp(alias, "OUTBOX", strlen("OUTBOX"))) {
 499                 map_folder = "OUTBOX";
 500         } else if (!g_ascii_strncasecmp(alias, "[gmail]", strlen("[gmail]"))) {
 501                 DBG("GMAIL Folders");
 502                 if (!g_ascii_strncasecmp(alias, "[Gmail]/Drafts", strlen("[Gmail]/Drafts")))
 503                         map_folder = "DRAFT";
 504                 else if (!g_ascii_strncasecmp(alias, "[Gmail]/Sent", strlen("[Gmail]/Sent")))
 505                         map_folder = "SENT";
 506                 else if (!g_ascii_strncasecmp(alias, "[Gmail]/Trash", strlen("[Gmail]/Trash")))
 507                         map_folder = "DELETED";
 508         }
 509
 510         if (map_folder && g_ascii_strcasecmp(map_folder, folder) == 0) {
 511                 DBG("Equivalent MAP Folder for Alias: %s", map_folder);
 512                 return TRUE;
 513         }
 514
 515         return FALSE;
 516 }
 517
 518 gboolean _bt_map_get_email_list(char *folder, int max,
 519                 guint8 subject_len, map_msg_filter_t *filter,
 520                 GSList **email_list, guint64 *count, gboolean *newmsg)
 521 {
 522         DBG("");
 523         int i;
 524         int ret;
 525         int total = 0;
 526         int account_id = 0;
 527         int mailbox_count = 0;
 528         int mail_count = 0;
 529         int msg_count = 0;
 530         char *type = NULL;
 531
 532         email_mailbox_t *mailbox_list = NULL;
 533         email_mail_list_item_t *mail_list = NULL;
 534         email_mail_list_item_t *temp = NULL;
 535         email_list_filter_t *filter_list = NULL;
 536         email_list_sorting_rule_t *sorting_rule_list = NULL;
 537         GSList *list = NULL;
 538
 539         if (max == 0)
 540                 max = 1024;
 541
 542         ret = email_load_default_account_id(&account_id);
 543         if (ret != EMAIL_ERROR_NONE)
 544                 return FALSE;
 545         DBG("Account ID:%d", account_id);
 546
 547         ret = email_get_mailbox_list(account_id, EMAIL_MAILBOX_ALL,
 548                                         &mailbox_list, &mailbox_count);
 549         if (ret != EMAIL_ERROR_NONE || mailbox_list == NULL)
 550                 return FALSE;
 551
 552         for (i = 0; i < mailbox_count; i++) {
 553                 DBG("mailbox alias = %s \n", mailbox_list[i].alias);
 554                 /* Optimize using mailbox_type */
 555                 if (__bt_map_email_compare_folders(mailbox_list[i].mailbox_name, folder)) {
 556                         total = mailbox_list[i].total_mail_count_on_server;
 557                         DBG("Total mail on sever:%d\n", total);
 558                         DBG("mailbox name:%s\n", mailbox_list[i].mailbox_name);
 559                         DBG("mailbox ID:%d\n", mailbox_list[i].mailbox_id);
 560                         break;
 561                 }
 562         }
 563         DBG("");
 564         if (total == 0) {
 565                 email_free_mailbox(&mailbox_list, mailbox_count);
 566                 return FALSE;
 567         }
 568         DBG("");
 569         filter_list = g_new0(email_list_filter_t, 3);
 570         filter_list[0].list_filter_item_type = EMAIL_LIST_FILTER_ITEM_RULE;
 571         filter_list[0].list_filter_item.rule.target_attribute = EMAIL_MAIL_ATTRIBUTE_ACCOUNT_ID;
 572         filter_list[0].list_filter_item.rule.rule_type = EMAIL_LIST_FILTER_RULE_EQUAL;
 573         filter_list[0].list_filter_item.rule.key_value.integer_type_value = account_id;
 574
 575         filter_list[1].list_filter_item_type = EMAIL_LIST_FILTER_ITEM_OPERATOR;
 576         filter_list[1].list_filter_item.operator_type = EMAIL_LIST_FILTER_OPERATOR_AND;
 577
 578         filter_list[2].list_filter_item_type = EMAIL_LIST_FILTER_ITEM_RULE;
 579         filter_list[2].list_filter_item.rule.target_attribute = EMAIL_MAIL_ATTRIBUTE_MAILBOX_ID;
 580         filter_list[2].list_filter_item.rule.rule_type = EMAIL_LIST_FILTER_RULE_EQUAL;
 581         filter_list[2].list_filter_item.rule.key_value.integer_type_value = mailbox_list[i].mailbox_id;
 582         DBG("mailbox ID:%d\n", mailbox_list[i].mailbox_id);
 583
 584         sorting_rule_list = g_new0(email_list_sorting_rule_t, 1);
 585         sorting_rule_list[0].target_attribute = EMAIL_MAIL_ATTRIBUTE_DATE_TIME;
 586         sorting_rule_list[0].sort_order = EMAIL_SORT_ORDER_DESCEND;
 587         sorting_rule_list[0].force_boolean_check = false;
 588
 589         ret = email_get_mail_list_ex(filter_list, 3, sorting_rule_list, 1, -1,
 590                         -1, &mail_list, &mail_count);
 591         if (ret != EMAIL_ERROR_NONE) {
 592                 DBG("Error Code:%d", ret);
 593                 g_free(type);
 594                 g_free(filter_list);
 595                 g_free(sorting_rule_list);
 596                 return FALSE;
 597         }
 598
 599         DBG("Mail Count: %d", mail_count);
 600         max = (max > mail_count) ? (mail_count) : max;
 601         DBG("Max:%d", max);
 602         for (i = 0, temp = mail_list; i < mail_count && msg_count < max; ++i, temp++) {
 603                 message_info_t *email_info;
 604
 605                 email_info = __bt_email_info_get(temp, subject_len);
 606
 607                 if (!_bt_verify_read_status(email_info, filter->read_status) ||
 608                                 !_bt_verify_receiver(email_info, filter->recipient) ||
 609                                 !_bt_verify_sender(email_info, filter->originator) ||
 610                                 !_bt_verify_time(email_info, filter) ||
 611                                 !_bt_filter_priority(email_info, filter->priority) ||
 612                                 !_bt_validate_msg_data(email_info)) {
 613                         _bt_message_info_free((gpointer)email_info);
 614                         continue;
 615                 }
 616
 617                 list = g_slist_append(list, email_info);
 618                 msg_count++;
 619         }
 620
 621         *count = (guint64)mail_count;
 622         *email_list = list;
 623
 624         email_free_mailbox(&mailbox_list, mailbox_count);
 625
 626         if (mail_list)
 627                 free(mail_list);
 628
 629         g_free(filter_list);
 630         g_free(sorting_rule_list);
 631         g_free(type);
 632         DBG("EXIT");
 633         return TRUE;
 634 }
 635 /* LCOV_EXCL_STOP */
 636
 637 gboolean _bt_map_update_mailbox(char *folder)
 638 {
 639         int handle;
 640         int ret;
 641
 642         ret = email_sync_header_for_all_account(&handle);
 643         if (ret == EMAIL_ERROR_NONE) {
 644                 DBG("Handle to stop download = %d \n", handle);
 645         } else {
 646                 ERR("Message Update failed \n");
 647                 return FALSE;
 648         }
 649
 650         return TRUE;
 651 }
 652
 653 gboolean _bt_map_set_email_read_status(int mail_id, int read_status)
 654 {
 655         int ret;
 656         email_mail_data_t *mail_data = NULL;
 657
 658         ret = email_get_mail_data(mail_id, &mail_data);
 659         if (ret != EMAIL_ERROR_NONE) {
 660                 ERR("email_get_mail_data failed\n"); /* LCOV_EXCL_LINE */
 661                 return FALSE;
 662         }
 663
 664         /* LCOV_EXCL_START */
 665         ret = email_set_flags_field(mail_data->account_id, &mail_id, 1,
 666                                 EMAIL_FLAGS_SEEN_FIELD, read_status, 0);
 667         if (ret != EMAIL_ERROR_NONE) {
 668                 email_free_mail_data(&mail_data, 1);
 669                 return FALSE;
 670         }
 671
 672         email_free_mail_data(&mail_data, 1);
 673         /* LCOV_EXCL_STOP */
 674         return TRUE;
 675 }
 676
 677 gboolean _bt_map_set_email_delete_status(int mail_id, int read_status)
 678 {
 679         int ret;
 680         email_mail_data_t *mail_data = NULL;
 681
 682         ret = email_get_mail_data(mail_id, &mail_data);
 683         if (ret != EMAIL_ERROR_NONE)
 684                 return FALSE;
 685
 686         /* LCOV_EXCL_START */
 687         ret = email_delete_mail(mail_data->mailbox_id, &mail_id, 1, 1);
 688         if (ret != EMAIL_ERROR_NONE) {
 689                 email_free_mail_data(&mail_data, 1);
 690                 return FALSE;
 691         }
 692
 693         email_free_mail_data(&mail_data, 1);
 694         /* LCOV_EXCL_STOP */
 695         return TRUE;
 696 }
 697
 698 /* LCOV_EXCL_START */
 699 static gchar *__bt_get_email_folder_name(int mailboxtype)
 700 {
 701         switch (mailboxtype) {
 702         case EMAIL_MAILBOX_TYPE_SENTBOX:
 703                 return g_strdup("TELECOM/MSG/SENT");
 704         case EMAIL_MAILBOX_TYPE_TRASH:
 705                 return g_strdup("TELECOM/MSG/DELETED");
 706         case EMAIL_MAILBOX_TYPE_OUTBOX:
 707                 return g_strdup("TELECOM/MSG/OUTBOX");
 708         case EMAIL_MAILBOX_TYPE_DRAFT:
 709                 return g_strdup("TELECOM/MSG/DRAFT");
 710         default:
 711                 return g_strdup("TELECOM/MSG/INBOX");
 712         }
 713 }
 714
 715 static char *__bt_prepare_email_bmseg(email_mail_data_t *mail_data)
 716 {
 717         FN_START;
 718         char *folder = NULL;
 719         FILE *body_file;
 720         long read_size;
 721         long email_size;
 722         GString *msg;
 723         char *buf = NULL;
 724
 725         msg = g_string_new(BEGIN_BMSEG);
 726         g_string_append(msg, BMSEG_VERSION);
 727
 728         DBG("Seen Flag: %d", mail_data->flags_seen_field);
 729         if (mail_data->flags_seen_field)
 730                 g_string_append_printf(msg, MSEG_STATUS, "READ");
 731         else
 732                 g_string_append_printf(msg, MSEG_STATUS, "UNREAD");
 733
 734         g_string_append_printf(msg, MSEG_TYPE, "EMAIL");
 735
 736         folder = __bt_get_email_folder_name(mail_data->mailbox_type);
 737         g_string_append_printf(msg, FOLDER_PATH, folder);
 738         g_free(folder);
 739
 740         /* List of recepient & sender */
 741         DBG("Sender: %s", mail_data->email_address_sender);
 742         DBG("Sender Alias: %s", mail_data->alias_sender);
 743         g_string_append_printf(msg, EMAIL_VCARD, mail_data->email_address_sender,
 744                         mail_data->email_address_sender);
 745
 746         g_string_append(msg, BEGIN_BENV);
 747         g_string_append(msg, BEGIN_BBODY);
 748
 749
 750         g_string_append_printf(msg, CHARSET, "UTF-8");
 751         g_string_append_printf(msg, ENCODING, "8BIT");
 752         DBG("Plain Message file: %s", mail_data->file_path_plain);
 753         DBG("HTML Message file: %s", mail_data->file_path_html);
 754         body_file = fopen(mail_data->file_path_plain, "r");
 755         if (body_file == NULL) {
 756                 DBG("NOT PLAIN TEXT MESSAGE");
 757                 body_file = fopen(mail_data->file_path_html, "rb");
 758         }
 759
 760         if (body_file != NULL) {
 761                 fseek(body_file, 0, SEEK_END);
 762                 email_size = ftell(body_file);
 763                 if (email_size <= 0) {
 764                         ERR("email_size is not a positive number");
 765                         g_string_free(msg, TRUE);
 766                         fclose(body_file);
 767                         return NULL;
 768                 }
 769                 rewind(body_file);
 770
 771                 buf = (char *)g_malloc0(sizeof(char) * (email_size + 1));
 772                 read_size = fread(buf, 1, email_size, body_file);
 773                 fclose(body_file);
 774                 DBG("MESSAGE: [%s]", buf);
 775                 if (read_size != email_size) {
 776                         ERR("Unequal Read size");
 777                         g_string_free(msg, TRUE);
 778                         g_free(buf);
 779                         return NULL;
 780                 }
 781         } else {
 782                 DBG("BODY of the MESSAGE NOT FOUND");
 783                 buf = (char *)g_strdup("");
 784         }
 785 #ifdef ARCH64
 786         g_string_append_printf(msg, LENGTH, (int)(unsigned int)strlen(buf));
 787 #else
 788         g_string_append_printf(msg, LENGTH, strlen(buf));
 789 #endif
 790         g_string_append_printf(msg, MSG_BODY, buf);
 791
 792
 793         g_string_append(msg, END_BBODY);
 794         g_string_append(msg, END_BENV);
 795         g_string_append(msg, END_BMSEG);
 796         g_free(buf);
 797
 798         FN_END;
 799         return g_string_free(msg, FALSE);
 800 }
 801 /* LCOV_EXCL_STOP */
 802
 803 gboolean _bt_map_get_email_message(int mail_id, gboolean attach,
 804                 gboolean transcode, gboolean first_request, gchar **bmseg)
 805 {
 806         DBG("ENTER==>");
 807         int account_id;
 808         int ret;
 809         email_mail_data_t *mail_data = NULL;
 810
 811         ret = email_load_default_account_id(&account_id);
 812         if (ret != EMAIL_ERROR_NONE)
 813                 return FALSE;
 814
 815         /* LCOV_EXCL_START */
 816         ret = email_get_mail_data(mail_id, &mail_data);
 817         if (ret != EMAIL_ERROR_NONE)
 818                 return FALSE;
 819
 820         *bmseg = __bt_prepare_email_bmseg(mail_data);
 821
 822         email_free_mail_data(&mail_data, 1);
 823         DBG("EXIT==>");
 824         /* LCOV_EXCL_STOP */
 825         return TRUE;
 826 }
 827
 828 /* LCOV_EXCL_START */
 829 static int __bt_map_save_email_to_outbox(char *subject, char *body,
 830                 char *recepients)
 831 {
 832         int type =  EMAIL_MAILBOX_TYPE_OUTBOX;
 833         int account_id;
 834         int mail_id = -1;
 835         int ret;
 836         struct stat st_buf;
 837         FILE *body_file;
 838
 839         email_account_t *account_data = NULL;
 840         email_mailbox_t *mailbox_data = NULL;
 841         email_mail_data_t *mail_data = NULL;
 842
 843         DBG("email_mailbox_type_e :%d", type);
 844         DBG("Subject: %s", subject);
 845         DBG("Body: %s", body);
 846         DBG("Recepients: %s", recepients);
 847
 848         ret = email_load_default_account_id(&account_id);
 849         if (ret != EMAIL_ERROR_NONE)
 850                 goto fail;
 851
 852         DBG("account_id %d", account_id);
 853         ret = email_get_mailbox_by_mailbox_type(account_id, type,
 854                         &mailbox_data);
 855         if (ret != EMAIL_ERROR_NONE)
 856                 goto fail;
 857
 858         ret = email_get_account(account_id, EMAIL_ACC_GET_OPT_FULL_DATA,
 859                         &account_data);
 860         if (ret != EMAIL_ERROR_NONE)
 861                 goto fail;
 862
 863         mail_data = calloc(1, sizeof(email_mail_data_t));
 864         if (mail_data == NULL) {
 865                 ERR("Allocation Failed");
 866                 goto fail;
 867         }
 868
 869         mail_data->account_id = account_id;
 870         mail_data->save_status = EMAIL_MAIL_STATUS_SEND_DELAYED;
 871         mail_data->body_download_status = 1;
 872         mail_data->flags_seen_field = 1;
 873         mail_data->report_status = EMAIL_MAIL_REQUEST_DSN |
 874                                                 EMAIL_MAIL_REQUEST_MDN;
 875         mail_data->remaining_resend_times = 3;
 876         mail_data->file_path_plain = g_strdup(BT_MAIL_TEMP_BODY);
 877         mail_data->subject = g_strdup(subject);
 878         mail_data->full_address_to = g_strdup(recepients);
 879
 880         /* Get Sender Address  from Account data*/
 881         mail_data->full_address_from = g_strdup(account_data->user_email_address);
 882
 883         /* Get MailboxID and Type from mailbox data */
 884         mail_data->mailbox_id = mailbox_data->mailbox_id;
 885         mail_data->mailbox_type = mailbox_data->mailbox_type;
 886
 887         /* Save Body to a File */
 888         body_file = fopen(BT_MAIL_TEMP_BODY, "w");
 889         if (body_file == NULL) {
 890                 ERR("fopen [%s]failed", BT_MAIL_TEMP_BODY);
 891                 goto fail;
 892         }
 893
 894         ret = fprintf(body_file, "%s", body);
 895         fflush(body_file);
 896         fclose(body_file);
 897
 898         /* Save Email */
 899         ret = email_add_mail(mail_data, NULL, 0, NULL, 0);
 900         if (ret != EMAIL_ERROR_NONE) {
 901                 DBG("email_add_mail failed. [%d]\n", ret);
 902                 if (!stat(mail_data->file_path_plain, &st_buf))
 903                         remove(mail_data->file_path_plain);
 904
 905                 goto fail;
 906         }
 907
 908         DBG("saved mail id = [%d]\n", mail_data->mail_id);
 909         mail_id = mail_data->mail_id;
 910
 911 fail:
 912         if (mailbox_data)
 913                 email_free_mailbox(&mailbox_data, 1);
 914         if (account_data)
 915                 email_free_account(&account_data, 1);
 916         if (mail_data)
 917                 email_free_mail_data(&mail_data, 1);
 918
 919         return mail_id;
 920 }
 921
 922 static int __bt_map_save_email_to_draft(char *subject,
 923                                                 char *body, char *recepients)
 924 {
 925         int type =  EMAIL_MAILBOX_TYPE_DRAFT;
 926         int account_id;
 927         int mail_id = -1;
 928         int ret;
 929         struct stat st_buf;
 930         FILE *body_file;
 931
 932         email_account_t *account_data = NULL;
 933         email_mailbox_t *mailbox_data = NULL;
 934         email_mail_data_t *mail_data = NULL;
 935
 936         DBG("email_mailbox_type_e :%d", type);
 937         DBG("Subject: %s", subject);
 938         DBG("Body: %s", body);
 939         DBG("Recepients: %s", recepients);
 940
 941         ret = email_load_default_account_id(&account_id);
 942         if (ret != EMAIL_ERROR_NONE)
 943                 goto fail;
 944
 945         DBG("account_id %d", account_id);
 946         ret = email_get_mailbox_by_mailbox_type(account_id, type,
 947                                                 &mailbox_data);
 948         if (ret != EMAIL_ERROR_NONE)
 949                 goto fail;
 950
 951         ret = email_get_account(account_id, EMAIL_ACC_GET_OPT_FULL_DATA,
 952                         &account_data);
 953         if (ret != EMAIL_ERROR_NONE)
 954                 goto fail;
 955
 956         mail_data = calloc(1, sizeof(email_mail_data_t));
 957         if (mail_data == NULL) {
 958                 ERR("Allocation Failed");
 959                 goto fail;
 960         }
 961
 962         mail_data->account_id = account_id;
 963         mail_data->body_download_status = 1;
 964         mail_data->flags_seen_field = 1;
 965         mail_data->flags_draft_field = 1;
 966         mail_data->report_status = EMAIL_MAIL_REPORT_NONE;
 967         mail_data->remaining_resend_times = -1;
 968         mail_data->subject = g_strdup(subject);
 969         mail_data->full_address_to = g_strdup(recepients);
 970
 971         /* Get Sender Address  from Account data*/
 972         mail_data->full_address_from = g_strdup(account_data->user_email_address);
 973         email_free_account(&account_data, 1);
 974
 975         /* Get MailboxID and Type from mailbox data */
 976         mail_data->mailbox_id = mailbox_data->mailbox_id;
 977         mail_data->mailbox_type = mailbox_data->mailbox_type;
 978         email_free_mailbox(&mailbox_data, 1);
 979
 980         /* Save Body to a File */
 981         mail_data->file_path_plain = g_strdup(BT_MAIL_TEMP_BODY);
 982
 983         body_file = fopen(BT_MAIL_TEMP_BODY, "w");
 984         if (body_file == NULL) {
 985                 ERR("fopen [%s]failed", BT_MAIL_TEMP_BODY);
 986                 goto fail;
 987         }
 988
 989         ret = fprintf(body_file, "%s", body);
 990         fflush(body_file);
 991         fclose(body_file);
 992
 993         /* Save Email */
 994         ret = email_add_mail(mail_data, NULL, 0, NULL, 0);
 995         if (ret != EMAIL_ERROR_NONE) {
 996                 DBG("email_add_mail failed. [%d]\n", ret);
 997                 if (!stat(mail_data->file_path_plain, &st_buf))
 998                         remove(mail_data->file_path_plain);
 999
1000                 goto fail;
1001         }
1002
1003         DBG("saved mail id = [%d]\n", mail_data->mail_id);
1004         mail_id = mail_data->mail_id;
1005
1006 fail:
1007         if (mailbox_data)
1008                 email_free_mailbox(&mailbox_data, 1);
1009         if (account_data)
1010                 email_free_account(&account_data, 1);
1011         if (mail_data)
1012                 email_free_mail_data(&mail_data, 1);
1013
1014         return mail_id;
1015 }
1016
1017 static int __bt_map_send_email(char *subject, char *body,
1018                 char *recepients, gboolean send)
1019 {
1020         int ret;
1021         int mail_id = -1;
1022         int handle;
1023
1024         if (send) {
1025                 DBG("Send Mail");
1026                 mail_id = __bt_map_save_email_to_outbox(subject,
1027                                         body, recepients);
1028                 if (mail_id) {
1029                         DBG("mail_id = %d\n", mail_id);
1030                         ret = email_send_mail(mail_id, &handle);
1031                         if (ret != EMAIL_ERROR_NONE)
1032                                 DBG("Sending failed[%d]\n", ret);
1033                 }
1034
1035         } else {
1036                 DBG("Save to Draft");
1037                 mail_id = __bt_map_save_email_to_draft(subject,
1038                                         body, recepients);
1039         }
1040
1041         return mail_id;
1042 }
1043
1044 static char *__bt_map_get_email_address(GSList *recepients)
1045 {
1046         GString *mailto = NULL;
1047
1048         while (recepients) {
1049                 char *address = recepients->data;
1050                 DBG("Email: %s", address);
1051                 if (email_verify_email_address(address) == EMAIL_ERROR_NONE) {
1052                         if (mailto == NULL) {
1053                                 mailto = g_string_new(address);
1054                         } else {
1055                                 g_string_append(mailto, "; ");
1056                                 g_string_append(mailto, address);
1057                         }
1058                 }
1059                 recepients = g_slist_next(recepients);
1060         }
1061
1062         return g_string_free(mailto, FALSE);
1063 }
1064
1065 gboolean _bt_map_push_email_data(struct bmsg_data *bmsg_info,
1066                 msg_send_option_t *option, char *folder)
1067 {
1068         FN_START;
1069         int id = -1;
1070         char *message = NULL;
1071         char *body = NULL;
1072         char *subject = NULL;
1073         GSList *recepients = NULL;
1074         gboolean send = FALSE;
1075         char *mailto = NULL;
1076
1077         DBG("Length of Folder String: %zd", strlen(bmsg_info->folder));
1078         if (strlen(bmsg_info->folder) == 0) {
1079                 DBG("No Folder Info. Default to OUTBOX");
1080                 bmsg_info->folder = g_strdup(folder);
1081         }
1082
1083         DBG("FOLDER: %s", bmsg_info->folder);
1084         if (!g_ascii_strcasecmp(bmsg_info->folder, "OUTBOX") ||
1085                         !g_ascii_strcasecmp(bmsg_info->folder, "TELECOM/MSG/OUTBOX"))
1086                 send = TRUE;
1087
1088         message = bmsg_get_msg_body(bmsg_info, option->native);
1089         if (message == NULL)
1090                 goto done;
1091         DBG_SECURE("Message: %s", message);
1092
1093         if (!bmsg_parse_msg_body(message, &body, &subject))
1094                 goto done;
1095         DBG_SECURE("SUBJECT: %s", subject);
1096         DBG_SECURE("BODY: %s", body);
1097
1098         recepients = bmsg_get_msg_recepients(bmsg_info, BT_MAP_ID_EMAIL);
1099
1100         mailto = __bt_map_get_email_address(recepients);
1101         DBG("Email IDs: %s", mailto);
1102
1103         /* TODO : Write logic to Get Subject from bmessage
1104          */
1105
1106         id = __bt_map_send_email(subject, body, mailto, send);
1107         if (id == -1)
1108                 goto done;
1109
1110         _bt_update_id(current_push_map_id, id, BT_MAP_ID_EMAIL);
1111
1112 done:
1113         g_free(body);
1114         g_free(subject);
1115         g_free(message);
1116         g_slist_free(recepients);
1117
1118         if (id == -1) {
1119                 FN_END;
1120                 return FALSE;
1121         }
1122
1123         return TRUE;
1124 }
1125 /* LCOV_EXCL_STOP */
1126