2 * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
29 #include <gio/gunixfdlist.h>
31 #include <arpa/inet.h>
33 #include "bt-otpserver.h"
34 #include "bluetooth-api.h"
36 #include <cynara-client.h>
39 #define LOG_TAG "BLUETOOTH_OTP"
41 #define BT_INFO(fmt, arg...) SLOGI(fmt, ##arg)
42 #define BT_ERR(fmt, arg...) SLOGE(fmt, ##arg)
43 #define BT_DBG(fmt, arg...) SLOGD(fmt, ##arg)
45 /* OTP object paths */
46 char *otp_obj_path = NULL;
47 char *otp_feature_obj_path = NULL;
48 char *otp_object_name_obj_path = NULL;
49 char *otp_object_type_obj_path = NULL;
50 char *otp_object_size_obj_path = NULL;
51 char *otp_object_first_created_obj_path = NULL;
52 char *otp_object_last_modified_obj_path = NULL;
53 char *otp_object_id_obj_path = NULL;
54 char *otp_object_prop_obj_path = NULL;
55 char *otp_oacp_obj_path = NULL;
56 char *otp_olcp_obj_path = NULL;
57 char *otp_oacp_desc_obj_path = NULL;
58 char *otp_olcp_desc_obj_path = NULL;
60 static GMainLoop *main_loop;
61 GDBusNodeInfo *otp_node_info = NULL;
62 static GDBusConnection *conn;
63 static GDBusConnection *g_conn;
65 static int property_sub_id = -1;
66 static int adapter_sub_id = -1;
67 static int device_sub_id = -1;
68 static int device_property_sub_id = -1;
69 static guint g_owner_id = 0;
70 static guint server_watch_id = 0;
72 struct otp_char_info {
78 struct indicate_info {
86 struct object_metadata {
97 struct oacp_operation {
102 uint32_t length_sofar;
108 static struct object_metadata *selected_object = NULL;
109 static uint64_t object_id = OBJECT_START_ID;
110 static GSList *otp_object_list = NULL;
111 static GSList *otp_char_list = NULL;
112 static guint curr_obj_index;
113 static int adv_handle = 0;
114 static gboolean OACP_indicate = FALSE;
115 static gboolean OLCP_indicate = FALSE;
116 char *directory = NULL;
117 gboolean mutiple_obj_support = false;
118 static gboolean otc_connection_status = FALSE;
119 struct oacp_operation *oacp_op = NULL;
120 unsigned int timeout_id;
121 unsigned int oacp_create_timeout_id;
122 uint64_t curr_obj_id, prev_obj_id;
123 static gboolean oacp_create = FALSE;
125 static const gchar otp_introspection_xml[] =
127 " <interface name='org.projectx.otp_service'>"
128 " <method name='enable'>"
129 " <arg type='s' name='directory'/>"
130 " <arg type='i' name='status' direction='out'/>"
132 " <method name='disable'>"
133 " <arg type='i' name='status' direction='out'/>"
135 " <method name='NewConnection'>"
136 " <arg type='o' name='object' direction='in'/>"
137 " <arg type='h' name='fd' direction='in'/>"
142 void _bt_otp_deinit_event_receiver(void);
143 void _bt_otp_unregister_interface(void);
144 void update_obj_metadata_charc_value(struct object_metadata *object);
145 void _bt_convert_device_path_to_address(const char *device_path,
146 char *device_address);
147 int _bt_otp_open_otc_and_listen(char *address, char *method);
148 void _bt_otp_restore_old_object();
149 struct object_metadata *_bt_otp_client_find_object(GSList *list,
150 uint64_t id, guint *index);
152 static void delete_all_objects(void)
155 for (tmp = otp_object_list; tmp != NULL; tmp = tmp->next) {
157 struct object_metadata *obj_info = tmp->data;
159 g_free(obj_info->name);
161 g_free(obj_info->type);
162 otp_object_list = g_slist_delete_link(otp_object_list, tmp->data);
165 g_slist_free(otp_object_list);
166 otp_object_list = NULL;
169 static void delete_all_characterisitc(void)
172 for (tmp = otp_char_list; tmp != NULL; tmp = tmp->next) {
174 struct otp_char_info *char_info = tmp->data;
175 if (char_info->char_path)
176 g_free(char_info->char_path);
177 if (char_info->char_value)
178 g_free(char_info->char_value);
179 otp_char_list = g_slist_delete_link(otp_char_list, tmp->data);
182 g_slist_free(otp_char_list);
183 otp_char_list = NULL;
186 void _bt_otp_exit(void)
192 delete_all_characterisitc();
195 delete_all_objects();
197 ret = bluetooth_gatt_deinit();
198 if (ret != BLUETOOTH_ERROR_NONE)
199 BT_ERR("Failed to Deinit GATT %d", ret);
201 _bt_otp_deinit_event_receiver();
203 _bt_otp_unregister_interface();
205 /* TODO: Advertising is not getting stopped by this API.
206 * This is because OTP_SERVER_DEINIT dbus call is blocking
207 * BT_SET_ADVERTISING_DATA dbus call. But now advertisment
208 * is stopped because of terminated process logic.
210 ret = bluetooth_set_advertising(adv_handle, FALSE);
211 if (ret != BLUETOOTH_ERROR_NONE)
212 BT_ERR("Failed to stop ADV %d", ret);
214 if (main_loop != NULL)
215 g_main_loop_quit(main_loop);
218 static void _bt_otp_set_char_value(const char *obj_path,
219 const char *value, int value_length)
225 for (tmp = otp_char_list; tmp != NULL; tmp = tmp->next) {
227 struct otp_char_info *char_info = tmp->data;
228 if (!g_strcmp0(char_info->char_path, obj_path)) {
229 char_info->char_value = g_try_realloc(char_info->char_value, value_length);
230 if (char_info->char_value) {
231 memcpy(char_info->char_value, value, value_length);
232 char_info->value_length = value_length;
241 int add_new_characteristic(const char *char_uuid, bt_gatt_permission_t perms,
242 bt_gatt_characteristic_property_t props, char **obj_path)
244 int ret = BLUETOOTH_ERROR_NONE;
245 struct otp_char_info *char_info = NULL;
247 ret = bluetooth_gatt_add_new_characteristic(otp_obj_path,
248 char_uuid, perms, props, obj_path);
249 if (ret != BLUETOOTH_ERROR_NONE) {
250 BT_ERR("Failed to add new char %d", ret);
254 char_info = g_new0(struct otp_char_info, 1);
255 char_info->char_path = g_strdup(*obj_path);
256 otp_char_list = g_slist_append(otp_char_list, char_info);
261 static char *_otp_convert_uuid_to_uuid128(const char *uuid)
271 uuid128 = g_strdup_printf("0000%s-0000-1000-8000-00805f9b34fb",
277 uuid128 = g_strdup_printf("%s-0000-1000-8000-00805f9b34fb",
283 uuid128 = strdup(uuid);
293 int _bt_otp_prepare_ots(void)
296 int ret = BLUETOOTH_ERROR_NONE;
300 bt_gatt_characteristic_property_t props;
301 bt_gatt_permission_t perms;
302 char supp_feat[OTP_FEATURE_LENGTH] = { 0x3B, 0x00, 0x00, 0x00,
303 0x01, 0x00, 0x00, 0x00 };
305 ret = bluetooth_gatt_init();
306 if (ret != BLUETOOTH_ERROR_NONE) {
307 BT_ERR("Failed to Init GATT %d", ret);
311 service_uuid = _otp_convert_uuid_to_uuid128(OTP_UUID);
312 ret = bluetooth_gatt_add_service(service_uuid, &otp_obj_path);
313 if (ret != BLUETOOTH_ERROR_NONE) {
314 BT_ERR("Failed to add service %d", ret);
318 /* Characteristic OTP Feature */
319 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ;
320 perms = BLUETOOTH_GATT_PERMISSION_READ;
321 char_uuid = _otp_convert_uuid_to_uuid128(OTP_FEATURE_UUID);
322 ret = add_new_characteristic(char_uuid, perms, props,
323 &otp_feature_obj_path);
324 if (ret != BLUETOOTH_ERROR_NONE)
327 ret = bluetooth_gatt_set_characteristic_value(otp_feature_obj_path,
328 supp_feat, OTP_FEATURE_LENGTH);
329 if (ret != BLUETOOTH_ERROR_NONE) {
330 BT_ERR("Failed to set char value %d", ret);
334 _bt_otp_set_char_value(otp_feature_obj_path, supp_feat,
337 /* Characteristic Object Name */
338 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
339 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE;
340 perms = BLUETOOTH_GATT_PERMISSION_READ |
341 BLUETOOTH_GATT_PERMISSION_WRITE;
342 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_NAME_UUID);
343 ret = add_new_characteristic(char_uuid, perms, props,
344 &otp_object_name_obj_path);
345 if (ret != BLUETOOTH_ERROR_NONE)
348 /* Characteristic Object Type */
349 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ;
350 perms = BLUETOOTH_GATT_PERMISSION_READ;
351 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_TYPE_UUID);
352 ret = add_new_characteristic(char_uuid, perms, props,
353 &otp_object_type_obj_path);
354 if (ret != BLUETOOTH_ERROR_NONE)
357 /* Characteristic Object Size */
358 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ;
359 perms = BLUETOOTH_GATT_PERMISSION_READ;
360 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_SIZE_UUID);
361 ret = add_new_characteristic(char_uuid, perms, props,
362 &otp_object_size_obj_path);
363 if (ret != BLUETOOTH_ERROR_NONE)
366 /* Characteristic Object First-Created */
367 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
368 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE;
369 perms = BLUETOOTH_GATT_PERMISSION_READ |
370 BLUETOOTH_GATT_PERMISSION_WRITE;
371 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_FIRST_CREATED_UUID);
372 ret = add_new_characteristic(char_uuid, perms, props,
373 &otp_object_first_created_obj_path);
374 if (ret != BLUETOOTH_ERROR_NONE)
377 /* Characteristic Object Last-Modified */
378 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
379 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE;
380 perms = BLUETOOTH_GATT_PERMISSION_READ |
381 BLUETOOTH_GATT_PERMISSION_WRITE;
382 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_LAST_MODIFIED_UUID);
383 ret = add_new_characteristic(char_uuid, perms, props,
384 &otp_object_last_modified_obj_path);
385 if (ret != BLUETOOTH_ERROR_NONE)
388 /* Object ID is mandatory for mutiple object server */
389 if (mutiple_obj_support) {
390 /* Characteristic Object ID */
391 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ;
392 perms = BLUETOOTH_GATT_PERMISSION_READ;
393 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_ID_UUID);
394 ret = add_new_characteristic(char_uuid, perms, props,
395 &otp_object_id_obj_path);
396 if (ret != BLUETOOTH_ERROR_NONE)
400 /* Characteristic Object Properties */
401 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
402 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE;
403 perms = BLUETOOTH_GATT_PERMISSION_READ |
404 BLUETOOTH_GATT_PERMISSION_WRITE;
405 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OBJECT_PROP_UUID);
406 ret = add_new_characteristic(char_uuid, perms, props,
407 &otp_object_prop_obj_path);
408 if (ret != BLUETOOTH_ERROR_NONE)
411 /* Characteristic OACP */
412 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE |
413 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
414 perms = BLUETOOTH_GATT_PERMISSION_WRITE;
415 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OACP_UUID);
416 ret = add_new_characteristic(char_uuid, perms, props,
418 if (ret != BLUETOOTH_ERROR_NONE)
422 desc_uuid = _otp_convert_uuid_to_uuid128(OTP_CP_CCC_DESC_UUID);
423 perms = BLUETOOTH_GATT_PERMISSION_READ |
424 BLUETOOTH_GATT_PERMISSION_WRITE;
425 ret = bluetooth_gatt_add_descriptor(otp_oacp_obj_path, desc_uuid,
426 perms, &otp_oacp_desc_obj_path);
427 if (ret != BLUETOOTH_ERROR_NONE) {
428 BT_ERR("Failed to add new char descriptor %d", ret);
432 /* OLCP Characteristics is not required
433 * for single object server
435 if (mutiple_obj_support) {
436 /* Characteristic OLCP */
437 props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE |
438 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
439 perms = BLUETOOTH_GATT_PERMISSION_WRITE;
440 char_uuid = _otp_convert_uuid_to_uuid128(OTP_OLCP_UUID);
441 ret = add_new_characteristic(char_uuid, perms, props,
443 if (ret != BLUETOOTH_ERROR_NONE)
447 desc_uuid = _otp_convert_uuid_to_uuid128(OTP_CP_CCC_DESC_UUID);
448 perms = BLUETOOTH_GATT_PERMISSION_READ |
449 BLUETOOTH_GATT_PERMISSION_WRITE;
450 ret = bluetooth_gatt_add_descriptor(otp_olcp_obj_path, desc_uuid,
451 perms, &otp_olcp_desc_obj_path);
452 if (ret != BLUETOOTH_ERROR_NONE) {
453 BT_ERR("Failed to add new char descriptor %d", ret);
458 /* Register service */
459 ret = bluetooth_gatt_register_service(otp_obj_path);
460 if (ret != BLUETOOTH_ERROR_NONE) {
461 BT_ERR("Failed to register service %d", ret);
465 /* Register Application */
466 ret = bluetooth_gatt_register_application();
467 if (ret != BLUETOOTH_ERROR_NONE) {
468 BT_ERR("Failed to register application %d", ret);
476 delete_all_characterisitc();
480 int _bt_otp_set_advertising_data(void)
486 guint8 data[4] = {0x03, 0x02, 0x25, 0x18};
487 bluetooth_advertising_data_t adv;
489 BT_DBG("%x %x %x %x", data[0], data[1], data[2], data[3]);
490 memcpy(adv.data, data, sizeof(data));
491 ret = bluetooth_set_advertising_data(adv_handle, &adv, sizeof(data));
492 if (ret != BLUETOOTH_ERROR_NONE) {
493 BT_ERR("Failed to set ADV data %d", ret);
497 ret = bluetooth_set_advertising(adv_handle, TRUE);
498 if (ret != BLUETOOTH_ERROR_NONE) {
499 BT_ERR("Failed to set ADV %d", ret);
506 void _bt_otp_start_write_on_fd()
508 char buf[BT_L2CAP_BUFFER_LEN];
513 char file_path[BT_FILE_PATH_MAX_LEN] = {0, };
515 char err_msg[256] = {0, };
517 snprintf(file_path, BT_FILE_PATH_MAX_LEN, "%s%s",
518 directory, selected_object->name);
519 BT_DBG("file_path = [%s]", file_path);
521 fp = fopen(file_path, "r");
523 cynara_strerror(errno, err_msg, sizeof(err_msg));
524 BT_ERR("fopen() failed : %s", err_msg);
528 BT_DBG("length [%d]", oacp_op->length);
529 length = oacp_op->length;
532 if (length < BT_L2CAP_BUFFER_LEN)
535 len = BT_L2CAP_BUFFER_LEN;
537 read = fread(buf, 1, len, fp);
538 written = write(oacp_op->fd, buf, len);
545 BT_DBG("read [%d], written [%d], rem_len [%d]",
546 read, written, length);
553 static bool __bt_otc_connection_timeout_cb(gpointer user_data)
555 int err = BLUETOOTH_ERROR_NONE;
556 char *remote_addr = oacp_op->remote_address;
558 err = _bt_otp_open_otc_and_listen(remote_addr, "DisconnectOtc");
559 if (err != BLUETOOTH_ERROR_NONE)
560 BT_ERR("Disconnect OTC failed");
565 static gboolean __server_data_received_cb(GIOChannel *chan, GIOCondition cond,
568 char *remote_addr = oacp_op->remote_address;
569 GIOStatus status = G_IO_STATUS_NORMAL;
575 char err_msg[256] = {0, };
579 fd = g_io_channel_unix_get_fd(chan);
580 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
581 otc_connection_status = FALSE;
582 BT_ERR("OTC disconnected: %d", fd);
584 g_source_remove(server_watch_id);
588 buffer = g_malloc0(BT_L2CAP_BUFFER_LEN + 1);
590 status = g_io_channel_read_chars(chan, buffer,
593 if (status != G_IO_STATUS_NORMAL) {
594 BT_ERR("IO Channel read is failed with %d", status);
598 otc_connection_status = FALSE;
599 BT_ERR("IO Channel read error [%s]", err->message);
600 if (status == G_IO_STATUS_ERROR) {
601 BT_ERR("cond : %d", cond);
604 g_source_remove(server_watch_id);
612 BT_DBG("Received data length %zu, remote_addr = %s", len, remote_addr);
615 char file_path[BT_FILE_PATH_MAX_LEN] = {0, };
618 if (!selected_object) {
619 BT_DBG("Object not selected");
623 snprintf(file_path, BT_FILE_PATH_MAX_LEN, "%s%s",
624 directory, selected_object->name);
626 BT_DBG("file_path = [%s]", file_path);
627 fp = fopen(file_path, "w");
629 cynara_strerror(errno, err_msg, sizeof(err_msg));
630 BT_ERR("fopen() failed : %s", err_msg);
636 if (oacp_op->length_sofar <= oacp_op->length) {
637 written = fwrite(buffer, 1, len, oacp_op->fp);
638 oacp_op->length_sofar += written;
639 BT_DBG("written [%d], length_sofar [%u], received_buff_len [%zu], size [%u]",
640 written, oacp_op->length_sofar, len, oacp_op->length);
643 if (timeout_id > 0) {
644 g_source_remove(timeout_id);
645 timeout_id = g_timeout_add(BT_OACP_MAX_TIMEOUT,
646 (GSourceFunc)__bt_otc_connection_timeout_cb, NULL);
653 static void _bt_otp_start_read_on_fd()
656 data_io = g_io_channel_unix_new(oacp_op->fd);
658 g_io_channel_set_encoding(data_io, NULL, NULL);
659 g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
661 server_watch_id = g_io_add_watch(data_io,
662 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
663 __server_data_received_cb, NULL);
666 g_source_remove(timeout_id);
668 timeout_id = g_timeout_add(BT_OACP_MAX_TIMEOUT,
669 (GSourceFunc)__bt_otc_connection_timeout_cb, NULL);
672 static void _bt_otp_method(GDBusConnection *connection,
674 const gchar *object_path,
675 const gchar *interface_name,
676 const gchar *method_name,
677 GVariant *parameters,
678 GDBusMethodInvocation *invocation,
682 int status = BLUETOOTH_ERROR_NONE;
684 BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]",
685 method_name, object_path, interface_name);
687 if (g_strcmp0(method_name, "enable") == 0) {
689 GError *error = NULL;
690 const gchar *filename = NULL;
691 char absolute_path[BT_FILE_PATH_MAX_LEN];
692 GSList *list = NULL, *l = NULL;
694 struct object_metadata *object = NULL;
696 g_variant_get(parameters, "(s)", &directory);
697 BT_DBG("Directory = [%s]", directory);
699 dir = g_dir_open(directory, 0, &error);
701 BT_ERR("Failed to open directory: %s", error->message);
703 status = BLUETOOTH_ERROR_INVALID_DIRECTORY;
707 while ((filename = g_dir_read_name(dir)))
708 list = g_slist_append(list, (gpointer) filename);
713 BT_DBG("No object found in given directory");
714 status = BLUETOOTH_ERROR_NO_OBJECTS_FOUND;
718 if (g_slist_length(list) > 1)
719 mutiple_obj_support = true;
721 for (l = list; l != NULL; l = l->next) {
722 if (!l->data) continue;
723 snprintf(absolute_path, BT_FILE_PATH_MAX_LEN, "%s%s", directory,
726 BT_INFO("filename: %s, absoulte_path: %s",
727 (char *)l->data, absolute_path);
729 if (stat(absolute_path, &st) == -1) {
730 BT_INFO("stat failed: (%d)\n", errno);
734 object = g_new0(struct object_metadata, 1);
736 object->name = g_strdup((const gchar *)l->data);
737 object->type = g_strdup(UNSUPPORTED_OBJECT_TYPE_UUID);
738 object->first_created = st.st_ctime;
739 object->last_modified = st.st_ctime;
740 object->curr_size = (uint32_t) st.st_size;
741 object->alloc_size = (uint32_t) st.st_size;
742 object->id = object_id;
743 object->props = OBJECT_READ | OBJECT_WRITE |
744 OBJECT_EXECUTE | OBJECT_DELETE;
746 otp_object_list = g_slist_append(otp_object_list,
753 if (_bt_otp_prepare_ots() != BLUETOOTH_ERROR_NONE) {
754 BT_ERR("Fail to prepare OTP Proxy");
755 status = BLUETOOTH_ERROR_INTERNAL;
759 /* If single object is supported, make that as
760 * selected object and update the metadata for the same.
762 if (!mutiple_obj_support) {
763 BT_INFO("Server supports single object");
764 selected_object = (struct object_metadata *) g_slist_nth_data(otp_object_list, 0);
766 update_obj_metadata_charc_value(selected_object);
769 BT_DBG("advertsing");
770 if (_bt_otp_set_advertising_data() != BLUETOOTH_ERROR_NONE) {
771 BT_ERR("Fail to set advertising data");
772 status = BLUETOOTH_ERROR_INTERNAL;
776 g_dbus_method_invocation_return_value(invocation,
777 g_variant_new("(i)", status));
779 } else if (g_strcmp0(method_name, "disable") == 0) {
780 g_dbus_method_invocation_return_value(invocation,
781 g_variant_new("(i)", status));
784 } else if (g_strcmp0(method_name, "NewConnection") == 0) {
787 GUnixFDList *fd_list;
789 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
792 g_variant_get(parameters, "(oh)", &dev_path, &index);
794 msg = g_dbus_method_invocation_get_message(invocation);
795 fd_list = g_dbus_message_get_unix_fd_list(msg);
796 if (fd_list == NULL) {
797 BT_ERR("fd_list is NULL");
801 fd = g_unix_fd_list_get(fd_list, index, NULL);
803 BT_ERR("Invalid fd return");
807 _bt_convert_device_path_to_address(dev_path, address);
809 BT_INFO("OTC Connected fd: %d, address %s", fd, address);
810 otc_connection_status = TRUE;
814 if (oacp_op->opcode == OACP_READ)
815 _bt_otp_start_write_on_fd();
816 else if (oacp_op->opcode == OACP_WRITE)
817 _bt_otp_start_read_on_fd();
819 /* Close fd if oacp_op is NULL */
822 g_dbus_method_invocation_return_value(invocation, NULL);
827 static const GDBusInterfaceVTable otp_method_table = {
833 static void _bt_otp_on_bus_acquired(GDBusConnection *connection,
834 const gchar *name, gpointer user_data)
837 GError *error = NULL;
843 object_id = g_dbus_connection_register_object(connection,
845 otp_node_info->interfaces[0],
848 if (object_id == 0) {
849 BT_ERR("Failed to register method table: %s", error->message);
851 g_dbus_node_info_unref(otp_node_info);
857 static void _bt_otp_on_name_acquired(GDBusConnection *connection,
864 static void _bt_otp_on_name_lost(GDBusConnection *connection,
869 g_object_unref(g_conn);
871 g_dbus_node_info_unref(otp_node_info);
872 g_bus_unown_name(g_owner_id);
875 int _bt_otp_register_interface(void)
878 GError *error = NULL;
881 otp_node_info = g_dbus_node_info_new_for_xml(otp_introspection_xml, &error);
882 if (!otp_node_info) {
883 BT_ERR("Failed to install: %s", error->message);
884 return BLUETOOTH_ERROR_INTERNAL;
887 owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
889 G_BUS_NAME_OWNER_FLAGS_NONE,
890 _bt_otp_on_bus_acquired,
891 _bt_otp_on_name_acquired,
892 _bt_otp_on_name_lost,
894 g_owner_id = owner_id;
895 BT_DBG("owner_id is [%d]\n", owner_id);
898 return BLUETOOTH_ERROR_NONE;
901 void _bt_otp_unregister_interface(void)
905 g_object_unref(g_conn);
907 g_dbus_node_info_unref(otp_node_info);
908 g_bus_unown_name(g_owner_id);
914 void _bt_convert_device_path_to_address(const char *device_path,
915 char *device_address)
917 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
920 dev_addr = strstr(device_path, "dev_");
921 if (dev_addr != NULL) {
924 g_strlcpy(address, dev_addr, sizeof(address));
926 while ((pos = strchr(address, '_')) != NULL)
929 g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
933 static char *__bt_extract_device_path(GVariantIter *iter, char *address)
935 char *object_path = NULL;
936 char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
938 /* Parse the signature: oa{sa{sv}}} */
939 while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
942 BT_ERR("Unable to get object path");
945 _bt_convert_device_path_to_address(object_path, device_address);
946 if (g_strcmp0(address, device_address) == 0)
947 return g_strdup(object_path);
951 BT_ERR("Unable to get object path");
955 char *_bt_otp_get_device_object_path(char *address)
958 GDBusProxy *proxy = NULL;
959 GVariant *result = NULL;
960 GVariantIter *iter = NULL;
961 char *object_path = NULL;
963 proxy = g_dbus_proxy_new_sync(conn,
964 G_DBUS_PROXY_FLAGS_NONE, NULL,
967 BT_MANAGER_INTERFACE,
971 BT_ERR("Unable to create proxy: %s", err->message);
975 result = g_dbus_proxy_call_sync(proxy, "GetManagedObjects", NULL,
976 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
979 BT_ERR("Fail to get GetManagedObjects (Error: %s)", err->message);
981 BT_ERR("Fail to get GetManagedObjects");
986 g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
987 object_path = __bt_extract_device_path(iter, address);
989 g_variant_unref(result);
990 g_variant_iter_free(iter);
997 g_object_unref(proxy);
1002 int _bt_otp_open_otc_and_listen(char *address, char *method)
1005 GDBusProxy *device_proxy = NULL;
1006 GVariant *result = NULL;
1007 GError *error = NULL;
1008 int ret = BLUETOOTH_ERROR_NONE;
1011 return BLUETOOTH_ERROR_INTERNAL;
1013 if (g_strcmp0(method, "ListenOtc") &&
1014 g_strcmp0(method, "DisconnectOtc"))
1015 return BLUETOOTH_ERROR_INTERNAL;
1017 object_path = _bt_otp_get_device_object_path(address);
1018 if (object_path == NULL) {
1019 ret = BLUETOOTH_ERROR_NOT_PAIRED;
1023 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1024 NULL, BT_BLUEZ_NAME, object_path,
1025 BT_DEVICE_INTERFACE, NULL, NULL);
1026 if (device_proxy == NULL) {
1027 ret = BLUETOOTH_ERROR_INTERNAL;
1032 result = g_dbus_proxy_call_sync(device_proxy, method,
1034 G_DBUS_CALL_FLAGS_NONE,
1038 if (result == NULL) {
1039 if (error != NULL) {
1040 BT_ERR("Error occured in Proxy call [%s]\n", error->message);
1041 g_error_free(error);
1043 ret = BLUETOOTH_ERROR_INTERNAL;
1047 g_free(object_path);
1049 g_variant_unref(result);
1051 g_object_unref(device_proxy);
1055 static bool __bt_oacp_create_timeout_cb(gpointer user_data)
1057 /* Delete the EMPTY object */
1059 _bt_otp_restore_old_object();
1063 static void _bt_otp_free_oacp_op()
1065 if (timeout_id > 0) {
1066 g_source_remove(timeout_id);
1071 g_free(oacp_op->remote_address);
1073 fclose(oacp_op->fp);
1079 int _bt_otp_send_launch_request(char *absolute_path)
1083 int ret = BLUETOOTH_ERROR_NONE;
1085 /* check ARCH 64 or 32*/
1086 if (!access(FILEPATH_ARCH_64, 0)) {
1087 BT_INFO("plugin loading for ARCH 64");
1088 handle = dlopen(HEADED_PLUGIN_FILEPATH64, RTLD_NOW);
1090 BT_INFO("plugin loading for ARCH 32");
1091 handle = dlopen(HEADED_PLUGIN_FILEPATH, RTLD_NOW);
1095 BT_ERR("Can not load plugin %s", dlerror());
1096 return BLUETOOTH_ERROR_INTERNAL;
1099 dlerror(); /* Clear any existing error */
1101 int (*fun)(char *) = (int (*)(char *))dlsym(handle,
1102 "bt_app_control_send_launch_request");
1104 if ((error = dlerror()) != NULL) {
1105 BT_ERR("Can not load symbol : %s", dlerror());
1107 return BLUETOOTH_ERROR_INTERNAL;
1111 ret = fun(absolute_path);
1117 char *_bt_otp_uuid_convert_hex_to_string(char *value, uint32_t length)
1121 unsigned short data1;
1122 unsigned short data2;
1123 unsigned short data3;
1125 unsigned short data5;
1128 uuid = (char *) g_malloc0(2 * length * sizeof(char));
1133 memcpy(&data1, &value[0], 2);
1134 snprintf(uuid, n, "%.4x", ntohs(data1));
1137 memcpy(&data0, &value[0], 4);
1138 snprintf(uuid, n, "%.8x", ntohl(data0));
1141 memcpy(&data0, &value[0], 4);
1142 memcpy(&data1, &value[4], 2);
1143 memcpy(&data2, &value[6], 2);
1144 memcpy(&data3, &value[8], 2);
1145 memcpy(&data4, &value[10], 4);
1146 memcpy(&data5, &value[14], 2);
1148 snprintf(uuid, n + 4, "%.8x-%.4x-%.4x-%.4x-%.8x%.4x",
1149 ntohl(data0), ntohs(data1),
1150 ntohs(data2), ntohs(data3),
1151 ntohl(data4), ntohs(data5));
1161 void _bt_otp_create_new_object(uint32_t size, char *uuid)
1163 struct object_metadata *object = NULL;
1165 /* Store current object id.
1166 * Incase of OACP Create fail, need to restore
1169 prev_obj_id = selected_object->id;
1171 object = g_new0(struct object_metadata, 1);
1173 object->name = NULL;
1174 object->type = g_strdup(uuid);
1175 object->first_created = 0;
1176 object->last_modified = 0;
1177 object->curr_size = 0;
1178 object->alloc_size = size;
1179 object->id = object_id;
1180 object->props = OBJECT_READ | OBJECT_WRITE |
1181 OBJECT_EXECUTE | OBJECT_DELETE;
1183 otp_object_list = g_slist_append(otp_object_list,
1186 update_obj_metadata_charc_value(object);
1187 selected_object = object;
1188 curr_obj_index = g_slist_length(otp_object_list) - 1;
1189 curr_obj_id = selected_object->id;
1193 void _bt_otp_restore_old_object()
1195 struct object_metadata *object = NULL;
1198 object = _bt_otp_client_find_object(otp_object_list, curr_obj_id, &index);
1202 otp_object_list = g_slist_remove(otp_object_list, object);
1205 object = _bt_otp_client_find_object(otp_object_list, prev_obj_id, &index);
1207 BT_ERR("Object is NULL");
1210 oacp_create = FALSE;
1211 update_obj_metadata_charc_value(object);
1212 selected_object = object;
1213 curr_obj_index = index;
1217 int _bt_otp_oacp_write_cb(char *value, int len, int offset,
1218 char *remote_addr, struct indicate_info *info)
1220 int ret = OACP_SUCCESS;
1221 int err = BLUETOOTH_ERROR_NONE;
1222 int opcode = value[0];
1223 uint32_t object_offset, length, object_size;
1226 char absolute_file_path[BT_FILE_PATH_MAX_LEN] = {0, };
1228 BT_INFO("OACP Opcode 0x%d", opcode);
1230 if (!selected_object) {
1231 BT_DBG("Object not selected");
1232 ret = OACP_INVALID_OBJ;
1238 BT_INFO("OACP_CREATE");
1240 BT_DBG("Error: invalid param");
1241 ret = OACP_INVALID_PARAM;
1244 /* UUIDs can be 2/4/16 bytes long.
1245 * So based on remaining len, determine uuid len.
1249 uuid = _bt_otp_uuid_convert_hex_to_string(value + 1, length);
1250 object_size = (uint32_t)(value[length + 4] & 0xFF) << 24 |
1251 (uint32_t)(value[length + 3] & 0xFF) << 16 |
1252 (uint32_t)(value[length + 2] & 0xFF) << 8 |
1253 (uint32_t)(value[length + 1] & 0xFF);
1255 BT_INFO("Size = %u, UUID = %s", object_size, uuid);
1258 _bt_otp_create_new_object(object_size, uuid);
1261 if (oacp_create_timeout_id > 0)
1262 g_source_remove(oacp_create_timeout_id);
1263 oacp_create_timeout_id = g_timeout_add(BT_OACP_MAX_TIMEOUT,
1264 (GSourceFunc)__bt_oacp_create_timeout_cb, NULL);
1267 if (!(selected_object->props & OBJECT_DELETE)) {
1268 ret = OACP_PROCEDURE_NOT_SUPPORTED;
1271 snprintf(absolute_file_path, BT_FILE_PATH_MAX_LEN,
1272 "%s%s", directory, selected_object->name);
1274 BT_DBG("absolute_file_path = [%s]", absolute_file_path);
1276 if (remove(absolute_file_path) != 0) {
1277 BT_DBG("Error: unable to delete the file");
1278 ret = OACP_OPERATION_FAILED;
1282 BT_DBG("File deleted successfully");
1283 selected_object = NULL;
1285 case OACP_CALC_CHECKSUM:
1286 ret = OACP_OPCODE_NOT_SUPPORTED;
1289 if (!(selected_object->props & OBJECT_EXECUTE)) {
1290 ret = OACP_PROCEDURE_NOT_SUPPORTED;
1293 snprintf(absolute_file_path, BT_FILE_PATH_MAX_LEN,
1294 "file://%s%s", directory, selected_object->name);
1296 BT_DBG("absolute_file_path = [%s]", absolute_file_path);
1298 err = _bt_otp_send_launch_request(absolute_file_path);
1299 if (err != BLUETOOTH_ERROR_NONE) {
1300 BT_DBG("Error: unable to launch the file");
1301 ret = OACP_OPERATION_FAILED;
1305 BT_DBG("Successfully launched the file");
1309 if (opcode == OACP_WRITE &&
1310 !(selected_object->props & OBJECT_WRITE)) {
1311 ret = OACP_PROCEDURE_NOT_SUPPORTED;
1315 if (opcode == OACP_READ &&
1316 !(selected_object->props & OBJECT_READ)) {
1317 ret = OACP_PROCEDURE_NOT_SUPPORTED;
1321 object_offset = (uint32_t)(value[4] & 0xFF) << 24 |
1322 (uint32_t)(value[3] & 0xFF) << 16 |
1323 (uint32_t)(value[2] & 0xFF) << 8 |
1324 (uint32_t)(value[1] & 0xFF);
1325 length = (uint32_t)(value[8] & 0xFF) << 24 |
1326 (uint32_t)(value[7] & 0xFF) << 16 |
1327 (uint32_t)(value[6] & 0xFF) << 8 |
1328 (uint32_t)(value[5] & 0xFF);
1330 if (opcode == OACP_WRITE)
1331 mode = (uint8_t)value[9] & 0xFF;
1333 BT_INFO("Offset = %u, Length = %u", object_offset, length);
1336 if (otc_connection_status) {
1337 /* Read/Write operation already going on. */
1338 ret = OACP_OBJECT_LOCKED;
1341 _bt_otp_free_oacp_op();
1344 oacp_op = g_malloc0(sizeof(struct oacp_operation));
1345 oacp_op->offset = object_offset;
1346 oacp_op->length = length;
1347 oacp_op->remote_address = g_strdup(remote_addr);
1348 oacp_op->mode = mode;
1349 oacp_op->opcode = opcode;
1350 oacp_op->length_sofar = 0;
1353 err = _bt_otp_open_otc_and_listen(remote_addr, "ListenOtc");
1354 if (err != BLUETOOTH_ERROR_NONE) {
1355 ret = OACP_CHANNEL_UNAVAILABLE;
1356 _bt_otp_free_oacp_op();
1361 ret = OACP_OPCODE_NOT_SUPPORTED;
1364 ret = OACP_OPCODE_NOT_SUPPORTED;
1368 info->resp_opcode = OACP_RESPONSE;
1369 info->req_opcode = opcode;
1370 info->result_code = ret;
1371 info->resp_param = NULL;
1372 return BLUETOOTH_ERROR_NONE;
1375 int _bt_otp_uuid_convert_string_to_hex(char *uuid, char *value)
1378 uint32_t data0, data4;
1379 uint16_t data1, data2, data3, data5;
1382 BT_ERR("Object Type UUID NULL");
1391 sscanf(uuid, "%04hx", &data1);
1392 data1 = htons(data1);
1393 memcpy(value, &data1, 2);
1399 sscanf(uuid, "%08x", &data0);
1400 data0 = htonl(data0);
1401 memcpy(value, &data0, 4);
1407 sscanf(uuid, "%08x-%04hx-%04hx-%04hx-%08x%04hx",
1408 &data0, &data1, &data2,
1409 &data3, &data4, &data5);
1411 data0 = htonl(data0);
1412 data1 = htons(data1);
1413 data2 = htons(data2);
1414 data3 = htons(data3);
1415 data4 = htonl(data4);
1416 data5 = htons(data5);
1418 memcpy(value, &data0, 4);
1419 memcpy(value+4, &data1, 2);
1420 memcpy(value+6, &data2, 2);
1421 memcpy(value+8, &data3, 2);
1422 memcpy(value+10, &data4, 4);
1423 memcpy(value+14, &data5, 2);
1434 void convert_to_hex(struct object_metadata *object, char *metadata, char *value)
1438 BT_DBG("Metadata : %s", metadata);
1440 memset(value, 0, 16);
1442 if (!g_strcmp0(metadata, "size")) {
1444 value[3] = (object->curr_size >> 24) & 0xFF;
1445 value[2] = (object->curr_size >> 16) & 0xFF;
1446 value[1] = (object->curr_size >> 8) & 0xFF;
1447 value[0] = object->curr_size & 0xFF;
1449 value[7] = (object->alloc_size >> 24) & 0xFF;
1450 value[6] = (object->alloc_size >> 16) & 0xFF;
1451 value[5] = (object->alloc_size >> 8) & 0xFF;
1452 value[4] = object->alloc_size & 0xFF;
1454 } else if (!g_strcmp0(metadata, "date")) {
1456 if (object->first_created) {
1457 localtime_r(&(object->first_created), &fc_tm);
1459 value[1] = ((fc_tm.tm_year+1900) >> 8) & 0xFF;
1460 value[0] = (fc_tm.tm_year+1900) & 0xFF;
1461 value[2] = (fc_tm.tm_mon+1) & 0xFF;
1462 value[3] = fc_tm.tm_mday & 0xFF;
1463 value[4] = fc_tm.tm_hour & 0xFF;
1464 value[5] = fc_tm.tm_min & 0xFF;
1465 value[6] = fc_tm.tm_sec & 0xFF;
1468 } else if (!g_strcmp0(metadata, "id")) {
1470 value[5] = (object->id >> 48) & 0xFF;
1471 value[4] = (object->id >> 32) & 0xFF;
1472 value[3] = (object->id >> 24) & 0xFF;
1473 value[2] = (object->id >> 16) & 0xFF;
1474 value[1] = (object->id >> 8) & 0xFF;
1475 value[0] = object->id & 0xFF;
1477 } else if (!g_strcmp0(metadata, "props")) {
1478 value[3] = (object->props >> 24) & 0xFF;
1479 value[2] = (object->props >> 16) & 0xFF;
1480 value[1] = (object->props >> 8) & 0xFF;
1481 value[0] = object->props & 0xFF;
1485 void update_obj_metadata_charc_value(struct object_metadata *object)
1487 /* Value can be of maximum 16 bytes */
1492 _bt_otp_set_char_value(otp_object_name_obj_path, object->name,
1493 strlen(object->name));
1496 uuid_len = _bt_otp_uuid_convert_string_to_hex(object->type, value);
1497 _bt_otp_set_char_value(otp_object_type_obj_path, value, uuid_len);
1499 convert_to_hex(object, "size", value);
1500 _bt_otp_set_char_value(otp_object_size_obj_path, value, 8);
1502 convert_to_hex(object, "date", value);
1503 _bt_otp_set_char_value(otp_object_first_created_obj_path, value, 7);
1504 _bt_otp_set_char_value(otp_object_last_modified_obj_path, value, 7);
1506 /* Object ID is optonal for single object server */
1507 if (mutiple_obj_support) {
1508 convert_to_hex(object, "id", value);
1509 _bt_otp_set_char_value(otp_object_id_obj_path, value, 6);
1512 convert_to_hex(object, "props", value);
1513 _bt_otp_set_char_value(otp_object_prop_obj_path, value, 4);
1516 struct object_metadata *_bt_otp_client_find_object(GSList *list, uint64_t id, guint *index)
1519 struct object_metadata *info;
1521 for (l = list; l; l = g_slist_next(l)) {
1525 if (info && (info->id == id))
1531 int _bt_otp_olcp_write_cb(char *value, int len, int offset,
1532 struct indicate_info *info)
1534 int ret = OLCP_SUCCESS;
1535 int opcode = value[0];
1536 struct object_metadata *object;
1540 BT_INFO("OLCP Opcode 0x%d", opcode);
1542 if (!otp_object_list) {
1549 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, 0);
1551 ret = OLCP_OUT_OF_BOUNDS;
1554 update_obj_metadata_charc_value(object);
1555 selected_object = object;
1559 len = g_slist_length(otp_object_list);
1560 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, len-1);
1562 ret = OLCP_OUT_OF_BOUNDS;
1565 update_obj_metadata_charc_value(object);
1566 selected_object = object;
1567 curr_obj_index = len-1;
1570 if (curr_obj_index == 0) {
1571 ret = OLCP_OUT_OF_BOUNDS;
1574 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, curr_obj_index-1);
1576 ret = OLCP_OUT_OF_BOUNDS;
1579 update_obj_metadata_charc_value(object);
1580 selected_object = object;
1581 curr_obj_index -= 1;
1584 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, curr_obj_index+1);
1586 ret = OLCP_OUT_OF_BOUNDS;
1589 update_obj_metadata_charc_value(object);
1590 selected_object = object;
1591 curr_obj_index += 1;
1594 object_id = (uint64_t)(value[6] & 0xFF) << 40 |
1595 (uint64_t)(value[5] & 0xFF) << 32 |
1596 (uint64_t)(value[4] & 0xFF) << 24 |
1597 (uint64_t)(value[3] & 0xFF) << 16 |
1598 (uint64_t)(value[2] & 0xFF) << 8 |
1599 (uint64_t)(value[1] & 0xFF);
1600 BT_INFO("Object ID [%llu]", (unsigned long long int)object_id);
1601 if (selected_object && selected_object->id == object_id)
1604 object = _bt_otp_client_find_object(otp_object_list, object_id, &index);
1606 ret = OLCP_OJECT_ID_NOT_FOUND;
1609 update_obj_metadata_charc_value(object);
1610 selected_object = object;
1611 curr_obj_index = index - 1;
1614 case OLCP_REQ_NO_OBJ:
1615 case OLCP_CLEAR_MARKING:
1617 ret = OLCP_OPCODE_NOT_SUPPORTED;
1621 info->resp_opcode = OLCP_RESPONSE;
1622 info->req_opcode = opcode;
1623 info->result_code = ret;
1624 info->resp_param = NULL;
1625 return BLUETOOTH_ERROR_NONE;
1628 int _bt_otp_obj_name_write_cb(char *value, int len)
1630 struct object_metadata *object;
1632 char new_abs_filepath[BT_FILE_PATH_MAX_LEN] = {0, };
1633 int ret = BLUETOOTH_ERROR_NONE;
1635 char err_msg[256] = {0, };
1637 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, curr_obj_index);
1639 return BLUETOOTH_OTP_ERROR_WRITE_REQUEST_REJECTED;
1641 filename = g_strndup(value, len);
1642 snprintf(new_abs_filepath, BT_FILE_PATH_MAX_LEN, "%s%s",
1643 directory, filename);
1644 BT_DBG("file_path = [%s]", new_abs_filepath);
1646 fp = fopen(new_abs_filepath, "r");
1647 /* fopen succeed means file already exists */
1649 ret = BLUETOOTH_OTP_ERROR_OBJECT_NAME_EXISTS;
1656 fp = fopen(new_abs_filepath, "a");
1658 cynara_strerror(errno, err_msg, sizeof(err_msg));
1659 BT_ERR("fopen() failed : %s", err_msg);
1660 ret = BLUETOOTH_ATT_ERROR_INTERNAL;
1664 if (stat(new_abs_filepath, &st) == -1) {
1665 BT_INFO("stat failed: (%d)\n", errno);
1666 ret = BLUETOOTH_ATT_ERROR_INTERNAL;
1670 object->name = g_strdup(filename);
1671 object->first_created = st.st_ctime;
1672 object->last_modified = st.st_ctime;
1673 object->curr_size = (uint32_t) st.st_size;
1674 oacp_create = FALSE;
1676 char old_abs_filepath[BT_FILE_PATH_MAX_LEN] = {0, };
1677 snprintf(old_abs_filepath, BT_FILE_PATH_MAX_LEN, "%s%s",
1678 directory, object->name);
1680 if (rename(old_abs_filepath, new_abs_filepath)) {
1681 ret = BLUETOOTH_ATT_ERROR_INTERNAL;
1686 memcpy(object->name, value, len);
1687 _bt_otp_set_char_value(otp_object_name_obj_path, value, len);
1691 _bt_otp_restore_old_object();
1693 if (oacp_create_timeout_id > 0)
1694 g_source_remove(oacp_create_timeout_id);
1703 int _bt_otp_obj_first_created_write_cb(char *value, int len)
1705 struct object_metadata *object;
1709 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, curr_obj_index);
1711 return BLUETOOTH_OTP_ERROR_WRITE_REQUEST_REJECTED;
1713 year = (uint16_t)(value[1] & 0xFF) << 8 |
1714 (uint16_t)(value[0] & 0xFF);
1715 tm.tm_year = year-1900;
1716 tm.tm_mon = value[2] & 0xFF;
1717 tm.tm_mon = tm.tm_mon-1;
1718 tm.tm_mday = value[3] & 0xFF;
1719 tm.tm_hour = value[4] & 0xFF;
1720 tm.tm_min = value[5] & 0xFF;
1721 tm.tm_sec = value[6] & 0xFF;
1723 object->first_created = mktime(&tm);
1724 _bt_otp_set_char_value(otp_object_first_created_obj_path, value, len);
1726 return BLUETOOTH_ERROR_NONE;
1729 int _bt_otp_obj_last_modified_write_cb(char *value, int len)
1731 struct object_metadata *object;
1735 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, curr_obj_index);
1737 return BLUETOOTH_OTP_ERROR_WRITE_REQUEST_REJECTED;
1739 year = (uint16_t)(value[1] & 0xFF) << 8 |
1740 (uint16_t)(value[0] & 0xFF);
1741 tm.tm_year = year-1900;
1742 tm.tm_mon = value[2] & 0xFF;
1743 tm.tm_mon = tm.tm_mon-1;
1744 tm.tm_mday = value[3] & 0xFF;
1745 tm.tm_hour = value[4] & 0xFF;
1746 tm.tm_min = value[5] & 0xFF;
1747 tm.tm_sec = value[6] & 0xFF;
1749 object->last_modified = mktime(&tm);
1750 _bt_otp_set_char_value(otp_object_last_modified_obj_path, value, len);
1752 return BLUETOOTH_ERROR_NONE;
1755 int _bt_otp_obj_props_write_cb(char *value, int len)
1757 struct object_metadata *object;
1760 /* Any attempt to write RFU bits is error */
1761 if (value[1] || value[2] || value[3])
1762 return BLUETOOTH_OTP_ERROR_WRITE_REQUEST_REJECTED;
1764 object = (struct object_metadata *) g_slist_nth_data(otp_object_list, curr_obj_index);
1766 return BLUETOOTH_OTP_ERROR_WRITE_REQUEST_REJECTED;
1768 props = (uint32_t)(value[3] & 0xFF) << 24 |
1769 (uint32_t)(value[2] & 0xFF) << 16 |
1770 (uint32_t)(value[1] & 0xFF) << 8 |
1771 (uint32_t)(value[0] & 0xFF);
1773 object->props = props;
1774 _bt_otp_set_char_value(otp_object_prop_obj_path, value, len);
1776 return BLUETOOTH_ERROR_NONE;
1779 static struct otp_char_info *otp_get_char_value(const char *path)
1783 for (tmp = otp_char_list; tmp != NULL; tmp = tmp->next) {
1785 struct otp_char_info *char_info = tmp->data;
1786 if (!g_strcmp0(char_info->char_path, path))
1794 int _bt_otp_read_cb(const char *obj_path, char **value, int *len, uint16_t offset)
1796 struct otp_char_info *info = NULL;
1799 BT_ERR("Wrong Obj path");
1800 return BLUETOOTH_ATT_ERROR_INTERNAL;
1803 if (g_strcmp0(obj_path, otp_feature_obj_path)) {
1804 if (!selected_object)
1805 return BLUETOOTH_OTP_ERROR_OBJECT_NOT_SELECTED;
1808 info = otp_get_char_value(obj_path);
1810 if (oacp_create && !g_strcmp0(obj_path, otp_object_name_obj_path)) {
1811 /* char_value is NULL, value_length is zero */
1814 return BLUETOOTH_ATT_ERROR_NONE;
1817 if (info->char_value == NULL || info->value_length == 0)
1818 return BLUETOOTH_ATT_ERROR_INTERNAL;
1820 if (offset > info->value_length)
1821 return BLUETOOTH_ATT_ERROR_INVALID_OFFSET;
1823 *len = info->value_length - offset;
1824 *value = (char *)malloc(sizeof(char)*(*len));
1826 return BLUETOOTH_ATT_ERROR_INTERNAL;
1828 memcpy(*value, info->char_value, *len);
1830 return BLUETOOTH_ATT_ERROR_NONE;
1832 return BLUETOOTH_ATT_ERROR_INTERNAL;
1836 static void _otp_convert_address_to_hex(bluetooth_device_address_t *addr_hex,
1837 const char *addr_str)
1840 unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = { 0, };
1842 if (addr_str == NULL || addr_str[0] == '\0')
1845 i = sscanf(addr_str, "%X:%X:%X:%X:%X:%X", &addr[0], &addr[1],
1846 &addr[2], &addr[3], &addr[4], &addr[5]);
1847 if (i != BLUETOOTH_ADDRESS_LENGTH)
1848 BT_ERR("Invalid format string - [%s]", addr_str);
1850 for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++)
1851 addr_hex->addr[i] = (unsigned char)addr[i];
1854 static void _bt_otp_send_indication(const char *obj_path,
1855 struct indicate_info *info,
1856 bluetooth_device_address_t *remote_address)
1858 int ret = BLUETOOTH_ERROR_NONE;
1859 char value[7] = {0x00};
1860 int length = OTP_INDICATION_LEN_WITHOUT_RESP;
1864 value[0] = info->resp_opcode & 0xFF;
1865 value[1] = info->req_opcode & 0xFF;
1866 value[2] = info->result_code & 0xFF;
1867 if (info->resp_param) {
1868 value[6] = info->resp_param[3] & 0xFF;
1869 value[5] = info->resp_param[4] & 0xFF;
1870 value[4] = info->resp_param[5] & 0xFF;
1871 value[3] = info->resp_param[6] & 0xFF;
1872 length = OTP_INDICATION_LEN_WITH_RESP;
1875 BT_DBG("Opcode: %d", value[1]);
1877 /* Store the status value */
1878 _bt_otp_set_char_value(obj_path, value, length);
1880 /* Send indication */
1881 ret = bluetooth_gatt_server_set_notification(obj_path, remote_address);
1882 if (ret != BLUETOOTH_ERROR_NONE) {
1883 BT_ERR("_bt_otp_send_control_point_indication failed");
1886 ret = bluetooth_gatt_update_characteristic(obj_path, value, length);
1887 if (ret != BLUETOOTH_ERROR_NONE) {
1888 BT_ERR("_bt_otp_send_control_point_indication failed");
1893 void _bt_otp_gatt_char_property_changed_event(GVariant *msg,
1896 int result = BLUETOOTH_ERROR_NONE;
1897 GVariantIter value_iter;
1898 const char *property = NULL;
1899 const char *char_path = NULL;
1900 const char *svc_handle = NULL;
1901 GVariant *var = NULL;
1902 GVariant *val = NULL;
1903 g_variant_iter_init(&value_iter, msg);
1905 while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &var))) {
1907 if (property == NULL) {
1908 BT_ERR("Property NULL");
1912 if (!g_strcmp0(property, "WriteValue")) {
1914 BT_INFO("WriteValue");
1915 BT_INFO("Type '%s'\n", g_variant_get_type_string(var));
1918 bluetooth_device_address_t addr_hex = { {0,} };
1923 struct indicate_info info;
1925 g_variant_get(var, "(&s&s&syq@ay)",
1926 &char_path, &svc_handle,
1927 &addr, &req_id, &offset, &val);
1929 len = g_variant_get_size(val);
1931 BT_DBG("Len = %d, BT_ADDR = %s", len, addr);
1933 value = (char *) g_variant_get_data(val);
1934 _otp_convert_address_to_hex(&addr_hex, addr);
1937 if (!g_strcmp0(char_path, otp_oacp_obj_path)) {
1939 result = BLUETOOTH_ATT_ERROR_CCCD_IMPROPERLY_CONFIGURED;
1941 result = _bt_otp_oacp_write_cb(value, len, offset, addr, &info);
1942 } else if (!g_strcmp0(char_path, otp_olcp_obj_path)) {
1944 result = BLUETOOTH_ATT_ERROR_CCCD_IMPROPERLY_CONFIGURED;
1946 result = _bt_otp_olcp_write_cb(value, len, offset, &info);
1947 } else if (!g_strcmp0(char_path, otp_object_name_obj_path)) {
1948 result = _bt_otp_obj_name_write_cb(value, len);
1949 } else if (!g_strcmp0(char_path, otp_object_first_created_obj_path)) {
1950 result = _bt_otp_obj_first_created_write_cb(value, len);
1951 } else if (!g_strcmp0(char_path, otp_object_last_modified_obj_path)) {
1952 result = _bt_otp_obj_last_modified_write_cb(value, len);
1953 } else if (!g_strcmp0(char_path, otp_object_prop_obj_path)) {
1954 result = _bt_otp_obj_props_write_cb(value, len);
1956 BT_ERR("Wrong Object Path %s", char_path);
1957 result = BLUETOOTH_ERROR_INTERNAL;
1959 bluetooth_gatt_send_response(req_id,
1960 BLUETOOTH_GATT_ATT_REQUEST_TYPE_WRITE,
1961 result, 0, NULL, 0);
1963 /* Send indication for CPs */
1964 if (!g_strcmp0(char_path, otp_oacp_obj_path)) {
1966 _bt_otp_send_indication(char_path, &info, &addr_hex);
1967 } else if (!g_strcmp0(char_path, otp_olcp_obj_path)) {
1969 _bt_otp_send_indication(char_path, &info, &addr_hex);
1972 BT_ERR("Array Len 0");
1975 BT_ERR("var==NULL");
1977 } else if (!g_strcmp0(property, "ReadValue")) {
1983 result = BLUETOOTH_ATT_ERROR_NONE;
1985 BT_INFO("ReadValue");
1986 BT_INFO("Type '%s'\n", g_variant_get_type_string(var));
1988 g_variant_get(var, "(&s&s&syq)", &char_path,
1989 &svc_handle, &addr, &req_id, &offset);
1991 result = _bt_otp_read_cb(char_path, &value, &len, offset);
1993 if (result != BLUETOOTH_ATT_ERROR_NONE) {
1994 BT_ERR("ReadValue failed %s", char_path);
1995 bluetooth_gatt_send_response(req_id,
1996 BLUETOOTH_GATT_ATT_REQUEST_TYPE_READ,
1997 result, offset, NULL, 0);
1999 bluetooth_gatt_send_response(req_id,
2000 BLUETOOTH_GATT_ATT_REQUEST_TYPE_READ,
2001 result, offset, value, len);
2005 } else if (!g_strcmp0(property, "NotificationStateChanged")) {
2006 gboolean indicate = FALSE;
2008 g_variant_get(var, "(&s&sb)", &char_path,
2009 &svc_handle, &indicate);
2011 BT_INFO("%s : [%s]", property,
2012 indicate ? "StartNotify" : "StopNotify");
2013 BT_INFO("Type '%s'\n", g_variant_get_type_string(var));
2015 if (!g_strcmp0(char_path, otp_oacp_obj_path))
2016 OACP_indicate = indicate;
2017 else if (!g_strcmp0(char_path, otp_olcp_obj_path))
2018 OLCP_indicate = indicate;
2024 void _bt_otp_property_event_filter(GDBusConnection *connection,
2025 const gchar *sender_name,
2026 const gchar *object_path,
2027 const gchar *interface_name,
2028 const gchar *signal_name,
2029 GVariant *parameters,
2034 if (signal_name == NULL) {
2035 BT_ERR("Wrong Signal");
2039 if (g_strcmp0(signal_name, PROPERTIES_CHANGED) == 0) {
2041 g_variant_get(parameters, "(@a{sv}@as)", &value, NULL);
2042 _bt_otp_gatt_char_property_changed_event(value, object_path);
2046 void _bt_otp_adapter_event_filter(GDBusConnection *connection,
2047 const gchar *sender_name,
2048 const gchar *object_path,
2049 const gchar *interface_name,
2050 const gchar *signal_name,
2051 GVariant *parameters,
2054 if (signal_name == NULL) {
2055 BT_ERR("Wrong Signal");
2059 BT_INFO("Interface %s, Signal %s", interface_name, signal_name);
2061 if (g_strcmp0(interface_name, BT_OTP_INTERFACE_NAME) == 0) {
2062 if (strcasecmp(signal_name, BLE_DISABLED) == 0)
2067 void _bt_otc_disconnected_cb(GDBusConnection *connection,
2068 const gchar *sender_name,
2069 const gchar *object_path,
2070 const gchar *interface_name,
2071 const gchar *signal_name,
2072 GVariant *parameters,
2075 if (signal_name == NULL) {
2076 BT_ERR("Wrong Signal");
2080 BT_INFO("Interface %s, Signal %s", interface_name, signal_name);
2082 if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
2083 if (strcasecmp(signal_name, OTC_DISCONNECTED) == 0) {
2084 BT_DBG("OTC Channel Disconnected dev_path[%s]",
2086 otc_connection_status = FALSE;
2087 _bt_otp_free_oacp_op();
2092 void _bt_otp_device_property_event_filter(GDBusConnection *connection,
2093 const gchar *sender_name,
2094 const gchar *object_path,
2095 const gchar *interface_name,
2096 const gchar *signal_name,
2097 GVariant *parameters,
2100 char *interfacename = NULL;
2101 GVariant *val = NULL;
2103 g_variant_get(parameters, "(&s@a{sv}@as)", &interfacename, &val, NULL);
2105 if (strcasecmp(interfacename, BT_DEVICE_INTERFACE) == 0) {
2106 GVariantIter value_iter;
2108 char *property = NULL;
2110 g_variant_iter_init(&value_iter, val);
2111 while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val1))) {
2112 if (strcasecmp(property, "GattConnected") == 0) {
2113 gboolean gatt_connected = FALSE;
2114 char *address = NULL;
2116 g_variant_get(val1, "b", &gatt_connected);
2118 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2120 _bt_convert_device_path_to_address(object_path, address);
2122 BT_DBG("gatt_connected: %d", gatt_connected);
2123 BT_DBG("address: %s", address);
2124 if (!gatt_connected) {
2126 _bt_otp_restore_old_object();
2128 if (oacp_create_timeout_id > 0)
2129 g_source_remove(oacp_create_timeout_id);
2137 int _bt_otp_init_event_receiver()
2140 GError *error = NULL;
2143 conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
2144 if (error != NULL) {
2145 BT_ERR("ERROR: Can't get on system bus [%s]",
2147 g_clear_error(&error);
2151 property_sub_id = g_dbus_connection_signal_subscribe(conn,
2153 BT_OTP_INTERFACE_NAME,
2155 BT_OTP_OBJECT_PATH, NULL, 0,
2156 _bt_otp_property_event_filter,
2159 adapter_sub_id = g_dbus_connection_signal_subscribe(conn,
2161 BT_OTP_INTERFACE_NAME,
2163 BT_OTP_OBJECT_PATH, NULL, 0,
2164 _bt_otp_adapter_event_filter,
2167 device_sub_id = g_dbus_connection_signal_subscribe(conn,
2168 NULL, BT_DEVICE_INTERFACE,
2169 OTC_DISCONNECTED, NULL, NULL, 0,
2170 _bt_otc_disconnected_cb,
2173 device_property_sub_id = g_dbus_connection_signal_subscribe(conn,
2174 NULL, BT_PROPERTIES_INTERFACE,
2175 PROPERTIES_CHANGED, NULL, NULL, 0,
2176 _bt_otp_device_property_event_filter,
2183 void _bt_otp_deinit_event_receiver(void)
2187 g_dbus_connection_signal_unsubscribe(conn, property_sub_id);
2188 g_dbus_connection_signal_unsubscribe(conn, adapter_sub_id);
2189 g_dbus_connection_signal_unsubscribe(conn, device_sub_id);
2190 g_dbus_connection_signal_unsubscribe(conn, device_property_sub_id);
2196 static void _bt_otp_sig_handler(int sig)
2201 BT_DBG("caught signal - sigterm\n");
2204 BT_DBG("caught signal - sigint\n");
2207 BT_DBG("caught signal - sigkill\n");
2210 BT_DBG("caught signal %d and ignored\n", sig);
2216 /* OTP Service Main loop */
2219 struct sigaction sa;
2220 BT_ERR("Starting the bt-otp daemon");
2222 memset(&sa, 0, sizeof(sa));
2223 sa.sa_handler = _bt_otp_sig_handler;
2224 sa.sa_flags = SA_SIGINFO;
2225 sigaction(SIGINT, &sa, NULL);
2226 sigaction(SIGTERM, &sa, NULL);
2227 sigaction(SIGKILL, &sa, NULL);
2229 if (_bt_otp_register_interface() != BLUETOOTH_ERROR_NONE) {
2230 BT_ERR("Fail to register otp service");
2234 if (_bt_otp_init_event_receiver() != BLUETOOTH_ERROR_NONE) {
2235 BT_ERR("Fail to init event reciever");
2239 main_loop = g_main_loop_new(NULL, FALSE);
2241 g_main_loop_run(main_loop);
2243 BT_DBG("g_main_loop_quit called!");
2245 if (main_loop != NULL)
2246 g_main_loop_unref(main_loop);