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