map-agent/bluetooth_map_agent.c

   1 /*
   2  * bluetooth-agent
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <glib.h>
  25 #include <dbus/dbus-glib.h>
  26 #include <dbus/dbus.h>
  27 #include <time.h>
  28 #include "vconf.h"
  29 #include "vconf-keys.h"
  30
  31 #include <sys/types.h>
  32 #include <fcntl.h>
  33
  34 /*Messaging Header Files*/
  35 #include "msg.h"
  36 #include "msg_storage.h"
  37 #include "msg_storage_types.h"
  38 #include "msg_transport.h"
  39 #include "msg_transport_types.h"
  40 #include "msg_types.h"
  41
  42 #ifdef SUPPORT_EMAIL
  43 /*Email Header Files*/
  44 #include "email-types.h"
  45 #include "email-api-init.h"
  46 #include "email-api-account.h"
  47 #include "email-api-mailbox.h"
  48 #include "email-api-mail.h"
  49 #include "email-api-network.h"
  50 #endif
  51
  52 #include <bluetooth_map_agent.h>
  53
  54 #include <map_bmessage.h>
  55
  56 #define OBEX_CLIENT_SERVICE "org.openobex.client"
  57 #define OBEX_CLIENT_INTERFACE "org.openobex.Client"
  58 #define OBEX_CLIENT_PATH "/"
  59 #define MNS_CLIENT_INTERFACE "org.openobex.MessageNotification"
  60
  61 #define DBUS_STRUCT_STRING_STRING_UINT (dbus_g_type_get_struct("GValueArray", \
  62                 G_TYPE_STRING, G_TYPE_STRING,  G_TYPE_STRING, G_TYPE_INVALID))
  63
  64 #define DBUS_STRUCT_MESSAGE_LIST (dbus_g_type_get_struct("GValueArray", \
  65                 G_TYPE_STRING, G_TYPE_STRING,  G_TYPE_STRING, G_TYPE_STRING, \
  66                 G_TYPE_STRING, G_TYPE_STRING,  G_TYPE_STRING, G_TYPE_STRING, \
  67                 G_TYPE_STRING, G_TYPE_STRING,   G_TYPE_BOOLEAN, G_TYPE_STRING, \
  68                 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, \
  69                 G_TYPE_BOOLEAN, G_TYPE_STRING, \
  70                 G_TYPE_INVALID))
  71
  72 static msg_handle_t g_msg_handle = NULL;
  73
  74 #define BT_MAP_NEW_MESSAGE "NewMessage"
  75 #define BT_MAP_STATUS_CB "sent status callback"
  76 #define BT_MAP_MSG_CB "sms message callback"
  77 #define BT_MAP_EMAIL_DEFAULTACCOUNT "db/email/defaultaccount"
  78 #define BT_MNS_OBJECT_PATH "/org/bluez/mns"
  79 #define BT_MNS_INTERFACE "org.bluez.mns"
  80 #define BT_MAIL_TEMP_BODY "/tmp/bt_mail.txt"
  81 #define BT_MAP_SENT_FOLDER_NAME "SENT"
  82 #define BT_MAP_MSG_INFO_MAX 256
  83 #define BT_MAP_MSG_HANDLE_MAX 21
  84 #define BT_MAP_TIMESTAMP_MAX_LEN 16
  85 #define BT_MAP_SUBJECT_MAX_LEN 20
  86 #define BT_MAP_MSG_BODY_MAX 1024
  87 #define BT_MSG_UPDATE   0
  88 #define BT_MSG_DELETE   1
  89 #define BT_SMS 0
  90 #define BT_EMAIL 1
  91 #define BT_EMAIL_HANDLE_BASE (G_MAXUINT64 / 2)
  92 #define BT_MAIL_ID_MAX_LENGTH 50
  93
  94 #define BEGIN_BMSEG "BEGIN:BMSG\r\n"
  95 #define END_BMSEG "END:BMSG\r\n"
  96 #define BMSEG_VERSION "VERSION:1.0\r\n"
  97 #define MSEG_STATUS "STATUS:%s\r\n"
  98 #define MSEG_TYPE "TYPE:%s\r\n"
  99 #define FOLDER_PATH "FOLDER:%s\r\n"
 100 #define VCARD "BEGIN:VCARD\r\nVERSION:2.1\r\nN:%s\r\nTEL:%s\r\nEND:VCARD\r\n"
 101 #define BEGIN_BENV "BEGIN:BENV\r\n"
 102 #define END_BENV "END:BENV\r\n"
 103 #define BEGIN_BBODY "BEGIN:BBODY\r\n"
 104 #define END_BBODY "END:BBODY\r\n"
 105 #define ENCODING "ENCODING:%s\r\n"
 106 #define CHARSET "CHARSET:%s\r\n"
 107 #define LANGUAGE "LANGUAGE:%s\r\n"
 108 #define LENGTH "LENGTH:%d\r\n"
 109 #define MSG_BODY "BEGIN:MSG\r\n%s\r\nEND:MSG\r\n"
 110
 111 /* This has been added for testing purpose, will be removed when SMS APIs
 112     are available. */
 113 #define TEST_PDU "06810000000000040681567777000021017101750261A05"\
 114                  "376BA0D8297E5F3B73BCC4ED3F3A030FB1ECECF41613A"\
 115                  "5D1E1ED3E7A0B2BD2CCF8362AEA4195407C941ECF77C9"\
 116                  "E769F41753968FC769BD3E4B27B5C0691EB6510FD0D7AD"\
 117                  "BCBF27B397D46D343A163990E42BFDB6590BCDC4E93D3"\
 118                  "E539889E86CF41F437485E26D7C765D0DB5E96DFCBE933"\
 119                  "9A1E9A36A72063900AA2BF41B5DBED760385E920E9DC357B35A9"
 120
 121 GSList* id_list = NULL;
 122 guint64 current_push_map_id;
 123
 124 struct id_info {
 125         guint64 map_id;
 126         int uid;
 127 };
 128
 129 struct msg_send_option {
 130         bool save_copy;
 131         bool retry_send;
 132         bool native;
 133 };
 134
 135 struct message_info {
 136         char *handle;
 137         char *subject;
 138         char *datetime;
 139         char *sender_name;
 140         char *sender_addressing;
 141         char *recipient_name;
 142         char *recipient_addressing;
 143         char *type;
 144         char *size;
 145         char *reception_status;
 146         char *attachment_size;
 147         char *replyto_addressing;
 148         gboolean text;
 149         gboolean priority;
 150         gboolean read;
 151         gboolean sent;
 152         gboolean protect;
 153 };
 154
 155 typedef struct {
 156         GObject parent;
 157 } BluetoothMapAgent;
 158
 159 typedef struct {
 160         GObjectClass parent;
 161 } BluetoothMapAgentClass;
 162
 163 GType bluetooth_map_agent_get_type(void);
 164
 165 #define BLUETOOTH_MAP_TYPE_AGENT (bluetooth_map_agent_get_type())
 166
 167 #define BLUETOOTH_MAP_AGENT(object) \
 168         (G_TYPE_CHECK_INSTANCE_CAST((object), \
 169         BLUETOOTH_MAP_TYPE_AGENT , BluetoothMapAgent))
 170 #define BLUETOOTH_MAP_AGENT_CLASS(klass) \
 171         (G_TYPE_CHECK_CLASS_CAST((klass), \
 172         BLUETOOTH_MAP_TYPE_AGENT , BluetoothMapAgentClass))
 173 #define BLUETOOTH_MAP_IS_AGENT(object) \
 174         (G_TYPE_CHECK_INSTANCE_TYPE((object), \
 175         BLUETOOTH_MAP_TYPE_AGENT))
 176 #define BLUETOOTH_MAP_IS_AGENT_CLASS(klass) \
 177         (G_TYPE_CHECK_CLASS_TYPE((klass), \
 178         BLUETOOTH_MAP_TYPE_AGENT))
 179 #define BLUETOOTH_MAP_AGENT_GET_CLASS(obj) \
 180         (G_TYPE_INSTANCE_GET_CLASS((obj), \
 181         BLUETOOTH_MAP_TYPE_AGENT , BluetoothMapAgentClass))
 182
 183 G_DEFINE_TYPE(BluetoothMapAgent, bluetooth_map_agent, G_TYPE_OBJECT)
 184
 185 GMainLoop *g_mainloop = NULL;
 186 static DBusGConnection *g_connection = NULL;
 187 static char *g_mns_path = NULL;
 188 static struct msg_send_option opt;
 189
 190 static gboolean bluetooth_map_get_folder_tree(BluetoothMapAgent *agent,
 191                                         DBusGMethodInvocation *context);
 192 static gboolean bluetooth_map_get_message_list(BluetoothMapAgent *agent,
 193                                         gchar *folder_name, guint16 max,
 194                                         DBusGMethodInvocation *context);
 195 static gboolean bluetooth_map_get_message(BluetoothMapAgent *agent,
 196                                         gchar *message_name,
 197                                         gboolean attach, gboolean transcode,
 198                                         gboolean first_request,
 199                                         DBusGMethodInvocation *context);
 200 static gboolean bluetooth_map_push_message(BluetoothMapAgent *agent,
 201                                         gboolean save_copy,
 202                                         gboolean retry_send,
 203                                         gboolean native,
 204                                         gchar *folder_name,
 205                                         DBusGMethodInvocation *context);
 206 static gboolean bluetooth_map_push_message_data(BluetoothMapAgent *agent,
 207                                         gchar *bmsg,
 208                                         DBusGMethodInvocation *context);
 209 static gboolean bluetooth_map_update_message(BluetoothMapAgent *agent,
 210                                         DBusGMethodInvocation *context);
 211 static gboolean bluetooth_map_set_read_status(BluetoothMapAgent *agent,
 212                                         gchar *handle, gboolean read_status,
 213                                         DBusGMethodInvocation *context);
 214 static gboolean bluetooth_map_set_delete_status(BluetoothMapAgent *agent,
 215                                         gchar *handle, gboolean delete_status,
 216                                         DBusGMethodInvocation *context);
 217 static gboolean bluetooth_map_noti_registration(BluetoothMapAgent *agent,
 218                                         gchar *remote_addr,
 219                                         gboolean status,
 220                                         DBusGMethodInvocation *context);
 221
 222
 223 #include "bluetooth_map_agent_glue.h"
 224
 225 static void bluetooth_map_agent_init(BluetoothMapAgent *obj)
 226 {
 227         DBG("+\n");
 228
 229         g_assert(obj != NULL);
 230 }
 231
 232 static void bluetooth_map_agent_finalize(GObject *obj)
 233 {
 234         DBG("+\n");
 235
 236         G_OBJECT_CLASS(bluetooth_map_agent_parent_class)->finalize(obj);
 237 }
 238
 239 static void bluetooth_map_agent_class_init(BluetoothMapAgentClass *klass)
 240 {
 241         GObjectClass *object_class = (GObjectClass *) klass;
 242
 243         g_assert(klass != NULL);
 244
 245         object_class->finalize = bluetooth_map_agent_finalize;
 246
 247         dbus_g_object_type_install_info(BLUETOOTH_MAP_TYPE_AGENT,
 248                                         &dbus_glib_bluetooth_map_object_info);
 249 }
 250
 251 static GQuark __bt_map_agent_error_quark(void)
 252 {
 253         static GQuark quark = 0;
 254         if (!quark)
 255                 quark = g_quark_from_static_string("agent");
 256
 257         return quark;
 258 }
 259
 260 static GError *__bt_map_agent_error(bt_map_agent_error_t error,
 261                                      const char *err_msg)
 262 {
 263         return g_error_new(BT_MAP_AGENT_ERROR, error, err_msg, NULL);
 264 }
 265
 266 static guint64 _bt_validate_uid(int uid)
 267 {
 268         DBG("Validate uid");
 269         struct id_info *info;
 270         int count;
 271         int i;
 272
 273         count = g_slist_length(id_list);
 274         for (i = 0; i < count; i++) {
 275                 info = (struct id_info *)g_slist_nth_data(id_list, i);
 276                 if (!info)
 277                         break;
 278
 279                 if (info->uid == uid) {
 280                         printf("uid = %d\n", uid);
 281                         return info->map_id;
 282                 }
 283         }
 284
 285         return 0;
 286 }
 287
 288 static guint64 __bt_add_id(int uid)
 289 {
 290         DBG("Add id: %d\n", uid);
 291         static guint64 map_id;
 292         struct id_info *info;
 293         guint64 test;
 294
 295         test = _bt_validate_uid(uid);
 296         DBG("test: %llx\n", test);
 297         if (test)
 298                 return test;
 299
 300         info = g_new0(struct id_info, 1);
 301
 302         map_id++;
 303
 304         info->map_id = map_id;
 305         info->uid = uid;
 306         DBG("map_id = %llx, uid = %d \n", info->map_id, info->uid);
 307
 308         id_list = g_slist_append(id_list, info);
 309
 310         return map_id;
 311 }
 312
 313 static int __bt_get_id(guint64 map_id)
 314 {
 315         DBG("get id\n");
 316         struct id_info *info;
 317         int count;
 318         int i;
 319
 320         count = g_slist_length(id_list);
 321
 322         for (i = 0; i < count; i++) {
 323                 info = (struct id_info *)g_slist_nth_data(id_list, i);
 324
 325                 if (info->map_id == map_id)
 326                         return info->uid;
 327         }
 328
 329         return -1;
 330 }
 331
 332 static int __bt_get_uid(gchar *handle)
 333 {
 334         guint64 map_id;
 335         int uid;
 336
 337         if (NULL == handle)
 338                 return -1;
 339
 340         map_id = g_ascii_strtoull(handle, NULL, 16);
 341         if (!map_id)
 342                 return -1;
 343
 344         uid = __bt_get_id(map_id);
 345
 346         return uid;
 347 }
 348
 349 static int __bt_update_id(guint64 map_id, int new_uid)
 350 {
 351         DBG("update id\n");
 352         struct id_info *info;
 353         int i;
 354         int count;
 355
 356         count = g_slist_length(id_list);
 357
 358         for (i = 0; i < count; i++) {
 359                 info = g_slist_nth_data(id_list, i);
 360
 361                 if (info->map_id == map_id) {
 362                         info->uid = new_uid;
 363                         return map_id;
 364                 }
 365         }
 366
 367         return -1;
 368 }
 369
 370 static void __bt_remove_list(GSList *id_list)
 371 {
 372         if (!id_list)
 373                 return;
 374
 375         DBG("Removing id list\n");
 376         g_slist_free_full(id_list, g_free);
 377 }
 378
 379
 380 static gchar *__bt_get_folder_name(int id)
 381 {
 382         int ret;
 383         char folder_name[BT_MAP_MSG_INFO_MAX] = {0,};
 384
 385         msg_struct_list_s g_folderList;
 386         msg_struct_t p_folder;
 387
 388         ret = msg_get_folder_list(g_msg_handle, &g_folderList);
 389         if (ret != MSG_SUCCESS)
 390                 goto done;
 391
 392         p_folder = g_folderList.msg_struct_info[id];
 393
 394         ret = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
 395                                         folder_name, BT_MAP_MSG_INFO_MAX);
 396         if (ret != MSG_SUCCESS)
 397                 goto done;
 398
 399         return g_strdup_printf("TELECOM/MSG/%s", folder_name);
 400
 401 done:
 402         return g_strdup("TELECOM/MSG");
 403 }
 404
 405 static void __get_msg_timestamp(time_t *ltime, char *timestamp)
 406 {
 407         struct tm local_time;
 408         int year;
 409         int month;
 410
 411         if (!localtime_r(ltime, &local_time))
 412                 return;
 413
 414         year = local_time.tm_year + 1900; /* years since 1900 */
 415         month = local_time.tm_mon + 1; /* months since January */
 416         snprintf(timestamp, 16, "%04d%02d%02dT%02d%02d%02d", year, month,
 417                                         local_time.tm_mday, local_time.tm_hour,
 418                                         local_time.tm_min, local_time.tm_sec);
 419
 420         return;
 421 }
 422
 423 static char *__bt_prepare_msg_bmseg(msg_struct_t msg_info, gboolean attach,
 424                                                         gboolean transcode)
 425 {
 426         int ret;
 427         int m_type = MSG_TYPE_SMS;
 428         int folder_id;
 429         int count;
 430         bool read_status = false;
 431         char msg_body[BT_MAP_MSG_BODY_MAX] = {0,};
 432         char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
 433         char name_value[MAX_ADDRESS_VAL_LEN] = {0,};
 434         gchar *folder_path;
 435
 436         msg_struct_list_s *addr_list = NULL;
 437         GString *msg;
 438
 439         msg = g_string_new(BEGIN_BMSEG);
 440         g_string_append(msg, BMSEG_VERSION);
 441
 442         ret = msg_get_bool_value(msg_info, MSG_MESSAGE_READ_BOOL, &read_status);
 443         if (ret == MSG_SUCCESS) {
 444                 DBG("read_status %d\n", read_status);
 445         }
 446
 447         if (read_status)
 448                 g_string_append_printf(msg, MSEG_STATUS, "READ");
 449         else
 450                 g_string_append_printf(msg, MSEG_STATUS, "UNREAD");
 451
 452         ret = msg_get_int_value(msg_info, MSG_MESSAGE_TYPE_INT, &m_type);
 453         if (ret == MSG_SUCCESS) {
 454                 DBG("m_type %d\n", m_type);
 455         }
 456
 457         switch (m_type) {
 458         case MSG_TYPE_MMS:
 459         case MSG_TYPE_MMS_JAVA:
 460         case MSG_TYPE_MMS_NOTI:
 461                 g_string_append_printf(msg, MSEG_TYPE, "MMS");
 462                 break;
 463
 464         default:
 465                  g_string_append_printf(msg, MSEG_TYPE, "SMS_GSM");
 466                 break;
 467         }
 468
 469         ret = msg_get_int_value(msg_info, MSG_MESSAGE_FOLDER_ID_INT,
 470                                                         &folder_id);
 471         if (ret == MSG_SUCCESS) {
 472                 DBG("folder_id %d\n", folder_id);
 473         }
 474
 475         folder_path = __bt_get_folder_name(folder_id);
 476         g_string_append_printf(msg, FOLDER_PATH, folder_path);
 477
 478
 479         ret = msg_get_list_handle(msg_info, MSG_MESSAGE_ADDR_LIST_STRUCT,
 480                                                         (void **)&addr_list);
 481         if (ret == MSG_SUCCESS) {
 482                 count = addr_list->nCount;
 483                 DBG("count %d \n", count);
 484                 while (count > 0) {
 485                         msg_struct_t addr_info = NULL;
 486                         addr_info = addr_list->msg_struct_info[count - 1];
 487
 488                         msg_get_str_value(addr_info,
 489                                         MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
 490                                         addr_value, MAX_ADDRESS_VAL_LEN);
 491                         DBG("addr_value %s\n", addr_value);
 492                         msg_get_str_value(addr_info,
 493                                         MSG_ADDRESS_INFO_DISPLAYNAME_STR,
 494                                         name_value, MAX_ADDRESS_VAL_LEN);
 495                         if (!strlen(name_value))
 496                                 g_stpcpy(name_value, addr_value);
 497
 498                         DBG("name_value %s\n", name_value);
 499
 500                         g_string_append_printf(msg, VCARD, name_value,
 501                                                                 addr_value);
 502                         count--;
 503                 }
 504         }
 505
 506         g_string_append(msg, BEGIN_BENV);
 507         g_string_append(msg, BEGIN_BBODY);
 508
 509         if (transcode) {
 510                 g_string_append_printf(msg, CHARSET, "UTF-8");
 511
 512                 if (m_type == MSG_TYPE_MMS)
 513                         ret = msg_get_str_value(msg_info,
 514                                                 MSG_MESSAGE_MMS_TEXT_STR,
 515                                                 msg_body, BT_MAP_SUBJECT_MAX_LEN);
 516                 else
 517                         ret = msg_get_str_value(msg_info,
 518                                                 MSG_MESSAGE_SMS_DATA_STR,
 519                                                 msg_body, BT_MAP_MSG_BODY_MAX);
 520
 521                 if (ret == MSG_SUCCESS) {
 522                         g_string_append_printf(msg, LENGTH, strlen(msg_body));
 523                         g_string_append_printf(msg, MSG_BODY, msg_body);
 524                 }
 525         } else {
 526                 gchar *msg_pdu;
 527                 g_string_append_printf(msg, ENCODING, "G-7BIT");
 528                 g_string_append_printf(msg, CHARSET, "native");
 529                 /* The below line has been added for testing purpose,
 530                     will be removed when SMS APIs are available. */
 531                 msg_pdu = g_strdup(TEST_PDU);
 532                 g_string_append_printf(msg, LENGTH, strlen(msg_pdu));
 533                 g_string_append_printf(msg, MSG_BODY, msg_pdu);
 534                 g_free(msg_pdu);
 535         }
 536
 537         g_string_append(msg, END_BBODY);
 538         g_string_append(msg, END_BENV);
 539         g_string_append(msg, END_BMSEG);
 540
 541         return g_string_free(msg, FALSE);
 542 }
 543
 544 static void __bt_message_info_free(struct message_info msg_info)
 545 {
 546         g_free(msg_info.handle);
 547         g_free(msg_info.subject);
 548         g_free(msg_info.datetime);
 549         g_free(msg_info.sender_name);
 550         g_free(msg_info.sender_addressing);
 551         g_free(msg_info.replyto_addressing);
 552         g_free(msg_info.recipient_name);
 553         g_free(msg_info.recipient_addressing);
 554         g_free(msg_info.type);
 555         g_free(msg_info.reception_status);
 556         g_free(msg_info.size);
 557         g_free(msg_info.attachment_size);
 558 }
 559
 560 static struct message_info __bt_message_info_get(msg_struct_t msg_struct_handle)
 561 {
 562         struct message_info msg_info = {0,};
 563         int ret;
 564         int msg_id;
 565         guint64 uid;
 566         int dptime;
 567         int m_type = 0;
 568         int data_size;
 569         int priority;
 570         int direction_type;
 571         bool protect_status = 0;
 572         bool read_status = 0;
 573
 574         char msg_handle[BT_MAP_MSG_HANDLE_MAX] = {0,};
 575         char msg_subject[BT_MAP_SUBJECT_MAX_LEN] = {0,};
 576         char msg_datetime[BT_MAP_TIMESTAMP_MAX_LEN] = {0,};
 577         char msg_size[5] = {0,};
 578         char msg_body[BT_MAP_MSG_BODY_MAX] = {0,};
 579         char addr_value[MAX_ADDRESS_VAL_LEN] = {0,};
 580         char name_value[MAX_ADDRESS_VAL_LEN] = {0,};
 581
 582         msg_info.text = FALSE;
 583         msg_info.protect = FALSE;
 584         msg_info.read = FALSE;
 585         msg_info.priority = FALSE;
 586
 587         msg_struct_t msg = NULL;
 588         msg_struct_t send_opt = NULL;
 589         msg_struct_list_s *addr_list = NULL;
 590         msg_struct_t addr_info = NULL;
 591
 592         ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_ID_INT, &msg_id);
 593         if (ret == MSG_SUCCESS) {
 594                 uid = __bt_add_id(msg_id);
 595                 snprintf(msg_handle, sizeof(msg_handle), "%llx", uid);
 596         }
 597         msg_info.handle = g_strdup(msg_handle);
 598
 599         msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
 600         send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
 601
 602         ret = msg_get_message(g_msg_handle,
 603                                                 (msg_message_id_t)msg_id,
 604                                                 msg, send_opt);
 605         if (ret != MSG_SUCCESS) {
 606                 DBG("ret = %d\n", ret);
 607                 goto next;
 608         }
 609
 610         ret = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_STRUCT,
 611                                                         (void **)&addr_list);
 612         if (ret != MSG_SUCCESS) {
 613                 DBG("ret = %d\n", ret);
 614                 goto next;
 615         }
 616
 617         addr_info = addr_list->msg_struct_info[0];
 618
 619         ret = msg_get_str_value(addr_info, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
 620                                 addr_value, MAX_ADDRESS_VAL_LEN);
 621         if (ret == MSG_SUCCESS)
 622                 DBG("addr_value %s\n", addr_value);
 623
 624         ret = msg_get_str_value(addr_info, MSG_ADDRESS_INFO_DISPLAYNAME_STR,
 625                         name_value, MAX_ADDRESS_VAL_LEN);
 626         if (ret == MSG_SUCCESS)
 627                 DBG("name_value %s\n", name_value);
 628
 629         if (!strlen(name_value))
 630                 g_stpcpy(name_value, addr_value);
 631
 632         DBG("name_value %s\n", name_value);
 633
 634         ret = msg_get_int_value(msg, MSG_MESSAGE_DIRECTION_INT, &direction_type);
 635         if (ret != MSG_SUCCESS)
 636                 goto next;
 637
 638         if (direction_type == MSG_DIRECTION_TYPE_MT) {
 639                 msg_info.sender_name = g_strdup(name_value);
 640                 msg_info.sender_addressing = g_strdup(addr_value);
 641                 msg_info.recipient_name = g_strdup("Unknown");
 642                 msg_info.recipient_addressing = g_strdup("0000");
 643         } else {
 644                 msg_info.sender_name = g_strdup("Unknown");
 645                 msg_info.sender_addressing = g_strdup("0000");
 646                 msg_info.recipient_name = g_strdup(name_value);
 647                 msg_info.recipient_addressing = g_strdup(addr_value);
 648         }
 649
 650 next:
 651         msg_release_struct(&msg);
 652         msg_release_struct(&send_opt);
 653
 654         ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_DISPLAY_TIME_INT, &dptime);
 655         if (ret == MSG_SUCCESS) {
 656                 __get_msg_timestamp((time_t *)&dptime, msg_datetime);
 657         }
 658         msg_info.datetime = g_strdup(msg_datetime);
 659
 660         ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_TYPE_INT,
 661                                                                 &m_type);
 662         if (ret == MSG_SUCCESS) {
 663                 DBG("m_type %d\n", m_type);
 664         }
 665
 666         switch (m_type) {
 667         case MSG_TYPE_MMS:
 668         case MSG_TYPE_MMS_JAVA:
 669         case MSG_TYPE_MMS_NOTI:
 670                 msg_info.type = g_strdup("MMS");
 671                 break;
 672
 673         default:
 674                 msg_info.type = g_strdup("SMS_GSM");
 675                 break;
 676         }
 677
 678         if (m_type == MSG_TYPE_MMS) {
 679                 ret = msg_get_str_value(msg_struct_handle,
 680                                         MSG_MESSAGE_SUBJECT_STR, msg_subject,
 681                                         BT_MAP_SUBJECT_MAX_LEN);
 682                 if (ret == MSG_SUCCESS) {
 683                         DBG("MMS subject %s", msg_subject);
 684                 }
 685
 686                 msg_info.subject = g_strdup(msg_subject);
 687
 688                 ret = msg_get_str_value(msg_struct_handle,
 689                                         MSG_MESSAGE_MMS_TEXT_STR, msg_body,
 690                                         BT_MAP_MSG_BODY_MAX);
 691                 if (ret == MSG_SUCCESS) {
 692                         DBG("msg_body %s", msg_body);
 693                         if (strlen(msg_body))
 694                                 msg_info.text = TRUE ;
 695                 }
 696
 697         } else if (m_type == MSG_TYPE_SMS) {
 698                 ret = msg_get_str_value(msg_struct_handle,
 699                                         MSG_MESSAGE_SMS_DATA_STR, msg_body,
 700                                         BT_MAP_MSG_BODY_MAX);
 701                 if (ret == MSG_SUCCESS) {
 702                         DBG("SMS subject %s", msg_body);
 703                         if (strlen(msg_body)) {
 704                                 msg_info.text = TRUE ;
 705                                 msg_info.subject = g_strndup(msg_body,
 706                                                         BT_MAP_SUBJECT_MAX_LEN);
 707                         }
 708                 }
 709         }
 710
 711         ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_DATA_SIZE_INT,
 712                                                                 &data_size);
 713         if (ret == MSG_SUCCESS)
 714                 snprintf(msg_size, sizeof(msg_size), "%d", data_size);
 715
 716         msg_info.size = g_strdup(msg_size);
 717
 718         msg_info.reception_status = g_strdup("complete");
 719         msg_info.attachment_size = g_strdup("0");
 720
 721         ret = msg_get_bool_value(msg_struct_handle, MSG_MESSAGE_PROTECTED_BOOL,
 722                                                         &protect_status);
 723         if (ret == MSG_SUCCESS) {
 724                 if (protect_status)
 725                         msg_info.protect = TRUE;
 726         }
 727
 728         ret = msg_get_bool_value(msg_struct_handle, MSG_MESSAGE_READ_BOOL,
 729                                                                 &read_status);
 730         if (ret == MSG_SUCCESS) {
 731                 if (read_status)
 732                         msg_info.read = TRUE;
 733         }
 734
 735         ret = msg_get_int_value(msg_struct_handle, MSG_MESSAGE_PRIORITY_INT,
 736                                                                 &priority);
 737         if (ret == MSG_SUCCESS) {
 738                 if (priority == MSG_MESSAGE_PRIORITY_HIGH)
 739                         msg_info.priority = TRUE;
 740         }
 741
 742         return msg_info;
 743 }
 744
 745 static void __bluetooth_map_msg_incoming_status_cb(msg_handle_t handle,
 746                                                         msg_struct_t msg,
 747                                                         void *user_param)
 748 {
 749         DBusGProxy *mns_proxy;
 750         GError *error = NULL;
 751
 752         int msg_id = 0;
 753         int msg_type = 0;
 754         int ret = MSG_SUCCESS;
 755
 756         char *message_type = NULL;
 757
 758         guint64 uid;
 759
 760         DBG("+\n");
 761
 762         ret = msg_get_int_value(msg, MSG_MESSAGE_ID_INT, &msg_id);
 763         if (ret != MSG_SUCCESS)
 764                 return;;
 765
 766         uid = __bt_add_id(msg_id);
 767
 768         ret = msg_get_int_value(msg, MSG_MESSAGE_TYPE_INT, &msg_type);
 769         if (ret != MSG_SUCCESS)
 770                 return;
 771
 772         switch (msg_type) {
 773         case MSG_TYPE_SMS:
 774                 message_type = g_strdup("SMS_GSM");
 775                 break;
 776         case MSG_TYPE_MMS:
 777                 message_type = g_strdup("MMS");
 778                 break;
 779         default:
 780                 return;
 781         }
 782
 783         mns_proxy = dbus_g_proxy_new_for_name(g_connection, OBEX_CLIENT_SERVICE,
 784                                                         g_mns_path,
 785                                                         MNS_CLIENT_INTERFACE);
 786         if (mns_proxy == NULL) {
 787                 ERR("Failed to get a proxy for D-Bus\n");
 788                 g_free(message_type);
 789                 return;
 790         }
 791
 792         dbus_g_proxy_call(mns_proxy, "SendEvent", &error,
 793                 G_TYPE_STRING, "NewMessage",
 794                 G_TYPE_UINT64, uid,
 795                 G_TYPE_STRING, "TELECOM/MSG/INBOX",
 796                 G_TYPE_STRING, "",
 797                 G_TYPE_STRING, message_type,
 798                 G_TYPE_INVALID, G_TYPE_INVALID);
 799         if (error) {
 800                 DBG("Error [%s]", error->message);
 801                 g_error_free(error);
 802         }
 803
 804         DBG("-\n");
 805         g_free(message_type);
 806         g_object_unref(mns_proxy);
 807         return;
 808 }
 809
 810 static gboolean __bluetooth_map_start_service()
 811 {
 812         msg_error_t err = MSG_SUCCESS;
 813         gboolean msg_ret = TRUE;
 814 #ifdef SUPPORT_EMAIL
 815         int email_err = EMAIL_ERROR_NONE;
 816         gboolean email_ret = TRUE;
 817 #endif
 818
 819         err = msg_open_msg_handle(&g_msg_handle);
 820         if (err != MSG_SUCCESS) {
 821                 ERR("msg_open_msg_handle error = %d\n", err);
 822                 msg_ret = FALSE;
 823                 goto done;
 824         }
 825
 826         err = msg_reg_sms_message_callback(g_msg_handle,
 827                                         __bluetooth_map_msg_incoming_status_cb,
 828                                         0, (void *)BT_MAP_MSG_CB);
 829         if (err != MSG_SUCCESS) {
 830                 ERR("msg_reg_sms_message_callback error  = %d\n", err);
 831                 msg_ret = FALSE;
 832         }
 833
 834 done:
 835
 836 #ifdef SUPPORT_EMAIL
 837
 838         email_err = email_service_begin();
 839         if (email_err != EMAIL_ERROR_NONE) {
 840                 ERR("email_service_begin fail  error = %d\n", email_err);
 841                 email_ret = FALSE;
 842         }
 843
 844         if (msg_ret || email_ret)
 845                 return TRUE;
 846         else
 847                 return FALSE;
 848
 849 #else
 850
 851         return msg_ret;
 852
 853 #endif
 854 }
 855
 856 static void __bluetooth_map_stop_service()
 857 {
 858         if (NULL != g_msg_handle)
 859                 msg_close_msg_handle(&g_msg_handle);
 860
 861         g_msg_handle = NULL;
 862
 863 #ifdef SUPPORT_EMAIL
 864         if (EMAIL_ERROR_NONE != email_service_end())
 865                 ERR("email_service_end fail \n");
 866 #endif
 867         return;
 868 }
 869
 870 #ifdef SUPPORT_EMAIL
 871 static int __bt_store_mail(email_mailbox_type_e type, char *subject,
 872                                                 char *body, char *recepients)
 873 {
 874         int account_id;
 875         int mail_id;
 876         int err;
 877         char from_address[BT_MAIL_ID_MAX_LENGTH] = { 0, };
 878         FILE *body_file;
 879         struct stat st_buf;
 880
 881         email_account_t *account_data = NULL;
 882         email_mailbox_t *mailbox_data = NULL;
 883         email_mail_data_t *mail_data = NULL;
 884
 885         err = email_load_default_account_id(&account_id);
 886         if (EMAIL_ERROR_NONE != err)
 887                 goto fail;
 888
 889         err = email_get_account(account_id, GET_FULL_DATA_WITHOUT_PASSWORD,
 890                                                                 &account_data);
 891         if (EMAIL_ERROR_NONE != err)
 892                 goto fail;
 893
 894         err = email_get_mailbox_by_mailbox_type(account_id, type,
 895                                                                 &mailbox_data);
 896         if (EMAIL_ERROR_NONE != err)
 897                 goto fail;
 898
 899         snprintf(from_address, BT_MAIL_ID_MAX_LENGTH, "<%s>",
 900                                         account_data->user_email_address);
 901         email_free_account(&account_data, 1);
 902
 903         mail_data = calloc(1, sizeof(email_mail_data_t));
 904         if (NULL == mail_data) {
 905                 email_free_mailbox(&mailbox_data, 1);
 906                 goto fail;
 907         }
 908
 909         DBG("\n account_id %d\n", account_id);
 910         mail_data->account_id = account_id;
 911         mail_data->save_status = 1;
 912         mail_data->body_download_status = 1;
 913         /* mail_data->flags_draft_field = 1; */
 914         mail_data->flags_seen_field = 1;
 915         mail_data->file_path_plain = g_strdup(BT_MAIL_TEMP_BODY);
 916
 917         mail_data->mailbox_id = mailbox_data->mailbox_id;
 918         mail_data->mailbox_type = mailbox_data->mailbox_type;
 919         email_free_mailbox(&mailbox_data, 1);
 920
 921         mail_data->full_address_from = g_strdup(from_address);
 922         mail_data->full_address_to = g_strdup(recepients);
 923         mail_data->subject = g_strdup(subject);
 924         mail_data->report_status = EMAIL_MAIL_REQUEST_DSN |
 925                                                         EMAIL_MAIL_REQUEST_MDN;
 926
 927         body_file = fopen(BT_MAIL_TEMP_BODY, "w");
 928         if (body_file == NULL) {
 929                 DBG("\n fopen [%s]failed\n", BT_MAIL_TEMP_BODY);
 930                 email_free_mail_data(&mail_data, 1);
 931                 goto fail;
 932         }
 933
 934         fprintf(body_file, body);
 935         fflush(body_file);
 936         fclose(body_file);
 937
 938         err = email_add_mail(mail_data, NULL, 0, NULL, 0);
 939         if (err != EMAIL_ERROR_NONE) {
 940                 DBG("email_add_mail failed. [%d]\n", err);
 941                 if (!stat(mail_data->file_path_plain, &st_buf))
 942                         remove(mail_data->file_path_plain);
 943
 944                 email_free_mail_data(&mail_data, 1);
 945                 goto fail;
 946         }
 947
 948         DBG("saved mail id = [%d]\n", mail_data->mail_id);
 949
 950         mail_id = mail_data->mail_id;
 951
 952         email_free_mail_data(&mail_data, 1);
 953
 954         return mail_id;
 955
 956 fail:
 957         return 0;
 958 }
 959
 960 static int __bt_email_send(char *subject, char *body, char* recepients)
 961 {
 962         int err;
 963         int mail_id;
 964         int handle;
 965
 966         mail_id = __bt_store_mail(EMAIL_MAILBOX_TYPE_OUTBOX, subject,
 967                                                         body, recepients);
 968         if (mail_id) {
 969                 DBG("mail_id = %d\n", mail_id);
 970                 err = email_send_mail(mail_id, &handle);
 971                 if (err != EMAIL_ERROR_NONE)
 972                         DBG("Sending failed[%d]\n", err);
 973         }
 974
 975         return mail_id;
 976 }
 977 #endif
 978
 979 static int __bt_get_folder_id(char *folder_path)
 980 {
 981         int folder_id = -1;
 982         int i;
 983         char *folder;
 984         msg_struct_list_s folder_list;
 985         msg_error_t err;
 986         msg_struct_t p_folder;
 987         DBG("__bt_get_folder_id\n");
 988
 989         folder = strrchr(folder_path, '/');
 990         if (NULL == folder)
 991                 return -1;
 992
 993         folder++;
 994
 995         DBG("folderName %s\n", folder);
 996
 997         err = msg_get_folder_list(g_msg_handle, &folder_list);
 998         if (err != MSG_SUCCESS)
 999                 return -1;
1000
1001         for (i = 0; i < folder_list.nCount; i++) {
1002                 p_folder = folder_list.msg_struct_info[i];
1003                 char folder_name[BT_MAP_MSG_INFO_MAX] = {0, };
1004
1005                 err = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
1006                                         folder_name, BT_MAP_MSG_INFO_MAX);
1007                 if (err != MSG_SUCCESS)
1008                         continue;
1009
1010                 DBG("folderName %s\n", folder_name);
1011                 if (!g_ascii_strncasecmp(folder_name, folder, strlen(folder))) {
1012                         err = msg_get_int_value(p_folder, MSG_FOLDER_INFO_ID_INT,
1013                                                                 &folder_id);
1014                         if (err != MSG_SUCCESS)
1015                                 return -1;
1016
1017                         break;
1018                 }
1019         }
1020
1021         return folder_id;
1022
1023 }
1024
1025 msg_error_t __bt_send_sms(int msg_id, msg_struct_t pMsg, msg_struct_t pSendOpt)
1026 {
1027         msg_error_t err;
1028         msg_struct_t pReq;
1029
1030         pReq = msg_create_struct(MSG_STRUCT_REQUEST_INFO);
1031
1032         msg_set_int_value(pMsg, MSG_MESSAGE_ID_INT, msg_id);
1033         msg_set_struct_handle(pReq, MSG_REQUEST_MESSAGE_HND, pMsg);
1034         msg_set_struct_handle(pReq, MSG_REQUEST_SENDOPT_HND, pSendOpt);
1035
1036         err = msg_sms_send_message(g_msg_handle, pReq);
1037         if (err == MSG_SUCCESS)
1038                 DBG("Sending Message is successful!!!");
1039         else
1040                 DBG("Sending Message is failed!!! %d", err);
1041
1042         msg_release_struct(&pReq);
1043         return err;
1044 }
1045
1046 static int __bt_push_sms(gboolean send, int folder_id, char *body,
1047                                                         GSList *recepients)
1048 {
1049         DBG("+ \n");
1050         msg_struct_t msg_info = NULL;
1051         msg_struct_t send_opt = NULL;
1052         msg_struct_list_s *addr_list;
1053         msg_error_t err;
1054
1055         int count = 0;
1056         int i = 0;
1057         int msg_id;
1058         guint64 uid = -1;
1059
1060         msg_info = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1061         if (msg_info == NULL)
1062                 goto fail;
1063
1064         err = msg_set_int_value(msg_info, MSG_MESSAGE_TYPE_INT, MSG_TYPE_SMS);
1065         if (err != MSG_SUCCESS)
1066                 goto fail;
1067
1068         if (body) {
1069                 err = msg_set_str_value(msg_info, MSG_MESSAGE_SMS_DATA_STR, body,
1070                                                                         strlen(body));
1071                 if (err != MSG_SUCCESS)
1072                         goto fail;
1073         } else {
1074                 err = msg_set_str_value(msg_info, MSG_MESSAGE_SMS_DATA_STR,
1075                                                                 NULL, 0);
1076                 if (err != MSG_SUCCESS)
1077                         goto fail;
1078         }
1079
1080         DBG("folder_id  %d\n", folder_id);
1081         err = msg_set_int_value(msg_info, MSG_MESSAGE_FOLDER_ID_INT,
1082                                                                 folder_id);
1083         if (err != MSG_SUCCESS)
1084                 goto fail;
1085
1086         if (recepients) {
1087                 count = g_slist_length(recepients);
1088                 DBG("Count = %d\n", count);
1089                 msg_get_list_handle(msg_info, MSG_MESSAGE_ADDR_LIST_STRUCT,
1090                                                         (void**)&addr_list);
1091
1092                 addr_list->nCount = count;
1093                 for (i = 0; i < count; i++) {
1094                         char *address = (char *)g_slist_nth_data(recepients, i);
1095                         if (address == NULL) {
1096                                 DBG("[ERROR] address is value NULL, skip");
1097                                 continue;
1098                         }
1099                         msg_set_int_value(addr_list->msg_struct_info[i],
1100                                         MSG_ADDRESS_INFO_ADDRESS_TYPE_INT,
1101                                         MSG_ADDRESS_TYPE_PLMN);
1102
1103                         msg_set_int_value(addr_list->msg_struct_info[i],
1104                                         MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT,
1105                                         MSG_RECIPIENTS_TYPE_TO);
1106
1107                         msg_set_str_value(addr_list->msg_struct_info[i],
1108                                         MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
1109                                         address, strlen(address));
1110                 }
1111         }
1112
1113         send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
1114
1115         err = msg_set_bool_value(send_opt, MSG_SEND_OPT_SETTING_BOOL, true);
1116         if (err != MSG_SUCCESS)
1117                 goto fail;
1118
1119         /* Do not keep a copy */
1120         err = msg_set_bool_value(send_opt, MSG_SEND_OPT_KEEPCOPY_BOOL,
1121                                                         opt.save_copy);
1122         if (err != MSG_SUCCESS)
1123                 goto fail;
1124
1125         msg_id = msg_add_message(g_msg_handle, msg_info, send_opt);
1126         DBG("msg_id = %d\n", msg_id);
1127         uid = __bt_add_id(msg_id);
1128
1129         if (send == TRUE) {
1130                 err = __bt_send_sms(msg_id, msg_info, send_opt);
1131                 if (err != MSG_SUCCESS) {
1132                         uid = -1;
1133                         goto fail;
1134                 }
1135         }
1136
1137 fail:
1138         msg_release_struct(&msg_info);
1139         msg_release_struct(&send_opt);
1140         DBG("-\n");
1141         return uid;
1142 }
1143
1144 static gboolean __bt_msg_is_mms(int msg_type)
1145 {
1146         gboolean result = FALSE;
1147
1148         switch (msg_type) {
1149         case MSG_TYPE_MMS_NOTI:
1150         case MSG_TYPE_MMS_JAVA:
1151         case MSG_TYPE_MMS:
1152                 result = TRUE;
1153                 break;
1154         default:
1155                 break;
1156         }
1157
1158         return result;
1159 }
1160
1161 static void __bt_mns_client_connect(char *address)
1162 {
1163         DBusGProxy *mns_proxy;
1164         GHashTable *hash;
1165         GValue *addr_value;
1166         GValue *tgt_value;
1167         GError *error = NULL;
1168         const char *session_path = NULL;
1169
1170         DBG("+ address %s\n", address);
1171
1172         mns_proxy = dbus_g_proxy_new_for_name(g_connection, OBEX_CLIENT_SERVICE,
1173                                                 OBEX_CLIENT_PATH,
1174                                                 OBEX_CLIENT_INTERFACE);
1175         if (mns_proxy == NULL) {
1176                 ERR("Failed to get a proxy for D-Bus\n");
1177                 return;
1178         }
1179
1180         hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1181                                      NULL, (GDestroyNotify)g_free);
1182
1183         addr_value = g_new0(GValue, 1);
1184         g_value_init(addr_value, G_TYPE_STRING);
1185         g_value_set_string(addr_value, address);
1186         g_hash_table_insert(hash, "Destination", addr_value);
1187
1188         tgt_value = g_new0(GValue, 1);
1189         g_value_init(tgt_value, G_TYPE_STRING);
1190         g_value_set_string(tgt_value, "MNS");
1191         g_hash_table_insert(hash, "Target", tgt_value);
1192
1193         dbus_g_proxy_call(mns_proxy, "CreateSession", &error,
1194                 dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
1195                 hash, G_TYPE_INVALID,
1196                 DBUS_TYPE_G_OBJECT_PATH, &session_path,
1197                 G_TYPE_INVALID);
1198         if (error) {
1199                 DBG("Error [%s]", error->message);
1200                 g_error_free(error);
1201                 g_hash_table_destroy(hash);
1202                 g_object_unref(mns_proxy);
1203                 return;
1204         }
1205
1206         g_mns_path = g_strdup(session_path);
1207         DBG("g_mns_path = %s\n", g_mns_path);
1208
1209         g_hash_table_destroy(hash);
1210         g_object_unref(mns_proxy);
1211
1212         DBG("-\n");
1213         return;
1214 }
1215
1216 static void __bt_mns_client_disconnect()
1217 {
1218         DBusGProxy *mns_proxy;
1219         GError *error = NULL;
1220
1221         if (!g_mns_path)
1222                 return;
1223
1224         mns_proxy = dbus_g_proxy_new_for_name(g_connection, OBEX_CLIENT_SERVICE,
1225                                                 OBEX_CLIENT_PATH,
1226                                                 OBEX_CLIENT_INTERFACE);
1227         if (mns_proxy == NULL) {
1228                 DBG("Failed to get a proxy for D-Bus\n");
1229                 return;
1230         }
1231
1232         dbus_g_proxy_call(mns_proxy, "RemoveSession", &error,
1233                 DBUS_TYPE_G_OBJECT_PATH, g_mns_path,
1234                 G_TYPE_INVALID, G_TYPE_INVALID);
1235         if (error) {
1236                 DBG("Error [%s]", error->message);
1237                 g_error_free(error);
1238                 g_object_unref(mns_proxy);
1239                 return;
1240         }
1241
1242         g_free(g_mns_path);
1243         g_mns_path = NULL;
1244
1245         g_object_unref(mns_proxy);
1246
1247         DBG("-\n");
1248         return;
1249 }
1250
1251 static gboolean bluetooth_map_get_folder_tree(BluetoothMapAgent *agent,
1252                                                 DBusGMethodInvocation *context)
1253 {
1254         GPtrArray *array = g_ptr_array_new();
1255         GValue value;
1256         GError *error = NULL;
1257
1258         char name[BT_MAP_MSG_INFO_MAX] = {0,};
1259         char folder_name[BT_MAP_MSG_INFO_MAX] = {0,};
1260         int i;
1261         int ret;
1262         gboolean msg_ret = TRUE;
1263
1264         msg_struct_list_s g_folderList;
1265         msg_struct_t p_folder;
1266
1267 #ifdef SUPPORT_EMAIL
1268         int j;
1269         int account_id = 0;
1270         int mailbox_count = 0;
1271         gboolean flag = FALSE;
1272         email_mailbox_t *mailbox_list = NULL;
1273 #endif
1274
1275         if (g_msg_handle == NULL) {
1276                 msg_ret = FALSE;
1277                 goto done;
1278         }
1279
1280         if (msg_get_folder_list(g_msg_handle, &g_folderList) != MSG_SUCCESS) {
1281                 msg_ret = FALSE;
1282                 goto done;
1283         }
1284
1285         for (i = 0; i < g_folderList.nCount; i++) {
1286                 p_folder = g_folderList.msg_struct_info[i];
1287                 memset(folder_name, 0x00, BT_MAP_MSG_INFO_MAX);
1288
1289                 ret = msg_get_str_value(p_folder, MSG_FOLDER_INFO_NAME_STR,
1290                                         folder_name, BT_MAP_MSG_INFO_MAX);
1291                 if (ret != MSG_SUCCESS)
1292                         continue;
1293
1294                 if (!g_ascii_strncasecmp(folder_name, BT_MAP_SENT_FOLDER_NAME,
1295                                         strlen(BT_MAP_SENT_FOLDER_NAME))) {
1296                         memset(folder_name, 0, sizeof(folder_name));
1297                         g_strlcpy(folder_name, BT_MAP_SENT_FOLDER_NAME,
1298                                                         sizeof(folder_name));
1299                 }
1300
1301                 g_strlcpy(name, folder_name, sizeof(name));
1302                 memset(&value, 0, sizeof(GValue));
1303                 g_value_init(&value, DBUS_STRUCT_STRING_STRING_UINT);
1304                 g_value_take_boxed(&value, dbus_g_type_specialized_construct(
1305                                         DBUS_STRUCT_STRING_STRING_UINT));
1306                 dbus_g_type_struct_set(&value, 0, name, G_MAXUINT);
1307                 g_ptr_array_add(array, g_value_get_boxed(&value));
1308         }
1309
1310 #ifdef SUPPORT_EMAIL
1311 email:
1312         if (EMAIL_ERROR_NONE != email_load_default_account_id(&account_id))
1313                 goto done;
1314
1315         if (EMAIL_ERROR_NONE != email_get_mailbox_list(account_id,
1316                                                         EMAIL_MAILBOX_ALL,
1317                                                         &mailbox_list,
1318                                                         &mailbox_count)) {
1319                 goto done;
1320         }
1321
1322         msg_ret = TRUE;
1323
1324         for (i = 0; i < mailbox_count; i++) {
1325                 flag = FALSE;
1326                 for (j = 0; j < g_folderList.nCount; j++) {
1327
1328                         p_folder = g_folderList.msg_struct_info[j];
1329                         memset(folder_name, 0x00, BT_MAP_MSG_INFO_MAX);
1330
1331                         ret = msg_get_str_value(p_folder,
1332                                                 MSG_FOLDER_INFO_NAME_STR,
1333                                                 folder_name,
1334                                                 BT_MAP_MSG_INFO_MAX);
1335                         if (ret != MSG_SUCCESS)
1336                                 continue;
1337
1338                         if (!g_ascii_strncasecmp(mailbox_list[i].alias,
1339                                 folder_name, strlen(mailbox_list[i].alias))) {
1340                                 flag = TRUE;
1341                                 break;
1342                         }
1343                 }
1344
1345                 if (!flag) {
1346                         g_strlcpy(name, mailbox_list[i].alias, sizeof(name));
1347
1348                         if (!g_ascii_strncasecmp(name, BT_MAP_SENT_FOLDER_NAME,
1349                                         strlen(BT_MAP_SENT_FOLDER_NAME)))
1350                                 continue;
1351
1352                         memset(&value, 0, sizeof(GValue));
1353                         g_value_init(&value, DBUS_STRUCT_STRING_STRING_UINT);
1354                         g_value_take_boxed(&value,
1355                                 dbus_g_type_specialized_construct(
1356                                 DBUS_STRUCT_STRING_STRING_UINT));
1357                         dbus_g_type_struct_set(&value, 0, name, G_MAXUINT);
1358                         g_ptr_array_add(array, g_value_get_boxed(&value));
1359                 }
1360         }
1361
1362         if (mailbox_list != NULL)
1363                  email_free_mailbox(&mailbox_list, mailbox_count);
1364 #endif
1365
1366 done:
1367
1368         if (msg_ret == FALSE) {
1369                 g_ptr_array_free(array, TRUE);
1370
1371                 error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
1372                                                 "InternalError");
1373                 dbus_g_method_return_error(context, error);
1374                 g_error_free(error);
1375                 return FALSE;
1376         } else {
1377                 dbus_g_method_return(context, array);
1378                 g_ptr_array_free(array, TRUE);
1379                 return TRUE;
1380         }
1381 }
1382
1383 static gboolean bluetooth_map_get_message_list(BluetoothMapAgent *agent,
1384                                                 gchar *folder_name, guint16 max,
1385                                                 DBusGMethodInvocation *context)
1386 {
1387         GPtrArray *array = g_ptr_array_new();
1388         GValue value;
1389         GError *error = NULL;
1390
1391         char *folder = NULL;
1392         int i = 0;
1393         int ret = 0;
1394         int folder_id = 0;
1395         int unread_cnt;
1396         guint64 count;
1397         gboolean newmsg;
1398
1399         msg_struct_list_s g_folderList;
1400         msg_struct_list_s msg_list;
1401         msg_struct_t count_info;
1402
1403 #ifdef SUPPORT_EMAIL
1404         int total = 0;
1405         int account_id = 0;
1406         int mailbox_count = 0;
1407         int mail_count = 0;
1408         char *type = NULL;
1409         char msg_datetime[BT_MAP_TIMESTAMP_MAX_LEN] = {0,};
1410         email_mailbox_t *mailbox_list = NULL;
1411         email_mail_list_item_t *mail_list = NULL;
1412         email_list_filter_t *filter_list = NULL;
1413         email_list_sorting_rule_t *sorting_rule_list = NULL;
1414 #endif
1415
1416         if (g_msg_handle == NULL)
1417                 goto fail;
1418
1419         folder = strrchr(folder_name, '/');
1420         if (NULL == folder)
1421                 folder = folder_name;
1422         else
1423                 folder++;
1424
1425         ret = msg_get_folder_list(g_msg_handle, &g_folderList);
1426         if (ret != MSG_SUCCESS)
1427                 goto fail;
1428
1429         for (i = 0; i < g_folderList.nCount; i++) {
1430                 msg_struct_t pFolder = g_folderList.msg_struct_info[i];
1431                 char folderName[BT_MAP_MSG_INFO_MAX] = {0, };
1432
1433                 ret = msg_get_str_value(pFolder, MSG_FOLDER_INFO_NAME_STR,
1434                                         folderName, BT_MAP_MSG_INFO_MAX);
1435                 if (ret  != MSG_SUCCESS)
1436                         continue;
1437
1438                 if (!g_ascii_strncasecmp(folderName, folder, strlen(folder))) {
1439                         ret = msg_get_int_value(pFolder, MSG_FOLDER_INFO_ID_INT,
1440                                                                 &folder_id);
1441                         if (ret != MSG_SUCCESS)
1442                                 goto fail;
1443                         else
1444                                 DBG("folder_id %d \n", folder_id);
1445
1446                         break;
1447                 }
1448         }
1449
1450         ret = msg_get_folder_view_list(g_msg_handle, folder_id,
1451                                                         NULL, &msg_list);
1452         if (ret  != MSG_SUCCESS)
1453                 goto fail;
1454
1455         count = msg_list.nCount;
1456
1457         count_info = msg_create_struct(MSG_STRUCT_COUNT_INFO);
1458         ret = msg_count_message(g_msg_handle, folder_id, count_info);
1459         if (ret != MSG_SUCCESS) {
1460                 msg_release_struct(&count_info);
1461                 goto fail;
1462         }
1463
1464         ret = msg_get_int_value(count_info, MSG_COUNT_INFO_UNREAD_INT,
1465                                                                 &unread_cnt);
1466         if (ret != MSG_SUCCESS) {
1467                 msg_release_struct(&count_info);
1468                 goto fail;
1469         }
1470
1471         if (unread_cnt != 0)
1472                 newmsg = TRUE;
1473         else
1474                 newmsg = FALSE;
1475
1476         msg_release_struct(&count_info);
1477
1478         DBG("MaxlistCount %d \n", max);
1479         if (max == 0)
1480                 goto done;
1481
1482         for (i = 0; i < msg_list.nCount; i++) {
1483
1484                 struct message_info msg_info;
1485
1486                 memset(&value, 0, sizeof(GValue));
1487                 g_value_init(&value, DBUS_STRUCT_MESSAGE_LIST);
1488                 g_value_take_boxed(&value, dbus_g_type_specialized_construct(
1489                                                 DBUS_STRUCT_MESSAGE_LIST));
1490
1491                 msg_info = __bt_message_info_get(msg_list.msg_struct_info[i]);
1492
1493 /* Keeping the bleow debug till stabilization is done. */
1494
1495 /*
1496         DBG("msg_info.handle = %s\n", msg_info.handle);
1497         DBG("msg_info.subject = %s\n", msg_info.subject);
1498         DBG("msg_info.datetime = %s\n", msg_info.datetime);
1499         DBG("msg_info.sender_name = %s\n", msg_info.sender_name);
1500         DBG("msg_info.sender_addressing = %s\n", msg_info.sender_addressing);
1501         DBG("msg_info.replyto_addressing = %s\n", msg_info.replyto_addressing);
1502         DBG("msg_info.recipient_name = %s\n", msg_info.recipient_name);
1503         DBG("msg_info.recipient_addressing = %s\n",
1504                                         msg_info.recipient_addressing);
1505         DBG("msg_info.type = %s\n", msg_info.type);
1506         DBG("msg_info.reception_status = %s\n", msg_info.reception_status);
1507         DBG("msg_info.size = %s\n", msg_info.size);
1508         DBG("msg_info.attachment_size = %s\n", msg_info.attachment_size);
1509         DBG("msg_info.text = %d\n", msg_info.text);
1510         DBG("msg_info.read = %d\n", msg_info.read);
1511         DBG("msg_info.sent = %d\n", msg_info.sent);
1512         DBG("msg_info.protect = %d\n", msg_info.protect);
1513         DBG("msg_info.priority = %d\n", msg_info.priority);
1514 */
1515
1516                 dbus_g_type_struct_set(&value, 0, msg_info.handle,
1517                                         1, msg_info.subject,
1518                                         2, msg_info.datetime,
1519                                         3, msg_info.sender_name,
1520                                         4, msg_info.sender_addressing,
1521                                         5, msg_info.recipient_name,
1522                                         6, msg_info.recipient_addressing,
1523                                         7, msg_info.type,
1524                                         8, msg_info.size,
1525                                         9, msg_info.reception_status,
1526                                         10, msg_info.text,
1527                                         11, msg_info.attachment_size,
1528                                         12, msg_info.priority,
1529                                         13, msg_info.read,
1530                                         14, msg_info.sent,
1531                                         15, msg_info.protect,
1532                                         16, msg_info.replyto_addressing, G_MAXUINT);
1533                 g_ptr_array_add(array, g_value_get_boxed(&value));
1534
1535                 __bt_message_info_free(msg_info);
1536         }
1537
1538 #ifdef SUPPORT_EMAIL
1539 email:
1540         if (EMAIL_ERROR_NONE != email_load_default_account_id(&account_id)) {
1541                 if (!msg_ret)
1542                         goto fail;
1543         }
1544
1545         if (EMAIL_ERROR_NONE != email_get_mailbox_list(account_id,
1546                                                         EMAIL_MAILBOX_ALL,
1547                                                         &mailbox_list,
1548                                                         &mailbox_count)) {
1549                 if (!msg_ret)
1550                         goto fail;
1551         }
1552
1553         if (mailbox_list == NULL)
1554                 goto fail;
1555
1556         for (i = 0; i < mailbox_count; i++) {
1557                 DBG("mailbox alias = %s \n", mailbox_list[i].alias);
1558                 if (!g_ascii_strncasecmp(mailbox_list[i].alias, folder,
1559                         strlen(folder))) {
1560                         total = mailbox_list[i].total_mail_count_on_server;
1561                         DBG("Total mail on sever:%d\n", total);
1562                         DBG("mailbox name:%s\n", mailbox_list[i].mailbox_name);
1563
1564                         break;
1565                 }
1566
1567                 if (!msg_ret)
1568                         goto fail;
1569                 else
1570                         goto done;
1571         }
1572
1573         /* Need to modify the filter code, have to make it dynamic
1574            based on remote device request Also to check whether it needs
1575            to be done in agent or in obexd */
1576
1577         filter_list = g_new0(email_list_filter_t, 3);
1578         filter_list[0].list_filter_item_type = EMAIL_LIST_FILTER_ITEM_RULE;
1579         filter_list[0].list_filter_item.rule.target_attribute =
1580                                                 EMAIL_MAIL_ATTRIBUTE_ACCOUNT_ID;
1581         filter_list[0].list_filter_item.rule.rule_type =
1582                                                 EMAIL_LIST_FILTER_RULE_EQUAL;
1583         filter_list[0].list_filter_item.rule.key_value.integer_type_value =
1584                                                                 account_id;
1585
1586         filter_list[1].list_filter_item_type = EMAIL_LIST_FILTER_ITEM_OPERATOR;
1587         filter_list[1].list_filter_item.operator_type =
1588                                                 EMAIL_LIST_FILTER_OPERATOR_AND;
1589
1590         filter_list[2].list_filter_item_type = EMAIL_LIST_FILTER_ITEM_RULE;
1591         filter_list[2].list_filter_item.rule.target_attribute =
1592                                         EMAIL_MAIL_ATTRIBUTE_MAILBOX_NAME;
1593         filter_list[2].list_filter_item.rule.rule_type =
1594                                                 EMAIL_LIST_FILTER_RULE_EQUAL;
1595         type = g_strdup(mailbox_list[i].mailbox_name);
1596         filter_list[2].list_filter_item.rule.key_value.string_type_value = type;
1597         filter_list[2].list_filter_item.rule.case_sensitivity = true;
1598
1599         sorting_rule_list = g_new0(email_list_sorting_rule_t, 1);
1600         sorting_rule_list->target_attribute = EMAIL_MAIL_ATTRIBUTE_DATE_TIME;
1601         sorting_rule_list->sort_order = EMAIL_SORT_ORDER_ASCEND;
1602
1603         ret = email_get_mail_list_ex(filter_list, 3,
1604                                         sorting_rule_list, 1, 0, total - 1,
1605                                         &mail_list, &mail_count);
1606
1607         DBG("email API ret %d  \n", ret);
1608         if (ret != EMAIL_ERROR_NONE) {
1609                 if (!msg_ret) {
1610                         g_free(type);
1611                         g_free(filter_list);
1612                         g_free(sorting_rule_list);
1613                         goto fail;
1614                 } else
1615                         goto done;
1616         }
1617
1618         for (i = 0; i < mail_count; ++i) {
1619                 time_t time = {0,};
1620                 memset(&value, 0, sizeof(GValue));
1621                 g_value_init(&value, DBUS_STRUCT_MESSAGE_LIST);
1622                 g_value_take_boxed(&value, dbus_g_type_specialized_construct(
1623                                         DBUS_STRUCT_MESSAGE_LIST));
1624
1625                 uid = __bt_add_id(mail_list[i].mail_id);
1626                 snprintf(msg_handle, sizeof(msg_handle), "%llx", uid);
1627
1628                 g_strlcpy(msg_type,  "EMAIL", sizeof(msg_type));
1629
1630                 time = mail_list[i].date_time;
1631                 __get_msg_timestamp(&time, msg_datetime);
1632
1633                 dbus_g_type_struct_set(&value, 0, msg_handle, 1, msg_type,
1634                                         2, msg_datetime, G_MAXUINT);
1635                 g_ptr_array_add(array, g_value_get_boxed(&value));
1636         }
1637
1638         if (mailbox_list != NULL)
1639                  email_free_mailbox(&mailbox_list, mailbox_count);
1640         if (mail_list != NULL)
1641                 g_free(mail_list);
1642
1643         g_free(filter_list);
1644         g_free(sorting_rule_list);
1645         g_free(type);
1646 #endif
1647
1648 done:
1649         DBG("Request completed \n");
1650         dbus_g_method_return(context, newmsg, count, array);
1651         g_ptr_array_free(array, TRUE);
1652         DBG("Request completed successfully \n");
1653         return TRUE;
1654
1655 fail:
1656         g_ptr_array_free(array, TRUE);
1657         error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
1658                                                           "InternalError");
1659         dbus_g_method_return_error(context, error);
1660         g_error_free(error);
1661         return FALSE;
1662 }
1663
1664 static gboolean bluetooth_map_get_message(BluetoothMapAgent *agent,
1665                                                 gchar *message_name,
1666                                                 gboolean attach,
1667                                                 gboolean transcode,
1668                                                 gboolean first_request,
1669                                                 DBusGMethodInvocation *context)
1670 {
1671         DBG("+ \n");
1672         char *buf = NULL;
1673         int message_id = 0;
1674         int msg_type = BT_SMS;
1675
1676         GError *error = NULL;
1677
1678         msg_struct_t msg = NULL;
1679         msg_struct_t send_opt = NULL;
1680 #ifdef SUPPORT_EMAIL
1681         email_mail_data_t *mail_data = NULL;
1682 #endif
1683         message_id = __bt_get_uid(message_name);
1684         if (message_id == -1)
1685                 goto fail;
1686
1687         DBG("message_id %d \n", message_id);
1688         DBG("msg_type %d \n", msg_type);
1689         DBG("attach %d \n", attach);
1690         DBG("transcode %d \n", transcode);
1691         DBG("first_request %d \n", first_request);
1692
1693         if (msg_type == BT_SMS) {
1694                 if (g_msg_handle == NULL)
1695                         goto fail;
1696
1697                 msg_error_t msg_err;
1698
1699                 msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1700                 send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
1701
1702                 msg_err = msg_get_message(g_msg_handle,
1703                                                 (msg_message_id_t)message_id,
1704                                                 msg, send_opt);
1705                 if (msg_err != MSG_SUCCESS)
1706                         goto fail;
1707
1708                 buf = __bt_prepare_msg_bmseg(msg, attach, transcode);
1709
1710                 msg_release_struct(&msg);
1711                 msg_release_struct(&send_opt);
1712 #ifdef SUPPORT_EMAIL
1713         } else if (msg_type == BT_EMAIL) {
1714
1715                 FILE *body_file;
1716                 int account_id;
1717                 long read_size;
1718                 long email_size;
1719
1720                 if (EMAIL_ERROR_NONE !=
1721                                 email_load_default_account_id(&account_id))
1722                         goto fail;
1723
1724                 if (EMAIL_ERROR_NONE !=
1725                                 email_get_mail_data(message_id, &mail_data))
1726                         goto fail;
1727
1728                 body_file = fopen(mail_data->file_path_plain, "r");
1729                 if (body_file == NULL)
1730                         body_file = fopen(mail_data->file_path_html, "rb");
1731
1732                 if (body_file != NULL) {
1733                         fseek(body_file , 0, SEEK_END);
1734                         email_size = ftell(body_file);
1735                         rewind(body_file);
1736
1737                         buf = (char *)g_malloc0(sizeof(char) * email_size);
1738
1739                         read_size = fread(buf, 1, email_size, body_file);
1740
1741                         fclose(body_file);
1742
1743                         if (read_size != email_size)
1744                                 goto fail;
1745                 } else
1746                         buf = (char *)g_strdup("");
1747
1748                 email_free_mail_data(&mail_data, 1);
1749 #endif
1750         } else {
1751                 DBG("msg_type not supported %d \n", msg_type);
1752                 goto fail;
1753         }
1754
1755         dbus_g_method_return(context, FALSE, buf);
1756         g_free(buf);
1757
1758         DBG("- \n");
1759         return TRUE;
1760
1761 fail:
1762         g_free(buf);
1763
1764         if (msg)
1765                 msg_release_struct(&msg);
1766
1767         if (send_opt)
1768                 msg_release_struct(&send_opt);
1769
1770 #ifdef SUPPORT_EMAIL
1771         if (mail_data)
1772                 email_free_mail_data(&mail_data, 1);
1773 #endif
1774
1775         error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
1776                                                         "InternalError");
1777         dbus_g_method_return_error(context, error);
1778         g_error_free(error);
1779         return FALSE;
1780 }
1781
1782 static gboolean bluetooth_map_push_message(BluetoothMapAgent *agent,
1783                                         gboolean save_copy,
1784                                         gboolean retry_send,
1785                                         gboolean native,
1786                                         gchar *folder_name,
1787                                         DBusGMethodInvocation *context)
1788 {
1789         DBG("+\n");
1790         GError *error = NULL;
1791         guint64 handle = 0;
1792         int folder_id;
1793
1794         DBG("folder_name = %s\n", folder_name);
1795
1796         folder_id = __bt_get_folder_id(folder_name);
1797         if (folder_id == -1)
1798                 goto fail;
1799
1800         handle = __bt_add_id(-1);
1801         current_push_map_id = handle;
1802
1803         /* FALSE : Keep messages in Sent folder */
1804         /* TRUE : don't keep messages in sent folder */
1805         opt.save_copy = save_copy;
1806         DBG("opt.save_copy = %d\n", opt.save_copy);
1807
1808         /* FALSE : don't retry */
1809         /* TRUE  : retry */
1810         opt.retry_send = retry_send;
1811         DBG("opt.retry_send = %d\n", opt.retry_send);
1812
1813         /* FALSE : native */
1814         /* TRUE : UTF-8 */
1815         opt.native = native;
1816         DBG("opt.native = %d\n", opt.native);
1817
1818         dbus_g_method_return(context, handle);
1819         DBG("-\n");
1820         return TRUE;
1821 fail:
1822         error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
1823                                                 "InternalError");
1824         dbus_g_method_return_error(context, error);
1825         g_error_free(error);
1826
1827         return FALSE;
1828 }
1829
1830 static gboolean bluetooth_map_push_message_data(BluetoothMapAgent *agent,
1831                                         gchar *bmsg,
1832                                         DBusGMethodInvocation *context)
1833 {
1834         DBG("+\n");
1835         int id = -1;
1836         int folder_id;
1837         char *folder = NULL;
1838         char *body = NULL;
1839         GSList *recepients = NULL;
1840         gboolean send = FALSE;
1841
1842         GError *error = NULL;
1843
1844         DBG("BMSG is \n %s", bmsg);
1845
1846         struct bmsg_data *bmsg_info = NULL;
1847
1848         bmsg_info = bmsg_parse(bmsg);
1849         if (!bmsg_info)
1850                 goto done;
1851
1852         folder = bmsg_get_msg_folder(bmsg_info);
1853         if (folder == NULL)
1854                 goto done;
1855
1856         folder_id = __bt_get_folder_id(bmsg_info->folder);
1857         if (folder_id == -1)
1858                 goto done;
1859
1860         if (MSG_OUTBOX_ID == folder_id)
1861                 send = TRUE;
1862
1863         body = bmsg_get_msg_body(bmsg_info);
1864         if (body == NULL)
1865                 goto done;
1866
1867         recepients = bmsg_get_msg_recepients(bmsg_info);
1868
1869         id = __bt_push_sms(send, folder_id, body, recepients);
1870         if (id == -1)
1871                 goto done;
1872
1873         __bt_update_id(current_push_map_id, id);
1874
1875 done:
1876         g_free(folder);
1877         g_free(body);
1878         g_slist_free(recepients);
1879         g_free(bmsg_info);
1880
1881         if (id == -1) {
1882                 error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
1883                                                         "InternalError");
1884                 dbus_g_method_return_error(context, error);
1885                 g_error_free(error);
1886                 DBG("-\n");
1887                 return FALSE;
1888         }
1889
1890         dbus_g_method_return(context);
1891         DBG("-\n");
1892         return TRUE;
1893 }
1894
1895 static gboolean bluetooth_map_update_message(BluetoothMapAgent *agent,
1896                                                 DBusGMethodInvocation *context)
1897 {
1898         int err = TRUE;
1899 #ifdef SUPPORT_EMAIL
1900         int handle;
1901         err = email_sync_header_for_all_account(&handle);
1902
1903         if (err == EMAIL_ERROR_NONE) {
1904                 DBG("Handle to stop download = %d \n", handle);
1905         } else {
1906                 ERR("Message Update failed \n");
1907         }
1908
1909         dbus_g_method_return(context, err);
1910         return (err == EMAIL_ERROR_NONE) ? TRUE : FALSE;
1911 #else
1912         dbus_g_method_return(context, err);
1913         return TRUE;
1914 #endif
1915 }
1916
1917 static gboolean bluetooth_map_set_read_status(BluetoothMapAgent *agent,
1918                                                 gchar *handle,
1919                                                 gboolean read_status,
1920                                                 DBusGMethodInvocation *context)
1921 {
1922         int message_id = 0;
1923         int msg_type = BT_SMS;
1924 #ifdef SUPPORT_EMAIL
1925         email_mail_data_t *mail_data = NULL;
1926 #endif
1927         GError *error = NULL;
1928
1929         DBG("+\n");
1930
1931         message_id = __bt_get_uid(handle);
1932         if (message_id == -1)
1933                 goto fail;
1934
1935         DBG("message_id = %d,  read_status = %d\n", message_id, read_status);
1936
1937         if (msg_type == BT_SMS) {
1938                 msg_error_t msg_err;
1939                 msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
1940                 msg_struct_t send_opt = msg_create_struct(MSG_STRUCT_SENDOPT);
1941                 int msg_type = 0;
1942
1943                 msg_err = msg_get_message(g_msg_handle,
1944                                                 (msg_message_id_t)message_id,
1945                                                 msg, send_opt);
1946                 if (msg_err != MSG_SUCCESS) {
1947                         msg_release_struct(&msg);
1948                         msg_release_struct(&send_opt);
1949                         goto fail;
1950                 }
1951
1952                 msg_err = msg_get_int_value(msg, MSG_MESSAGE_TYPE_INT,
1953                                                                 &msg_type);
1954                 if (msg_err != MSG_SUCCESS) {
1955                         msg_release_struct(&msg);
1956                         msg_release_struct(&send_opt);
1957                         goto fail;
1958                 }
1959
1960                 msg_err = msg_update_read_status(g_msg_handle, message_id,
1961                                                                 read_status);
1962                 if (msg_err != MSG_SUCCESS) {
1963                         msg_release_struct(&msg);
1964                         msg_release_struct(&send_opt);
1965                         goto fail;
1966                 }
1967
1968                 if (__bt_msg_is_mms(msg_type)) {
1969                         if (read_status == TRUE)
1970                                 msg_err = msg_mms_send_read_report(g_msg_handle,
1971                                                 message_id,
1972                                                 MSG_READ_REPORT_IS_READ);
1973                         else
1974                                 msg_err = msg_mms_send_read_report(g_msg_handle,
1975                                                 message_id,
1976                                                 MSG_READ_REPORT_NONE);
1977                 }
1978
1979                 msg_release_struct(&msg);
1980                 msg_release_struct(&send_opt);
1981
1982                 if (msg_err != MSG_SUCCESS)
1983                         goto fail;
1984 #ifdef SUPPORT_EMAIL
1985         } else if (msg_type == BT_EMAIL) {
1986
1987                 if (email_get_mail_data(message_id, &mail_data) !=
1988                                                         EMAIL_ERROR_NONE) {
1989                         ERR("email_get_mail_data failed\n");
1990                         goto fail;
1991                 }
1992
1993                 if (email_set_flags_field(mail_data->account_id, &message_id, 1,
1994                         EMAIL_FLAGS_SEEN_FIELD, read_status, 0) !=
1995                                                         EMAIL_ERROR_NONE) {
1996                         email_free_mail_data(&mail_data, 1);
1997                         goto fail;
1998                 }
1999
2000                 email_free_mail_data(&mail_data, 1);
2001 #endif
2002         } else
2003                 goto fail;
2004
2005         dbus_g_method_return(context);
2006         DBG("-\n");
2007         return TRUE;
2008
2009 fail:
2010         error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
2011                                                         "InternalError");
2012         dbus_g_method_return_error(context, error);
2013         g_error_free(error);
2014
2015         return FALSE;
2016 }
2017
2018 static gboolean bluetooth_map_set_delete_status(BluetoothMapAgent *agent,
2019                                                 gchar *handle,
2020                                                 gboolean delete_status,
2021                                                 DBusGMethodInvocation *context)
2022 {
2023         int message_id = 0;
2024         int msg_type = BT_SMS;
2025 #ifdef SUPPORT_EMAIL
2026         email_mail_data_t *mail_data = NULL;
2027 #endif
2028         GError *error = NULL;
2029
2030         DBG("+\n");
2031
2032         message_id = __bt_get_uid(handle);
2033         if (message_id == -1)
2034                 goto fail;
2035
2036         DBG("message_id = %d, delete_status = %d\n", message_id, delete_status);
2037
2038         if (msg_type == BT_SMS) {
2039                 if (msg_delete_message(g_msg_handle, message_id) !=
2040                                                                 MSG_SUCCESS) {
2041                         goto fail;
2042                 }
2043 #ifdef SUPPORT_EMAIL
2044         } else if (msg_type == BT_EMAIL) {
2045
2046                 if (email_get_mail_data(message_id, &mail_data) !=
2047                                                         EMAIL_ERROR_NONE)
2048                         goto fail;
2049
2050                 if (email_delete_mail(mail_data->mailbox_id, &message_id,
2051                                                 1, 1) != EMAIL_ERROR_NONE) {
2052                         email_free_mail_data(&mail_data, 1);
2053                         goto fail;
2054                 }
2055
2056                 email_free_mail_data(&mail_data, 1);
2057 #endif
2058         } else
2059                 goto fail;
2060
2061         dbus_g_method_return(context);
2062         DBG("-\n");
2063         return TRUE;
2064
2065 fail:
2066         error = __bt_map_agent_error(BT_MAP_AGENT_ERROR_INTERNAL,
2067                                                         "InternalError");
2068         dbus_g_method_return_error(context, error);
2069         g_error_free(error);
2070         return FALSE;
2071 }
2072
2073 static gboolean bluetooth_map_noti_registration(BluetoothMapAgent *agent,
2074                                                 gchar *remote_addr,
2075                                                 gboolean status,
2076                                                 DBusGMethodInvocation *context)
2077 {
2078         DBG("remote_addr = %s \n", remote_addr);
2079
2080         if (status == TRUE)
2081                 __bt_mns_client_connect(remote_addr);
2082         else
2083                 __bt_mns_client_disconnect();
2084
2085         return TRUE;
2086 }
2087
2088 int main(int argc, char **argv)
2089 {
2090         BluetoothMapAgent *bluetooth_map_obj = NULL;
2091         DBusGProxy *bus_proxy = NULL;
2092         guint result = 0;
2093         GError *error = NULL;
2094
2095         g_type_init();
2096
2097         g_mainloop = g_main_loop_new(NULL, FALSE);
2098
2099         if (g_mainloop == NULL) {
2100                 ERR("Couldn't create GMainLoop\n");
2101                 return EXIT_FAILURE;
2102         }
2103
2104         g_connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
2105
2106         if (error != NULL) {
2107                 ERR("Couldn't connect to system bus[%s]\n", error->message);
2108                 g_error_free(error);
2109                 return EXIT_FAILURE;
2110         }
2111
2112         bus_proxy = dbus_g_proxy_new_for_name(g_connection, DBUS_SERVICE_DBUS,
2113                                                 DBUS_PATH_DBUS,
2114                                                 DBUS_INTERFACE_DBUS);
2115         if (bus_proxy == NULL) {
2116                 ERR("Failed to get a proxy for D-Bus\n");
2117                 goto failure;
2118         }
2119
2120         if (!dbus_g_proxy_call(bus_proxy, "RequestName", &error, G_TYPE_STRING,
2121                                         BT_MAP_SERVICE_NAME, G_TYPE_UINT, 0,
2122                                         G_TYPE_INVALID, G_TYPE_UINT, &result,
2123                                         G_TYPE_INVALID)) {
2124                 if (error != NULL) {
2125                         ERR("RequestName RPC failed[%s]\n", error->message);
2126                         g_error_free(error);
2127                 }
2128                 goto failure;
2129         }
2130         DBG("result : %d %d\n", result, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
2131         if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
2132                 ERR("Failed to get the primary well-known name.\n");
2133                 goto failure;
2134         }
2135
2136         g_object_unref(bus_proxy);
2137         bus_proxy = NULL;
2138
2139         bluetooth_map_obj = g_object_new(BLUETOOTH_MAP_TYPE_AGENT, NULL);
2140         if (bluetooth_map_obj == NULL) {
2141                 ERR("Failed to create one BluetoothMapAgent instance.\n");
2142                 goto failure;
2143         }
2144
2145         /* Registering it on the D-Bus */
2146         dbus_g_connection_register_g_object(g_connection,
2147                                                 BT_MAP_SERVICE_OBJECT_PATH,
2148                                                 G_OBJECT(bluetooth_map_obj));
2149
2150         if (__bluetooth_map_start_service() == FALSE)
2151                 goto failure;
2152
2153         g_main_loop_run(g_mainloop);
2154
2155  failure:
2156         DBG("Terminate the bluetooth-map-agent\n");
2157
2158         __bt_remove_list(id_list);
2159
2160         if (g_mns_path)
2161                 __bt_mns_client_disconnect();
2162         if (bus_proxy)
2163                 g_object_unref(bus_proxy);
2164         if (bluetooth_map_obj)
2165                 g_object_unref(bluetooth_map_obj);
2166         if (g_connection)
2167                 dbus_g_connection_unref(g_connection);
2168
2169
2170         __bluetooth_map_stop_service();
2171         return EXIT_FAILURE;
2172 }