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 /* Create GError from error code and error message */
181 static GError *__bt_map_error(int error_code, char *error_message)
183 return g_error_new(g_quark_from_string("MAP Agent"),
184 error_code, "MAP Agent Error: %s", error_message);
187 static map_msg_filter_t __bt_map_get_filters(GVariant *filters)
189 map_msg_filter_t filter = { 0, };
194 g_variant_iter_init(&iter, filters);
195 while (g_variant_iter_loop(&iter, "{sv}", &key, &value)) {
196 if (!g_strcmp0(key, "ParameterMask")) {
197 filter.parameter_mask = g_variant_get_uint32(value);
198 DBG("ParameterMask :%u", filter.parameter_mask);
199 } else if (!g_strcmp0(key, "FilterMessageType")) {
200 filter.type = g_variant_get_byte(value);
201 DBG("FilterMessageType :%u", filter.type);
202 } else if (!g_strcmp0(key, "FilterPeriodBegin")) {
203 g_variant_get(value, "s", &filter.period_begin);
204 DBG("FilterPeriodBegin :%s", filter.period_begin);
205 } else if (!g_strcmp0(key, "FilterPeriodEnd")) {
206 g_variant_get(value, "s", &filter.period_end);
207 DBG("FilterPeriodEnd :%s", filter.period_end);
208 } else if (!g_strcmp0(key, "FilterReadStatus")) {
209 filter.read_status = g_variant_get_byte(value);
210 DBG("FilterReadStatus :%u", filter.read_status);
211 } else if (!g_strcmp0(key, "FilterRecipient")) {
212 g_variant_get(value, "s", &filter.recipient);
213 DBG("FilterRecipient :%s", filter.recipient);
214 } else if (!g_strcmp0(key, "FilterOriginator")) {
215 g_variant_get(value, "s", &filter.originator);
216 DBG("FilterOriginator :%s", filter.originator);
217 } else if (!g_strcmp0(key, "FilterPriority")) {
218 filter.priority = g_variant_get_byte(value);
219 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;
394 gboolean is_mns_connected(void)
402 guint64 _bt_validate_uid(int uid, int msg_type)
405 struct id_info *info;
406 GSList *list = id_list;
411 if (info && info->uid == uid && info->msg_type == msg_type) {
412 DBG("UID = %d, MessageType=%d", uid, msg_type);
416 list = g_slist_next(list);
423 guint64 _bt_add_id(int uid, int msg_type)
426 static guint64 map_id;
427 struct id_info *info;
430 DBG("Add id: %d, MsgType:%d", uid, msg_type);
431 test = _bt_validate_uid(uid, msg_type);
432 DBG("test: %llx\n", test);
436 info = g_new0(struct id_info, 1);
440 info->map_id = map_id;
442 info->msg_type = msg_type;
443 DBG("map_id = %llx, uid = %d, MsgType=%d", info->map_id, info->uid, msg_type);
445 id_list = g_slist_append(id_list, info);
451 static struct id_info *__bt_get_id(guint64 map_id)
454 struct id_info *info;
455 GSList *list = id_list;
460 if (info->map_id == map_id)
463 list = g_slist_next(list);
470 static struct id_info *__bt_get_uid(gchar *handle)
474 struct id_info *handle_info;
479 map_id = g_ascii_strtoull(handle, NULL, 16);
483 handle_info = __bt_get_id(map_id);
489 int _bt_update_id(guint64 map_id, int new_uid, int msg_type)
492 struct id_info *info;
493 GSList *list = id_list;
498 if (info->map_id == map_id) {
500 info->msg_type = msg_type;
504 list = g_slist_next(list);
511 static void __bt_remove_list(GSList *id_list)
517 DBG("Removing id list\n");
518 g_slist_free_full(id_list, g_free);
522 gboolean _bt_verify_sender(message_info_t *msg_info, char *sender)
527 if (!g_strcmp0(sender, "*"))
530 if (g_strrstr(msg_info->sender_name, sender) ||
531 g_strrstr(msg_info->sender_addressing, sender))
537 gboolean _bt_verify_receiver(message_info_t *msg_info, char *receiver)
542 if (!g_strcmp0(receiver, "*"))
545 if (g_strrstr(msg_info->recipient_name, receiver) ||
546 g_strrstr(msg_info->recipient_addressing, receiver))
552 gboolean _bt_verify_read_status(message_info_t *msg_info, guint8 read_status)
554 if (read_status == FILTER_READ_STATUS_ALL ||
555 ((read_status == FILTER_READ_STATUS_UNREAD) && msg_info->read == FALSE) ||
556 ((read_status == FILTER_READ_STATUS_READ) && msg_info->read == TRUE))
562 gboolean _bt_filter_priority(message_info_t *msg_info, guint8 priority)
564 if (priority == FILTER_PRIORITY_ALL ||
565 ((priority == FILTER_PRIORITY_HIGH) && msg_info->priority == TRUE) ||
566 ((priority == FILTER_PRIORITY_LOW) && msg_info->priority == FALSE))
572 void _get_msg_timestamp(time_t *ltime, char *timestamp)
575 struct tm local_time;
579 if (!localtime_r(ltime, &local_time))
582 year = local_time.tm_year + 1900; /* years since 1900 */
583 month = local_time.tm_mon + 1; /* months since January */
584 snprintf(timestamp, 16, "%04d%02d%02dT%02d%02d%02d", year, month,
585 local_time.tm_mday, local_time.tm_hour,
586 local_time.tm_min, local_time.tm_sec);
591 time_t _get_time_t_from_timestamp(char *timestamp)
593 struct tm local_time;
598 int ymd; /* year, month, day */
599 int hms; /* hour, min, sec */
602 ymd = strtol(timestamp, &ptr, 10);
603 hms = strtol(ptr + 1, &ptr2, 10);
605 /* parse year, month, day */
606 local_time.tm_mday = ymd % 100;
607 ymd = (ymd - local_time.tm_mday) / 100;
609 year = (ymd - month) / 100;
611 /* parse hour, minute, sec */
612 local_time.tm_sec = hms % 100;
613 hms = (hms - local_time.tm_sec) / 100;
614 local_time.tm_min = hms % 100;
615 local_time.tm_hour = (hms - local_time.tm_min) / 100;
617 local_time.tm_year = year - 1900;
618 local_time.tm_mon = month - 1;
620 int_time = mktime(&local_time);
624 gboolean _bt_verify_time(message_info_t *msg_info, map_msg_filter_t *filter)
626 struct tm local_time = { 0, };
630 /* Set 19710101T000000 as Start Date */
631 local_time.tm_year = 1971 - 1900;
632 local_time.tm_mon = 0;
633 local_time.tm_mday = 1;
634 start = mktime(&local_time);
636 /* Set 20380101T000000 as End Date */
637 local_time.tm_year = 2038 - 1900;
638 local_time.tm_mon = 0;
639 local_time.tm_mday = 1;
640 end = mktime(&local_time);
642 if (filter->period_begin)
643 start = _get_time_t_from_timestamp(filter->period_begin);
645 if (filter->period_end)
646 end = _get_time_t_from_timestamp(filter->period_end);
648 if (msg_info->time >= start && msg_info->time <= end)
654 #define SET_TON_NPI(dest, ton, npi) { \
656 dest |= (ton & 0x07) << 4; \
657 dest |= npi & 0x0F; \
660 static int __bt_ascii_to_upper(int ch)
662 return (('a' <= (ch) && (ch) <= 'z') ? ((ch) - ('a'-'A')) : (ch));
665 static int __bt_sms_pack_gsm_code(gchar *p_out, const char *data, int in_len)
672 for (pos = 0, i = 0; i < in_len; pos++, i++) {
673 /* pack the low bits */
674 p_out[pos] = data[i] >> shift;
676 if (i + 1 < in_len) {
677 /* pack the high bits using the low bits
678 of the next character */
679 p_out[pos] |= data[i+1] << (7 - shift);
694 static void __bt_sms_conv_digit_to_bcd(gchar *p_bcd, char *p_digits, int digit_len)
700 unsigned char higher;
703 if (p_bcd == NULL || p_digits == NULL)
706 /* 0123456789 -> 1032547698 */
707 for (i = 0, j = 0; i < digit_len; i = i + 2, j++) {
708 if (p_digits[i] == '*')
710 else if (p_digits[i] == '#')
712 else if (__bt_ascii_to_upper(p_digits[i]) == 'P')
715 digit = (int) (p_digits[i] - '0');
717 lower = digit & 0x0F;
719 if (digit_len != i + 1) {
720 if (p_digits[i+1] == '*')
722 else if (p_digits[i+1] == '#')
724 else if (__bt_ascii_to_upper(p_digits[i+1]) == 'P')
727 digit = (int) (p_digits[i+1] - '0');
729 higher = digit & 0x0F;
734 p_bcd[j] = (higher << 4) | lower;
739 static int __bt_sms_encode_addr(gchar *addr_field, char *dial_num,
740 int dial_num_len, int ton, int npi)
745 if (dial_num == NULL || addr_field == NULL)
748 if (dial_num[0] == '+') {
751 ton = SMS_TON_INTERNATIONAL;
754 if (ton != SMS_TON_ALPHA_NUMERIC) {
755 /* Origination address length address length */
756 addr_field[index++] = (unsigned char)dial_num_len;
758 addr_field[index] = (unsigned char)
759 (((dial_num_len * 7 + 7) / 8) * 2);
761 if (((dial_num_len * 7) % 8) <= 4)
767 SET_TON_NPI(addr_field[index], ton, npi);
768 index++; /* SET_TON_NPI */
770 if (ton != SMS_TON_ALPHA_NUMERIC) {
771 __bt_sms_conv_digit_to_bcd(&addr_field[index],
772 (char *)dial_num, dial_num_len);
774 if (dial_num_len % 2)
775 index += (dial_num_len / 2) + 1;
777 index += dial_num_len / 2;
779 index += __bt_sms_pack_gsm_code(&addr_field[index],
780 dial_num, (int)dial_num_len);
787 static int __bt_sms_encode_time(gchar *addr_field, time_t *tm)
795 if (!localtime_r(tm, <ime))
798 year = ltime.tm_year + 1900; /* years since 1900 */
800 month = ltime.tm_mon + 1; /* months since January */
802 addr_field[index++] = ((year % 10) << 4) + (year / 10);
803 addr_field[index++] = ((month % 10) << 4) + (month / 10);
804 addr_field[index++] = ((ltime.tm_mday % 10) << 4) +
805 (ltime.tm_mday / 10);
806 addr_field[index++] = ((ltime.tm_hour % 10) << 4) +
807 (ltime.tm_hour / 10);
808 addr_field[index++] = ((ltime.tm_min % 10) << 4) + (ltime.tm_min / 10);
809 addr_field[index++] = ((ltime.tm_sec % 10) << 4) + (ltime.tm_sec / 10);
810 addr_field[index] = 0x00;
816 gchar *__bt_get_sms_pdu_from_msg_data(gchar *number,
817 char *msg, time_t tm,
821 gchar packet[TAPI_NETTEXT_MSG_SIZE_MAX] = {0,};
824 packet[index] = 0x00; /* Since SCA is unknown for stored messages */
827 /* TP-MTI : Type of message */
828 packet[index] = 0x00; /* SMS-DELIVER PDU */
830 /* TP-MMS bit is set to 1 as we support only SMS */
831 packet[index] |= 0x04;
834 /* TP-OA : Mobile originating address */
835 index += __bt_sms_encode_addr(packet+index,
836 number, strlen(number),
837 g_sca_info->Ton, g_sca_info->Npi);
839 /* TP-PID : Since we use only SMS so set to 0 */
840 packet[index++] = 0x00;
842 /* TP-DCS : Data Coding Scheme, default value set */
843 packet[index++] = 0x00;
845 /* TP-SCTS : Message timestamp */
846 index += __bt_sms_encode_time(packet+index, &tm);
848 /* TP-UDL : Message body length */
849 packet[index++] = strlen(msg);
851 /* TP-UD : Message body */
852 index += __bt_sms_pack_gsm_code(packet + index, msg, strlen(msg));
854 *msg_pdu_len = index;
857 return g_memdup(packet, index);
860 static void __bt_get_sms_sca(TapiHandle *handle, int result, void *data,
864 TelSmsAddressInfo_t *scaInfo = data;
866 DBG("__bt_get_sms_sca 0x%x", result);
869 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
872 g_sca_info->DialNumLen = 0;
876 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
877 g_sca_info->Ton = scaInfo->Ton;
878 g_sca_info->Npi = scaInfo->Npi;
879 g_sca_info->DialNumLen = scaInfo->DialNumLen;
883 void _bt_message_info_free(gpointer data)
886 message_info_t *msg_info = (message_info_t *)data;
887 g_free(msg_info->handle);
888 g_free(msg_info->subject);
889 g_free(msg_info->datetime);
890 g_free(msg_info->sender_name);
891 g_free(msg_info->sender_addressing);
892 g_free(msg_info->replyto_addressing);
893 g_free(msg_info->recipient_name);
894 g_free(msg_info->recipient_addressing);
895 g_free(msg_info->type);
896 g_free(msg_info->reception_status);
897 g_free(msg_info->size);
898 g_free(msg_info->attachment_size);
903 static gboolean __bluetooth_map_start_service()
909 sms = _bt_map_start_sms_service();
910 email = _bt_map_start_email_service();
918 static gboolean __bt_validate_utf8(char **text)
921 if (g_utf8_validate(*text, -1, NULL))
928 gboolean _bt_validate_msg_data(message_info_t *msg_info)
931 if (msg_info == NULL)
934 if (msg_info->subject)
935 return __bt_validate_utf8(&msg_info->subject);
937 if (msg_info->sender_name)
938 return __bt_validate_utf8(&msg_info->sender_name);
940 if (msg_info->sender_addressing)
941 return __bt_validate_utf8(&msg_info->sender_addressing);
943 if (msg_info->replyto_addressing)
944 return __bt_validate_utf8(&msg_info->replyto_addressing);
946 if (msg_info->recipient_name)
947 return __bt_validate_utf8(&msg_info->recipient_name);
949 if (msg_info->recipient_addressing)
950 return __bt_validate_utf8(&msg_info->recipient_addressing);
956 static void __bt_mns_client_connect(char *address)
959 GDBusConnection *connection;
960 GVariantBuilder builder;
964 GError *error = NULL;
965 const char *session_path;
968 DBG_SECURE("MNS Client already connected to %s", address);
972 connection = __bt_map_get_gdbus_connection();
973 if (connection == NULL) {
974 DBG("Could not get GDBus Connection");
978 g_mns_proxy = g_dbus_proxy_new_sync(connection,
979 G_DBUS_PROXY_FLAGS_NONE, NULL,
980 OBEX_CLIENT_SERVICE, OBEX_CLIENT_PATH,
981 OBEX_CLIENT_INTERFACE, NULL, &error);
984 ERR("Failed to get a proxy for D-Bus");
989 g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
990 g_variant_builder_add(&builder, "{sv}", "Target",
991 g_variant_new("s", "MNS"));
992 args = g_variant_builder_end(&builder);
994 param = g_variant_new("(s@a{sv})", address, args);
996 value = g_dbus_proxy_call_sync(g_mns_proxy,
997 "CreateSession", param, G_DBUS_CALL_FLAGS_NONE, -1,
1000 /* dBUS-RPC is failed */
1001 ERR("dBUS-RPC is failed");
1002 if (error != NULL) {
1003 /* dBUS gives error cause */
1004 ERR("D-Bus API failure: errCode[%x], message[%s]",
1005 error->code, error->message);
1007 g_clear_error(&error);
1009 g_object_unref(g_mns_proxy);
1014 g_variant_get(value, "(&o)", &session_path);
1015 g_mns_path = g_strdup(session_path);
1016 DBG("g_mns_path = %s\n", g_mns_path);
1018 g_variant_unref(value);
1022 static void __bt_mns_client_disconnect()
1025 GError *error = NULL;
1029 ERR("No proxy to disconnect");
1033 value = g_dbus_proxy_call_sync(g_mns_proxy,
1034 "RemoveSession", g_variant_new("(o)", g_mns_path),
1035 G_DBUS_CALL_FLAGS_NONE, -1,
1038 if (value == NULL) {
1039 /* dBUS-RPC is failed */
1040 ERR("dBUS-RPC is failed: Could not remove MAP session");
1041 if (error != NULL) {
1042 /* dBUS gives error cause */
1043 ERR("D-Bus API failure: errCode[%x], message[%s]",
1044 error->code, error->message);
1046 g_clear_error(&error);
1054 g_object_unref(g_mns_proxy);
1057 g_variant_unref(value);
1061 void _bt_mns_client_event_notify(gchar *event, guint64 handle,
1062 gchar *folder, gchar *old_folder,
1066 GError *error = NULL;
1067 GDBusProxy *mns_proxy;
1068 GDBusConnection *connection = NULL;
1072 ERR("No client proxy");
1076 connection = __bt_map_get_gdbus_connection();
1077 if (connection == NULL) {
1078 DBG("Could not get GDBus Connection");
1082 mns_proxy = g_dbus_proxy_new_sync(connection,
1083 G_DBUS_PROXY_FLAGS_NONE, NULL,
1084 OBEX_CLIENT_SERVICE, g_mns_path,
1085 MNS_CLIENT_INTERFACE, NULL, &error);
1086 if (mns_proxy == NULL) {
1087 ERR("Failed to get a proxy for D-Bus\n");
1091 value = g_dbus_proxy_call_sync(mns_proxy, "SendEvent",
1092 g_variant_new("(stsss)", event, handle, folder, old_folder, msg_type),
1093 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1094 if (value == NULL) {
1095 /* dBUS-RPC is failed */
1096 ERR("dBUS-RPC is failed: SendEvent failed");
1097 if (error != NULL) {
1098 /* dBUS gives error cause */
1099 ERR("D-Bus API failure: errCode[%x], message[%s]",
1100 error->code, error->message);
1102 g_clear_error(&error);
1104 g_object_unref(mns_proxy);
1108 g_variant_unref(value);
1109 g_object_unref(mns_proxy);
1113 static gchar *__bt_get_map_folder(int folder)
1117 return g_strdup("INBOX");
1119 return g_strdup("SENT");
1121 return g_strdup("OUTBOX");
1123 return g_strdup("DRAFT");
1124 case BT_MSG_DELETED:
1125 return g_strdup("DELETED");
1130 static GList *_bt_map_merge_sorted(GSList *sms_list, GSList *email_list)
1133 message_info_t *sms;
1134 message_info_t *email;
1136 /* **********************Note from glib documentation**************************
1137 * g_list_append() has to traverse the entire list to find the end, which
1138 * is inefficient when adding multiple elements. A common idiom to avoid the
1139 * inefficiency is to use g_list_prepend() and reverse the list with
1140 * g_list_reverse() when all elements have been added.
1141 * ***************************************************************************/
1143 while (sms_list && email_list) {
1144 sms = sms_list->data;
1145 email = email_list->data;
1147 if (sms->time > email->time) {
1148 list = g_list_prepend(list, sms);
1149 sms_list = g_slist_next(sms_list);
1151 list = g_list_prepend(list, email);
1152 email_list = g_slist_next(email_list);
1157 sms = sms_list->data;
1158 list = g_list_prepend(list, sms);
1159 sms_list = g_slist_next(sms_list);
1161 while (email_list) {
1162 email = email_list->data;
1163 list = g_list_prepend(list, email);
1164 email_list = g_slist_next(email_list);
1167 list = g_list_reverse(list);
1171 static GVariant *__bt_map_get_folder_tree(GError **err)
1173 GVariant *folder_list = NULL;
1174 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(s)"));
1176 gboolean sms_ret = TRUE;
1177 gboolean email_ret = TRUE;
1179 sms_ret = _bt_map_sms_get_supported_folders(folders_supported);
1180 email_ret = _bt_map_email_get_supported_folders(folders_supported);
1182 if (sms_ret || email_ret) {
1183 for (i = 0; i < 5; i++) {
1184 if (folders_supported[i][BT_MSG_SOURCE_SMS] ||
1185 folders_supported[i][BT_MSG_SOURCE_EMAIL]) {
1186 g_variant_builder_add(builder, "(s)", __bt_get_map_folder(i));
1190 folder_list = g_variant_new("(a(s))", builder);
1192 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1196 g_variant_builder_unref(builder);
1200 static GVariant *__bt_map_get_message_list(char *folder_name, guint16 max,
1201 guint16 offset, guint8 subject_len,
1202 map_msg_filter_t *filter, GError **err)
1205 GVariant *message_list = NULL;
1206 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssssssssssbsbbbbs)"));
1207 GSList *sms_list = NULL;
1208 GSList *email_list = NULL;
1209 gboolean sms_ret = TRUE;
1210 gboolean email_ret = TRUE;
1212 guint64 count_sms = 0;
1213 guint64 count_email = 0;
1214 gboolean newmsg = FALSE;
1215 char *folder = NULL;
1217 DBG("Folder:%s Max:%d", folder_name, max);
1221 /* In case of parent folders send empty message listing */
1223 if (g_ascii_strncasecmp(folder_name, "/telecom/msg/", strlen("/telecom/msg/")))
1227 folder = strrchr(folder_name, '/');
1229 folder = folder_name;
1232 DBG("Filter Type: %d", filter->type);
1233 if ((filter->type & FILTER_TYPE_SMS_GSM) == 0) { /* Check if SMS is requested */
1234 if (!g_ascii_strncasecmp(folder, "SENT", strlen("SENT"))) {
1235 /* Failed Sent SMS are stored in OUTBOX.
1236 * Hence, Fetch both SENT and OUTBOX */
1237 gboolean sent_ret = _bt_map_get_sms_message_list("SENT",
1238 max + offset, subject_len, filter,
1239 &sms_list, &count_sms, &newmsg);
1240 gboolean outbox_ret = _bt_map_get_sms_message_list("OUTBOX",
1241 max + offset, subject_len, filter,
1242 &sms_list, &count_sms, &newmsg);
1243 sms_ret = (sent_ret || outbox_ret);
1245 sms_ret = _bt_map_get_sms_message_list(folder,
1246 max + offset, subject_len, filter,
1247 &sms_list, &count_sms, &newmsg);
1251 if ((filter->type & FILTER_TYPE_EMAIL) == 0) { /* Check if EMAIL is requested */
1252 email_ret = _bt_map_get_email_list(folder,
1253 max + offset, subject_len, filter,
1254 &email_list, &count_email, &newmsg);
1257 if (sms_ret || email_ret) {
1258 GList *list = _bt_map_merge_sorted(sms_list, email_list);
1261 message_info_t *msg_info = NULL;
1263 g_slist_free(sms_list);
1264 g_slist_free(email_list);
1266 count = count_sms + count_email;
1268 pos = g_list_nth(list, offset);
1269 for (i = offset; pos && i < max + offset; i++) {
1270 msg_info = pos->data;
1271 g_variant_builder_add(builder, "(ssssssssssbsbbbbs)",
1275 msg_info->sender_name,
1276 msg_info->sender_addressing,
1277 msg_info->recipient_name,
1278 msg_info->recipient_addressing,
1281 msg_info->reception_status,
1283 msg_info->attachment_size,
1288 msg_info->replyto_addressing);
1290 pos = g_list_next(pos);
1293 message_list = g_variant_new("(bta(ssssssssssbsbbbbs))",
1294 newmsg, count, builder);
1295 g_variant_builder_unref(builder);
1296 g_list_free_full(list, _bt_message_info_free);
1298 return message_list;
1302 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1304 g_variant_builder_unref(builder);
1309 static GVariant *__bt_map_get_message(char *message_name, gboolean attach,
1310 gboolean transcode, gboolean first_request, GError **err)
1313 GVariant *message = NULL;
1316 gchar *bmseg = NULL;
1318 struct id_info *handle_info = __bt_get_uid(message_name);
1319 if (handle_info == NULL)
1322 message_id = handle_info->uid;
1323 if (handle_info->msg_type == BT_MAP_ID_SMS)
1324 val_ret = _bt_map_get_sms_message(message_id, attach, transcode, first_request, &bmseg);
1326 val_ret = _bt_map_get_email_message(message_id, attach, transcode, first_request, &bmseg);
1329 message = g_variant_new("(bs)", FALSE, bmseg);
1335 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1341 static GVariant *__bt_map_push_message(gboolean save_copy, gboolean retry_send,
1342 gboolean native, char *folder_name, GError **err)
1347 DBG_SECURE("folder_name = %s\n", folder_name);
1349 handle = _bt_add_id(-1, BT_MAP_ID_SMS);
1350 current_push_map_id = handle;
1351 push_folder = g_strdup(folder_name);
1353 /* FALSE : Keep messages in Sent folder */
1354 /* TRUE : don't keep messages in sent folder */
1355 opt.save_copy = save_copy;
1356 DBG("opt.save_copy = %d\n", opt.save_copy);
1358 /* FALSE : don't retry */
1360 opt.retry_send = retry_send;
1361 DBG("opt.retry_send = %d\n", opt.retry_send);
1363 /* FALSE : native */
1365 opt.native = native;
1366 DBG("opt.native = %d\n", opt.native);
1368 return g_variant_new("(t)", handle);
1372 static GVariant *__bt_map_push_message_data(char *bmseg, GError **err)
1375 gboolean ret = FALSE;
1377 DBG_SECURE("BMSG: %s", bmseg);
1379 struct bmsg_data *bmsg_info = NULL;
1381 bmsg_info = bmsg_parse(bmseg);
1383 if (!g_ascii_strcasecmp(bmsg_info->type, "SMS_GSM"))
1384 ret = _bt_map_push_sms_data(bmsg_info, &opt, push_folder);
1385 else if (!g_ascii_strcasecmp(bmsg_info->type, "EMAIL"))
1386 ret = _bt_map_push_email_data(bmsg_info, &opt, push_folder);
1388 bmsg_free_bmsg(bmsg_info);
1391 g_free(push_folder);
1394 INFO("Message Successfully Sent or Saved");
1398 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1400 ERR("Error in sending or saving Message");
1404 /* Dummy Implementation */
1405 static GVariant *__bt_map_update_message(GError **err)
1407 return g_variant_new("(b)", TRUE);
1410 static GVariant *__bt_map_set_read_status(char *handle, gboolean read_status, GError **err)
1416 struct id_info *handle_info = __bt_get_uid(handle);
1417 if (handle_info == NULL)
1420 msg_id = handle_info->uid;
1421 DBG("msg_id = %d, read_status = %d\n", msg_id, read_status);
1422 if (handle_info->msg_type == BT_MAP_ID_SMS)
1423 val_ret = _bt_map_sms_set_read_status(msg_id, read_status);
1425 val_ret = _bt_map_set_email_read_status(msg_id, read_status);
1433 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1439 static GVariant *__bt_map_set_delete_status(char *handle, gboolean delete_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 if (handle_info->msg_type == BT_MAP_ID_SMS)
1451 val_ret = _bt_map_set_sms_delete_status(msg_id, delete_status);
1453 val_ret = _bt_map_set_email_delete_status(msg_id, delete_status);
1461 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1467 static void __bt_map_noti_registration(char *remote_addr, gboolean status)
1470 DBG_SECURE("remote_addr = %s \n", remote_addr);
1473 __bt_mns_client_connect(remote_addr);
1475 __bt_mns_client_disconnect();
1478 static void __bt_map_destroy_agent(void)
1480 g_main_loop_quit(g_mainloop);
1483 static GDBusNodeInfo *__bt_map_create_method_node_info
1484 (const gchar *introspection_data)
1487 GDBusNodeInfo *node_info = NULL;
1489 if (introspection_data == NULL)
1492 node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
1495 ERR("Unable to create node: %s", err->message);
1496 g_clear_error(&err);
1501 static gboolean __bt_map_dbus_init(void)
1505 GDBusNodeInfo *node_info;
1506 GError *error = NULL;
1507 GDBusConnection *gdbus_conn = __bt_map_get_gdbus_connection();
1509 if (gdbus_conn == NULL) {
1510 ERR("Error in creating the gdbus connection");
1514 owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1515 BT_MAP_SERVICE_NAME,
1516 G_BUS_NAME_OWNER_FLAGS_NONE,
1519 DBG("owner_id is [%d]", owner_id);
1521 node_info = __bt_map_create_method_node_info(
1522 map_agent_introspection_xml);
1523 if (node_info == NULL)
1526 map_id = g_dbus_connection_register_object(gdbus_conn, BT_MAP_SERVICE_OBJECT_PATH,
1527 node_info->interfaces[0],
1529 NULL, NULL, &error);
1531 g_dbus_node_info_unref(node_info);
1534 ERR("Failed to register: %s", error->message);
1535 g_error_free(error);
1546 DBG("Starting Bluetooth MAP agent");
1550 g_mainloop = g_main_loop_new(NULL, FALSE);
1552 if (g_mainloop == NULL) {
1553 ERR("Couldn't create GMainLoop\n");
1554 return EXIT_FAILURE;
1557 if (__bt_map_dbus_init() == FALSE)
1560 if (__bluetooth_map_start_service() == FALSE)
1563 g_tapi_handle = tel_init(NULL);
1567 ret = tel_get_sms_sca(g_tapi_handle, 0, __bt_get_sms_sca, NULL);
1568 if (ret != TAPI_API_SUCCESS) {
1569 ERR("TAPI err = %d", ret);
1573 g_main_loop_run(g_mainloop);
1577 __bt_remove_list(id_list);
1579 tel_deinit(g_tapi_handle);
1582 __bt_mns_client_disconnect();
1585 g_object_unref(map_dbus_conn);
1587 _bt_map_stop_sms_service();
1588 _bt_map_stop_email_service();
1590 DBG("Bluetooth MAP agent Terminated successfully\n");
1592 return EXIT_FAILURE;