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