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_SESSION, 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 sscanf(timestamp, "%04d%02d%02dT%02d%02d%02d", &year, &month,
599 &local_time.tm_mday, &local_time.tm_hour,
600 &local_time.tm_min, &local_time.tm_sec);
602 local_time.tm_year = year - 1900;
603 local_time.tm_mon = month - 1;
605 int_time = mktime(&local_time);
609 gboolean _bt_verify_time(message_info_t *msg_info, map_msg_filter_t *filter)
611 struct tm local_time = { 0, };
615 /* Set 19710101T000000 as Start Date */
616 local_time.tm_year = 1971 - 1900;
617 local_time.tm_mon = 0;
618 local_time.tm_mday = 1;
619 start = mktime(&local_time);
621 /* Set 20380101T000000 as End Date */
622 local_time.tm_year = 2038 - 1900;
623 local_time.tm_mon = 0;
624 local_time.tm_mday = 1;
625 end = mktime(&local_time);
627 if (filter->period_begin)
628 start = _get_time_t_from_timestamp(filter->period_begin);
630 if (filter->period_end)
631 end = _get_time_t_from_timestamp(filter->period_end);
633 if (msg_info->time >= start && msg_info->time <= end)
639 #define SET_TON_NPI(dest, ton, npi) { \
641 dest |= (ton & 0x07) << 4; \
642 dest |= npi & 0x0F; \
645 static int __bt_ascii_to_upper(int ch)
647 return (('a' <= (ch) && (ch) <= 'z') ? ((ch) - ('a'-'A')) : (ch));
650 static int __bt_sms_pack_gsm_code(gchar *p_out, const char *data, int in_len)
657 for (pos = 0, i = 0; i < in_len; pos++, i++) {
658 /* pack the low bits */
659 p_out[pos] = data[i] >> shift;
661 if (i + 1 < in_len) {
662 /* pack the high bits using the low bits
663 of the next character */
664 p_out[pos] |= data[i+1] << (7 - shift);
679 static void __bt_sms_conv_digit_to_bcd(gchar *p_bcd, char *p_digits, int digit_len)
685 unsigned char higher;
688 if (p_bcd == NULL || p_digits == NULL)
691 /* 0123456789 -> 1032547698 */
692 for (i = 0, j = 0; i < digit_len; i = i + 2, j++) {
693 if (p_digits[i] == '*')
695 else if (p_digits[i] == '#')
697 else if (__bt_ascii_to_upper(p_digits[i]) == 'P')
700 digit = (int) (p_digits[i] - '0');
702 lower = digit & 0x0F;
704 if (digit_len != i + 1) {
705 if (p_digits[i+1] == '*')
707 else if (p_digits[i+1] == '#')
709 else if (__bt_ascii_to_upper(p_digits[i+1]) == 'P')
712 digit = (int) (p_digits[i+1] - '0');
714 higher = digit & 0x0F;
719 p_bcd[j] = (higher << 4) | lower;
724 static int __bt_sms_encode_addr(gchar *addr_field, char *dial_num,
725 int dial_num_len, int ton, int npi)
730 if (dial_num == NULL || addr_field == NULL)
733 if (dial_num[0] == '+') {
736 ton = SMS_TON_INTERNATIONAL;
739 if (ton != SMS_TON_ALPHA_NUMERIC) {
740 /* Origination address length address length */
741 addr_field[index++] = (unsigned char)dial_num_len;
743 addr_field[index] = (unsigned char)
744 (((dial_num_len * 7 + 7) / 8) * 2);
746 if (((dial_num_len * 7) % 8) <= 4)
752 SET_TON_NPI(addr_field[index], ton, npi);
753 index++; /* SET_TON_NPI */
755 if (ton != SMS_TON_ALPHA_NUMERIC) {
756 __bt_sms_conv_digit_to_bcd(&addr_field[index],
757 (char *)dial_num, dial_num_len);
759 if (dial_num_len % 2)
760 index += (dial_num_len / 2) + 1;
762 index += dial_num_len / 2;
764 index += __bt_sms_pack_gsm_code(&addr_field[index],
765 dial_num, (int)dial_num_len);
772 static int __bt_sms_encode_time(gchar *addr_field, time_t *tm)
780 if (!localtime_r(tm, <ime))
783 year = ltime.tm_year + 1900; /* years since 1900 */
785 month = ltime.tm_mon + 1; /* months since January */
787 addr_field[index++] = ((year % 10) << 4) + (year / 10);
788 addr_field[index++] = ((month % 10) << 4) + (month / 10);
789 addr_field[index++] = ((ltime.tm_mday % 10) << 4) +
790 (ltime.tm_mday / 10);
791 addr_field[index++] = ((ltime.tm_hour % 10) << 4) +
792 (ltime.tm_hour / 10);
793 addr_field[index++] = ((ltime.tm_min % 10) << 4) + (ltime.tm_min / 10);
794 addr_field[index++] = ((ltime.tm_sec % 10) << 4) + (ltime.tm_sec / 10);
795 addr_field[index] = 0x00;
801 gchar *__bt_get_sms_pdu_from_msg_data(gchar *number,
802 char *msg, time_t tm,
806 gchar packet[TAPI_NETTEXT_MSG_SIZE_MAX] = {0,};
809 packet[index] = 0x00; /* Since SCA is unknown for stored messages */
812 /* TP-MTI : Type of message */
813 packet[index] = 0x00; /* SMS-DELIVER PDU */
815 /* TP-MMS bit is set to 1 as we support only SMS */
816 packet[index] |= 0x04;
819 /* TP-OA : Mobile originating address */
820 index += __bt_sms_encode_addr(packet+index,
821 number, strlen(number),
822 g_sca_info->Ton, g_sca_info->Npi);
824 /* TP-PID : Since we use only SMS so set to 0 */
825 packet[index++] = 0x00;
827 /* TP-DCS : Data Coding Scheme, default value set */
828 packet[index++] = 0x00;
830 /* TP-SCTS : Message timestamp */
831 index += __bt_sms_encode_time(packet+index, &tm);
833 /* TP-UDL : Message body length */
834 packet[index++] = strlen(msg);
836 /* TP-UD : Message body */
837 index += __bt_sms_pack_gsm_code(packet + index, msg, strlen(msg));
839 *msg_pdu_len = index;
842 return g_memdup(packet, index);
845 static void __bt_get_sms_sca(TapiHandle *handle, int result, void *data,
849 TelSmsAddressInfo_t *scaInfo = data;
851 DBG("__bt_get_sms_sca 0x%x", result);
854 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
857 g_sca_info->DialNumLen = 0;
861 g_sca_info = g_malloc0(sizeof(TelSmsAddressInfo_t));
862 g_sca_info->Ton = scaInfo->Ton;
863 g_sca_info->Npi = scaInfo->Npi;
864 g_sca_info->DialNumLen = scaInfo->DialNumLen;
868 void _bt_message_info_free(gpointer data)
871 message_info_t *msg_info = (message_info_t *)data;
872 g_free(msg_info->handle);
873 g_free(msg_info->subject);
874 g_free(msg_info->datetime);
875 g_free(msg_info->sender_name);
876 g_free(msg_info->sender_addressing);
877 g_free(msg_info->replyto_addressing);
878 g_free(msg_info->recipient_name);
879 g_free(msg_info->recipient_addressing);
880 g_free(msg_info->type);
881 g_free(msg_info->reception_status);
882 g_free(msg_info->size);
883 g_free(msg_info->attachment_size);
888 static gboolean __bluetooth_map_start_service()
894 sms = _bt_map_start_sms_service();
895 email = _bt_map_start_email_service();
903 static gboolean __bt_validate_utf8(char **text)
906 if (g_utf8_validate(*text, -1, NULL))
913 gboolean _bt_validate_msg_data(message_info_t *msg_info)
916 if (msg_info == NULL)
919 if (msg_info->subject)
920 return __bt_validate_utf8(&msg_info->subject);
922 if (msg_info->sender_name)
923 return __bt_validate_utf8(&msg_info->sender_name);
925 if (msg_info->sender_addressing)
926 return __bt_validate_utf8(&msg_info->sender_addressing);
928 if (msg_info->replyto_addressing)
929 return __bt_validate_utf8(&msg_info->replyto_addressing);
931 if (msg_info->recipient_name)
932 return __bt_validate_utf8(&msg_info->recipient_name);
934 if (msg_info->recipient_addressing)
935 return __bt_validate_utf8(&msg_info->recipient_addressing);
941 static void __bt_mns_client_connect(char *address)
944 GDBusConnection *connection;
945 GVariantBuilder builder;
949 GError *error = NULL;
950 const char *session_path;
953 DBG_SECURE("MNS Client already connected to %s", address);
957 connection = __bt_map_get_gdbus_connection();
958 if (connection == NULL) {
959 DBG("Could not get GDBus Connection");
963 g_mns_proxy = g_dbus_proxy_new_sync(connection,
964 G_DBUS_PROXY_FLAGS_NONE, NULL,
965 OBEX_CLIENT_SERVICE, OBEX_CLIENT_PATH,
966 OBEX_CLIENT_INTERFACE, NULL, &error);
969 ERR("Failed to get a proxy for D-Bus");
974 g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
975 g_variant_builder_add(&builder, "{sv}", "Target",
976 g_variant_new("s", "MNS"));
977 args = g_variant_builder_end(&builder);
979 param = g_variant_new("(s@a{sv})", address, args);
981 value = g_dbus_proxy_call_sync(g_mns_proxy,
982 "CreateSession", param, G_DBUS_CALL_FLAGS_NONE, -1,
985 /* dBUS-RPC is failed */
986 ERR("dBUS-RPC is failed");
988 /* dBUS gives error cause */
989 ERR("D-Bus API failure: errCode[%x], message[%s]",
990 error->code, error->message);
992 g_clear_error(&error);
994 g_object_unref(g_mns_proxy);
999 g_variant_get(value, "(&o)", &session_path);
1000 g_mns_path = g_strdup(session_path);
1001 DBG("g_mns_path = %s\n", g_mns_path);
1003 g_variant_unref(value);
1007 static void __bt_mns_client_disconnect()
1010 GError *error = NULL;
1014 ERR("No proxy to disconnect");
1018 value = g_dbus_proxy_call_sync(g_mns_proxy,
1019 "RemoveSession", g_variant_new("(o)", g_mns_path),
1020 G_DBUS_CALL_FLAGS_NONE, -1,
1023 if (value == NULL) {
1024 /* dBUS-RPC is failed */
1025 ERR("dBUS-RPC is failed: Could not remove MAP session");
1026 if (error != NULL) {
1027 /* dBUS gives error cause */
1028 ERR("D-Bus API failure: errCode[%x], message[%s]",
1029 error->code, error->message);
1031 g_clear_error(&error);
1039 g_object_unref(g_mns_proxy);
1042 g_variant_unref(value);
1046 void _bt_mns_client_event_notify(gchar *event, guint64 handle,
1047 gchar *folder, gchar *old_folder,
1051 GError *error = NULL;
1052 GDBusProxy *mns_proxy;
1053 GDBusConnection *connection = NULL;
1057 ERR("No client proxy");
1061 connection = __bt_map_get_gdbus_connection();
1062 if (connection == NULL) {
1063 DBG("Could not get GDBus Connection");
1067 mns_proxy = g_dbus_proxy_new_sync(connection,
1068 G_DBUS_PROXY_FLAGS_NONE, NULL,
1069 OBEX_CLIENT_SERVICE, g_mns_path,
1070 MNS_CLIENT_INTERFACE, NULL, &error);
1071 if (mns_proxy == NULL) {
1072 ERR("Failed to get a proxy for D-Bus\n");
1076 value = g_dbus_proxy_call_sync(mns_proxy, "SendEvent",
1077 g_variant_new("(stsss)", event, handle, folder, old_folder, msg_type),
1078 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1079 if (value == NULL) {
1080 /* dBUS-RPC is failed */
1081 ERR("dBUS-RPC is failed: SendEvent failed");
1082 if (error != NULL) {
1083 /* dBUS gives error cause */
1084 ERR("D-Bus API failure: errCode[%x], message[%s]",
1085 error->code, error->message);
1087 g_clear_error(&error);
1089 g_object_unref(mns_proxy);
1093 g_variant_unref(value);
1094 g_object_unref(mns_proxy);
1098 static gchar *__bt_get_map_folder(int folder)
1102 return g_strdup("INBOX");
1104 return g_strdup("SENT");
1106 return g_strdup("OUTBOX");
1108 return g_strdup("DRAFT");
1109 case BT_MSG_DELETED:
1110 return g_strdup("DELETED");
1115 static GList *_bt_map_merge_sorted(GSList *sms_list, GSList *email_list)
1118 message_info_t *sms;
1119 message_info_t *email;
1121 /* **********************Note from glib documentation**************************
1122 * g_list_append() has to traverse the entire list to find the end, which
1123 * is inefficient when adding multiple elements. A common idiom to avoid the
1124 * inefficiency is to use g_list_prepend() and reverse the list with
1125 * g_list_reverse() when all elements have been added.
1126 * ***************************************************************************/
1128 while (sms_list && email_list) {
1129 sms = sms_list->data;
1130 email = email_list->data;
1132 if (sms->time > email->time) {
1133 list = g_list_prepend(list, sms);
1134 sms_list = g_slist_next(sms_list);
1136 list = g_list_prepend(list, email);
1137 email_list = g_slist_next(email_list);
1142 sms = sms_list->data;
1143 list = g_list_prepend(list, sms);
1144 sms_list = g_slist_next(sms_list);
1146 while (email_list) {
1147 email = email_list->data;
1148 list = g_list_prepend(list, email);
1149 email_list = g_slist_next(email_list);
1152 list = g_list_reverse(list);
1156 static GVariant *__bt_map_get_folder_tree(GError **err)
1158 GVariant *folder_list = NULL;
1159 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(s)"));
1161 gboolean sms_ret = TRUE;
1162 gboolean email_ret = TRUE;
1164 sms_ret = _bt_map_sms_get_supported_folders(folders_supported);
1165 email_ret = _bt_map_email_get_supported_folders(folders_supported);
1167 if (sms_ret || email_ret) {
1168 for (i = 0; i < 5; i++) {
1169 if (folders_supported[i][BT_MSG_SOURCE_SMS] ||
1170 folders_supported[i][BT_MSG_SOURCE_EMAIL]) {
1171 g_variant_builder_add(builder, "(s)", __bt_get_map_folder(i));
1175 folder_list = g_variant_new("(a(s))", builder);
1177 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1181 g_variant_builder_unref(builder);
1185 static GVariant *__bt_map_get_message_list(char *folder_name, guint16 max,
1186 guint16 offset, guint8 subject_len,
1187 map_msg_filter_t *filter, GError **err)
1190 GVariant *message_list = NULL;
1191 GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssssssssssbsbbbbs)"));
1192 GSList *sms_list = NULL;
1193 GSList *email_list = NULL;
1194 gboolean sms_ret = TRUE;
1195 gboolean email_ret = TRUE;
1197 guint64 count_sms = 0;
1198 guint64 count_email = 0;
1199 gboolean newmsg = FALSE;
1200 char *folder = NULL;
1202 DBG("Folder:%s Max:%d", folder_name, max);
1206 /* In case of parent folders send empty message listing */
1208 if (g_ascii_strncasecmp(folder_name, "/telecom/msg/", strlen("/telecom/msg/")))
1212 folder = strrchr(folder_name, '/');
1214 folder = folder_name;
1217 DBG("Filter Type: %d", filter->type);
1218 if ((filter->type & FILTER_TYPE_SMS_GSM) == 0) { /* Check if SMS is requested */
1219 if (!g_ascii_strncasecmp(folder, "SENT", strlen("SENT"))) {
1220 /* Failed Sent SMS are stored in OUTBOX.
1221 * Hence, Fetch both SENT and OUTBOX */
1222 gboolean sent_ret = _bt_map_get_sms_message_list("SENT",
1223 max + offset, subject_len, filter,
1224 &sms_list, &count_sms, &newmsg);
1225 gboolean outbox_ret = _bt_map_get_sms_message_list("OUTBOX",
1226 max + offset, subject_len, filter,
1227 &sms_list, &count_sms, &newmsg);
1228 sms_ret = (sent_ret || outbox_ret);
1230 sms_ret = _bt_map_get_sms_message_list(folder,
1231 max + offset, subject_len, filter,
1232 &sms_list, &count_sms, &newmsg);
1236 if ((filter->type & FILTER_TYPE_EMAIL) == 0) { /* Check if EMAIL is requested */
1237 email_ret = _bt_map_get_email_list(folder,
1238 max + offset, subject_len, filter,
1239 &email_list, &count_email, &newmsg);
1242 if (sms_ret || email_ret) {
1243 GList *list = _bt_map_merge_sorted(sms_list, email_list);
1246 message_info_t *msg_info = NULL;
1248 g_slist_free(sms_list);
1249 g_slist_free(email_list);
1251 count = count_sms + count_email;
1253 pos = g_list_nth(list, offset);
1254 for (i = offset; pos && i < max + offset; i++) {
1255 msg_info = pos->data;
1256 g_variant_builder_add(builder, "(ssssssssssbsbbbbs)",
1260 msg_info->sender_name,
1261 msg_info->sender_addressing,
1262 msg_info->recipient_name,
1263 msg_info->recipient_addressing,
1266 msg_info->reception_status,
1268 msg_info->attachment_size,
1273 msg_info->replyto_addressing);
1275 pos = g_list_next(pos);
1278 message_list = g_variant_new("(bta(ssssssssssbsbbbbs))",
1279 newmsg, count, builder);
1280 g_variant_builder_unref(builder);
1281 g_list_free_full(list, _bt_message_info_free);
1283 return message_list;
1287 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1289 g_variant_builder_unref(builder);
1294 static GVariant *__bt_map_get_message(char *message_name, gboolean attach,
1295 gboolean transcode, gboolean first_request, GError **err)
1298 GVariant *message = NULL;
1301 gchar *bmseg = NULL;
1303 struct id_info *handle_info = __bt_get_uid(message_name);
1304 if (handle_info == NULL)
1307 message_id = handle_info->uid;
1308 if (handle_info->msg_type == BT_MAP_ID_SMS)
1309 val_ret = _bt_map_get_sms_message(message_id, attach, transcode, first_request, &bmseg);
1311 val_ret = _bt_map_get_email_message(message_id, attach, transcode, first_request, &bmseg);
1314 message = g_variant_new("(bs)", FALSE, bmseg);
1320 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1326 static GVariant *__bt_map_push_message(gboolean save_copy, gboolean retry_send,
1327 gboolean native, char *folder_name, GError **err)
1332 DBG_SECURE("folder_name = %s\n", folder_name);
1334 handle = _bt_add_id(-1, BT_MAP_ID_SMS);
1335 current_push_map_id = handle;
1336 push_folder = g_strdup(folder_name);
1338 /* FALSE : Keep messages in Sent folder */
1339 /* TRUE : don't keep messages in sent folder */
1340 opt.save_copy = save_copy;
1341 DBG("opt.save_copy = %d\n", opt.save_copy);
1343 /* FALSE : don't retry */
1345 opt.retry_send = retry_send;
1346 DBG("opt.retry_send = %d\n", opt.retry_send);
1348 /* FALSE : native */
1350 opt.native = native;
1351 DBG("opt.native = %d\n", opt.native);
1353 return g_variant_new("(t)", handle);
1357 static GVariant *__bt_map_push_message_data(char *bmseg, GError **err)
1360 gboolean ret = FALSE;
1362 DBG_SECURE("BMSG: %s", bmseg);
1364 struct bmsg_data *bmsg_info = NULL;
1366 bmsg_info = bmsg_parse(bmseg);
1368 if (!g_ascii_strcasecmp(bmsg_info->type, "SMS_GSM"))
1369 ret = _bt_map_push_sms_data(bmsg_info, &opt, push_folder);
1370 else if (!g_ascii_strcasecmp(bmsg_info->type, "EMAIL"))
1371 ret = _bt_map_push_email_data(bmsg_info, &opt, push_folder);
1373 bmsg_free_bmsg(bmsg_info);
1376 g_free(push_folder);
1379 INFO("Message Successfully Sent or Saved");
1383 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1385 ERR("Error in sending or saving Message");
1389 /* Dummy Implementation */
1390 static GVariant *__bt_map_update_message(GError **err)
1392 return g_variant_new("(b)", TRUE);
1395 static GVariant *__bt_map_set_read_status(char *handle, gboolean read_status, GError **err)
1401 struct id_info *handle_info = __bt_get_uid(handle);
1402 if (handle_info == NULL)
1405 msg_id = handle_info->uid;
1406 DBG("msg_id = %d, read_status = %d\n", msg_id, read_status);
1407 if (handle_info->msg_type == BT_MAP_ID_SMS)
1408 val_ret = _bt_map_sms_set_read_status(msg_id, read_status);
1410 val_ret = _bt_map_set_email_read_status(msg_id, read_status);
1418 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1424 static GVariant *__bt_map_set_delete_status(char *handle, gboolean delete_status, GError **err)
1430 struct id_info *handle_info = __bt_get_uid(handle);
1431 if (handle_info == NULL)
1434 msg_id = handle_info->uid;
1435 if (handle_info->msg_type == BT_MAP_ID_SMS)
1436 val_ret = _bt_map_set_sms_delete_status(msg_id, delete_status);
1438 val_ret = _bt_map_set_email_delete_status(msg_id, delete_status);
1446 *err = __bt_map_error(BT_MAP_AGENT_ERROR_INTERNAL,
1452 static void __bt_map_noti_registration(char *remote_addr, gboolean status)
1455 DBG_SECURE("remote_addr = %s \n", remote_addr);
1458 __bt_mns_client_connect(remote_addr);
1460 __bt_mns_client_disconnect();
1463 static void __bt_map_destroy_agent(void)
1465 g_main_loop_quit(g_mainloop);
1468 static GDBusNodeInfo *__bt_map_create_method_node_info
1469 (const gchar *introspection_data)
1472 GDBusNodeInfo *node_info = NULL;
1474 if (introspection_data == NULL)
1477 node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
1480 ERR("Unable to create node: %s", err->message);
1481 g_clear_error(&err);
1486 static gboolean __bt_map_dbus_init(void)
1490 GDBusNodeInfo *node_info;
1491 GError *error = NULL;
1492 GDBusConnection *gdbus_conn = __bt_map_get_gdbus_connection();
1494 if (gdbus_conn == NULL) {
1495 ERR("Error in creating the gdbus connection");
1499 owner_id = g_bus_own_name(G_BUS_TYPE_SESSION,
1500 BT_MAP_SERVICE_NAME,
1501 G_BUS_NAME_OWNER_FLAGS_NONE,
1504 DBG("owner_id is [%d]", owner_id);
1506 node_info = __bt_map_create_method_node_info(
1507 map_agent_introspection_xml);
1508 if (node_info == NULL)
1511 map_id = g_dbus_connection_register_object(gdbus_conn, BT_MAP_SERVICE_OBJECT_PATH,
1512 node_info->interfaces[0],
1514 NULL, NULL, &error);
1516 g_dbus_node_info_unref(node_info);
1519 ERR("Failed to register: %s", error->message);
1520 g_error_free(error);
1531 DBG("Starting Bluetooth MAP agent");
1535 g_mainloop = g_main_loop_new(NULL, FALSE);
1537 if (g_mainloop == NULL) {
1538 ERR("Couldn't create GMainLoop\n");
1539 return EXIT_FAILURE;
1542 if (__bt_map_dbus_init() == FALSE)
1545 if (__bluetooth_map_start_service() == FALSE)
1548 g_tapi_handle = tel_init(NULL);
1552 ret = tel_get_sms_sca(g_tapi_handle, 0, __bt_get_sms_sca, NULL);
1553 if (ret != TAPI_API_SUCCESS) {
1554 ERR("TAPI err = %d", ret);
1558 g_main_loop_run(g_mainloop);
1562 __bt_remove_list(id_list);
1564 tel_deinit(g_tapi_handle);
1567 __bt_mns_client_disconnect();
1570 g_object_unref(map_dbus_conn);
1572 _bt_map_stop_sms_service();
1573 _bt_map_stop_email_service();
1575 DBG("Bluetooth MAP agent Terminated successfully\n");
1577 return EXIT_FAILURE;