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);
226 static void __bt_map_agent_method(GDBusConnection *connection,
228 const gchar *object_path,
229 const gchar *interface_name,
230 const gchar *method_name,
231 GVariant *parameters,
232 GDBusMethodInvocation *invocation,
237 INFO("method %s", method_name);
238 INFO("object_path %s", object_path);
241 if (g_strcmp0(method_name, "GetFolderTree") == 0) {
242 GVariant *folder_list = NULL;
244 folder_list = __bt_map_get_folder_tree(&err);
248 g_dbus_method_invocation_return_value(invocation, folder_list);
249 } else if (g_strcmp0(method_name, "GetMessageList") == 0) {
250 GVariant *message_list = NULL;
255 GVariant *filters = NULL;
256 map_msg_filter_t filter = { 0, };
258 g_variant_get(parameters, "(&sqqy@a{sv})", &folder_name,
259 &max, &offset, &subject_len, &filters);
261 DBG("MAX:%d Offset:%d SubjectLen:%d", max, offset, subject_len);
262 if (subject_len == 0)
263 subject_len = BT_MAP_SUBJECT_MAX_LEN;
265 filter = __bt_map_get_filters(filters);
266 message_list = __bt_map_get_message_list(folder_name, max,
267 offset, subject_len, &filter, &err);
272 g_dbus_method_invocation_return_value(invocation, message_list);
273 } else if (g_strcmp0(method_name, "GetMessage") == 0) {
274 GVariant *message = NULL;
278 gboolean first_request;
280 g_variant_get(parameters, "(&sbbb)", &message_name,
281 &attach, &transcode, &first_request);
283 message = __bt_map_get_message(message_name, attach,
284 transcode, first_request, &err);
288 g_dbus_method_invocation_return_value(invocation, message);
289 } else if (g_strcmp0(method_name, "PushMessage") == 0) {
290 GVariant *handle = NULL;
296 g_variant_get(parameters, "(bbb&s)", &save_copy,
297 &retry_send, &native, &folder_name);
299 handle = __bt_map_push_message(save_copy, retry_send,
300 native, folder_name, &err);
304 g_dbus_method_invocation_return_value(invocation, handle);
305 } else if (g_strcmp0(method_name, "PushMessageData") == 0) {
308 g_variant_get(parameters, "(&s)", &bmseg);
310 __bt_map_push_message_data(bmseg, &err);
314 g_dbus_method_invocation_return_value(invocation, NULL);
315 } else if (g_strcmp0(method_name, "UpdateMessage") == 0) {
316 GVariant *update = NULL;
318 update = __bt_map_update_message(&err);
322 g_dbus_method_invocation_return_value(invocation, update);
323 } else if (g_strcmp0(method_name, "SetReadStatus") == 0) {
325 gboolean read_status;
327 g_variant_get(parameters, "(&sb)", &handle, &read_status);
329 __bt_map_set_read_status(handle, read_status, &err);
333 g_dbus_method_invocation_return_value(invocation, NULL);
334 } else if (g_strcmp0(method_name, "SetDeleteStatus") == 0) {
336 gboolean delete_status;
338 g_variant_get(parameters, "(&sb)", &handle, &delete_status);
340 __bt_map_set_delete_status(handle, delete_status, &err);
344 g_dbus_method_invocation_return_value(invocation, NULL);
345 } else if (g_strcmp0(method_name, "NotiRegistration") == 0) {
348 g_variant_get(parameters, "(&sb)", &remote_addr, &status);
350 __bt_map_noti_registration(remote_addr, status);
351 g_dbus_method_invocation_return_value(invocation, NULL);
352 } else if (g_strcmp0(method_name, "DestroyAgent") == 0) {
353 g_dbus_method_invocation_return_value(invocation, NULL);
354 __bt_map_destroy_agent();
361 g_dbus_method_invocation_return_gerror(invocation, err);
366 static const GDBusInterfaceVTable method_table = {
367 __bt_map_agent_method,
372 static GDBusConnection *__bt_map_get_gdbus_connection(void)
379 return map_dbus_conn;
381 map_dbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
382 if (!map_dbus_conn) {
384 ERR("Unable to connect to dbus: %s", err->message);
391 return map_dbus_conn;
395 gboolean is_mns_connected(void)
400 return TRUE; /* LCOV_EXCL_LINE */
403 guint64 _bt_validate_uid(int uid, int msg_type)
406 struct id_info *info;
407 GSList *list = id_list;
412 if (info && info->uid == uid && info->msg_type == msg_type) {
413 DBG("UID = %d, MessageType=%d", uid, msg_type);
417 list = g_slist_next(list); /* LCOV_EXCL_LINE */
424 guint64 _bt_add_id(int uid, int msg_type)
427 static guint64 map_id;
428 struct id_info *info;
431 DBG("Add id: %d, MsgType:%d", uid, msg_type);
432 test = _bt_validate_uid(uid, msg_type);
433 DBG("test: %llu\n", (unsigned long long int)test);
437 info = g_new0(struct id_info, 1);
441 info->map_id = map_id;
443 info->msg_type = msg_type;
444 DBG("map_id = %llu, uid = %d, MsgType=%d", (unsigned long long int)info->map_id, info->uid, msg_type);
446 id_list = g_slist_append(id_list, info);
452 /* LCOV_EXCL_START */
453 static struct id_info *__bt_get_id(guint64 map_id)
456 struct id_info *info;
457 GSList *list = id_list;
462 if (info->map_id == map_id)
465 list = g_slist_next(list);
472 static struct id_info *__bt_get_uid(gchar *handle)
476 struct id_info *handle_info;
481 map_id = g_ascii_strtoull(handle, NULL, 16);
485 handle_info = __bt_get_id(map_id);
492 int _bt_update_id(guint64 map_id, int new_uid, int msg_type)
495 struct id_info *info;
496 GSList *list = id_list;
499 /* LCOV_EXCL_START */
502 if (info->map_id == map_id) {
504 info->msg_type = msg_type;
508 list = g_slist_next(list);
516 /* LCOV_EXCL_START */
517 static void __bt_remove_list(GSList *id_list)
523 DBG("Removing id list\n");
524 g_slist_free_full(id_list, g_free);
529 gboolean _bt_verify_sender(message_info_t *msg_info, char *sender)
534 if (!g_strcmp0(sender, "*"))
537 if (g_strrstr(msg_info->sender_name, sender) ||
538 g_strrstr(msg_info->sender_addressing, sender))
544 gboolean _bt_verify_receiver(message_info_t *msg_info, char *receiver)
549 if (!g_strcmp0(receiver, "*"))
552 if (g_strrstr(msg_info->recipient_name, receiver) ||
553 g_strrstr(msg_info->recipient_addressing, receiver))
559 gboolean _bt_verify_read_status(message_info_t *msg_info, guint8 read_status)
561 if (read_status == FILTER_READ_STATUS_ALL ||
562 ((read_status == FILTER_READ_STATUS_UNREAD) && msg_info->read == FALSE) ||
563 ((read_status == FILTER_READ_STATUS_READ) && msg_info->read == TRUE))
569 gboolean _bt_filter_priority(message_info_t *msg_info, guint8 priority)
571 if (priority == FILTER_PRIORITY_ALL ||
572 ((priority == FILTER_PRIORITY_HIGH) && msg_info->priority == TRUE) ||
573 ((priority == FILTER_PRIORITY_LOW) && msg_info->priority == FALSE))
579 void _get_msg_timestamp(time_t *ltime, char *timestamp)
582 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 buf_len = snprintf(timestamp, 16, "%04hu%02hu%02huT%02hu%02hu%02hu",(unsigned short int)year, (unsigned short int)month,
593 (unsigned short int)local_time.tm_mday, (unsigned short int)local_time.tm_hour,
594 (unsigned short int)local_time.tm_min, (unsigned short int)local_time.tm_sec);
597 ERR("Encoding error occured in snprintf");
602 /* LCOV_EXCL_START */
603 time_t _get_time_t_from_timestamp(char *timestamp)
605 struct tm local_time;
610 int ymd; /* year, month, day */
611 int hms; /* hour, min, sec */
614 ymd = strtol(timestamp, &ptr, 10);
615 hms = strtol(ptr + 1, &ptr2, 10);
617 /* Initialize local_time */
618 memset(&local_time, 0, sizeof(struct tm));
620 /* parse year, month, day */
621 local_time.tm_mday = ymd % 100;
622 ymd = (ymd - local_time.tm_mday) / 100;
624 year = (ymd - month) / 100;
626 /* parse hour, minute, sec */
627 local_time.tm_sec = hms % 100;
628 hms = (hms - local_time.tm_sec) / 100;
629 local_time.tm_min = hms % 100;
630 local_time.tm_hour = (hms - local_time.tm_min) / 100;
632 local_time.tm_year = year - 1900;
633 local_time.tm_mon = month - 1;
635 int_time = mktime(&local_time);
640 gboolean _bt_verify_time(message_info_t *msg_info, map_msg_filter_t *filter)
642 struct tm local_time = { 0, };
646 /* Set 19710101T000000 as Start Date */
647 local_time.tm_year = 1971 - 1900;
648 local_time.tm_mon = 0;
649 local_time.tm_mday = 1;
650 start = mktime(&local_time);
652 /* Set 20380101T000000 as End Date */
653 local_time.tm_year = 2038 - 1900;
654 local_time.tm_mon = 0;
655 local_time.tm_mday = 1;
656 end = mktime(&local_time);
658 if (filter->period_begin)
659 start = _get_time_t_from_timestamp(filter->period_begin);
661 if (filter->period_end)
662 end = _get_time_t_from_timestamp(filter->period_end);
664 if (msg_info->time >= start && msg_info->time <= end)
670 #define SET_TON_NPI(dest, ton, npi) { \
672 dest |= (ton & 0x07) << 4; \
673 dest |= npi & 0x0F; \
676 /* LCOV_EXCL_START */
677 static int __bt_ascii_to_upper(int ch)
679 return (('a' <= (ch) && (ch) <= 'z') ? ((ch) - ('a'-'A')) : (ch));
682 static int __bt_sms_pack_gsm_code(gchar *p_out, const char *data, int in_len)
689 for (pos = 0, i = 0; i < in_len; pos++, i++) {
690 /* pack the low bits */
691 p_out[pos] = data[i] >> shift;
693 if (i + 1 < in_len) {
694 /* pack the high bits using the low bits
695 of the next character */
696 p_out[pos] |= data[i+1] << (7 - shift);
711 static void __bt_sms_conv_digit_to_bcd(gchar *p_bcd, char *p_digits, int digit_len)
717 unsigned char higher;
720 if (p_bcd == NULL || p_digits == NULL)
723 /* 0123456789 -> 1032547698 */
724 for (i = 0, j = 0; i < digit_len; i = i + 2, j++) {
725 if (p_digits[i] == '*')
727 else if (p_digits[i] == '#')
729 else if (__bt_ascii_to_upper(p_digits[i]) == 'P')
732 digit = (int) (p_digits[i] - '0');
734 lower = digit & 0x0F;
736 if (digit_len != i + 1) {
737 if (p_digits[i+1] == '*')
739 else if (p_digits[i+1] == '#')
741 else if (__bt_ascii_to_upper(p_digits[i+1]) == 'P')
744 digit = (int) (p_digits[i+1] - '0');
746 higher = digit & 0x0F;
751 p_bcd[j] = (higher << 4) | lower;
756 static int __bt_sms_encode_addr(gchar *addr_field, char *dial_num,
757 int dial_num_len, int ton, int npi)
762 if (dial_num == NULL || addr_field == NULL)
765 if (dial_num[0] == '+') {
768 ton = SMS_TON_INTERNATIONAL;
771 if (ton != SMS_TON_ALPHA_NUMERIC) {
772 /* Origination address length address length */
773 addr_field[index++] = (unsigned char)dial_num_len;
775 addr_field[index] = (unsigned char)
776 (((dial_num_len * 7 + 7) / 8) * 2);
778 if (((dial_num_len * 7) % 8) <= 4)
784 SET_TON_NPI(addr_field[index], ton, npi);
785 index++; /* SET_TON_NPI */
787 if (ton != SMS_TON_ALPHA_NUMERIC) {
788 __bt_sms_conv_digit_to_bcd(&addr_field[index],
789 (char *)dial_num, dial_num_len);
791 if (dial_num_len % 2)
792 index += (dial_num_len / 2) + 1;
794 index += dial_num_len / 2;
796 index += __bt_sms_pack_gsm_code(&addr_field[index],
797 dial_num, (int)dial_num_len);
804 static int __bt_sms_encode_time(gchar *addr_field, time_t *tm)
812 if (!localtime_r(tm, <ime))
815 year = ltime.tm_year + 1900; /* years since 1900 */
817 month = ltime.tm_mon + 1; /* months since January */
819 addr_field[index++] = ((year % 10) << 4) + (year / 10);
820 addr_field[index++] = ((month % 10) << 4) + (month / 10);
821 addr_field[index++] = ((ltime.tm_mday % 10) << 4) +
822 (ltime.tm_mday / 10);
823 addr_field[index++] = ((ltime.tm_hour % 10) << 4) +
824 (ltime.tm_hour / 10);
825 addr_field[index++] = ((ltime.tm_min % 10) << 4) + (ltime.tm_min / 10);
826 addr_field[index++] = ((ltime.tm_sec % 10) << 4) + (ltime.tm_sec / 10);
827 addr_field[index] = 0x00;
833 gchar *_bt_get_sms_pdu_from_msg_data(gchar *number,
834 char *msg, time_t tm,
838 gchar packet[TAPI_NETTEXT_MSG_SIZE_MAX] = {0,};
841 packet[index] = 0x00; /* Since SCA is unknown for stored messages */
844 /* TP-MTI : Type of message */
845 packet[index] = 0x00; /* SMS-DELIVER PDU */
847 /* TP-MMS bit is set to 1 as we support only SMS */
848 packet[index] |= 0x04;
851 /* TP-OA : Mobile originating address */
852 index += __bt_sms_encode_addr(packet+index,
853 number, strlen(number),
854 g_sca_info->Ton, g_sca_info->Npi);
856 /* TP-PID : Since we use only SMS so set to 0 */
857 packet[index++] = 0x00;
859 /* TP-DCS : Data Coding Scheme, default value set */
860 packet[index++] = 0x00;
862 /* TP-SCTS : Message timestamp */
863 index += __bt_sms_encode_time(packet+index, &tm);
865 /* TP-UDL : Message body length */
866 packet[index++] = strlen(msg);
868 /* TP-UD : Message body */
869 index += __bt_sms_pack_gsm_code(packet + index, msg, strlen(msg));
871 *msg_pdu_len = index;
874 return g_memdup2(packet, index);
877 static void __bt_get_sms_sca(TapiHandle *handle, int result, void *data,
881 TelSmsAddressInfo_t *scaInfo = data;
883 DBG("__bt_get_sms_sca 0x%x", result);
886 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
889 g_sca_info->DialNumLen = 0;
893 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
894 g_sca_info->Ton = scaInfo->Ton;
895 g_sca_info->Npi = scaInfo->Npi;
896 g_sca_info->DialNumLen = scaInfo->DialNumLen;
901 void _bt_message_info_free(gpointer data)
904 message_info_t *msg_info = (message_info_t *)data;
905 g_free(msg_info->handle);
906 g_free(msg_info->subject);
907 g_free(msg_info->datetime);
908 g_free(msg_info->sender_name);
909 g_free(msg_info->sender_addressing);
910 g_free(msg_info->replyto_addressing);
911 g_free(msg_info->recipient_name);
912 g_free(msg_info->recipient_addressing);
913 g_free(msg_info->type);
914 g_free(msg_info->reception_status);
915 g_free(msg_info->size);
916 g_free(msg_info->attachment_size);
921 /* LCOV_EXCL_START */
922 static gboolean __bluetooth_map_start_service()
928 sms = _bt_map_start_sms_service();
929 email = _bt_map_start_email_service();
938 static gboolean __bt_validate_utf8(char **text)
941 if (g_utf8_validate(*text, -1, NULL))
944 /* LCOV_EXCL_START */
950 gboolean _bt_validate_msg_data(message_info_t *msg_info)
953 if (msg_info == NULL)
956 if (msg_info->subject)
957 return __bt_validate_utf8(&msg_info->subject);
959 if (msg_info->sender_name)
960 return __bt_validate_utf8(&msg_info->sender_name);
962 /* LCOV_EXCL_START */
963 if (msg_info->sender_addressing)
964 return __bt_validate_utf8(&msg_info->sender_addressing);
966 if (msg_info->replyto_addressing)
967 return __bt_validate_utf8(&msg_info->replyto_addressing);
969 if (msg_info->recipient_name)
970 return __bt_validate_utf8(&msg_info->recipient_name);
972 if (msg_info->recipient_addressing)
973 return __bt_validate_utf8(&msg_info->recipient_addressing);
980 /* LCOV_EXCL_START */
981 static void __bt_mns_client_connect(char *address)
984 GDBusConnection *connection;
985 GVariantBuilder builder;
989 GError *error = NULL;
990 const char *session_path;
993 DBG_SECURE("MNS Client already connected to %s", address);
997 connection = __bt_map_get_gdbus_connection();
998 if (connection == NULL) {
999 DBG("Could not get GDBus Connection");
1003 g_mns_proxy = g_dbus_proxy_new_sync(connection,
1004 G_DBUS_PROXY_FLAGS_NONE, NULL,
1005 OBEX_CLIENT_SERVICE, OBEX_CLIENT_PATH,
1006 OBEX_CLIENT_INTERFACE, NULL, &error);
1009 ERR("Failed to get a proxy for D-Bus");
1014 g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
1015 g_variant_builder_add(&builder, "{sv}", "Target",
1016 g_variant_new("s", "MNS"));
1017 args = g_variant_builder_end(&builder);
1019 param = g_variant_new("(s@a{sv})", address, args);
1021 value = g_dbus_proxy_call_sync(g_mns_proxy,
1022 "CreateSession", param, G_DBUS_CALL_FLAGS_NONE, -1,
1024 if (value == NULL) {
1025 /* dBUS-RPC is failed */
1026 ERR("dBUS-RPC is failed");
1027 if (error != NULL) {
1028 /* dBUS gives error cause */
1029 ERR("D-Bus API failure: errCode[%x], message[%s]",
1030 error->code, error->message);
1032 g_clear_error(&error);
1034 g_object_unref(g_mns_proxy);
1039 g_variant_get(value, "(&o)", &session_path);
1040 g_mns_path = g_strdup(session_path);
1041 DBG("g_mns_path = %s\n", g_mns_path);
1043 g_variant_unref(value);
1047 static void __bt_mns_client_disconnect()
1050 GError *error = NULL;
1054 ERR("No proxy to disconnect");
1058 value = g_dbus_proxy_call_sync(g_mns_proxy,
1059 "RemoveSession", g_variant_new("(o)", g_mns_path),
1060 G_DBUS_CALL_FLAGS_NONE, -1,
1063 if (value == NULL) {
1064 /* dBUS-RPC is failed */
1065 ERR("dBUS-RPC is failed: Could not remove MAP session");
1066 if (error != NULL) {
1067 /* dBUS gives error cause */
1068 ERR("D-Bus API failure: errCode[%x], message[%s]",
1069 error->code, error->message);
1071 g_clear_error(&error);
1079 g_object_unref(g_mns_proxy);
1082 g_variant_unref(value);
1085 /* LCOV_EXCL_STOP */
1087 void _bt_mns_client_event_notify(gchar *event, guint64 handle,
1088 gchar *folder, gchar *old_folder,
1092 GError *error = NULL;
1093 GDBusProxy *mns_proxy;
1094 GDBusConnection *connection = NULL;
1098 ERR("No client proxy");
1102 /* LCOV_EXCL_START */
1103 connection = __bt_map_get_gdbus_connection();
1104 if (connection == NULL) {
1105 DBG("Could not get GDBus Connection");
1109 mns_proxy = g_dbus_proxy_new_sync(connection,
1110 G_DBUS_PROXY_FLAGS_NONE, NULL,
1111 OBEX_CLIENT_SERVICE, g_mns_path,
1112 MNS_CLIENT_INTERFACE, NULL, &error);
1113 if (mns_proxy == NULL) {
1114 ERR("Failed to get a proxy for D-Bus\n");
1118 value = g_dbus_proxy_call_sync(mns_proxy, "SendEvent",
1119 g_variant_new("(stsss)", event, handle, folder, old_folder, msg_type),
1120 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1121 if (value == NULL) {
1122 /* dBUS-RPC is failed */
1123 ERR("dBUS-RPC is failed: SendEvent failed");
1124 if (error != NULL) {
1125 /* dBUS gives error cause */
1126 ERR("D-Bus API failure: errCode[%x], message[%s]",
1127 error->code, error->message);
1129 g_clear_error(&error);
1131 g_object_unref(mns_proxy);
1135 g_variant_unref(value);
1136 g_object_unref(mns_proxy);
1138 /* LCOV_EXCL_STOP */
1141 /* LCOV_EXCL_START */
1142 static gchar *__bt_get_map_folder(int folder)
1146 return g_strdup("INBOX");
1148 return g_strdup("SENT");
1150 return g_strdup("OUTBOX");
1152 return g_strdup("DRAFT");
1153 case BT_MSG_DELETED:
1154 return g_strdup("DELETED");
1159 static GList *_bt_map_merge_sorted(GSList *sms_list, GSList *email_list)
1162 message_info_t *sms;
1163 message_info_t *email;
1165 /* **********************Note from glib documentation**************************
1166 * g_list_append() has to traverse the entire list to find the end, which
1167 * is inefficient when adding multiple elements. A common idiom to avoid the
1168 * inefficiency is to use g_list_prepend() and reverse the list with
1169 * g_list_reverse() when all elements have been added.
1170 * ***************************************************************************/
1172 while (sms_list && email_list) {
1173 sms = sms_list->data;
1174 email = email_list->data;
1176 if (sms->time > email->time) {
1177 list = g_list_prepend(list, sms);
1178 sms_list = g_slist_next(sms_list);
1180 list = g_list_prepend(list, email);
1181 email_list = g_slist_next(email_list);
1186 sms = sms_list->data;
1187 list = g_list_prepend(list, sms);
1188 sms_list = g_slist_next(sms_list);
1190 while (email_list) {
1191 email = email_list->data;
1192 list = g_list_prepend(list, email);
1193 email_list = g_slist_next(email_list);
1196 list = g_list_reverse(list);
1200 static GVariant *__bt_map_get_folder_tree(GError **err)
1202 GVariant *folder_list = NULL;
1203 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(s)"));
1205 gboolean sms_ret = TRUE;
1206 gboolean email_ret = TRUE;
1208 sms_ret = _bt_map_sms_get_supported_folders(folders_supported);
1209 email_ret = _bt_map_email_get_supported_folders(folders_supported);
1211 if (sms_ret || email_ret) {
1212 for (i = 0; i < 5; i++) {
1213 if (folders_supported[i][BT_MSG_SOURCE_SMS] ||
1214 folders_supported[i][BT_MSG_SOURCE_EMAIL]) {
1215 g_variant_builder_add(builder, "(s)", __bt_get_map_folder(i));
1219 folder_list = g_variant_new("(a(s))", builder);
1221 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1225 g_variant_builder_unref(builder);
1229 static GVariant *__bt_map_get_message_list(char *folder_name, guint16 max,
1230 guint16 offset, guint8 subject_len,
1231 map_msg_filter_t *filter, GError **err)
1234 GVariant *message_list = NULL;
1235 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssssssssssbsbbbbs)"));
1236 GSList *sms_list = NULL;
1237 GSList *email_list = NULL;
1238 gboolean sms_ret = TRUE;
1239 gboolean email_ret = TRUE;
1241 guint64 count_sms = 0;
1242 guint64 count_email = 0;
1243 gboolean newmsg = FALSE;
1244 char *folder = NULL;
1246 DBG("Folder:%s Max:%d", folder_name, max);
1250 /* In case of parent folders send empty message listing */
1252 if (g_ascii_strncasecmp(folder_name, "/telecom/msg/", strlen("/telecom/msg/")))
1256 folder = strrchr(folder_name, '/');
1258 folder = folder_name;
1261 DBG("Filter Type: %d", filter->type);
1262 if ((filter->type & FILTER_TYPE_SMS_GSM) == 0) { /* Check if SMS is requested */
1263 if (!g_ascii_strncasecmp(folder, "SENT", strlen("SENT"))) {
1264 /* Failed Sent SMS are stored in OUTBOX.
1265 * Hence, Fetch both SENT and OUTBOX */
1266 gboolean sent_ret = _bt_map_get_sms_message_list("SENT",
1267 max + offset, subject_len, filter,
1268 &sms_list, &count_sms, &newmsg);
1269 gboolean outbox_ret = _bt_map_get_sms_message_list("OUTBOX",
1270 max + offset, subject_len, filter,
1271 &sms_list, &count_sms, &newmsg);
1272 sms_ret = (sent_ret || outbox_ret);
1274 sms_ret = _bt_map_get_sms_message_list(folder,
1275 max + offset, subject_len, filter,
1276 &sms_list, &count_sms, &newmsg);
1280 if ((filter->type & FILTER_TYPE_EMAIL) == 0) { /* Check if EMAIL is requested */
1281 email_ret = _bt_map_get_email_list(folder,
1282 max + offset, subject_len, filter,
1283 &email_list, &count_email, &newmsg);
1286 if (sms_ret || email_ret) {
1287 GList *list = _bt_map_merge_sorted(sms_list, email_list);
1290 message_info_t *msg_info = NULL;
1292 g_slist_free(sms_list);
1293 g_slist_free(email_list);
1295 count = count_sms + count_email;
1297 pos = g_list_nth(list, offset);
1298 for (i = offset; pos && i < max + offset; i++) {
1299 msg_info = pos->data;
1300 g_variant_builder_add(builder, "(ssssssssssbsbbbbs)",
1304 msg_info->sender_name,
1305 msg_info->sender_addressing,
1306 msg_info->recipient_name,
1307 msg_info->recipient_addressing,
1310 msg_info->reception_status,
1312 msg_info->attachment_size,
1317 msg_info->replyto_addressing);
1319 pos = g_list_next(pos);
1322 message_list = g_variant_new("(bta(ssssssssssbsbbbbs))",
1323 newmsg, count, builder);
1324 g_variant_builder_unref(builder);
1325 g_list_free_full(list, _bt_message_info_free);
1327 return message_list;
1331 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1333 g_variant_builder_unref(builder);
1338 static GVariant *__bt_map_get_message(char *message_name, gboolean attach,
1339 gboolean transcode, gboolean first_request, GError **err)
1342 GVariant *message = NULL;
1345 gchar *bmseg = NULL;
1347 struct id_info *handle_info = __bt_get_uid(message_name);
1348 if (handle_info == NULL)
1351 message_id = handle_info->uid;
1352 if (handle_info->msg_type == BT_MAP_ID_SMS)
1353 val_ret = _bt_map_get_sms_message(message_id, attach, transcode, first_request, &bmseg);
1355 val_ret = _bt_map_get_email_message(message_id, attach, transcode, first_request, &bmseg);
1358 message = g_variant_new("(bs)", FALSE, bmseg);
1364 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1370 static GVariant *__bt_map_push_message(gboolean save_copy, gboolean retry_send,
1371 gboolean native, char *folder_name, GError **err)
1376 DBG_SECURE("folder_name = %s\n", folder_name);
1378 handle = _bt_add_id(-1, BT_MAP_ID_SMS);
1379 current_push_map_id = handle;
1380 push_folder = g_strdup(folder_name);
1382 /* FALSE : Keep messages in Sent folder */
1383 /* TRUE : don't keep messages in sent folder */
1384 opt.save_copy = save_copy;
1385 DBG("opt.save_copy = %d\n", opt.save_copy);
1387 /* FALSE : don't retry */
1389 opt.retry_send = retry_send;
1390 DBG("opt.retry_send = %d\n", opt.retry_send);
1392 /* FALSE : native */
1394 opt.native = native;
1395 DBG("opt.native = %d\n", opt.native);
1397 return g_variant_new("(t)", handle);
1401 static GVariant *__bt_map_push_message_data(char *bmseg, GError **err)
1404 gboolean ret = FALSE;
1406 DBG_SECURE("BMSG: %s", bmseg);
1408 struct bmsg_data *bmsg_info = NULL;
1410 bmsg_info = bmsg_parse(bmseg);
1412 if (!g_ascii_strcasecmp(bmsg_info->type, "SMS_GSM"))
1413 ret = _bt_map_push_sms_data(bmsg_info, &opt, push_folder);
1414 else if (!g_ascii_strcasecmp(bmsg_info->type, "EMAIL"))
1415 ret = _bt_map_push_email_data(bmsg_info, &opt, push_folder);
1417 bmsg_free_bmsg(bmsg_info);
1420 g_free(push_folder);
1423 INFO("Message Successfully Sent or Saved");
1427 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1429 ERR("Error in sending or saving Message");
1433 /* Dummy Implementation */
1434 static GVariant *__bt_map_update_message(GError **err)
1436 return g_variant_new("(b)", TRUE);
1439 static GVariant *__bt_map_set_read_status(char *handle, gboolean read_status, GError **err)
1445 struct id_info *handle_info = __bt_get_uid(handle);
1446 if (handle_info == NULL)
1449 msg_id = handle_info->uid;
1450 DBG("msg_id = %d, read_status = %d\n", msg_id, read_status);
1451 if (handle_info->msg_type == BT_MAP_ID_SMS)
1452 val_ret = _bt_map_sms_set_read_status(msg_id, read_status);
1454 val_ret = _bt_map_set_email_read_status(msg_id, read_status);
1462 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1468 static GVariant *__bt_map_set_delete_status(char *handle, gboolean delete_status, GError **err)
1474 struct id_info *handle_info = __bt_get_uid(handle);
1475 if (handle_info == NULL)
1478 msg_id = handle_info->uid;
1479 if (handle_info->msg_type == BT_MAP_ID_SMS)
1480 val_ret = _bt_map_set_sms_delete_status(msg_id, delete_status);
1482 val_ret = _bt_map_set_email_delete_status(msg_id, delete_status);
1490 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1496 static void __bt_map_noti_registration(char *remote_addr, gboolean status)
1499 DBG_SECURE("remote_addr = %s \n", remote_addr);
1502 __bt_mns_client_connect(remote_addr);
1504 __bt_mns_client_disconnect();
1507 static void __bt_map_destroy_agent(void)
1509 g_main_loop_quit(g_mainloop);
1512 static GDBusNodeInfo *__bt_map_create_method_node_info
1513 (const gchar *introspection_data)
1516 GDBusNodeInfo *node_info = NULL;
1518 if (introspection_data == NULL)
1521 node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
1524 ERR("Unable to create node: %s", err->message);
1525 g_clear_error(&err);
1530 static gboolean __bt_map_dbus_init(void)
1534 GDBusNodeInfo *node_info;
1535 GError *error = NULL;
1536 GDBusConnection *gdbus_conn = __bt_map_get_gdbus_connection();
1538 if (gdbus_conn == NULL) {
1539 ERR("Error in creating the gdbus connection");
1543 owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1544 BT_MAP_SERVICE_NAME,
1545 G_BUS_NAME_OWNER_FLAGS_NONE,
1548 DBG("owner_id is [%d]", owner_id);
1550 node_info = __bt_map_create_method_node_info(
1551 map_agent_introspection_xml);
1552 if (node_info == NULL)
1555 map_id = g_dbus_connection_register_object(gdbus_conn, BT_MAP_SERVICE_OBJECT_PATH,
1556 node_info->interfaces[0],
1558 NULL, NULL, &error);
1560 g_dbus_node_info_unref(node_info);
1563 ERR("Failed to register: %s", error->message);
1564 g_error_free(error);
1575 DBG("Starting Bluetooth MAP agent");
1579 g_mainloop = g_main_loop_new(NULL, FALSE);
1581 if (g_mainloop == NULL) {
1582 ERR("Couldn't create GMainLoop\n");
1583 return EXIT_FAILURE;
1586 if (__bt_map_dbus_init() == FALSE)
1589 if (__bluetooth_map_start_service() == FALSE)
1592 g_tapi_handle = tel_init(NULL);
1596 ret = tel_get_sms_sca(g_tapi_handle, 0, __bt_get_sms_sca, NULL);
1597 if (ret != TAPI_API_SUCCESS) {
1598 ERR("TAPI err = %d", ret);
1602 g_main_loop_run(g_mainloop);
1606 __bt_remove_list(id_list);
1608 tel_deinit(g_tapi_handle);
1611 __bt_mns_client_disconnect();
1614 g_object_unref(map_dbus_conn);
1616 _bt_map_stop_sms_service();
1617 _bt_map_stop_email_service();
1619 DBG("Bluetooth MAP agent Terminated successfully\n");
1621 return EXIT_FAILURE;
1623 /* LCOV_EXCL_STOP */