4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
7 * Girishashok Joshi <girish.joshi@samsung.com>
8 * Chanyeol Park <chanyeol.park@samsung.com>
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
14 * http://www.apache.org/licenses/LICENSE-2.0
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.
32 #include "vconf-keys.h"
34 #include <sys/types.h>
37 /*Messaging Header Files*/
39 #include "msg_storage.h"
40 #include "msg_storage_types.h"
41 #include "msg_transport.h"
42 #include "msg_transport_types.h"
43 #include "msg_types.h"
46 #include <TapiUtility.h>
47 #include <ITapiNetText.h>
48 #include <bluetooth_map_agent.h>
49 #include <bluetooth_map_email.h>
50 #include <bluetooth_map_sms.h>
51 #include <map_bmessage.h>
53 #define OBEX_CLIENT_SERVICE "org.bluez.obex"
54 #define OBEX_CLIENT_INTERFACE "org.bluez.obex.Client1"
55 #define OBEX_CLIENT_PATH "/org/bluez/obex"
56 #define MNS_CLIENT_INTERFACE "org.openobex.MessageNotification"
58 #define BT_MAP_NEW_MESSAGE "NewMessage"
59 #define BT_MAP_STATUS_CB "sent status callback"
60 #define BT_MAP_MSG_CB "sms message callback"
61 #define BT_MNS_OBJECT_PATH "/org/bluez/mns"
62 #define BT_MNS_INTERFACE "org.bluez.mns"
63 #define BT_MAP_SENT_FOLDER_NAME "SENT"
64 #define BT_MAP_MSG_TEMPLATE "TEMPLATE"
65 #define BT_MAP_DELETED_FOLDER_NAME "DELETED"
66 #define BT_MAP_MSG_INFO_MAX 256
67 #define BT_MAP_MSG_HANDLE_MAX 21
68 #define BT_MAP_TIMESTAMP_MAX_LEN 16
69 #define BT_MAP_MSG_BODY_MAX 1024
70 #define BT_MSG_UPDATE 0
71 #define BT_MSG_DELETE 1
74 static TapiHandle *g_tapi_handle;
75 static TelSmsAddressInfo_t *g_sca_info;
77 GSList *id_list = NULL;
78 guint64 current_push_map_id;
80 msg_send_option_t opt;
83 SMS_TON_UNKNOWN = 0, /* unknown */
84 SMS_TON_INTERNATIONAL = 1, /* international number */
85 SMS_TON_NATIONAL = 2, /* national number */
86 SMS_TON_NETWORK_SPECIFIC = 3, /* network specific number */
87 SMS_TON_DEDICATED_ACCESS = 4, /* subscriber number */
88 SMS_TON_ALPHA_NUMERIC = 5, /* alphanumeric, GSM 7-bit default */
89 SMS_TON_ABBREVIATED_NUMBER = 6, /* abbreviated number */
90 SMS_TON_RESERVED_FOR_EXT = 7 /* reserved for extension */
91 } bt_sim_type_of_num_t;
99 /* Store supported folders in SMS and EMAIL */
100 gboolean folders_supported[FOLDER_COUNT][MSG_TYPES] = { {FALSE, FALSE}, };
102 GMainLoop *g_mainloop;
103 static char *g_mns_path;
104 static GDBusConnection *map_dbus_conn;
105 static GDBusProxy *g_mns_proxy;
107 static const gchar map_agent_introspection_xml[] =
109 " <interface name='org.bluez.MapAgent'>"
110 " <method name='GetFolderTree'>"
111 " <arg type='a(s)' name='folder_list' direction='out'/>"
113 " <method name='GetMessageList'>"
114 " <arg type='s' name='folder_name'/>"
115 " <arg type='q' name='max'/>"
116 " <arg type='q' name='offset'/>"
117 " <arg type='y' name='subject_len'/>"
118 " <arg type='a{sv}' name='filters'/>"
119 " <arg type='b' name='newmessage' direction='out'/>"
120 " <arg type='t' name='count' direction='out'/>"
121 " <arg type='a(ssssssssssbsbbbbs)' name='msg_list' direction='out'/>"
123 " <method name='GetMessage'>"
124 " <arg type='s' name='message_name'/>"
125 " <arg type='b' name='attach'/>"
126 " <arg type='b' name='transcode'/>"
127 " <arg type='b' name='first_request'/>"
128 " <arg type='b' name='fraction_deliver' direction='out'/>"
129 " <arg type='s' name='msg_body' direction='out'/>"
131 " <method name='PushMessage'>"
132 " <arg type='b' name='save_copy'/>"
133 " <arg type='b' name='retry_send'/>"
134 " <arg type='b' name='native'/>"
135 " <arg type='s' name='folder_name'/>"
136 " <arg type='t' name='handle' direction='out'/>"
138 " <method name='PushMessageData'>"
139 " <arg type='s' name='bmsg'/>"
141 " <method name='UpdateMessage'>"
142 " <arg type='u' name='update_err' direction='out'/>"
144 " <method name='SetReadStatus'>"
145 " <arg type='s' name='handle'/>"
146 " <arg type='b' name='read_status'/>"
147 " <arg type='u' name='update_err' direction='out'/>"
149 " <method name='SetDeleteStatus'>"
150 " <arg type='s' name='handle'/>"
151 " <arg type='b' name='delete_status'/>"
152 " <arg type='u' name='update_err' direction='out'/>"
154 " <method name='NotiRegistration'>"
155 " <arg type='s' name='remote_addr'/>"
156 " <arg type='b' name='status'/>"
157 " <arg type='u' name='update_err' direction='out'/>"
159 " <method name='DestroyAgent'>"
164 /* Method Prototypes */
165 static GVariant *__bt_map_get_folder_tree(GError **err);
166 static GVariant *__bt_map_get_message_list(char *folder_name, guint16 max,
167 guint16 offset, guint8 subject_len,
168 map_msg_filter_t *filter, GError **err);
169 static GVariant *__bt_map_get_message(char *message_name, gboolean attach,
170 gboolean transcode, gboolean first_request, GError **err);
171 static GVariant *__bt_map_push_message(gboolean save_copy, gboolean retry_send,
172 gboolean native, char *folder_name, GError **err);
173 static GVariant *__bt_map_push_message_data(char *bmseg, GError **err);
174 static GVariant *__bt_map_update_message(GError **err);
175 static GVariant *__bt_map_set_read_status(char *handle, gboolean read_status, GError **err);
176 static GVariant *__bt_map_set_delete_status(char *handle, gboolean delete_status, GError **err);
177 static void __bt_map_noti_registration(char *remote_addr, gboolean status);
178 static void __bt_map_destroy_agent(void);
180 /* LCOV_EXCL_START */
181 /* Create GError from error code and error message */
182 static GError *__bt_map_error(int error_code, char *error_message)
184 return g_error_new(g_quark_from_string("MAP Agent"),
185 error_code, "MAP Agent Error: %s", error_message);
188 static map_msg_filter_t __bt_map_get_filters(GVariant *filters)
190 map_msg_filter_t filter = { 0, };
195 g_variant_iter_init(&iter, filters);
196 while (g_variant_iter_loop(&iter, "{sv}", &key, &value)) {
197 if (!g_strcmp0(key, "ParameterMask")) {
198 filter.parameter_mask = g_variant_get_uint32(value);
199 DBG("ParameterMask :%u", filter.parameter_mask);
200 } else if (!g_strcmp0(key, "FilterMessageType")) {
201 filter.type = g_variant_get_byte(value);
202 DBG("FilterMessageType :%u", filter.type);
203 } else if (!g_strcmp0(key, "FilterPeriodBegin")) {
204 g_variant_get(value, "s", &filter.period_begin);
205 DBG("FilterPeriodBegin :%s", filter.period_begin);
206 } else if (!g_strcmp0(key, "FilterPeriodEnd")) {
207 g_variant_get(value, "s", &filter.period_end);
208 DBG("FilterPeriodEnd :%s", filter.period_end);
209 } else if (!g_strcmp0(key, "FilterReadStatus")) {
210 filter.read_status = g_variant_get_byte(value);
211 DBG("FilterReadStatus :%u", filter.read_status);
212 } else if (!g_strcmp0(key, "FilterRecipient")) {
213 g_variant_get(value, "s", &filter.recipient);
214 DBG("FilterRecipient :%s", filter.recipient);
215 } else if (!g_strcmp0(key, "FilterOriginator")) {
216 g_variant_get(value, "s", &filter.originator);
217 DBG("FilterOriginator :%s", filter.originator);
218 } else if (!g_strcmp0(key, "FilterPriority")) {
219 filter.priority = g_variant_get_byte(value);
220 DBG("FilterPriority :%u", filter.priority);
227 static void __bt_map_agent_method(GDBusConnection *connection,
229 const gchar *object_path,
230 const gchar *interface_name,
231 const gchar *method_name,
232 GVariant *parameters,
233 GDBusMethodInvocation *invocation,
238 INFO("method %s", method_name);
239 INFO("object_path %s", object_path);
242 if (g_strcmp0(method_name, "GetFolderTree") == 0) {
243 GVariant *folder_list = NULL;
245 folder_list = __bt_map_get_folder_tree(&err);
249 g_dbus_method_invocation_return_value(invocation, folder_list);
250 } else if (g_strcmp0(method_name, "GetMessageList") == 0) {
251 GVariant *message_list = NULL;
256 GVariant *filters = NULL;
257 map_msg_filter_t filter = { 0, };
259 g_variant_get(parameters, "(&sqqy@a{sv})", &folder_name,
260 &max, &offset, &subject_len, &filters);
262 DBG("MAX:%d Offset:%d SubjectLen:%d", max, offset, subject_len);
263 if (subject_len == 0)
264 subject_len = BT_MAP_SUBJECT_MAX_LEN;
266 filter = __bt_map_get_filters(filters);
267 message_list = __bt_map_get_message_list(folder_name, max,
268 offset, subject_len, &filter, &err);
273 g_dbus_method_invocation_return_value(invocation, message_list);
274 } else if (g_strcmp0(method_name, "GetMessage") == 0) {
275 GVariant *message = NULL;
279 gboolean first_request;
281 g_variant_get(parameters, "(&sbbb)", &message_name,
282 &attach, &transcode, &first_request);
284 message = __bt_map_get_message(message_name, attach,
285 transcode, first_request, &err);
289 g_dbus_method_invocation_return_value(invocation, message);
290 } else if (g_strcmp0(method_name, "PushMessage") == 0) {
291 GVariant *handle = NULL;
297 g_variant_get(parameters, "(bbb&s)", &save_copy,
298 &retry_send, &native, &folder_name);
300 handle = __bt_map_push_message(save_copy, retry_send,
301 native, folder_name, &err);
305 g_dbus_method_invocation_return_value(invocation, handle);
306 } else if (g_strcmp0(method_name, "PushMessageData") == 0) {
309 g_variant_get(parameters, "(&s)", &bmseg);
311 __bt_map_push_message_data(bmseg, &err);
315 g_dbus_method_invocation_return_value(invocation, NULL);
316 } else if (g_strcmp0(method_name, "UpdateMessage") == 0) {
317 GVariant *update = NULL;
319 update = __bt_map_update_message(&err);
323 g_dbus_method_invocation_return_value(invocation, update);
324 } else if (g_strcmp0(method_name, "SetReadStatus") == 0) {
326 gboolean read_status;
328 g_variant_get(parameters, "(&sb)", &handle, &read_status);
330 __bt_map_set_read_status(handle, read_status, &err);
334 g_dbus_method_invocation_return_value(invocation, NULL);
335 } else if (g_strcmp0(method_name, "SetDeleteStatus") == 0) {
337 gboolean delete_status;
339 g_variant_get(parameters, "(&sb)", &handle, &delete_status);
341 __bt_map_set_delete_status(handle, delete_status, &err);
345 g_dbus_method_invocation_return_value(invocation, NULL);
346 } else if (g_strcmp0(method_name, "NotiRegistration") == 0) {
349 g_variant_get(parameters, "(&sb)", &remote_addr, &status);
351 __bt_map_noti_registration(remote_addr, status);
352 g_dbus_method_invocation_return_value(invocation, NULL);
353 } else if (g_strcmp0(method_name, "DestroyAgent") == 0) {
354 g_dbus_method_invocation_return_value(invocation, NULL);
355 __bt_map_destroy_agent();
362 g_dbus_method_invocation_return_gerror(invocation, err);
367 static const GDBusInterfaceVTable method_table = {
368 __bt_map_agent_method,
373 static GDBusConnection *__bt_map_get_gdbus_connection(void)
380 return map_dbus_conn;
382 map_dbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
383 if (!map_dbus_conn) {
385 ERR("Unable to connect to dbus: %s", err->message);
392 return map_dbus_conn;
396 gboolean is_mns_connected(void)
401 return TRUE; /* LCOV_EXCL_LINE */
404 guint64 _bt_validate_uid(int uid, int msg_type)
407 struct id_info *info;
408 GSList *list = id_list;
413 if (info && info->uid == uid && info->msg_type == msg_type) {
414 DBG("UID = %d, MessageType=%d", uid, msg_type);
418 list = g_slist_next(list); /* LCOV_EXCL_LINE */
425 guint64 _bt_add_id(int uid, int msg_type)
428 static guint64 map_id;
429 struct id_info *info;
432 DBG("Add id: %d, MsgType:%d", uid, msg_type);
433 test = _bt_validate_uid(uid, msg_type);
434 DBG("test: %llx\n", test);
438 info = g_new0(struct id_info, 1);
442 info->map_id = map_id;
444 info->msg_type = msg_type;
445 DBG("map_id = %llx, uid = %d, MsgType=%d", info->map_id, info->uid, msg_type);
447 id_list = g_slist_append(id_list, info);
453 /* LCOV_EXCL_START */
454 static struct id_info *__bt_get_id(guint64 map_id)
457 struct id_info *info;
458 GSList *list = id_list;
463 if (info->map_id == map_id)
466 list = g_slist_next(list);
473 static struct id_info *__bt_get_uid(gchar *handle)
477 struct id_info *handle_info;
482 map_id = g_ascii_strtoull(handle, NULL, 16);
486 handle_info = __bt_get_id(map_id);
493 int _bt_update_id(guint64 map_id, int new_uid, int msg_type)
496 struct id_info *info;
497 GSList *list = id_list;
500 /* LCOV_EXCL_START */
503 if (info->map_id == map_id) {
505 info->msg_type = msg_type;
509 list = g_slist_next(list);
517 /* LCOV_EXCL_START */
518 static void __bt_remove_list(GSList *id_list)
524 DBG("Removing id list\n");
525 g_slist_free_full(id_list, g_free);
530 gboolean _bt_verify_sender(message_info_t *msg_info, char *sender)
535 if (!g_strcmp0(sender, "*"))
538 if (g_strrstr(msg_info->sender_name, sender) ||
539 g_strrstr(msg_info->sender_addressing, sender))
545 gboolean _bt_verify_receiver(message_info_t *msg_info, char *receiver)
550 if (!g_strcmp0(receiver, "*"))
553 if (g_strrstr(msg_info->recipient_name, receiver) ||
554 g_strrstr(msg_info->recipient_addressing, receiver))
560 gboolean _bt_verify_read_status(message_info_t *msg_info, guint8 read_status)
562 if (read_status == FILTER_READ_STATUS_ALL ||
563 ((read_status == FILTER_READ_STATUS_UNREAD) && msg_info->read == FALSE) ||
564 ((read_status == FILTER_READ_STATUS_READ) && msg_info->read == TRUE))
570 gboolean _bt_filter_priority(message_info_t *msg_info, guint8 priority)
572 if (priority == FILTER_PRIORITY_ALL ||
573 ((priority == FILTER_PRIORITY_HIGH) && msg_info->priority == TRUE) ||
574 ((priority == FILTER_PRIORITY_LOW) && msg_info->priority == FALSE))
580 void _get_msg_timestamp(time_t *ltime, char *timestamp)
583 struct tm local_time;
587 if (!localtime_r(ltime, &local_time))
590 year = local_time.tm_year + 1900; /* years since 1900 */
591 month = local_time.tm_mon + 1; /* months since January */
592 snprintf(timestamp, 16, "%04d%02d%02dT%02d%02d%02d", year, month,
593 local_time.tm_mday, local_time.tm_hour,
594 local_time.tm_min, local_time.tm_sec);
599 /* LCOV_EXCL_START */
600 time_t _get_time_t_from_timestamp(char *timestamp)
602 struct tm local_time;
607 int ymd; /* year, month, day */
608 int hms; /* hour, min, sec */
611 ymd = strtol(timestamp, &ptr, 10);
612 hms = strtol(ptr + 1, &ptr2, 10);
614 /* Initialize local_time */
615 memset(&local_time, 0, sizeof(struct tm));
617 /* parse year, month, day */
618 local_time.tm_mday = ymd % 100;
619 ymd = (ymd - local_time.tm_mday) / 100;
621 year = (ymd - month) / 100;
623 /* parse hour, minute, sec */
624 local_time.tm_sec = hms % 100;
625 hms = (hms - local_time.tm_sec) / 100;
626 local_time.tm_min = hms % 100;
627 local_time.tm_hour = (hms - local_time.tm_min) / 100;
629 local_time.tm_year = year - 1900;
630 local_time.tm_mon = month - 1;
632 int_time = mktime(&local_time);
637 gboolean _bt_verify_time(message_info_t *msg_info, map_msg_filter_t *filter)
639 struct tm local_time = { 0, };
643 /* Set 19710101T000000 as Start Date */
644 local_time.tm_year = 1971 - 1900;
645 local_time.tm_mon = 0;
646 local_time.tm_mday = 1;
647 start = mktime(&local_time);
649 /* Set 20380101T000000 as End Date */
650 local_time.tm_year = 2038 - 1900;
651 local_time.tm_mon = 0;
652 local_time.tm_mday = 1;
653 end = mktime(&local_time);
655 if (filter->period_begin)
656 start = _get_time_t_from_timestamp(filter->period_begin);
658 if (filter->period_end)
659 end = _get_time_t_from_timestamp(filter->period_end);
661 if (msg_info->time >= start && msg_info->time <= end)
667 #define SET_TON_NPI(dest, ton, npi) { \
669 dest |= (ton & 0x07) << 4; \
670 dest |= npi & 0x0F; \
673 /* LCOV_EXCL_START */
674 static int __bt_ascii_to_upper(int ch)
676 return (('a' <= (ch) && (ch) <= 'z') ? ((ch) - ('a'-'A')) : (ch));
679 static int __bt_sms_pack_gsm_code(gchar *p_out, const char *data, int in_len)
686 for (pos = 0, i = 0; i < in_len; pos++, i++) {
687 /* pack the low bits */
688 p_out[pos] = data[i] >> shift;
690 if (i + 1 < in_len) {
691 /* pack the high bits using the low bits
692 of the next character */
693 p_out[pos] |= data[i+1] << (7 - shift);
708 static void __bt_sms_conv_digit_to_bcd(gchar *p_bcd, char *p_digits, int digit_len)
714 unsigned char higher;
717 if (p_bcd == NULL || p_digits == NULL)
720 /* 0123456789 -> 1032547698 */
721 for (i = 0, j = 0; i < digit_len; i = i + 2, j++) {
722 if (p_digits[i] == '*')
724 else if (p_digits[i] == '#')
726 else if (__bt_ascii_to_upper(p_digits[i]) == 'P')
729 digit = (int) (p_digits[i] - '0');
731 lower = digit & 0x0F;
733 if (digit_len != i + 1) {
734 if (p_digits[i+1] == '*')
736 else if (p_digits[i+1] == '#')
738 else if (__bt_ascii_to_upper(p_digits[i+1]) == 'P')
741 digit = (int) (p_digits[i+1] - '0');
743 higher = digit & 0x0F;
748 p_bcd[j] = (higher << 4) | lower;
753 static int __bt_sms_encode_addr(gchar *addr_field, char *dial_num,
754 int dial_num_len, int ton, int npi)
759 if (dial_num == NULL || addr_field == NULL)
762 if (dial_num[0] == '+') {
765 ton = SMS_TON_INTERNATIONAL;
768 if (ton != SMS_TON_ALPHA_NUMERIC) {
769 /* Origination address length address length */
770 addr_field[index++] = (unsigned char)dial_num_len;
772 addr_field[index] = (unsigned char)
773 (((dial_num_len * 7 + 7) / 8) * 2);
775 if (((dial_num_len * 7) % 8) <= 4)
781 SET_TON_NPI(addr_field[index], ton, npi);
782 index++; /* SET_TON_NPI */
784 if (ton != SMS_TON_ALPHA_NUMERIC) {
785 __bt_sms_conv_digit_to_bcd(&addr_field[index],
786 (char *)dial_num, dial_num_len);
788 if (dial_num_len % 2)
789 index += (dial_num_len / 2) + 1;
791 index += dial_num_len / 2;
793 index += __bt_sms_pack_gsm_code(&addr_field[index],
794 dial_num, (int)dial_num_len);
801 static int __bt_sms_encode_time(gchar *addr_field, time_t *tm)
809 if (!localtime_r(tm, <ime))
812 year = ltime.tm_year + 1900; /* years since 1900 */
814 month = ltime.tm_mon + 1; /* months since January */
816 addr_field[index++] = ((year % 10) << 4) + (year / 10);
817 addr_field[index++] = ((month % 10) << 4) + (month / 10);
818 addr_field[index++] = ((ltime.tm_mday % 10) << 4) +
819 (ltime.tm_mday / 10);
820 addr_field[index++] = ((ltime.tm_hour % 10) << 4) +
821 (ltime.tm_hour / 10);
822 addr_field[index++] = ((ltime.tm_min % 10) << 4) + (ltime.tm_min / 10);
823 addr_field[index++] = ((ltime.tm_sec % 10) << 4) + (ltime.tm_sec / 10);
824 addr_field[index] = 0x00;
830 gchar *_bt_get_sms_pdu_from_msg_data(gchar *number,
831 char *msg, time_t tm,
835 gchar packet[TAPI_NETTEXT_MSG_SIZE_MAX] = {0,};
838 packet[index] = 0x00; /* Since SCA is unknown for stored messages */
841 /* TP-MTI : Type of message */
842 packet[index] = 0x00; /* SMS-DELIVER PDU */
844 /* TP-MMS bit is set to 1 as we support only SMS */
845 packet[index] |= 0x04;
848 /* TP-OA : Mobile originating address */
849 index += __bt_sms_encode_addr(packet+index,
850 number, strlen(number),
851 g_sca_info->Ton, g_sca_info->Npi);
853 /* TP-PID : Since we use only SMS so set to 0 */
854 packet[index++] = 0x00;
856 /* TP-DCS : Data Coding Scheme, default value set */
857 packet[index++] = 0x00;
859 /* TP-SCTS : Message timestamp */
860 index += __bt_sms_encode_time(packet+index, &tm);
862 /* TP-UDL : Message body length */
863 packet[index++] = strlen(msg);
865 /* TP-UD : Message body */
866 index += __bt_sms_pack_gsm_code(packet + index, msg, strlen(msg));
868 *msg_pdu_len = index;
871 return g_memdup(packet, index);
874 static void __bt_get_sms_sca(TapiHandle *handle, int result, void *data,
878 TelSmsAddressInfo_t *scaInfo = data;
880 DBG("__bt_get_sms_sca 0x%x", result);
883 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
886 g_sca_info->DialNumLen = 0;
890 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
891 g_sca_info->Ton = scaInfo->Ton;
892 g_sca_info->Npi = scaInfo->Npi;
893 g_sca_info->DialNumLen = scaInfo->DialNumLen;
898 void _bt_message_info_free(gpointer data)
901 message_info_t *msg_info = (message_info_t *)data;
902 g_free(msg_info->handle);
903 g_free(msg_info->subject);
904 g_free(msg_info->datetime);
905 g_free(msg_info->sender_name);
906 g_free(msg_info->sender_addressing);
907 g_free(msg_info->replyto_addressing);
908 g_free(msg_info->recipient_name);
909 g_free(msg_info->recipient_addressing);
910 g_free(msg_info->type);
911 g_free(msg_info->reception_status);
912 g_free(msg_info->size);
913 g_free(msg_info->attachment_size);
918 /* LCOV_EXCL_START */
919 static gboolean __bluetooth_map_start_service()
925 sms = _bt_map_start_sms_service();
926 email = _bt_map_start_email_service();
935 static gboolean __bt_validate_utf8(char **text)
938 if (g_utf8_validate(*text, -1, NULL))
941 /* LCOV_EXCL_START */
947 gboolean _bt_validate_msg_data(message_info_t *msg_info)
950 if (msg_info == NULL)
953 if (msg_info->subject)
954 return __bt_validate_utf8(&msg_info->subject);
956 if (msg_info->sender_name)
957 return __bt_validate_utf8(&msg_info->sender_name);
959 /* LCOV_EXCL_START */
960 if (msg_info->sender_addressing)
961 return __bt_validate_utf8(&msg_info->sender_addressing);
963 if (msg_info->replyto_addressing)
964 return __bt_validate_utf8(&msg_info->replyto_addressing);
966 if (msg_info->recipient_name)
967 return __bt_validate_utf8(&msg_info->recipient_name);
969 if (msg_info->recipient_addressing)
970 return __bt_validate_utf8(&msg_info->recipient_addressing);
977 /* LCOV_EXCL_START */
978 static void __bt_mns_client_connect(char *address)
981 GDBusConnection *connection;
982 GVariantBuilder builder;
986 GError *error = NULL;
987 const char *session_path;
990 DBG_SECURE("MNS Client already connected to %s", address);
994 connection = __bt_map_get_gdbus_connection();
995 if (connection == NULL) {
996 DBG("Could not get GDBus Connection");
1000 g_mns_proxy = g_dbus_proxy_new_sync(connection,
1001 G_DBUS_PROXY_FLAGS_NONE, NULL,
1002 OBEX_CLIENT_SERVICE, OBEX_CLIENT_PATH,
1003 OBEX_CLIENT_INTERFACE, NULL, &error);
1006 ERR("Failed to get a proxy for D-Bus");
1011 g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
1012 g_variant_builder_add(&builder, "{sv}", "Target",
1013 g_variant_new("s", "MNS"));
1014 args = g_variant_builder_end(&builder);
1016 param = g_variant_new("(s@a{sv})", address, args);
1018 value = g_dbus_proxy_call_sync(g_mns_proxy,
1019 "CreateSession", param, G_DBUS_CALL_FLAGS_NONE, -1,
1021 if (value == NULL) {
1022 /* dBUS-RPC is failed */
1023 ERR("dBUS-RPC is failed");
1024 if (error != NULL) {
1025 /* dBUS gives error cause */
1026 ERR("D-Bus API failure: errCode[%x], message[%s]",
1027 error->code, error->message);
1029 g_clear_error(&error);
1031 g_object_unref(g_mns_proxy);
1036 g_variant_get(value, "(&o)", &session_path);
1037 g_mns_path = g_strdup(session_path);
1038 DBG("g_mns_path = %s\n", g_mns_path);
1040 g_variant_unref(value);
1044 static void __bt_mns_client_disconnect()
1047 GError *error = NULL;
1051 ERR("No proxy to disconnect");
1055 value = g_dbus_proxy_call_sync(g_mns_proxy,
1056 "RemoveSession", g_variant_new("(o)", g_mns_path),
1057 G_DBUS_CALL_FLAGS_NONE, -1,
1060 if (value == NULL) {
1061 /* dBUS-RPC is failed */
1062 ERR("dBUS-RPC is failed: Could not remove MAP session");
1063 if (error != NULL) {
1064 /* dBUS gives error cause */
1065 ERR("D-Bus API failure: errCode[%x], message[%s]",
1066 error->code, error->message);
1068 g_clear_error(&error);
1076 g_object_unref(g_mns_proxy);
1079 g_variant_unref(value);
1082 /* LCOV_EXCL_STOP */
1084 void _bt_mns_client_event_notify(gchar *event, guint64 handle,
1085 gchar *folder, gchar *old_folder,
1089 GError *error = NULL;
1090 GDBusProxy *mns_proxy;
1091 GDBusConnection *connection = NULL;
1095 ERR("No client proxy");
1099 /* LCOV_EXCL_START */
1100 connection = __bt_map_get_gdbus_connection();
1101 if (connection == NULL) {
1102 DBG("Could not get GDBus Connection");
1106 mns_proxy = g_dbus_proxy_new_sync(connection,
1107 G_DBUS_PROXY_FLAGS_NONE, NULL,
1108 OBEX_CLIENT_SERVICE, g_mns_path,
1109 MNS_CLIENT_INTERFACE, NULL, &error);
1110 if (mns_proxy == NULL) {
1111 ERR("Failed to get a proxy for D-Bus\n");
1115 value = g_dbus_proxy_call_sync(mns_proxy, "SendEvent",
1116 g_variant_new("(stsss)", event, handle, folder, old_folder, msg_type),
1117 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1118 if (value == NULL) {
1119 /* dBUS-RPC is failed */
1120 ERR("dBUS-RPC is failed: SendEvent failed");
1121 if (error != NULL) {
1122 /* dBUS gives error cause */
1123 ERR("D-Bus API failure: errCode[%x], message[%s]",
1124 error->code, error->message);
1126 g_clear_error(&error);
1128 g_object_unref(mns_proxy);
1132 g_variant_unref(value);
1133 g_object_unref(mns_proxy);
1135 /* LCOV_EXCL_STOP */
1138 /* LCOV_EXCL_START */
1139 static gchar *__bt_get_map_folder(int folder)
1143 return g_strdup("INBOX");
1145 return g_strdup("SENT");
1147 return g_strdup("OUTBOX");
1149 return g_strdup("DRAFT");
1150 case BT_MSG_DELETED:
1151 return g_strdup("DELETED");
1156 static GList *_bt_map_merge_sorted(GSList *sms_list, GSList *email_list)
1159 message_info_t *sms;
1160 message_info_t *email;
1162 /* **********************Note from glib documentation**************************
1163 * g_list_append() has to traverse the entire list to find the end, which
1164 * is inefficient when adding multiple elements. A common idiom to avoid the
1165 * inefficiency is to use g_list_prepend() and reverse the list with
1166 * g_list_reverse() when all elements have been added.
1167 * ***************************************************************************/
1169 while (sms_list && email_list) {
1170 sms = sms_list->data;
1171 email = email_list->data;
1173 if (sms->time > email->time) {
1174 list = g_list_prepend(list, sms);
1175 sms_list = g_slist_next(sms_list);
1177 list = g_list_prepend(list, email);
1178 email_list = g_slist_next(email_list);
1183 sms = sms_list->data;
1184 list = g_list_prepend(list, sms);
1185 sms_list = g_slist_next(sms_list);
1187 while (email_list) {
1188 email = email_list->data;
1189 list = g_list_prepend(list, email);
1190 email_list = g_slist_next(email_list);
1193 list = g_list_reverse(list);
1197 static GVariant *__bt_map_get_folder_tree(GError **err)
1199 GVariant *folder_list = NULL;
1200 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(s)"));
1202 gboolean sms_ret = TRUE;
1203 gboolean email_ret = TRUE;
1205 sms_ret = _bt_map_sms_get_supported_folders(folders_supported);
1206 email_ret = _bt_map_email_get_supported_folders(folders_supported);
1208 if (sms_ret || email_ret) {
1209 for (i = 0; i < 5; i++) {
1210 if (folders_supported[i][BT_MSG_SOURCE_SMS] ||
1211 folders_supported[i][BT_MSG_SOURCE_EMAIL]) {
1212 g_variant_builder_add(builder, "(s)", __bt_get_map_folder(i));
1216 folder_list = g_variant_new("(a(s))", builder);
1218 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1222 g_variant_builder_unref(builder);
1226 static GVariant *__bt_map_get_message_list(char *folder_name, guint16 max,
1227 guint16 offset, guint8 subject_len,
1228 map_msg_filter_t *filter, GError **err)
1231 GVariant *message_list = NULL;
1232 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssssssssssbsbbbbs)"));
1233 GSList *sms_list = NULL;
1234 GSList *email_list = NULL;
1235 gboolean sms_ret = TRUE;
1236 gboolean email_ret = TRUE;
1238 guint64 count_sms = 0;
1239 guint64 count_email = 0;
1240 gboolean newmsg = FALSE;
1241 char *folder = NULL;
1243 DBG("Folder:%s Max:%d", folder_name, max);
1247 /* In case of parent folders send empty message listing */
1249 if (g_ascii_strncasecmp(folder_name, "/telecom/msg/", strlen("/telecom/msg/")))
1253 folder = strrchr(folder_name, '/');
1255 folder = folder_name;
1258 DBG("Filter Type: %d", filter->type);
1259 if ((filter->type & FILTER_TYPE_SMS_GSM) == 0) { /* Check if SMS is requested */
1260 if (!g_ascii_strncasecmp(folder, "SENT", strlen("SENT"))) {
1261 /* Failed Sent SMS are stored in OUTBOX.
1262 * Hence, Fetch both SENT and OUTBOX */
1263 gboolean sent_ret = _bt_map_get_sms_message_list("SENT",
1264 max + offset, subject_len, filter,
1265 &sms_list, &count_sms, &newmsg);
1266 gboolean outbox_ret = _bt_map_get_sms_message_list("OUTBOX",
1267 max + offset, subject_len, filter,
1268 &sms_list, &count_sms, &newmsg);
1269 sms_ret = (sent_ret || outbox_ret);
1271 sms_ret = _bt_map_get_sms_message_list(folder,
1272 max + offset, subject_len, filter,
1273 &sms_list, &count_sms, &newmsg);
1277 if ((filter->type & FILTER_TYPE_EMAIL) == 0) { /* Check if EMAIL is requested */
1278 email_ret = _bt_map_get_email_list(folder,
1279 max + offset, subject_len, filter,
1280 &email_list, &count_email, &newmsg);
1283 if (sms_ret || email_ret) {
1284 GList *list = _bt_map_merge_sorted(sms_list, email_list);
1287 message_info_t *msg_info = NULL;
1289 g_slist_free(sms_list);
1290 g_slist_free(email_list);
1292 count = count_sms + count_email;
1294 pos = g_list_nth(list, offset);
1295 for (i = offset; pos && i < max + offset; i++) {
1296 msg_info = pos->data;
1297 g_variant_builder_add(builder, "(ssssssssssbsbbbbs)",
1301 msg_info->sender_name,
1302 msg_info->sender_addressing,
1303 msg_info->recipient_name,
1304 msg_info->recipient_addressing,
1307 msg_info->reception_status,
1309 msg_info->attachment_size,
1314 msg_info->replyto_addressing);
1316 pos = g_list_next(pos);
1319 message_list = g_variant_new("(bta(ssssssssssbsbbbbs))",
1320 newmsg, count, builder);
1321 g_variant_builder_unref(builder);
1322 g_list_free_full(list, _bt_message_info_free);
1324 return message_list;
1328 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1330 g_variant_builder_unref(builder);
1335 static GVariant *__bt_map_get_message(char *message_name, gboolean attach,
1336 gboolean transcode, gboolean first_request, GError **err)
1339 GVariant *message = NULL;
1342 gchar *bmseg = NULL;
1344 struct id_info *handle_info = __bt_get_uid(message_name);
1345 if (handle_info == NULL)
1348 message_id = handle_info->uid;
1349 if (handle_info->msg_type == BT_MAP_ID_SMS)
1350 val_ret = _bt_map_get_sms_message(message_id, attach, transcode, first_request, &bmseg);
1352 val_ret = _bt_map_get_email_message(message_id, attach, transcode, first_request, &bmseg);
1355 message = g_variant_new("(bs)", FALSE, bmseg);
1361 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1367 static GVariant *__bt_map_push_message(gboolean save_copy, gboolean retry_send,
1368 gboolean native, char *folder_name, GError **err)
1373 DBG_SECURE("folder_name = %s\n", folder_name);
1375 handle = _bt_add_id(-1, BT_MAP_ID_SMS);
1376 current_push_map_id = handle;
1377 push_folder = g_strdup(folder_name);
1379 /* FALSE : Keep messages in Sent folder */
1380 /* TRUE : don't keep messages in sent folder */
1381 opt.save_copy = save_copy;
1382 DBG("opt.save_copy = %d\n", opt.save_copy);
1384 /* FALSE : don't retry */
1386 opt.retry_send = retry_send;
1387 DBG("opt.retry_send = %d\n", opt.retry_send);
1389 /* FALSE : native */
1391 opt.native = native;
1392 DBG("opt.native = %d\n", opt.native);
1394 return g_variant_new("(t)", handle);
1398 static GVariant *__bt_map_push_message_data(char *bmseg, GError **err)
1401 gboolean ret = FALSE;
1403 DBG_SECURE("BMSG: %s", bmseg);
1405 struct bmsg_data *bmsg_info = NULL;
1407 bmsg_info = bmsg_parse(bmseg);
1409 if (!g_ascii_strcasecmp(bmsg_info->type, "SMS_GSM"))
1410 ret = _bt_map_push_sms_data(bmsg_info, &opt, push_folder);
1411 else if (!g_ascii_strcasecmp(bmsg_info->type, "EMAIL"))
1412 ret = _bt_map_push_email_data(bmsg_info, &opt, push_folder);
1414 bmsg_free_bmsg(bmsg_info);
1417 g_free(push_folder);
1420 INFO("Message Successfully Sent or Saved");
1424 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1426 ERR("Error in sending or saving Message");
1430 /* Dummy Implementation */
1431 static GVariant *__bt_map_update_message(GError **err)
1433 return g_variant_new("(b)", TRUE);
1436 static GVariant *__bt_map_set_read_status(char *handle, gboolean read_status, GError **err)
1442 struct id_info *handle_info = __bt_get_uid(handle);
1443 if (handle_info == NULL)
1446 msg_id = handle_info->uid;
1447 DBG("msg_id = %d, read_status = %d\n", msg_id, read_status);
1448 if (handle_info->msg_type == BT_MAP_ID_SMS)
1449 val_ret = _bt_map_sms_set_read_status(msg_id, read_status);
1451 val_ret = _bt_map_set_email_read_status(msg_id, read_status);
1459 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1465 static GVariant *__bt_map_set_delete_status(char *handle, gboolean delete_status, GError **err)
1471 struct id_info *handle_info = __bt_get_uid(handle);
1472 if (handle_info == NULL)
1475 msg_id = handle_info->uid;
1476 if (handle_info->msg_type == BT_MAP_ID_SMS)
1477 val_ret = _bt_map_set_sms_delete_status(msg_id, delete_status);
1479 val_ret = _bt_map_set_email_delete_status(msg_id, delete_status);
1487 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1493 static void __bt_map_noti_registration(char *remote_addr, gboolean status)
1496 DBG_SECURE("remote_addr = %s \n", remote_addr);
1499 __bt_mns_client_connect(remote_addr);
1501 __bt_mns_client_disconnect();
1504 static void __bt_map_destroy_agent(void)
1506 g_main_loop_quit(g_mainloop);
1509 static GDBusNodeInfo *__bt_map_create_method_node_info
1510 (const gchar *introspection_data)
1513 GDBusNodeInfo *node_info = NULL;
1515 if (introspection_data == NULL)
1518 node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
1521 ERR("Unable to create node: %s", err->message);
1522 g_clear_error(&err);
1527 static gboolean __bt_map_dbus_init(void)
1531 GDBusNodeInfo *node_info;
1532 GError *error = NULL;
1533 GDBusConnection *gdbus_conn = __bt_map_get_gdbus_connection();
1535 if (gdbus_conn == NULL) {
1536 ERR("Error in creating the gdbus connection");
1540 owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1541 BT_MAP_SERVICE_NAME,
1542 G_BUS_NAME_OWNER_FLAGS_NONE,
1545 DBG("owner_id is [%d]", owner_id);
1547 node_info = __bt_map_create_method_node_info(
1548 map_agent_introspection_xml);
1549 if (node_info == NULL)
1552 map_id = g_dbus_connection_register_object(gdbus_conn, BT_MAP_SERVICE_OBJECT_PATH,
1553 node_info->interfaces[0],
1555 NULL, NULL, &error);
1557 g_dbus_node_info_unref(node_info);
1560 ERR("Failed to register: %s", error->message);
1561 g_error_free(error);
1572 DBG("Starting Bluetooth MAP agent");
1576 g_mainloop = g_main_loop_new(NULL, FALSE);
1578 if (g_mainloop == NULL) {
1579 ERR("Couldn't create GMainLoop\n");
1580 return EXIT_FAILURE;
1583 if (__bt_map_dbus_init() == FALSE)
1586 if (__bluetooth_map_start_service() == FALSE)
1589 g_tapi_handle = tel_init(NULL);
1593 ret = tel_get_sms_sca(g_tapi_handle, 0, __bt_get_sms_sca, NULL);
1594 if (ret != TAPI_API_SUCCESS) {
1595 ERR("TAPI err = %d", ret);
1599 g_main_loop_run(g_mainloop);
1603 __bt_remove_list(id_list);
1605 tel_deinit(g_tapi_handle);
1608 __bt_mns_client_disconnect();
1611 g_object_unref(map_dbus_conn);
1613 _bt_map_stop_sms_service();
1614 _bt_map_stop_email_service();
1616 DBG("Bluetooth MAP agent Terminated successfully\n");
1618 return EXIT_FAILURE;
1620 /* LCOV_EXCL_STOP */