1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * BlueZ - Bluetooth protocol stack for Linux
6 * Copyright (C) 2006-2010 Nokia Corporation
7 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
22 #include <sys/ioctl.h>
28 #include <dbus/dbus.h>
30 #include "bluetooth/bluetooth.h"
31 #include "bluetooth/hci.h"
32 #include "bluetooth/hci_lib.h"
33 #include "bluetooth/sdp.h"
34 #include "bluetooth/sdp_lib.h"
38 #include "gdbus/gdbus.h"
43 #include "src/shared/mgmt.h"
44 #include "src/shared/util.h"
45 #include "src/shared/queue.h"
46 #include "src/shared/att.h"
47 #include "src/shared/gatt-db.h"
48 #include "src/shared/timeout.h"
50 #include "btio/btio.h"
56 #include "dbus-common.h"
58 #include "uuid-helper.h"
61 #include "attrib/gattrib.h"
62 #include "attrib/att.h"
63 #include "attrib/gatt.h"
64 #include "attrib-server.h"
65 #include "gatt-database.h"
66 #include "advertising.h"
67 #include "adv_monitor.h"
71 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
73 #include "adapter_le_vsc_features.h"
74 #include "../profile.h"
77 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
78 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
79 #define DEVICED_DEST "org.tizen.system.deviced"
80 #define DEVICED_BATT_INTERFACE "org.tizen.system.deviced.Battery"
81 #define DEVICED_BATT_OBJECT_PATH "/Org/Tizen/System/DeviceD/Battery"
82 #endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
86 #define MODE_CONNECTABLE 0x01
87 #define MODE_DISCOVERABLE 0x02
88 #define MODE_UNKNOWN 0xff
90 #define CONN_SCAN_TIMEOUT (3)
91 #define IDLE_DISCOV_TIMEOUT (5)
92 #define TEMP_DEV_TIMEOUT (3 * 60)
93 #define BONDING_TIMEOUT (2 * 60)
95 #define SCAN_TYPE_BREDR (1 << BDADDR_BREDR)
96 #define SCAN_TYPE_LE ((1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM))
97 #define SCAN_TYPE_DUAL (SCAN_TYPE_BREDR | SCAN_TYPE_LE)
98 #define SETTING_PRIVACY_MASK (1<<13)
100 #define HCI_RSSI_INVALID 127
101 #define DISTANCE_VAL_INVALID 0x7FFF
102 #define PATHLOSS_MAX 137
105 * These are known security keys that have been compromised.
106 * If this grows or there are needs to be platform specific, it is
107 * conceivable that these could be read from a config file.
109 static const struct mgmt_blocked_key_info blocked_keys[] = {
110 /* Google Titan Security Keys */
111 { HCI_BLOCKED_KEY_TYPE_LTK,
112 {0xbf, 0x01, 0xfb, 0x9d, 0x4e, 0xf3, 0xbc, 0x36,
113 0xd8, 0x74, 0xf5, 0x39, 0x41, 0x38, 0x68, 0x4c}},
114 { HCI_BLOCKED_KEY_TYPE_IRK,
115 {0xa5, 0x99, 0xba, 0xe4, 0xe1, 0x7c, 0xa6, 0x18,
116 0x22, 0x8e, 0x07, 0x56, 0xb4, 0xe8, 0x5f, 0x01}},
119 struct mgmt_exp_uuid {
124 /* d4992530-b9ec-469f-ab01-6c481c47da1c */
125 static const struct mgmt_exp_uuid debug_uuid = {
126 .val = { 0x1c, 0xda, 0x47, 0x1c, 0x48, 0x6c, 0x01, 0xab,
127 0x9f, 0x46, 0xec, 0xb9, 0x30, 0x25, 0x99, 0xd4 },
128 .str = "d4992530-b9ec-469f-ab01-6c481c47da1c"
131 /* 671b10b5-42c0-4696-9227-eb28d1b049d6 */
132 static const struct mgmt_exp_uuid le_simult_central_peripheral_uuid = {
133 .val = { 0xd6, 0x49, 0xb0, 0xd1, 0x28, 0xeb, 0x27, 0x92,
134 0x96, 0x46, 0xc0, 0x42, 0xb5, 0x10, 0x1b, 0x67 },
135 .str = "671b10b5-42c0-4696-9227-eb28d1b049d6"
138 /* 330859bc-7506-492d-9370-9a6f0614037f */
139 static const struct mgmt_exp_uuid quality_report_uuid = {
140 .val = { 0x7f, 0x03, 0x14, 0x06, 0x6f, 0x9a, 0x70, 0x93,
141 0x2d, 0x49, 0x06, 0x75, 0xbc, 0x59, 0x08, 0x33 },
142 .str = "330859bc-7506-492d-9370-9a6f0614037f"
145 /* 15c0a148-c273-11ea-b3de-0242ac130004 */
146 static const struct mgmt_exp_uuid rpa_resolution_uuid = {
147 .val = { 0x04, 0x00, 0x13, 0xac, 0x42, 0x02, 0xde, 0xb3,
148 0xea, 0x11, 0x73, 0xc2, 0x48, 0xa1, 0xc0, 0x15 },
149 .str = "15c0a148-c273-11ea-b3de-0242ac130004"
152 /* a6695ace-ee7f-4fb9-881a-5fac66c629af */
153 static const struct mgmt_exp_uuid codec_offload_uuid = {
154 .val = { 0xaf, 0x29, 0xc6, 0x66, 0xac, 0x5f, 0x1a, 0x88,
155 0xb9, 0x4f, 0x7f, 0xee, 0xce, 0x5a, 0x69, 0xa6 },
156 .str = "a6695ace-ee7f-4fb9-881a-5fac66c629af"
159 /* 6fbaf188-05e0-496a-9885-d6ddfdb4e03e */
160 static const struct mgmt_exp_uuid iso_socket_uuid = {
161 .val = { 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, 0x85, 0x98,
162 0x6a, 0x49, 0xe0, 0x05, 0x88, 0xf1, 0xba, 0x6f },
163 .str = "6fbaf188-05e0-496a-9885-d6ddfdb4e03e"
166 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
167 #define ADV_DATA_MAX_LENGTH 31
168 #define SCAN_RESPONSE_DATA_LENGTH_MAX 31
169 #define EIR_MANUFACTURER_DATA_LENGTH_MAX 100
171 #define LE_BEARER_POSTFIX " LE"
172 #define LE_BEARER_POSTFIX_LEN 3
173 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
176 static DBusConnection *dbus_conn = NULL;
178 static uint32_t kernel_features = 0;
180 static GList *adapter_list = NULL;
181 static unsigned int adapter_remaining = 0;
182 static bool powering_down = false;
184 static GSList *adapters = NULL;
186 static struct mgmt *mgmt_primary = NULL;
188 static uint8_t mgmt_version = 0;
189 static uint8_t mgmt_revision = 0;
191 static GSList *adapter_drivers = NULL;
193 static GSList *disconnect_list = NULL;
194 static GSList *conn_fail_list = NULL;
196 struct link_key_info {
198 unsigned char key[16];
204 struct smp_ltk_info {
207 uint8_t authenticated;
226 uint16_t min_interval;
227 uint16_t max_interval;
232 struct discovery_filter {
242 struct discovery_client {
243 struct btd_adapter *adapter;
247 struct discovery_filter *discovery_filter;
250 struct service_auth {
256 struct btd_device *device;
257 struct btd_adapter *adapter;
258 struct agent *agent; /* NULL for queued auths */
261 struct btd_adapter_pin_cb_iter {
262 GSList *it; /* current callback function */
263 unsigned int attempt; /* numer of times it() was called */
264 /* When the iterator reaches the end, it is NULL and attempt is 0 */
268 ADAPTER_POWER_STATE_OFF,
269 ADAPTER_POWER_STATE_ON,
270 ADAPTER_POWER_STATE_ON_DISABLING,
271 ADAPTER_POWER_STATE_OFF_ENABLING,
272 ADAPTER_POWER_STATE_OFF_BLOCKED,
275 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
277 int slot_id; /* Reservied slot id is 0 (Single adv) */
278 bool status; /* Advertising status */
281 static GSList *read_requests = NULL;
283 struct le_data_length_read_request {
284 struct btd_adapter *adapter;
288 struct le_batching_request {
289 struct btd_adapter *adapter;
293 struct le_batching_set_param_request {
294 struct btd_adapter *adapter;
306 bdaddr_t bdaddr; /* controller Bluetooth address */
307 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
308 bdaddr_t le_static_addr;
311 uint8_t bdaddr_type; /* address type */
312 uint32_t dev_class; /* controller class of device */
313 char *name; /* controller device name */
314 char *short_name; /* controller short name */
315 uint32_t supported_settings; /* controller supported settings */
316 uint32_t pending_settings; /* pending controller settings */
317 uint32_t power_state; /* the power state */
318 uint32_t current_settings; /* current controller settings */
320 char *path; /* adapter object path */
321 uint16_t manufacturer; /* adapter manufacturer */
322 uint8_t major_class; /* configured major class */
323 uint8_t minor_class; /* configured minor class */
324 char *system_name; /* configured system name */
325 char *modalias; /* device id (modalias) */
326 bool stored_discoverable; /* stored discoverable mode */
327 uint32_t discoverable_timeout; /* discoverable time(sec) */
328 uint32_t pairable_timeout; /* pairable time(sec) */
330 char *current_alias; /* current adapter name alias */
331 char *stored_alias; /* stored adapter name alias */
332 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
333 uint8_t *local_irk; /* adapter local IRK */
335 bool ipsp_intialized; /* Ipsp Initialization state */
336 struct le_data_length_read_handler *read_handler;
337 struct le_data_length_read_default_data_length_handler *def_read_handler;
338 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
339 guint charging_watch;
340 guint charging_timeout;
341 charging_state_e charging;
342 #endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
345 bool discovering; /* discovering property state */
346 bool filtered_discovery; /* we are doing filtered discovery */
347 bool no_scan_restart_delay; /* when this flag is set, restart scan
349 uint8_t discovery_type; /* current active discovery type */
350 uint8_t discovery_enable; /* discovery enabled/disabled */
351 bool discovery_suspended; /* discovery has been suspended */
352 bool discovery_discoverable; /* discoverable while discovering */
353 GSList *discovery_list; /* list of discovery clients */
354 GSList *set_filter_list; /* list of clients that specified
355 * filter, but don't scan yet
357 /* current discovery filter, if any */
358 struct mgmt_cp_start_service_discovery *current_discovery_filter;
360 struct discovery_client *client; /* active discovery client */
362 GSList *discovery_found; /* list of found devices */
363 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
364 guint le_discovery_idle_timeout; /* timeout between le discovery runs */
366 unsigned int discovery_idle_timeout; /* timeout between discovery
369 unsigned int passive_scan_timeout; /* timeout between passive scans */
371 unsigned int pairable_timeout_id; /* pairable timeout id */
372 guint auth_idle_id; /* Pending authorization dequeue */
373 GQueue *auths; /* Ongoing and pending auths */
374 bool pincode_requested; /* PIN requested during last bonding */
375 GSList *connections; /* Connected devices */
376 GSList *devices; /* Devices structure pointers */
377 GSList *connect_list; /* Devices to connect when found */
378 struct btd_device *connect_le; /* LE device waiting to be connected */
379 sdp_list_t *services; /* Services associated to adapter */
381 struct btd_gatt_database *database;
382 struct btd_adv_manager *adv_manager;
384 struct btd_adv_monitor_manager *adv_monitor_manager;
386 struct btd_battery_provider_manager *battery_provider_manager;
387 GHashTable *allowed_uuid_set; /* Set of allowed service UUIDs */
389 gboolean initialized;
390 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
391 GSList *adv_list; /* List of advertising instance */
392 bool advertising; /* Advertising active */
393 gchar *version; /* Bluetooth Version */
394 uint8_t adv_tx_power;
395 guint adv_restart_timeout;
396 bool le_discovering; /* LE Discovery active */
397 GSList *le_discovery_list; /* list of LE discovery clients */
400 GSList *pin_callbacks;
401 GSList *msd_callbacks;
406 struct oob_handler *oob_handler;
408 unsigned int db_id; /* Service event handler for GATT db */
409 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
410 uint8_t central_rpa_res_support;
411 bluetooth_a2dp_role_t a2dp_role;
412 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
413 bool scan_filter_support; /* platform's scan filtering support */
414 uint8_t scan_type; /* scan type */
415 GSList *scan_params; /* scan filter parameters */
416 GSList *addr_filters; /* adress scan filters list */
417 GSList *service_data_changed_filters; /* service data changed scan filters list */
418 GSList *service_uuid_filters; /* service uuid scan filters list */
419 GSList *solicit_data_filters; /* solicitation data scan filters list */
420 GSList *local_name_filters; /* local name scan filters list */
421 GSList *manufaturer_data_filters; /* manufacturer data scan filters list */
422 GSList *service_data_filters; /* service data scan filters list */
425 bool is_default; /* true if adapter is default one */
428 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
429 bool le_2m_phy_supported;
430 bool le_coded_phy_supported;
431 guint le_batching_available_pkts;
435 static char *adapter_power_state_str(uint32_t power_state)
437 switch (power_state) {
438 case ADAPTER_POWER_STATE_OFF:
440 case ADAPTER_POWER_STATE_ON:
442 case ADAPTER_POWER_STATE_ON_DISABLING:
443 return "on-disabling";
444 case ADAPTER_POWER_STATE_OFF_ENABLING:
445 return "off-enabling";
446 case ADAPTER_POWER_STATE_OFF_BLOCKED:
447 return "off-blocked";
449 DBG("Invalid power state %d", power_state);
454 ADAPTER_AUTHORIZE_DISCONNECTED = 0,
455 ADAPTER_AUTHORIZE_CHECK_CONNECTED
456 } adapter_authorize_type;
458 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
465 static struct btd_adapter *btd_adapter_lookup(uint16_t index)
469 for (list = g_list_first(adapter_list); list;
470 list = g_list_next(list)) {
471 struct btd_adapter *adapter = list->data;
473 if (adapter->dev_id == index)
480 struct btd_adapter *btd_adapter_get_default(void)
484 for (list = g_list_first(adapter_list); list;
485 list = g_list_next(list)) {
486 struct btd_adapter *adapter = list->data;
488 if (adapter->is_default)
495 bool btd_adapter_is_default(struct btd_adapter *adapter)
500 return adapter->is_default;
503 uint16_t btd_adapter_get_index(struct btd_adapter *adapter)
506 return MGMT_INDEX_NONE;
508 return adapter->dev_id;
511 static gboolean process_auth_queue(gpointer user_data);
513 static void dev_class_changed_callback(uint16_t index, uint16_t length,
514 const void *param, void *user_data)
516 struct btd_adapter *adapter = user_data;
517 const struct mgmt_cod *rp = param;
520 if (length < sizeof(*rp)) {
521 btd_error(adapter->dev_id,
522 "Wrong size of class of device changed parameters");
526 dev_class = rp->val[0] | (rp->val[1] << 8) | (rp->val[2] << 16);
528 if (dev_class == adapter->dev_class)
531 DBG("Class: 0x%06x", dev_class);
533 adapter->dev_class = dev_class;
535 g_dbus_emit_property_changed(dbus_conn, adapter->path,
536 ADAPTER_INTERFACE, "Class");
539 static void set_dev_class_complete(uint8_t status, uint16_t length,
540 const void *param, void *user_data)
542 struct btd_adapter *adapter = user_data;
544 if (status != MGMT_STATUS_SUCCESS) {
545 btd_error(adapter->dev_id,
546 "Failed to set device class: %s (0x%02x)",
547 mgmt_errstr(status), status);
552 * The parameters are identical and also the task that is
553 * required in both cases. So it is safe to just call the
554 * event handling functions here.
556 dev_class_changed_callback(adapter->dev_id, length, param, adapter);
559 static void set_dev_class(struct btd_adapter *adapter)
561 struct mgmt_cp_set_dev_class cp;
564 * If the controller does not support BR/EDR operation,
565 * there is no point in trying to set a major and minor
568 * This is an optimization for Low Energy only controllers.
570 if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
573 memset(&cp, 0, sizeof(cp));
576 * Silly workaround for a really stupid kernel bug :(
578 * All current kernel versions assign the major and minor numbers
579 * straight to dev_class[0] and dev_class[1] without considering
580 * the proper bit shifting.
582 * To make this work, shift the value in userspace for now until
583 * we get a fixed kernel version.
585 cp.major = adapter->major_class & 0x1f;
586 cp.minor = adapter->minor_class << 2;
588 DBG("sending set device class command for index %u", adapter->dev_id);
590 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_CLASS,
591 adapter->dev_id, sizeof(cp), &cp,
592 set_dev_class_complete, adapter, NULL) > 0)
595 btd_error(adapter->dev_id,
596 "Failed to set class of device for index %u", adapter->dev_id);
599 void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
602 if (adapter->major_class == major && adapter->minor_class == minor)
605 DBG("class: major %u minor %u", major, minor);
607 adapter->major_class = major;
608 adapter->minor_class = minor;
610 set_dev_class(adapter);
613 static uint8_t get_mode(const char *mode)
615 if (strcasecmp("off", mode) == 0)
617 else if (strcasecmp("connectable", mode) == 0)
618 return MODE_CONNECTABLE;
619 else if (strcasecmp("discoverable", mode) == 0)
620 return MODE_DISCOVERABLE;
625 const char *btd_adapter_get_storage_dir(struct btd_adapter *adapter)
629 if (adapter->bdaddr_type == BDADDR_LE_RANDOM) {
630 strcpy(dir, "static-");
631 ba2str(&adapter->bdaddr, dir + 7);
633 ba2str(&adapter->bdaddr, dir);
639 uint8_t btd_adapter_get_address_type(struct btd_adapter *adapter)
641 return adapter->bdaddr_type;
644 static void store_adapter_info(struct btd_adapter *adapter)
648 char filename[PATH_MAX];
651 gboolean discoverable;
653 key_file = g_key_file_new();
655 if (adapter->pairable_timeout != btd_opts.pairto)
656 g_key_file_set_integer(key_file, "General", "PairableTimeout",
657 adapter->pairable_timeout);
659 if ((adapter->current_settings & MGMT_SETTING_DISCOVERABLE) &&
660 !adapter->discoverable_timeout)
663 discoverable = FALSE;
665 g_key_file_set_boolean(key_file, "General", "Discoverable",
668 if (adapter->discoverable_timeout != btd_opts.discovto)
669 g_key_file_set_integer(key_file, "General",
670 "DiscoverableTimeout",
671 adapter->discoverable_timeout);
673 if (adapter->stored_alias)
674 g_key_file_set_string(key_file, "General", "Alias",
675 adapter->stored_alias);
676 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
677 /* Store A2DP Role */
678 if (adapter->a2dp_role == BLUETOOTH_A2DP_SINK_ROLE)
679 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "sink");
680 else if (adapter->a2dp_role == BLUETOOTH_A2DP_BOTH_ROLE)
681 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "both");
683 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "source");
686 create_filename(filename, PATH_MAX, "/%s/settings",
687 btd_adapter_get_storage_dir(adapter));
688 create_file(filename, 0600);
690 str = g_key_file_to_data(key_file, &length, NULL);
691 if (!g_file_set_contents(filename, str, length, &gerr)) {
692 error("Unable set contents for %s: (%s)", filename,
698 g_key_file_free(key_file);
701 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
702 bluetooth_a2dp_role_t btd_adapter_get_a2dp_role(struct btd_adapter *adapter)
705 return BLUETOOTH_A2DP_SOURCE_ROLE;
707 return adapter->a2dp_role;
710 void btd_adapter_set_a2dp_role(struct btd_adapter *adapter, bluetooth_a2dp_role_t role)
713 DBG("Could not set a2dp role");
717 if (role == BLUETOOTH_A2DP_SOURCE_ROLE) {
718 DBG("Set audio source role");
719 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
720 } else if (role == BLUETOOTH_A2DP_SINK_ROLE) {
721 DBG("Set audio sink role");
722 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
723 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
724 } else if (role == BLUETOOTH_A2DP_BOTH_ROLE) {
725 DBG("Set audio both role");
726 adapter->a2dp_role = BLUETOOTH_A2DP_BOTH_ROLE;
730 store_adapter_info(adapter);
733 void btd_adapter_emit_a2dp_role_changed(struct btd_adapter *adapter)
736 DBG("Could not emit signal for a2dp role");
740 DBG("A2dp role: %u", adapter->a2dp_role);
742 g_dbus_emit_property_changed(dbus_conn, adapter->path,
743 ADAPTER_INTERFACE, "A2dpRole");
747 static void trigger_pairable_timeout(struct btd_adapter *adapter);
748 static void adapter_start(struct btd_adapter *adapter);
749 static void adapter_stop(struct btd_adapter *adapter);
750 static void trigger_passive_scanning(struct btd_adapter *adapter);
751 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
753 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
754 static bool load_local_irk(struct btd_adapter *adapter);
755 static bool set_local_irk(struct btd_adapter *adapter);
756 static bool set_privacy(struct btd_adapter *adapter, bool privacy);
759 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
760 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
761 static gboolean charging_state_timeout_cb(gpointer user_data)
763 struct btd_adapter *adapter = user_data;
764 int bredr_pkt_type = ACL_PTYPE_MASK;
766 adapter->charging_timeout = 0;
768 DBG("Set all connections to BR/EDR type");
769 g_slist_foreach(adapter->devices, device_change_pkt_type,
770 (gpointer)bredr_pkt_type);
775 static void set_charging_state(struct btd_adapter *adapter,
776 charging_state_e state)
778 int br_pkt_type = ACL_PTYPE_MASK |
779 HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
780 HCI_3DH1 | HCI_3DH3 | HCI_3DH5;
782 if (adapter->charging == state)
785 DBG("old charging state : %d, new charging_state : %d",
786 adapter->charging, state);
789 * Only none / wire charging <-> wireless charging state change should
792 if ((adapter->charging == NONE_CHARGING && state == WIRE_CHARGING) ||
793 (adapter->charging == WIRE_CHARGING && state == NONE_CHARGING)) {
794 DBG("Just update charging state");
795 adapter->charging = state;
799 if (adapter->charging_timeout) {
800 g_source_remove(adapter->charging_timeout);
801 adapter->charging_timeout = 0;
804 adapter->charging = state;
805 if (adapter->charging == NONE_CHARGING ||
806 adapter->charging == WIRE_CHARGING) {
807 DBG("Trigger timeout to set connection to BR/EDR type");
808 adapter->charging_timeout = g_timeout_add(2000,
809 charging_state_timeout_cb, adapter);
810 } else if (adapter->charging == WIRELESS_CHARGING) {
811 DBG("Set all connections to BR type");
812 g_slist_foreach(adapter->devices, device_change_pkt_type,
813 (gpointer)br_pkt_type);
819 static gboolean charging_state_changed(DBusConnection *connection,
820 DBusMessage *msg, void *user_data)
822 struct btd_adapter *adapter = user_data;
825 DBG("charging_state_changed");
827 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &state,
831 set_charging_state(adapter, state);
836 charging_state_e get_charging_state(struct btd_adapter *adapter)
838 DBG("charging_state: %d", adapter->charging);
839 return adapter->charging;
841 #endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
843 static int compare_slot(gconstpointer a, gconstpointer b)
845 const struct adv_info *adv = a;
846 const int id = *(int*)b;
848 return (adv->slot_id == id ? 0 : -1);
851 static struct adv_info *find_advertiser(struct btd_adapter *adapter,
856 list = g_slist_find_custom(adapter->adv_list, &slot_id,
864 static struct adv_info *create_advertiser(struct btd_adapter *adapter,
867 struct adv_info *adv;
872 adv = find_advertiser(adapter, slot_id);
874 DBG("Aleady existed. solt_id [%d]", slot_id);
878 DBG("Create adv slot id : %d", slot_id);
880 adv = g_new0(struct adv_info, 1);
884 adv->slot_id = slot_id;
886 adapter->adv_list = g_slist_append(adapter->adv_list, adv);
891 static void advertising_state_changed(struct btd_adapter *adapter,
892 int slot_id, bool enabled)
894 struct adv_info *adv;
901 adv = find_advertiser(adapter, slot_id);
903 DBG("Unable to find advertiser [%d]", slot_id);
907 adv->status = enabled;
908 DBG("slot_id %d, status %d", adv->slot_id, adv->status);
910 g_dbus_emit_signal(dbus_conn, adapter->path,
911 ADAPTER_INTERFACE, "AdvertisingEnabled",
912 DBUS_TYPE_INT32, &id,
913 DBUS_TYPE_BOOLEAN, &state,
917 static void clear_advertiser_cb(gpointer data, gpointer user_data)
919 struct adv_info *adv = data;
920 struct btd_adapter *adapter = user_data;
923 advertising_state_changed(adapter, adv->slot_id, 0);
926 static void advertiser_cleanup(struct btd_adapter *adapter)
928 if (!adapter->adv_list)
931 g_slist_foreach(adapter->adv_list, clear_advertiser_cb, adapter);
932 g_slist_free(adapter->adv_list);
933 adapter->adv_list = NULL;
936 static void update_advertiser_address(gpointer data, gpointer user_data)
938 struct adv_info *adv = data;
939 struct btd_adapter *adapter = user_data;
941 if (adv->slot_id > 0 && adv->status == 1)
942 adapter_le_set_random_address(adapter, &adapter->rpa, adv->slot_id);
945 static void rpa_changed_callback(uint16_t index, uint16_t length,
946 const void *param, void *user_data)
948 const struct mgmt_ev_rpa_changed *ev = param;
949 struct btd_adapter *adapter = user_data;
952 if (length < sizeof(*ev)) {
953 error("Too small rpa changed event");
957 ba2str(&ev->bdaddr, addr);
958 DBG("RPA changed %s", addr);
959 bacpy(&adapter->rpa, &ev->bdaddr);
961 if (!adapter->adv_list)
964 g_slist_foreach(adapter->adv_list, update_advertiser_address, adapter);
969 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
970 #define OCF_PAGE_SCAN_TIMEOUT 0x0018
971 #define OGF_PAGE_SCAN_TIMEOUT 0x03
974 uint16_t timeout; /* Value */
975 } __attribute__ ((packed)) hci_page_scan_timeout;
976 #define HCI_PAGE_SCAN_TIMEOUT_CP_SIZE 2
978 static gboolean send_sprd_page_scan_timeout(gint value)
981 hci_page_scan_timeout cp;
983 dd = hci_open_dev(0);
985 if (hci_send_cmd(dd, OGF_PAGE_SCAN_TIMEOUT, OCF_PAGE_SCAN_TIMEOUT,
986 HCI_PAGE_SCAN_TIMEOUT_CP_SIZE, &cp) < 0) {
987 DBG("Error: While setting Page Timeout value");
991 DBG("Page Scan Timeout Value Patch %d", value);
999 static void settings_changed(struct btd_adapter *adapter, uint32_t settings)
1001 uint32_t changed_mask;
1003 changed_mask = adapter->current_settings ^ settings;
1005 adapter->current_settings = settings;
1006 adapter->pending_settings &= ~changed_mask;
1008 DBG("Changed settings: 0x%08x", changed_mask);
1009 DBG("Pending settings: 0x%08x", adapter->pending_settings);
1011 if (changed_mask & MGMT_SETTING_POWERED) {
1012 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1013 ADAPTER_INTERFACE, "Powered");
1015 if (adapter->current_settings & MGMT_SETTING_POWERED) {
1016 adapter_start(adapter);
1018 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1019 if (TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN) {
1020 /* Approx 6.4 Seconds of timeout */
1021 /* This Added because Z3 device was not able to connect with
1022 * some device as it was getting Page Timeout
1023 * (LG HBS800, sony carkit) etc. So, Increasing Page timeout value
1024 * from 5.12 Sec (which is default) to ~6.4sec*/
1025 DBG("Setting value");
1026 send_sprd_page_scan_timeout(10240);
1030 adapter_stop(adapter);
1032 if (powering_down) {
1033 adapter_remaining--;
1035 if (!adapter_remaining)
1041 if ((changed_mask & MGMT_SETTING_LE) &&
1042 btd_adapter_get_powered(adapter) &&
1043 (adapter->current_settings & MGMT_SETTING_LE))
1044 trigger_passive_scanning(adapter);
1046 if (changed_mask & MGMT_SETTING_DISCOVERABLE) {
1047 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1048 ADAPTER_INTERFACE, "Discoverable");
1049 /* Only persist discoverable setting if it was not set
1050 * temporarily by discovery.
1052 if (!adapter->discovery_discoverable)
1053 store_adapter_info(adapter);
1054 btd_adv_manager_refresh(adapter->adv_manager);
1057 if (changed_mask & MGMT_SETTING_BONDABLE) {
1058 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1059 ADAPTER_INTERFACE, "Pairable");
1061 trigger_pairable_timeout(adapter);
1064 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1065 if (changed_mask & MGMT_SETTING_ADVERTISING) {
1066 if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
1067 (adapter->advertising)) {
1071 adapter->advertising = adapter->current_settings & MGMT_SETTING_ADVERTISING;
1072 advertising_state_changed(adapter, 0, adapter->advertising);
1075 if ((changed_mask & MGMT_SETTING_PRIVACY) &&
1076 !(adapter->current_settings & MGMT_SETTING_PRIVACY)) {
1077 DBG("LE Privacy feature is disabled");
1080 * Some Android devices don't consider the device as LE one,
1081 * if the device doesn't distribute IRK when pairing.
1082 * Because of this compatibility issue, set IRK
1083 * even though privacy feature is disabled.
1085 set_local_irk(adapter);
1090 static void adapter_set_power_state(struct btd_adapter *adapter, uint32_t value)
1092 if (adapter->power_state == value)
1095 DBG("%s", adapter_power_state_str(value));
1096 adapter->power_state = value;
1097 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1098 ADAPTER_INTERFACE, "PowerState");
1101 static void reset_power_state_target(struct btd_adapter *adapter,
1105 adapter->power_state == ADAPTER_POWER_STATE_OFF_ENABLING) {
1106 adapter_set_power_state(adapter, ADAPTER_POWER_STATE_ON);
1107 } else if (!value &&
1108 adapter->power_state == ADAPTER_POWER_STATE_ON_DISABLING) {
1109 adapter_set_power_state(adapter, ADAPTER_POWER_STATE_OFF);
1113 static void new_settings_callback(uint16_t index, uint16_t length,
1114 const void *param, void *user_data)
1116 struct btd_adapter *adapter = user_data;
1119 if (length < sizeof(settings)) {
1120 btd_error(adapter->dev_id,
1121 "Wrong size of new settings parameters");
1125 settings = get_le32(param);
1127 if (settings == adapter->current_settings)
1130 if ((adapter->current_settings ^ settings) & MGMT_SETTING_POWERED) {
1131 reset_power_state_target(adapter,
1132 settings & MGMT_SETTING_POWERED ?
1136 DBG("Settings: 0x%08x", settings);
1138 settings_changed(adapter, settings);
1141 struct set_mode_data {
1142 struct btd_adapter *adapter;
1147 static void set_mode_complete(uint8_t status, uint16_t length,
1148 const void *param, void *user_data)
1150 struct set_mode_data *data = user_data;
1151 struct btd_adapter *adapter = data->adapter;
1153 if (status != MGMT_STATUS_SUCCESS) {
1154 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
1155 mgmt_errstr(status), status);
1156 if (status == MGMT_STATUS_RFKILLED)
1157 adapter_set_power_state(adapter,
1158 ADAPTER_POWER_STATE_OFF_BLOCKED);
1159 adapter->pending_settings &= ~data->setting;
1160 if (status != MGMT_STATUS_RFKILLED &&
1161 data->setting & MGMT_SETTING_POWERED)
1162 reset_power_state_target(adapter, data->value);
1167 * The parameters are identical and also the task that is
1168 * required in both cases. So it is safe to just call the
1169 * event handling functions here.
1171 new_settings_callback(adapter->dev_id, length, param, adapter);
1174 static void remove_temporary_devices(struct btd_adapter *adapter)
1178 for (l = adapter->devices; l; l = next) {
1179 struct btd_device *dev = l->data;
1181 next = g_slist_next(l);
1182 if (device_is_temporary(dev))
1183 btd_adapter_remove_device(adapter, dev);
1187 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
1190 struct mgmt_mode cp;
1191 uint32_t setting = 0;
1192 struct set_mode_data *data;
1194 memset(&cp, 0, sizeof(cp));
1198 case MGMT_OP_SET_POWERED:
1199 setting = MGMT_SETTING_POWERED;
1200 if (adapter->power_state != ADAPTER_POWER_STATE_OFF_BLOCKED) {
1201 adapter_set_power_state(adapter, mode ?
1202 ADAPTER_POWER_STATE_OFF_ENABLING :
1203 ADAPTER_POWER_STATE_ON_DISABLING);
1206 case MGMT_OP_SET_CONNECTABLE:
1207 setting = MGMT_SETTING_CONNECTABLE;
1209 case MGMT_OP_SET_FAST_CONNECTABLE:
1210 setting = MGMT_SETTING_FAST_CONNECTABLE;
1212 case MGMT_OP_SET_DISCOVERABLE:
1213 setting = MGMT_SETTING_DISCOVERABLE;
1215 case MGMT_OP_SET_BONDABLE:
1216 setting = MGMT_SETTING_BONDABLE;
1220 adapter->pending_settings |= setting;
1222 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1223 DBG("sending 0x%4.4x set mode %d command for index %u", opcode, mode, adapter->dev_id);
1225 DBG("sending set mode command for index %u", adapter->dev_id);
1228 data = g_new0(struct set_mode_data, 1);
1229 data->adapter = adapter;
1230 data->setting = setting;
1233 if (mgmt_send(adapter->mgmt, opcode,
1234 adapter->dev_id, sizeof(cp), &cp,
1235 set_mode_complete, data, g_free) > 0){
1236 adapter->pending_settings |= setting;
1240 if (setting == MGMT_SETTING_POWERED) {
1241 /* cancel the earlier setting */
1242 adapter_set_power_state(adapter, mode ?
1243 ADAPTER_POWER_STATE_OFF :
1244 ADAPTER_POWER_STATE_ON);
1246 btd_error(adapter->dev_id, "Failed to set mode for index %u",
1252 static bool set_discoverable(struct btd_adapter *adapter, uint8_t mode,
1255 struct mgmt_cp_set_discoverable cp;
1256 struct set_mode_data *data;
1258 memset(&cp, 0, sizeof(cp));
1260 cp.timeout = htobs(timeout);
1262 DBG("sending set mode command for index %u", adapter->dev_id);
1264 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1265 if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
1267 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, mode);
1269 /* This also disables discoverable so we're done */
1270 return set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
1275 data = g_new0(struct set_mode_data, 1);
1276 data->adapter = adapter;
1279 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DISCOVERABLE,
1280 adapter->dev_id, sizeof(cp), &cp,
1281 set_mode_complete, data, g_free) > 0)
1285 btd_error(adapter->dev_id, "Failed to set mode for index %u",
1291 static bool pairable_timeout_handler(gpointer user_data)
1293 struct btd_adapter *adapter = user_data;
1295 adapter->pairable_timeout_id = 0;
1297 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
1302 static void trigger_pairable_timeout(struct btd_adapter *adapter)
1304 if (adapter->pairable_timeout_id > 0) {
1305 timeout_remove(adapter->pairable_timeout_id);
1306 adapter->pairable_timeout_id = 0;
1309 if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
1312 if (adapter->pairable_timeout > 0)
1313 adapter->pairable_timeout_id =
1314 timeout_add_seconds(adapter->pairable_timeout,
1315 pairable_timeout_handler, adapter,
1319 static void local_name_changed_callback(uint16_t index, uint16_t length,
1320 const void *param, void *user_data)
1322 struct btd_adapter *adapter = user_data;
1323 const struct mgmt_cp_set_local_name *rp = param;
1325 if (length < sizeof(*rp)) {
1326 btd_error(adapter->dev_id,
1327 "Wrong size of local name changed parameters");
1331 if (!g_strcmp0(adapter->short_name, (const char *) rp->short_name) &&
1332 !g_strcmp0(adapter->name, (const char *) rp->name))
1335 DBG("Name: %s", rp->name);
1336 DBG("Short name: %s", rp->short_name);
1338 g_free(adapter->name);
1339 adapter->name = g_strdup((const char *) rp->name);
1341 g_free(adapter->short_name);
1342 adapter->short_name = g_strdup((const char *) rp->short_name);
1345 * Changing the name (even manually via HCI) will update the
1346 * current alias property.
1348 * In case the name is empty, use the short name.
1350 * There is a difference between the stored alias (which is
1351 * configured by the user) and the current alias. The current
1352 * alias is temporary for the lifetime of the daemon.
1354 if (adapter->name && adapter->name[0] != '\0') {
1355 g_free(adapter->current_alias);
1356 adapter->current_alias = g_strdup(adapter->name);
1358 g_free(adapter->current_alias);
1359 adapter->current_alias = g_strdup(adapter->short_name);
1362 DBG("Current alias: %s", adapter->current_alias);
1364 if (!adapter->current_alias)
1367 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1368 ADAPTER_INTERFACE, "Alias");
1370 attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
1371 (const uint8_t *) adapter->current_alias,
1372 strlen(adapter->current_alias));
1375 static void set_local_name_complete(uint8_t status, uint16_t length,
1376 const void *param, void *user_data)
1378 struct btd_adapter *adapter = user_data;
1380 if (status != MGMT_STATUS_SUCCESS) {
1381 btd_error(adapter->dev_id,
1382 "Failed to set local name: %s (0x%02x)",
1383 mgmt_errstr(status), status);
1388 * The parameters are identical and also the task that is
1389 * required in both cases. So it is safe to just call the
1390 * event handling functions here.
1392 local_name_changed_callback(adapter->dev_id, length, param, adapter);
1395 static int set_name(struct btd_adapter *adapter, const char *name)
1397 struct mgmt_cp_set_local_name cp;
1398 char maxname[MAX_NAME_LENGTH];
1400 memset(maxname, 0, sizeof(maxname));
1401 strncpy(maxname, name, MAX_NAME_LENGTH - 1);
1403 if (!g_utf8_validate(maxname, -1, NULL)) {
1404 btd_error(adapter->dev_id,
1405 "Name change failed: supplied name isn't valid UTF-8");
1409 memset(&cp, 0, sizeof(cp));
1410 strncpy((char *) cp.name, maxname, sizeof(cp.name) - 1);
1412 DBG("sending set local name command for index %u", adapter->dev_id);
1414 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LOCAL_NAME,
1415 adapter->dev_id, sizeof(cp), &cp,
1416 set_local_name_complete, adapter, NULL) > 0)
1419 btd_error(adapter->dev_id, "Failed to set local name for index %u",
1425 int adapter_set_name(struct btd_adapter *adapter, const char *name)
1427 if (g_strcmp0(adapter->system_name, name) == 0)
1430 DBG("name: %s", name);
1432 g_free(adapter->system_name);
1433 adapter->system_name = g_strdup(name);
1435 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1436 ADAPTER_INTERFACE, "Name");
1438 /* alias is preferred over system name */
1439 if (adapter->stored_alias)
1442 DBG("alias: %s", name);
1444 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1445 ADAPTER_INTERFACE, "Alias");
1447 return set_name(adapter, name);
1450 struct btd_device *btd_adapter_find_device(struct btd_adapter *adapter,
1451 const bdaddr_t *dst,
1452 uint8_t bdaddr_type)
1454 struct device_addr_type addr;
1455 struct btd_device *device;
1461 bacpy(&addr.bdaddr, dst);
1462 addr.bdaddr_type = bdaddr_type;
1464 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1465 list = g_slist_find_custom(adapter->devices, &addr,
1466 device_addr_type_strict_cmp);
1468 device = list->data;
1472 list = g_slist_find_custom(adapter->devices, &addr,
1473 device_addr_type_cmp);
1477 device = list->data;
1480 * If we're looking up based on public address and the address
1481 * was not previously used over this bearer we may need to
1482 * update LE or BR/EDR support information.
1484 if (bdaddr_type == BDADDR_BREDR)
1485 device_set_bredr_support(device);
1487 device_set_le_support(device, bdaddr_type);
1492 static int device_path_cmp(gconstpointer a, gconstpointer b)
1494 const struct btd_device *device = a;
1495 const char *path = b;
1496 const char *dev_path = device_get_path(device);
1498 return strcasecmp(dev_path, path);
1501 struct btd_device *btd_adapter_find_device_by_path(struct btd_adapter *adapter,
1509 list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
1516 static void uuid_to_uuid128(uuid_t *uuid128, const uuid_t *uuid)
1518 if (uuid->type == SDP_UUID16)
1519 sdp_uuid16_to_uuid128(uuid128, uuid);
1520 else if (uuid->type == SDP_UUID32)
1521 sdp_uuid32_to_uuid128(uuid128, uuid);
1523 memcpy(uuid128, uuid, sizeof(*uuid));
1526 static bool is_supported_uuid(const uuid_t *uuid)
1530 /* mgmt versions from 1.3 onwards support all types of UUIDs */
1531 if (MGMT_VERSION(mgmt_version, mgmt_revision) >= MGMT_VERSION(1, 3))
1534 uuid_to_uuid128(&tmp, uuid);
1536 if (!sdp_uuid128_to_uuid(&tmp))
1539 if (tmp.type != SDP_UUID16)
1545 static void add_uuid_complete(uint8_t status, uint16_t length,
1546 const void *param, void *user_data)
1548 struct btd_adapter *adapter = user_data;
1550 if (status != MGMT_STATUS_SUCCESS) {
1551 btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
1552 mgmt_errstr(status), status);
1557 * The parameters are identical and also the task that is
1558 * required in both cases. So it is safe to just call the
1559 * event handling functions here.
1561 dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1563 if (adapter->initialized)
1564 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1565 ADAPTER_INTERFACE, "UUIDs");
1568 static int add_uuid(struct btd_adapter *adapter, uuid_t *uuid, uint8_t svc_hint)
1570 struct mgmt_cp_add_uuid cp;
1574 if (!is_supported_uuid(uuid)) {
1575 btd_warn(adapter->dev_id,
1576 "Ignoring unsupported UUID for addition");
1580 uuid_to_uuid128(&uuid128, uuid);
1582 ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1583 htob128(&uint128, (uint128_t *) cp.uuid);
1584 cp.svc_hint = svc_hint;
1586 DBG("sending add uuid command for index %u", adapter->dev_id);
1588 if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_UUID,
1589 adapter->dev_id, sizeof(cp), &cp,
1590 add_uuid_complete, adapter, NULL) > 0)
1593 btd_error(adapter->dev_id, "Failed to add UUID for index %u",
1599 static void remove_uuid_complete(uint8_t status, uint16_t length,
1600 const void *param, void *user_data)
1602 struct btd_adapter *adapter = user_data;
1604 if (status != MGMT_STATUS_SUCCESS) {
1605 btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
1606 mgmt_errstr(status), status);
1611 * The parameters are identical and also the task that is
1612 * required in both cases. So it is safe to just call the
1613 * event handling functions here.
1615 dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1617 if (adapter->initialized)
1618 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1619 ADAPTER_INTERFACE, "UUIDs");
1622 static int remove_uuid(struct btd_adapter *adapter, uuid_t *uuid)
1624 struct mgmt_cp_remove_uuid cp;
1628 if (!is_supported_uuid(uuid)) {
1629 btd_warn(adapter->dev_id,
1630 "Ignoring unsupported UUID for removal");
1634 uuid_to_uuid128(&uuid128, uuid);
1636 ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1637 htob128(&uint128, (uint128_t *) cp.uuid);
1639 DBG("sending remove uuid command for index %u", adapter->dev_id);
1641 if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1642 adapter->dev_id, sizeof(cp), &cp,
1643 remove_uuid_complete, adapter, NULL) > 0)
1646 btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
1652 static void clear_uuids_complete(uint8_t status, uint16_t length,
1653 const void *param, void *user_data)
1655 struct btd_adapter *adapter = user_data;
1657 if (status != MGMT_STATUS_SUCCESS) {
1658 btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
1659 mgmt_errstr(status), status);
1664 * The parameters are identical and also the task that is
1665 * required in both cases. So it is safe to just call the
1666 * event handling functions here.
1668 dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1671 static int clear_uuids(struct btd_adapter *adapter)
1673 struct mgmt_cp_remove_uuid cp;
1675 memset(&cp, 0, sizeof(cp));
1677 DBG("sending clear uuids command for index %u", adapter->dev_id);
1679 if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1680 adapter->dev_id, sizeof(cp), &cp,
1681 clear_uuids_complete, adapter, NULL) > 0)
1684 btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
1690 static uint8_t get_uuid_mask(uuid_t *uuid)
1692 if (uuid->type != SDP_UUID16)
1695 switch (uuid->value.uuid16) {
1696 case DIALUP_NET_SVCLASS_ID:
1697 case CIP_SVCLASS_ID:
1698 return 0x42; /* Telephony & Networking */
1699 case IRMC_SYNC_SVCLASS_ID:
1700 case OBEX_OBJPUSH_SVCLASS_ID:
1701 case OBEX_FILETRANS_SVCLASS_ID:
1702 case IRMC_SYNC_CMD_SVCLASS_ID:
1703 case PBAP_PSE_SVCLASS_ID:
1704 return 0x10; /* Object Transfer */
1705 case HEADSET_SVCLASS_ID:
1706 case HANDSFREE_SVCLASS_ID:
1707 return 0x20; /* Audio */
1708 case CORDLESS_TELEPHONY_SVCLASS_ID:
1709 case INTERCOM_SVCLASS_ID:
1710 case FAX_SVCLASS_ID:
1711 case SAP_SVCLASS_ID:
1713 * Setting the telephony bit for the handsfree audio gateway
1714 * role is not required by the HFP specification, but the
1715 * Nokia 616 carkit is just plain broken! It will refuse
1716 * pairing without this bit set.
1718 case HANDSFREE_AGW_SVCLASS_ID:
1719 return 0x40; /* Telephony */
1720 case AUDIO_SOURCE_SVCLASS_ID:
1721 case VIDEO_SOURCE_SVCLASS_ID:
1722 return 0x08; /* Capturing */
1723 case AUDIO_SINK_SVCLASS_ID:
1724 case VIDEO_SINK_SVCLASS_ID:
1725 return 0x04; /* Rendering */
1726 case PANU_SVCLASS_ID:
1727 case NAP_SVCLASS_ID:
1729 return 0x02; /* Networking */
1735 static int uuid_cmp(const void *a, const void *b)
1737 const sdp_record_t *rec = a;
1738 const uuid_t *uuid = b;
1740 return sdp_uuid_cmp(&rec->svclass, uuid);
1743 static void adapter_service_insert(struct btd_adapter *adapter, sdp_record_t *rec)
1745 sdp_list_t *browse_list = NULL;
1749 DBG("%s", adapter->path);
1751 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1753 DBG("record is NULL return");
1758 /* skip record without a browse group */
1759 if (sdp_get_browse_groups(rec, &browse_list) < 0) {
1760 DBG("skipping record without browse group");
1764 sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
1766 /* skip record without public browse group */
1767 if (!sdp_list_find(browse_list, &browse_uuid, sdp_uuid_cmp))
1770 if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1775 adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1779 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1780 add_uuid(adapter, &rec->svclass, svc_hint);
1784 sdp_list_free(browse_list, free);
1787 int adapter_service_add(struct btd_adapter *adapter, sdp_record_t *rec)
1792 * If the controller does not support BR/EDR operation,
1793 * there is no point in trying to add SDP records.
1795 if (btd_opts.mode == BT_MODE_LE)
1798 DBG("%s", adapter->path);
1800 ret = add_record_to_server(&adapter->bdaddr, rec);
1804 adapter_service_insert(adapter, rec);
1809 void adapter_service_remove(struct btd_adapter *adapter, uint32_t handle)
1813 * If the controller does not support BR/EDR operation,
1814 * there is no point in trying to remote SDP records.
1816 if (btd_opts.mode == BT_MODE_LE)
1819 DBG("%s", adapter->path);
1821 rec = sdp_record_find(handle);
1825 adapter->services = sdp_list_remove(adapter->services, rec);
1827 if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1828 remove_uuid(adapter, &rec->svclass);
1830 remove_record_from_server(rec->handle);
1833 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1834 static void adapter_print_devices(struct btd_adapter *adapter)
1838 dev = adapter->devices;
1839 for (; dev; dev = dev->next)
1840 device_print_addr(dev->data);
1844 static void adapter_add_device(struct btd_adapter *adapter,
1845 struct btd_device *device);
1847 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
1848 const bdaddr_t *bdaddr,
1849 uint8_t bdaddr_type)
1851 struct btd_device *device;
1853 device = device_create(adapter, bdaddr, bdaddr_type);
1857 adapter_add_device(adapter, device);
1859 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1860 device_print_addr(device);
1861 DBG("devices list count : %d", g_slist_length(adapter->devices));
1867 static void service_auth_cancel(struct service_auth *auth)
1871 if (auth->svc_id > 0)
1872 device_remove_svc_complete_callback(auth->device,
1875 dbus_error_init(&derr);
1876 dbus_set_error_const(&derr, ERROR_INTERFACE ".Canceled", NULL);
1878 auth->cb(&derr, auth->user_data);
1880 dbus_error_free(&derr);
1882 if (auth->agent != NULL) {
1883 agent_cancel(auth->agent);
1884 agent_unref(auth->agent);
1890 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1891 void btd_adapter_unpair_device(struct btd_adapter *adapter,
1892 struct btd_device *dev)
1897 adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1899 // adapter->devices = g_slist_remove(adapter->devices, dev);
1901 // adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1904 adapter->connections = g_slist_remove(adapter->connections, dev);
1906 if (adapter->connect_le == dev)
1907 adapter->connect_le = NULL;
1909 l = adapter->auths->head;
1911 struct service_auth *auth = l->data;
1912 GList *next = g_list_next(l);
1914 if (auth->device != dev) {
1919 g_queue_delete_link(adapter->auths, l);
1922 service_auth_cancel(auth);
1925 device_unpair(dev, TRUE);
1930 static void adapter_remove_device(struct btd_adapter *adapter,
1931 struct btd_device *device);
1933 void btd_adapter_remove_device(struct btd_adapter *adapter,
1934 struct btd_device *dev)
1938 adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1940 adapter_remove_device(adapter, dev);
1941 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1942 btd_adv_monitor_device_remove(adapter->adv_monitor_manager, dev);
1944 adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1947 adapter->connections = g_slist_remove(adapter->connections, dev);
1949 if (adapter->connect_le == dev)
1950 adapter->connect_le = NULL;
1952 l = adapter->auths->head;
1954 struct service_auth *auth = l->data;
1955 GList *next = g_list_next(l);
1957 if (auth->device != dev) {
1962 g_queue_delete_link(adapter->auths, l);
1965 service_auth_cancel(auth);
1968 device_remove(dev, TRUE);
1971 struct btd_device *btd_adapter_get_device(struct btd_adapter *adapter,
1972 const bdaddr_t *addr,
1975 struct btd_device *device;
1980 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1981 if (!bacmp(addr, BDADDR_ANY))
1985 device = btd_adapter_find_device(adapter, addr, addr_type);
1989 return adapter_create_device(adapter, addr, addr_type);
1992 struct btd_device *btd_adapter_find_device_by_fd(int fd)
1996 GIOChannel *io = NULL;
1997 GError *gerr = NULL;
1998 struct btd_adapter *adapter;
2000 io = g_io_channel_unix_new(fd);
2004 bt_io_get(io, &gerr,
2005 BT_IO_OPT_SOURCE_BDADDR, &src,
2006 BT_IO_OPT_DEST_BDADDR, &dst,
2007 BT_IO_OPT_DEST_TYPE, &dst_type,
2010 error("bt_io_get: %s", gerr->message);
2012 g_io_channel_unref(io);
2016 g_io_channel_unref(io);
2018 adapter = adapter_find(&src);
2022 return btd_adapter_find_device(adapter, &dst, dst_type);
2025 sdp_list_t *btd_adapter_get_services(struct btd_adapter *adapter)
2027 return adapter->services;
2030 static void passive_scanning_complete(uint8_t status, uint16_t length,
2031 const void *param, void *user_data)
2033 struct btd_adapter *adapter = user_data;
2034 const struct mgmt_cp_start_discovery *rp = param;
2036 DBG("status 0x%02x", status);
2038 if (length < sizeof(*rp)) {
2039 btd_error(adapter->dev_id,
2040 "Wrong size of start scanning return parameters");
2044 if (status == MGMT_STATUS_SUCCESS) {
2045 adapter->discovery_type = rp->type;
2046 adapter->discovery_enable = 0x01;
2050 static bool passive_scanning_timeout(gpointer user_data)
2052 struct btd_adapter *adapter = user_data;
2053 struct mgmt_cp_start_discovery cp;
2055 adapter->passive_scan_timeout = 0;
2057 cp.type = SCAN_TYPE_LE;
2058 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2059 mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2060 adapter->dev_id, sizeof(cp), &cp,
2061 passive_scanning_complete, adapter, NULL);
2063 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2064 adapter->dev_id, sizeof(cp), &cp,
2065 passive_scanning_complete, adapter, NULL);
2070 static void trigger_passive_scanning(struct btd_adapter *adapter)
2072 if (!(adapter->current_settings & MGMT_SETTING_LE))
2077 if (adapter->passive_scan_timeout > 0) {
2078 timeout_remove(adapter->passive_scan_timeout);
2079 adapter->passive_scan_timeout = 0;
2083 * When the kernel background scanning is available, there is
2084 * no need to start any discovery. The kernel will keep scanning
2085 * as long as devices are in its auto-connection list.
2087 if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
2091 * If any client is running a discovery right now, then do not
2092 * even try to start passive scanning.
2094 * The discovery procedure is using interleaved scanning and
2095 * thus will discover Low Energy devices as well.
2097 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2098 if (adapter->discovery_list || adapter->le_discovery_list)
2101 if (adapter->discovery_list)
2105 if (adapter->discovery_enable == 0x01)
2109 * In case the discovery is suspended (for example for an ongoing
2110 * pairing attempt), then also do not start passive scanning.
2112 if (adapter->discovery_suspended)
2116 * If the list of connectable Low Energy devices is empty,
2117 * then do not start passive scanning.
2119 if (!adapter->connect_list)
2122 adapter->passive_scan_timeout = timeout_add_seconds(CONN_SCAN_TIMEOUT,
2123 passive_scanning_timeout, adapter,
2127 static void stop_passive_scanning_complete(uint8_t status, uint16_t length,
2128 const void *param, void *user_data)
2130 struct btd_adapter *adapter = user_data;
2131 struct btd_device *dev;
2134 DBG("status 0x%02x (%s)", status, mgmt_errstr(status));
2136 dev = adapter->connect_le;
2137 adapter->connect_le = NULL;
2140 * When the kernel background scanning is available, there is
2141 * no need to stop any discovery. The kernel will handle the
2142 * auto-connection by itself.
2144 if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
2148 * MGMT_STATUS_REJECTED may be returned from kernel because the passive
2149 * scan timer had expired in kernel and passive scan was disabled just
2150 * around the time we called stop_passive_scanning().
2152 if (status != MGMT_STATUS_SUCCESS && status != MGMT_STATUS_REJECTED) {
2153 btd_error(adapter->dev_id, "Stopping passive scanning failed: %s",
2154 mgmt_errstr(status));
2158 adapter->discovery_type = 0x00;
2159 adapter->discovery_enable = 0x00;
2162 DBG("Device removed while stopping passive scanning");
2163 trigger_passive_scanning(adapter);
2167 err = device_connect_le(dev);
2169 btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
2170 strerror(-err), -err);
2171 trigger_passive_scanning(adapter);
2175 static void stop_passive_scanning(struct btd_adapter *adapter)
2177 struct mgmt_cp_stop_discovery cp;
2178 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2179 struct mgmt_cp_stop_discovery le_cp;
2184 /* If there are any normal discovery clients passive scanning
2185 * wont be running */
2186 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2187 if (adapter->discovery_list || adapter->le_discovery_list)
2190 if (adapter->discovery_list)
2194 if (adapter->discovery_enable == 0x00)
2197 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2198 if ((adapter->discovery_type & 0x01) > 0) {
2200 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2201 adapter->dev_id, sizeof(cp), &cp,
2202 stop_passive_scanning_complete, adapter, NULL);
2204 if ((adapter->discovery_type & 0x06) > 0) {
2206 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
2207 adapter->dev_id, sizeof(le_cp), &le_cp,
2208 stop_passive_scanning_complete, adapter, NULL);
2211 cp.type = adapter->discovery_type;
2213 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2214 adapter->dev_id, sizeof(cp), &cp,
2215 stop_passive_scanning_complete, adapter, NULL);
2219 static void cancel_passive_scanning(struct btd_adapter *adapter)
2221 if (!(adapter->current_settings & MGMT_SETTING_LE))
2226 if (adapter->passive_scan_timeout > 0) {
2227 timeout_remove(adapter->passive_scan_timeout);
2228 adapter->passive_scan_timeout = 0;
2232 static uint8_t get_scan_type(struct btd_adapter *adapter)
2236 if (adapter->current_settings & MGMT_SETTING_BREDR)
2237 type = SCAN_TYPE_BREDR;
2241 if (adapter->current_settings & MGMT_SETTING_LE)
2242 type |= SCAN_TYPE_LE;
2247 static void free_discovery_filter(struct discovery_filter *discovery_filter)
2249 if (!discovery_filter)
2252 g_slist_free_full(discovery_filter->uuids, free);
2253 free(discovery_filter->pattern);
2254 g_free(discovery_filter);
2257 static void invalidate_rssi_and_tx_power(gpointer a)
2259 struct btd_device *dev = a;
2261 device_set_rssi(dev, 0);
2262 device_set_tx_power(dev, 127);
2265 static void discovery_cleanup(struct btd_adapter *adapter, int timeout)
2269 adapter->discovery_type = 0x00;
2271 if (adapter->discovery_idle_timeout > 0) {
2272 timeout_remove(adapter->discovery_idle_timeout);
2273 adapter->discovery_idle_timeout = 0;
2276 g_slist_free_full(adapter->discovery_found,
2277 invalidate_rssi_and_tx_power);
2278 adapter->discovery_found = NULL;
2280 if (!adapter->devices)
2283 for (l = adapter->devices; l != NULL; l = next) {
2284 struct btd_device *dev = l->data;
2286 next = g_slist_next(l);
2288 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2289 if (device_is_temporary(dev) && !device_is_connectable(dev)
2290 && !btd_device_is_connected(dev))
2292 if (device_is_temporary(dev) && !device_is_connectable(dev))
2294 btd_adapter_remove_device(adapter, dev);
2299 static void discovery_free(void *user_data)
2301 struct discovery_client *client = user_data;
2302 struct btd_adapter *adapter = client->adapter;
2304 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2308 g_dbus_remove_watch(dbus_conn, client->watch);
2310 if (client->discovery_filter) {
2311 free_discovery_filter(client->discovery_filter);
2312 client->discovery_filter = NULL;
2316 if (client == adapter->client) {
2317 g_dbus_send_message(dbus_conn,
2318 btd_error_busy(client->msg));
2319 adapter->client = NULL;
2321 dbus_message_unref(client->msg);
2324 g_free(client->owner);
2328 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2329 static void discovery_remove(struct discovery_client *client, bool exit)
2331 static void discovery_remove(struct discovery_client *client)
2335 struct btd_adapter *adapter = client->adapter;
2337 DBG("owner %s", client->owner);
2339 adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2342 adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2345 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2346 if (!exit && client->discovery_filter)
2348 if (adapter->client == client)
2349 adapter->client = NULL;
2351 if (client->watch && client->discovery_filter)
2353 adapter->set_filter_list = g_slist_prepend(
2354 adapter->set_filter_list, client);
2356 discovery_free(client);
2359 * If there are other client discoveries in progress, then leave
2360 * it active. If not, then make sure to stop the restart timeout.
2362 if (adapter->discovery_list)
2365 discovery_cleanup(adapter, TEMP_DEV_TIMEOUT);
2368 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay);
2370 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2371 static void discovery_reply(struct discovery_client *client, uint8_t status)
2373 static struct discovery_client *discovery_complete(struct btd_adapter *adapter,
2377 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2378 struct discovery_client *client = adapter->client;
2381 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2386 adapter->client = NULL;
2390 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2396 g_dbus_send_reply(dbus_conn, client->msg, DBUS_TYPE_INVALID);
2398 reply = btd_error_busy(client->msg);
2399 g_dbus_send_message(dbus_conn, reply);
2402 dbus_message_unref(client->msg);
2404 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2409 static void start_discovery_complete(uint8_t status, uint16_t length,
2410 const void *param, void *user_data)
2412 struct btd_adapter *adapter = user_data;
2413 struct discovery_client *client;
2414 const struct mgmt_cp_start_discovery *rp = param;
2416 DBG("status 0x%02x", status);
2418 /* Is there are no clients the discovery must have been stopped while
2419 * discovery command was pending.
2421 if (!adapter->discovery_list) {
2422 struct mgmt_cp_stop_discovery cp;
2424 if (status != MGMT_STATUS_SUCCESS)
2427 /* Stop discovering as there are no clients left */
2429 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2430 adapter->dev_id, sizeof(cp), &cp,
2435 client = adapter->discovery_list->data;
2437 if (length < sizeof(*rp)) {
2438 btd_error(adapter->dev_id,
2439 "Wrong size of start discovery return parameters");
2445 if (status == MGMT_STATUS_SUCCESS) {
2446 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2447 DBG("Return param discovery type 0x%02x", rp->type);
2448 adapter->discovery_type |= rp->type;
2450 adapter->discovery_type = rp->type;
2452 adapter->discovery_enable = 0x01;
2454 if (adapter->current_discovery_filter)
2455 adapter->filtered_discovery = true;
2457 adapter->filtered_discovery = false;
2459 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2460 discovery_reply(client, status);
2462 discovery_complete(adapter, status);
2464 if (adapter->discovering)
2467 adapter->discovering = true;
2468 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2469 ADAPTER_INTERFACE, "Discovering");
2471 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2473 adapter->discovering = false;
2474 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2475 ADAPTER_INTERFACE, "Discovering");
2479 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2481 /* Reply with an error if the first discovery has failed */
2483 discovery_reply(client, status);
2484 discovery_remove(client, false);
2486 client = discovery_complete(adapter, status);
2488 discovery_remove(client);
2494 * In case the restart of the discovery failed, then just trigger
2495 * it for the next idle timeout again.
2497 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2498 trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
2502 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2503 static void start_le_discovery_complete(uint8_t status, uint16_t length,
2504 const void *param, void *user_data)
2506 struct btd_adapter *adapter = user_data;
2507 const struct mgmt_cp_start_discovery *rp = param;
2510 error("Error ocurred in LEDiscovering, rp is NULL");
2514 DBG("status 0x%02x", status);
2515 if (length < sizeof(*rp)) {
2516 error("Wrong size of start discovery return parameters");
2520 DBG("Discovery Type 0x%02x", rp->type);
2521 if (status == MGMT_STATUS_SUCCESS) {
2522 adapter->discovery_type |= rp->type;
2523 adapter->discovery_enable = 0x01;
2525 if (adapter->le_discovering)
2528 adapter->le_discovering = true;
2529 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2530 ADAPTER_INTERFACE, "LEDiscovering");
2534 adapter->le_discovering = false;
2535 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2536 ADAPTER_INTERFACE, "LEDiscovering");
2542 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2543 static bool start_le_discovery_timeout(gpointer user_data)
2545 struct btd_adapter *adapter = user_data;
2550 adapter->le_discovery_idle_timeout = 0;
2552 new_type = SCAN_TYPE_LE;
2554 if (adapter->discovery_enable == 0x01) {
2556 * If there is an already running discovery and it has the
2557 * same type, then just keep it.
2560 if ((adapter->discovery_type & new_type) == SCAN_TYPE_LE) {
2561 if (adapter->le_discovering)
2564 adapter->le_discovering = true;
2565 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2566 ADAPTER_INTERFACE, "LEDiscovering");
2572 struct mgmt_cp_start_discovery cp;
2575 mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2576 adapter->dev_id, sizeof(cp), &cp,
2577 start_le_discovery_complete, adapter, NULL);
2583 static bool start_discovery_timeout(gpointer user_data)
2585 struct btd_adapter *adapter = user_data;
2586 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2587 struct mgmt_cp_start_service_discovery *sd_cp;
2593 adapter->discovery_idle_timeout = 0;
2595 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2596 new_type = SCAN_TYPE_BREDR;
2598 if (adapter->discovery_enable == 0x01) {
2600 * If there is an already running discovery and it has the
2601 * same type, then just keep it.
2603 if ((adapter->discovery_type & new_type) == SCAN_TYPE_BREDR) {
2604 if (adapter->discovering)
2607 adapter->discovering = true;
2608 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2609 ADAPTER_INTERFACE, "Discovering");
2615 struct mgmt_cp_start_discovery cp;
2617 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2618 adapter->dev_id, sizeof(cp), &cp,
2619 start_discovery_complete, adapter,
2624 /* If we're doing filtered discovery, it must be quickly restarted */
2625 adapter->no_scan_restart_delay = !!adapter->current_discovery_filter;
2627 DBG("adapter->current_discovery_filter == %d",
2628 !!adapter->current_discovery_filter);
2630 new_type = get_scan_type(adapter);
2632 if (adapter->discovery_enable == 0x01) {
2633 struct mgmt_cp_stop_discovery cp;
2636 * If we're asked to start regular discovery, and there is an
2637 * already running regular discovery and it has the same type,
2638 * then just keep it.
2640 if (!adapter->current_discovery_filter &&
2641 !adapter->filtered_discovery &&
2642 adapter->discovery_type == new_type) {
2643 if (adapter->discovering)
2646 adapter->discovering = true;
2647 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2648 ADAPTER_INTERFACE, "Discovering");
2653 * Otherwise the current discovery must be stopped. So
2654 * queue up a stop discovery command.
2656 * This can happen if a passive scanning for Low Energy
2657 * devices is ongoing, or scan type is changed between
2658 * regular and filtered, or filter was updated.
2660 cp.type = adapter->discovery_type;
2661 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2662 adapter->dev_id, sizeof(cp), &cp,
2665 /* Don't even bother to try to quickly start discovery
2666 * just after stopping it, it would fail with status
2667 * MGMT_BUSY. Instead discovering_callback will take
2674 /* Regular discovery is required */
2675 if (!adapter->current_discovery_filter) {
2676 struct mgmt_cp_start_discovery cp;
2679 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2680 adapter->dev_id, sizeof(cp), &cp,
2681 start_discovery_complete, adapter,
2687 /* Filtered discovery is required */
2688 sd_cp = adapter->current_discovery_filter;
2690 DBG("sending MGMT_OP_START_SERVICE_DISCOVERY %d, %d, %d",
2691 sd_cp->rssi, sd_cp->type,
2692 btohs(sd_cp->uuid_count));
2694 mgmt_send(adapter->mgmt, MGMT_OP_START_SERVICE_DISCOVERY,
2695 adapter->dev_id, sizeof(*sd_cp) +
2696 btohs(sd_cp->uuid_count) * 16,
2697 sd_cp, start_discovery_complete, adapter, NULL);
2704 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2705 static void trigger_start_le_discovery(struct btd_adapter *adapter, guint delay)
2710 cancel_passive_scanning(adapter);
2712 if (adapter->le_discovery_idle_timeout > 0) {
2713 g_source_remove(adapter->le_discovery_idle_timeout);
2714 adapter->le_discovery_idle_timeout = 0;
2718 * If the controller got powered down in between, then ensure
2719 * that we do not keep trying to restart discovery.
2721 * This is safe-guard and should actually never trigger.
2723 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2726 adapter->le_discovery_idle_timeout = timeout_add_seconds(delay,
2727 start_le_discovery_timeout, adapter, NULL);
2731 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
2736 cancel_passive_scanning(adapter);
2738 if (adapter->discovery_idle_timeout > 0) {
2739 timeout_remove(adapter->discovery_idle_timeout);
2740 adapter->discovery_idle_timeout = 0;
2744 * If the controller got powered down in between, then ensure
2745 * that we do not keep trying to restart discovery.
2747 * This is safe-guard and should actually never trigger.
2749 if (!btd_adapter_get_powered(adapter))
2752 adapter->discovery_idle_timeout = timeout_add_seconds(delay,
2753 start_discovery_timeout, adapter, NULL);
2756 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2757 static void suspend_discovery_complete(uint8_t status, uint16_t length,
2758 const void *param, void *user_data)
2760 struct btd_adapter *adapter = user_data;
2762 DBG("status 0x%02x", status);
2764 if (status == MGMT_STATUS_SUCCESS) {
2765 adapter->discovery_type = 0x00;
2766 adapter->discovery_enable = 0x00;
2771 static void suspend_discovery(struct btd_adapter *adapter)
2773 struct mgmt_cp_stop_discovery cp;
2777 adapter->discovery_suspended = true;
2780 * If there are no clients discovering right now, then there is
2781 * also nothing to suspend.
2783 if (!adapter->discovery_list)
2787 * In case of being inside the idle phase, make sure to remove
2788 * the timeout to not trigger a restart.
2790 * The restart will be triggered when the discovery is resumed.
2792 if (adapter->discovery_idle_timeout > 0) {
2793 timeout_remove(adapter->discovery_idle_timeout);
2794 adapter->discovery_idle_timeout = 0;
2797 if (adapter->discovery_enable == 0x00)
2800 cp.type = adapter->discovery_type;
2802 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2803 adapter->dev_id, sizeof(cp), &cp,
2804 suspend_discovery_complete, adapter, NULL);
2807 static void resume_discovery(struct btd_adapter *adapter)
2811 adapter->discovery_suspended = false;
2814 * If there are no clients discovering right now, then there is
2815 * also nothing to resume.
2817 if (!adapter->discovery_list)
2821 * Treat a suspended discovery session the same as extra long
2822 * idle time for a normal discovery. So just trigger the default
2823 * restart procedure.
2825 trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2829 static void discovering_callback(uint16_t index, uint16_t length,
2830 const void *param, void *user_data)
2832 const struct mgmt_ev_discovering *ev = param;
2833 struct btd_adapter *adapter = user_data;
2835 if (length < sizeof(*ev)) {
2836 btd_error(adapter->dev_id, "Too small discovering event");
2840 DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
2841 ev->discovering, adapter->filtered_discovery);
2843 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2844 DBG("info discov_type %d", adapter->discovery_type);
2845 if (ev->type == SCAN_TYPE_BREDR) {
2846 if (ev->discovering == FALSE) {
2847 hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
2848 adapter->discovering = false;
2850 hci_set_bit(BDADDR_BREDR, &adapter->discovery_type);
2851 adapter->discovering = true;
2853 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2854 ADAPTER_INTERFACE, "Discovering");
2856 } else if (ev->type == SCAN_TYPE_LE) {
2857 if (ev->discovering == FALSE) {
2858 hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2859 hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2861 if (adapter->le_discovering == true) {
2862 if (adapter->le_discovery_list) {
2863 struct discovery_client *client;
2865 client = adapter->le_discovery_list->data;
2866 g_dbus_remove_watch(dbus_conn, client->watch);
2869 adapter->le_discovering = false;
2872 hci_set_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2873 hci_set_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2874 adapter->le_discovering = true;
2877 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2878 ADAPTER_INTERFACE, "LEDiscovering");
2881 if (adapter->discovery_enable == ev->discovering)
2884 adapter->discovery_type = ev->type;
2885 adapter->discovery_enable = ev->discovering;
2889 * Check for existing discoveries triggered by client applications
2890 * and ignore all others.
2892 * If there are no clients, then it is good idea to trigger a
2893 * passive scanning attempt.
2895 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2896 if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2897 if (!adapter->connect_le)
2898 trigger_passive_scanning(adapter);
2902 if (!adapter->discovery_list) {
2903 if (!adapter->connect_le)
2904 trigger_passive_scanning(adapter);
2909 if (adapter->discovery_suspended)
2912 switch (adapter->discovery_enable) {
2914 if (adapter->no_scan_restart_delay)
2915 trigger_start_discovery(adapter, 0);
2917 trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2921 if (adapter->discovery_idle_timeout > 0) {
2922 timeout_remove(adapter->discovery_idle_timeout);
2923 adapter->discovery_idle_timeout = 0;
2930 static bool set_discovery_discoverable(struct btd_adapter *adapter, bool enable)
2932 if (adapter->discovery_discoverable == enable)
2935 /* Reset discoverable filter if already set */
2936 if (enable && (adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
2939 adapter->discovery_discoverable = enable;
2941 return set_discoverable(adapter, enable, 0);
2944 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2945 static void stop_discovery_complete(uint8_t status, uint16_t length,
2946 const void *param, void *user_data)
2948 struct discovery_client *client = user_data;
2949 struct btd_adapter *adapter = client->adapter;
2952 DBG("status 0x%02x", status);
2954 if (status != MGMT_STATUS_SUCCESS) {
2956 reply = btd_error_busy(client->msg);
2957 g_dbus_send_message(dbus_conn, reply);
2964 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2965 g_dbus_send_message(dbus_conn, reply);
2968 adapter->discovery_type &= (~0x01);
2969 DBG("Discovery Type 0x%02x", adapter->discovery_type);
2971 adapter->filtered_discovery = false;
2972 adapter->no_scan_restart_delay = false;
2973 adapter->discovering = false;
2974 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2975 ADAPTER_INTERFACE, "Discovering");
2977 if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2978 adapter->discovery_enable = 0x00;
2979 trigger_passive_scanning(adapter);
2983 discovery_remove(client, false);
2986 static void stop_le_discovery_complete(uint8_t status, uint16_t length,
2987 const void *param, void *user_data)
2989 struct btd_adapter *adapter = user_data;
2990 struct discovery_client *client;
2993 DBG("status 0x%02x", status);
2995 /* Is there are no clients the discovery must have been stopped while
2996 * discovery command was pending.
2998 if (!adapter->le_discovery_list)
3001 client = adapter->le_discovery_list->data;
3003 if (status != MGMT_STATUS_SUCCESS) {
3005 reply = btd_error_busy(client->msg);
3006 g_dbus_send_message(dbus_conn, reply);
3013 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
3014 g_dbus_send_message(dbus_conn, reply);
3017 adapter->discovery_type &= (~0x06);
3018 DBG("Discovery Type 0x%02x", adapter->discovery_type);
3020 adapter->filtered_discovery = false;
3021 adapter->no_scan_restart_delay = false;
3022 adapter->le_discovering = false;
3023 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3024 ADAPTER_INTERFACE, "LEDiscovering");
3026 if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
3027 adapter->discovery_enable = 0x00;
3028 trigger_passive_scanning(adapter);
3033 * The destroy function will cleanup the client information and
3034 * also remove it from the list of discovery clients.
3036 g_dbus_remove_watch(dbus_conn, client->watch);
3040 static void stop_discovery_complete(uint8_t status, uint16_t length,
3041 const void *param, void *user_data)
3043 struct btd_adapter *adapter = user_data;
3044 struct discovery_client *client;
3046 DBG("status 0x%02x", status);
3048 client = discovery_complete(adapter, status);
3050 discovery_remove(client);
3052 if (status != MGMT_STATUS_SUCCESS)
3055 adapter->discovery_type = 0x00;
3056 adapter->discovery_enable = 0x00;
3057 adapter->filtered_discovery = false;
3058 adapter->no_scan_restart_delay = false;
3059 adapter->discovering = false;
3060 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3061 ADAPTER_INTERFACE, "Discovering");
3063 trigger_passive_scanning(adapter);
3067 static int compare_sender(gconstpointer a, gconstpointer b)
3069 const struct discovery_client *client = a;
3070 const char *sender = b;
3072 return g_strcmp0(client->owner, sender);
3075 static gint g_strcmp(gconstpointer a, gconstpointer b)
3077 return strcmp(a, b);
3080 static void extract_unique_uuids(gpointer data, gpointer user_data)
3082 char *uuid_str = data;
3083 GSList **uuids = user_data;
3085 if (!g_slist_find_custom(*uuids, uuid_str, g_strcmp))
3086 *uuids = g_slist_insert_sorted(*uuids, uuid_str, g_strcmp);
3090 * This method merges all adapter filters into rssi, transport and uuids.
3091 * Returns 1 if there was no filtered scan, 0 otherwise.
3093 static int merge_discovery_filters(struct btd_adapter *adapter, int *rssi,
3094 uint8_t *transport, GSList **uuids)
3097 bool empty_uuid = false;
3098 bool has_regular_discovery = false;
3099 bool has_filtered_discovery = false;
3100 uint8_t adapter_scan_type = get_scan_type(adapter);
3102 for (l = adapter->discovery_list; l != NULL; l = g_slist_next(l)) {
3103 struct discovery_client *client = l->data;
3104 struct discovery_filter *item = client->discovery_filter;
3107 has_regular_discovery = true;
3112 * Detect empty filter with only discoverable
3113 * (which does not require a kernel filter) set.
3115 if (item->uuids == NULL &&
3116 item->pathloss == DISTANCE_VAL_INVALID &&
3117 item->rssi == DISTANCE_VAL_INVALID &&
3118 item->type == adapter_scan_type &&
3119 item->duplicate == false &&
3120 item->pattern == NULL) {
3121 has_regular_discovery = true;
3125 has_filtered_discovery = true;
3127 *transport |= item->type;
3130 * Rule for merging rssi and pathloss into rssi field of kernel
3131 * filter is as follow:
3132 * - if there's any client without proximity filter, then do no
3133 * proximity filtering,
3134 * - if all clients specified RSSI, then use lowest value,
3135 * - if any client specified pathloss, then kernel filter should
3136 * do no proximity, as kernel can't compute pathloss. We'll do
3137 * filtering on our own.
3139 if (item->rssi == DISTANCE_VAL_INVALID)
3140 *rssi = HCI_RSSI_INVALID;
3141 else if (*rssi != HCI_RSSI_INVALID && *rssi >= item->rssi)
3143 else if (item->pathloss != DISTANCE_VAL_INVALID)
3144 *rssi = HCI_RSSI_INVALID;
3146 if (!g_slist_length(item->uuids))
3149 g_slist_foreach(item->uuids, extract_unique_uuids, uuids);
3152 /* If no proximity filtering is set, disable it */
3153 if (*rssi == DISTANCE_VAL_INVALID)
3154 *rssi = HCI_RSSI_INVALID;
3157 * Empty_uuid variable determines wether there was any filter with no
3158 * uuids. In this case someone might be looking for all devices in
3159 * certain proximity, and we need to have empty uuids in kernel filter.
3162 g_slist_free(*uuids);
3166 if (has_regular_discovery) {
3167 if (!has_filtered_discovery)
3171 * It there is both regular and filtered scan running, then
3172 * clear whole fitler to report all devices.
3174 *transport = adapter_scan_type;
3175 *rssi = HCI_RSSI_INVALID;
3176 g_slist_free(*uuids);
3183 static void populate_mgmt_filter_uuids(uint8_t (*mgmt_uuids)[16], GSList *uuids)
3187 for (l = uuids; l != NULL; l = g_slist_next(l)) {
3188 bt_uuid_t uuid, u128;
3191 bt_string_to_uuid(&uuid, l->data);
3192 bt_uuid_to_uuid128(&uuid, &u128);
3194 ntoh128((uint128_t *) u128.value.u128.data, &uint128);
3195 htob128(&uint128, (uint128_t *) mgmt_uuids);
3202 * This method merges all adapter filters into one that will be send to kernel.
3203 * cp_ptr is set to null when regular non-filtered discovery is needed,
3204 * otherwise it's pointing to filter. Returns 0 on succes, -1 on error
3206 static int discovery_filter_to_mgmt_cp(struct btd_adapter *adapter,
3207 struct mgmt_cp_start_service_discovery **cp_ptr)
3209 GSList *uuids = NULL;
3210 struct mgmt_cp_start_service_discovery *cp;
3211 int rssi = DISTANCE_VAL_INVALID;
3213 uint8_t discovery_type = 0;
3217 if (merge_discovery_filters(adapter, &rssi, &discovery_type, &uuids)) {
3218 /* There are only regular scans, run just regular scan. */
3223 uuid_count = g_slist_length(uuids);
3225 cp = g_try_malloc(sizeof(*cp) + 16*uuid_count);
3228 g_slist_free(uuids);
3232 cp->type = discovery_type;
3234 cp->uuid_count = htobs(uuid_count);
3235 populate_mgmt_filter_uuids(cp->uuids, uuids);
3237 g_slist_free(uuids);
3241 static bool filters_equal(struct mgmt_cp_start_service_discovery *a,
3242 struct mgmt_cp_start_service_discovery *b) {
3246 if ((!a && b) || (a && !b))
3249 if (a->type != b->type)
3252 if (a->rssi != b->rssi)
3256 * When we create mgmt_cp_start_service_discovery structure inside
3257 * discovery_filter_to_mgmt_cp, we always keep uuids sorted, and
3258 * unique, so we're safe to compare uuid_count, and uuids like that.
3260 if (a->uuid_count != b->uuid_count)
3263 if (memcmp(a->uuids, b->uuids, 16 * a->uuid_count) != 0)
3269 static int update_discovery_filter(struct btd_adapter *adapter)
3271 struct mgmt_cp_start_service_discovery *sd_cp;
3275 if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
3276 btd_error(adapter->dev_id,
3277 "discovery_filter_to_mgmt_cp returned error");
3281 /* Only attempt to overwrite current discoverable setting when not
3284 if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE)) {
3287 for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
3288 struct discovery_client *client = l->data;
3290 if (!client->discovery_filter)
3293 if (client->discovery_filter->discoverable) {
3294 set_discovery_discoverable(adapter, true);
3301 * If filters are equal, then don't update scan, except for when
3302 * starting discovery.
3304 if (filters_equal(adapter->current_discovery_filter, sd_cp) &&
3305 adapter->discovering != 0) {
3306 DBG("filters were equal, deciding to not restart the scan.");
3311 g_free(adapter->current_discovery_filter);
3312 adapter->current_discovery_filter = sd_cp;
3314 trigger_start_discovery(adapter, 0);
3316 return -EINPROGRESS;
3319 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3320 static int discovery_stop(struct discovery_client *client, bool exit)
3322 static int discovery_stop(struct discovery_client *client)
3325 struct btd_adapter *adapter = client->adapter;
3326 struct mgmt_cp_stop_discovery cp;
3328 /* Check if there are more client discovering */
3329 if (g_slist_next(adapter->discovery_list)) {
3330 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3331 discovery_remove(client, exit);
3333 discovery_remove(client);
3335 update_discovery_filter(adapter);
3339 set_discovery_discoverable(adapter, false);
3342 * In the idle phase of a discovery, there is no need to stop it
3343 * and so it is enough to send out the signal and just return.
3345 if (adapter->discovery_enable == 0x00) {
3346 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3347 discovery_remove(client, exit);
3349 discovery_remove(client);
3351 adapter->discovering = false;
3352 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3353 ADAPTER_INTERFACE, "Discovering");
3355 trigger_passive_scanning(adapter);
3359 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3360 adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3362 cp.type = adapter->discovery_type;
3363 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
3364 adapter->client = client;
3366 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3369 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
3370 adapter->dev_id, sizeof(cp), &cp,
3371 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3372 stop_discovery_complete, client, NULL);
3374 stop_discovery_complete, adapter, NULL);
3377 return -EINPROGRESS;
3380 static void discovery_destroy(void *user_data)
3382 struct discovery_client *client = user_data;
3383 struct btd_adapter *adapter = client->adapter;
3385 DBG("owner %s", client->owner);
3387 adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
3390 adapter->discovery_list = g_slist_remove(adapter->discovery_list,
3393 if (client->discovery_filter) {
3394 free_discovery_filter(client->discovery_filter);
3395 client->discovery_filter = NULL;
3398 g_free(client->owner);
3402 * If there are other client discoveries in progress, then leave
3403 * it active. If not, then make sure to stop the restart timeout.
3405 if (adapter->discovery_list)
3408 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3409 hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
3411 adapter->discovery_type = 0x00;
3414 discovery_cleanup(adapter, 0);
3418 static void discovery_disconnect(DBusConnection *conn, void *user_data)
3420 struct discovery_client *client = user_data;
3422 DBG("owner %s", client->owner);
3423 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3424 discovery_stop(client, true);
3428 discovery_stop(client);
3433 * Returns true if client was already discovering, false otherwise. *client
3434 * will point to discovering client, or client that have pre-set his filter.
3436 static bool get_discovery_client(struct btd_adapter *adapter,
3438 struct discovery_client **client)
3440 GSList *list = g_slist_find_custom(adapter->discovery_list, owner,
3443 *client = list->data;
3447 list = g_slist_find_custom(adapter->set_filter_list, owner,
3450 *client = list->data;
3458 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3459 static void le_discovery_destroy(void *user_data)
3461 struct discovery_client *client = user_data;
3462 struct btd_adapter *adapter = client->adapter;
3464 DBG("owner %s", client->owner);
3466 adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3469 g_free(client->owner);
3473 * If there are other client discoveries in progress, then leave
3474 * it active. If not, then make sure to stop the restart timeout.
3476 DBG("adapter->discovery_list[%p] adapter->le_discovery_list[%p]",
3477 adapter->discovery_list, adapter->le_discovery_list);
3478 if (adapter->discovery_list || adapter->le_discovery_list)
3481 hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
3482 hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
3484 DBG("Restart Timer... adapter->discovery_type[%d]", adapter->discovery_type);
3485 if (adapter->discovery_idle_timeout > 0) {
3486 g_source_remove(adapter->discovery_idle_timeout);
3487 adapter->discovery_idle_timeout = 0;
3490 discovery_cleanup(adapter, 0);
3493 static void le_discovery_disconnect(DBusConnection *conn, void *user_data)
3495 struct discovery_client *client = user_data;
3496 struct btd_adapter *adapter = client->adapter;
3497 struct mgmt_cp_stop_le_discovery cp;
3499 DBG("owner %s", client->owner);
3501 adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3505 * There is no need for extra cleanup of the client since that
3506 * will be done by the destroy callback.
3508 * However in case this is the last client, the discovery in
3509 * the kernel needs to be disabled.
3511 if (adapter->le_discovery_list)
3515 * In the idle phase of a discovery, there is no need to stop it
3516 * and so it is enough to send out the signal and just return.
3518 if (adapter->discovery_enable == 0x00) {
3519 adapter->le_discovering = false;
3520 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3521 ADAPTER_INTERFACE, "LEDiscovering");
3523 if (adapter->discovering == false && adapter->le_discovering == false) {
3524 trigger_passive_scanning(adapter);
3531 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
3532 adapter->dev_id, sizeof(cp), &cp,
3533 stop_le_discovery_complete, adapter, NULL);
3536 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
3537 static void addr_filter_params_free(gpointer data)
3539 adapter_le_address_filter_params_t *params = data;
3544 static void uuid_filter_params_free(gpointer data)
3546 adapter_le_uuid_params_t *params = data;
3548 g_free((char *)params->uuid);
3549 g_free((char *)params->uuid_mask);
3553 static void manufacturer_filter_params_free(gpointer data)
3555 adapter_le_manf_data_params_t *params = data;
3557 g_free((char *)params->man_data);
3558 g_free((char *)params->man_data_mask);
3562 static void local_name_filter_params_free(gpointer data)
3564 adapter_le_local_name_params_t *params = data;
3566 g_free((char *)params->local_name);
3570 static void service_data_filter_params_free(gpointer data)
3572 adapter_le_service_data_params_t *params = data;
3574 g_free((char *)params->service_data);
3575 g_free((char *)params->service_data_mask);
3579 static void scan_filter_params_free(gpointer data)
3581 adapter_le_scan_filter_param_t *params = data;
3585 int adapter_le_address_cmp(gconstpointer a, gconstpointer b)
3587 const adapter_le_address_filter_params_t *params = a;
3588 const char *address = b;
3591 ba2str(¶ms->broadcaster_addr, addr);
3592 return strcasecmp(addr, address);
3595 int adapter_le_uuid_cmp(gconstpointer a, gconstpointer b)
3597 const adapter_le_uuid_params_t *params = a;
3598 const char *uuid = b;
3600 return strcasecmp((const char *)params->uuid, uuid);
3603 int adapter_le_manufacturer_data_cmp(gconstpointer a, gconstpointer b)
3605 const adapter_le_manf_data_params_t *params = a;
3606 const struct eir_msd *msd = b;
3608 if (msd->company == params->company_id) {
3609 /* if the advertisiement packet is an iBeacon */
3610 if (msd->company == COMPANY_ID_APPLE)
3612 return strncasecmp((const char *)params->man_data,
3613 (const char *)msd->data,
3614 params->man_data_len);
3620 int adapter_le_local_name_cmp(gconstpointer a, gconstpointer b)
3622 const adapter_le_local_name_params_t *params = a;
3623 const char *name = b;
3625 return strcasecmp(params->local_name, name);
3628 int adapter_le_service_data_cmp(gconstpointer a, gconstpointer b)
3630 const adapter_le_service_data_params_t *params = a;
3631 const struct eir_sd *sd = b;
3632 /* Todo, the service data format for 16 bit, 32bit and
3633 * 128 bit uuids needs to addressed */
3634 return strncasecmp((const char *)(params->service_data),
3635 (const char *)sd->data,
3639 int adapter_le_address_filter_index_cmp(gconstpointer a, gconstpointer b)
3641 const adapter_le_address_filter_params_t *params = a;
3642 uint16_t filter_inex = GPOINTER_TO_UINT(b);
3644 return params->filter_index - filter_inex;
3647 int adapter_le_uuid_filter_index_cmp(gconstpointer a, gconstpointer b)
3649 const adapter_le_uuid_params_t *params = a;
3650 uint16_t filter_inex = GPOINTER_TO_UINT(b);
3652 return params->filter_index - filter_inex;
3655 int adapter_le_manufacturer_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3657 const adapter_le_manf_data_params_t *params = a;
3658 uint16_t filter_inex = GPOINTER_TO_UINT(b);
3660 return params->filter_index - filter_inex;
3663 int adapter_le_local_name_filter_index_cmp(gconstpointer a, gconstpointer b)
3665 const adapter_le_local_name_params_t *params = a;
3666 uint16_t filter_inex = GPOINTER_TO_UINT(b);
3668 return params->filter_index - filter_inex;
3671 int adapter_le_service_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3673 const adapter_le_service_data_params_t *params = a;
3674 uint16_t filter_inex = GPOINTER_TO_UINT(b);
3676 return params->filter_index - filter_inex;
3679 int adapter_le_scan_params_filter_index_cmp(gconstpointer a, gconstpointer b)
3681 const adapter_le_scan_filter_param_t *params = a;
3682 uint16_t filter_inex = GPOINTER_TO_UINT(b);
3684 return params->index - filter_inex;
3687 static gboolean adapter_le_clear_platform_scan_filter_data(
3688 struct btd_adapter *adapter, int filter_index)
3695 list = g_slist_find_custom(adapter->addr_filters,
3696 GINT_TO_POINTER(filter_index), adapter_le_address_filter_index_cmp);
3697 if (list && list->data) {
3698 /* Delete info from the struct to list */
3699 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3701 list = g_slist_find_custom(adapter->service_data_changed_filters,
3702 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3703 if (list && list->data) {
3704 /* Delete info from the struct to list */
3705 adapter->service_data_changed_filters = g_slist_delete_link(adapter->service_data_changed_filters, list);
3708 list = g_slist_find_custom(adapter->service_uuid_filters,
3709 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3710 if (list && list->data) {
3711 /* Delete info from the struct to list */
3712 adapter->service_uuid_filters = g_slist_delete_link(adapter->service_uuid_filters, list);
3715 list = g_slist_find_custom(adapter->solicit_data_filters,
3716 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3717 if (list && list->data) {
3718 /* Delete info from the struct to list */
3719 adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3722 list = g_slist_find_custom(adapter->local_name_filters,
3723 GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
3724 if (list && list->data) {
3725 /* Delete info from the struct to list */
3726 adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
3729 list = g_slist_find_custom(adapter->manufaturer_data_filters,
3730 GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3731 if (list && list->data) {
3732 /* Delete info from the struct to list */
3733 adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3736 list = g_slist_find_custom(adapter->service_data_filters,
3737 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3738 if (list && list->data) {
3739 /* Delete info from the struct to list */
3740 adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
3743 list = g_slist_find_custom(adapter->scan_params,
3744 GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
3745 if (list && list->data) {
3746 /* Delete info from the struct to list */
3747 adapter->scan_params = g_slist_delete_link(adapter->scan_params, list);
3753 static gboolean adapter_le_enable_platform_scan_filtering(
3754 struct btd_adapter *adapter, gboolean enable)
3759 DBG("Platform scan filtering enable[%d]", enable);
3761 adapter->scan_filter_support = enable;
3767 static gboolean adapter_le_service_add_addr_scan_filter_data(struct btd_adapter *adapter,
3768 int filter_index, gchar *string, int addr_type)
3770 /* TYPE_DEVICE_ADDRESS */
3771 adapter_le_address_filter_params_t *params;
3775 params = g_new0(adapter_le_address_filter_params_t, 1);
3779 params->filter_index = filter_index;
3780 str2ba(string, ¶ms->broadcaster_addr);
3781 params->bdaddr_type = addr_type;
3783 /* Store the struct to list */
3784 adapter->addr_filters = g_slist_append(adapter->addr_filters, params);
3788 static const char *adapter_le_service_find_addr_scan_filter_data(
3789 struct btd_adapter *adapter, gchar *string)
3794 list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3803 static gboolean adapter_le_service_delete_addr_scan_filter_data(struct btd_adapter *adapter,
3804 int filter_index, gchar *string, int addr_type)
3809 list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3813 /* Delete info from the struct to list */
3814 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3819 static gboolean adapter_le_service_clear_addr_scan_filter_data(struct btd_adapter *adapter)
3823 g_slist_free_full(adapter->addr_filters, addr_filter_params_free);
3824 adapter->addr_filters = NULL;
3829 static gboolean adapter_le_service_add_uuid_scan_filter_data(struct btd_adapter *adapter,
3830 int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3831 uint8_t *p_uuid_mask, int uuid_mask_len)
3834 adapter_le_uuid_params_t *params;
3839 params = g_new0(adapter_le_uuid_params_t, 1);
3843 if (uuid_mask_len == UUID_16_LEN) {
3844 uint16_t *uuid16 = (void *)p_uuid;
3845 sdp_uuid16_create((uuid_t *)&uuid, get_be16(uuid16));
3846 } else if (uuid_mask_len == UUID_32_LEN) {
3847 uint32_t *uuid32 = (void *)p_uuid;
3848 sdp_uuid32_create((uuid_t *)&uuid, get_be32(uuid32));
3850 sdp_uuid128_create((uuid_t *)&uuid, p_uuid);
3852 params->filter_index = filter_index;
3853 params->uuid = (uint8_t *)bt_uuid2string((uuid_t *)&uuid);
3854 params->uuid_mask = g_new0(uint8_t, uuid_mask_len);
3855 memcpy(params->uuid_mask, p_uuid_mask, uuid_mask_len);
3856 params->uuid_len = uuid_mask_len;
3858 /* Store the struct to list */
3859 adapter->solicit_data_filters = g_slist_append(adapter->solicit_data_filters, params);
3864 static adapter_le_uuid_params_t *adapter_le_service_find_uuid_scan_filter_data(struct btd_adapter *adapter,
3870 list = g_slist_find_custom(adapter->solicit_data_filters, p_uuid, adapter_le_uuid_cmp);
3874 /* Delete info from the struct to list */
3880 static gboolean adapter_le_service_delete_uuid_scan_filter_data(struct btd_adapter *adapter,
3881 int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3882 uint8_t *p_uuid_mask, int uuid_mask_len)
3887 list = g_slist_find_custom(adapter->solicit_data_filters, GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3891 adapter_le_uuid_params_t *params = list->data;
3892 /* Delete info from the struct to list */
3893 if (params && strcasecmp((const char *)params->uuid, (const char *)p_uuid)) {
3894 adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3901 static gboolean adapter_le_service_clear_uuid_scan_filter_data(struct btd_adapter *adapter)
3905 g_slist_free_full(adapter->solicit_data_filters, uuid_filter_params_free);
3906 adapter->solicit_data_filters = NULL;
3911 static gboolean adapter_le_service_add_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3912 int filter_index, int company_id, int company_id_mask,
3913 uint8_t *p_data, uint8_t *p_mask, int data_len)
3916 adapter_le_manf_data_params_t *params;
3920 params = g_new0(adapter_le_manf_data_params_t, 1);
3924 params->filter_index = filter_index;
3925 params->company_id = company_id;
3926 params->company_id_mask = company_id_mask;
3927 params->man_data = g_new0(uint8_t, data_len);
3928 memcpy(params->man_data, p_data, data_len);
3929 params->man_data_mask = g_new0(uint8_t, data_len);
3930 memcpy(params->man_data_mask, p_mask, data_len);
3931 params->man_data_len = data_len;
3933 /* Store the struct to list */
3934 adapter->manufaturer_data_filters = g_slist_append(adapter->manufaturer_data_filters, params);
3939 static adapter_le_manf_data_params_t *adapter_le_service_find_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3940 struct eir_msd *msd)
3944 list = g_slist_find_custom(adapter->manufaturer_data_filters, msd, adapter_le_manufacturer_data_cmp);
3953 static gboolean adapter_le_service_delete_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3954 int filter_index, int company_id, int company_id_mask,
3955 uint8_t *p_data, uint8_t *p_mask, int data_len)
3959 list = g_slist_find_custom(adapter->manufaturer_data_filters, GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3963 adapter_le_manf_data_params_t *params = list->data;
3964 /* Delete info from the struct to list */
3965 if (params && strcasecmp((const char *)params->man_data, (const char *)p_data)) {
3966 adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3973 static gboolean adapter_le_service_clear_manufacturer_scan_filter_data(struct btd_adapter *adapter)
3977 g_slist_free_full(adapter->manufaturer_data_filters, manufacturer_filter_params_free);
3978 adapter->manufaturer_data_filters = NULL;
3983 static gboolean adapter_le_service_add_local_name_scan_filter_data(struct btd_adapter *adapter,
3984 int filter_index, gchar *name)
3987 adapter_le_local_name_params_t *params;
3991 params = g_new0(adapter_le_local_name_params_t, 1);
3995 params->filter_index = filter_index;
3996 params->local_name = g_strdup(name);
3997 params->name_len = strlen(name);
3999 /* Store the struct to list */
4000 adapter->local_name_filters = g_slist_append(adapter->local_name_filters, params);
4005 static adapter_le_local_name_params_t *adapter_le_service_find_local_name_scan_filter_data(
4006 struct btd_adapter *adapter,
4011 list = g_slist_find_custom(adapter->local_name_filters, name, adapter_le_local_name_cmp);
4020 static gboolean adapter_le_service_delete_local_name_scan_filter_data(struct btd_adapter *adapter,
4021 int filter_index, gchar *name)
4025 list = g_slist_find_custom(adapter->local_name_filters, GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
4029 adapter_le_local_name_params_t *params = list->data;
4030 /* Delete info from the struct to list */
4031 if (params && strcasecmp((const char *)params->local_name, (const char *)name)) {
4032 adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
4039 static gboolean adapter_le_service_clear_local_name_scan_filter_data(struct btd_adapter *adapter)
4043 g_slist_free_full(adapter->local_name_filters, local_name_filter_params_free);
4044 adapter->local_name_filters = NULL;
4049 static gboolean adapter_le_service_add_service_scan_filter_data(struct btd_adapter *adapter,
4050 int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
4052 adapter_le_service_data_params_t *params;
4056 params = g_new0(adapter_le_service_data_params_t, 1);
4060 params->filter_index = filter_index;
4061 params->service_data = g_new0(uint8_t, data_len);
4062 memcpy(params->service_data, p_data, data_len);
4063 params->service_data_mask = g_new0(uint8_t, data_len);
4064 memcpy(params->service_data_mask, p_mask, data_len);
4065 params->service_data_len = data_len;
4067 /* Store the struct to list */
4068 adapter->service_data_filters = g_slist_append(adapter->service_data_filters, params);
4073 static adapter_le_service_data_params_t* adapter_le_service_find_service_scan_filter_data(
4074 struct btd_adapter *adapter, struct eir_sd *sd)
4079 list = g_slist_find_custom(adapter->service_data_filters, sd, adapter_le_service_data_cmp);
4088 static gboolean adapter_le_service_delete_service_scan_filter_data(struct btd_adapter *adapter,
4089 int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
4094 list = g_slist_find_custom(adapter->service_data_filters, GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
4098 adapter_le_service_data_params_t *params = list->data;
4099 /* Delete info from the struct to list */
4100 if (params && strcasecmp((const char *)params->service_data, (const char *)p_data)) {
4101 adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
4107 static gboolean adapter_le_service_clear_service_scan_filter_data(struct btd_adapter *adapter)
4111 g_slist_free_full(adapter->service_data_filters, service_data_filter_params_free);
4112 adapter->service_data_filters = NULL;
4117 static gboolean adapter_le_service_add_scan_filter_params(struct btd_adapter *adapter,
4118 adapter_le_scan_filter_param_t *params)
4120 adapter_le_scan_filter_param_t *l_params;
4124 l_params = g_new0(adapter_le_scan_filter_param_t, 1);
4128 l_params->action = params->action;
4129 l_params->delivery_mode = params->delivery_mode;
4130 l_params->feature = params->feature;
4131 l_params->filter_logic_type = params->filter_logic_type;
4132 l_params->index = params->index;
4133 l_params->list_logic_type = params->list_logic_type;
4134 l_params->onfound_timeout = params->onfound_timeout;
4135 l_params->onfound_timeout_cnt = params->onfound_timeout_cnt;
4136 l_params->rssi_high_threshold = params->rssi_high_threshold;
4137 l_params->rssi_low_threshold = params->rssi_low_threshold;
4139 /* Store the struct to list */
4140 adapter->scan_params = g_slist_append(adapter->scan_params, l_params);
4145 static adapter_le_scan_filter_param_t *adapter_le_service_find_scan_filter_params(
4146 struct btd_adapter *adapter, int filter_index)
4151 list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
4160 static gboolean adapter_le_service_delete_scan_filter_params(struct btd_adapter *adapter,
4161 adapter_le_scan_filter_param_t *params)
4166 list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(params->index), adapter_le_scan_params_filter_index_cmp);
4170 adapter->scan_params = g_slist_remove(adapter->scan_params, list);
4175 static gboolean adapter_le_service_clear_scan_filter_params(struct btd_adapter *adapter)
4179 g_slist_free_full(adapter->scan_params, scan_filter_params_free);
4180 adapter->scan_params = NULL;
4185 int adapter_byte_arr_cmp_with_mask(const char *data1, const char *data2,
4186 const char *mask, int data_len)
4190 if (data1 == NULL || data2 == NULL || mask == NULL)
4192 for (i = 0; i < data_len; i++) {
4193 a = data1[i] & mask[i];
4194 b = data2[i] & mask[i];
4196 return (int)(a - b);
4201 static uint8_t validate_for_filter_policy(struct btd_adapter *adapter,
4202 const struct eir_data *eir, gchar *addr)
4204 uint8_t allow_report = NONE_REPORT;
4206 if (adapter->scan_filter_support == FALSE)
4207 allow_report = SCAN_REPORT;
4209 if (adapter_le_service_find_addr_scan_filter_data(adapter, addr))
4210 allow_report = SCAN_REPORT;
4212 if(adapter_le_service_find_local_name_scan_filter_data(adapter, eir->name))
4213 allow_report = SCAN_REPORT;
4216 GSList *list = NULL;
4217 for (list = eir->sd_list; list != NULL; list = g_slist_next(list)) {
4218 struct eir_sd *sd = list->data;
4220 static adapter_le_uuid_params_t *uuid_data = NULL;
4221 static adapter_le_service_data_params_t *service_data = NULL;
4222 static adapter_le_scan_filter_param_t *scan_param_data = NULL;
4223 uuid_data = adapter_le_service_find_uuid_scan_filter_data(adapter, (uint8_t *)sd->uuid);
4224 service_data = adapter_le_service_find_service_scan_filter_data(adapter, sd);
4225 if (service_data != NULL) {
4226 if (!adapter_byte_arr_cmp_with_mask((const char *)service_data->service_data,
4227 (const char *)sd->data, (const char *)service_data->service_data_mask,
4228 service_data->service_data_len)) {
4229 scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4230 service_data->filter_index);
4231 if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4232 scan_param_data->rssi_low_threshold < eir->tx_power)
4233 allow_report = SCAN_REPORT;
4236 if (uuid_data != NULL) {
4237 if (!adapter_byte_arr_cmp_with_mask((const char *)uuid_data->uuid,
4238 (const char *)sd->uuid, (const char *)uuid_data->uuid_mask,
4239 uuid_data->uuid_len)) {
4240 scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4241 uuid_data->filter_index);
4242 if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4243 scan_param_data->rssi_low_threshold < eir->tx_power)
4244 allow_report = SCAN_REPORT;
4252 if (eir->msd_list) {
4253 GSList *list = NULL;
4254 for (list = eir->msd_list; list != NULL; list = g_slist_next(list)) {
4255 struct eir_msd *msd = list->data;
4257 static adapter_le_manf_data_params_t *manuf_data;
4258 static adapter_le_scan_filter_param_t *scan_param_data = NULL;
4259 manuf_data = adapter_le_service_find_manufacturer_scan_filter_data(adapter,
4261 if (manuf_data != NULL) {
4262 if (!adapter_byte_arr_cmp_with_mask((const char *)msd->data,
4263 (const char *)manuf_data->man_data, (const char *)manuf_data->man_data_mask,
4264 manuf_data->man_data_len)) {
4265 scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4266 manuf_data->filter_index);
4267 if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4268 scan_param_data->rssi_low_threshold < eir->tx_power)
4269 allow_report = SCAN_REPORT;
4271 if (msd->company == COMPANY_ID_APPLE)
4272 allow_report = IBEACON_REPORT;
4278 return allow_report;
4281 gboolean adapter_le_set_platform_scan_filter_params(struct btd_adapter *adapter,
4282 adapter_le_scan_filter_param_t *params)
4284 gboolean ret = TRUE;
4285 DBG("adapter_le_scan_filter_param_t [%d]", params->index);
4286 adapter_le_scan_filter_action_type action_type = params->action;
4288 if (action_type == ADD) {
4289 ret = adapter_le_service_add_scan_filter_params(adapter, params);
4290 } else if (action_type == DELETE) {
4291 ret = adapter_le_service_delete_scan_filter_params(adapter, params);
4292 } else if (action_type == CLEAR) {
4293 ret = adapter_le_service_clear_scan_filter_params(adapter);
4295 DBG("filter_action error");
4299 DBG("Scan Filter VSC :: Action [%x]",
4304 gboolean adapter_le_set_platform_scan_filter_data(struct btd_adapter *adapter,
4305 int client_if, int action,
4306 int filt_type, int filter_index,
4308 int company_id_mask,
4309 int uuid_len, uint8_t *p_uuid,
4310 int uuid_mask_len, uint8_t *p_uuid_mask,
4311 gchar *string, int addr_type,
4312 int data_len, uint8_t *p_data,
4313 int mask_len, uint8_t *p_mask)
4315 gboolean ret = TRUE;
4319 switch (filt_type) {
4320 case TYPE_DEVICE_ADDRESS: {
4321 /* TYPE_DEVICE_ADDRESS */
4322 adapter_le_scan_filter_action_type action_type = action;
4324 if (action_type == ADD) {
4325 ret = adapter_le_service_add_addr_scan_filter_data(adapter,
4326 filter_index, string, addr_type);
4327 } else if (action_type == DELETE) {
4328 ret = adapter_le_service_delete_addr_scan_filter_data(adapter,
4329 filter_index, string, addr_type);
4330 } else if (action_type == CLEAR) {
4331 ret = adapter_le_service_clear_addr_scan_filter_data(adapter);
4333 DBG("filter_action error");
4340 case TYPE_SERVICE_UUID:
4341 case TYPE_SOLICIT_UUID: {
4342 adapter_le_scan_filter_action_type action_type = action;
4344 gboolean is_solicited = (filt_type == TYPE_SOLICIT_UUID) ? TRUE : FALSE;
4346 if (uuid_len != UUID_16_LEN && uuid_len != UUID_32_LEN
4347 && uuid_len != UUID_128_LEN) {
4348 DBG("UUID length error");
4352 if (uuid_len != uuid_mask_len) {
4353 DBG("Both UUID and UUID_MASK length shoule be samed");
4357 if (action_type == ADD) {
4358 ret = adapter_le_service_add_uuid_scan_filter_data(adapter,
4359 filter_index, is_solicited, p_uuid,
4360 p_uuid_mask, uuid_len);
4361 } else if (action_type == DELETE) {
4362 ret = adapter_le_service_delete_uuid_scan_filter_data(adapter,
4363 filter_index, is_solicited, p_uuid,
4364 p_uuid_mask, uuid_len);
4365 } else if (action_type == CLEAR) {
4366 ret = adapter_le_service_clear_uuid_scan_filter_data(adapter);
4368 DBG("filter_action error");
4375 case TYPE_LOCAL_NAME: {
4376 adapter_le_scan_filter_action_type action_type = action;
4378 if (action_type == ADD) {
4379 ret = adapter_le_service_add_local_name_scan_filter_data(adapter,
4380 filter_index, (gchar*)string);
4381 } else if (action_type == DELETE) {
4382 ret = adapter_le_service_delete_local_name_scan_filter_data(adapter,
4383 filter_index, (gchar*)string);
4384 } else if (action_type == CLEAR) {
4385 ret = adapter_le_service_clear_local_name_scan_filter_data(adapter);
4387 DBG("filter_action error");
4394 case TYPE_MANUFACTURER_DATA: {
4395 adapter_le_scan_filter_action_type action_type = action;
4397 if (data_len == 0 || (data_len != mask_len)) {
4398 DBG("parameter length error");
4402 if (action_type == ADD) {
4403 ret = adapter_le_service_add_manufacturer_scan_filter_data(adapter,
4404 filter_index,company_id, company_id_mask, p_data, p_mask, data_len);
4405 } else if (action_type == DELETE) {
4406 ret = adapter_le_service_delete_manufacturer_scan_filter_data(adapter,
4407 filter_index, company_id, company_id_mask, p_data, p_mask, data_len);
4408 } else if (action_type == CLEAR) {
4409 ret = adapter_le_service_clear_manufacturer_scan_filter_data(adapter);
4411 DBG("filter_action error");
4418 case TYPE_SERVICE_DATA: {
4419 adapter_le_scan_filter_action_type action_type = action;
4421 if (data_len == 0 || (data_len != mask_len)) {
4422 DBG("parameter length error");
4426 if (action_type == ADD) {
4427 ret = adapter_le_service_add_service_scan_filter_data(adapter,
4428 filter_index, p_data, p_mask, data_len);
4429 } else if (action_type == DELETE) {
4430 ret = adapter_le_service_delete_service_scan_filter_data(adapter,
4431 filter_index, p_data, p_mask, data_len);
4432 } else if (action_type == CLEAR) {
4433 ret = adapter_le_service_clear_service_scan_filter_data(adapter);
4435 DBG("filter_action error");
4443 DBG("filter_type error");
4451 static bool is_set_adv_data_flag(uint8_t *data, int data_len)
4454 for (int i = 0; i < data_len; i++) {
4455 adv_type = data[i + 1];
4456 if (adv_type == EIR_FLAGS)
4464 static int set_adv_data_flag(uint8_t *adv_data, uint8_t *data, int data_len, void *user_data)
4466 struct btd_adapter *adapter = user_data;
4468 if (is_set_adv_data_flag(data, data_len))
4472 adv_data[1] = EIR_FLAGS;
4474 if (adapter->le_static_addr.b[5] != 0)
4475 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER |
4476 EIR_SIM_HOST | EIR_BREDR_UNSUP;
4478 if (TIZEN_FEATURE_BLUEZ_DA) {
4479 DBG("Disable LE General Discoverable Mode");
4480 adv_data[2] = EIR_CONTROLLER | EIR_SIM_HOST;
4482 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER | EIR_SIM_HOST;
4485 memcpy(adv_data + 3, data, data_len);
4486 return data_len + 3;
4489 static int set_adv_data_device_name(uint8_t *adv_data, int adv_len, char *name)
4495 uint8_t *data = NULL;
4500 data = g_memdup(adv_data, adv_len);
4504 name_len = strlen(name);
4506 for (i = 0; i <adv_len ; i++) {
4508 ad_type = data[i + 1];
4510 if (ad_type == EIR_NAME_COMPLETE && ad_len == 1) {
4511 /* Move to last position and update local name */
4512 for (j = i; j < adv_len - 2; j++)
4513 adv_data[j] = data[j + 2];
4515 adv_data[j] = name_len + 1;
4516 if (name_len > ADV_DATA_MAX_LENGTH - adv_len) {
4517 adv_data[j] = ADV_DATA_MAX_LENGTH - adv_len + 1;
4518 adv_data[j + 1] = EIR_NAME_SHORT;
4519 memcpy(adv_data + j + 2, name, ADV_DATA_MAX_LENGTH - adv_len);
4521 return ADV_DATA_MAX_LENGTH;
4523 adv_data[j + 1] = EIR_NAME_COMPLETE;
4524 memcpy(adv_data + j + 2, name, name_len);
4526 return adv_len + name_len;
4530 memcpy(adv_data + i, &data[i], ad_len + 1);
4539 static int set_adv_data_tx_power(uint8_t *adv_data, int adv_len, int8_t tx_power)
4544 uint8_t *data = NULL;
4546 data = g_memdup(adv_data, adv_len);
4550 for (i = 0; i <adv_len ; i++) {
4552 ad_type = data[i + 1];
4554 if (ad_type == EIR_TX_POWER) {
4556 adv_data[i + 1] = EIR_TX_POWER;
4557 adv_data[i + 2] = tx_power;
4559 for(j = i + 2; j < adv_len; j++)
4560 adv_data[j + 1] = data[j];
4565 memcpy(adv_data + i, &data[i], ad_len + 1);
4575 static int adapter_le_set_missed_adv_data(uint8_t *p_data, uint8_t data_len,
4576 gboolean is_scan_rsp, char *adapter_name, int8_t tx_power, uint8_t **adv_data, int *adv_len,
4582 data = g_malloc0(ADV_DATA_MAX_LENGTH);
4583 memcpy(data, p_data, data_len);
4586 /* In case multi advertising, need to update the below AD type
4587 since it handled into kernel */
4589 len = set_adv_data_flag(data, p_data, data_len, user_data);
4592 len = set_adv_data_tx_power(data, len, tx_power);
4594 len = set_adv_data_device_name(data, len, adapter_name);
4601 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
4602 static DBusMessage *adapter_get_psm_l2cap_le(DBusConnection *conn,
4603 DBusMessage *msg, void *user_data)
4605 return get_psm_l2cap_le(conn, msg);
4608 static DBusMessage *adapter_listen_l2cap_le_socket(DBusConnection *conn,
4609 DBusMessage *msg, void *user_data)
4611 return listen_l2cap_le_socket(conn, msg, user_data);
4614 static DBusMessage *adapter_remove_l2cap_le_socket(DBusConnection *conn,
4615 DBusMessage *msg, void *user_data)
4617 return remove_l2cap_le_socket(conn, msg);
4622 static DBusMessage *adapter_start_custom_discovery(DBusConnection *conn,
4623 DBusMessage *msg, void *user_data)
4625 struct btd_adapter *adapter = user_data;
4626 const char *sender = dbus_message_get_sender(msg);
4627 struct discovery_client *client;
4629 const gchar *disc_type;
4631 DBG("sender %s", sender);
4633 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4634 return btd_error_not_ready(msg);
4636 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &disc_type,
4637 DBUS_TYPE_INVALID)) {
4638 return btd_error_invalid_args(msg);
4641 DBG("discovery type = %s", disc_type);
4643 /*Valid strings: "BREDR", "LE", "LE_BREDR" */
4644 if (g_strcmp0(disc_type, "BREDR") == 0)
4645 adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
4646 else if (g_strcmp0(disc_type, "LE") == 0)
4647 adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4648 else if (g_strcmp0(disc_type, "LE_BREDR") == 0)
4649 adapter->disc_type = BT_DISC_TYPE_LE_BREDR;
4651 return btd_error_invalid_args(msg);
4654 * Every client can only start one discovery, if the client
4655 * already started a discovery then return an error.
4657 list = g_slist_find_custom(adapter->discovery_list, sender,
4660 return btd_error_busy(msg);
4662 client = g_new0(struct discovery_client, 1);
4664 client->adapter = adapter;
4665 client->owner = g_strdup(sender);
4666 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4667 discovery_disconnect, client,
4670 adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
4674 * Just trigger the discovery here. In case an already running
4675 * discovery in idle phase exists, it will be restarted right
4678 trigger_start_discovery(adapter, 0);
4680 return dbus_message_new_method_return(msg);
4683 static DBusMessage *adapter_start_le_discovery(DBusConnection *conn,
4684 DBusMessage *msg, void *user_data)
4686 struct btd_adapter *adapter = user_data;
4687 const char *sender = dbus_message_get_sender(msg);
4688 struct discovery_client *client;
4691 DBG("sender %s", sender);
4693 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4694 return btd_error_not_ready(msg);
4697 * Every client can only start one discovery, if the client
4698 * already started a discovery then return an error.
4701 adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4702 DBG("adapter->disc_type[%d]", adapter->disc_type);
4703 DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4705 list = g_slist_find_custom(adapter->le_discovery_list, sender,
4708 return btd_error_busy(msg);
4710 client = g_new0(struct discovery_client, 1);
4712 client->adapter = adapter;
4713 client->owner = g_strdup(sender);
4714 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4715 le_discovery_disconnect, client,
4716 le_discovery_destroy);
4718 adapter->le_discovery_list = g_slist_prepend(adapter->le_discovery_list,
4722 * Just trigger the discovery here. In case an already running
4723 * discovery in idle phase exists, it will be restarted right
4726 trigger_start_le_discovery(adapter, 0);
4728 return dbus_message_new_method_return(msg);
4731 static DBusMessage *adapter_stop_le_discovery(DBusConnection *conn,
4732 DBusMessage *msg, void *user_data)
4734 struct btd_adapter *adapter = user_data;
4735 const char *sender = dbus_message_get_sender(msg);
4736 struct mgmt_cp_stop_le_discovery cp;
4737 struct discovery_client *client;
4740 DBG("sender %s", sender);
4742 if (adapter->le_discovery_idle_timeout > 0) {
4743 DBG("Remove LE scan trigger");
4744 g_source_remove(adapter->le_discovery_idle_timeout);
4745 adapter->le_discovery_idle_timeout = 0;
4748 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4749 return btd_error_not_ready(msg);
4751 list = g_slist_find_custom(adapter->le_discovery_list, sender,
4754 return btd_error_failed(msg, "No discovery started");
4756 client = list->data;
4758 adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4759 DBG("adapter->disc_type[%d]", adapter->disc_type);
4760 DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4762 cp.type = adapter->discovery_type;
4763 DBG("cp.type %d", cp.type);
4766 * As long as other discovery clients are still active, just
4767 * clenup client info and return success.
4769 DBG("adapter->le_discovery_list %p", adapter->le_discovery_list);
4770 if (g_slist_next(adapter->le_discovery_list)) {
4772 * The destroy function will cleanup the client information and
4773 * also remove it from the list of discovery clients.
4775 g_dbus_remove_watch(dbus_conn, client->watch);
4776 return dbus_message_new_method_return(msg);
4780 * In the idle phase of a discovery, there is no need to stop it
4781 * and so it is enough to send out the signal and just return.
4783 DBG("cp.type %d", cp.type);
4784 DBG("adapter->discovery_enable %d", adapter->discovery_enable);
4785 if (adapter->discovery_enable == 0x00) {
4786 adapter->le_discovering = false;
4787 g_dbus_remove_watch(dbus_conn, client->watch);
4788 g_dbus_emit_property_changed(dbus_conn, adapter->path,
4789 ADAPTER_INTERFACE, "LEDiscovering");
4791 trigger_passive_scanning(adapter);
4792 return dbus_message_new_method_return(msg);
4795 DBG("adapter->discovery_type %d", adapter->discovery_type);
4797 DBG("cp.type %d", cp.type);
4798 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
4799 adapter->dev_id, sizeof(cp), &cp,
4800 stop_le_discovery_complete, adapter, NULL);
4802 client->msg = dbus_message_ref(msg);
4806 static DBusMessage *adapter_set_advertising(DBusConnection *conn,
4807 DBusMessage *msg, void *data)
4809 struct btd_adapter *adapter = data;
4811 dbus_bool_t enable = FALSE;
4812 dbus_int32_t slot_id;
4814 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4815 return btd_error_not_ready(msg);
4817 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &enable,
4818 DBUS_TYPE_INT32, &slot_id,
4820 return btd_error_invalid_args(msg);
4822 if (adapter->adv_restart_timeout > 0)
4823 return btd_error_in_progress(msg);
4825 DBG("%s advertising slot_id %d", enable ? "Enable" : "Disable", slot_id);
4827 if (adapter_le_is_supported_multi_advertising() && slot_id > 0)
4828 err = adapter_le_enable_multi_adv(adapter, enable, slot_id);
4830 err = set_mode(adapter, MGMT_OP_SET_ADVERTISING, enable);
4833 return btd_error_failed(msg, "Set Advertising failed");
4836 create_advertiser(adapter, slot_id);
4838 if (err && slot_id > 0)
4839 advertising_state_changed(adapter, slot_id, enable);
4841 return dbus_message_new_method_return(msg);
4844 static DBusMessage *adapter_set_advertising_params(DBusConnection *conn,
4845 DBusMessage *msg, void *data)
4847 struct btd_adapter *adapter = data;
4848 struct mgmt_cp_set_advertising_params cp;
4849 dbus_uint32_t interval_min;
4850 dbus_uint32_t interval_max;
4851 dbus_uint32_t filter_policy;
4853 dbus_int32_t tx_power_level;
4854 dbus_int32_t slot_id;
4857 DBG("Set customised advertising parameters");
4859 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4860 return btd_error_not_ready(msg);
4862 if (!dbus_message_get_args(msg, NULL,
4863 DBUS_TYPE_UINT32, &interval_min,
4864 DBUS_TYPE_UINT32, &interval_max,
4865 DBUS_TYPE_UINT32, &filter_policy,
4866 DBUS_TYPE_UINT32, &type,
4867 DBUS_TYPE_INT32, &tx_power_level,
4868 DBUS_TYPE_INT32, &slot_id,
4870 return btd_error_invalid_args(msg);
4872 memset(&cp, 0, sizeof(cp));
4874 DBG("advertising interval min %x, max %x, filter %x type %x, tx power %d",
4875 interval_min, interval_max, filter_policy, type, tx_power_level);
4877 if (filter_policy > 0x03)
4878 return btd_error_invalid_args(msg);
4881 return btd_error_invalid_args(msg);
4883 if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4884 adapter_le_adv_inst_info_t *p_inst;
4885 adapter_le_adv_param_t *p_params;
4887 p_inst = g_malloc0(sizeof(adapter_le_adv_inst_info_t));
4888 p_params = g_malloc0(sizeof(adapter_le_adv_param_t));
4889 p_inst->inst_id = slot_id;
4890 p_params->adv_int_min = interval_min;
4891 p_params->adv_int_max = interval_max;
4892 p_params->adv_type = type;
4893 p_params->channel_map = 0x07; /* fixed channel :: will be used all */
4894 p_params->adv_filter_policy = filter_policy;
4895 p_params->tx_power = tx_power_level;
4897 if (adapter->current_settings & MGMT_SETTING_PRIVACY) {
4898 p_inst->bdaddr_type = 0x01;
4899 bacpy(&p_inst->bdaddr, &adapter->rpa);
4900 } else if (adapter->le_static_addr.b[5] != 0) {
4901 p_inst->bdaddr_type = 0x01;
4902 bacpy(&p_inst->bdaddr, &adapter->le_static_addr);
4904 p_inst->bdaddr_type = 0x00;
4905 bacpy(&p_inst->bdaddr, &adapter->bdaddr);
4908 ret = adapter_le_set_multi_adv_params(p_inst, p_params);
4914 return dbus_message_new_method_return(msg);
4916 return btd_error_failed(msg, "set advertising param failed");
4918 cp.interval_max = interval_max;
4919 cp.interval_min = interval_min;
4920 cp.filter_policy = filter_policy;
4923 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_PARAMS,
4924 adapter->dev_id, sizeof(cp), &cp,
4925 NULL, NULL, NULL) > 0)
4926 return dbus_message_new_method_return(msg);
4928 return btd_error_failed(msg, "set advertising param failed");
4932 static DBusMessage *adapter_set_advertising_data(DBusConnection *conn,
4933 DBusMessage *msg, void *data)
4935 struct btd_adapter *adapter = data;
4936 struct mgmt_cp_set_advertising_data cp;
4939 dbus_int32_t slot_id;
4940 uint8_t *adv_data = NULL;
4942 char *adapter_name = adapter->name;
4943 char le_name[MAX_NAME_LENGTH + 1] = { 0 };
4945 DBG("Set advertising data");
4947 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4948 return btd_error_not_ready(msg);
4950 if (!dbus_message_get_args(msg, NULL,
4951 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4952 DBUS_TYPE_INT32, &slot_id,
4954 return btd_error_invalid_args(msg);
4956 if (is_set_adv_data_flag(value, len)) {
4957 if (len > ADV_DATA_MAX_LENGTH)
4958 return btd_error_invalid_args(msg);
4960 if (len > ADV_DATA_MAX_LENGTH - 3)
4961 return btd_error_invalid_args(msg);
4964 if (adapter->le_static_addr.b[5] != 0) {
4967 g_strlcpy(le_name, adapter_name,
4968 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
4969 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
4972 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
4973 adapter_name = le_name;
4976 adapter_le_set_missed_adv_data(value, len, FALSE,
4977 adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
4979 if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4980 if (adapter_le_set_multi_adv_data(slot_id, FALSE, adv_len, adv_data)) {
4982 return dbus_message_new_method_return(msg);
4985 return btd_error_failed(msg, "set advertising data failed");
4988 memcpy(&cp, adv_data, adv_len);
4990 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_DATA,
4991 adapter->dev_id, adv_len,
4992 &cp, NULL, NULL, NULL) > 0) {
4994 return dbus_message_new_method_return(msg);
4998 return btd_error_failed(msg, "set advertising data failed");
5002 static DBusMessage *adapter_le_scan_filter_param_setup(DBusConnection *conn,
5003 DBusMessage *msg, void *data)
5005 struct btd_adapter *adapter = data;
5006 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5007 dbus_bool_t ctlr_filter_support = TRUE;
5009 dbus_int32_t client_if, action, filt_index;
5010 dbus_int32_t feat_seln, list_logic_type, filt_logic_type;
5011 dbus_int32_t rssi_high_thres, rssi_low_thres, dely_mode;
5012 dbus_int32_t found_timeout, lost_timeout, found_timeout_cnt;
5013 adapter_le_scan_filter_param_t params;
5016 DBG("adapter_le_scan_filter_param_setup");
5018 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5019 return btd_error_not_ready(msg);
5021 if (adapter_le_get_scan_filter_size() == 0)
5022 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5023 return btd_error_not_supported(msg);
5025 ctlr_filter_support = FALSE;
5028 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5029 DBUS_TYPE_INT32, &action,
5030 DBUS_TYPE_INT32, &filt_index,
5031 DBUS_TYPE_INT32, &feat_seln,
5032 DBUS_TYPE_INT32, &list_logic_type,
5033 DBUS_TYPE_INT32, &filt_logic_type,
5034 DBUS_TYPE_INT32, &rssi_high_thres,
5035 DBUS_TYPE_INT32, &rssi_low_thres,
5036 DBUS_TYPE_INT32, &dely_mode,
5037 DBUS_TYPE_INT32, &found_timeout,
5038 DBUS_TYPE_INT32, &lost_timeout,
5039 DBUS_TYPE_INT32, &found_timeout_cnt,
5041 return btd_error_invalid_args(msg);
5043 memset(¶ms, 0, sizeof(params));
5045 params.action = action;
5046 params.index = filt_index;
5047 params.feature = feat_seln;
5048 params.filter_logic_type = filt_logic_type;
5049 params.list_logic_type = list_logic_type;
5050 params.delivery_mode = dely_mode;
5051 params.rssi_high_threshold = rssi_high_thres;
5053 if (params.delivery_mode == ON_FOUND) {
5054 params.rssi_low_threshold = rssi_low_thres;
5055 params.onfound_timeout = found_timeout;
5056 params.onfound_timeout_cnt = found_timeout_cnt;
5057 params.onlost_timeout = lost_timeout;
5060 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5061 if (ctlr_filter_support)
5063 err = adapter_le_set_scan_filter_params(¶ms);
5064 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5066 err = adapter_le_set_platform_scan_filter_params(adapter, ¶ms);
5070 return btd_error_failed(msg, "Failed to scan filter param setup");
5072 return dbus_message_new_method_return(msg);
5075 static DBusMessage *adapter_le_scan_filter_add_remove(DBusConnection *conn,
5076 DBusMessage *msg, void *data)
5078 struct btd_adapter *adapter = data;
5079 struct btd_device *dev = NULL;
5080 dbus_int32_t client_if, action, filt_type, filt_index;
5081 dbus_int32_t company_id, company_id_mask;
5083 dbus_uint32_t address_type = 0;
5084 uint8_t addr_type = 0;
5087 uint8_t *p_uuid, *p_uuid_mask, *p_data, *p_mask;
5088 int32_t uuid_len = 0, uuid_mask_len = 0, data_len = 0, mask_len = 0;
5090 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5091 dbus_bool_t ctlr_filter_support = TRUE;
5094 DBG("adapter_le_scan_filter_add_remove");
5096 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5097 return btd_error_not_ready(msg);
5099 /* if controller does not support vendor specific scan filtering feature
5100 * then add the filter into platform supported scan filters.
5102 if (adapter_le_get_scan_filter_size() == 0) {
5103 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5104 return btd_error_not_supported(msg);
5106 ctlr_filter_support = FALSE;
5110 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5111 DBUS_TYPE_INT32, &action,
5112 DBUS_TYPE_INT32, &filt_type,
5113 DBUS_TYPE_INT32, &filt_index,
5114 DBUS_TYPE_INT32, &company_id,
5115 DBUS_TYPE_INT32, &company_id_mask,
5116 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid, &uuid_len,
5117 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid_mask, &uuid_mask_len,
5118 DBUS_TYPE_STRING, &str,
5119 DBUS_TYPE_UINT32, &address_type,
5120 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_data, &data_len,
5121 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_mask, &mask_len,
5123 return btd_error_invalid_args(msg);
5125 if (filt_type == TYPE_DEVICE_ADDRESS) {
5126 list = g_slist_find_custom(adapter->devices, str, device_rpa_cmp);
5128 list = g_slist_find_custom(adapter->devices, str,
5129 device_address_cmp);
5132 if (dev && device_get_rpa_exist(dev) == true) {
5133 ba2str(device_get_address(dev), string);
5134 if (btd_device_get_bdaddr_type(dev) == BDADDR_LE_PUBLIC)
5139 strncpy(string, str, sizeof(string) - 1);
5143 DBG("addr %s, type %d", string, addr_type);
5145 strncpy(string, str, sizeof(string) - 1 );
5148 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5149 if (ctlr_filter_support)
5151 err = adapter_le_set_scan_filter_data(client_if, action, filt_type,
5152 filt_index, company_id, company_id_mask,
5153 uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
5154 string, addr_type, data_len, p_data, mask_len, p_mask);
5155 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5157 err = adapter_le_set_platform_scan_filter_data(adapter, client_if, action, filt_type,
5158 filt_index, company_id, company_id_mask,
5159 uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
5160 string, addr_type, data_len, p_data, mask_len, p_mask);
5163 return btd_error_failed(msg, "Failed to add/remove filter");
5165 return dbus_message_new_method_return(msg);
5168 static DBusMessage *adapter_le_scan_filter_clear(DBusConnection *conn,
5169 DBusMessage *msg, void *data)
5171 struct btd_adapter *adapter = data;
5172 dbus_int32_t client_if = 0;
5173 dbus_int32_t filt_index = 0;
5175 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5176 dbus_bool_t ctlr_filter_support = TRUE;
5179 DBG("adapter_le_scan_filter_clear");
5181 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5182 return btd_error_not_ready(msg);
5184 if (adapter_le_get_scan_filter_size() == 0)
5185 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5186 return btd_error_not_supported(msg);
5188 ctlr_filter_support = FALSE;
5191 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5192 DBUS_TYPE_INT32, &filt_index,
5194 return btd_error_invalid_args(msg);
5196 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5197 if (ctlr_filter_support)
5199 err = adapter_le_clear_scan_filter_data(client_if, filt_index);
5200 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5202 err = adapter_le_clear_platform_scan_filter_data(adapter, filt_index);
5206 return btd_error_failed(msg, "Failed to clear filter");
5208 return dbus_message_new_method_return(msg);
5212 static DBusMessage *adapter_le_scan_filter_enable(DBusConnection *conn,
5213 DBusMessage *msg, void *data)
5215 struct btd_adapter *adapter = data;
5216 dbus_bool_t enable = FALSE;
5217 dbus_int32_t client_if = 0;
5219 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5220 dbus_bool_t ctlr_filter_support = TRUE;
5223 DBG("adapter_le_scan_filter_enable");
5225 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5226 return btd_error_not_ready(msg);
5228 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5229 /* if controller does not support vendor specific scan filtering feature
5230 * then enable platform supported scan filtering functionalites.
5233 if (adapter_le_get_scan_filter_size() == 0)
5234 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5235 return btd_error_not_supported(msg);
5237 ctlr_filter_support = FALSE;
5240 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5241 DBUS_TYPE_BOOLEAN, &enable,
5243 return btd_error_invalid_args(msg);
5245 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5246 if (ctlr_filter_support)
5248 err = adapter_le_enable_scan_filtering(enable);
5249 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5251 err = adapter_le_enable_platform_scan_filtering(adapter, enable);
5255 return btd_error_failed(msg, "Failed to enable scan filtering");
5257 return dbus_message_new_method_return(msg);
5260 static DBusMessage *adapter_le_set_scan_params(DBusConnection *conn,
5261 DBusMessage *msg, void *data)
5263 struct btd_adapter *adapter = data;
5264 struct mgmt_cp_le_set_scan_params cp;
5269 DBG("Set scan parameters");
5271 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5272 return btd_error_not_ready(msg);
5274 if (!dbus_message_get_args(msg, NULL,
5275 DBUS_TYPE_UINT32, &type,
5276 DBUS_TYPE_UINT32, &interval,
5277 DBUS_TYPE_UINT32, &window,
5279 return btd_error_invalid_args(msg);
5281 DBG("scan type %x, interval %x, window %x",
5282 type, interval, window);
5283 memset(&cp, 0, sizeof(cp));
5286 cp.interval = interval;
5288 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5289 adapter->scan_type = type;
5292 if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_SCAN_PARAMS,
5293 adapter->dev_id, sizeof(cp), &cp,
5294 NULL, NULL, NULL) > 0)
5295 return dbus_message_new_method_return(msg);
5297 return btd_error_failed(msg, "set scan parameters failed");
5300 static DBusMessage *adapter_set_scan_rsp_data(DBusConnection *conn,
5301 DBusMessage *msg, void *data)
5303 struct btd_adapter *adapter = data;
5304 struct mgmt_cp_set_scan_rsp_data cp;
5307 dbus_int32_t slot_id;
5308 uint8_t *adv_data = NULL;
5311 char *adapter_name = adapter->name;
5312 char le_name[MAX_NAME_LENGTH + 1] = { 0 };
5314 DBG("Set scan response data");
5316 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5317 return btd_error_not_ready(msg);
5319 if (!dbus_message_get_args(msg, NULL,
5320 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
5321 DBUS_TYPE_INT32, &slot_id,
5323 return btd_error_invalid_args(msg);
5325 if (len > SCAN_RESPONSE_DATA_LENGTH_MAX)
5326 return btd_error_invalid_args(msg);
5328 if (adapter->le_static_addr.b[5] != 0) {
5331 g_strlcpy(le_name, adapter_name,
5332 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
5333 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
5336 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
5337 adapter_name = le_name;
5340 adapter_le_set_missed_adv_data(value, len, TRUE,
5341 adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
5343 if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
5344 if (adapter_le_set_multi_adv_data(slot_id, TRUE, adv_len, (uint8_t *)adv_data)) {
5346 return dbus_message_new_method_return(msg);
5349 return btd_error_failed(msg, "set advertising data failed");
5352 memcpy(&cp, adv_data, adv_len);
5354 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_SCAN_RSP_DATA,
5355 adapter->dev_id, adv_len, &cp,
5356 NULL, NULL, NULL) > 0) {
5358 return dbus_message_new_method_return(msg);
5362 return btd_error_failed(msg, "set scan reponse data failed");
5366 static DBusMessage *adapter_add_device_white_list(DBusConnection *conn,
5367 DBusMessage *msg, void *data)
5369 struct btd_adapter *adapter = data;
5370 struct mgmt_cp_add_dev_white_list cp;
5371 const gchar *address;
5373 dbus_uint32_t address_type;
5374 struct btd_device *dev;
5376 DBG("Add device whie list");
5377 if (dbus_message_get_args(msg, NULL,
5378 DBUS_TYPE_STRING, &address,
5379 DBUS_TYPE_UINT32, &address_type,
5380 DBUS_TYPE_INVALID) == FALSE)
5381 return btd_error_invalid_args(msg);
5383 if (bachk(address) < 0)
5384 return btd_error_invalid_args(msg);
5386 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5387 return btd_error_not_ready(msg);
5389 DBG("addr %s, type %d", address, address_type);
5390 str2ba(address, &bdaddr);
5392 dev = btd_adapter_find_device(adapter, &bdaddr,
5393 address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5394 if (dev && device_get_rpa_exist(dev) == true) {
5395 if (adapter_le_is_supported_offloading() == FALSE) {
5396 error("Spec based command is not supported yet");
5397 return btd_error_not_supported(msg);
5400 /* Add IRK value to list */
5401 if (adapter_le_add_irk_to_list(device_get_irk_value(dev),
5402 device_get_address(dev),
5403 btd_device_get_bdaddr_type(dev))) {
5404 return dbus_message_new_method_return(msg);
5406 return btd_error_failed(msg, "Add LE IRK to list failed");
5410 memset(&cp, 0, sizeof(cp));
5412 cp.bdaddr_type = address_type;
5413 memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5415 if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEV_WHITE_LIST,
5416 adapter->dev_id, sizeof(cp), &cp,
5417 NULL, NULL, NULL) > 0)
5418 return dbus_message_new_method_return(msg);
5420 return btd_error_failed(msg, "add device white list failed");
5423 static DBusMessage *adapter_remove_device_white_list(DBusConnection *conn,
5424 DBusMessage *msg, void *data)
5426 struct btd_adapter *adapter = data;
5427 struct mgmt_cp_remove_dev_white_list cp;
5428 const gchar *address;
5430 dbus_uint32_t address_type;
5431 struct btd_device *dev;
5433 DBG("Remove device whie list");
5435 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5436 return btd_error_not_ready(msg);
5438 if (dbus_message_get_args(msg, NULL,
5439 DBUS_TYPE_STRING, &address,
5440 DBUS_TYPE_UINT32, &address_type,
5441 DBUS_TYPE_INVALID) == FALSE)
5442 return btd_error_invalid_args(msg);
5444 if (bachk(address) < 0)
5445 return btd_error_invalid_args(msg);
5447 DBG("addr %s, type %d", address, address_type);
5448 str2ba(address, &bdaddr);
5450 dev = btd_adapter_find_device(adapter, &bdaddr,
5451 address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5452 if (dev && device_get_rpa_exist(dev) == true) {
5453 if (adapter_le_is_supported_offloading() == FALSE) {
5454 error("Spec based command is not supported yet");
5455 return btd_error_not_supported(msg);
5458 /* Remove IRK value to list */
5459 if (adapter_le_remove_irk_to_list(device_get_address(dev),
5460 btd_device_get_bdaddr_type(dev))) {
5461 return dbus_message_new_method_return(msg);
5463 return btd_error_failed(msg, "Remove IRK is failed");
5467 memset(&cp, 0, sizeof(cp));
5469 cp.bdaddr_type = address_type;
5470 memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5472 if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEV_FROM_WHITE_LIST,
5473 adapter->dev_id, sizeof(cp), &cp,
5474 NULL, NULL, NULL) > 0)
5475 return dbus_message_new_method_return(msg);
5477 return btd_error_failed(msg, "remove device white list failed");
5480 static DBusMessage *adapter_clear_device_white_list(DBusConnection *conn,
5481 DBusMessage *msg, void *data)
5483 struct btd_adapter *adapter = data;
5485 DBG("Clear device whie list");
5487 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5488 return btd_error_not_ready(msg);
5490 if (mgmt_send(adapter->mgmt, MGMT_OP_CLEAR_DEV_WHITE_LIST,
5491 adapter->dev_id, 0, NULL,
5492 NULL, NULL, NULL) > 0)
5493 return dbus_message_new_method_return(msg);
5495 return btd_error_failed(msg, "clear white list failed");
5498 static DBusMessage *adapter_set_le_privacy(DBusConnection *conn,
5499 DBusMessage *msg, void *data)
5501 struct btd_adapter *adapter = data;
5503 dbus_bool_t enable_privacy = FALSE;
5505 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
5506 return btd_error_not_supported(msg);
5508 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
5509 &enable_privacy, DBUS_TYPE_INVALID))
5510 return btd_error_invalid_args(msg);
5512 if (enable_privacy) {
5513 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
5514 return btd_error_already_exists(msg);
5516 if (!(adapter->current_settings & MGMT_SETTING_PRIVACY))
5517 return btd_error_already_exists(msg);
5520 err = set_privacy(adapter, enable_privacy);
5523 return btd_error_failed(msg, "Set Le Privacy failed");
5526 adapter->current_settings = adapter->current_settings | MGMT_SETTING_PRIVACY;
5528 adapter->current_settings = adapter->current_settings & ~(SETTING_PRIVACY_MASK);
5531 return dbus_message_new_method_return(msg);
5534 static void init_le_static_address(struct btd_adapter *adapter)
5539 char dirname[PATH_MAX];
5541 bdaddr_t le_static_addr;
5543 le_static_addr.b[5] = adapter->bdaddr.b[5] | 0xc0;
5544 for (i = 0; i < 5; i++) {
5545 le_static_addr.b[i] =
5546 (adapter->bdaddr.b[i] & 0x7f) << 1 |
5547 (adapter->bdaddr.b[i] & 0x80) >> 7;
5551 * < How to get Public address from above static address >
5553 * for (i = 0; i < 5; i++) {
5555 * (adapter->le_static_addr.b[i] & 0xfe) >> 1 |
5556 * (adapter->le_static_addr.b[i] & 0x01) << 7;
5558 * bredr_addr.b[5] = {the value from advertising data}
5561 snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5562 fd = open(dirname, O_WRONLY | O_CREAT, 0644);
5565 ba2str(&le_static_addr, address);
5566 DBG("LE static random : %s", address);
5567 ret = write(fd, address, strlen(address));
5569 error("Cannot save LE address : %s",
5573 ret = fdatasync(fd);
5575 error("sync failed : %s", strerror(errno));
5579 error("Cannot save LE address");
5583 static void set_le_static_address(struct btd_adapter *adapter)
5588 char dirname[PATH_MAX];
5590 snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5591 if (access(dirname, F_OK) < 0)
5592 init_le_static_address(adapter);
5594 fd = open(dirname, O_RDONLY);
5596 ret = read(fd, address, sizeof(address));
5598 /* xx:xx:xx:xx:xx:xx */
5600 DBG("LE static random : %s", address);
5601 str2ba(address, &adapter->le_static_addr);
5602 adapter->le_static_addr.b[5] |= 0xc0;
5604 error("Invalid LE address");
5607 error("Cannot get LE address");
5613 static void set_le_static_address_complete(uint8_t status, uint16_t length,
5614 const void *param, void *user_data)
5616 struct btd_adapter *adapter = user_data;
5618 DBG("index %u status 0x%02x", adapter->dev_id, status);
5620 if (status != MGMT_STATUS_SUCCESS) {
5621 error("Failed to set static address for index %u: %s (0x%02x)",
5622 adapter->dev_id, mgmt_errstr(status), status);
5623 if (adapter->le_static_addr.b[5] != 0)
5624 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5626 set_le_static_address(adapter);
5633 static DBusMessage *adapter_set_le_static_address(DBusConnection *conn,
5634 DBusMessage *msg, void *data)
5636 struct btd_adapter *adapter = data;
5637 dbus_bool_t is_enable = FALSE;
5638 struct mgmt_cp_set_static_address cp;
5640 if (!(adapter->supported_settings & MGMT_OP_SET_STATIC_ADDRESS)) {
5641 error("LE static address is not supported");
5642 return btd_error_not_supported(msg);
5645 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &is_enable,
5646 DBUS_TYPE_INVALID)) {
5647 error("Invalid arguments");
5648 return btd_error_invalid_args(msg);
5651 memset(&cp, 0x00, sizeof(cp));
5653 if (adapter->le_static_addr.b[5] != 0) {
5654 DBG("LE static address is already configured");
5655 return dbus_message_new_method_return(msg);
5657 set_le_static_address(adapter);
5658 bacpy(&cp.bdaddr, &adapter->le_static_addr);
5660 if (adapter->le_static_addr.b[5] == 0) {
5661 DBG("LE static address is not configured");
5662 return dbus_message_new_method_return(msg);
5664 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5666 DBG("Set static random address : %d", is_enable);
5668 if (mgmt_send(mgmt_primary, MGMT_OP_SET_STATIC_ADDRESS, adapter->dev_id,
5670 set_le_static_address_complete, adapter, NULL) <= 0) {
5671 error("Failed to set static address : %d", is_enable);
5673 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5675 set_le_static_address(adapter);
5676 return btd_error_failed(msg, "Unable to set static address");
5679 return dbus_message_new_method_return(msg);
5682 static DBusMessage *adapter_enable_rssi(DBusConnection *conn,
5683 DBusMessage *msg, void *data)
5685 struct btd_adapter *adapter = data;
5686 struct mgmt_cp_set_enable_rssi cp;
5687 struct mgmt_cp_disable_rssi cp_dis;
5688 bdaddr_t bt_addr = { { 0, } };
5689 const gchar *address = NULL;
5691 const char *sender = dbus_message_get_sender(msg);
5692 dbus_int32_t link_type;
5693 dbus_int32_t low_threshold;
5694 dbus_int32_t in_range_threshold;
5695 dbus_int32_t high_threshold;
5697 DBG("Enable RSSI called");
5698 DBG("sender %s", sender);
5699 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5700 return btd_error_not_ready(msg);
5702 if (!dbus_message_get_args(msg, NULL,
5703 DBUS_TYPE_STRING, &address,
5704 DBUS_TYPE_INT32, &link_type,
5705 DBUS_TYPE_INT32, &low_threshold,
5706 DBUS_TYPE_INT32, &in_range_threshold,
5707 DBUS_TYPE_INT32, &high_threshold,
5709 return btd_error_invalid_args(msg);
5711 DBG("Enable RSSI: [%s %d %d %d %d]", address, link_type,
5712 low_threshold, in_range_threshold, high_threshold);
5714 DBG("BT address [%s]", address);
5715 memset(&bt_addr, 0, sizeof(bdaddr_t));
5716 str2ba(address, &bt_addr);
5717 memset(&cp, 0, sizeof(struct mgmt_cp_set_enable_rssi));
5718 memset(&cp_dis, 0, sizeof(struct mgmt_cp_disable_rssi));
5720 if (bachk(address) < 0)
5721 return btd_error_invalid_args(msg);
5723 // if (!btd_adapter_find_device(adapter, address))
5724 // return btd_error_not_found(msg);
5726 if (low_threshold == 0 && in_range_threshold == 0 && high_threshold == 0) {
5727 cp_dis.bdaddr = bt_addr;
5728 cp_dis.link_type = link_type;
5729 DBG("Disable Request");
5730 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_DISABLE,
5731 adapter->dev_id, sizeof(cp_dis), &cp_dis,
5732 NULL, NULL, NULL) > 0)
5733 return dbus_message_new_method_return(msg);
5735 cp.low_th = low_threshold;
5736 cp.in_range_th = in_range_threshold;
5737 cp.high_th = high_threshold;
5738 cp.bdaddr = bt_addr;
5739 cp.link_type = link_type;
5740 DBG("Enable Request");
5741 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_ENABLE,
5742 adapter->dev_id, sizeof(cp), &cp,
5743 NULL, NULL, NULL) > 0)
5744 return dbus_message_new_method_return(msg);
5746 return btd_error_failed(msg, "Enable/Disable RSSI Failed");
5749 static DBusMessage *adapter_get_rssi(DBusConnection *conn,
5750 DBusMessage *msg, void *data)
5752 struct btd_adapter *adapter = data;
5753 struct mgmt_cp_get_raw_rssi cp;
5755 const gchar *address = NULL;
5756 dbus_int32_t link_type;
5757 const char *sender = dbus_message_get_sender(msg);
5759 DBG("Get RSSI called");
5760 DBG("sender %s", sender);
5761 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5762 return btd_error_not_ready(msg);
5764 if (!dbus_message_get_args(msg, NULL,
5765 DBUS_TYPE_STRING, &address,
5766 DBUS_TYPE_INT32, &link_type,
5768 return btd_error_invalid_args(msg);
5770 DBG("BT address [%s] link type [%d]", address, link_type);
5771 memset(&bt_addr, 0, sizeof(bdaddr_t));
5772 str2ba(address, &bt_addr);
5773 memset(&cp, 0, sizeof(struct mgmt_cp_get_raw_rssi));
5775 if (bachk(address) < 0)
5776 return btd_error_invalid_args(msg);
5778 // if (!btd_adapter_find_device(adapter, address))
5779 // return btd_error_not_found(msg);
5781 memcpy(&(cp.bt_address), &bt_addr, sizeof(bdaddr_t));
5782 cp.link_type = link_type;
5783 DBG("RAW RSSI Request");
5784 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_RAW_RSSI,
5785 adapter->dev_id, sizeof(cp), &cp,
5786 NULL, NULL, NULL) > 0)
5787 return dbus_message_new_method_return(msg);
5789 return btd_error_failed(msg, "Get Raw RSSI Failed");
5792 #if !defined(__SPRD_PATCH__)
5793 static void get_adv_tx_power_complete(uint8_t status, uint16_t length,
5794 const void *param, void *user_data)
5796 struct btd_adapter *adapter = user_data;
5797 const struct mgmt_rp_get_adv_tx_power *rp = param;
5800 error("Error ocurred in Getting adv tx power, rp is NULL");
5804 if (status != MGMT_STATUS_SUCCESS) {
5805 error("Failed to get adv tx power: %s (0x%02x)",
5806 mgmt_errstr(status), status);
5810 if (length < sizeof(*rp)) {
5811 error("Wrong size of get adv tx power");
5815 adapter->adv_tx_power = rp->adv_tx_power;
5819 static void adapter_get_adv_tx_power(void *data)
5821 struct btd_adapter *adapter = data;
5823 mgmt_send(adapter->mgmt, MGMT_OP_GET_ADV_TX_POWER,
5824 adapter->dev_id, 0, NULL,
5825 get_adv_tx_power_complete, adapter, NULL);
5830 static DBusMessage *set_wbs_parameters(DBusConnection *conn,
5831 DBusMessage *msg, void *data)
5833 struct btd_adapter *adapter = data;
5834 const gchar *role = NULL;
5835 const gchar *address = NULL;
5836 struct mgmt_cp_set_voice_setting cp;
5837 bdaddr_t bt_addr = { { 0, } };
5841 if (!dbus_message_get_args(msg, NULL,
5842 DBUS_TYPE_STRING, &role,
5843 DBUS_TYPE_STRING, &address,
5844 DBUS_TYPE_INVALID)) {
5845 return btd_error_invalid_args(msg);
5848 DBG("Role = %s", role);
5849 DBG("Address = %s", address);
5851 memset(&cp, 0, sizeof(cp));
5853 cp.voice_setting = BT_VOICE_TRANSPARENT | BT_VOICE_CVSD_16BIT;
5855 if (g_strcmp0(role, "Handsfree") == 0)
5856 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5857 else if (g_strcmp0(role, "Gateway") == 0)
5858 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5860 str2ba(address, &bt_addr);
5861 memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5863 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5864 adapter->dev_id, sizeof(cp), &cp,
5865 NULL, NULL, NULL) == 0)
5866 error("mgmt_send failed for voice setting");
5869 return dbus_message_new_method_return(msg);
5872 static DBusMessage *set_nb_parameters(DBusConnection *conn,
5873 DBusMessage *msg, void *data)
5875 struct btd_adapter *adapter = data;
5877 const gchar *address = NULL;
5878 struct mgmt_cp_set_voice_setting cp;
5879 bdaddr_t bt_addr = { { 0, } };
5883 if (!dbus_message_get_args(msg, NULL,
5884 DBUS_TYPE_STRING, &role,
5885 DBUS_TYPE_STRING, &address,
5886 DBUS_TYPE_INVALID)) {
5887 return btd_error_invalid_args(msg);
5890 DBG("Role = %s", role);
5891 DBG("Address = %s", address);
5893 memset(&cp, 0, sizeof(cp));
5895 cp.voice_setting = BT_VOICE_CVSD_16BIT;
5897 if (g_strcmp0(role, "Handsfree") == 0)
5898 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5899 else if (g_strcmp0(role, "Gateway") == 0)
5900 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5902 str2ba(address, &bt_addr);
5903 memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5905 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5906 adapter->dev_id, sizeof(cp), &cp,
5907 NULL, NULL, NULL) == 0)
5908 error("mgmt_send failed for voice setting");
5912 return dbus_message_new_method_return(msg);
5915 void btd_adapter_set_read_le_data_length_handler(
5916 struct btd_adapter *adapter,
5917 struct le_data_length_read_handler *handler)
5919 adapter->read_handler = handler;
5922 static void le_read_maximum_data_length_return_param_complete(
5923 uint8_t status, uint16_t length,
5924 const void *param, void *user_data)
5926 struct btd_adapter *adapter = user_data;
5927 const struct mgmt_rp_le_read_maximum_data_length *rp = param;
5928 uint16_t max_tx_octects = 0;
5929 uint16_t max_tx_time = 0;
5930 uint16_t max_rx_octects = 0;
5931 uint16_t max_rx_time = 0;
5935 error("Error ocurred in Reading maximum data length, rp is NULL");
5940 if (status != MGMT_STATUS_SUCCESS) {
5941 error("le read maximum data length failed: %s (0x%02x)",
5942 mgmt_errstr(status), status);
5947 if (length < sizeof(*rp)) {
5948 error("Too small le read maximum data length response");
5952 max_tx_octects = rp->max_tx_octets;
5953 max_tx_time =rp->max_tx_time;
5954 max_rx_octects = rp->max_rx_octets;
5955 max_rx_time = rp->max_rx_time;
5959 if (!adapter->read_handler ||
5960 !adapter->read_handler->read_callback) {
5961 g_free(adapter->read_handler);
5965 adapter->read_handler->read_callback(adapter, err,
5966 max_tx_octects, max_tx_time,
5967 max_rx_octects, max_rx_time,
5968 adapter->read_handler->user_data);
5970 g_free(adapter->read_handler);
5971 adapter->read_handler = NULL;
5974 int btd_adapter_le_read_maximum_data_length(
5975 struct btd_adapter *adapter)
5977 if (mgmt_send(adapter->mgmt,
5978 MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
5979 adapter->dev_id, 0, NULL,
5980 le_read_maximum_data_length_return_param_complete,
5987 static gint read_request_cmp(gconstpointer a, gconstpointer b)
5989 const struct le_data_length_read_request *data = a;
5990 const struct btd_adapter *adapter = b;
5992 return data->adapter != adapter;
5995 static struct le_data_length_read_request *find_read_le_data_length_request(
5996 struct btd_adapter *adapter)
6000 match = g_slist_find_custom(read_requests, adapter, read_request_cmp);
6008 static void le_read_data_length_complete(
6009 struct btd_adapter *adapter,
6011 uint16_t max_tx_octects, uint16_t max_tx_time,
6012 uint16_t max_rx_octects, uint16_t max_rx_time,
6016 struct le_data_length_read_request *read_request;
6018 read_request = find_read_le_data_length_request(adapter);
6024 DBG("Failed to read max data length. errno[%d]", err);
6025 reply = btd_error_failed(read_request->msg,
6026 "Failed to read max data length");
6028 reply = g_dbus_create_reply(read_request->msg,
6029 DBUS_TYPE_UINT16, &max_tx_octects,
6030 DBUS_TYPE_UINT16, &max_tx_time,
6031 DBUS_TYPE_UINT16, &max_rx_octects,
6032 DBUS_TYPE_UINT16, &max_rx_time,
6036 reply = btd_error_failed(read_request->msg,
6037 "Failed to create reply.");
6041 read_requests = g_slist_remove(read_requests, read_request);
6042 dbus_message_unref(read_request->msg);
6043 g_free(read_request);
6045 if (!g_dbus_send_message(dbus_conn, reply))
6046 error("D-Bus send failed");
6049 static DBusMessage *le_read_maximum_data_length(
6050 DBusConnection *conn, DBusMessage *msg,
6053 struct btd_adapter *adapter = user_data;
6054 struct le_data_length_read_request *read_request;
6055 struct le_data_length_read_handler *handler;
6057 if (find_read_le_data_length_request(adapter))
6058 return btd_error_in_progress(msg);
6060 if (btd_adapter_le_read_maximum_data_length(adapter))
6061 return btd_error_failed(msg, "Unable to read maximum le data length");
6063 read_request = g_new(struct le_data_length_read_request, 1);
6065 read_request->msg = dbus_message_ref(msg);
6066 read_request->adapter = adapter;
6068 read_requests = g_slist_append(read_requests, read_request);
6070 handler = g_new0(struct le_data_length_read_handler, 1);
6072 handler->read_callback =
6073 (read_max_data_length_cb_t)le_read_data_length_complete;
6075 btd_adapter_set_read_le_data_length_handler(
6076 read_request->adapter, handler);
6082 void le_write_host_suggested_data_length_return_param_complete(
6083 uint8_t status, uint16_t length,
6084 const void *param, void *user_data)
6086 if (status != MGMT_STATUS_SUCCESS) {
6087 error("le write host suggested data length failed: %s (0x%02x)",
6088 mgmt_errstr(status), status);
6094 static DBusMessage *le_write_host_suggested_default_data_length(
6095 DBusConnection *conn, DBusMessage *msg,
6098 struct btd_adapter *adapter = user_data;
6099 struct mgmt_cp_le_write_host_suggested_data_length cp;
6100 dbus_uint16_t def_tx_Octets;
6101 dbus_uint16_t def_tx_time;
6103 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6104 return btd_error_not_ready(msg);
6106 if (!dbus_message_get_args(msg, NULL,
6107 DBUS_TYPE_UINT16, &def_tx_Octets,
6108 DBUS_TYPE_UINT16, &def_tx_time,
6110 return btd_error_invalid_args(msg);
6112 memset(&cp, 0, sizeof(cp));
6113 cp.def_tx_octets = def_tx_Octets;
6114 cp.def_tx_time = def_tx_time;
6116 if (mgmt_send(adapter->mgmt,
6117 MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
6118 adapter->dev_id, sizeof(cp), &cp,
6119 le_write_host_suggested_data_length_return_param_complete,
6121 return dbus_message_new_method_return(msg);
6123 return btd_error_failed(msg, "Unable to write host suggested le data length values");
6126 static void le_read_suggested_default_data_length_return_param_complete(
6127 uint8_t status, uint16_t length,
6128 const void *param, void *user_data)
6130 struct btd_adapter *adapter = user_data;
6131 const struct mgmt_rp_le_read_host_suggested_data_length *rp = param;
6132 uint16_t def_tx_octects, def_tx_time;
6135 error("Error ocurred in Reading suggested data length, rp is NULL");
6136 if (adapter->def_read_handler)
6137 g_free(adapter->def_read_handler->user_data);
6139 g_free(adapter->def_read_handler);
6143 if (status != MGMT_STATUS_SUCCESS) {
6144 error("Read host suggested def le data length values failed: %s (0x%02x)",
6145 mgmt_errstr(status), status);
6149 if (adapter->def_read_handler)
6150 g_free(adapter->def_read_handler->user_data);
6152 g_free(adapter->def_read_handler);
6156 if (length < sizeof(*rp)) {
6159 def_tx_octects = rp->def_tx_octets;
6160 def_tx_time =rp->def_tx_time;
6161 DBG("retrieving host suggested data length values %d %d", def_tx_octects, def_tx_time);
6164 if (!adapter->def_read_handler)
6167 if(!adapter->def_read_handler->read_callback) {
6171 adapter->def_read_handler->read_callback(adapter,
6172 def_tx_octects, def_tx_time,
6173 adapter->def_read_handler->user_data);
6175 if (adapter->def_read_handler)
6176 g_free(adapter->def_read_handler->user_data);
6178 g_free(adapter->def_read_handler);
6179 adapter->def_read_handler = NULL;
6182 int btd_adapter_le_read_suggested_default_data_length(
6183 struct btd_adapter *adapter)
6185 if (mgmt_send(adapter->mgmt,
6186 MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
6187 adapter->dev_id, 0, NULL,
6188 le_read_suggested_default_data_length_return_param_complete,
6189 adapter, NULL) > 0) {
6196 static void le_read_host_suggested_default_length_complete(
6197 struct btd_adapter *adapter,
6198 uint16_t def_tx_octects, uint16_t def_tx_time,
6202 struct le_data_length_read_request *read_request;
6204 read_request = find_read_le_data_length_request(adapter);
6208 reply = g_dbus_create_reply(read_request->msg,
6209 DBUS_TYPE_UINT16, &def_tx_octects,
6210 DBUS_TYPE_UINT16, &def_tx_time,
6214 btd_error_failed(read_request->msg,
6215 "Failed to read host suggested def data length values");
6219 read_requests = g_slist_remove(read_requests, read_request);
6220 dbus_message_unref(read_request->msg);
6221 g_free(read_request);
6223 if (!g_dbus_send_message(dbus_conn, reply))
6224 error("D-Bus send failed");
6227 static DBusMessage *le_read_host_suggested_default_data_length(
6228 DBusConnection *conn, DBusMessage *msg,
6231 struct btd_adapter *adapter = user_data;
6232 struct le_data_length_read_request *read_request;
6233 struct le_data_length_read_default_data_length_handler *handler;
6235 if (find_read_le_data_length_request(adapter))
6236 return btd_error_in_progress(msg);
6238 if (btd_adapter_le_read_suggested_default_data_length(adapter))
6239 return btd_error_failed(msg, "Unable to read host suggested def data length");
6241 read_request = g_new(struct le_data_length_read_request, 1);
6243 read_request->msg = dbus_message_ref(msg);
6244 read_request->adapter = adapter;
6246 read_requests = g_slist_append(read_requests, read_request);
6248 handler = g_new0(struct le_data_length_read_default_data_length_handler, 1);
6250 handler->read_callback =
6251 (read_host_suggested_default_data_length_cb_t)le_read_host_suggested_default_length_complete;
6253 read_request->adapter->def_read_handler = handler;
6258 static void get_le_batching_available_pkts_complete(
6259 uint8_t status, uint16_t length,
6260 const void *param, void *user_data)
6262 const struct mgmt_rp_get_le_batching_buffer *rp = param;
6263 struct le_batching_request *request =
6264 (struct le_batching_request*)user_data;
6267 if (status != MGMT_STATUS_SUCCESS) {
6268 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6269 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6270 reply = btd_error_not_supported(request->msg);
6272 reply = btd_error_failed(request->msg, mgmt_errstr(status));
6276 if (length < sizeof(*rp)) {
6277 reply = btd_error_failed(request->msg,
6278 "Wrong size of get le batching buffer");
6282 DBG("LE Batching buffer: [%u]", rp->buffer);
6283 request->adapter->le_batching_available_pkts = rp->buffer;
6284 reply = g_dbus_create_reply(request->msg,
6285 DBUS_TYPE_UINT32, &rp->buffer,
6288 reply = btd_error_failed(request->msg,
6289 "Failed to create reply.");
6292 if (!g_dbus_send_message(dbus_conn, reply))
6293 error("D-Bus send failed");
6295 dbus_message_unref(request->msg);
6299 static DBusMessage *adapter_get_le_batching_available_pkts(DBusConnection *conn,
6300 DBusMessage *msg, void *data)
6302 struct btd_adapter *adapter = data;
6303 struct le_batching_request *request;
6307 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6308 return btd_error_not_ready(msg);
6310 if (adapter->le_batching_available_pkts < 0)
6311 return btd_error_not_supported(msg);
6313 if (adapter->le_batching_available_pkts > 0) {
6314 reply = dbus_message_new_method_return(msg);
6318 val = adapter->le_batching_available_pkts;
6319 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &val,
6321 DBG("LE Batching buffer: [%u]", val);
6325 request = g_new(struct le_batching_request, 1);
6327 request->msg = dbus_message_ref(msg);
6328 request->adapter = adapter;
6330 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_LE_BATCHING_BUFFER,
6331 adapter->dev_id, 0, NULL,
6332 get_le_batching_available_pkts_complete, request, NULL) == 0) {
6333 dbus_message_unref(request->msg);
6335 return btd_error_failed(msg, "Unable to get le batching buffer");
6341 static void set_le_batching_enable_complete(
6342 uint8_t status, uint16_t length,
6343 const void *param, void *user_data)
6345 const struct mgmt_rp_set_le_batching_enable *rp = param;
6346 struct le_batching_request *request =
6347 (struct le_batching_request*)user_data;
6351 if (status != MGMT_STATUS_SUCCESS) {
6352 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6353 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6354 reply = btd_error_not_supported(request->msg);
6356 reply = btd_error_failed(request->msg, mgmt_errstr(status));
6360 if (length < sizeof(*rp)) {
6361 reply = btd_error_failed(request->msg,
6362 "Wrong size of set le batching enable");
6366 reply = g_dbus_create_reply(request->msg,
6369 reply = btd_error_failed(request->msg,
6370 "Failed to create reply.");
6373 if (!g_dbus_send_message(dbus_conn, reply))
6374 error("D-Bus send failed");
6376 dbus_message_unref(request->msg);
6380 static void set_le_batching_param_complete(
6381 uint8_t status, uint16_t length,
6382 const void *param, void *user_data)
6384 const struct mgmt_rp_set_le_batching_param *rp = param;
6385 struct mgmt_cp_set_le_batching_enable cp;
6386 struct le_batching_set_param_request *request =
6387 (struct le_batching_set_param_request*)user_data;
6390 if (status != MGMT_STATUS_SUCCESS) {
6391 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6392 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6393 reply = btd_error_not_supported(request->msg);
6395 reply = btd_error_failed(request->msg, mgmt_errstr(status));
6399 if (length < sizeof(*rp)) {
6400 reply = btd_error_failed(request->msg,
6401 "Wrong size of set le batching param");
6405 memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6406 cp.bdaddr = request->bdaddr;
6408 if (mgmt_send(request->adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6409 request->adapter->dev_id, sizeof(cp), &cp,
6410 set_le_batching_enable_complete, request, NULL) == 0) {
6411 reply = btd_error_failed(request->msg, "Unable to set le batching enable");
6417 if (!g_dbus_send_message(dbus_conn, reply))
6418 error("D-Bus send failed");
6420 dbus_message_unref(request->msg);
6424 static DBusMessage *adapter_enable_le_batching(DBusConnection *conn,
6425 DBusMessage *msg, void *data)
6427 struct btd_adapter *adapter = data;
6428 struct mgmt_cp_set_le_batching_param cp;
6429 struct le_batching_set_param_request *request;
6430 bdaddr_t bt_addr = { { 0, } };
6431 const gchar *address = NULL;
6432 dbus_int32_t packet_threshold;
6433 dbus_int32_t timeout;
6435 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6436 return btd_error_not_ready(msg);
6438 if (!dbus_message_get_args(msg, NULL,
6439 DBUS_TYPE_STRING, &address,
6440 DBUS_TYPE_INT32, &packet_threshold,
6441 DBUS_TYPE_INT32, &timeout,
6443 return btd_error_invalid_args(msg);
6445 if (packet_threshold < 0 || packet_threshold > 0x7fff ||
6446 timeout < 0 || timeout > 0x7fff)
6447 return btd_error_invalid_args(msg);
6449 DBG("Set LE batching param: [%s %d %d]", address,
6450 packet_threshold, timeout);
6452 memset(&bt_addr, 0, sizeof(bdaddr_t));
6453 str2ba(address, &bt_addr);
6454 memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_param));
6456 if (bachk(address) < 0)
6457 return btd_error_invalid_args(msg);
6459 cp.bdaddr = bt_addr;
6460 cp.pkt_th = packet_threshold;
6462 cp.timeout = timeout * 100;
6464 request = g_new(struct le_batching_set_param_request, 1);
6465 request->msg = dbus_message_ref(msg);
6466 request->adapter = adapter;
6467 request->bdaddr = bt_addr;
6468 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_PARAM,
6469 adapter->dev_id, sizeof(cp), &cp,
6470 set_le_batching_param_complete, request, NULL) == 0) {
6471 dbus_message_unref(request->msg);
6473 return btd_error_failed(msg, "Unable to set le batching param");
6479 static DBusMessage *adapter_disable_le_batching(DBusConnection *conn,
6480 DBusMessage *msg, void *data)
6482 struct btd_adapter *adapter = data;
6483 struct le_batching_request *request;
6484 struct mgmt_cp_set_le_batching_enable cp;
6485 bdaddr_t bt_addr = { { 0, } };
6486 const gchar *address = NULL;
6488 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6489 return btd_error_not_ready(msg);
6491 if (!dbus_message_get_args(msg, NULL,
6492 DBUS_TYPE_STRING, &address,
6494 return btd_error_invalid_args(msg);
6496 DBG("Disable LE Batching: [%s]", address);
6498 memset(&bt_addr, 0, sizeof(bdaddr_t));
6499 str2ba(address, &bt_addr);
6500 memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6502 if (bachk(address) < 0)
6503 return btd_error_invalid_args(msg);
6505 cp.bdaddr = bt_addr;
6508 request = g_new(struct le_batching_request, 1);
6509 request->msg = dbus_message_ref(msg);
6510 request->adapter = adapter;
6511 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6512 adapter->dev_id, sizeof(cp), &cp,
6513 set_le_batching_enable_complete, request, NULL) == 0) {
6514 dbus_message_unref(request->msg);
6516 return btd_error_failed(msg, "Unable to set le batching enable");
6522 void le_set_data_length_return_param_complete(
6523 uint8_t status, uint16_t length,
6524 const void *param, void *user_data)
6526 if (status != MGMT_STATUS_SUCCESS) {
6527 error("le_set_data_length failed: %s (0x%02x)",
6528 mgmt_errstr(status), status);
6534 int btd_adapter_le_set_data_length(struct btd_adapter *adapter, bdaddr_t *bdaddr,
6535 uint16_t max_tx_octets, uint16_t max_tx_time)
6537 struct mgmt_cp_le_set_data_length cp;
6539 memset(&cp, 0, sizeof(cp));
6541 bacpy(&cp.bdaddr, bdaddr);
6543 cp.max_tx_octets = max_tx_octets;
6544 cp.max_tx_time = max_tx_time;
6546 if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_DATA_LENGTH,
6547 adapter->dev_id, sizeof(cp), &cp,
6548 le_set_data_length_return_param_complete,
6555 static DBusMessage *adapter_set_manufacturer_data(DBusConnection *conn,
6556 DBusMessage *msg, void *data)
6558 struct btd_adapter *adapter = data;
6559 struct mgmt_cp_set_manufacturer_data cp;
6563 DBG("Set manufacturer data");
6565 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6566 return btd_error_not_ready(msg);
6568 if (!dbus_message_get_args(msg, NULL,
6569 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
6571 return btd_error_invalid_args(msg);
6573 if (len > EIR_MANUFACTURER_DATA_LENGTH_MAX)
6574 return btd_error_invalid_args(msg);
6576 memcpy(&cp, value, len);
6578 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_MANUFACTURER_DATA,
6579 adapter->dev_id, EIR_MANUFACTURER_DATA_LENGTH_MAX,
6580 &cp, NULL, NULL, NULL) > 0)
6581 return dbus_message_new_method_return(msg);
6583 return btd_error_failed(msg, "Set manufacturer data failed");
6586 static DBusMessage *adapter_get_energy_info(DBusConnection *conn,
6587 DBusMessage *msg, void *user_data)
6590 uint32_t tx_time = 0;
6591 uint32_t rx_time = 0;
6592 uint32_t idle_time = 0;
6593 uint32_t energy_used = 0;
6595 if (adapter_le_get_energy_info(&tx_time, &rx_time,
6596 &idle_time, &energy_used) == FALSE) {
6597 error("Fail to send vcs for getting energy info");
6598 reply = btd_error_not_supported(msg);
6602 reply = g_dbus_create_reply(msg,
6603 DBUS_TYPE_UINT32, &tx_time,
6604 DBUS_TYPE_UINT32, &rx_time,
6605 DBUS_TYPE_UINT32, &idle_time,
6606 DBUS_TYPE_UINT32, &energy_used,
6610 reply = btd_error_failed(msg,
6611 "Failed to create reply.");
6618 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
6620 static DBusMessage *start_discovery(DBusConnection *conn,
6621 DBusMessage *msg, void *user_data)
6623 struct btd_adapter *adapter = user_data;
6624 const char *sender = dbus_message_get_sender(msg);
6625 struct discovery_client *client;
6626 bool is_discovering;
6629 DBG("sender %s", sender);
6631 if (!btd_adapter_get_powered(adapter))
6632 return btd_error_not_ready(msg);
6634 is_discovering = get_discovery_client(adapter, sender, &client);
6637 * Every client can only start one discovery, if the client
6638 * already started a discovery then return an error.
6641 return btd_error_busy(msg);
6644 * If there was pre-set filter, just reconnect it to discovery_list,
6649 return btd_error_busy(msg);
6651 adapter->set_filter_list = g_slist_remove(
6652 adapter->set_filter_list, client);
6653 adapter->discovery_list = g_slist_prepend(
6654 adapter->discovery_list, client);
6659 client = g_new0(struct discovery_client, 1);
6661 client->adapter = adapter;
6662 client->owner = g_strdup(sender);
6663 client->discovery_filter = NULL;
6664 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6665 discovery_disconnect, client,
6667 adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
6672 * Just trigger the discovery here. In case an already running
6673 * discovery in idle phase exists, it will be restarted right
6676 err = update_discovery_filter(adapter);
6678 return dbus_message_new_method_return(msg);
6680 /* If the discovery has to be started wait it complete to reply */
6681 if (err == -EINPROGRESS) {
6682 client->msg = dbus_message_ref(msg);
6683 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
6684 adapter->client = client;
6690 return btd_error_failed(msg, strerror(-err));
6693 static bool parse_uuids(DBusMessageIter *value, struct discovery_filter *filter)
6695 DBusMessageIter arriter;
6697 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_ARRAY)
6700 dbus_message_iter_recurse(value, &arriter);
6701 while (dbus_message_iter_get_arg_type(&arriter) != DBUS_TYPE_INVALID) {
6702 bt_uuid_t uuid, u128;
6703 char uuidstr[MAX_LEN_UUID_STR + 1];
6706 if (dbus_message_iter_get_arg_type(&arriter) !=
6710 dbus_message_iter_get_basic(&arriter, &uuid_param);
6712 if (bt_string_to_uuid(&uuid, uuid_param))
6715 bt_uuid_to_uuid128(&uuid, &u128);
6716 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
6718 filter->uuids = g_slist_prepend(filter->uuids, g_strdup(uuidstr));
6720 dbus_message_iter_next(&arriter);
6726 static bool parse_rssi(DBusMessageIter *value, struct discovery_filter *filter)
6728 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_INT16)
6731 dbus_message_iter_get_basic(value, &filter->rssi);
6732 /* -127 <= RSSI <= +20 (spec V4.2 [Vol 2, Part E] 7.7.65.2) */
6733 if (filter->rssi > 20 || filter->rssi < -127)
6739 static bool parse_pathloss(DBusMessageIter *value,
6740 struct discovery_filter *filter)
6742 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT16)
6745 dbus_message_iter_get_basic(value, &filter->pathloss);
6746 /* pathloss filter must be smaller that PATHLOSS_MAX */
6747 if (filter->pathloss > PATHLOSS_MAX)
6753 static bool parse_transport(DBusMessageIter *value,
6754 struct discovery_filter *filter)
6756 char *transport_str;
6758 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6761 dbus_message_iter_get_basic(value, &transport_str);
6763 if (!strcmp(transport_str, "bredr"))
6764 filter->type = SCAN_TYPE_BREDR;
6765 else if (!strcmp(transport_str, "le"))
6766 filter->type = SCAN_TYPE_LE;
6767 else if (strcmp(transport_str, "auto"))
6773 static bool parse_duplicate_data(DBusMessageIter *value,
6774 struct discovery_filter *filter)
6776 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6779 dbus_message_iter_get_basic(value, &filter->duplicate);
6784 static bool parse_discoverable(DBusMessageIter *value,
6785 struct discovery_filter *filter)
6787 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6790 dbus_message_iter_get_basic(value, &filter->discoverable);
6795 static bool parse_pattern(DBusMessageIter *value,
6796 struct discovery_filter *filter)
6798 const char *pattern;
6800 if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6803 dbus_message_iter_get_basic(value, &pattern);
6805 free(filter->pattern);
6806 filter->pattern = strdup(pattern);
6811 struct filter_parser {
6813 bool (*func)(DBusMessageIter *iter, struct discovery_filter *filter);
6815 { "UUIDs", parse_uuids },
6816 { "RSSI", parse_rssi },
6817 { "Pathloss", parse_pathloss },
6818 { "Transport", parse_transport },
6819 { "DuplicateData", parse_duplicate_data },
6820 { "Discoverable", parse_discoverable },
6821 { "Pattern", parse_pattern },
6825 static bool parse_discovery_filter_entry(char *key, DBusMessageIter *value,
6826 struct discovery_filter *filter)
6828 struct filter_parser *parser;
6830 for (parser = parsers; parser && parser->name; parser++) {
6831 if (!strcmp(parser->name, key))
6832 return parser->func(value, filter);
6835 DBG("Unknown key parameter: %s!\n", key);
6840 * This method is responsible for parsing parameters to SetDiscoveryFilter. If
6841 * filter in msg was empty, sets *filter to NULL. If whole parsing was
6842 * successful, sets *filter to proper value.
6843 * Returns false on any error, and true on success.
6845 static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
6846 struct discovery_filter **filter,
6849 DBusMessageIter iter, subiter, dictiter, variantiter;
6850 bool is_empty = true;
6852 *filter = g_try_malloc(sizeof(**filter));
6856 (*filter)->uuids = NULL;
6857 (*filter)->pathloss = DISTANCE_VAL_INVALID;
6858 (*filter)->rssi = DISTANCE_VAL_INVALID;
6859 (*filter)->type = get_scan_type(adapter);
6860 (*filter)->duplicate = false;
6861 (*filter)->discoverable = false;
6862 (*filter)->pattern = NULL;
6864 dbus_message_iter_init(msg, &iter);
6865 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
6866 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
6869 dbus_message_iter_recurse(&iter, &subiter);
6871 int type = dbus_message_iter_get_arg_type(&subiter);
6874 if (type == DBUS_TYPE_INVALID)
6878 dbus_message_iter_recurse(&subiter, &dictiter);
6880 dbus_message_iter_get_basic(&dictiter, &key);
6881 if (!dbus_message_iter_next(&dictiter))
6884 if (dbus_message_iter_get_arg_type(&dictiter) !=
6888 dbus_message_iter_recurse(&dictiter, &variantiter);
6890 if (!parse_discovery_filter_entry(key, &variantiter, *filter))
6893 dbus_message_iter_next(&subiter);
6902 /* only pathlos or rssi can be set, never both */
6903 if ((*filter)->pathloss != DISTANCE_VAL_INVALID &&
6904 (*filter)->rssi != DISTANCE_VAL_INVALID)
6907 DBG("filtered discovery params: transport: %d rssi: %d pathloss: %d "
6908 " duplicate data: %s discoverable %s pattern %s",
6909 (*filter)->type, (*filter)->rssi, (*filter)->pathloss,
6910 (*filter)->duplicate ? "true" : "false",
6911 (*filter)->discoverable ? "true" : "false",
6912 (*filter)->pattern);
6917 g_slist_free_full((*filter)->uuids, g_free);
6923 static DBusMessage *set_discovery_filter(DBusConnection *conn,
6924 DBusMessage *msg, void *user_data)
6926 struct btd_adapter *adapter = user_data;
6927 struct discovery_client *client;
6928 struct discovery_filter *discovery_filter;
6929 const char *sender = dbus_message_get_sender(msg);
6930 bool is_discovering;
6932 DBG("sender %s", sender);
6934 if (!btd_adapter_get_powered(adapter))
6935 return btd_error_not_ready(msg);
6937 if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 8))
6938 return btd_error_not_supported(msg);
6940 /* parse parameters */
6941 if (!parse_discovery_filter_dict(adapter, &discovery_filter, msg))
6942 return btd_error_invalid_args(msg);
6944 is_discovering = get_discovery_client(adapter, sender, &client);
6947 free_discovery_filter(client->discovery_filter);
6948 client->discovery_filter = discovery_filter;
6951 update_discovery_filter(adapter);
6953 if (discovery_filter || is_discovering)
6954 return dbus_message_new_method_return(msg);
6956 /* Removing pre-set filter */
6957 adapter->set_filter_list = g_slist_remove(
6958 adapter->set_filter_list,
6960 discovery_free(client);
6961 DBG("successfully cleared pre-set filter");
6962 } else if (discovery_filter) {
6963 /* Client pre-setting his filter for first time */
6964 client = g_new0(struct discovery_client, 1);
6965 client->adapter = adapter;
6966 client->owner = g_strdup(sender);
6967 client->discovery_filter = discovery_filter;
6968 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6969 discovery_disconnect, client,
6971 adapter->set_filter_list = g_slist_prepend(
6972 adapter->set_filter_list, client);
6974 DBG("successfully pre-set filter");
6977 return dbus_message_new_method_return(msg);
6980 static DBusMessage *stop_discovery(DBusConnection *conn,
6981 DBusMessage *msg, void *user_data)
6983 struct btd_adapter *adapter = user_data;
6984 const char *sender = dbus_message_get_sender(msg);
6985 struct discovery_client *client;
6989 DBG("sender %s", sender);
6991 if (!btd_adapter_get_powered(adapter))
6992 return btd_error_not_ready(msg);
6994 list = g_slist_find_custom(adapter->discovery_list, sender,
6997 return btd_error_failed(msg, "No discovery started");
6999 client = list->data;
7002 return btd_error_busy(msg);
7004 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7005 err = discovery_stop(client, false);
7007 err = discovery_stop(client);
7011 return dbus_message_new_method_return(msg);
7013 client->msg = dbus_message_ref(msg);
7014 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7015 adapter->client = client;
7019 return btd_error_failed(msg, strerror(-err));
7023 static gboolean property_get_address(const GDBusPropertyTable *property,
7024 DBusMessageIter *iter, void *user_data)
7026 struct btd_adapter *adapter = user_data;
7028 const char *str = addr;
7030 ba2str(&adapter->bdaddr, addr);
7032 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7037 static gboolean property_get_address_type(const GDBusPropertyTable *property,
7038 DBusMessageIter *iter, void *user_data)
7040 struct btd_adapter *adapter = user_data;
7043 if ((adapter->current_settings & MGMT_SETTING_LE) &&
7044 (adapter->bdaddr_type == BDADDR_LE_RANDOM))
7049 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7054 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7055 static gboolean property_get_le_address(const GDBusPropertyTable *property,
7056 DBusMessageIter *iter, void *user_data)
7058 struct btd_adapter *adapter = user_data;
7059 DBusMessageIter entry;
7061 const char *str = addr;
7064 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7065 DBUS_TYPE_STRING_AS_STRING, &entry);
7067 if (adapter->le_static_addr.b[5] != 0) {
7068 ba2str(&adapter->le_static_addr, addr);
7069 type = g_strdup_printf("%d", BDADDR_LE_RANDOM);
7071 ba2str(&adapter->bdaddr, addr);
7072 type = g_strdup_printf("%d", BDADDR_LE_PUBLIC);
7075 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &type);
7076 g_free((void *)type);
7078 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7080 dbus_message_iter_close_container(iter, &entry);
7086 static gboolean property_get_name(const GDBusPropertyTable *property,
7087 DBusMessageIter *iter, void *user_data)
7089 struct btd_adapter *adapter = user_data;
7090 const char *str = adapter->system_name ? : "";
7092 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7097 static gboolean property_get_alias(const GDBusPropertyTable *property,
7098 DBusMessageIter *iter, void *user_data)
7100 struct btd_adapter *adapter = user_data;
7103 if (adapter->current_alias)
7104 str = adapter->current_alias;
7105 else if (adapter->stored_alias)
7106 str = adapter->stored_alias;
7108 str = adapter->system_name ? : "";
7110 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7115 static void property_set_alias(const GDBusPropertyTable *property,
7116 DBusMessageIter *iter,
7117 GDBusPendingPropertySet id, void *user_data)
7119 struct btd_adapter *adapter = user_data;
7123 dbus_message_iter_get_basic(iter, &name);
7125 if (g_str_equal(name, "") == TRUE) {
7126 if (adapter->stored_alias == NULL) {
7127 /* no alias set, nothing to restore */
7128 g_dbus_pending_property_success(id);
7132 /* restore to system name */
7133 ret = set_name(adapter, adapter->system_name);
7135 if (g_strcmp0(adapter->stored_alias, name) == 0) {
7136 /* alias already set, nothing to do */
7137 g_dbus_pending_property_success(id);
7142 ret = set_name(adapter, name);
7146 g_free(adapter->stored_alias);
7148 if (g_str_equal(name, "") == TRUE)
7149 adapter->stored_alias = NULL;
7151 adapter->stored_alias = g_strdup(name);
7153 store_adapter_info(adapter);
7155 g_dbus_pending_property_success(id);
7160 g_dbus_pending_property_error(id,
7161 ERROR_INTERFACE ".InvalidArguments",
7162 "Invalid arguments in method call");
7164 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7168 static gboolean property_get_class(const GDBusPropertyTable *property,
7169 DBusMessageIter *iter, void *user_data)
7171 struct btd_adapter *adapter = user_data;
7172 dbus_uint32_t val = adapter->dev_class;
7174 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
7179 static gboolean property_get_a2dp_role(const GDBusPropertyTable *property,
7180 DBusMessageIter *iter, void *user_data)
7182 struct btd_adapter *adapter = user_data;
7183 dbus_uint32_t val = adapter->a2dp_role;
7185 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
7190 static gboolean property_get_mode(struct btd_adapter *adapter,
7191 uint32_t setting, DBusMessageIter *iter)
7195 enable = (adapter->current_settings & setting) ? TRUE : FALSE;
7197 dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
7202 struct property_set_data {
7203 struct btd_adapter *adapter;
7205 GDBusPendingPropertySet id;
7209 static void property_set_mode_complete(uint8_t status, uint16_t length,
7210 const void *param, void *user_data)
7212 struct property_set_data *data = user_data;
7213 struct btd_adapter *adapter = data->adapter;
7215 DBG("%s (0x%02x)", mgmt_errstr(status), status);
7217 if (status != MGMT_STATUS_SUCCESS) {
7218 const char *dbus_err;
7220 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
7221 mgmt_errstr(status), status);
7223 if (status == MGMT_STATUS_RFKILLED) {
7224 dbus_err = ERROR_INTERFACE ".Blocked";
7225 adapter_set_power_state(adapter,
7226 ADAPTER_POWER_STATE_OFF_BLOCKED);
7228 dbus_err = ERROR_INTERFACE ".Failed";
7231 g_dbus_pending_property_error(data->id, dbus_err,
7232 mgmt_errstr(status));
7234 adapter->pending_settings &= ~data->setting;
7235 if (status != MGMT_STATUS_RFKILLED &&
7236 data->setting & MGMT_SETTING_POWERED)
7237 reset_power_state_target(adapter, data->value);
7241 g_dbus_pending_property_success(data->id);
7244 * The parameters are identical and also the task that is
7245 * required in both cases. So it is safe to just call the
7246 * event handling functions here.
7248 new_settings_callback(adapter->dev_id, length, param, adapter);
7251 static void clear_discoverable(struct btd_adapter *adapter)
7253 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
7256 if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
7259 /* If no timeout is set do nothing as both connectable and discoverable
7260 * flags are persistent on power toggle.
7262 if (!adapter->discoverable_timeout)
7265 /* If timeout was set kernel clears discoverable on its own when
7266 * powering off controller. This would leave connectable flag set
7269 * With kernel control clearing connectable clear also discoverable
7270 * flag so we need to clear connectable.
7272 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
7275 static void property_set_mode(struct btd_adapter *adapter, uint32_t setting,
7276 DBusMessageIter *value,
7277 GDBusPendingPropertySet id)
7279 struct property_set_data *data;
7280 struct mgmt_cp_set_discoverable cp;
7282 dbus_bool_t enable, current_enable;
7283 uint16_t opcode, len;
7286 dbus_message_iter_get_basic(value, &enable);
7288 if (adapter->pending_settings & setting) {
7289 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Busy",
7294 if (adapter->current_settings & setting)
7295 current_enable = TRUE;
7297 current_enable = FALSE;
7299 if (enable == current_enable) {
7300 g_dbus_pending_property_success(id);
7304 mode = (enable == TRUE) ? 0x01 : 0x00;
7307 case MGMT_SETTING_POWERED:
7308 opcode = MGMT_OP_SET_POWERED;
7313 btd_adv_monitor_power_down(
7314 adapter->adv_monitor_manager);
7315 clear_discoverable(adapter);
7316 remove_temporary_devices(adapter);
7320 case MGMT_SETTING_DISCOVERABLE:
7321 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7322 if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
7324 set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
7327 opcode = MGMT_OP_SET_CONNECTABLE;
7335 memset(&cp, 0, sizeof(cp));
7338 cp.timeout = htobs(adapter->discoverable_timeout);
7340 opcode = MGMT_OP_SET_DISCOVERABLE;
7344 case MGMT_SETTING_BONDABLE:
7345 opcode = MGMT_OP_SET_BONDABLE;
7349 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7350 case MGMT_SETTING_CONNECTABLE:
7351 opcode = MGMT_OP_SET_CONNECTABLE;
7360 DBG("sending %s command for index %u", mgmt_opstr(opcode),
7363 data = g_try_new0(struct property_set_data, 1);
7367 data->adapter = adapter;
7368 data->setting = setting;
7370 data->setting = setting;
7373 if (setting == MGMT_SETTING_POWERED &&
7374 adapter->power_state != ADAPTER_POWER_STATE_OFF_BLOCKED) {
7375 adapter_set_power_state(adapter, mode ?
7376 ADAPTER_POWER_STATE_OFF_ENABLING :
7377 ADAPTER_POWER_STATE_ON_DISABLING);
7380 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7382 * Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
7384 if (mgmt_send_nowait(adapter->mgmt, opcode, adapter->dev_id, len, param,
7385 property_set_mode_complete, data, g_free) > 0)
7388 if (mgmt_send(adapter->mgmt, opcode, adapter->dev_id, len, param,
7389 propertyi_set_mode_complete, data, g_free) > 0){
7390 adapter->pending_settings |= setting;
7396 if (setting == MGMT_SETTING_POWERED) {
7397 /* cancel the earlier setting */
7398 adapter_set_power_state(adapter, mode ?
7399 ADAPTER_POWER_STATE_OFF :
7400 ADAPTER_POWER_STATE_ON);
7404 btd_error(adapter->dev_id, "Failed to set mode for index %u",
7407 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
7410 static gboolean property_get_powered(const GDBusPropertyTable *property,
7411 DBusMessageIter *iter, void *user_data)
7413 struct btd_adapter *adapter = user_data;
7415 return property_get_mode(adapter, MGMT_SETTING_POWERED, iter);
7418 static void property_set_powered(const GDBusPropertyTable *property,
7419 DBusMessageIter *iter,
7420 GDBusPendingPropertySet id, void *user_data)
7422 struct btd_adapter *adapter = user_data;
7424 if (powering_down) {
7425 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7430 property_set_mode(adapter, MGMT_SETTING_POWERED, iter, id);
7433 static gboolean property_get_power_state(const GDBusPropertyTable *property,
7434 DBusMessageIter *iter, void *user_data)
7436 struct btd_adapter *adapter = user_data;
7439 str = adapter_power_state_str(adapter->power_state);
7440 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7445 static gboolean property_get_discoverable(const GDBusPropertyTable *property,
7446 DBusMessageIter *iter, void *user_data)
7448 struct btd_adapter *adapter = user_data;
7450 return property_get_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter);
7453 static void property_set_discoverable(const GDBusPropertyTable *property,
7454 DBusMessageIter *iter,
7455 GDBusPendingPropertySet id, void *user_data)
7457 struct btd_adapter *adapter = user_data;
7459 if (adapter->discoverable_timeout > 0 &&
7460 !btd_adapter_get_powered(adapter)) {
7461 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7466 /* Reset discovery_discoverable as Discoverable takes precedence */
7467 adapter->discovery_discoverable = false;
7469 property_set_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter, id);
7472 static gboolean property_get_discoverable_timeout(
7473 const GDBusPropertyTable *property,
7474 DBusMessageIter *iter, void *user_data)
7476 struct btd_adapter *adapter = user_data;
7477 dbus_uint32_t value = adapter->discoverable_timeout;
7479 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7484 static void property_set_discoverable_timeout(
7485 const GDBusPropertyTable *property,
7486 DBusMessageIter *iter,
7487 GDBusPendingPropertySet id, void *user_data)
7489 struct btd_adapter *adapter = user_data;
7491 dbus_uint32_t value;
7493 dbus_message_iter_get_basic(iter, &value);
7495 adapter->discoverable_timeout = value;
7497 g_dbus_pending_property_success(id);
7499 store_adapter_info(adapter);
7501 g_dbus_emit_property_changed(dbus_conn, adapter->path,
7502 ADAPTER_INTERFACE, "DiscoverableTimeout");
7504 if (adapter->pending_settings & MGMT_SETTING_DISCOVERABLE) {
7505 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7510 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7517 set_discoverable(adapter, 0x01, adapter->discoverable_timeout);
7520 static gboolean property_get_pairable(const GDBusPropertyTable *property,
7521 DBusMessageIter *iter, void *user_data)
7523 struct btd_adapter *adapter = user_data;
7525 return property_get_mode(adapter, MGMT_SETTING_BONDABLE, iter);
7528 static void property_set_pairable(const GDBusPropertyTable *property,
7529 DBusMessageIter *iter,
7530 GDBusPendingPropertySet id, void *user_data)
7532 struct btd_adapter *adapter = user_data;
7534 property_set_mode(adapter, MGMT_SETTING_BONDABLE, iter, id);
7537 static gboolean property_get_pairable_timeout(
7538 const GDBusPropertyTable *property,
7539 DBusMessageIter *iter, void *user_data)
7541 struct btd_adapter *adapter = user_data;
7542 dbus_uint32_t value = adapter->pairable_timeout;
7544 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7549 static void property_set_pairable_timeout(const GDBusPropertyTable *property,
7550 DBusMessageIter *iter,
7551 GDBusPendingPropertySet id, void *user_data)
7553 struct btd_adapter *adapter = user_data;
7554 dbus_uint32_t value;
7556 dbus_message_iter_get_basic(iter, &value);
7558 adapter->pairable_timeout = value;
7560 g_dbus_pending_property_success(id);
7562 store_adapter_info(adapter);
7564 g_dbus_emit_property_changed(dbus_conn, adapter->path,
7565 ADAPTER_INTERFACE, "PairableTimeout");
7567 trigger_pairable_timeout(adapter);
7570 static gboolean property_get_discovering(const GDBusPropertyTable *property,
7571 DBusMessageIter *iter, void *user_data)
7573 struct btd_adapter *adapter = user_data;
7574 dbus_bool_t discovering = adapter->discovering;
7576 dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7581 static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
7583 GHashTable *uuids = user_data;
7584 bt_uuid_t uuid, u128;
7585 char uuidstr[MAX_LEN_UUID_STR + 1];
7587 if (!gatt_db_service_get_active(attrib))
7590 if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
7593 bt_uuid_to_uuid128(&uuid, &u128);
7594 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
7596 g_hash_table_add(uuids, strdup(uuidstr));
7599 static void iter_append_uuid(gpointer key, gpointer value, gpointer user_data)
7601 DBusMessageIter *iter = user_data;
7602 const char *uuid = key;
7604 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
7607 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7608 static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
7609 DBusMessageIter *iter, void *user_data)
7611 struct btd_adapter *adapter = user_data;
7612 dbus_bool_t discovering = adapter->le_discovering;
7614 dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7619 static gboolean property_get_connectable(const GDBusPropertyTable *property,
7620 DBusMessageIter *iter, void *user_data)
7622 struct btd_adapter *adapter = user_data;
7624 return property_get_mode(adapter, MGMT_SETTING_CONNECTABLE, iter);
7627 static void property_set_connectable(const GDBusPropertyTable *property,
7628 DBusMessageIter *iter,
7629 GDBusPendingPropertySet id, void *user_data)
7631 struct btd_adapter *adapter = user_data;
7633 property_set_mode(adapter, MGMT_SETTING_CONNECTABLE, iter, id);
7636 static gboolean property_get_version(const GDBusPropertyTable *property,
7637 DBusMessageIter *iter, void *user_data)
7639 struct btd_adapter *adapter = user_data;
7640 const char *str = adapter->version ? : "";
7642 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7647 static gboolean property_get_supported_le_features(
7648 const GDBusPropertyTable *property,
7649 DBusMessageIter *iter, void *user_data)
7651 const char *str, *val;
7653 DBusMessageIter entry;
7654 struct btd_adapter *adapter = user_data;
7656 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7657 DBUS_TYPE_STRING_AS_STRING, &entry);
7659 value = adapter_le_get_max_adv_instance();
7661 str = g_strdup("adv_inst_max");
7662 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7664 val = g_strdup_printf("%d", value);
7665 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7667 g_free((void *)str);
7668 g_free((void *)val);
7671 value = adapter_le_is_supported_offloading();
7673 str = g_strdup("rpa_offloading");
7674 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7676 val = g_strdup_printf("%d", value);
7677 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7679 g_free((void *)str);
7680 g_free((void *)val);
7683 value = adapter_le_get_scan_filter_size();
7684 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
7686 value = SCAN_FILTER_SLOTS_MAX;
7689 str = g_strdup("max_filter");
7690 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7692 val = g_strdup_printf("%d", value);
7693 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7695 g_free((void *)str);
7696 g_free((void *)val);
7699 if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
7700 /* 2M PHY Support */
7701 str = g_strdup("2m_phy");
7702 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7704 if (adapter->le_2m_phy_supported)
7705 val = g_strdup("true");
7707 val = g_strdup("false");
7709 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7711 g_free((void *)str);
7712 g_free((void *)val);
7714 /* CODED PHY Support */
7715 str = g_strdup("coded_phy");
7716 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7718 if (adapter->le_coded_phy_supported)
7719 val = g_strdup("true");
7721 val = g_strdup("false");
7723 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7725 g_free((void *)str);
7726 g_free((void *)val);
7729 dbus_message_iter_close_container(iter, &entry);
7734 static gboolean property_get_ipsp_init_state(
7735 const GDBusPropertyTable *property,
7736 DBusMessageIter *iter, void *data)
7738 struct btd_adapter *adapter = data;
7739 dbus_bool_t ipsp_initialized;
7741 if (adapter->ipsp_intialized)
7742 ipsp_initialized = TRUE;
7744 ipsp_initialized = FALSE;
7746 dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
7753 static gboolean property_get_uuids(const GDBusPropertyTable *property,
7754 DBusMessageIter *iter, void *user_data)
7756 struct btd_adapter *adapter = user_data;
7757 DBusMessageIter entry;
7762 uuids = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
7767 for (l = adapter->services; l != NULL; l = l->next) {
7768 sdp_record_t *rec = l->data;
7771 uuid = bt_uuid2string(&rec->svclass);
7775 g_hash_table_add(uuids, uuid);
7779 db = btd_gatt_database_get_db(adapter->database);
7781 gatt_db_foreach_service(db, NULL, add_gatt_uuid, uuids);
7783 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7784 DBUS_TYPE_STRING_AS_STRING, &entry);
7785 g_hash_table_foreach(uuids, iter_append_uuid, &entry);
7786 dbus_message_iter_close_container(iter, &entry);
7788 g_hash_table_destroy(uuids);
7793 static gboolean property_exists_modalias(const GDBusPropertyTable *property,
7796 struct btd_adapter *adapter = user_data;
7798 return adapter->modalias ? TRUE : FALSE;
7801 static gboolean property_get_modalias(const GDBusPropertyTable *property,
7802 DBusMessageIter *iter, void *user_data)
7804 struct btd_adapter *adapter = user_data;
7805 const char *str = adapter->modalias ? : "";
7807 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7812 static gboolean property_get_roles(const GDBusPropertyTable *property,
7813 DBusMessageIter *iter, void *user_data)
7815 struct btd_adapter *adapter = user_data;
7816 DBusMessageIter entry;
7818 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7819 DBUS_TYPE_STRING_AS_STRING, &entry);
7821 if (adapter->supported_settings & MGMT_SETTING_LE) {
7822 const char *str = "central";
7823 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7826 if (adapter->supported_settings & MGMT_SETTING_ADVERTISING) {
7827 const char *str = "peripheral";
7828 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7831 if (queue_find(adapter->exps, NULL,
7832 le_simult_central_peripheral_uuid.val)) {
7833 const char *str = "central-peripheral";
7834 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7837 dbus_message_iter_close_container(iter, &entry);
7842 static void property_append_experimental(void *data, void *user_data)
7844 uint8_t *feature = data;
7845 DBusMessageIter *iter = user_data;
7848 char str[MAX_LEN_UUID_STR + 1];
7851 bswap_128(feature, &value);
7852 bt_uuid128_create(&uuid, value);
7853 bt_uuid_to_string(&uuid, str, sizeof(str));
7857 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &ptr);
7860 static gboolean property_get_experimental(const GDBusPropertyTable *property,
7861 DBusMessageIter *iter, void *user_data)
7863 struct btd_adapter *adapter = user_data;
7864 DBusMessageIter entry;
7866 dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7867 DBUS_TYPE_STRING_AS_STRING, &entry);
7869 queue_foreach(adapter->exps, property_append_experimental, &entry);
7871 dbus_message_iter_close_container(iter, &entry);
7876 static gboolean property_experimental_exists(const GDBusPropertyTable *property,
7879 struct btd_adapter *adapter = data;
7881 return !queue_isempty(adapter->exps);
7884 static DBusMessage *remove_device(DBusConnection *conn,
7885 DBusMessage *msg, void *user_data)
7887 struct btd_adapter *adapter = user_data;
7888 struct btd_device *device;
7892 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
7893 DBUS_TYPE_INVALID) == FALSE)
7894 return btd_error_invalid_args(msg);
7896 list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7898 return btd_error_does_not_exist(msg);
7900 if (!btd_adapter_get_powered(adapter))
7901 return btd_error_not_ready(msg);
7903 device = list->data;
7905 btd_device_set_temporary(device, true);
7907 if (!btd_device_is_connected(device)) {
7908 btd_adapter_remove_device(adapter, device);
7909 return dbus_message_new_method_return(msg);
7912 device_request_disconnect(device, msg);
7917 static DBusMessage *get_discovery_filters(DBusConnection *conn,
7918 DBusMessage *msg, void *user_data)
7921 DBusMessageIter iter, array;
7922 struct filter_parser *parser;
7924 reply = dbus_message_new_method_return(msg);
7926 dbus_message_iter_init_append(reply, &iter);
7928 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
7929 DBUS_TYPE_STRING_AS_STRING, &array);
7931 for (parser = parsers; parser && parser->name; parser++) {
7932 dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
7936 dbus_message_iter_close_container(&iter, &array);
7941 struct device_connect_data {
7942 struct btd_adapter *adapter;
7948 static void device_browse_cb(struct btd_device *dev, int err, void *user_data)
7950 DBG("err %d (%s)", err, strerror(-err));
7953 btd_device_connect_services(dev, NULL);
7956 static void device_connect_cb(GIOChannel *io, GError *gerr, gpointer user_data)
7958 struct device_connect_data *data = user_data;
7959 struct btd_adapter *adapter = data->adapter;
7960 struct btd_device *device;
7963 DBG("%s", gerr ? gerr->message : "");
7968 /* object might already exist due to mgmt socket event */
7969 device = btd_adapter_get_device(adapter, &data->dst, data->dst_type);
7973 path = device_get_path(device);
7975 g_dbus_send_reply(dbus_conn, data->msg, DBUS_TYPE_OBJECT_PATH, &path,
7978 /* continue with service discovery and connection */
7979 btd_device_set_temporary(device, false);
7980 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7981 device_update_last_seen(device, data->dst_type);
7983 device_update_last_seen(device, data->dst_type, true);
7986 if (data->dst_type != BDADDR_BREDR){
7987 g_io_channel_set_close_on_unref(io, FALSE);
7988 device_attach_att(device, io);
7991 device_discover_services(device);
7992 device_wait_for_svc_complete(device, device_browse_cb, NULL);
7994 g_io_channel_unref(io);
7995 dbus_message_unref(data->msg);
8000 g_dbus_send_error(dbus_conn, data->msg, "org.bluez.Failed", NULL);
8001 g_io_channel_unref(io);
8002 dbus_message_unref(data->msg);
8006 static void device_connect(struct btd_adapter *adapter, const bdaddr_t *dst,
8007 uint8_t dst_type, DBusMessage *msg)
8009 struct device_connect_data *data;
8012 data = new0(struct device_connect_data, 1);
8013 data->adapter = adapter;
8014 bacpy(&data->dst, dst);
8015 data->dst_type = dst_type;
8016 data->msg = dbus_message_ref(msg);
8018 if (dst_type == BDADDR_BREDR)
8019 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
8020 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
8021 BT_IO_OPT_SOURCE_TYPE, BDADDR_BREDR,
8022 BT_IO_OPT_DEST_BDADDR, dst,
8023 BT_IO_OPT_DEST_TYPE, BDADDR_BREDR,
8024 BT_IO_OPT_PSM, SDP_PSM,
8025 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
8028 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
8029 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
8030 BT_IO_OPT_SOURCE_TYPE, adapter->bdaddr_type,
8031 BT_IO_OPT_DEST_BDADDR, dst,
8032 BT_IO_OPT_DEST_TYPE, dst_type,
8033 BT_IO_OPT_CID, ATT_CID,
8034 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
8038 g_dbus_send_message(dbus_conn,
8039 btd_error_failed(msg, "Connect failed"));
8040 dbus_message_unref(data->msg);
8045 static DBusMessage *connect_device(DBusConnection *conn,
8046 DBusMessage *msg, void *user_data)
8048 struct btd_adapter *adapter = user_data;
8049 DBusMessageIter iter, subiter, dictiter, value;
8050 uint8_t addr_type = BDADDR_BREDR;
8051 bdaddr_t addr = *BDADDR_ANY;
8053 DBG("sender %s", dbus_message_get_sender(msg));
8055 if (!btd_adapter_get_powered(adapter))
8056 return btd_error_not_ready(msg);
8058 dbus_message_iter_init(msg, &iter);
8059 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
8060 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
8061 return btd_error_invalid_args(msg);
8063 dbus_message_iter_recurse(&iter, &subiter);
8065 int type = dbus_message_iter_get_arg_type(&subiter);
8069 if (type == DBUS_TYPE_INVALID)
8072 dbus_message_iter_recurse(&subiter, &dictiter);
8074 dbus_message_iter_get_basic(&dictiter, &key);
8075 if (!dbus_message_iter_next(&dictiter))
8076 return btd_error_invalid_args(msg);
8078 if (dbus_message_iter_get_arg_type(&dictiter) !=
8080 return btd_error_invalid_args(msg);
8082 dbus_message_iter_recurse(&dictiter, &value);
8084 if (!strcmp(key, "Address")) {
8085 if (dbus_message_iter_get_arg_type(&value) !=
8087 return btd_error_invalid_args(msg);
8089 dbus_message_iter_get_basic(&value, &str);
8091 if (str2ba(str, &addr) < 0 )
8092 return btd_error_invalid_args(msg);
8093 } else if (!strcmp(key, "AddressType")) {
8094 if (dbus_message_iter_get_arg_type(&value) !=
8096 return btd_error_invalid_args(msg);
8098 dbus_message_iter_get_basic(&value, &str);
8101 if (!strcmp(str, "public"))
8102 addr_type = BDADDR_LE_PUBLIC;
8103 else if (!strcmp(str, "random"))
8104 addr_type = BDADDR_LE_RANDOM;
8106 return btd_error_invalid_args(msg);
8108 return btd_error_invalid_args(msg);
8111 dbus_message_iter_next(&subiter);
8114 if (!bacmp(&addr, BDADDR_ANY))
8115 return btd_error_invalid_args(msg);
8117 device_connect(adapter, &addr, addr_type, msg);
8121 static void update_device_allowed_services(void *data, void *user_data)
8123 struct btd_device *device = data;
8125 btd_device_update_allowed_services(device);
8128 static void add_uuid_to_uuid_set(void *data, void *user_data)
8130 bt_uuid_t *uuid = data;
8131 GHashTable *uuid_set = user_data;
8134 error("Found NULL in UUID allowed list");
8138 g_hash_table_add(uuid_set, uuid);
8141 static guint bt_uuid_hash(gconstpointer key)
8143 const bt_uuid_t *uuid = key;
8144 uint64_t uuid_128[2];
8149 bt_uuid_to_uuid128(uuid, (bt_uuid_t *)uuid_128);
8151 return g_int64_hash(uuid_128) ^ g_int64_hash(uuid_128+1);
8154 static gboolean bt_uuid_equal(gconstpointer v1, gconstpointer v2)
8156 const bt_uuid_t *uuid1 = v1;
8157 const bt_uuid_t *uuid2 = v2;
8159 if (!uuid1 || !uuid2)
8160 return !uuid1 && !uuid2;
8162 return bt_uuid_cmp(uuid1, uuid2) == 0;
8165 bool btd_adapter_set_allowed_uuids(struct btd_adapter *adapter,
8166 struct queue *uuids)
8171 if (adapter->allowed_uuid_set)
8172 g_hash_table_destroy(adapter->allowed_uuid_set);
8174 adapter->allowed_uuid_set = g_hash_table_new(bt_uuid_hash,
8176 if (!adapter->allowed_uuid_set) {
8177 btd_error(adapter->dev_id,
8178 "Failed to allocate allowed_uuid_set");
8182 queue_foreach(uuids, add_uuid_to_uuid_set, adapter->allowed_uuid_set);
8183 g_slist_foreach(adapter->devices, update_device_allowed_services, NULL);
8188 bool btd_adapter_is_uuid_allowed(struct btd_adapter *adapter,
8189 const char *uuid_str)
8193 if (!adapter || !adapter->allowed_uuid_set)
8196 if (bt_string_to_uuid(&uuid, uuid_str)) {
8197 btd_error(adapter->dev_id,
8198 "Failed to parse UUID string '%s'", uuid_str);
8202 return !g_hash_table_size(adapter->allowed_uuid_set) ||
8203 g_hash_table_contains(adapter->allowed_uuid_set, &uuid);
8206 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8207 static DBusMessage *adapter_unpair_device(DBusConnection *conn,
8208 DBusMessage *msg, void *user_data)
8211 struct btd_adapter *adapter = user_data;
8212 struct btd_device *device;
8216 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
8217 DBUS_TYPE_INVALID) == FALSE)
8218 return btd_error_invalid_args(msg);
8220 list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
8222 return btd_error_does_not_exist(msg);
8224 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8225 return btd_error_not_ready(msg);
8227 device = list->data;
8229 btd_device_set_temporary(device, TRUE);
8231 if (!btd_device_is_connected(device)) {
8232 btd_adapter_unpair_device(adapter, device);
8233 return dbus_message_new_method_return(msg);
8236 device_request_disconnect(device, msg);
8242 static DBusMessage *create_device(DBusConnection *conn,
8243 DBusMessage *msg, void *data)
8245 struct btd_adapter *adapter = data;
8246 const gchar *address;
8250 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8251 DBUS_TYPE_INVALID) == FALSE)
8252 return btd_error_invalid_args(msg);
8254 if (bachk(address) < 0)
8255 return btd_error_invalid_args(msg);
8259 str2ba(address, &addr);
8260 btd_adapter_get_device(adapter, &addr, BDADDR_BREDR);
8263 return dbus_message_new_method_return(msg);
8266 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
8269 struct btd_adapter *adapter = data;
8270 struct btd_device *device;
8272 const gchar *address;
8274 const gchar *dev_path;
8276 if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8278 return btd_error_invalid_args(msg);
8280 l = g_slist_find_custom(adapter->devices, address, device_rpa_cmp);
8282 l = g_slist_find_custom(adapter->devices, address,
8283 device_address_cmp);
8285 return btd_error_does_not_exist(msg);
8289 reply = dbus_message_new_method_return(msg);
8293 dev_path = device_get_path(device);
8295 dbus_message_append_args(reply,
8296 DBUS_TYPE_OBJECT_PATH, &dev_path,
8302 static gboolean adapter_ipsp_connected(struct btd_adapter *adapter)
8306 DBG("%s", adapter->path);
8308 for (l = adapter->connections; l != NULL; l = next) {
8309 struct btd_device *dev = l->data;
8311 next = g_slist_next(l);
8313 if (device_is_ipsp_connected(dev))
8320 static void adapter_set_ipsp_init_state(struct btd_adapter *adapter, gboolean initialized)
8322 if (adapter->ipsp_intialized == initialized)
8325 adapter->ipsp_intialized = initialized;
8327 g_dbus_emit_property_changed(dbus_conn, adapter->path,
8328 ADAPTER_INTERFACE, "IpspInitStateChanged");
8331 static void deinitialize_6lowpan_complete(uint8_t status, uint16_t length,
8332 const void *param, void *user_data)
8334 struct btd_adapter *adapter = user_data;
8335 bool initialized = FALSE;
8337 if (status != MGMT_STATUS_SUCCESS)
8338 error("De-Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
8339 adapter->dev_id, mgmt_errstr(status), status);
8341 adapter_set_ipsp_init_state(adapter, initialized);
8342 DBG("De-Initialize BT 6lowpan successfully for hci%u",
8347 static bool deinitialize_6lowpan(struct btd_adapter *adapter)
8349 struct mgmt_cp_enable_6lowpan cp;
8351 memset(&cp, 0, sizeof(cp));
8353 cp.enable_6lowpan = DEINIT_6LOWPAN;
8354 if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
8355 adapter->dev_id, sizeof(cp), &cp,
8356 deinitialize_6lowpan_complete, adapter, NULL) > 0)
8359 error("Failed to de-initialize BT 6Lowpan for index %u",
8364 static void initialize_6lowpan_complete(uint8_t status, uint16_t length,
8365 const void *param, void *user_data)
8367 struct btd_adapter *adapter = user_data;
8368 bool initialized = TRUE;
8370 if (status != MGMT_STATUS_SUCCESS)
8371 error("Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
8372 adapter->dev_id, mgmt_errstr(status), status);
8374 adapter_set_ipsp_init_state(adapter, initialized);
8375 DBG("Initialize BT 6lowpan successfully for hci%u",
8380 static bool initialize_6lowpan(struct btd_adapter *adapter)
8382 struct mgmt_cp_enable_6lowpan cp;
8384 memset(&cp, 0, sizeof(cp));
8386 cp.enable_6lowpan = INIT_6LOWPAN;
8387 if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
8388 adapter->dev_id, sizeof(cp), &cp,
8389 initialize_6lowpan_complete, adapter, NULL) > 0)
8392 error("Failed to initialize BT 6Lowpan for index %u",
8397 static DBusMessage *adapter_initialize_ipsp(DBusConnection *conn,
8398 DBusMessage *msg, void *data)
8400 struct btd_adapter *adapter = data;
8403 DBG("Initialize IPSP");
8405 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8406 return btd_error_not_ready(msg);
8408 if (adapter->ipsp_intialized)
8409 return btd_error_already_exists(msg);
8411 /* Enable BT 6lowpan in kernel */
8412 err = initialize_6lowpan(adapter);
8415 return btd_error_failed(msg, "Failed to initialize BT 6lowpan");
8417 return dbus_message_new_method_return(msg);
8420 static DBusMessage *adapter_deinitialize_ipsp(DBusConnection *conn,
8421 DBusMessage *msg, void *data)
8423 struct btd_adapter *adapter = data;
8426 DBG("De-initialize IPSP");
8428 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8429 return btd_error_not_ready(msg);
8431 if (!adapter->ipsp_intialized)
8432 return btd_error_not_permitted(msg, "IPSP not initialized");
8434 if (adapter_ipsp_connected(adapter))
8435 return btd_error_not_permitted(msg, "IPSP Client device found connected");
8437 /* Disable BT 6lowpan in kernel */
8438 err = deinitialize_6lowpan(adapter);
8441 return btd_error_failed(msg, "Failed to deinitialize BT 6lowpan");
8443 return dbus_message_new_method_return(msg);
8447 static const GDBusMethodTable adapter_methods[] = {
8448 { GDBUS_ASYNC_METHOD("StartDiscovery", NULL, NULL, start_discovery) },
8449 { GDBUS_METHOD("SetDiscoveryFilter",
8450 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8451 set_discovery_filter) },
8452 { GDBUS_ASYNC_METHOD("StopDiscovery", NULL, NULL, stop_discovery) },
8453 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8454 { GDBUS_METHOD("GetPSML2capLE",
8455 GDBUS_ARGS({ "path", "o"}),
8456 GDBUS_ARGS({ "psm", "i" }),
8457 adapter_get_psm_l2cap_le) },
8458 { GDBUS_METHOD("ListenL2capLESocket",
8459 GDBUS_ARGS({ "path", "o"}, { "psm", "i" }, { "options", "a{sv}" }),
8460 NULL, adapter_listen_l2cap_le_socket) },
8461 { GDBUS_METHOD("RemoveL2capLESocket", GDBUS_ARGS({ "path", "o" }),
8462 NULL, adapter_remove_l2cap_le_socket) },
8463 { GDBUS_METHOD("StartCustomDiscovery",
8464 GDBUS_ARGS({ "type", "s" }), NULL,
8465 adapter_start_custom_discovery) },
8466 { GDBUS_METHOD("StartLEDiscovery", NULL, NULL,
8467 adapter_start_le_discovery) },
8468 { GDBUS_ASYNC_METHOD("StopLEDiscovery", NULL, NULL,
8469 adapter_stop_le_discovery) },
8470 { GDBUS_METHOD("SetAdvertising",
8471 GDBUS_ARGS({ "enable", "b" },
8472 { "slot_id", "i" }), NULL,
8473 adapter_set_advertising) },
8474 { GDBUS_METHOD("SetAdvertisingParameters",
8475 GDBUS_ARGS({ "interval_min", "u" },
8476 { "interval_max", "u" },
8477 { "filter_policy", "u" },
8479 { "tx_power_level", "i" },
8480 { "slot_id", "i" }), NULL,
8481 adapter_set_advertising_params) },
8482 { GDBUS_METHOD("SetAdvertisingData",
8483 GDBUS_ARGS({ "value", "ay" },
8484 { "slot_id", "i" }), NULL,
8485 adapter_set_advertising_data) },
8486 { GDBUS_METHOD("SetScanParameters",
8487 GDBUS_ARGS({ "type", "u" },
8488 { "interval", "u" },
8489 { "window", "u" }), NULL,
8490 adapter_le_set_scan_params) },
8491 { GDBUS_ASYNC_METHOD("scan_filter_param_setup",
8492 GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
8493 { "filt_index", "i" }, { "feat_seln", "i"},
8494 { "list_logic_type", "i" }, { "filt_logic_type", "i"},
8495 { "rssi_high_thres", "i" }, { "rssi_low_thres", "i"},
8496 { "dely_mode", "i" }, { "found_timeout", "i"},
8497 { "lost_timeout", "i" }, { "found_timeout_cnt", "i"}), NULL,
8498 adapter_le_scan_filter_param_setup) },
8499 { GDBUS_ASYNC_METHOD("scan_filter_add_remove",
8500 GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
8501 { "filt_type", "i" }, { "filt_index", "i"},
8502 { "company_id", "i" }, { "company_id_mask", "i"},
8503 { "p_uuid", "ay" }, { "p_uuid_mask", "ay" },
8504 { "string", "s" }, { "address_type", "u" },
8505 /*{ "data_len", "i" },*/ { "p_data", "ay" },
8506 /*{ "mask_len", "i" },*/ { "p_mask", "ay" }), NULL,
8507 adapter_le_scan_filter_add_remove) },
8508 { GDBUS_ASYNC_METHOD("scan_filter_clear",
8509 GDBUS_ARGS({ "client_if", "i" }, { "filt_index", "i" }), NULL,
8510 adapter_le_scan_filter_clear) },
8511 { GDBUS_ASYNC_METHOD("scan_filter_enable",
8512 GDBUS_ARGS({ "client_if", "i" }, { "enable", "b" }), NULL,
8513 adapter_le_scan_filter_enable) },
8514 { GDBUS_METHOD("InitializeIpsp",
8516 adapter_initialize_ipsp) },
8517 { GDBUS_METHOD("DeinitializeIpsp",
8519 adapter_deinitialize_ipsp) },
8520 { GDBUS_METHOD("SetScanRespData",
8521 GDBUS_ARGS({ "value", "ay" },
8522 { "slot_id", "i" }), NULL,
8523 adapter_set_scan_rsp_data) },
8524 { GDBUS_METHOD("AddDeviceWhiteList",
8525 GDBUS_ARGS({ "address", "s" },
8526 { "address_type", "u" }), NULL,
8527 adapter_add_device_white_list) },
8528 { GDBUS_METHOD("RemoveDeviceWhiteList",
8529 GDBUS_ARGS({ "address", "s" },
8530 { "address_type", "u" }), NULL,
8531 adapter_remove_device_white_list) },
8532 { GDBUS_METHOD("ClearDeviceWhiteList",
8534 adapter_clear_device_white_list) },
8535 { GDBUS_METHOD("SetLePrivacy",
8536 GDBUS_ARGS({ "enable", "b" }), NULL,
8537 adapter_set_le_privacy) },
8538 { GDBUS_METHOD("SetLeStaticRandomAddress",
8539 GDBUS_ARGS({ "enable", "b" }), NULL,
8540 adapter_set_le_static_address) },
8541 { GDBUS_ASYNC_METHOD("EnableRssi",
8542 GDBUS_ARGS({ "bt_address", "s" },
8543 { "link_type", "i" },
8545 { "in_range_th", "i" },
8548 adapter_enable_rssi) },
8549 { GDBUS_ASYNC_METHOD("GetRssiStrength",
8550 GDBUS_ARGS({ "bt_address", "s" }, { "link_type", "i" }),
8552 adapter_get_rssi) },
8553 { GDBUS_ASYNC_METHOD("UnpairDevice",
8554 GDBUS_ARGS({ "device", "o" }), NULL, adapter_unpair_device) },
8555 { GDBUS_METHOD("FindDevice",
8556 GDBUS_ARGS({ "address", "s" }),
8557 GDBUS_ARGS({ "device", "o" }),
8559 { GDBUS_METHOD("SetWbsParameters",
8560 GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8562 set_wbs_parameters) },
8563 { GDBUS_METHOD("SetNbParameters",
8564 GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8566 set_nb_parameters) },
8567 { GDBUS_METHOD("SetManufacturerData",
8568 GDBUS_ARGS({ "value", "ay" }), NULL,
8569 adapter_set_manufacturer_data) },
8570 { GDBUS_ASYNC_METHOD("CreateDevice",
8571 GDBUS_ARGS({ "address", "s" }), NULL,
8573 { GDBUS_METHOD("GetEnergyInfo",
8575 GDBUS_ARGS({ "tx_time", "u" },
8577 { "idle_time", "u" },
8578 { "energy_used", "u" }),
8579 adapter_get_energy_info) },
8581 { GDBUS_ASYNC_METHOD("RemoveDevice",
8582 GDBUS_ARGS({ "device", "o" }), NULL, remove_device) },
8583 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8584 { GDBUS_ASYNC_METHOD("LEReadMaximumDataLength", NULL,
8585 GDBUS_ARGS({"maxTxOctets", "q" }, { "maxTxTime", "q" },
8586 {"maxRxOctets", "q" }, { "maxRxTime", "q" }),
8587 le_read_maximum_data_length)},
8588 { GDBUS_ASYNC_METHOD("LEWriteHostSuggestedDataLength",
8589 GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }), NULL,
8590 le_write_host_suggested_default_data_length)},
8591 { GDBUS_ASYNC_METHOD("LEReadHostSuggestedDataLength", NULL,
8592 GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }),
8593 le_read_host_suggested_default_data_length)},
8594 { GDBUS_ASYNC_METHOD("GetLeBatchingAvailablePkts",
8596 GDBUS_ARGS({ "AvailablePkts", "u" }),
8597 adapter_get_le_batching_available_pkts) },
8598 { GDBUS_ASYNC_METHOD("EnableLeBatching",
8599 GDBUS_ARGS({ "bt_address", "s" },
8600 { "packet_threshold", "i" },
8603 adapter_enable_le_batching) },
8604 { GDBUS_ASYNC_METHOD("DisableLeBatching",
8605 GDBUS_ARGS({ "bt_address", "s" }),
8607 adapter_disable_le_batching) },
8609 { GDBUS_METHOD("GetDiscoveryFilters", NULL,
8610 GDBUS_ARGS({ "filters", "as" }),
8611 get_discovery_filters) },
8612 { GDBUS_EXPERIMENTAL_ASYNC_METHOD("ConnectDevice",
8613 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8618 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8619 static const GDBusSignalTable adapter_signals[] = {
8620 { GDBUS_SIGNAL("AdvertisingEnabled",
8621 GDBUS_ARGS({ "slot_id", "i" },
8622 { "enabled", "b"})) },
8623 { GDBUS_SIGNAL("RssiEnabled",
8624 GDBUS_ARGS({"address","s"},
8625 { "link_type", "i" },
8626 { "enabled", "b"})) },
8627 { GDBUS_SIGNAL("RssiAlert",
8628 GDBUS_ARGS({"address","s"},
8629 { "link_type", "i" },
8630 { "alert_type", "i" },
8631 { "rssi_dbm", "i"})) },
8632 { GDBUS_SIGNAL("RawRssi",
8633 GDBUS_ARGS({"address","s"},
8634 { "link_type", "i" },
8635 { "rssi_dbm", "i"})) },
8636 { GDBUS_SIGNAL("HardwareError", NULL) },
8637 { GDBUS_SIGNAL("TxTimeoutError", NULL) },
8642 static const GDBusPropertyTable adapter_properties[] = {
8643 { "Address", "s", property_get_address },
8644 { "AddressType", "s", property_get_address_type },
8645 { "Name", "s", property_get_name },
8646 { "Alias", "s", property_get_alias, property_set_alias },
8647 { "Class", "u", property_get_class },
8648 { "Powered", "b", property_get_powered, property_set_powered },
8649 { "PowerState", "s", property_get_power_state, NULL, NULL,
8650 G_DBUS_PROPERTY_FLAG_EXPERIMENTAL },
8651 { "Discoverable", "b", property_get_discoverable,
8652 property_set_discoverable },
8653 { "DiscoverableTimeout", "u", property_get_discoverable_timeout,
8654 property_set_discoverable_timeout },
8655 { "Pairable", "b", property_get_pairable, property_set_pairable },
8656 { "PairableTimeout", "u", property_get_pairable_timeout,
8657 property_set_pairable_timeout },
8658 { "Discovering", "b", property_get_discovering },
8659 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8660 { "LEDiscovering", "b", property_get_le_discovering },
8662 { "UUIDs", "as", property_get_uuids },
8663 { "Modalias", "s", property_get_modalias, NULL,
8664 property_exists_modalias },
8665 { "Roles", "as", property_get_roles },
8666 { "ExperimentalFeatures", "as", property_get_experimental, NULL,
8667 property_experimental_exists },
8668 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8669 { "Connectable", "b", property_get_connectable,
8670 property_set_connectable },
8671 { "Version", "s", property_get_version },
8672 { "SupportedLEFeatures", "as", property_get_supported_le_features},
8673 { "IpspInitStateChanged", "b", property_get_ipsp_init_state},
8674 { "LEAddress", "as", property_get_le_address },
8675 { "A2dpRole", "u", property_get_a2dp_role },
8681 static int str2buf(const char *str, uint8_t *buf, size_t blen)
8688 memset(buf, 0, blen);
8690 dlen = MIN((strlen(str) / 2), blen);
8692 for (i = 0; i < dlen; i++)
8693 sscanf(str + (i * 2), "%02hhX", &buf[i]);
8698 static bool is_blocked_key(uint8_t key_type, uint8_t *key_value)
8702 for (i = 0; i < ARRAY_SIZE(blocked_keys); ++i) {
8703 if (key_type == blocked_keys[i].type &&
8704 !memcmp(blocked_keys[i].val, key_value,
8705 sizeof(blocked_keys[i].val)))
8712 static struct link_key_info *get_key_info(GKeyFile *key_file, const char *peer)
8714 struct link_key_info *info = NULL;
8717 str = g_key_file_get_string(key_file, "LinkKey", "Key", NULL);
8718 if (!str || strlen(str) < 32)
8721 info = g_new0(struct link_key_info, 1);
8723 str2ba(peer, &info->bdaddr);
8725 if (!strncmp(str, "0x", 2))
8726 str2buf(&str[2], info->key, sizeof(info->key));
8728 str2buf(&str[0], info->key, sizeof(info->key));
8730 info->type = g_key_file_get_integer(key_file, "LinkKey", "Type", NULL);
8731 info->pin_len = g_key_file_get_integer(key_file, "LinkKey", "PINLength",
8734 info->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8743 static struct smp_ltk_info *get_ltk(GKeyFile *key_file, const char *peer,
8744 uint8_t peer_type, const char *group)
8746 struct smp_ltk_info *ltk = NULL;
8750 key = g_key_file_get_string(key_file, group, "Key", NULL);
8751 if (!key || strlen(key) < 32)
8754 rand = g_key_file_get_string(key_file, group, "Rand", NULL);
8758 ltk = g_new0(struct smp_ltk_info, 1);
8760 /* Default to assuming a central key */
8761 ltk->central = true;
8763 str2ba(peer, <k->bdaddr);
8764 ltk->bdaddr_type = peer_type;
8767 * Long term keys should respond to an identity address which can
8768 * either be a public address or a random static address. Keys
8769 * stored for resolvable random and unresolvable random addresses
8772 * This is an extra sanity check for older kernel versions or older
8773 * daemons that might have been instructed to store long term keys
8774 * for these temporary addresses.
8776 if (ltk->bdaddr_type == BDADDR_LE_RANDOM &&
8777 (ltk->bdaddr.b[5] & 0xc0) != 0xc0) {
8783 if (!strncmp(key, "0x", 2))
8784 str2buf(&key[2], ltk->val, sizeof(ltk->val));
8786 str2buf(&key[0], ltk->val, sizeof(ltk->val));
8788 if (!strncmp(rand, "0x", 2)) {
8790 str2buf(&rand[2], (uint8_t *) &rand_le, sizeof(rand_le));
8791 ltk->rand = le64_to_cpu(rand_le);
8793 sscanf(rand, "%" PRIu64, <k->rand);
8796 ltk->authenticated = g_key_file_get_integer(key_file, group,
8797 "Authenticated", NULL);
8798 ltk->enc_size = g_key_file_get_integer(key_file, group, "EncSize",
8800 ltk->ediv = g_key_file_get_integer(key_file, group, "EDiv", NULL);
8802 ltk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LTK,
8812 static struct smp_ltk_info *get_ltk_info(GKeyFile *key_file, const char *peer,
8813 uint8_t bdaddr_type)
8817 return get_ltk(key_file, peer, bdaddr_type, "LongTermKey");
8820 static struct smp_ltk_info *get_peripheral_ltk_info(GKeyFile *key_file,
8822 uint8_t bdaddr_type)
8824 struct smp_ltk_info *ltk;
8828 /* Peripheral* is the proper term, but for now read both entries
8829 * so it won't break when user up/downgrades. Remove the other
8830 * term after a few releases.
8832 ltk = get_ltk(key_file, peer, bdaddr_type, "PeripheralLongTermKey");
8834 ltk = get_ltk(key_file, peer, bdaddr_type, "SlaveLongTermKey");
8837 ltk->central = false;
8842 static struct irk_info *get_irk_info(GKeyFile *key_file, const char *peer,
8843 uint8_t bdaddr_type)
8845 struct irk_info *irk = NULL;
8848 str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
8849 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8852 if (strlen(str) < 32) {
8857 if (!str || strlen(str) < 32)
8861 irk = g_new0(struct irk_info, 1);
8863 str2ba(peer, &irk->bdaddr);
8864 irk->bdaddr_type = bdaddr_type;
8866 if (!strncmp(str, "0x", 2))
8867 str2buf(&str[2], irk->val, sizeof(irk->val));
8869 str2buf(&str[0], irk->val, sizeof(irk->val));
8871 irk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8874 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
8882 static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
8883 uint8_t bdaddr_type)
8885 struct conn_param *param;
8887 if (!g_key_file_has_group(key_file, "ConnectionParameters"))
8890 param = g_new0(struct conn_param, 1);
8892 param->min_interval = g_key_file_get_integer(key_file,
8893 "ConnectionParameters",
8894 "MinInterval", NULL);
8895 param->max_interval = g_key_file_get_integer(key_file,
8896 "ConnectionParameters",
8897 "MaxInterval", NULL);
8898 param->latency = g_key_file_get_integer(key_file,
8899 "ConnectionParameters",
8901 param->timeout = g_key_file_get_integer(key_file,
8902 "ConnectionParameters",
8904 str2ba(peer, ¶m->bdaddr);
8905 param->bdaddr_type = bdaddr_type;
8911 static int generate_and_write_irk(uint8_t *irk, GKeyFile *key_file,
8912 const char *filename)
8914 struct bt_crypto *crypto;
8915 char str_irk_out[33];
8917 GError *gerr = NULL;
8921 crypto = bt_crypto_new();
8923 error("Failed to open crypto");
8927 if (!bt_crypto_random_bytes(crypto, irk, 16)) {
8928 error("Failed to generate IRK");
8929 bt_crypto_unref(crypto);
8933 bt_crypto_unref(crypto);
8935 for (i = 0; i < 16; i++)
8936 sprintf(str_irk_out + (i * 2), "%02x", irk[i]);
8938 str_irk_out[32] = '\0';
8939 info("Generated IRK successfully");
8941 g_key_file_set_string(key_file, "General", "IdentityResolvingKey",
8943 create_file(filename, S_IRUSR | S_IWUSR);
8944 str = g_key_file_to_data(key_file, &length, NULL);
8945 if (!g_file_set_contents(filename, str, length, &gerr)) {
8946 error("Unable set contents for %s: (%s)", filename,
8951 DBG("Generated IRK written to file");
8955 static int load_irk(struct btd_adapter *adapter, uint8_t *irk)
8957 char filename[PATH_MAX];
8959 GError *gerr = NULL;
8963 create_filename(filename, PATH_MAX, "/%s/identity",
8964 btd_adapter_get_storage_dir(adapter));
8966 key_file = g_key_file_new();
8967 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
8968 error("Unable to load key file from %s: (%s)", filename,
8973 str_irk = g_key_file_get_string(key_file, "General",
8974 "IdentityResolvingKey", NULL);
8976 info("No IRK stored");
8977 ret = generate_and_write_irk(irk, key_file, filename);
8978 g_key_file_free(key_file);
8982 g_key_file_free(key_file);
8984 if (strlen(str_irk) != 32 || str2buf(str_irk, irk, 16)) {
8985 /* TODO re-create new IRK here? */
8986 error("Invalid IRK format, disabling privacy");
8992 DBG("Successfully read IRK from file");
8996 static void set_privacy_complete(uint8_t status, uint16_t length,
8997 const void *param, void *user_data)
8999 struct btd_adapter *adapter = user_data;
9001 if (status != MGMT_STATUS_SUCCESS) {
9002 btd_error(adapter->dev_id, "Failed to set privacy: %s (0x%02x)",
9003 mgmt_errstr(status), status);
9007 DBG("Successfuly set privacy for index %u", adapter->dev_id);
9010 static int set_privacy(struct btd_adapter *adapter, uint8_t privacy)
9012 struct mgmt_cp_set_privacy cp;
9014 memset(&cp, 0, sizeof(cp));
9019 if (load_irk(adapter, irk) == 0) {
9020 cp.privacy = privacy;
9021 memcpy(cp.irk, irk, 16);
9025 DBG("sending set privacy command for index %u", adapter->dev_id);
9026 DBG("setting privacy mode 0x%02x for index %u", cp.privacy,
9029 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
9030 adapter->dev_id, sizeof(cp), &cp,
9031 set_privacy_complete, adapter, NULL) > 0)
9034 btd_error(adapter->dev_id, "Failed to set privacy for index %u",
9041 static void load_link_keys_complete(uint8_t status, uint16_t length,
9042 const void *param, void *user_data)
9044 struct btd_adapter *adapter = user_data;
9046 if (status != MGMT_STATUS_SUCCESS) {
9047 btd_error(adapter->dev_id,
9048 "Failed to load link keys for hci%u: %s (0x%02x)",
9049 adapter->dev_id, mgmt_errstr(status), status);
9053 DBG("link keys loaded for hci%u", adapter->dev_id);
9056 static void load_link_keys(struct btd_adapter *adapter, GSList *keys,
9059 struct mgmt_cp_load_link_keys *cp;
9060 struct mgmt_link_key_info *key;
9061 size_t key_count, cp_size;
9066 * If the controller does not support BR/EDR operation,
9067 * there is no point in trying to load the link keys into
9070 * This is an optimization for Low Energy only controllers.
9072 if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
9075 key_count = g_slist_length(keys);
9077 DBG("hci%u keys %zu debug_keys %d", adapter->dev_id, key_count,
9080 cp_size = sizeof(*cp) + (key_count * sizeof(*key));
9082 cp = g_try_malloc0(cp_size);
9084 btd_error(adapter->dev_id, "No memory for link keys for hci%u",
9090 * Even if the list of stored keys is empty, it is important to
9091 * load an empty list into the kernel. That way it is ensured
9092 * that no old keys from a previous daemon are present.
9094 * In addition it is also the only way to toggle the different
9095 * behavior for debug keys.
9097 cp->debug_keys = debug_keys;
9098 cp->key_count = htobs(key_count);
9100 for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
9101 struct link_key_info *info = l->data;
9103 bacpy(&key->addr.bdaddr, &info->bdaddr);
9104 key->addr.type = BDADDR_BREDR;
9105 key->type = info->type;
9106 memcpy(key->val, info->key, 16);
9107 key->pin_len = info->pin_len;
9110 id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_LINK_KEYS,
9111 adapter->dev_id, cp_size, cp,
9112 load_link_keys_complete, adapter, NULL);
9117 btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
9121 static void load_ltks_complete(uint8_t status, uint16_t length,
9122 const void *param, void *user_data)
9124 struct btd_adapter *adapter = user_data;
9126 if (status != MGMT_STATUS_SUCCESS) {
9127 btd_error(adapter->dev_id,
9128 "Failed to load LTKs for hci%u: %s (0x%02x)",
9129 adapter->dev_id, mgmt_errstr(status), status);
9132 DBG("LTKs loaded for hci%u", adapter->dev_id);
9135 static void load_ltks(struct btd_adapter *adapter, GSList *keys)
9137 struct mgmt_cp_load_long_term_keys *cp;
9138 struct mgmt_ltk_info *key;
9139 size_t key_count, max_key_count, cp_size;
9144 * If the controller does not support Low Energy operation,
9145 * there is no point in trying to load the long term keys
9148 * While there is no harm in loading keys into the kernel,
9149 * this is an optimization to avoid a confusing warning
9150 * message when the loading of the keys timed out due to
9151 * a kernel bug (see comment below).
9153 if (!(adapter->supported_settings & MGMT_SETTING_LE))
9156 key_count = g_slist_length(keys);
9157 mtu = mgmt_get_mtu(adapter->mgmt);
9158 max_key_count = (mtu - sizeof(*cp)) / sizeof(*key);
9159 key_count = MIN(max_key_count, key_count);
9161 DBG("hci%u keys %zu", adapter->dev_id, key_count);
9163 cp_size = sizeof(*cp) + (key_count * sizeof(*key));
9165 cp = g_try_malloc0(cp_size);
9167 btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
9173 * Even if the list of stored keys is empty, it is important to
9174 * load an empty list into the kernel. That way it is ensured
9175 * that no old keys from a previous daemon are present.
9177 cp->key_count = htobs(key_count);
9179 for (l = keys, key = cp->keys; l && key_count;
9180 l = g_slist_next(l), key++, key_count--) {
9181 struct smp_ltk_info *info = l->data;
9182 struct btd_device *dev;
9184 bacpy(&key->addr.bdaddr, &info->bdaddr);
9185 key->addr.type = info->bdaddr_type;
9186 memcpy(key->val, info->val, sizeof(info->val));
9187 key->rand = cpu_to_le64(info->rand);
9188 key->ediv = cpu_to_le16(info->ediv);
9189 key->type = info->authenticated;
9190 key->central = info->central;
9191 key->enc_size = info->enc_size;
9193 /* Mark device as paired as their LTKs can be loaded. */
9194 dev = btd_adapter_find_device(adapter, &info->bdaddr,
9197 device_set_paired(dev, info->bdaddr_type);
9198 device_set_bonded(dev, info->bdaddr_type);
9199 device_set_ltk(dev, info->val, info->central,
9205 * This timeout handling is needed since the kernel is stupid
9206 * and forgets to send a command complete response. However in
9207 * case of failures it does send a command status.
9209 if (!mgmt_send_timeout(adapter->mgmt, MGMT_OP_LOAD_LONG_TERM_KEYS,
9210 adapter->dev_id, cp_size, cp, load_ltks_complete,
9212 btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
9218 static void load_irks_complete(uint8_t status, uint16_t length,
9219 const void *param, void *user_data)
9221 struct btd_adapter *adapter = user_data;
9223 if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
9224 btd_info(adapter->dev_id,
9225 "Load IRKs failed: Kernel doesn't support LE Privacy");
9229 if (status != MGMT_STATUS_SUCCESS) {
9230 btd_error(adapter->dev_id,
9231 "Failed to load IRKs for hci%u: %s (0x%02x)",
9232 adapter->dev_id, mgmt_errstr(status), status);
9236 DBG("IRKs loaded for hci%u", adapter->dev_id);
9239 static void load_irks(struct btd_adapter *adapter, GSList *irks)
9241 struct mgmt_cp_load_irks *cp;
9242 struct mgmt_irk_info *irk;
9243 size_t irk_count, cp_size;
9248 * If the controller does not support LE Privacy operation,
9249 * there is no support for loading identity resolving keys
9252 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
9255 irk_count = g_slist_length(irks);
9257 DBG("hci%u irks %zu", adapter->dev_id, irk_count);
9259 cp_size = sizeof(*cp) + (irk_count * sizeof(*irk));
9261 cp = g_try_malloc0(cp_size);
9263 btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
9269 * Even if the list of stored keys is empty, it is important to
9270 * load an empty list into the kernel. That way we tell the
9271 * kernel that we are able to handle New IRK events.
9273 cp->irk_count = htobs(irk_count);
9275 for (l = irks, irk = cp->irks; l != NULL; l = g_slist_next(l), irk++) {
9276 struct irk_info *info = l->data;
9278 bacpy(&irk->addr.bdaddr, &info->bdaddr);
9279 irk->addr.type = info->bdaddr_type;
9280 memcpy(irk->val, info->val, sizeof(irk->val));
9283 id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_IRKS, adapter->dev_id,
9284 cp_size, cp, load_irks_complete, adapter, NULL);
9289 btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
9293 static void load_conn_params_complete(uint8_t status, uint16_t length,
9294 const void *param, void *user_data)
9296 struct btd_adapter *adapter = user_data;
9298 if (status != MGMT_STATUS_SUCCESS) {
9299 btd_error(adapter->dev_id,
9300 "hci%u Load Connection Parameters failed: %s (0x%02x)",
9301 adapter->dev_id, mgmt_errstr(status), status);
9305 DBG("Connection Parameters loaded for hci%u", adapter->dev_id);
9308 static void load_conn_params(struct btd_adapter *adapter, GSList *params)
9310 struct mgmt_cp_load_conn_param *cp;
9311 struct mgmt_conn_param *param;
9312 size_t param_count, cp_size;
9317 * If the controller does not support Low Energy operation,
9318 * there is no point in trying to load the connection
9319 * parameters into the kernel.
9321 if (!(adapter->supported_settings & MGMT_SETTING_LE))
9324 param_count = g_slist_length(params);
9326 DBG("hci%u conn params %zu", adapter->dev_id, param_count);
9328 cp_size = sizeof(*cp) + (param_count * sizeof(*param));
9330 cp = g_try_malloc0(cp_size);
9332 btd_error(adapter->dev_id,
9333 "Failed to allocate memory for connection parameters");
9337 cp->param_count = htobs(param_count);
9339 for (l = params, param = cp->params; l; l = g_slist_next(l), param++) {
9340 struct conn_param *info = l->data;
9342 bacpy(¶m->addr.bdaddr, &info->bdaddr);
9343 param->addr.type = info->bdaddr_type;
9344 param->min_interval = htobs(info->min_interval);
9345 param->max_interval = htobs(info->max_interval);
9346 param->latency = htobs(info->latency);
9347 param->timeout = htobs(info->timeout);
9350 id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_PARAM, adapter->dev_id,
9351 cp_size, cp, load_conn_params_complete, adapter, NULL);
9356 btd_error(adapter->dev_id, "Load connection parameters failed");
9359 static uint8_t get_le_addr_type(GKeyFile *keyfile)
9364 type = g_key_file_get_string(keyfile, "General", "AddressType", NULL);
9366 return BDADDR_LE_PUBLIC;
9368 if (g_str_equal(type, "public"))
9369 addr_type = BDADDR_LE_PUBLIC;
9370 else if (g_str_equal(type, "static"))
9371 addr_type = BDADDR_LE_RANDOM;
9373 addr_type = BDADDR_LE_PUBLIC;
9380 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9381 static uint8_t get_addr_type(GKeyFile *keyfile)
9385 uint8_t bdaddr_type = BDADDR_BREDR;
9388 /* Load device technology */
9389 techno = g_key_file_get_string_list(keyfile, "General",
9390 "SupportedTechnologies", NULL, NULL);
9394 for (t = techno; *t; t++) {
9395 if (g_str_equal(*t, "LE"))
9400 bdaddr_type = BDADDR_BREDR;
9402 str = g_key_file_get_string(keyfile, "General",
9403 "AddressType", NULL);
9405 if (str && g_str_equal(str, "public"))
9406 bdaddr_type = BDADDR_LE_PUBLIC;
9407 else if (str && g_str_equal(str, "static"))
9408 bdaddr_type = BDADDR_LE_RANDOM;
9410 error("Unknown LE device technology");
9421 static void probe_devices(void *user_data)
9423 struct btd_device *device = user_data;
9425 device_probe_profiles(device, btd_device_get_uuids(device));
9426 device_resolved_drivers(device_get_adapter(device), device);
9429 static bool load_bredr_defaults(struct btd_adapter *adapter,
9430 struct mgmt_tlv_list *list,
9431 struct btd_br_defaults *defaults)
9433 if (btd_opts.mode == BT_MODE_LE)
9436 if (defaults->page_scan_type != 0xFFFF) {
9437 if (!mgmt_tlv_add_fixed(list, 0x0000,
9438 &defaults->page_scan_type))
9442 if (defaults->page_scan_interval) {
9443 if (!mgmt_tlv_add_fixed(list, 0x0001,
9444 &defaults->page_scan_interval))
9448 if (defaults->page_scan_win) {
9449 if (!mgmt_tlv_add_fixed(list, 0x0002,
9450 &defaults->page_scan_win))
9454 if (defaults->scan_type != 0xFFFF) {
9455 if (!mgmt_tlv_add_fixed(list, 0x0003,
9456 &defaults->scan_type))
9460 if (defaults->scan_interval) {
9461 if (!mgmt_tlv_add_fixed(list, 0x0004,
9462 &defaults->scan_interval))
9466 if (defaults->scan_win) {
9467 if (!mgmt_tlv_add_fixed(list, 0x0005,
9468 &defaults->scan_win))
9472 if (defaults->link_supervision_timeout) {
9473 if (!mgmt_tlv_add_fixed(list, 0x0006,
9474 &defaults->link_supervision_timeout))
9478 if (defaults->page_timeout) {
9479 if (!mgmt_tlv_add_fixed(list, 0x0007,
9480 &defaults->page_timeout))
9484 if (defaults->min_sniff_interval) {
9485 if (!mgmt_tlv_add_fixed(list, 0x0008,
9486 &defaults->min_sniff_interval))
9490 if (defaults->max_sniff_interval) {
9491 if (!mgmt_tlv_add_fixed(list, 0x0009,
9492 &defaults->max_sniff_interval))
9499 static bool load_le_defaults(struct btd_adapter *adapter,
9500 struct mgmt_tlv_list *list,
9501 struct btd_le_defaults *defaults)
9503 if (btd_opts.mode == BT_MODE_BREDR)
9506 if (defaults->min_adv_interval) {
9507 if (!mgmt_tlv_add_fixed(list, 0x000a,
9508 &defaults->min_adv_interval))
9512 if (defaults->max_adv_interval) {
9513 if (!mgmt_tlv_add_fixed(list, 0x000b,
9514 &defaults->max_adv_interval))
9518 if (defaults->adv_rotation_interval) {
9519 if (!mgmt_tlv_add_fixed(list, 0x000c,
9520 &defaults->adv_rotation_interval))
9524 if (defaults->scan_interval_autoconnect) {
9525 if (!mgmt_tlv_add_fixed(list, 0x000d,
9526 &defaults->scan_interval_autoconnect))
9530 if (defaults->scan_win_autoconnect) {
9531 if (!mgmt_tlv_add_fixed(list, 0x000e,
9532 &defaults->scan_win_autoconnect))
9536 if (defaults->scan_interval_suspend) {
9537 if (!mgmt_tlv_add_fixed(list, 0x000f,
9538 &defaults->scan_interval_suspend))
9542 if (defaults->scan_win_suspend) {
9543 if (!mgmt_tlv_add_fixed(list, 0x0010,
9544 &defaults->scan_win_suspend))
9548 if (defaults->scan_interval_discovery) {
9549 if (!mgmt_tlv_add_fixed(list, 0x0011,
9550 &defaults->scan_interval_discovery))
9554 if (defaults->scan_win_discovery) {
9555 if (!mgmt_tlv_add_fixed(list, 0x0012,
9556 &defaults->scan_win_discovery))
9560 if (defaults->scan_interval_adv_monitor) {
9561 if (!mgmt_tlv_add_fixed(list, 0x0013,
9562 &defaults->scan_interval_adv_monitor))
9566 if (defaults->scan_win_adv_monitor) {
9567 if (!mgmt_tlv_add_fixed(list, 0x0014,
9568 &defaults->scan_win_adv_monitor))
9572 if (defaults->scan_interval_connect) {
9573 if (!mgmt_tlv_add_fixed(list, 0x0015,
9574 &defaults->scan_interval_connect))
9578 if (defaults->scan_win_connect) {
9579 if (!mgmt_tlv_add_fixed(list, 0x0016,
9580 &defaults->scan_win_connect))
9584 if (defaults->min_conn_interval) {
9585 if (!mgmt_tlv_add_fixed(list, 0x0017,
9586 &defaults->min_conn_interval))
9590 if (defaults->max_conn_interval) {
9591 if (!mgmt_tlv_add_fixed(list, 0x0018,
9592 &defaults->max_conn_interval))
9596 if (defaults->conn_latency) {
9597 if (!mgmt_tlv_add_fixed(list, 0x0019,
9598 &defaults->conn_latency))
9602 if (defaults->conn_lsto) {
9603 if (!mgmt_tlv_add_fixed(list, 0x001a,
9604 &defaults->conn_lsto))
9608 if (defaults->autoconnect_timeout) {
9609 if (!mgmt_tlv_add_fixed(list, 0x001b,
9610 &defaults->autoconnect_timeout))
9614 if (defaults->advmon_allowlist_scan_duration) {
9615 if (!mgmt_tlv_add_fixed(list, 0x001d,
9616 &defaults->advmon_allowlist_scan_duration))
9620 if (defaults->advmon_no_filter_scan_duration) {
9621 if (!mgmt_tlv_add_fixed(list, 0x001e,
9622 &defaults->advmon_no_filter_scan_duration))
9626 if (defaults->enable_advmon_interleave_scan != 0xFF) {
9627 if (!mgmt_tlv_add_fixed(list, 0x001f,
9628 &defaults->enable_advmon_interleave_scan))
9635 static void load_defaults(struct btd_adapter *adapter)
9637 struct mgmt_tlv_list *list;
9638 unsigned int err = 0;
9640 if (!btd_opts.defaults.num_entries ||
9641 !btd_has_kernel_features(KERNEL_SET_SYSTEM_CONFIG))
9644 list = mgmt_tlv_list_new();
9646 if (!load_bredr_defaults(adapter, list, &btd_opts.defaults.br))
9649 if (!load_le_defaults(adapter, list, &btd_opts.defaults.le))
9652 err = mgmt_send_tlv(adapter->mgmt, MGMT_OP_SET_DEF_SYSTEM_CONFIG,
9653 adapter->dev_id, list, NULL, NULL, NULL);
9657 btd_error(adapter->dev_id,
9658 "Failed to set default system config for hci%u",
9661 mgmt_tlv_list_free(list);
9664 static void load_devices(struct btd_adapter *adapter)
9666 char dirname[PATH_MAX];
9667 GSList *keys = NULL;
9668 GSList *ltks = NULL;
9669 GSList *irks = NULL;
9670 GSList *params = NULL;
9671 GSList *added_devices = NULL;
9672 GError *gerr = NULL;
9674 struct dirent *entry;
9676 create_filename(dirname, PATH_MAX, "/%s",
9677 btd_adapter_get_storage_dir(adapter));
9679 dir = opendir(dirname);
9681 btd_error(adapter->dev_id,
9682 "Unable to open adapter storage directory: %s",
9687 while ((entry = readdir(dir)) != NULL) {
9688 struct btd_device *device;
9689 char filename[PATH_MAX];
9691 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9692 struct link_key_info *key_info = NULL;
9693 struct smp_ltk_info *ltk_info = NULL;
9694 struct smp_ltk_info *peripheral_ltk_info;
9695 GSList *list = NULL;
9696 struct device_addr_type addr;
9698 struct link_key_info *key_info;
9699 struct smp_ltk_info *ltk_info;
9700 struct smp_ltk_info *peripheral_ltk_info;
9703 struct irk_info *irk_info;
9704 struct conn_param *param;
9705 uint8_t bdaddr_type;
9707 if (entry->d_type == DT_UNKNOWN)
9708 entry->d_type = util_get_dt(dirname, entry->d_name);
9710 if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
9713 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9717 str2ba(entry->d_name, &bdaddr);
9719 if (!bacmp(&bdaddr, BDADDR_ANY)) {
9720 error("No Bluetooth address");
9725 create_filename(filename, PATH_MAX, "/%s/%s/info",
9726 btd_adapter_get_storage_dir(adapter),
9729 key_file = g_key_file_new();
9730 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
9731 error("Unable to load key file from %s: (%s)", filename,
9733 g_clear_error(&gerr);
9736 key_info = get_key_info(key_file, entry->d_name);
9738 bdaddr_type = get_le_addr_type(key_file);
9740 ltk_info = get_ltk_info(key_file, entry->d_name, bdaddr_type);
9742 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9743 entry->d_name, bdaddr_type);
9745 irk_info = get_irk_info(key_file, entry->d_name, bdaddr_type);
9747 // If any key for the device is blocked, we discard all.
9748 if ((key_info && key_info->is_blocked) ||
9749 (ltk_info && ltk_info->is_blocked) ||
9750 (peripheral_ltk_info &&
9751 peripheral_ltk_info->is_blocked) ||
9752 (irk_info && irk_info->is_blocked)) {
9764 if (peripheral_ltk_info) {
9765 g_free(peripheral_ltk_info);
9766 peripheral_ltk_info = NULL;
9778 keys = g_slist_append(keys, key_info);
9781 ltks = g_slist_append(ltks, ltk_info);
9783 if (peripheral_ltk_info)
9784 ltks = g_slist_append(ltks, peripheral_ltk_info);
9787 irks = g_slist_append(irks, irk_info);
9789 param = get_conn_param(key_file, entry->d_name, bdaddr_type);
9791 params = g_slist_append(params, param);
9793 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9794 str2ba(entry->d_name, &addr.bdaddr);
9795 addr.bdaddr_type = get_addr_type(key_file);
9796 if (addr.bdaddr_type == 0xff) {
9797 error("No SupportedTechnologies. Skipping");
9801 list = g_slist_find_custom(adapter->devices, &addr,
9802 device_addr_type_strict_cmp);
9804 list = g_slist_find_custom(adapter->devices, entry->d_name,
9805 device_address_cmp);
9808 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9809 DBG("Skip already loaded device [%s] [%d]",
9810 entry->d_name, addr.bdaddr_type);
9812 device = list->data;
9816 device = device_create_from_storage(adapter, entry->d_name,
9821 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9826 * After loading IRK information from file,
9827 * store it into device->bdaddr.
9828 * RPA is stored in device->rpa_addr
9830 ba2str(device_get_address(device), idaddr);
9832 DBG("irk address: %s, rpa_exist %d",
9833 idaddr, device_get_rpa_exist(device));
9835 if (device_get_rpa_exist(device) == true) {
9837 str2ba(idaddr, &key_info->bdaddr);
9840 ltks = g_slist_remove(ltks, ltk_info);
9841 ltk_info = get_ltk_info(key_file,
9842 idaddr, bdaddr_type);
9844 ltks = g_slist_append(ltks, ltk_info);
9847 if (peripheral_ltk_info) {
9848 ltks = g_slist_remove(ltks, peripheral_ltk_info);
9849 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9850 idaddr, bdaddr_type);
9851 if (peripheral_ltk_info)
9852 ltks = g_slist_append(ltks, peripheral_ltk_info);
9856 str2ba(idaddr, &irk_info->bdaddr);
9857 device_set_irk_value(device, irk_info->val);
9861 str2ba(idaddr, ¶m->bdaddr);
9866 device_set_rpa(device, true);
9868 btd_device_set_temporary(device, false);
9869 adapter_add_device(adapter, device);
9871 /* TODO: register services from pre-loaded list of primaries */
9873 added_devices = g_slist_append(added_devices, device);
9877 device_set_paired(device, BDADDR_BREDR);
9878 device_set_bonded(device, BDADDR_BREDR);
9882 g_key_file_free(key_file);
9887 load_link_keys(adapter, keys, btd_opts.debug_keys);
9888 g_slist_free_full(keys, g_free);
9890 load_ltks(adapter, ltks);
9891 g_slist_free_full(ltks, g_free);
9892 load_irks(adapter, irks);
9893 g_slist_free_full(irks, g_free);
9894 load_conn_params(adapter, params);
9895 g_slist_free_full(params, g_free);
9897 g_slist_free_full(added_devices, probe_devices);
9900 int btd_adapter_block_address(struct btd_adapter *adapter,
9901 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9903 struct mgmt_cp_block_device cp;
9906 ba2str(bdaddr, addr);
9907 DBG("hci%u %s", adapter->dev_id, addr);
9909 memset(&cp, 0, sizeof(cp));
9910 bacpy(&cp.addr.bdaddr, bdaddr);
9911 cp.addr.type = bdaddr_type;
9913 if (mgmt_send(adapter->mgmt, MGMT_OP_BLOCK_DEVICE,
9914 adapter->dev_id, sizeof(cp), &cp,
9915 NULL, NULL, NULL) > 0)
9921 int btd_adapter_unblock_address(struct btd_adapter *adapter,
9922 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9924 struct mgmt_cp_unblock_device cp;
9927 ba2str(bdaddr, addr);
9928 DBG("hci%u %s", adapter->dev_id, addr);
9930 memset(&cp, 0, sizeof(cp));
9931 bacpy(&cp.addr.bdaddr, bdaddr);
9932 cp.addr.type = bdaddr_type;
9934 if (mgmt_send(adapter->mgmt, MGMT_OP_UNBLOCK_DEVICE,
9935 adapter->dev_id, sizeof(cp), &cp,
9936 NULL, NULL, NULL) > 0)
9942 static int clear_blocked(struct btd_adapter *adapter)
9944 return btd_adapter_unblock_address(adapter, BDADDR_ANY, 0);
9947 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
9949 struct btd_adapter_driver *driver = user_data;
9952 if (driver->probe == NULL)
9955 err = driver->probe(adapter);
9957 btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
9958 strerror(-err), -err);
9962 adapter->drivers = g_slist_prepend(adapter->drivers, driver);
9965 static void load_drivers(struct btd_adapter *adapter)
9969 for (l = adapter_drivers; l; l = l->next)
9970 probe_driver(adapter, l->data);
9973 static void probe_profile(struct btd_profile *profile, void *data)
9975 struct btd_adapter *adapter = data;
9978 if (profile->adapter_probe == NULL)
9981 err = profile->adapter_probe(profile, adapter);
9983 btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
9984 strerror(-err), -err);
9988 adapter->profiles = g_slist_prepend(adapter->profiles, profile);
9991 void adapter_add_profile(struct btd_adapter *adapter, gpointer p)
9993 struct btd_profile *profile = p;
9995 if (!adapter->initialized)
9998 probe_profile(profile, adapter);
10000 g_slist_foreach(adapter->devices, device_probe_profile, profile);
10003 void adapter_remove_profile(struct btd_adapter *adapter, gpointer p)
10005 struct btd_profile *profile = p;
10007 if (!adapter->initialized)
10010 if (profile->device_remove)
10011 g_slist_foreach(adapter->devices, device_remove_profile, p);
10013 adapter->profiles = g_slist_remove(adapter->profiles, profile);
10015 if (profile->adapter_remove)
10016 profile->adapter_remove(profile, adapter);
10019 static void device_added_drivers(struct btd_adapter *adapter,
10020 struct btd_device *device)
10022 struct btd_adapter_driver *driver;
10025 for (l = adapter_drivers; l; l = l->next) {
10028 if (driver->device_added)
10029 driver->device_added(adapter, device);
10033 static void device_removed_drivers(struct btd_adapter *adapter,
10034 struct btd_device *device)
10036 struct btd_adapter_driver *driver;
10039 for (l = adapter_drivers; l; l = l->next) {
10042 if (driver->device_removed)
10043 driver->device_removed(adapter, device);
10047 void device_resolved_drivers(struct btd_adapter *adapter,
10048 struct btd_device *device)
10050 struct btd_adapter_driver *driver;
10053 for (l = adapter_drivers; l; l = l->next) {
10056 if (driver->device_resolved)
10057 driver->device_resolved(adapter, device);
10061 static void adapter_add_device(struct btd_adapter *adapter,
10062 struct btd_device *device)
10064 adapter->devices = g_slist_append(adapter->devices, device);
10065 device_added_drivers(adapter, device);
10068 static void adapter_remove_device(struct btd_adapter *adapter,
10069 struct btd_device *device)
10071 adapter->devices = g_slist_remove(adapter->devices, device);
10072 device_removed_drivers(adapter, device);
10075 static void adapter_add_connection(struct btd_adapter *adapter,
10076 struct btd_device *device,
10077 uint8_t bdaddr_type)
10079 device_add_connection(device, bdaddr_type);
10081 if (g_slist_find(adapter->connections, device)) {
10082 btd_error(adapter->dev_id,
10083 "Device is already marked as connected");
10087 adapter->connections = g_slist_append(adapter->connections, device);
10090 static void get_connections_complete(uint8_t status, uint16_t length,
10091 const void *param, void *user_data)
10093 struct btd_adapter *adapter = user_data;
10094 const struct mgmt_rp_get_connections *rp = param;
10095 uint16_t i, conn_count;
10097 if (status != MGMT_STATUS_SUCCESS) {
10098 btd_error(adapter->dev_id,
10099 "Failed to get connections: %s (0x%02x)",
10100 mgmt_errstr(status), status);
10104 if (length < sizeof(*rp)) {
10105 btd_error(adapter->dev_id,
10106 "Wrong size of get connections response");
10110 conn_count = btohs(rp->conn_count);
10112 DBG("Connection count: %d", conn_count);
10114 if (conn_count * sizeof(struct mgmt_addr_info) +
10115 sizeof(*rp) != length) {
10116 btd_error(adapter->dev_id,
10117 "Incorrect packet size for get connections response");
10121 for (i = 0; i < conn_count; i++) {
10122 const struct mgmt_addr_info *addr = &rp->addr[i];
10123 struct btd_device *device;
10126 ba2str(&addr->bdaddr, address);
10127 DBG("Adding existing connection to %s", address);
10129 device = btd_adapter_get_device(adapter, &addr->bdaddr,
10132 adapter_add_connection(adapter, device, addr->type);
10136 static void load_connections(struct btd_adapter *adapter)
10138 DBG("sending get connections command for index %u", adapter->dev_id);
10140 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_CONNECTIONS,
10141 adapter->dev_id, 0, NULL,
10142 get_connections_complete, adapter, NULL) > 0)
10145 btd_error(adapter->dev_id, "Failed to get connections for index %u",
10149 bool btd_adapter_get_pairable(struct btd_adapter *adapter)
10151 if (adapter->current_settings & MGMT_SETTING_BONDABLE)
10157 bool btd_adapter_get_powered(struct btd_adapter *adapter)
10159 if ((adapter->current_settings & MGMT_SETTING_POWERED) &&
10160 !(adapter->pending_settings & MGMT_SETTING_POWERED))
10166 bool btd_adapter_get_connectable(struct btd_adapter *adapter)
10168 if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
10174 bool btd_adapter_get_discoverable(struct btd_adapter *adapter)
10176 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
10182 bool btd_adapter_get_bredr(struct btd_adapter *adapter)
10184 if (adapter->current_settings & MGMT_SETTING_BREDR)
10190 struct btd_gatt_database *btd_adapter_get_database(struct btd_adapter *adapter)
10195 return adapter->database;
10198 uint32_t btd_adapter_get_class(struct btd_adapter *adapter)
10200 return adapter->dev_class;
10203 const char *btd_adapter_get_name(struct btd_adapter *adapter)
10205 if (adapter->stored_alias)
10206 return adapter->stored_alias;
10208 if (adapter->system_name)
10209 return adapter->system_name;
10214 int adapter_connect_list_add(struct btd_adapter *adapter,
10215 struct btd_device *device)
10218 * If the adapter->connect_le device is getting added back to
10219 * the connect list it probably means that the connect attempt
10220 * failed and hence we should clear this pointer
10222 if (device == adapter->connect_le)
10223 adapter->connect_le = NULL;
10226 * If kernel background scanning is supported then the
10227 * adapter_auto_connect_add() function is used to maintain what to
10230 if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10233 if (g_slist_find(adapter->connect_list, device)) {
10234 DBG("ignoring already added device %s",
10235 device_get_path(device));
10239 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
10240 btd_error(adapter->dev_id,
10241 "Can't add %s to non-LE capable adapter connect list",
10242 device_get_path(device));
10246 adapter->connect_list = g_slist_append(adapter->connect_list, device);
10247 DBG("%s added to %s's connect_list", device_get_path(device),
10248 adapter->system_name);
10251 if (!btd_adapter_get_powered(adapter))
10254 trigger_passive_scanning(adapter);
10259 void adapter_connect_list_remove(struct btd_adapter *adapter,
10260 struct btd_device *device)
10263 * If the adapter->connect_le device is being removed from the
10264 * connect list it means the connection was successful and hence
10265 * the pointer should be cleared
10267 if (device == adapter->connect_le)
10268 adapter->connect_le = NULL;
10270 if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10273 if (!g_slist_find(adapter->connect_list, device)) {
10274 DBG("device %s is not on the list, ignoring",
10275 device_get_path(device));
10279 adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10280 DBG("%s removed from %s's connect_list", device_get_path(device),
10281 adapter->system_name);
10283 if (!adapter->connect_list) {
10284 stop_passive_scanning(adapter);
10288 if (!btd_adapter_get_powered(adapter))
10291 trigger_passive_scanning(adapter);
10294 static void add_accept_list_complete(uint8_t status, uint16_t length,
10295 const void *param, void *user_data)
10297 const struct mgmt_rp_add_device *rp = param;
10298 struct btd_adapter *adapter = user_data;
10299 struct btd_device *dev;
10302 if (length < sizeof(*rp)) {
10303 btd_error(adapter->dev_id,
10304 "Too small Add Device complete event");
10308 ba2str(&rp->addr.bdaddr, addr);
10310 dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10313 btd_error(adapter->dev_id,
10314 "Add Device complete for unknown device %s", addr);
10318 if (status != MGMT_STATUS_SUCCESS) {
10319 btd_error(adapter->dev_id,
10320 "Failed to add device %s: %s (0x%02x)",
10321 addr, mgmt_errstr(status), status);
10325 DBG("%s added to kernel accept list", addr);
10328 void adapter_accept_list_add(struct btd_adapter *adapter,
10329 struct btd_device *dev)
10331 struct mgmt_cp_add_device cp;
10333 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10336 memset(&cp, 0, sizeof(cp));
10337 bacpy(&cp.addr.bdaddr, device_get_address(dev));
10338 cp.addr.type = BDADDR_BREDR;
10341 mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10342 adapter->dev_id, sizeof(cp), &cp,
10343 add_accept_list_complete, adapter, NULL);
10346 static void remove_accept_list_complete(uint8_t status, uint16_t length,
10347 const void *param, void *user_data)
10349 const struct mgmt_rp_remove_device *rp = param;
10352 if (length < sizeof(*rp)) {
10353 error("Too small Remove Device complete event");
10357 ba2str(&rp->addr.bdaddr, addr);
10359 if (status != MGMT_STATUS_SUCCESS) {
10360 error("Failed to remove device %s: %s (0x%02x)",
10361 addr, mgmt_errstr(status), status);
10365 DBG("%s removed from kernel accept list", addr);
10368 void adapter_accept_list_remove(struct btd_adapter *adapter,
10369 struct btd_device *dev)
10371 struct mgmt_cp_remove_device cp;
10373 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10376 memset(&cp, 0, sizeof(cp));
10377 bacpy(&cp.addr.bdaddr, device_get_address(dev));
10378 cp.addr.type = BDADDR_BREDR;
10380 mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10381 adapter->dev_id, sizeof(cp), &cp,
10382 remove_accept_list_complete, adapter, NULL);
10385 static void set_device_privacy_complete(uint8_t status, uint16_t length,
10386 const void *param, void *user_data)
10388 const struct mgmt_rp_set_device_flags *rp = param;
10390 if (status != MGMT_STATUS_SUCCESS) {
10391 error("Set device flags return status: %s",
10392 mgmt_errstr(status));
10396 if (length < sizeof(*rp)) {
10397 error("Too small Set Device Flags complete event: %d", length);
10402 static void add_device_complete(uint8_t status, uint16_t length,
10403 const void *param, void *user_data)
10405 const struct mgmt_rp_add_device *rp = param;
10406 struct btd_adapter *adapter = user_data;
10407 struct btd_device *dev;
10410 if (length < sizeof(*rp)) {
10411 btd_error(adapter->dev_id,
10412 "Too small Add Device complete event");
10416 ba2str(&rp->addr.bdaddr, addr);
10418 dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10421 btd_error(adapter->dev_id,
10422 "Add Device complete for unknown device %s", addr);
10426 if (status != MGMT_STATUS_SUCCESS) {
10427 btd_error(adapter->dev_id,
10428 "Failed to add device %s (%u): %s (0x%02x)",
10429 addr, rp->addr.type, mgmt_errstr(status), status);
10430 adapter->connect_list = g_slist_remove(adapter->connect_list,
10435 DBG("%s (%u) added to kernel connect list", addr, rp->addr.type);
10437 if (btd_opts.device_privacy) {
10438 uint32_t flags = btd_device_get_current_flags(dev);
10440 /* Set Device Privacy Mode has not set the flag yet. */
10441 if (!(flags & DEVICE_FLAG_DEVICE_PRIVACY)) {
10442 adapter_set_device_flags(adapter, dev, flags |
10443 DEVICE_FLAG_DEVICE_PRIVACY,
10444 set_device_privacy_complete,
10450 void adapter_auto_connect_add(struct btd_adapter *adapter,
10451 struct btd_device *device)
10453 struct mgmt_cp_add_device cp;
10454 const bdaddr_t *bdaddr;
10455 uint8_t bdaddr_type;
10458 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10461 if (g_slist_find(adapter->connect_list, device)) {
10462 DBG("ignoring already added device %s",
10463 device_get_path(device));
10467 bdaddr = device_get_address(device);
10468 bdaddr_type = btd_device_get_bdaddr_type(device);
10470 if (bdaddr_type == BDADDR_BREDR) {
10471 DBG("auto-connection feature is not avaiable for BR/EDR");
10475 memset(&cp, 0, sizeof(cp));
10476 bacpy(&cp.addr.bdaddr, bdaddr);
10477 cp.addr.type = bdaddr_type;
10480 id = mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10481 adapter->dev_id, sizeof(cp), &cp, add_device_complete,
10486 adapter->connect_list = g_slist_append(adapter->connect_list, device);
10489 void adapter_set_device_flags(struct btd_adapter *adapter,
10490 struct btd_device *device, uint32_t flags,
10491 mgmt_request_func_t func, void *user_data)
10493 struct mgmt_cp_set_device_flags cp;
10494 uint32_t supported = btd_device_get_supported_flags(device);
10495 const bdaddr_t *bdaddr;
10496 uint8_t bdaddr_type;
10498 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL) ||
10499 (supported | flags) != supported)
10502 bdaddr = device_get_address(device);
10503 bdaddr_type = btd_device_get_bdaddr_type(device);
10505 memset(&cp, 0, sizeof(cp));
10506 bacpy(&cp.addr.bdaddr, bdaddr);
10507 cp.addr.type = bdaddr_type;
10508 cp.current_flags = cpu_to_le32(flags);
10510 mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_FLAGS, adapter->dev_id,
10511 sizeof(cp), &cp, func, user_data, NULL);
10514 static void device_flags_changed_callback(uint16_t index, uint16_t length,
10515 const void *param, void *user_data)
10517 const struct mgmt_ev_device_flags_changed *ev = param;
10518 struct btd_adapter *adapter = user_data;
10519 struct btd_device *dev;
10522 if (length < sizeof(*ev)) {
10523 btd_error(adapter->dev_id,
10524 "Too small Device Flags Changed event: %d",
10529 ba2str(&ev->addr.bdaddr, addr);
10531 dev = btd_adapter_find_device(adapter, &ev->addr.bdaddr, ev->addr.type);
10533 btd_error(adapter->dev_id,
10534 "Device Flags Changed for unknown device %s", addr);
10538 btd_device_flags_changed(dev, ev->supported_flags, ev->current_flags);
10542 static void remove_device_complete(uint8_t status, uint16_t length,
10543 const void *param, void *user_data)
10545 const struct mgmt_rp_remove_device *rp = param;
10548 if (length < sizeof(*rp)) {
10549 error("Too small Remove Device complete event");
10553 ba2str(&rp->addr.bdaddr, addr);
10555 if (status != MGMT_STATUS_SUCCESS) {
10556 error("Failed to remove device %s (%u): %s (0x%02x)",
10557 addr, rp->addr.type, mgmt_errstr(status), status);
10561 DBG("%s (%u) removed from kernel connect list", addr, rp->addr.type);
10564 void adapter_auto_connect_remove(struct btd_adapter *adapter,
10565 struct btd_device *device)
10567 struct mgmt_cp_remove_device cp;
10568 const bdaddr_t *bdaddr;
10569 uint8_t bdaddr_type;
10572 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10575 if (!g_slist_find(adapter->connect_list, device)) {
10576 DBG("ignoring not added device %s", device_get_path(device));
10580 bdaddr = device_get_address(device);
10581 bdaddr_type = btd_device_get_bdaddr_type(device);
10583 if (bdaddr_type == BDADDR_BREDR) {
10584 DBG("auto-connection feature is not avaiable for BR/EDR");
10588 memset(&cp, 0, sizeof(cp));
10589 bacpy(&cp.addr.bdaddr, bdaddr);
10590 cp.addr.type = bdaddr_type;
10592 id = mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10593 adapter->dev_id, sizeof(cp), &cp,
10594 remove_device_complete, adapter, NULL);
10598 adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10601 #if defined (TIZEN_FEATURE_BLUEZ_MODIFY)
10602 static void get_phy_configuration_resp(uint8_t status, uint16_t len, const void *param,
10605 uint32_t supported_phys;
10606 uint32_t configurable_phys;
10607 uint32_t selected_phys;
10609 const struct mgmt_rp_get_phy_confguration *rp = param;
10610 struct btd_adapter *adapter = user_data;
10612 if (status != MGMT_STATUS_SUCCESS) {
10613 error("Get PHY Configuration failed with status 0x%02x (%s)",
10614 status, mgmt_errstr(status));
10618 if (len < sizeof(*rp)) {
10619 error("Too small get-phy reply (%u bytes)", len);
10623 supported_phys = get_le32(&rp->supported_phys);
10624 configurable_phys = get_le32(&rp-> configurable_phys);
10625 selected_phys = get_le16(&rp->selected_phys);
10627 DBG("Supported phys: [0x%x]", supported_phys);
10628 DBG("Configurable phys: [0x%x]", configurable_phys);
10629 DBG("Selected phys: [0x%x]", selected_phys);
10631 if (adapter->supported_settings & MGMT_SETTING_LE) {
10632 if ((supported_phys & MGMT_PHY_LE_2M_TX) &&
10633 (supported_phys & MGMT_PHY_LE_2M_RX)) {
10634 DBG("Adapter supports LE 2M PHY");
10635 adapter->le_2m_phy_supported = TRUE;
10637 DBG("Adapter does not support LE 2M PHY");
10639 if ((supported_phys & MGMT_PHY_LE_CODED_TX) &&
10640 (supported_phys & MGMT_PHY_LE_CODED_RX)) {
10641 adapter->le_coded_phy_supported = TRUE;
10642 DBG("Adapter supports LE CODED PHY");
10644 DBG("Adapter does not support LE CODED PHY");
10647 /* Emit Property Changed Signal */
10648 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10649 ADAPTER_INTERFACE, "SupportedLEFeatures");
10654 static void adapter_start(struct btd_adapter *adapter)
10657 #if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__SPRD_PATCH__)
10658 if (adapter_le_read_ble_feature_info())
10659 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10660 ADAPTER_INTERFACE, "SupportedLEFeatures");
10661 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
10663 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10664 ADAPTER_INTERFACE, "SupportedLEFeatures");
10667 adapter_get_adv_tx_power(adapter);
10669 /* By default enable offloading for testing, this should be modified */
10670 if (!TIZEN_FEATURE_BLUEZ_DA)
10671 if (adapter_le_is_supported_offloading())
10672 adapter_le_enable_offloading(TRUE);
10675 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
10676 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10677 ADAPTER_INTERFACE, "Powered");
10679 g_dbus_emit_property_changed_full(dbus_conn, adapter->path,
10680 ADAPTER_INTERFACE, "Powered", 1);
10682 adapter_set_power_state(adapter, ADAPTER_POWER_STATE_ON);
10684 DBG("adapter %s has been enabled", adapter->path);
10686 trigger_passive_scanning(adapter);
10689 static void reply_pending_requests(struct btd_adapter *adapter)
10696 /* pending bonding */
10697 for (l = adapter->devices; l; l = l->next) {
10698 struct btd_device *device = l->data;
10700 if (device_is_bonding(device, NULL))
10701 device_bonding_failed(device,
10702 HCI_OE_USER_ENDED_CONNECTION);
10706 static void remove_driver(gpointer data, gpointer user_data)
10708 struct btd_adapter_driver *driver = data;
10709 struct btd_adapter *adapter = user_data;
10711 if (driver->remove)
10712 driver->remove(adapter);
10715 static void remove_profile(gpointer data, gpointer user_data)
10717 struct btd_profile *profile = data;
10718 struct btd_adapter *adapter = user_data;
10720 if (profile->adapter_remove)
10721 profile->adapter_remove(profile, adapter);
10724 static void unload_drivers(struct btd_adapter *adapter)
10726 g_slist_foreach(adapter->drivers, remove_driver, adapter);
10727 g_slist_free(adapter->drivers);
10728 adapter->drivers = NULL;
10730 g_slist_foreach(adapter->profiles, remove_profile, adapter);
10731 g_slist_free(adapter->profiles);
10732 adapter->profiles = NULL;
10735 static void free_service_auth(gpointer data, gpointer user_data)
10737 struct service_auth *auth = data;
10742 static void remove_discovery_list(struct btd_adapter *adapter)
10744 g_slist_free_full(adapter->set_filter_list, discovery_free);
10745 adapter->set_filter_list = NULL;
10747 g_slist_free_full(adapter->discovery_list, discovery_free);
10748 adapter->discovery_list = NULL;
10751 static void adapter_free(gpointer user_data)
10753 struct btd_adapter *adapter = user_data;
10755 DBG("%p", adapter);
10757 /* Make sure the adapter's discovery list is cleaned up before freeing
10760 remove_discovery_list(adapter);
10762 if (adapter->pairable_timeout_id > 0) {
10763 timeout_remove(adapter->pairable_timeout_id);
10764 adapter->pairable_timeout_id = 0;
10767 if (adapter->passive_scan_timeout > 0) {
10768 timeout_remove(adapter->passive_scan_timeout);
10769 adapter->passive_scan_timeout = 0;
10772 if (adapter->auth_idle_id)
10773 timeout_remove(adapter->auth_idle_id);
10775 g_queue_foreach(adapter->auths, free_service_auth, NULL);
10776 g_queue_free(adapter->auths);
10777 queue_destroy(adapter->exps, NULL);
10780 * Unregister all handlers for this specific index since
10781 * the adapter bound to them is no longer valid.
10783 * This also avoids having multiple instances of the same
10784 * handler in case indexes got removed and re-added.
10786 mgmt_unregister_index(adapter->mgmt, adapter->dev_id);
10789 * Cancel all pending commands for this specific index
10790 * since the adapter bound to them is no longer valid.
10792 mgmt_cancel_index(adapter->mgmt, adapter->dev_id);
10794 mgmt_unref(adapter->mgmt);
10796 sdp_list_free(adapter->services, NULL);
10798 g_slist_free(adapter->connections);
10800 g_free(adapter->path);
10801 g_free(adapter->name);
10802 g_free(adapter->short_name);
10803 g_free(adapter->system_name);
10804 g_free(adapter->stored_alias);
10805 g_free(adapter->current_alias);
10806 free(adapter->modalias);
10808 if (adapter->allowed_uuid_set)
10809 g_hash_table_destroy(adapter->allowed_uuid_set);
10814 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
10816 __sync_fetch_and_add(&adapter->ref_count, 1);
10821 void btd_adapter_unref(struct btd_adapter *adapter)
10823 if (__sync_sub_and_fetch(&adapter->ref_count, 1))
10826 if (!adapter->path) {
10827 DBG("Freeing adapter %u", adapter->dev_id);
10829 adapter_free(adapter);
10833 DBG("Freeing adapter %s", adapter->path);
10835 g_dbus_unregister_interface(dbus_conn, adapter->path,
10836 ADAPTER_INTERFACE);
10839 static void convert_names_entry(char *key, char *value, void *user_data)
10841 char *address = user_data;
10843 char filename[PATH_MAX];
10844 GKeyFile *key_file;
10845 GError *gerr = NULL;
10849 if (strchr(key, '#'))
10852 if (bachk(str) != 0)
10855 create_filename(filename, PATH_MAX, "/%s/cache/%s", address, str);
10856 create_file(filename, 0600);
10858 key_file = g_key_file_new();
10859 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
10860 error("Unable to load key file from %s: (%s)", filename,
10862 g_clear_error(&gerr);
10864 g_key_file_set_string(key_file, "General", "Name", value);
10866 data = g_key_file_to_data(key_file, &length, NULL);
10867 if (!g_file_set_contents(filename, data, length, &gerr)) {
10868 error("Unable set contents for %s: (%s)", filename,
10870 g_error_free(gerr);
10874 g_key_file_free(key_file);
10877 struct device_converter {
10879 void (*cb)(GKeyFile *key_file, void *value);
10883 static void set_device_type(GKeyFile *key_file, char type)
10886 char *addr_type = NULL;
10893 case BDADDR_LE_PUBLIC:
10895 addr_type = "public";
10897 case BDADDR_LE_RANDOM:
10899 addr_type = "static";
10905 str = g_key_file_get_string(key_file, "General",
10906 "SupportedTechnologies", NULL);
10908 g_key_file_set_string(key_file, "General",
10909 "SupportedTechnologies", techno);
10910 else if (!strstr(str, techno))
10911 g_key_file_set_string(key_file, "General",
10912 "SupportedTechnologies", "BR/EDR;LE");
10917 g_key_file_set_string(key_file, "General", "AddressType",
10921 static void convert_aliases_entry(GKeyFile *key_file, void *value)
10923 g_key_file_set_string(key_file, "General", "Alias", value);
10926 static void convert_trusts_entry(GKeyFile *key_file, void *value)
10928 g_key_file_set_boolean(key_file, "General", "Trusted", TRUE);
10931 static void convert_classes_entry(GKeyFile *key_file, void *value)
10933 g_key_file_set_string(key_file, "General", "Class", value);
10936 static void convert_blocked_entry(GKeyFile *key_file, void *value)
10938 g_key_file_set_boolean(key_file, "General", "Blocked", TRUE);
10941 static void convert_did_entry(GKeyFile *key_file, void *value)
10943 char *vendor_str, *product_str, *version_str;
10946 vendor_str = strchr(value, ' ');
10950 *(vendor_str++) = 0;
10952 if (g_str_equal(value, "FFFF"))
10955 product_str = strchr(vendor_str, ' ');
10959 *(product_str++) = 0;
10961 version_str = strchr(product_str, ' ');
10965 *(version_str++) = 0;
10967 val = (uint16_t) strtol(value, NULL, 16);
10968 g_key_file_set_integer(key_file, "DeviceID", "Source", val);
10970 val = (uint16_t) strtol(vendor_str, NULL, 16);
10971 g_key_file_set_integer(key_file, "DeviceID", "Vendor", val);
10973 val = (uint16_t) strtol(product_str, NULL, 16);
10974 g_key_file_set_integer(key_file, "DeviceID", "Product", val);
10976 val = (uint16_t) strtol(version_str, NULL, 16);
10977 g_key_file_set_integer(key_file, "DeviceID", "Version", val);
10980 static void convert_linkkey_entry(GKeyFile *key_file, void *value)
10982 char *type_str, *length_str, *str;
10985 type_str = strchr(value, ' ');
10991 length_str = strchr(type_str, ' ');
10995 *(length_str++) = 0;
10997 str = g_strconcat("0x", value, NULL);
10998 g_key_file_set_string(key_file, "LinkKey", "Key", str);
11001 val = strtol(type_str, NULL, 16);
11002 g_key_file_set_integer(key_file, "LinkKey", "Type", val);
11004 val = strtol(length_str, NULL, 16);
11005 g_key_file_set_integer(key_file, "LinkKey", "PINLength", val);
11008 static void convert_ltk_entry(GKeyFile *key_file, void *value)
11010 char *auth_str, *rand_str, *str;
11012 unsigned char auth, central, enc_size;
11013 unsigned short ediv;
11015 auth_str = strchr(value, ' ');
11021 for (i = 0, rand_str = auth_str; i < 4; i++) {
11022 rand_str = strchr(rand_str, ' ');
11023 if (!rand_str || rand_str[1] == '\0')
11029 ret = sscanf(auth_str, " %hhd %hhd %hhd %hd", &auth, ¢ral,
11034 str = g_strconcat("0x", value, NULL);
11035 g_key_file_set_string(key_file, "LongTermKey", "Key", str);
11038 g_key_file_set_integer(key_file, "LongTermKey", "Authenticated", auth);
11039 g_key_file_set_integer(key_file, "LongTermKey", "EncSize", enc_size);
11040 g_key_file_set_integer(key_file, "LongTermKey", "EDiv", ediv);
11042 str = g_strconcat("0x", rand_str, NULL);
11043 g_key_file_set_string(key_file, "LongTermKey", "Rand", str);
11047 static void convert_profiles_entry(GKeyFile *key_file, void *value)
11049 g_strdelimit(value, " ", ';');
11050 g_key_file_set_string(key_file, "General", "Services", value);
11053 static void convert_appearances_entry(GKeyFile *key_file, void *value)
11055 g_key_file_set_string(key_file, "General", "Appearance", value);
11058 static void convert_entry(char *key, char *value, void *user_data)
11060 struct device_converter *converter = user_data;
11061 char type = BDADDR_BREDR;
11062 char filename[PATH_MAX];
11063 GKeyFile *key_file;
11064 GError *gerr = NULL;
11068 if (strchr(key, '#')) {
11070 type = key[18] - '0';
11073 if (bachk(key) != 0)
11076 if (converter->force == FALSE) {
11080 create_filename(filename, PATH_MAX, "/%s/%s",
11081 converter->address, key);
11083 err = stat(filename, &st);
11084 if (err || !S_ISDIR(st.st_mode))
11088 create_filename(filename, PATH_MAX, "/%s/%s/info",
11089 converter->address, key);
11091 key_file = g_key_file_new();
11092 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11093 error("Unable to load key file from %s: (%s)", filename,
11095 g_clear_error(&gerr);
11098 set_device_type(key_file, type);
11100 converter->cb(key_file, value);
11102 data = g_key_file_to_data(key_file, &length, NULL);
11104 create_file(filename, 0600);
11105 if (!g_file_set_contents(filename, data, length, &gerr)) {
11106 error("Unable set contents for %s: (%s)", filename,
11108 g_error_free(gerr);
11114 g_key_file_free(key_file);
11117 static void convert_file(char *file, char *address,
11118 void (*cb)(GKeyFile *key_file, void *value),
11121 char filename[PATH_MAX];
11122 struct device_converter converter;
11124 create_filename(filename, PATH_MAX, "/%s/%s", address, file);
11126 converter.address = address;
11128 converter.force = force;
11130 textfile_foreach(filename, convert_entry, &converter);
11133 static gboolean record_has_uuid(const sdp_record_t *rec,
11134 const char *profile_uuid)
11138 for (pat = rec->pattern; pat != NULL; pat = pat->next) {
11142 uuid = bt_uuid2string(pat->data);
11146 ret = strcasecmp(uuid, profile_uuid);
11157 static void store_attribute_uuid(GKeyFile *key_file, uint16_t start,
11158 uint16_t end, char *att_uuid,
11161 char handle[6], uuid_str[33];
11164 switch (uuid.type) {
11166 sprintf(uuid_str, "%4.4X", uuid.value.uuid16);
11169 sprintf(uuid_str, "%8.8X", uuid.value.uuid32);
11172 for (i = 0; i < 16; i++)
11173 sprintf(uuid_str + (i * 2), "%2.2X",
11174 uuid.value.uuid128.data[i]);
11177 uuid_str[0] = '\0';
11180 sprintf(handle, "%hu", start);
11181 g_key_file_set_string(key_file, handle, "UUID", att_uuid);
11182 g_key_file_set_string(key_file, handle, "Value", uuid_str);
11183 g_key_file_set_integer(key_file, handle, "EndGroupHandle", end);
11186 static void store_sdp_record(char *local, char *peer, int handle, char *value)
11188 char filename[PATH_MAX];
11189 GKeyFile *key_file;
11190 GError *gerr = NULL;
11191 char handle_str[11];
11195 create_filename(filename, PATH_MAX, "/%s/cache/%s", local, peer);
11197 key_file = g_key_file_new();
11198 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11199 error("Unable to load key file from %s: (%s)", filename,
11201 g_clear_error(&gerr);
11204 sprintf(handle_str, "0x%8.8X", handle);
11205 g_key_file_set_string(key_file, "ServiceRecords", handle_str, value);
11207 data = g_key_file_to_data(key_file, &length, NULL);
11209 create_file(filename, 0600);
11210 if (!g_file_set_contents(filename, data, length, &gerr)) {
11211 error("Unable set contents for %s: (%s)", filename,
11213 g_error_free(gerr);
11219 g_key_file_free(key_file);
11222 static void convert_sdp_entry(char *key, char *value, void *user_data)
11224 char *src_addr = user_data;
11226 char type = BDADDR_BREDR;
11228 char filename[PATH_MAX];
11229 GKeyFile *key_file;
11230 GError *gerr = NULL;
11234 char *att_uuid, *prim_uuid;
11235 uint16_t start = 0, end = 0, psm = 0;
11240 ret = sscanf(key, "%17s#%hhu#%08X", dst_addr, &type, &handle);
11242 ret = sscanf(key, "%17s#%08X", dst_addr, &handle);
11247 if (bachk(dst_addr) != 0)
11250 /* Check if the device directory has been created as records should
11251 * only be converted for known devices */
11252 create_filename(filename, PATH_MAX, "/%s/%s", src_addr, dst_addr);
11254 err = stat(filename, &st);
11255 if (err || !S_ISDIR(st.st_mode))
11258 /* store device records in cache */
11259 store_sdp_record(src_addr, dst_addr, handle, value);
11261 /* Retrieve device record and check if there is an
11262 * attribute entry in it */
11263 sdp_uuid16_create(&uuid, ATT_UUID);
11264 att_uuid = bt_uuid2string(&uuid);
11266 sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11267 prim_uuid = bt_uuid2string(&uuid);
11269 rec = record_from_string(value);
11271 if (record_has_uuid(rec, att_uuid))
11274 /* TODO: Do this through btd_gatt_database */
11275 if (!gatt_parse_record(rec, &uuid, &psm, &start, &end))
11278 create_filename(filename, PATH_MAX, "/%s/%s/attributes", src_addr,
11281 key_file = g_key_file_new();
11282 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11283 error("Unable to load key file from %s: (%s)", filename,
11285 g_clear_error(&gerr);
11288 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11290 data = g_key_file_to_data(key_file, &length, NULL);
11292 create_file(filename, 0600);
11293 if (!g_file_set_contents(filename, data, length, &gerr)) {
11294 error("Unable set contents for %s: (%s)", filename,
11296 g_error_free(gerr);
11301 g_key_file_free(key_file);
11304 sdp_record_free(rec);
11309 static void convert_primaries_entry(char *key, char *value, void *user_data)
11311 char *address = user_data;
11312 int device_type = -1;
11314 char **services, **service, *prim_uuid;
11315 char filename[PATH_MAX];
11316 GKeyFile *key_file;
11317 GError *gerr = NULL;
11319 uint16_t start, end;
11320 char uuid_str[MAX_LEN_UUID_STR + 1];
11324 if (strchr(key, '#')) {
11326 device_type = key[18] - '0';
11329 if (bachk(key) != 0)
11332 services = g_strsplit(value, " ", 0);
11333 if (services == NULL)
11336 sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11337 prim_uuid = bt_uuid2string(&uuid);
11339 create_filename(filename, PATH_MAX, "/%s/%s/attributes", address, key);
11341 key_file = g_key_file_new();
11342 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11343 error("Unable to load key file from %s: (%s)", filename,
11345 g_clear_error(&gerr);
11348 for (service = services; *service; service++) {
11349 ret = sscanf(*service, "%04hX#%04hX#%s", &start, &end,
11354 bt_string2uuid(&uuid, uuid_str);
11355 sdp_uuid128_to_uuid(&uuid);
11357 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11360 g_strfreev(services);
11362 data = g_key_file_to_data(key_file, &length, NULL);
11366 create_file(filename, 0600);
11367 if (!g_file_set_contents(filename, data, length, &gerr)) {
11368 error("Unable set contents for %s: (%s)", filename,
11370 g_clear_error(&gerr);
11373 if (device_type < 0)
11377 g_key_file_free(key_file);
11379 create_filename(filename, PATH_MAX, "/%s/%s/info", address, key);
11381 key_file = g_key_file_new();
11382 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11383 error("Unable to load key file from %s: (%s)", filename,
11385 g_clear_error(&gerr);
11387 set_device_type(key_file, device_type);
11389 data = g_key_file_to_data(key_file, &length, NULL);
11391 create_file(filename, 0600);
11392 if (!g_file_set_contents(filename, data, length, &gerr)) {
11393 error("Unable set contents for %s: (%s)", filename,
11395 g_error_free(gerr);
11402 g_key_file_free(key_file);
11405 static void convert_ccc_entry(char *key, char *value, void *user_data)
11407 char *src_addr = user_data;
11409 char type = BDADDR_BREDR;
11412 char filename[PATH_MAX];
11413 GKeyFile *key_file;
11414 GError *gerr = NULL;
11420 ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11424 if (bachk(dst_addr) != 0)
11427 /* Check if the device directory has been created as records should
11428 * only be converted for known devices */
11429 create_filename(filename, PATH_MAX, "/%s/%s", src_addr, dst_addr);
11431 err = stat(filename, &st);
11432 if (err || !S_ISDIR(st.st_mode))
11435 create_filename(filename, PATH_MAX, "/%s/%s/ccc", src_addr, dst_addr);
11437 key_file = g_key_file_new();
11438 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11439 error("Unable to load key file from %s: (%s)", filename,
11441 g_clear_error(&gerr);
11444 sprintf(group, "%hu", handle);
11445 g_key_file_set_string(key_file, group, "Value", value);
11447 data = g_key_file_to_data(key_file, &length, NULL);
11449 create_file(filename, 0600);
11450 if (!g_file_set_contents(filename, data, length, &gerr)) {
11451 error("Unable set contents for %s: (%s)", filename,
11453 g_error_free(gerr);
11458 g_key_file_free(key_file);
11461 static void convert_gatt_entry(char *key, char *value, void *user_data)
11463 char *src_addr = user_data;
11465 char type = BDADDR_BREDR;
11468 char filename[PATH_MAX];
11469 GKeyFile *key_file;
11470 GError *gerr = NULL;
11476 ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11480 if (bachk(dst_addr) != 0)
11483 /* Check if the device directory has been created as records should
11484 * only be converted for known devices */
11485 create_filename(filename, PATH_MAX, "/%s/%s", src_addr, dst_addr);
11487 err = stat(filename, &st);
11488 if (err || !S_ISDIR(st.st_mode))
11491 create_filename(filename, PATH_MAX, "/%s/%s/gatt", src_addr, dst_addr);
11493 key_file = g_key_file_new();
11494 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11495 error("Unable to load key file from %s: (%s)", filename,
11497 g_clear_error(&gerr);
11500 sprintf(group, "%hu", handle);
11501 g_key_file_set_string(key_file, group, "Value", value);
11503 data = g_key_file_to_data(key_file, &length, NULL);
11505 create_file(filename, 0600);
11506 if (!g_file_set_contents(filename, data, length, &gerr)) {
11507 error("Unable set contents for %s: (%s)", filename,
11509 g_error_free(gerr);
11514 g_key_file_free(key_file);
11517 static void convert_proximity_entry(char *key, char *value, void *user_data)
11519 char *src_addr = user_data;
11521 char filename[PATH_MAX];
11522 GKeyFile *key_file;
11523 GError *gerr = NULL;
11529 if (!strchr(key, '#'))
11535 if (bachk(key) != 0)
11538 /* Check if the device directory has been created as records should
11539 * only be converted for known devices */
11540 create_filename(filename, PATH_MAX, "/%s/%s", src_addr, key);
11542 err = stat(filename, &st);
11543 if (err || !S_ISDIR(st.st_mode))
11546 create_filename(filename, PATH_MAX, "/%s/%s/proximity", src_addr, key);
11548 key_file = g_key_file_new();
11549 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11550 error("Unable to load key file from %s: (%s)", filename,
11552 g_clear_error(&gerr);
11555 g_key_file_set_string(key_file, alert, "Level", value);
11557 data = g_key_file_to_data(key_file, &length, NULL);
11559 create_file(filename, 0600);
11560 if (!g_file_set_contents(filename, data, length, &gerr)) {
11561 error("Unable set contents for %s: (%s)", filename,
11563 g_error_free(gerr);
11568 g_key_file_free(key_file);
11571 static void convert_device_storage(struct btd_adapter *adapter)
11573 char filename[PATH_MAX];
11576 ba2str(&adapter->bdaddr, address);
11578 /* Convert device's name cache */
11579 create_filename(filename, PATH_MAX, "/%s/names", address);
11580 textfile_foreach(filename, convert_names_entry, address);
11582 /* Convert aliases */
11583 convert_file("aliases", address, convert_aliases_entry, TRUE);
11585 /* Convert trusts */
11586 convert_file("trusts", address, convert_trusts_entry, TRUE);
11588 /* Convert blocked */
11589 convert_file("blocked", address, convert_blocked_entry, TRUE);
11591 /* Convert profiles */
11592 convert_file("profiles", address, convert_profiles_entry, TRUE);
11594 /* Convert primaries */
11595 create_filename(filename, PATH_MAX, "/%s/primaries", address);
11596 textfile_foreach(filename, convert_primaries_entry, address);
11598 /* Convert linkkeys */
11599 convert_file("linkkeys", address, convert_linkkey_entry, TRUE);
11601 /* Convert longtermkeys */
11602 convert_file("longtermkeys", address, convert_ltk_entry, TRUE);
11604 /* Convert classes */
11605 convert_file("classes", address, convert_classes_entry, FALSE);
11607 /* Convert device ids */
11608 convert_file("did", address, convert_did_entry, FALSE);
11611 create_filename(filename, PATH_MAX, "/%s/sdp", address);
11612 textfile_foreach(filename, convert_sdp_entry, address);
11615 create_filename(filename, PATH_MAX, "/%s/ccc", address);
11616 textfile_foreach(filename, convert_ccc_entry, address);
11618 /* Convert appearances */
11619 convert_file("appearances", address, convert_appearances_entry, FALSE);
11622 create_filename(filename, PATH_MAX, "/%s/gatt", address);
11623 textfile_foreach(filename, convert_gatt_entry, address);
11625 /* Convert proximity */
11626 create_filename(filename, PATH_MAX, "/%s/proximity", address);
11627 textfile_foreach(filename, convert_proximity_entry, address);
11630 static void convert_config(struct btd_adapter *adapter, const char *filename,
11631 GKeyFile *key_file)
11634 char str[MAX_NAME_LENGTH + 1];
11635 char config_path[PATH_MAX];
11640 GError *gerr = NULL;
11642 ba2str(&adapter->bdaddr, address);
11643 create_filename(config_path, PATH_MAX, "/%s/config", address);
11645 if (read_pairable_timeout(address, &timeout) == 0)
11646 g_key_file_set_integer(key_file, "General",
11647 "PairableTimeout", timeout);
11649 if (read_discoverable_timeout(address, &timeout) == 0)
11650 g_key_file_set_integer(key_file, "General",
11651 "DiscoverableTimeout", timeout);
11653 if (read_on_mode(address, str, sizeof(str)) == 0) {
11654 mode = get_mode(str);
11655 g_key_file_set_boolean(key_file, "General", "Discoverable",
11656 mode == MODE_DISCOVERABLE);
11659 if (read_local_name(&adapter->bdaddr, str) == 0)
11660 g_key_file_set_string(key_file, "General", "Alias", str);
11662 create_file(filename, 0600);
11664 data = g_key_file_to_data(key_file, &length, NULL);
11665 if (!g_file_set_contents(filename, data, length, &gerr)) {
11666 error("Unable set contents for %s: (%s)", filename,
11668 g_error_free(gerr);
11673 static void fix_storage(struct btd_adapter *adapter)
11675 char filename[PATH_MAX];
11679 ba2str(&adapter->bdaddr, address);
11681 create_filename(filename, PATH_MAX, "/%s/config", address);
11683 converted = textfile_get(filename, "converted");
11689 textfile_del(filename, "converted");
11691 create_filename(filename, PATH_MAX, "/%s/names", address);
11692 textfile_del(filename, "converted");
11694 create_filename(filename, PATH_MAX, "/%s/aliases", address);
11695 textfile_del(filename, "converted");
11697 create_filename(filename, PATH_MAX, "/%s/trusts", address);
11698 textfile_del(filename, "converted");
11700 create_filename(filename, PATH_MAX, "/%s/blocked", address);
11701 textfile_del(filename, "converted");
11703 create_filename(filename, PATH_MAX, "/%s/profiles", address);
11704 textfile_del(filename, "converted");
11706 create_filename(filename, PATH_MAX, "/%s/primaries", address);
11707 textfile_del(filename, "converted");
11709 create_filename(filename, PATH_MAX, "/%s/linkkeys", address);
11710 textfile_del(filename, "converted");
11712 create_filename(filename, PATH_MAX, "/%s/longtermkeys", address);
11713 textfile_del(filename, "converted");
11715 create_filename(filename, PATH_MAX, "/%s/classes", address);
11716 textfile_del(filename, "converted");
11718 create_filename(filename, PATH_MAX, "/%s/did", address);
11719 textfile_del(filename, "converted");
11721 create_filename(filename, PATH_MAX, "/%s/sdp", address);
11722 textfile_del(filename, "converted");
11724 create_filename(filename, PATH_MAX, "/%s/ccc", address);
11725 textfile_del(filename, "converted");
11727 create_filename(filename, PATH_MAX, "/%s/appearances", address);
11728 textfile_del(filename, "converted");
11730 create_filename(filename, PATH_MAX, "/%s/gatt", address);
11731 textfile_del(filename, "converted");
11733 create_filename(filename, PATH_MAX, "/%s/proximity", address);
11734 textfile_del(filename, "converted");
11737 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11738 static bool is_tempfile(const char *filename)
11743 /* tempfile has ^[A-Z0-9]{6}$ suffix (e.g. "settings.1LS4BZ") */
11744 p = strrchr(filename, '.');
11748 if (strlen(++p) != 6)
11751 for (i = 0; i < 6; i++) {
11752 if (isdigit(p[i]) || isupper(p[i]))
11760 static void delete_tempfiles(const char *dirname)
11763 struct dirent *entry;
11764 char filename[PATH_MAX];
11766 dir = opendir(dirname);
11770 while ((entry = readdir(dir)) != NULL) {
11771 if (g_str_equal(entry->d_name, ".") || g_str_equal(entry->d_name, ".."))
11774 if (entry->d_type == DT_UNKNOWN)
11775 entry->d_type = util_get_dt(dirname, entry->d_name);
11777 snprintf(filename, PATH_MAX, "%s/%s", dirname, entry->d_name);
11779 if (entry->d_type == DT_DIR) {
11780 delete_tempfiles(filename);
11781 } else if (entry->d_type == DT_REG && is_tempfile(entry->d_name)) {
11789 static void load_config(struct btd_adapter *adapter)
11791 GKeyFile *key_file;
11792 char filename[PATH_MAX];
11794 GError *gerr = NULL;
11795 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11799 key_file = g_key_file_new();
11801 create_filename(filename, PATH_MAX, "/%s/settings",
11802 btd_adapter_get_storage_dir(adapter));
11804 if (stat(filename, &st) < 0) {
11805 convert_config(adapter, filename, key_file);
11806 convert_device_storage(adapter);
11809 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11810 error("Unable to load key file from %s: (%s)", filename,
11812 g_clear_error(&gerr);
11816 adapter->stored_alias = g_key_file_get_string(key_file, "General",
11818 if (!adapter->stored_alias) {
11820 adapter->stored_alias = g_key_file_get_string(key_file,
11821 "General", "Name", NULL);
11824 /* Get pairable timeout */
11825 adapter->pairable_timeout = g_key_file_get_integer(key_file, "General",
11826 "PairableTimeout", &gerr);
11828 adapter->pairable_timeout = btd_opts.pairto;
11829 g_error_free(gerr);
11833 /* Get discoverable mode */
11834 adapter->stored_discoverable = g_key_file_get_boolean(key_file,
11835 "General", "Discoverable", &gerr);
11837 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11838 if (TIZEN_FEATURE_BLUEZ_FHUB) {
11839 DBG("Default Discoverable mode is TRUE");
11840 adapter->stored_discoverable = true;
11843 adapter->stored_discoverable = false;
11844 g_error_free(gerr);
11848 /* Get discoverable timeout */
11849 adapter->discoverable_timeout = g_key_file_get_integer(key_file,
11850 "General", "DiscoverableTimeout", &gerr);
11852 adapter->discoverable_timeout = btd_opts.discovto;
11853 g_error_free(gerr);
11857 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11858 /* Get A2DP Role */
11859 str = g_key_file_get_string(key_file, "General", "DefaultA2DPRole", &gerr);
11860 if (gerr || !str) {
11861 if (btd_opts.default_a2dp_role) {
11862 DBG("Default A2DP role is %s", btd_opts.default_a2dp_role);
11863 if (g_strcmp0(btd_opts.default_a2dp_role, "sink") == 0) {
11864 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
11865 } else if (g_strcmp0(btd_opts.default_a2dp_role, "both") == 0) {
11866 adapter->a2dp_role = BLUETOOTH_A2DP_BOTH_ROLE;
11867 } else { /* source */
11868 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11871 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11873 g_error_free(gerr);
11876 if (g_strcmp0(str, "sink") == 0)
11877 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
11878 else if (g_strcmp0(str, "both") == 0)
11879 adapter->a2dp_role = BLUETOOTH_A2DP_BOTH_ROLE;
11881 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11886 g_key_file_free(key_file);
11889 static struct btd_adapter *btd_adapter_new(uint16_t index)
11891 struct btd_adapter *adapter;
11894 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11895 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11896 DBusConnection *conn = btd_get_dbus_connection();
11897 DBusMessage *msg = NULL;
11898 DBusMessage *reply = NULL;
11899 int charging_state = 0;
11900 #endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11903 adapter = g_try_new0(struct btd_adapter, 1);
11907 adapter->dev_id = index;
11908 adapter->mgmt = mgmt_ref(mgmt_primary);
11909 adapter->pincode_requested = false;
11910 blocked = rfkill_get_blocked(index);
11912 adapter->power_state = ADAPTER_POWER_STATE_OFF_BLOCKED;
11915 * Setup default configuration values. These are either adapter
11916 * defaults or from a system wide configuration file.
11918 * Some value might be overwritten later on by adapter specific
11919 * configuration. This is to make sure that sane defaults are
11922 adapter->system_name = g_strdup(btd_opts.name);
11923 adapter->major_class = (btd_opts.class & 0x001f00) >> 8;
11924 adapter->minor_class = (btd_opts.class & 0x0000fc) >> 2;
11925 adapter->modalias = bt_modalias(btd_opts.did_source,
11926 btd_opts.did_vendor,
11927 btd_opts.did_product,
11928 btd_opts.did_version);
11929 adapter->discoverable_timeout = btd_opts.discovto;
11930 adapter->pairable_timeout = btd_opts.pairto;
11931 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11932 adapter->advertising = FALSE;
11935 DBG("System name: %s", adapter->system_name);
11936 DBG("Major class: %u", adapter->major_class);
11937 DBG("Minor class: %u", adapter->minor_class);
11938 DBG("Modalias: %s", adapter->modalias);
11939 DBG("Discoverable timeout: %u seconds", adapter->discoverable_timeout);
11940 DBG("Pairable timeout: %u seconds", adapter->pairable_timeout);
11942 DBG("Power state: %s",
11943 adapter_power_state_str(adapter->power_state));
11945 adapter->auths = g_queue_new();
11946 adapter->exps = queue_new();
11948 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11949 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11950 adapter->charging_watch = g_dbus_add_signal_watch(conn, DEVICED_DEST,
11951 DEVICED_BATT_OBJECT_PATH,
11952 DEVICED_BATT_INTERFACE, "ChargerType",
11953 charging_state_changed, adapter, NULL);
11954 if (adapter->charging_watch == 0)
11955 error("Cannot add signal watch for ChargerType");
11957 msg = dbus_message_new_method_call(DEVICED_DEST,
11958 DEVICED_BATT_OBJECT_PATH,
11959 DEVICED_BATT_INTERFACE, "ChargerType");
11961 reply = dbus_connection_send_with_reply_and_block(conn,
11964 if (dbus_message_get_args(reply, NULL,
11965 DBUS_TYPE_INT32, &charging_state,
11966 DBUS_TYPE_INVALID) == TRUE) {
11967 set_charging_state(adapter, charging_state);
11969 dbus_message_unref(reply);
11971 error("Reply is NULL");
11973 dbus_message_unref(msg);
11975 error("Unable to create dbus message for charging state");
11977 #endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11980 return btd_adapter_ref(adapter);
11983 static void adapter_remove(struct btd_adapter *adapter)
11986 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11987 struct gatt_db *db;
11990 DBG("Removing adapter %s", adapter->path);
11992 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11993 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11994 if (adapter->charging_watch > 0) {
11995 g_dbus_remove_watch(btd_get_dbus_connection(),
11996 adapter->charging_watch);
11997 adapter->charging_watch = 0;
12000 if (adapter->charging_timeout) {
12001 g_source_remove(adapter->charging_timeout);
12002 adapter->charging_timeout = 0;
12004 #endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
12007 if (adapter->discovery_idle_timeout > 0) {
12008 g_source_remove(adapter->discovery_idle_timeout);
12009 adapter->discovery_idle_timeout = 0;
12012 discovery_cleanup(adapter, 0);
12014 g_slist_free(adapter->connect_list);
12015 adapter->connect_list = NULL;
12017 for (l = adapter->devices; l; l = l->next) {
12018 device_removed_drivers(adapter, l->data);
12019 device_remove(l->data, FALSE);
12022 g_slist_free(adapter->devices);
12023 adapter->devices = NULL;
12025 discovery_cleanup(adapter, 0);
12027 unload_drivers(adapter);
12029 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12030 db = btd_gatt_database_get_db(adapter->database);
12031 gatt_db_unregister(db, adapter->db_id);
12032 adapter->db_id = 0;
12034 btd_gatt_database_destroy(adapter->database);
12035 adapter->database = NULL;
12037 btd_adapter_gatt_server_stop(adapter);
12039 btd_adv_manager_destroy(adapter->adv_manager);
12040 adapter->adv_manager = NULL;
12042 btd_adv_monitor_manager_destroy(adapter->adv_monitor_manager);
12043 adapter->adv_monitor_manager = NULL;
12045 btd_battery_provider_manager_destroy(adapter->battery_provider_manager);
12046 adapter->battery_provider_manager = NULL;
12048 g_slist_free(adapter->pin_callbacks);
12049 adapter->pin_callbacks = NULL;
12051 g_slist_free(adapter->msd_callbacks);
12052 adapter->msd_callbacks = NULL;
12055 const char *adapter_get_path(struct btd_adapter *adapter)
12060 return adapter->path;
12063 const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter)
12065 return &adapter->bdaddr;
12068 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12069 const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter)
12071 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
12072 return &adapter->rpa;
12073 else if (adapter->le_static_addr.b[5] != 0)
12074 return &adapter->le_static_addr;
12076 return &adapter->bdaddr;
12079 uint8_t btd_adapter_get_le_address_type(struct btd_adapter * adapter)
12081 if (adapter->current_settings & MGMT_SETTING_PRIVACY ||
12082 adapter->le_static_addr.b[5] != 0)
12083 return BDADDR_LE_RANDOM;
12085 return BDADDR_LE_PUBLIC;
12089 static void confirm_name_complete(uint8_t status, uint16_t length,
12090 const void *param, void *user_data)
12092 struct btd_adapter *adapter = user_data;
12094 if (status != MGMT_STATUS_SUCCESS) {
12095 btd_error(adapter->dev_id,
12096 "Failed to confirm name for hci%u: %s (0x%02x)",
12097 adapter->dev_id, mgmt_errstr(status), status);
12101 DBG("Confirm name complete for hci%u", adapter->dev_id);
12104 static void confirm_name(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12105 uint8_t bdaddr_type, bool name_known)
12107 struct mgmt_cp_confirm_name cp;
12110 ba2str(bdaddr, addr);
12111 DBG("hci%d bdaddr %s name_known %u", adapter->dev_id, addr,
12114 memset(&cp, 0, sizeof(cp));
12115 bacpy(&cp.addr.bdaddr, bdaddr);
12116 cp.addr.type = bdaddr_type;
12117 cp.name_known = name_known;
12120 * This timeout handling is needed since the kernel is stupid
12121 * and forgets to send a command complete response. However in
12122 * case of failures it does send a command status.
12124 if (!mgmt_reply_timeout(adapter->mgmt, MGMT_OP_CONFIRM_NAME,
12125 adapter->dev_id, sizeof(cp), &cp,
12126 confirm_name_complete, adapter, NULL, 2))
12127 btd_error(adapter->dev_id, "Failed to confirm name for hci%u",
12131 static void adapter_msd_notify(struct btd_adapter *adapter,
12132 struct btd_device *dev,
12135 GSList *cb_l, *cb_next;
12136 GSList *msd_l, *msd_next;
12138 for (cb_l = adapter->msd_callbacks; cb_l != NULL; cb_l = cb_next) {
12139 btd_msd_cb_t cb = cb_l->data;
12141 cb_next = g_slist_next(cb_l);
12143 for (msd_l = msd_list; msd_l != NULL; msd_l = msd_next) {
12144 const struct eir_msd *msd = msd_l->data;
12146 msd_next = g_slist_next(msd_l);
12148 cb(adapter, dev, msd->company, msd->data,
12154 static bool is_filter_match(GSList *discovery_filter, struct eir_data *eir_data,
12158 bool got_match = false;
12160 for (l = discovery_filter; l != NULL && got_match != true;
12161 l = g_slist_next(l)) {
12162 struct discovery_client *client = l->data;
12163 struct discovery_filter *item = client->discovery_filter;
12166 * If one of currently running scans is regular scan, then
12167 * return all devices as matches
12174 /* if someone started discovery with empty uuids, he wants all
12175 * devices in given proximity.
12180 for (m = item->uuids; m != NULL && got_match != true;
12181 m = g_slist_next(m)) {
12182 /* m->data contains string representation of
12185 if (g_slist_find_custom(eir_data->services,
12193 /* we have service match, check proximity */
12194 if (item->rssi == DISTANCE_VAL_INVALID ||
12195 item->rssi <= rssi ||
12196 item->pathloss == DISTANCE_VAL_INVALID ||
12197 (eir_data->tx_power != 127 &&
12198 eir_data->tx_power - rssi <= item->pathloss))
12208 static void filter_duplicate_data(void *data, void *user_data)
12210 struct discovery_client *client = data;
12211 bool *duplicate = user_data;
12213 if (*duplicate || !client->discovery_filter)
12216 *duplicate = client->discovery_filter->duplicate;
12219 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12220 static bool device_is_discoverable(struct btd_adapter *adapter,
12221 struct eir_data *eir, const char *addr,
12222 uint8_t bdaddr_type)
12227 if (bdaddr_type == BDADDR_BREDR || adapter->filtered_discovery)
12228 discoverable = true;
12230 discoverable = eir->flags & (EIR_LIM_DISC | EIR_GEN_DISC);
12233 * Mark as not discoverable if no client has requested discovery and
12234 * report has not set any discoverable flags.
12236 if (!adapter->discovery_list && !discoverable)
12239 /* Do a prefix match for both address and name if pattern is set */
12240 for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
12241 struct dicovery_client *client = l->data;
12242 struct discovery_filter *filter = client->discovery_filter;
12243 size_t pattern_len;
12245 if (!filter || !filter->pattern)
12248 /* Reset discoverable if a client has a pattern filter */
12249 discoverable = false;
12251 pattern_len = strlen(filter->pattern);
12255 if (!strncmp(filter->pattern, addr, pattern_len))
12258 if (eir->name && !strncmp(filter->pattern, eir->name,
12263 return discoverable;
12267 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12268 void btd_adapter_device_found(struct btd_adapter *adapter,
12269 const bdaddr_t *bdaddr,
12270 uint8_t bdaddr_type, int8_t rssi,
12271 uint8_t adv_type, uint32_t flags,
12272 const uint8_t *data, uint8_t data_len,
12275 void btd_adapter_device_found(struct btd_adapter *adapter,
12276 const bdaddr_t *bdaddr,
12277 uint8_t bdaddr_type, int8_t rssi,
12278 uint8_t adv_type, uint32_t flags,
12279 const uint8_t *data, uint8_t data_len,
12283 struct btd_device *dev;
12284 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12285 struct bt_ad *ad = NULL;
12287 struct eir_data eir_data;
12288 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12289 bool name_known, discoverable;
12290 bool not_connectable;
12294 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12295 uint8_t allow_report;
12300 // bool not_connectable;
12301 bool name_resolve_failed;
12303 bool duplicate = false;
12305 confirm = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
12306 legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
12307 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12308 not_connectable = (flags & MGMT_DEV_FOUND_NOT_CONNECTABLE);
12310 name_resolve_failed = (flags & MGMT_DEV_FOUND_NAME_REQUEST_FAILED);
12311 scan_rsp = (flags & MGMT_DEV_FOUND_SCAN_RSP);
12313 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12314 struct queue *matched_monitors = NULL;
12316 if (!btd_adv_monitor_offload_enabled(adapter->adv_monitor_manager) ||
12317 (MGMT_VERSION(mgmt_version, mgmt_revision) <
12318 MGMT_VERSION(1, 22))) {
12319 if (bdaddr_type != BDADDR_BREDR)
12320 ad = bt_ad_new_with_data(data_len, data);
12322 /* During the background scanning, update the device only when
12323 * the data match at least one Adv monitor
12326 matched_monitors = btd_adv_monitor_content_filter(
12327 adapter->adv_monitor_manager,
12331 monitoring = matched_monitors ? true : false;
12335 if (!adapter->discovering && !monitoring)
12338 memset(&eir_data, 0, sizeof(eir_data));
12339 eir_parse(&eir_data, data, data_len);
12340 ba2str(bdaddr, addr);
12341 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12342 discoverable = device_is_discoverable(adapter, &eir_data, addr,
12347 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12348 /* Check if the any filter policy */
12349 allow_report = validate_for_filter_policy(adapter, &eir_data, addr);
12350 if (allow_report == NONE_REPORT &&
12351 ((adapter->scan_type == LE_ACTIVE_SCAN && adv_type == ADV_TYPE_SCAN_RESPONSE) ||
12352 adapter->scan_type == LE_PASSIVE_SCAN)) {
12353 eir_data_free(&eir_data);
12357 dev = btd_adapter_find_device(adapter, bdaddr, bdaddr_type);
12360 * If no client has requested discovery or the device is
12361 * not marked as discoverable, then do not create new
12365 /* In case of being just a scan response don't attempt to create
12369 eir_data_free(&eir_data);
12373 /* Monitor Devices advertising Broadcast Announcements if the
12374 * adapter is capable of synchronizing to it.
12376 if (eir_get_service_data(&eir_data, BAA_SERVICE_UUID) &&
12377 btd_adapter_has_settings(adapter,
12378 MGMT_SETTING_ISO_SYNC_RECEIVER))
12380 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12381 /*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
12382 adapter->le_discovery_list, discoverable);*/
12383 if ((adapter->discovery_list == NULL &&
12384 adapter->le_discovery_list == NULL)) {
12385 DBG("discovery list is NULL");
12386 eir_data_free(&eir_data);
12390 if (!adapter->discovery_list || !discoverable &&
12391 !matched_monitors && !eir_data.rsi) {
12392 eir_data_free(&eir_data);
12397 dev = adapter_create_device(adapter, bdaddr, bdaddr_type);
12401 btd_error(adapter->dev_id,
12402 "Unable to create object for found device %s", addr);
12403 eir_data_free(&eir_data);
12407 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12408 if (device_get_rpa_exist(dev) == true)
12409 bdaddr_type = BDADDR_LE_RANDOM;
12411 device_update_last_seen(dev, bdaddr_type);
12413 device_update_last_seen(dev, bdaddr_type, !not_connectable);
12417 * FIXME: We need to check for non-zero flags first because
12418 * older kernels send separate adv_ind and scan_rsp. Newer
12419 * kernels send them merged, so once we know which mgmt version
12420 * supports this we can make the non-zero check conditional.
12422 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12423 if (bdaddr_type == BDADDR_LE_PUBLIC && eir_data.flags &&
12424 !(eir_data.flags & EIR_BREDR_UNSUP)) {
12425 device_set_bredr_support(dev);
12426 /* Update last seen for BR/EDR in case its flag is set */
12427 device_update_last_seen(dev, BDADDR_BREDR);
12430 if (bdaddr_type != BDADDR_BREDR && eir_data.flags &&
12431 !(eir_data.flags & EIR_BREDR_UNSUP)) {
12432 device_set_bredr_support(dev);
12433 /* Update last seen for BR/EDR in case its flag is set */
12434 device_update_last_seen(dev, BDADDR_BREDR, !not_connectable);
12438 if (eir_data.name != NULL && eir_data.name_complete)
12439 device_store_cached_name(dev, eir_data.name);
12442 * Only skip devices that are not connected, are temporary, and there
12443 * is no active discovery session ongoing and no matched Adv monitors
12445 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12446 if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
12447 adapter->le_discovery_list == NULL) {
12448 DBG("discovery list is NULL");
12449 eir_data_free(&eir_data);
12453 device_set_last_addr_type(dev, bdaddr_type);
12454 device_set_ipsp_connected(dev, FALSE, NULL);
12456 if (!btd_device_is_connected(dev) &&
12457 (device_is_temporary(dev) && !adapter->discovery_list) &&
12459 eir_data_free(&eir_data);
12464 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12465 if (bdaddr_type == BDADDR_BREDR) {
12466 if (adapter->filtered_discovery &&
12467 !is_filter_match(adapter->discovery_list, &eir_data, rssi)) {
12469 /* If there is no matched Adv monitors, don't continue if not
12470 * discoverable or if active discovery filter don't match.
12472 if (!eir_data.rsi && !monitoring && (!discoverable ||
12473 (adapter->filtered_discovery && !is_filter_match(
12474 adapter->discovery_list, &eir_data, rssi)))) {
12476 eir_data_free(&eir_data);
12480 device_set_legacy(dev, legacy);
12482 if (name_resolve_failed)
12483 device_name_resolve_fail(dev);
12485 if (adapter->filtered_discovery)
12486 device_set_rssi_with_delta(dev, rssi, 0);
12488 device_set_rssi(dev, rssi);
12490 if (eir_data.tx_power != 127)
12491 device_set_tx_power(dev, eir_data.tx_power);
12492 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12496 if (eir_data.appearance != 0)
12497 device_set_appearance(dev, eir_data.appearance);
12499 /* Report an unknown name to the kernel even if there is a short name
12500 * known, but still update the name with the known short name. */
12501 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12502 if (eir_data.name_complete)
12503 name_known = device_name_known(dev);
12505 name_known = false;
12507 name_known = device_name_known(dev);
12510 if (eir_data.name && (eir_data.name_complete || !name_known))
12511 btd_device_device_set_name(dev, eir_data.name);
12513 if (eir_data.class != 0)
12514 device_set_class(dev, eir_data.class);
12516 if (eir_data.did_source || eir_data.did_vendor ||
12517 eir_data.did_product || eir_data.did_version)
12518 btd_device_set_pnpid(dev, eir_data.did_source,
12519 eir_data.did_vendor,
12520 eir_data.did_product,
12521 eir_data.did_version);
12523 device_add_eir_uuids(dev, eir_data.services);
12525 if (adapter->discovery_list)
12526 g_slist_foreach(adapter->discovery_list, filter_duplicate_data,
12528 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12529 if (eir_data.flags != 0)
12530 device_set_remote_feature_flag(dev, eir_data.flags);
12532 if (bdaddr_type == BDADDR_BREDR)
12533 device_set_manufacturer_info(dev, &eir_data);
12535 /* if the application has registered for iBeacon report,
12536 * then send ibeacon report along with advertisement report */
12537 device_set_adv_report_info(dev, (void*)data, data_len, adv_type, rssi);
12541 if (eir_data.msd_list) {
12542 device_set_manufacturer_data(dev, eir_data.msd_list, duplicate);
12543 adapter_msd_notify(adapter, dev, eir_data.msd_list);
12546 if (eir_data.sd_list)
12547 device_set_service_data(dev, eir_data.sd_list, duplicate);
12549 if (eir_data.data_list)
12550 device_set_data(dev, eir_data.data_list, duplicate);
12552 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12553 if (bdaddr_type != BDADDR_BREDR && adv_type != ADV_TYPE_SCAN_RESPONSE) {
12554 device_set_flags(dev, eir_data.flags);
12555 device_set_le_connectable(dev, adv_type);
12558 if (bdaddr_type != BDADDR_BREDR)
12559 device_set_flags(dev, eir_data.flags);
12562 eir_data_free(&eir_data);
12564 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12565 /* After the device is updated, notify the matched Adv monitors */
12566 if (matched_monitors) {
12567 btd_adv_monitor_notify_monitors(adapter->adv_monitor_manager,
12568 dev, rssi, matched_monitors);
12569 queue_destroy(matched_monitors, NULL);
12570 matched_monitors = NULL;
12574 * Only if at least one client has requested discovery, maintain
12575 * list of found devices and name confirming for legacy devices.
12576 * Otherwise, this is an event from passive discovery and we
12577 * should check if the device needs connecting to.
12579 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12580 if (!adapter->discovery_list && !adapter->le_discovery_list)
12582 if (!adapter->discovery_list)
12586 if (g_slist_find(adapter->discovery_found, dev))
12589 /* If name is unknown but it's not allowed to resolve, don't send
12590 * MGMT_OP_CONFIRM_NAME.
12592 if (confirm && (name_known || device_is_name_resolve_allowed(dev)))
12593 confirm_name(adapter, bdaddr, bdaddr_type, name_known);
12595 adapter->discovery_found = g_slist_prepend(adapter->discovery_found,
12601 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12602 /* Ignore non-connectable events */
12603 if (not_connectable)
12608 * If we're in the process of stopping passive scanning and
12609 * connecting another (or maybe even the same) LE device just
12612 if (adapter->connect_le)
12616 * If kernel background scan is used then the kernel is
12617 * responsible for connecting.
12619 if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
12623 * If this is an LE device that's not connected and part of the
12624 * connect_list stop passive scanning so that a connection
12625 * attempt to it can be made
12627 if (bdaddr_type != BDADDR_BREDR && !btd_device_is_connected(dev) &&
12628 g_slist_find(adapter->connect_list, dev)) {
12629 adapter->connect_le = dev;
12630 stop_passive_scanning(adapter);
12634 static void device_found_callback(uint16_t index, uint16_t length,
12635 const void *param, void *user_data)
12637 const struct mgmt_ev_device_found *ev = param;
12638 struct btd_adapter *adapter = user_data;
12639 const uint8_t *eir;
12643 if (length < sizeof(*ev)) {
12644 btd_error(adapter->dev_id,
12645 "Too short device found event (%u bytes)", length);
12649 eir_len = btohs(ev->eir_len);
12650 if (length != sizeof(*ev) + eir_len) {
12651 btd_error(adapter->dev_id,
12652 "Device found event size mismatch (%u != %zu)",
12653 length, sizeof(*ev) + eir_len);
12662 flags = le32_to_cpu(ev->flags);
12664 ba2str(&ev->addr.bdaddr, addr);
12665 DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12666 index, addr, ev->rssi, flags, eir_len);
12668 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12669 btd_adapter_device_found(adapter, &ev->addr.bdaddr,
12670 ev->addr.type, ev->rssi, 0, flags,
12671 eir, eir_len, false);
12673 btd_adapter_device_found(adapter, &ev->addr.bdaddr,
12674 ev->addr.type, ev->rssi, 0, flags,
12675 eir, eir_len, false);
12679 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12680 static void le_device_found_callback(uint16_t index, uint16_t length,
12681 const void *param, void *user_data)
12683 const struct mgmt_ev_le_device_found *ev = param;
12684 struct btd_adapter *adapter = user_data;
12685 const uint8_t *eir;
12690 if (length < sizeof(*ev)) {
12691 error("Too short device found event (%u bytes)", length);
12695 eir_len = btohs(ev->eir_len);
12696 if (length != sizeof(*ev) + eir_len) {
12697 error("Device found event size mismatch (%u != %zu)",
12698 length, sizeof(*ev) + eir_len);
12707 flags = btohl(ev->flags);
12709 ba2str(&ev->addr.bdaddr, addr);
12710 /*DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12711 index, addr, ev->rssi, flags, eir_len);*/
12713 btd_adapter_device_found(adapter, &ev->addr.bdaddr, ev->addr.type,
12714 ev->rssi, ev->adv_type, flags,
12715 eir, eir_len, false);
12719 struct agent *adapter_get_agent(struct btd_adapter *adapter)
12721 return agent_get(NULL);
12724 static void adapter_remove_connection(struct btd_adapter *adapter,
12725 struct btd_device *device,
12726 uint8_t bdaddr_type)
12728 bool remove_device = false;
12732 if (!g_slist_find(adapter->connections, device)) {
12733 btd_error(adapter->dev_id, "No matching connection for device");
12737 device_remove_connection(device, bdaddr_type, &remove_device);
12739 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12740 if (device_is_authenticating(device, bdaddr_type))
12742 if (device_is_authenticating(device))
12744 device_cancel_authentication(device, TRUE);
12746 /* If another bearer is still connected */
12747 if (btd_device_is_connected(device))
12750 adapter->connections = g_slist_remove(adapter->connections, device);
12752 if (remove_device) {
12753 const char *path = device_get_path(device);
12755 DBG("Removing temporary device %s", path);
12756 btd_adapter_remove_device(adapter, device);
12759 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12760 DBG("isPaired %d, isBonded %d", device_is_paired(device, bdaddr_type),
12761 device_is_bonded(device, bdaddr_type));
12762 if ((device_is_temporary(device) && !device_is_retrying(device)) ||
12763 (!device_is_bonded(device, bdaddr_type))) {
12765 const char *path = device_get_path(device);
12767 DBG("Removing temporary device %s", path);
12769 /* device_is_paired is added incase of tempoary bonded
12770 * oop file transfer in that device is not bonded it's paired.
12772 if (!(device_is_bonded(device, bdaddr_type) ||
12773 device_is_paired(device, bdaddr_type))) {
12774 DBG("addr type %d, bonded", bdaddr_type);
12778 btd_adapter_unpair_device(adapter, device);
12783 static void adapter_stop(struct btd_adapter *adapter)
12785 /* check pending requests */
12786 reply_pending_requests(adapter);
12788 cancel_passive_scanning(adapter);
12790 remove_discovery_list(adapter);
12792 discovery_cleanup(adapter, 0);
12794 adapter->filtered_discovery = false;
12795 adapter->no_scan_restart_delay = false;
12796 g_free(adapter->current_discovery_filter);
12797 adapter->current_discovery_filter = NULL;
12799 set_discovery_discoverable(adapter, false);
12800 adapter->discovering = false;
12802 while (adapter->connections) {
12803 struct btd_device *device = adapter->connections->data;
12804 uint8_t addr_type = btd_device_get_bdaddr_type(device);
12806 adapter_remove_connection(adapter, device, BDADDR_BREDR);
12807 if (addr_type != BDADDR_BREDR)
12808 adapter_remove_connection(adapter, device, addr_type);
12811 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12812 ADAPTER_INTERFACE, "Discovering");
12813 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12814 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12815 ADAPTER_INTERFACE, "LEDiscovering");
12818 if (adapter->dev_class) {
12819 /* the kernel should reset the class of device when powering
12820 * down, but it does not. So force it here ... */
12821 adapter->dev_class = 0;
12822 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12823 ADAPTER_INTERFACE, "Class");
12826 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12827 advertiser_cleanup(adapter);
12829 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12830 ADAPTER_INTERFACE, "Powered");
12831 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12835 DBG("adapter %s has been disabled", adapter->path);
12838 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
12840 if (driver->experimental && !(g_dbus_get_flags() &
12841 G_DBUS_FLAG_ENABLE_EXPERIMENTAL)) {
12842 DBG("D-Bus experimental not enabled");
12846 adapter_drivers = g_slist_append(adapter_drivers, driver);
12848 if (driver->probe == NULL)
12851 adapter_foreach(probe_driver, driver);
12856 static void unload_driver(struct btd_adapter *adapter, gpointer data)
12858 struct btd_adapter_driver *driver = data;
12860 if (driver->remove)
12861 driver->remove(adapter);
12863 adapter->drivers = g_slist_remove(adapter->drivers, data);
12866 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
12868 adapter_drivers = g_slist_remove(adapter_drivers, driver);
12870 adapter_foreach(unload_driver, driver);
12873 static void agent_auth_cb(struct agent *agent, DBusError *derr,
12876 struct btd_adapter *adapter = user_data;
12877 struct service_auth *auth = g_queue_pop_head(adapter->auths);
12880 DBG("No pending authorization");
12884 auth->cb(derr, auth->user_data);
12887 agent_unref(auth->agent);
12891 /* Stop processing if queue is empty */
12892 if (g_queue_is_empty(adapter->auths)) {
12893 if (adapter->auth_idle_id > 0)
12894 g_source_remove(adapter->auth_idle_id);
12898 if (adapter->auth_idle_id > 0)
12901 adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12904 static gboolean process_auth_queue(gpointer user_data)
12906 struct btd_adapter *adapter = user_data;
12909 adapter->auth_idle_id = 0;
12911 dbus_error_init(&err);
12912 dbus_set_error_const(&err, ERROR_INTERFACE ".Rejected", NULL);
12914 while (!g_queue_is_empty(adapter->auths)) {
12915 struct service_auth *auth = adapter->auths->head->data;
12916 struct btd_device *device = auth->device;
12918 /* Wait services to be resolved before asking authorization */
12919 if (auth->svc_id > 0) {
12920 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12921 DBG("Wait services to be resolved before asking authorization");
12925 if (!btd_adapter_is_uuid_allowed(adapter, auth->uuid)) {
12926 auth->cb(&err, auth->user_data);
12930 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12931 if (btd_device_is_trusted(device) == TRUE) {
12933 if (btd_device_is_trusted(device) == TRUE
12934 || device_is_profile_trusted(device, auth->uuid)
12935 || btd_opts.pin_code) {
12936 /* In headless device(pin_code is existing),
12937 no need to request to agent */
12939 auth->cb(NULL, auth->user_data);
12943 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12944 /* If Profile is Blocked, Simply reject Authorization*/
12945 if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
12946 auth->cb(&err, auth->user_data);
12951 /* If agent is set authorization is already ongoing */
12955 auth->agent = agent_get(NULL);
12956 if (auth->agent == NULL) {
12957 btd_warn(adapter->dev_id,
12958 "Authentication attempt without agent");
12959 auth->cb(&err, auth->user_data);
12963 if (agent_authorize_service(auth->agent, device, auth->uuid,
12964 agent_auth_cb, adapter, NULL) < 0) {
12965 auth->cb(&err, auth->user_data);
12973 agent_unref(auth->agent);
12977 g_queue_pop_head(adapter->auths);
12980 dbus_error_free(&err);
12985 static void svc_complete(struct btd_device *dev, int err, void *user_data)
12987 struct service_auth *auth = user_data;
12988 struct btd_adapter *adapter = auth->adapter;
12992 if (adapter->auth_idle_id != 0)
12995 adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12998 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
13000 adapter_authorize_type check_for_connection,
13001 service_auth_cb cb, void *user_data)
13003 struct service_auth *auth;
13004 struct btd_device *device;
13005 static guint id = 0;
13007 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13008 if (!strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
13009 device = btd_adapter_find_device(adapter, dst, BDADDR_LE_PUBLIC);
13011 device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
13013 device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
13019 if (device_is_disconnecting(device)) {
13020 DBG("Authorization request while disconnecting");
13024 /* Device connected? */
13025 if (check_for_connection && !g_slist_find(adapter->connections, device))
13026 btd_error(adapter->dev_id,
13027 "Authorization request for non-connected device!?");
13029 auth = g_try_new0(struct service_auth, 1);
13034 auth->user_data = user_data;
13036 auth->device = device;
13037 auth->adapter = adapter;
13039 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13040 if (check_for_connection &&
13041 strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
13043 if (check_for_connection)
13045 auth->svc_id = device_wait_for_svc_complete(device, svc_complete, auth);
13047 if (adapter->auth_idle_id == 0)
13048 adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
13051 g_queue_push_tail(adapter->auths, auth);
13056 guint btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
13057 const char *uuid, service_auth_cb cb,
13060 struct btd_adapter *adapter;
13063 if (bacmp(src, BDADDR_ANY) != 0) {
13064 adapter = adapter_find(src);
13068 return adapter_authorize(adapter, dst, uuid,
13069 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
13072 for (l = adapters; l != NULL; l = g_slist_next(l)) {
13077 id = adapter_authorize(adapter, dst, uuid,
13078 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
13086 guint btd_request_authorization_cable_configured(const bdaddr_t *src, const bdaddr_t *dst,
13087 const char *uuid, service_auth_cb cb,
13090 struct btd_adapter *adapter;
13092 if (bacmp(src, BDADDR_ANY) == 0)
13095 adapter = adapter_find(src);
13099 return adapter_authorize(adapter, dst, uuid,
13100 ADAPTER_AUTHORIZE_DISCONNECTED, cb, user_data);
13103 static struct service_auth *find_authorization(guint id)
13108 for (l = adapters; l != NULL; l = g_slist_next(l)) {
13109 struct btd_adapter *adapter = l->data;
13111 for (l2 = adapter->auths->head; l2 != NULL; l2 = l2->next) {
13112 struct service_auth *auth = l2->data;
13114 if (auth->id == id)
13122 int btd_cancel_authorization(guint id)
13124 struct service_auth *auth;
13126 auth = find_authorization(id);
13130 if (auth->svc_id > 0)
13131 device_remove_svc_complete_callback(auth->device,
13134 g_queue_remove(auth->adapter->auths, auth);
13137 agent_cancel(auth->agent);
13138 agent_unref(auth->agent);
13146 int btd_adapter_restore_powered(struct btd_adapter *adapter)
13150 powered = btd_adapter_get_powered(adapter);
13151 if (adapter->power_state == ADAPTER_POWER_STATE_OFF_BLOCKED &&
13152 rfkill_get_blocked(adapter->dev_id) == 0) {
13153 adapter_set_power_state(adapter,
13155 ADAPTER_POWER_STATE_ON :
13156 ADAPTER_POWER_STATE_OFF);
13162 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
13167 int btd_adapter_set_blocked(struct btd_adapter *adapter)
13169 adapter_set_power_state(adapter, ADAPTER_POWER_STATE_OFF_BLOCKED);
13173 void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
13174 btd_adapter_pin_cb_t cb)
13176 adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
13179 void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
13180 btd_adapter_pin_cb_t cb)
13182 adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
13185 void btd_adapter_unregister_msd_cb(struct btd_adapter *adapter,
13188 adapter->msd_callbacks = g_slist_remove(adapter->msd_callbacks, cb);
13191 void btd_adapter_register_msd_cb(struct btd_adapter *adapter,
13194 adapter->msd_callbacks = g_slist_prepend(adapter->msd_callbacks, cb);
13197 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
13200 if (!btd_adapter_get_powered(adapter))
13203 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, enable ? 0x01 : 0x00);
13208 int btd_adapter_read_clock(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13209 int which, int timeout, uint32_t *clock,
13210 uint16_t *accuracy)
13212 if (!btd_adapter_get_powered(adapter))
13218 int btd_adapter_remove_bonding(struct btd_adapter *adapter,
13219 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
13221 struct mgmt_cp_unpair_device cp;
13223 memset(&cp, 0, sizeof(cp));
13224 bacpy(&cp.addr.bdaddr, bdaddr);
13225 cp.addr.type = bdaddr_type;
13228 if (mgmt_send(adapter->mgmt, MGMT_OP_UNPAIR_DEVICE,
13229 adapter->dev_id, sizeof(cp), &cp,
13230 NULL, NULL, NULL) > 0)
13236 static void pincode_reply_complete(uint8_t status, uint16_t length,
13237 const void *param, void *user_data)
13239 struct btd_device *device = user_data;
13241 /* If the MGMT_OP_PIN_CODE_REPLY command is acknowledged, move the
13242 * starting time to that point. This give a better sense of time
13243 * evaluating the pincode. */
13244 device_bonding_restart_timer(device);
13247 int btd_adapter_pincode_reply(struct btd_adapter *adapter,
13248 const bdaddr_t *bdaddr,
13249 const char *pin, size_t pin_len)
13251 struct btd_device *device;
13255 ba2str(bdaddr, addr);
13256 DBG("hci%u addr %s pinlen %zu", adapter->dev_id, addr, pin_len);
13259 struct mgmt_cp_pin_code_neg_reply cp;
13261 memset(&cp, 0, sizeof(cp));
13262 bacpy(&cp.addr.bdaddr, bdaddr);
13263 cp.addr.type = BDADDR_BREDR;
13265 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
13266 adapter->dev_id, sizeof(cp), &cp,
13269 struct mgmt_cp_pin_code_reply cp;
13274 memset(&cp, 0, sizeof(cp));
13275 bacpy(&cp.addr.bdaddr, bdaddr);
13276 cp.addr.type = BDADDR_BREDR;
13277 cp.pin_len = pin_len;
13278 memcpy(cp.pin_code, pin, pin_len);
13280 /* Since a pincode was requested, update the starting time to
13281 * the point where the pincode is provided. */
13282 device = btd_adapter_find_device(adapter, bdaddr, BDADDR_BREDR);
13283 device_bonding_restart_timer(device);
13285 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_REPLY,
13286 adapter->dev_id, sizeof(cp), &cp,
13287 pincode_reply_complete, device, NULL);
13296 int btd_adapter_confirm_reply(struct btd_adapter *adapter,
13297 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13300 struct mgmt_cp_user_confirm_reply cp;
13304 ba2str(bdaddr, addr);
13305 DBG("hci%u addr %s success %d", adapter->dev_id, addr, success);
13308 opcode = MGMT_OP_USER_CONFIRM_REPLY;
13310 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
13312 memset(&cp, 0, sizeof(cp));
13313 bacpy(&cp.addr.bdaddr, bdaddr);
13314 cp.addr.type = bdaddr_type;
13316 if (mgmt_reply(adapter->mgmt, opcode, adapter->dev_id, sizeof(cp), &cp,
13317 NULL, NULL, NULL) > 0)
13323 static void user_confirm_request_callback(uint16_t index, uint16_t length,
13324 const void *param, void *user_data)
13326 const struct mgmt_ev_user_confirm_request *ev = param;
13327 struct btd_adapter *adapter = user_data;
13328 struct btd_device *device;
13332 if (length < sizeof(*ev)) {
13333 btd_error(adapter->dev_id,
13334 "Too small user confirm request event");
13338 ba2str(&ev->addr.bdaddr, addr);
13339 DBG("hci%u %s confirm_hint %u", adapter->dev_id, addr,
13341 device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13344 btd_error(adapter->dev_id,
13345 "Unable to get device object for %s", addr);
13349 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13350 device_set_auth_addr_type(device, ev->addr.type);
13352 err = device_confirm_passkey(device, ev->addr.type, btohl(ev->value),
13355 btd_error(adapter->dev_id,
13356 "device_confirm_passkey: %s", strerror(-err));
13357 btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
13358 ev->addr.type, FALSE);
13362 int btd_adapter_passkey_reply(struct btd_adapter *adapter,
13363 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13369 ba2str(bdaddr, addr);
13370 DBG("hci%u addr %s passkey %06u", adapter->dev_id, addr, passkey);
13372 if (passkey == INVALID_PASSKEY) {
13373 struct mgmt_cp_user_passkey_neg_reply cp;
13375 memset(&cp, 0, sizeof(cp));
13376 bacpy(&cp.addr.bdaddr, bdaddr);
13377 cp.addr.type = bdaddr_type;
13379 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
13380 adapter->dev_id, sizeof(cp), &cp,
13383 struct mgmt_cp_user_passkey_reply cp;
13385 memset(&cp, 0, sizeof(cp));
13386 bacpy(&cp.addr.bdaddr, bdaddr);
13387 cp.addr.type = bdaddr_type;
13388 cp.passkey = htobl(passkey);
13390 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_REPLY,
13391 adapter->dev_id, sizeof(cp), &cp,
13401 static void user_passkey_request_callback(uint16_t index, uint16_t length,
13402 const void *param, void *user_data)
13404 const struct mgmt_ev_user_passkey_request *ev = param;
13405 struct btd_adapter *adapter = user_data;
13406 struct btd_device *device;
13410 if (length < sizeof(*ev)) {
13411 btd_error(adapter->dev_id, "Too small passkey request event");
13415 ba2str(&ev->addr.bdaddr, addr);
13416 DBG("hci%u %s", index, addr);
13418 device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13421 btd_error(adapter->dev_id,
13422 "Unable to get device object for %s", addr);
13426 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13427 device_set_auth_addr_type(device, ev->addr.type);
13429 err = device_request_passkey(device, ev->addr.type);
13431 btd_error(adapter->dev_id,
13432 "device_request_passkey: %s", strerror(-err));
13433 btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
13434 ev->addr.type, INVALID_PASSKEY);
13438 static void user_passkey_notify_callback(uint16_t index, uint16_t length,
13439 const void *param, void *user_data)
13441 const struct mgmt_ev_passkey_notify *ev = param;
13442 struct btd_adapter *adapter = user_data;
13443 struct btd_device *device;
13448 if (length < sizeof(*ev)) {
13449 btd_error(adapter->dev_id, "Too small passkey notify event");
13453 ba2str(&ev->addr.bdaddr, addr);
13454 DBG("hci%u %s", index, addr);
13456 device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13459 btd_error(adapter->dev_id,
13460 "Unable to get device object for %s", addr);
13464 passkey = get_le32(&ev->passkey);
13466 DBG("passkey %06u entered %u", passkey, ev->entered);
13468 err = device_notify_passkey(device, ev->addr.type, passkey,
13471 btd_error(adapter->dev_id,
13472 "device_notify_passkey: %s", strerror(-err));
13475 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13476 static void rssi_alert_callback(uint16_t index, uint16_t length,
13477 const void *param, void *user_data)
13479 const struct mgmt_ev_vendor_specific_rssi_alert *ev = param;
13480 struct btd_adapter *adapter = user_data;
13482 char *bt_addr = NULL;
13483 int link_type = -1;
13484 int alert_type = -1;
13487 if (length < sizeof(*ev)) {
13488 error("Too small rssi alert event");
13492 ba2str(&ev->bdaddr, addr);
13493 DBG("hci%u %s %d", index, addr, ev->link_type);
13494 DBG("RSSI Alert Params [%d %d]", ev->alert_type, ev->rssi_dbm);
13496 bt_addr = (char *)&addr;
13497 link_type = ev->link_type;
13498 alert_type = ev->alert_type;
13499 rssi_dbm = ev->rssi_dbm;
13500 g_dbus_emit_signal(dbus_conn, adapter->path,
13501 ADAPTER_INTERFACE, "RssiAlert",
13502 DBUS_TYPE_STRING, &bt_addr,
13503 DBUS_TYPE_INT32, &link_type,
13504 DBUS_TYPE_INT32, &alert_type,
13505 DBUS_TYPE_INT32, &rssi_dbm,
13506 DBUS_TYPE_INVALID);
13509 static void get_raw_rssi_callback(uint16_t index, uint16_t length,
13510 const void *param, void *user_data)
13512 const struct mgmt_cc_rp_get_raw_rssi *ev = param;
13513 struct btd_adapter *adapter = user_data;
13515 char *bt_addr = NULL;
13516 int link_type = -1;
13519 if (length < sizeof(*ev)) {
13520 error("Too small raw RSSI event");
13524 ba2str(&ev->bt_address, addr);
13525 DBG("hci%u %s", index, addr);
13526 DBG("Raw RSSI Params [%d %d]", ev->link_type, ev->rssi_dbm);
13528 bt_addr = (char *)&addr;
13529 link_type = ev->link_type;
13530 rssi_dbm = ev->rssi_dbm;
13532 g_dbus_emit_signal(dbus_conn, adapter->path,
13533 ADAPTER_INTERFACE, "RawRssi",
13534 DBUS_TYPE_STRING, &bt_addr,
13535 DBUS_TYPE_INT32, &link_type,
13536 DBUS_TYPE_INT32, &rssi_dbm,
13537 DBUS_TYPE_INVALID);
13540 static void rssi_enabled_callback(uint16_t index, uint16_t length,
13541 const void *param, void *user_data)
13543 const struct mgmt_cc_rsp_enable_rssi *ev = param;
13544 struct btd_adapter *adapter = user_data;
13546 char *bt_addr = NULL;
13547 int enabled = TRUE;
13548 int link_type = -1;
13550 if (length < sizeof(*ev)) {
13551 error("Too small rssi enabled event");
13555 ba2str(&ev->bt_address, addr);
13556 DBG("hci%u %s %d", index, addr, ev->link_type);
13557 DBG("RSSI Enabled [%d %d]", ev->le_ext_opcode, ev->status);
13559 bt_addr = (char *)&addr;
13560 link_type = ev->link_type;
13562 g_dbus_emit_signal(dbus_conn, adapter->path,
13563 ADAPTER_INTERFACE, "RssiEnabled",
13564 DBUS_TYPE_STRING, &bt_addr,
13565 DBUS_TYPE_INT32, &link_type,
13566 DBUS_TYPE_BOOLEAN, &enabled,
13567 DBUS_TYPE_INVALID);
13570 static void rssi_disabled_callback(uint16_t index, uint16_t length,
13571 const void *param, void *user_data)
13573 const struct mgmt_cc_rp_disable_rssi *ev = param;
13574 struct btd_adapter *adapter = user_data;
13576 char *bt_addr = NULL;
13577 int disabled = FALSE;
13578 int link_type = -1;
13580 if (length < sizeof(*ev)) {
13581 error("Too small RSSI disabled event");
13585 ba2str(&ev->bt_address, addr);
13586 DBG("hci%u %s %d", index, addr, ev->link_type);
13587 DBG("RSSI Disabled Params [%d %d]", ev->le_ext_opcode, ev->status);
13589 bt_addr = (char *)&addr;
13590 link_type = ev->link_type;
13592 g_dbus_emit_signal(dbus_conn, adapter->path,
13593 ADAPTER_INTERFACE, "RssiEnabled",
13594 DBUS_TYPE_STRING, &bt_addr,
13595 DBUS_TYPE_INT32, &link_type,
13596 DBUS_TYPE_BOOLEAN, &disabled,
13597 DBUS_TYPE_INVALID);
13600 void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver)
13606 ver = "Bluetooth 1.0b";
13609 ver = "Bluetooth 1.1";
13612 ver = "Bluetooth 1.2";
13615 ver = "Bluetooth 2.0 + EDR";
13618 ver = "Bluetooth 2.1 + EDR";
13621 ver = "Bluetooth 3.0 + HS";
13624 ver = "Bluetooth 4.0";
13627 ver = "Bluetooth 4.1";
13634 if (adapter->version)
13635 g_free(adapter->version);
13637 adapter->version = g_strdup(ver);
13640 static void hardware_error_callback(uint16_t index, uint16_t length,
13641 const void *param, void *user_data)
13643 const struct mgmt_ev_hardware_error *ev = param;
13644 struct btd_adapter *adapter = user_data;
13646 if (length < sizeof(*ev)) {
13647 error("Too small Hardware error event");
13651 error("Hardware error occurred : %d", ev->error_code);
13652 g_dbus_emit_signal(dbus_conn, adapter->path,
13653 ADAPTER_INTERFACE, "HardwareError",
13654 DBUS_TYPE_INVALID);
13657 static void tx_timeout_error_callback(uint16_t index, uint16_t length,
13658 const void *param, void *user_data)
13660 struct btd_adapter *adapter = user_data;
13662 error("Tx Timeout error occurred");
13663 g_dbus_emit_signal(dbus_conn, adapter->path,
13664 ADAPTER_INTERFACE, "TxTimeoutError",
13665 DBUS_TYPE_INVALID);
13668 static void device_name_update_callback(uint16_t index, uint16_t length,
13669 const void *param, void *user_data)
13671 const struct mgmt_ev_device_name_update *ev = param;
13672 struct btd_adapter *adapter = user_data;
13673 struct btd_device *device;
13675 const uint8_t *eir_name;
13676 struct eir_data eir_data;
13678 if (length < sizeof(*ev)) {
13679 error("Name update error event");
13683 ba2str(&ev->addr.bdaddr, addr);
13684 DBG("hci%u %s", index, addr);
13686 device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13689 error("Unable to get device object for %s", addr);
13693 if (ev->eir_len == 0)
13696 eir_name = ev->eir;
13698 memset(&eir_data, 0, sizeof(eir_data));
13699 eir_parse(&eir_data, eir_name, ev->eir_len);
13702 btd_device_device_set_name(device, eir_data.name);
13704 eir_data_free(&eir_data);
13707 struct multi_adv_data {
13708 struct btd_adapter *adapter;
13712 static gboolean multi_adv_start_timeout_cb(gpointer user_data)
13714 struct multi_adv_data *data = user_data;
13715 struct btd_adapter *adapter = data->adapter;
13718 adapter->adv_restart_timeout = 0;
13720 err = adapter_le_enable_multi_adv(adapter, TRUE, data->slot_id);
13722 advertising_state_changed(adapter, data->slot_id, FALSE);
13728 static void multi_adv_state_change_callback(uint16_t index, uint16_t length,
13729 const void *param, void *user_data)
13731 const struct mgmt_ev_vendor_specific_multi_adv_state_changed *ev = param;
13732 struct btd_adapter *adapter = user_data;
13733 struct multi_adv_data *data;
13735 if (length < sizeof(*ev)) {
13736 error("Too small adv state change event");
13740 DBG("adv id %d, state change reason %d, connection_handle %x",
13741 ev->adv_instance, ev->state_change_reason, ev->connection_handle);
13743 if ((ev->adv_instance > 0 && ev->adv_instance < adapter_le_get_max_adv_instance()) &&
13744 ev->state_change_reason == 0) {
13745 /* advertising is stopped by controller, it should be enabled again.
13746 * If fails, state should be changed to FALSE */
13747 data = g_new0(struct multi_adv_data, 1);
13748 data->adapter = adapter;
13749 data->slot_id = ev->adv_instance;
13751 adapter->adv_restart_timeout =
13752 g_timeout_add(300, multi_adv_start_timeout_cb, data);
13756 static void le_conn_update_completed_callback(uint16_t index, uint16_t length,
13757 const void *param, void *user_data)
13759 const struct mgmt_ev_conn_updated *ev = param;
13760 struct btd_adapter *adapter = user_data;
13761 struct btd_device *device;
13763 GSList *list = NULL;
13765 if (length < sizeof(*ev)) {
13766 error("Too small le conn update completed event");
13770 ba2str(&ev->addr.bdaddr, addr);
13771 if (ev->addr.type == BDADDR_LE_PUBLIC) {
13772 /* Private Random Address */
13773 list = g_slist_find_custom(adapter->devices, addr,
13774 device_rpa_ida_cmp);
13777 list = g_slist_find_custom(adapter->devices, addr,
13778 device_address_cmp);
13779 } else if (ev->addr.type == BDADDR_LE_RANDOM) {
13780 /* LE Static Random address */
13781 list = g_slist_find_custom(adapter->devices, addr,
13782 device_address_cmp);
13786 device = list->data;
13787 device_print_addr(device);
13789 if (device_get_conn_update_state(device))
13790 device_set_conn_update_state(device, false);
13794 static void bt_6lowpan_conn_state_change_callback(uint16_t index, uint16_t length,
13795 const void *param, void *user_data)
13797 const struct mgmt_ev_6lowpan_conn_state_changed *ev = param;
13798 struct btd_adapter *adapter = user_data;
13799 struct btd_device *device;
13801 gboolean connected = 0;
13803 if (length < sizeof(*ev)) {
13804 btd_error(adapter->dev_id,
13805 "Too small device connected event");
13809 ba2str(&ev->addr.bdaddr, addr);
13811 DBG("hci%u device %s", index, addr);
13813 device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13816 btd_error(adapter->dev_id,
13817 "Unable to get device object for %s", addr);
13826 device_set_ipsp_connected(device, connected, ev->ifname);
13829 static void bt_le_data_length_changed_callback(uint16_t index, uint16_t length,
13830 const void *param, void *user_data)
13832 const struct mgmt_ev_le_data_length_changed *ev = param;
13833 struct btd_adapter *adapter = user_data;
13834 struct btd_device *device;
13837 if (length < sizeof(*ev)) {
13838 btd_error(adapter->dev_id,
13839 "Too small data length changed event");
13843 ba2str(&ev->addr.bdaddr, addr);
13845 DBG("hci%u device %s", index, addr);
13847 device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13850 btd_error(adapter->dev_id,
13851 "Unable to get device object for %s", addr);
13855 device_le_data_length_changed(device, ev->max_tx_octets, ev->max_tx_time,
13856 ev->max_rx_octets, ev->max_rx_time);
13861 struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
13862 struct btd_adapter *adapter)
13864 struct btd_adapter_pin_cb_iter *iter =
13865 g_new0(struct btd_adapter_pin_cb_iter, 1);
13867 iter->it = adapter->pin_callbacks;
13873 void btd_adapter_pin_cb_iter_free(struct btd_adapter_pin_cb_iter *iter)
13878 bool btd_adapter_pin_cb_iter_end(struct btd_adapter_pin_cb_iter *iter)
13880 return iter->it == NULL && iter->attempt == 0;
13883 static ssize_t btd_adapter_pin_cb_iter_next(
13884 struct btd_adapter_pin_cb_iter *iter,
13885 struct btd_adapter *adapter,
13886 struct btd_device *device,
13887 char *pin_buf, bool *display)
13889 btd_adapter_pin_cb_t cb;
13892 while (iter->it != NULL) {
13893 cb = iter->it->data;
13894 ret = cb(adapter, device, pin_buf, display, iter->attempt);
13899 iter->it = g_slist_next(iter->it);
13906 static void pin_code_request_callback(uint16_t index, uint16_t length,
13907 const void *param, void *user_data)
13909 const struct mgmt_ev_pin_code_request *ev = param;
13910 struct btd_adapter *adapter = user_data;
13911 struct btd_device *device;
13912 bool display = false;
13917 struct btd_adapter_pin_cb_iter *iter;
13919 if (length < sizeof(*ev)) {
13920 btd_error(adapter->dev_id, "Too small PIN code request event");
13924 ba2str(&ev->addr.bdaddr, addr);
13926 DBG("hci%u %s", adapter->dev_id, addr);
13928 device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13931 btd_error(adapter->dev_id,
13932 "Unable to get device object for %s", addr);
13936 /* Flag the request of a pincode to allow a bonding retry. */
13937 adapter->pincode_requested = true;
13938 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13939 btd_device_set_legacy_pairing(device, true);
13942 memset(pin, 0, sizeof(pin));
13944 iter = device_bonding_iter(device);
13948 pinlen = btd_adapter_pin_cb_iter_next(iter, adapter, device,
13951 if (pinlen > 0 && (!ev->secure || pinlen == 16)) {
13952 if (display && device_is_bonding(device, NULL)) {
13953 err = device_notify_pincode(device, ev->secure, pin);
13955 btd_error(adapter->dev_id,
13956 "device_notify_pin: %s",
13958 btd_adapter_pincode_reply(adapter,
13963 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
13969 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13970 if (btd_opts.pin_code) {
13971 /* Because we can't receive user input on headless device,
13972 no need to request pincode. Use the 'PinCode' in headless conf file */
13973 DBG("Use configured PinCode in headless device");
13974 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
13975 btd_opts.pin_code, strlen(btd_opts.pin_code));
13980 err = device_request_pincode(device, ev->secure);
13982 btd_error(adapter->dev_id, "device_request_pin: %s",
13984 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
13988 int adapter_cancel_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13991 struct mgmt_addr_info cp;
13994 ba2str(bdaddr, addr);
13995 DBG("hci%u bdaddr %s type %u", adapter->dev_id, addr, addr_type);
13997 memset(&cp, 0, sizeof(cp));
13998 bacpy(&cp.bdaddr, bdaddr);
13999 cp.type = addr_type;
14001 if (mgmt_reply(adapter->mgmt, MGMT_OP_CANCEL_PAIR_DEVICE,
14002 adapter->dev_id, sizeof(cp), &cp,
14003 NULL, NULL, NULL) > 0)
14009 static void check_oob_bonding_complete(struct btd_adapter *adapter,
14010 const bdaddr_t *bdaddr, uint8_t status)
14012 if (!adapter->oob_handler || !adapter->oob_handler->bonding_cb)
14015 if (bacmp(bdaddr, &adapter->oob_handler->remote_addr) != 0)
14018 adapter->oob_handler->bonding_cb(adapter, bdaddr, status,
14019 adapter->oob_handler->user_data);
14021 g_free(adapter->oob_handler);
14022 adapter->oob_handler = NULL;
14025 static void bonding_complete(struct btd_adapter *adapter,
14026 const bdaddr_t *bdaddr,
14027 uint8_t addr_type, uint8_t status)
14029 struct btd_device *device;
14032 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
14034 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
14036 if (device != NULL)
14037 device_bonding_complete(device, addr_type, status);
14039 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14040 resume_discovery(adapter);
14042 check_oob_bonding_complete(adapter, bdaddr, status);
14045 /* bonding_attempt_complete() handles the end of a "bonding attempt" checking if
14046 * it should begin a new attempt or complete the bonding.
14048 static void bonding_attempt_complete(struct btd_adapter *adapter,
14049 const bdaddr_t *bdaddr,
14050 uint8_t addr_type, uint8_t status)
14052 struct btd_device *device;
14055 ba2str(bdaddr, addr);
14056 DBG("hci%u bdaddr %s type %u status 0x%x", adapter->dev_id, addr,
14057 addr_type, status);
14060 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
14062 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
14064 if (status == MGMT_STATUS_AUTH_FAILED && adapter->pincode_requested) {
14065 /* On faliure, issue a bonding_retry if possible. */
14066 if (device != NULL) {
14067 if (device_bonding_attempt_retry(device) == 0)
14072 /* Ignore disconnects during retry. */
14073 if (status == MGMT_STATUS_DISCONNECTED &&
14074 device && device_is_retrying(device))
14077 /* In any other case, finish the bonding. */
14078 bonding_complete(adapter, bdaddr, addr_type, status);
14081 struct pair_device_data {
14082 struct btd_adapter *adapter;
14087 static void free_pair_device_data(void *user_data)
14089 struct pair_device_data *data = user_data;
14094 static void pair_device_complete(uint8_t status, uint16_t length,
14095 const void *param, void *user_data)
14097 const struct mgmt_rp_pair_device *rp = param;
14098 struct pair_device_data *data = user_data;
14099 struct btd_adapter *adapter = data->adapter;
14101 DBG("%s (0x%02x)", mgmt_errstr(status), status);
14103 /* Workaround for a kernel bug
14105 * Broken kernels may reply to device pairing command with command
14106 * status instead of command complete event e.g. if adapter was not
14109 if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
14110 btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
14111 mgmt_errstr(status), status);
14113 bonding_attempt_complete(adapter, &data->bdaddr,
14114 data->addr_type, status);
14118 if (length < sizeof(*rp)) {
14119 btd_error(adapter->dev_id, "Too small pair device response");
14123 bonding_attempt_complete(adapter, &rp->addr.bdaddr, rp->addr.type,
14127 int adapter_create_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14128 uint8_t addr_type, uint8_t io_cap)
14130 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14131 suspend_discovery(adapter);
14133 return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
14136 /* Starts a new bonding attempt in a fresh new bonding_req or a retried one. */
14137 int adapter_bonding_attempt(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14138 uint8_t addr_type, uint8_t io_cap)
14140 struct mgmt_cp_pair_device cp;
14142 struct pair_device_data *data;
14145 ba2str(bdaddr, addr);
14146 DBG("hci%u bdaddr %s type %d io_cap 0x%02x",
14147 adapter->dev_id, addr, addr_type, io_cap);
14149 /* Reset the pincode_requested flag for a new bonding attempt. */
14150 adapter->pincode_requested = false;
14152 memset(&cp, 0, sizeof(cp));
14153 bacpy(&cp.addr.bdaddr, bdaddr);
14154 cp.addr.type = addr_type;
14155 cp.io_cap = io_cap;
14157 data = g_new0(struct pair_device_data, 1);
14158 data->adapter = adapter;
14159 bacpy(&data->bdaddr, bdaddr);
14160 data->addr_type = addr_type;
14162 /* Due to a bug in the kernel it is possible that a LE pairing
14163 * request never times out. Therefore, add a timer to clean up
14164 * if no response arrives
14166 id = mgmt_send_timeout(adapter->mgmt, MGMT_OP_PAIR_DEVICE,
14167 adapter->dev_id, sizeof(cp), &cp,
14168 pair_device_complete, data,
14169 free_pair_device_data, BONDING_TIMEOUT);
14171 btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
14172 addr, adapter->dev_id);
14173 free_pair_device_data(data);
14180 static void disconnect_notify(struct btd_device *dev, uint8_t reason)
14184 for (l = disconnect_list; l; l = g_slist_next(l)) {
14185 btd_disconnect_cb disconnect_cb = l->data;
14186 disconnect_cb(dev, reason);
14190 static void dev_disconnected(struct btd_adapter *adapter,
14191 const struct mgmt_addr_info *addr,
14194 struct btd_device *device;
14196 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14197 struct device_addr_type t_addr;
14200 ba2str(&addr->bdaddr, dst);
14202 DBG("Device %s disconnected, reason %u", dst, reason);
14204 device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
14206 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14208 device_get_tizen_addr(device, addr->type, &t_addr);
14210 device_set_disconnect_reason(device, reason);
14211 adapter_remove_connection(adapter, device, t_addr.bdaddr_type);
14212 disconnect_notify(device, reason);
14213 if (device_is_bonded(device, t_addr.bdaddr_type)) {
14214 DBG("addr type %d, bonded", t_addr.bdaddr_type);
14218 bonding_attempt_complete(adapter, &t_addr.bdaddr,
14219 t_addr.bdaddr_type, MGMT_STATUS_DISCONNECTED);
14224 adapter_remove_connection(adapter, device, addr->type);
14225 disconnect_notify(device, reason);
14229 bonding_attempt_complete(adapter, &addr->bdaddr, addr->type,
14230 MGMT_STATUS_DISCONNECTED);
14233 void btd_add_disconnect_cb(btd_disconnect_cb func)
14235 disconnect_list = g_slist_append(disconnect_list, func);
14238 void btd_remove_disconnect_cb(btd_disconnect_cb func)
14240 disconnect_list = g_slist_remove(disconnect_list, func);
14243 static void disconnect_complete(uint8_t status, uint16_t length,
14244 const void *param, void *user_data)
14246 const struct mgmt_rp_disconnect *rp = param;
14247 struct btd_adapter *adapter = user_data;
14249 if (status == MGMT_STATUS_NOT_CONNECTED) {
14250 btd_warn(adapter->dev_id,
14251 "Disconnecting failed: already disconnected");
14252 } else if (status != MGMT_STATUS_SUCCESS) {
14253 btd_error(adapter->dev_id,
14254 "Failed to disconnect device: %s (0x%02x)",
14255 mgmt_errstr(status), status);
14259 if (length < sizeof(*rp)) {
14260 btd_error(adapter->dev_id,
14261 "Too small device disconnect response");
14265 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14266 /* Use HCI error code instead of MGMT disconnection reason */
14267 dev_disconnected(adapter, &rp->addr, 0x16);
14269 dev_disconnected(adapter, &rp->addr, MGMT_DEV_DISCONN_LOCAL_HOST);
14273 int btd_adapter_disconnect_device(struct btd_adapter *adapter,
14274 const bdaddr_t *bdaddr,
14275 uint8_t bdaddr_type)
14278 struct mgmt_cp_disconnect cp;
14280 memset(&cp, 0, sizeof(cp));
14281 bacpy(&cp.addr.bdaddr, bdaddr);
14282 cp.addr.type = bdaddr_type;
14284 if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT,
14285 adapter->dev_id, sizeof(cp), &cp,
14286 disconnect_complete, adapter, NULL) > 0)
14292 static void auth_failed_callback(uint16_t index, uint16_t length,
14293 const void *param, void *user_data)
14295 const struct mgmt_ev_auth_failed *ev = param;
14296 struct btd_adapter *adapter = user_data;
14298 if (length < sizeof(*ev)) {
14299 btd_error(adapter->dev_id, "Too small auth failed mgmt event");
14303 bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
14307 static void store_link_key(struct btd_adapter *adapter,
14308 struct btd_device *device, const uint8_t *key,
14309 uint8_t type, uint8_t pin_length)
14311 char device_addr[18];
14312 char filename[PATH_MAX];
14313 GKeyFile *key_file;
14314 GError *gerr = NULL;
14320 ba2str(device_get_address(device), device_addr);
14322 create_filename(filename, PATH_MAX, "/%s/%s/info",
14323 btd_adapter_get_storage_dir(adapter), device_addr);
14324 create_file(filename, 0600);
14326 key_file = g_key_file_new();
14327 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14328 error("Unable to load key file from %s: (%s)", filename,
14330 g_error_free(gerr);
14331 g_key_file_free(key_file);
14335 for (i = 0; i < 16; i++)
14336 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14338 g_key_file_set_string(key_file, "LinkKey", "Key", key_str);
14340 g_key_file_set_integer(key_file, "LinkKey", "Type", type);
14341 g_key_file_set_integer(key_file, "LinkKey", "PINLength", pin_length);
14343 str = g_key_file_to_data(key_file, &length, NULL);
14344 if (!g_file_set_contents(filename, str, length, &gerr)) {
14345 error("Unable set contents for %s: (%s)", filename,
14347 g_error_free(gerr);
14351 g_key_file_free(key_file);
14354 static void new_link_key_callback(uint16_t index, uint16_t length,
14355 const void *param, void *user_data)
14357 const struct mgmt_ev_new_link_key *ev = param;
14358 const struct mgmt_addr_info *addr = &ev->key.addr;
14359 struct btd_adapter *adapter = user_data;
14360 struct btd_device *device;
14363 if (length < sizeof(*ev)) {
14364 btd_error(adapter->dev_id, "Too small new link key event");
14368 ba2str(&addr->bdaddr, dst);
14370 DBG("hci%u new key for %s type %u pin_len %u store_hint %u",
14371 adapter->dev_id, dst, ev->key.type, ev->key.pin_len,
14374 if (ev->key.pin_len > 16) {
14375 btd_error(adapter->dev_id,
14376 "Invalid PIN length (%u) in new_key event",
14381 device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14383 btd_error(adapter->dev_id,
14384 "Unable to get device object for %s", dst);
14388 if (ev->store_hint) {
14389 const struct mgmt_link_key_info *key = &ev->key;
14391 store_link_key(adapter, device, key->val, key->type,
14394 device_set_bonded(device, BDADDR_BREDR);
14395 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14397 if (btd_adapter_get_a2dp_role(adapter) & BLUETOOTH_A2DP_SINK_ROLE) {
14398 DBG("store_hint %d", ev->store_hint);
14399 btd_device_set_temporary(device, false);
14404 bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14407 static void store_ltk_group(struct btd_adapter *adapter, const bdaddr_t *peer,
14408 uint8_t bdaddr_type, const unsigned char *key,
14409 const char *group, uint8_t authenticated,
14410 uint8_t enc_size, uint16_t ediv,
14413 char device_addr[18];
14414 char filename[PATH_MAX];
14415 GKeyFile *key_file;
14416 GError *gerr = NULL;
14422 ba2str(peer, device_addr);
14424 create_filename(filename, PATH_MAX, "/%s/%s/info",
14425 btd_adapter_get_storage_dir(adapter), device_addr);
14426 create_file(filename, 0600);
14428 key_file = g_key_file_new();
14429 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14430 error("Unable to load key file from %s: (%s)", filename,
14432 g_error_free(gerr);
14433 g_key_file_free(key_file);
14437 for (i = 0; i < 16; i++)
14438 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14440 g_key_file_set_string(key_file, group, "Key", key_str);
14442 g_key_file_set_integer(key_file, group, "Authenticated",
14444 g_key_file_set_integer(key_file, group, "EncSize", enc_size);
14446 g_key_file_set_integer(key_file, group, "EDiv", ediv);
14447 g_key_file_set_uint64(key_file, group, "Rand", rand);
14449 create_file(filename, 0600);
14451 str = g_key_file_to_data(key_file, &length, NULL);
14452 if (!g_file_set_contents(filename, str, length, &gerr)) {
14453 error("Unable set contents for %s: (%s)", filename,
14455 g_error_free(gerr);
14459 g_key_file_free(key_file);
14462 static void store_longtermkey(struct btd_adapter *adapter, const bdaddr_t *peer,
14463 uint8_t bdaddr_type, const unsigned char *key,
14464 uint8_t central, uint8_t authenticated,
14465 uint8_t enc_size, uint16_t ediv,
14468 if (central != 0x00 && central != 0x01) {
14469 error("Unsupported LTK type %u", central);
14474 store_ltk_group(adapter, peer, bdaddr_type, key, "LongTermKey",
14475 authenticated, enc_size, ediv, rand);
14477 /* Peripheral* is the proper term, but for now keep duplicates
14478 * so it won't break when user up/downgrades. Remove the other
14479 * term after a few releases.
14481 store_ltk_group(adapter, peer, bdaddr_type, key,
14482 "PeripheralLongTermKey", authenticated,
14483 enc_size, ediv, rand);
14484 store_ltk_group(adapter, peer, bdaddr_type, key,
14485 "SlaveLongTermKey", authenticated,
14486 enc_size, ediv, rand);
14490 static void new_long_term_key_callback(uint16_t index, uint16_t length,
14491 const void *param, void *user_data)
14493 const struct mgmt_ev_new_long_term_key *ev = param;
14494 const struct mgmt_addr_info *addr = &ev->key.addr;
14495 struct btd_adapter *adapter = user_data;
14496 struct btd_device *device;
14499 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14500 struct device_addr_type t_addr;
14503 if (length < sizeof(*ev)) {
14504 btd_error(adapter->dev_id, "Too small long term key event");
14508 ba2str(&addr->bdaddr, dst);
14510 DBG("hci%u new LTK for %s type %u enc_size %u",
14511 adapter->dev_id, dst, ev->key.type, ev->key.enc_size);
14513 device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14515 btd_error(adapter->dev_id,
14516 "Unable to get device object for %s", dst);
14521 * Some older kernel versions set store_hint for long term keys
14522 * from resolvable and unresolvable random addresses, but there
14523 * is no point in storing these. Next time around the device
14524 * address will be invalid.
14526 * So only for identity addresses (public and static random) use
14527 * the store_hint as an indication if the long term key should
14528 * be persistently stored.
14531 if (addr->type == BDADDR_LE_RANDOM &&
14532 (addr->bdaddr.b[5] & 0xc0) != 0xc0)
14533 persistent = false;
14535 persistent = !!ev->store_hint;
14538 const struct mgmt_ltk_info *key = &ev->key;
14542 ediv = le16_to_cpu(key->ediv);
14543 rand = le64_to_cpu(key->rand);
14545 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14546 device_get_tizen_addr(device, addr->type, &t_addr);
14547 store_longtermkey(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14548 key->val, key->central, key->type,
14549 key->enc_size, ediv, rand);
14551 store_longtermkey(adapter, &key->addr.bdaddr,
14552 key->addr.type, key->val, key->central,
14553 key->type, key->enc_size, ediv, rand);
14556 device_set_bonded(device, addr->type);
14559 device_set_ltk(device, ev->key.val, ev->key.central, ev->key.enc_size);
14561 bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14564 static void store_csrk(struct btd_adapter *adapter, const bdaddr_t *peer,
14565 uint8_t bdaddr_type, const unsigned char *key,
14566 uint32_t counter, uint8_t type)
14569 char device_addr[18];
14570 char filename[PATH_MAX];
14571 GKeyFile *key_file;
14572 GError *gerr = NULL;
14581 group = "LocalSignatureKey";
14585 group = "RemoteSignatureKey";
14589 group = "LocalSignatureKey";
14593 group = "RemoteSignatureKey";
14597 warn("Unsupported CSRK type %u", type);
14601 ba2str(peer, device_addr);
14603 create_filename(filename, PATH_MAX, "/%s/%s/info",
14604 btd_adapter_get_storage_dir(adapter), device_addr);
14606 key_file = g_key_file_new();
14607 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14608 error("Unable to load key file from %s: (%s)", filename,
14610 g_clear_error(&gerr);
14613 for (i = 0; i < 16; i++)
14614 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14616 g_key_file_set_string(key_file, group, "Key", key_str);
14617 g_key_file_set_integer(key_file, group, "Counter", counter);
14618 g_key_file_set_boolean(key_file, group, "Authenticated", auth);
14620 create_file(filename, 0600);
14622 str = g_key_file_to_data(key_file, &length, NULL);
14623 if (!g_file_set_contents(filename, str, length, &gerr)) {
14624 error("Unable set contents for %s: (%s)", filename,
14626 g_error_free(gerr);
14630 g_key_file_free(key_file);
14633 static void new_csrk_callback(uint16_t index, uint16_t length,
14634 const void *param, void *user_data)
14636 const struct mgmt_ev_new_csrk *ev = param;
14637 const struct mgmt_addr_info *addr = &ev->key.addr;
14638 const struct mgmt_csrk_info *key = &ev->key;
14639 struct btd_adapter *adapter = user_data;
14640 struct btd_device *device;
14642 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14643 struct device_addr_type t_addr;
14646 if (length < sizeof(*ev)) {
14647 btd_error(adapter->dev_id, "Too small CSRK event");
14651 ba2str(&addr->bdaddr, dst);
14653 DBG("hci%u new CSRK for %s type %u", adapter->dev_id, dst,
14656 device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14658 btd_error(adapter->dev_id,
14659 "Unable to get device object for %s", dst);
14663 if (!ev->store_hint)
14666 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14667 device_get_tizen_addr(device, addr->type, &t_addr);
14668 store_csrk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, key->val, 0,
14671 store_csrk(adapter, &key->addr.bdaddr, key->addr.type, key->val, 0,
14675 btd_device_set_temporary(device, false);
14678 static void store_irk(struct btd_adapter *adapter, const bdaddr_t *peer,
14679 uint8_t bdaddr_type, const unsigned char *key)
14681 char device_addr[18];
14682 char filename[PATH_MAX];
14683 GKeyFile *key_file;
14684 GError *gerr = NULL;
14690 ba2str(peer, device_addr);
14692 create_filename(filename, PATH_MAX, "/%s/%s/info",
14693 btd_adapter_get_storage_dir(adapter), device_addr);
14694 key_file = g_key_file_new();
14695 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14696 error("Unable to load key file from %s: (%s)", filename,
14698 g_clear_error(&gerr);
14701 for (i = 0; i < 16; i++)
14702 sprintf(str + (i * 2), "%2.2X", key[i]);
14704 g_key_file_set_string(key_file, "IdentityResolvingKey", "Key", str);
14706 store_data = g_key_file_to_data(key_file, &length, NULL);
14707 if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14708 error("Unable set contents for %s: (%s)", filename,
14710 g_error_free(gerr);
14712 g_free(store_data);
14714 g_key_file_free(key_file);
14717 static void new_irk_callback(uint16_t index, uint16_t length,
14718 const void *param, void *user_data)
14720 const struct mgmt_ev_new_irk *ev = param;
14721 const struct mgmt_addr_info *addr = &ev->key.addr;
14722 const struct mgmt_irk_info *irk = &ev->key;
14723 struct btd_adapter *adapter = user_data;
14724 struct btd_device *device, *duplicate;
14726 char dst[18], rpa[18];
14727 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14728 struct device_addr_type t_addr;
14731 if (length < sizeof(*ev)) {
14732 btd_error(adapter->dev_id, "Too small New IRK event");
14736 ba2str(&addr->bdaddr, dst);
14737 ba2str(&ev->rpa, rpa);
14739 DBG("hci%u new IRK for %s RPA %s", adapter->dev_id, dst, rpa);
14741 if (bacmp(&ev->rpa, BDADDR_ANY)) {
14742 device = btd_adapter_get_device(adapter, &ev->rpa,
14744 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14745 device = btd_adapter_get_device(adapter, &ev->rpa,
14747 duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
14749 if (duplicate == device)
14752 device_set_rpa_addr(device, &ev->rpa);
14756 device = btd_adapter_get_device(adapter, &addr->bdaddr,
14762 btd_error(adapter->dev_id,
14763 "Unable to get device object for %s", dst);
14767 device_update_addr(device, &addr->bdaddr, addr->type);
14770 device_merge_duplicate(device, duplicate);
14772 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14773 device_set_irk_value(device, irk->val);
14776 persistent = !!ev->store_hint;
14780 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14781 device_get_tizen_addr(device, addr->type, &t_addr);
14782 store_irk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, irk->val);
14784 store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
14787 btd_device_set_temporary(device, false);
14790 static void store_conn_param(struct btd_adapter *adapter, const bdaddr_t *peer,
14791 uint8_t bdaddr_type, uint16_t min_interval,
14792 uint16_t max_interval, uint16_t latency,
14795 char device_addr[18];
14796 char filename[PATH_MAX];
14797 GKeyFile *key_file;
14798 GError *gerr = NULL;
14802 ba2str(peer, device_addr);
14806 create_filename(filename, PATH_MAX, "/%s/%s/info",
14807 btd_adapter_get_storage_dir(adapter), device_addr);
14808 key_file = g_key_file_new();
14809 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14810 error("Unable to load key file from %s: (%s)", filename,
14812 g_clear_error(&gerr);
14815 g_key_file_set_integer(key_file, "ConnectionParameters",
14816 "MinInterval", min_interval);
14817 g_key_file_set_integer(key_file, "ConnectionParameters",
14818 "MaxInterval", max_interval);
14819 g_key_file_set_integer(key_file, "ConnectionParameters",
14820 "Latency", latency);
14821 g_key_file_set_integer(key_file, "ConnectionParameters",
14822 "Timeout", timeout);
14824 create_file(filename, 0600);
14826 store_data = g_key_file_to_data(key_file, &length, NULL);
14827 if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14828 error("Unable set contents for %s: (%s)", filename,
14830 g_error_free(gerr);
14832 g_free(store_data);
14834 g_key_file_free(key_file);
14837 static void new_conn_param(uint16_t index, uint16_t length,
14838 const void *param, void *user_data)
14840 const struct mgmt_ev_new_conn_param *ev = param;
14841 struct btd_adapter *adapter = user_data;
14842 uint16_t min, max, latency, timeout;
14843 struct btd_device *dev;
14845 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14846 struct device_addr_type t_addr;
14849 if (length < sizeof(*ev)) {
14850 btd_error(adapter->dev_id,
14851 "Too small New Connection Parameter event");
14855 ba2str(&ev->addr.bdaddr, dst);
14857 min = btohs(ev->min_interval);
14858 max = btohs(ev->max_interval);
14859 latency = btohs(ev->latency);
14860 timeout = btohs(ev->timeout);
14862 DBG("hci%u %s (%u) min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
14863 adapter->dev_id, dst, ev->addr.type, min, max, latency, timeout);
14865 dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
14867 btd_error(adapter->dev_id,
14868 "Unable to get device object for %s", dst);
14872 if (!ev->store_hint)
14875 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14876 device_get_tizen_addr(dev, ev->addr.type, &t_addr);
14877 store_conn_param(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14878 ev->min_interval, ev->max_interval,
14879 ev->latency, ev->timeout);
14881 store_conn_param(adapter, &ev->addr.bdaddr, ev->addr.type,
14882 ev->min_interval, ev->max_interval,
14883 ev->latency, ev->timeout);
14887 int adapter_set_io_capability(struct btd_adapter *adapter, uint8_t io_cap)
14889 struct mgmt_cp_set_io_capability cp;
14891 if (!btd_opts.pairable) {
14892 if (io_cap == IO_CAPABILITY_INVALID) {
14893 if (adapter->current_settings & MGMT_SETTING_BONDABLE)
14894 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
14899 if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
14900 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
14901 } else if (io_cap == IO_CAPABILITY_INVALID)
14902 io_cap = IO_CAPABILITY_NOINPUTNOOUTPUT;
14904 memset(&cp, 0, sizeof(cp));
14905 cp.io_capability = io_cap;
14907 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IO_CAPABILITY,
14908 adapter->dev_id, sizeof(cp), &cp,
14909 NULL, NULL, NULL) > 0)
14915 int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
14916 const bdaddr_t *bdaddr,
14917 uint8_t *hash, uint8_t *randomizer)
14919 struct mgmt_cp_add_remote_oob_data cp;
14922 ba2str(bdaddr, addr);
14923 DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14925 memset(&cp, 0, sizeof(cp));
14926 bacpy(&cp.addr.bdaddr, bdaddr);
14927 memcpy(cp.hash192, hash, 16);
14930 memcpy(cp.rand192, randomizer, 16);
14932 if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14933 adapter->dev_id, sizeof(cp), &cp,
14934 NULL, NULL, NULL) > 0)
14940 int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
14941 const bdaddr_t *bdaddr)
14943 struct mgmt_cp_remove_remote_oob_data cp;
14946 ba2str(bdaddr, addr);
14947 DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14949 memset(&cp, 0, sizeof(cp));
14950 bacpy(&cp.addr.bdaddr, bdaddr);
14952 if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
14953 adapter->dev_id, sizeof(cp), &cp,
14954 NULL, NULL, NULL) > 0)
14960 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14961 int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
14962 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
14963 uint8_t *hash192, uint8_t *randomizer192,
14964 uint8_t *hash256, uint8_t *randomizer256)
14966 struct mgmt_cp_add_remote_oob_data cp;
14969 ba2str(bdaddr, addr);
14970 DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
14972 memset(&cp, 0, sizeof(cp));
14973 bacpy(&cp.addr.bdaddr, bdaddr);
14974 cp.addr.type = bdaddr_type;
14976 if (hash192 && randomizer192) {
14977 memcpy(cp.hash192, hash192, 16);
14978 memcpy(cp.rand192, randomizer192, 16);
14981 if (hash256 && randomizer256) {
14982 memcpy(cp.hash256, hash256, 16);
14983 memcpy(cp.rand256, randomizer256, 16);
14986 if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14987 adapter->dev_id, sizeof(cp), &cp,
14988 NULL, NULL, NULL) > 0)
14994 int btd_adapter_remove_remote_oob_ext_data(struct btd_adapter *adapter,
14995 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
14997 struct mgmt_cp_remove_remote_oob_data cp;
15000 ba2str(bdaddr, addr);
15001 DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
15003 memset(&cp, 0, sizeof(cp));
15004 bacpy(&cp.addr.bdaddr, bdaddr);
15005 cp.addr.type = bdaddr_type;
15007 if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
15008 adapter->dev_id, sizeof(cp), &cp,
15009 NULL, NULL, NULL) > 0)
15016 bool btd_adapter_ssp_enabled(struct btd_adapter *adapter)
15018 if (adapter->current_settings & MGMT_SETTING_SSP)
15024 void btd_adapter_set_oob_handler(struct btd_adapter *adapter,
15025 struct oob_handler *handler)
15027 adapter->oob_handler = handler;
15030 gboolean btd_adapter_check_oob_handler(struct btd_adapter *adapter)
15032 return adapter->oob_handler != NULL;
15035 static void read_local_oob_data_complete(uint8_t status, uint16_t length,
15036 const void *param, void *user_data)
15038 const struct mgmt_rp_read_local_oob_data *rp = param;
15039 struct btd_adapter *adapter = user_data;
15040 const uint8_t *hash, *randomizer;
15041 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15042 const uint8_t *hash256 = NULL;
15043 const uint8_t *randomizer256 = NULL;
15046 if (status != MGMT_STATUS_SUCCESS) {
15047 btd_error(adapter->dev_id,
15048 "Read local OOB data failed: %s (0x%02x)",
15049 mgmt_errstr(status), status);
15052 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15053 } else if (length < 32) {
15055 } else if (length < sizeof(*rp)) {
15057 btd_error(adapter->dev_id,
15058 "Too small read local OOB data response");
15061 hash = rp->hash192;
15062 randomizer = rp->rand192;
15063 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15065 hash256 = rp->hash256;
15066 randomizer256 = rp->rand256;
15071 if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
15074 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15075 adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
15076 hash256, randomizer256,
15077 adapter->oob_handler->user_data);
15079 adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
15080 adapter->oob_handler->user_data);
15083 g_free(adapter->oob_handler);
15084 adapter->oob_handler = NULL;
15087 int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
15089 DBG("hci%u", adapter->dev_id);
15091 if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_DATA,
15092 adapter->dev_id, 0, NULL, read_local_oob_data_complete,
15093 adapter, NULL) > 0)
15099 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15100 static void le_read_local_oob_data_complete(uint8_t status, uint16_t length,
15101 const void *param, void *user_data)
15103 const struct mgmt_rp_read_local_oob_ext_data *rp = param;
15104 struct btd_adapter *adapter = user_data;
15106 if (status != MGMT_STATUS_SUCCESS) {
15107 btd_error(adapter->dev_id, "LE Read local OOB data failed: %s (0x%02x)",
15108 mgmt_errstr(status), status);
15109 } else if (length < sizeof(struct mgmt_rp_read_local_oob_ext_data)) {
15110 btd_error(adapter->dev_id,
15111 "Too small read local OOB ext data response");
15115 if (!adapter->oob_handler || !adapter->oob_handler->le_read_local_cb) {
15116 btd_error(adapter->dev_id, "oob_handler is not valid : %p",
15117 adapter->oob_handler);
15121 adapter->oob_handler->le_read_local_cb(adapter, rp->eir_len, rp->eir,
15122 adapter->oob_handler->user_data);
15124 g_free(adapter->oob_handler);
15125 adapter->oob_handler = NULL;
15128 int btd_adapter_le_read_local_oob_data(struct btd_adapter *adapter)
15130 struct mgmt_cp_read_local_oob_ext_data cp;
15132 DBG("hci%u", adapter->dev_id);
15134 memset(&cp, 0, sizeof(cp));
15135 cp.type = (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
15137 if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
15138 adapter->dev_id, sizeof(cp), &cp, le_read_local_oob_data_complete,
15139 adapter, NULL) > 0)
15146 void btd_adapter_for_each_device(struct btd_adapter *adapter,
15147 void (*cb)(struct btd_device *device, void *data),
15150 g_slist_foreach(adapter->devices, (GFunc) cb, data);
15153 static int adapter_cmp(gconstpointer a, gconstpointer b)
15155 struct btd_adapter *adapter = (struct btd_adapter *) a;
15156 const bdaddr_t *bdaddr = b;
15158 return bacmp(&adapter->bdaddr, bdaddr);
15161 static int adapter_id_cmp(gconstpointer a, gconstpointer b)
15163 struct btd_adapter *adapter = (struct btd_adapter *) a;
15164 uint16_t id = GPOINTER_TO_UINT(b);
15166 return adapter->dev_id == id ? 0 : -1;
15169 struct btd_adapter *adapter_find(const bdaddr_t *sba)
15173 match = g_slist_find_custom(adapters, sba, adapter_cmp);
15177 return match->data;
15180 struct btd_adapter *adapter_find_by_id(int id)
15184 match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
15189 return match->data;
15192 void adapter_foreach(adapter_cb func, gpointer user_data)
15194 g_slist_foreach(adapters, (GFunc) func, user_data);
15197 static int set_did(struct btd_adapter *adapter, uint16_t vendor,
15198 uint16_t product, uint16_t version, uint16_t source)
15200 struct mgmt_cp_set_device_id cp;
15202 DBG("hci%u source %x vendor %x product %x version %x",
15203 adapter->dev_id, source, vendor, product, version);
15205 memset(&cp, 0, sizeof(cp));
15207 cp.source = htobs(source);
15208 cp.vendor = htobs(vendor);
15209 cp.product = htobs(product);
15210 cp.version = htobs(version);
15212 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_ID,
15213 adapter->dev_id, sizeof(cp), &cp,
15214 NULL, NULL, NULL) > 0)
15220 static void services_modified(struct gatt_db_attribute *attrib, void *user_data)
15222 struct btd_adapter *adapter = user_data;
15224 g_dbus_emit_property_changed(dbus_conn, adapter->path,
15225 ADAPTER_INTERFACE, "UUIDs");
15228 static int adapter_register(struct btd_adapter *adapter)
15230 struct agent *agent;
15231 struct gatt_db *db;
15232 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15233 char address[18] = { 0 };
15234 char filename[PATH_MAX] = { 0 };
15240 adapter->path = g_strdup_printf("/org/bluez/hci%d", adapter->dev_id);
15242 if (!g_dbus_register_interface(dbus_conn,
15243 adapter->path, ADAPTER_INTERFACE,
15244 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15245 adapter_methods, adapter_signals,
15247 adapter_methods, NULL,
15249 adapter_properties, adapter,
15251 btd_error(adapter->dev_id,
15252 "Adapter interface init failed on path %s",
15254 g_free(adapter->path);
15255 adapter->path = NULL;
15259 if (adapters == NULL)
15260 adapter->is_default = true;
15262 adapters = g_slist_append(adapters, adapter);
15264 agent = agent_get(NULL);
15266 uint8_t io_cap = agent_get_io_capability(agent);
15267 adapter_set_io_capability(adapter, io_cap);
15268 agent_unref(agent);
15271 if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15272 adapter->battery_provider_manager =
15273 btd_battery_provider_manager_create(adapter);
15276 /* Don't start GATT database and advertising managers on
15277 * non-LE controllers.
15279 if (!(adapter->supported_settings & MGMT_SETTING_LE) ||
15280 btd_opts.mode == BT_MODE_BREDR)
15283 adapter->database = btd_gatt_database_new(adapter);
15284 if (!adapter->database) {
15285 btd_error(adapter->dev_id,
15286 "Failed to create GATT database for adapter");
15287 adapters = g_slist_remove(adapters, adapter);
15291 adapter->adv_manager = btd_adv_manager_new(adapter, adapter->mgmt);
15293 if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15294 if (adapter->supported_settings & MGMT_SETTING_LE) {
15295 adapter->adv_monitor_manager =
15296 btd_adv_monitor_manager_create(adapter,
15298 if (!adapter->adv_monitor_manager) {
15299 btd_error(adapter->dev_id,
15300 "Failed to create Adv Monitor "
15301 "Manager for adapter");
15305 btd_info(adapter->dev_id, "Adv Monitor Manager "
15306 "skipped, LE unavailable");
15310 db = btd_gatt_database_get_db(adapter->database);
15311 adapter->db_id = gatt_db_register(db, services_modified,
15315 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15316 ba2str(&adapter->bdaddr, address);
15317 snprintf(filename, PATH_MAX, STORAGEDIR "/%s", address);
15318 delete_tempfiles(filename);
15321 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15322 adapter_print_devices(adapter);
15324 if (load_local_irk(adapter)) {
15325 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
15326 btd_opts.le_privacy = false;
15329 * Some Android devices don't consider the device as LE one,
15330 * if the device doesn't distribute IRK when pairing.
15331 * Because of this compatibility issue, set IRK
15332 * even though privacy feature is disabled.
15334 set_local_irk(adapter);
15336 if (btd_opts.le_privacy) {
15337 DBG("Enable LE Privacy feature");
15338 set_privacy(adapter, true);
15340 DBG("Disable LE Privacy feature");
15346 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FLAGS_CHANGED,
15348 device_flags_changed_callback,
15351 load_config(adapter);
15352 fix_storage(adapter);
15353 load_drivers(adapter);
15354 btd_profile_foreach(probe_profile, adapter);
15355 clear_blocked(adapter);
15356 load_defaults(adapter);
15357 load_devices(adapter);
15359 /* restore Service Changed CCC value for bonded devices */
15360 btd_gatt_database_restore_svc_chng_ccc(adapter->database);
15362 /* retrieve the active connections: address the scenario where
15363 * the are active connections before the daemon've started */
15364 if (btd_adapter_get_powered(adapter))
15365 load_connections(adapter);
15367 adapter->initialized = TRUE;
15369 if (btd_opts.did_source) {
15370 /* DeviceID record is added by sdpd-server before any other
15371 * record is registered. */
15372 adapter_service_insert(adapter, sdp_record_find(0x10000));
15373 set_did(adapter, btd_opts.did_vendor, btd_opts.did_product,
15374 btd_opts.did_version, btd_opts.did_source);
15377 DBG("Adapter %s registered", adapter->path);
15382 static int adapter_unregister(struct btd_adapter *adapter)
15384 DBG("Unregister path: %s", adapter->path);
15386 adapters = g_slist_remove(adapters, adapter);
15388 if (adapter->is_default && adapters != NULL) {
15389 struct btd_adapter *new_default;
15391 new_default = adapter_find_by_id(hci_get_route(NULL));
15392 if (new_default == NULL)
15393 new_default = adapters->data;
15395 new_default->is_default = true;
15398 adapter_list = g_list_remove(adapter_list, adapter);
15400 adapter_remove(adapter);
15401 btd_adapter_unref(adapter);
15406 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15407 /* ---- HCI Error Codes ---- */
15408 #define HCI_ERROR_AUTH_FAILURE 0x05
15409 #define HCI_ERROR_PIN_OR_KEY_MISSING 0x06
15410 #define HCI_ERROR_MEMORY_EXCEEDED 0x07
15411 #define HCI_ERROR_CONNECTION_TIMEOUT 0x08
15412 #define HCI_ERROR_REJ_LIMITED_RESOURCES 0x0d
15413 #define HCI_ERROR_REJ_BAD_ADDR 0x0f
15414 #define HCI_ERROR_REMOTE_USER_TERM 0x13
15415 #define HCI_ERROR_REMOTE_LOW_RESOURCES 0x14
15416 #define HCI_ERROR_REMOTE_POWER_OFF 0x15
15417 #define HCI_ERROR_LOCAL_HOST_TERM 0x16
15418 #define HCI_ERROR_PAIRING_NOT_ALLOWED 0x18
15419 #define HCI_ERROR_INVALID_LL_PARAMS 0x1e
15420 #define HCI_ERROR_UNSPECIFIED 0x1f
15421 #define HCI_ERROR_ADVERTISING_TIMEOUT 0x3c
15423 static uint8_t mgmt_to_hci_reason(uint8_t err)
15426 case MGMT_DEV_DISCONN_TIMEOUT:
15427 return HCI_ERROR_CONNECTION_TIMEOUT;
15428 case MGMT_DEV_DISCONN_REMOTE:
15429 return HCI_ERROR_REMOTE_USER_TERM;
15430 case MGMT_DEV_DISCONN_LOCAL_HOST:
15431 return HCI_ERROR_LOCAL_HOST_TERM;
15433 error("No match MGMT error");
15439 static void disconnected_callback(uint16_t index, uint16_t length,
15440 const void *param, void *user_data)
15442 const struct mgmt_ev_device_disconnected *ev = param;
15443 struct btd_adapter *adapter = user_data;
15446 if (length < sizeof(struct mgmt_addr_info)) {
15447 btd_error(adapter->dev_id,
15448 "Too small device disconnected event");
15452 if (length < sizeof(*ev))
15453 reason = MGMT_DEV_DISCONN_UNKNOWN;
15455 reason = ev->reason;
15457 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15458 /* Use HCI error code instead of MGMT disconnection reason */
15459 dev_disconnected(adapter, &ev->addr, mgmt_to_hci_reason(reason));
15461 dev_disconnected(adapter, &ev->addr, reason);
15465 static void connected_callback(uint16_t index, uint16_t length,
15466 const void *param, void *user_data)
15468 const struct mgmt_ev_device_connected *ev = param;
15469 struct btd_adapter *adapter = user_data;
15470 struct btd_device *device;
15471 struct eir_data eir_data;
15476 if (length < sizeof(*ev)) {
15477 btd_error(adapter->dev_id, "Too small device connected event");
15481 eir_len = btohs(ev->eir_len);
15482 if (length < sizeof(*ev) + eir_len) {
15483 btd_error(adapter->dev_id, "Too small device connected event");
15487 ba2str(&ev->addr.bdaddr, addr);
15489 DBG("hci%u device %s connected eir_len %u", index, addr, eir_len);
15491 device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
15494 btd_error(adapter->dev_id,
15495 "Unable to get device object for %s", addr);
15499 memset(&eir_data, 0, sizeof(eir_data));
15501 eir_parse(&eir_data, ev->eir, eir_len);
15503 if (eir_data.class != 0)
15504 device_set_class(device, eir_data.class);
15506 adapter_add_connection(adapter, device, ev->addr.type);
15508 name_known = device_name_known(device);
15510 if (eir_data.name && (eir_data.name_complete || !name_known)) {
15511 device_store_cached_name(device, eir_data.name);
15512 btd_device_device_set_name(device, eir_data.name);
15515 if (eir_data.msd_list)
15516 adapter_msd_notify(adapter, device, eir_data.msd_list);
15518 eir_data_free(&eir_data);
15521 static void controller_resume_notify(struct btd_adapter *adapter)
15525 for (l = adapter->drivers; l; l = g_slist_next(l)) {
15526 struct btd_adapter_driver *driver = l->data;
15527 if (driver->resume)
15528 driver->resume(adapter);
15532 static void controller_resume_callback(uint16_t index, uint16_t length,
15533 const void *param, void *user_data)
15535 const struct mgmt_ev_controller_resume *ev = param;
15536 struct btd_adapter *adapter = user_data;
15538 if (length < sizeof(*ev)) {
15539 btd_error(adapter->dev_id, "Too small device resume event");
15543 info("Controller resume with wake event 0x%x", ev->wake_reason);
15545 controller_resume_notify(adapter);
15548 static void device_blocked_callback(uint16_t index, uint16_t length,
15549 const void *param, void *user_data)
15551 const struct mgmt_ev_device_blocked *ev = param;
15552 struct btd_adapter *adapter = user_data;
15553 struct btd_device *device;
15556 if (length < sizeof(*ev)) {
15557 btd_error(adapter->dev_id, "Too small device blocked event");
15561 ba2str(&ev->addr.bdaddr, addr);
15562 DBG("hci%u %s blocked", index, addr);
15564 device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15567 device_block(device, TRUE);
15570 static void device_unblocked_callback(uint16_t index, uint16_t length,
15571 const void *param, void *user_data)
15573 const struct mgmt_ev_device_unblocked *ev = param;
15574 struct btd_adapter *adapter = user_data;
15575 struct btd_device *device;
15578 if (length < sizeof(*ev)) {
15579 btd_error(adapter->dev_id, "Too small device unblocked event");
15583 ba2str(&ev->addr.bdaddr, addr);
15584 DBG("hci%u %s unblocked", index, addr);
15586 device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15589 device_unblock(device, FALSE, TRUE);
15592 static void conn_fail_notify(struct btd_device *dev, uint8_t status)
15596 for (l = conn_fail_list; l; l = g_slist_next(l)) {
15597 btd_conn_fail_cb conn_fail_cb = l->data;
15598 conn_fail_cb(dev, status);
15602 void btd_add_conn_fail_cb(btd_conn_fail_cb func)
15604 conn_fail_list = g_slist_append(conn_fail_list, func);
15607 void btd_remove_conn_fail_cb(btd_conn_fail_cb func)
15609 conn_fail_list = g_slist_remove(conn_fail_list, func);
15612 static void connect_failed_callback(uint16_t index, uint16_t length,
15613 const void *param, void *user_data)
15615 const struct mgmt_ev_connect_failed *ev = param;
15616 struct btd_adapter *adapter = user_data;
15617 struct btd_device *device;
15620 if (length < sizeof(*ev)) {
15621 btd_error(adapter->dev_id, "Too small connect failed event");
15625 ba2str(&ev->addr.bdaddr, addr);
15627 DBG("hci%u %s status %u", index, addr, ev->status);
15629 device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15632 conn_fail_notify(device, ev->status);
15634 /* If the device is in a bonding process cancel any auth request
15635 * sent to the agent before proceeding, but keep the bonding
15636 * request structure. */
15637 if (device_is_bonding(device, NULL))
15638 device_cancel_authentication(device, FALSE);
15641 /* In the case of security mode 3 devices */
15642 bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
15645 /* If the device is scheduled to retry the bonding wait until the retry
15646 * happens. In other case, proceed with cancel the bondig.
15648 if (device && device_is_bonding(device, NULL)
15649 && !device_is_retrying(device)) {
15650 device_cancel_authentication(device, TRUE);
15651 device_bonding_failed(device, ev->status);
15654 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
15655 /* In the case the bonding was canceled or did exists, remove the device
15656 * when it is temporary. */
15657 if (device && !device_is_bonding(device, NULL)
15658 && device_is_temporary(device))
15659 btd_adapter_remove_device(adapter, device);
15663 static void remove_keys(struct btd_adapter *adapter,
15664 struct btd_device *device, uint8_t type)
15666 char device_addr[18];
15667 char filename[PATH_MAX];
15668 GKeyFile *key_file;
15669 GError *gerr = NULL;
15673 ba2str(device_get_address(device), device_addr);
15675 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15676 if (device_get_rpa_exist(device) == true)
15677 ba2str(device_get_rpa(device), device_addr);
15680 create_filename(filename, PATH_MAX, "/%s/%s/info",
15681 btd_adapter_get_storage_dir(adapter), device_addr);
15683 key_file = g_key_file_new();
15684 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
15685 error("Unable to load key file from %s: (%s)", filename,
15687 g_clear_error(&gerr);
15690 if (type == BDADDR_BREDR) {
15691 g_key_file_remove_group(key_file, "LinkKey", NULL);
15693 g_key_file_remove_group(key_file, "LongTermKey", NULL);
15694 g_key_file_remove_group(key_file, "LocalSignatureKey", NULL);
15695 g_key_file_remove_group(key_file, "RemoteSignatureKey", NULL);
15696 g_key_file_remove_group(key_file, "IdentityResolvingKey", NULL);
15699 str = g_key_file_to_data(key_file, &length, NULL);
15700 if (!g_file_set_contents(filename, str, length, &gerr)) {
15701 error("Unable set contents for %s: (%s)", filename,
15703 g_error_free(gerr);
15707 g_key_file_free(key_file);
15710 static void unpaired_callback(uint16_t index, uint16_t length,
15711 const void *param, void *user_data)
15713 const struct mgmt_ev_device_unpaired *ev = param;
15714 struct btd_adapter *adapter = user_data;
15715 struct btd_device *device;
15718 if (length < sizeof(*ev)) {
15719 btd_error(adapter->dev_id, "Too small device unpaired event");
15723 ba2str(&ev->addr.bdaddr, addr);
15725 DBG("hci%u addr %s", index, addr);
15727 device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15730 btd_warn(adapter->dev_id,
15731 "No device object for unpaired device %s", addr);
15735 remove_keys(adapter, device, ev->addr.type);
15736 device_set_unpaired(device, ev->addr.type);
15739 static void clear_devices_complete(uint8_t status, uint16_t length,
15740 const void *param, void *user_data)
15742 if (status != MGMT_STATUS_SUCCESS) {
15743 error("Failed to clear devices: %s (0x%02x)",
15744 mgmt_errstr(status), status);
15749 static int clear_devices(struct btd_adapter *adapter)
15751 struct mgmt_cp_remove_device cp;
15753 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
15756 memset(&cp, 0, sizeof(cp));
15758 DBG("sending clear devices command for index %u", adapter->dev_id);
15760 if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
15761 adapter->dev_id, sizeof(cp), &cp,
15762 clear_devices_complete, adapter, NULL) > 0)
15765 btd_error(adapter->dev_id, "Failed to clear devices for index %u",
15771 static bool get_static_addr(struct btd_adapter *adapter)
15773 struct bt_crypto *crypto;
15775 GError *gerr = NULL;
15776 char filename[PATH_MAX];
15783 snprintf(mfg, sizeof(mfg), "0x%04x", adapter->manufacturer);
15785 create_filename(filename, PATH_MAX, "/addresses");
15787 file = g_key_file_new();
15788 if (!g_key_file_load_from_file(file, filename, 0, &gerr)) {
15789 error("Unable to load key file from %s: (%s)",
15790 filename, gerr->message);
15791 g_clear_error(&gerr);
15793 addrs = g_key_file_get_string_list(file, "Static", mfg, &len, NULL);
15795 for (i = 0; i < len; i++) {
15798 str2ba(addrs[i], &addr);
15799 if (adapter_find(&addr))
15802 /* Usable address found in list */
15803 bacpy(&adapter->bdaddr, &addr);
15804 adapter->bdaddr_type = BDADDR_LE_RANDOM;
15810 addrs = g_renew(char *, addrs, len + 1);
15813 addrs = g_new(char *, len + 1);
15816 /* Initialize slot for new address */
15817 addrs[len - 1] = g_malloc(18);
15820 crypto = bt_crypto_new();
15822 error("Failed to open crypto");
15827 ret = bt_crypto_random_bytes(crypto, &adapter->bdaddr,
15828 sizeof(adapter->bdaddr));
15830 error("Failed to generate static address");
15831 bt_crypto_unref(crypto);
15835 bt_crypto_unref(crypto);
15837 adapter->bdaddr.b[5] |= 0xc0;
15838 adapter->bdaddr_type = BDADDR_LE_RANDOM;
15840 ba2str(&adapter->bdaddr, addrs[len - 1]);
15842 g_key_file_set_string_list(file, "Static", mfg,
15843 (const char **)addrs, len);
15845 str = g_key_file_to_data(file, &len, NULL);
15846 if (!g_file_set_contents(filename, str, len, &gerr)) {
15847 error("Unable set contents for %s: (%s)",
15848 filename, gerr->message);
15849 g_error_free(gerr);
15856 g_key_file_free(file);
15862 static bool set_static_addr(struct btd_adapter *adapter)
15864 struct mgmt_cp_set_static_address cp;
15866 /* dual-mode adapters must have a public address */
15867 if (adapter->supported_settings & MGMT_SETTING_BREDR)
15870 if (!(adapter->supported_settings & MGMT_SETTING_LE))
15873 DBG("Setting static address");
15875 if (!get_static_addr(adapter))
15878 bacpy(&cp.bdaddr, &adapter->bdaddr);
15879 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STATIC_ADDRESS,
15880 adapter->dev_id, sizeof(cp), &cp,
15881 NULL, NULL, NULL) > 0) {
15888 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15889 static uint8_t *generate_irk(void)
15894 DBG("Generate IRK");
15896 fd = open("/dev/urandom", O_RDONLY);
15900 irk = g_malloc0(MGMT_IRK_SIZE);
15901 if (read(fd, irk, MGMT_IRK_SIZE) != MGMT_IRK_SIZE) {
15902 error("Cannot read random bytes");
15912 #define LOCAL_IRK_DIRNAME "/csa/bluetooth"
15913 #define LOCAL_IRK_FILENAME ".local_irk"
15915 static bool store_local_irk(struct btd_adapter *adapter)
15920 if (adapter->local_irk == NULL) {
15921 error("Local IRK is not proper");
15925 if (access(LOCAL_IRK_DIRNAME, F_OK) < 0) {
15926 if (mkdir(LOCAL_IRK_DIRNAME, 0755) < 0) {
15927 error("Cannot create a directory for local IRK : %s",
15933 fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME,
15934 O_WRONLY | O_CREAT | O_TRUNC, 0644);
15936 error("Cannot open a file for local IRK : %s", strerror(errno));
15940 ret = write(fd, adapter->local_irk, MGMT_IRK_SIZE);
15941 if (ret != MGMT_IRK_SIZE) {
15942 error("Cannot write local IRK [%d] : %s", ret, strerror(errno));
15945 unlink(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME);
15949 ret = fdatasync(fd);
15951 error("sync failed : %s", strerror(errno));
15957 static bool load_local_irk(struct btd_adapter *adapter)
15962 if (access(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, F_OK) < 0) {
15963 adapter->local_irk = generate_irk();
15964 if (store_local_irk(adapter) == false) {
15965 error("Cannot store Local IRK");
15966 g_free(adapter->local_irk);
15973 if (adapter->local_irk) {
15974 DBG("Local IRK is already loaded");
15978 fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, O_RDONLY);
15980 error("Cannot open local IRK file : %s", strerror(errno));
15984 adapter->local_irk = g_malloc0(MGMT_IRK_SIZE);
15986 ret = read(fd, adapter->local_irk, MGMT_IRK_SIZE);
15987 if (ret != MGMT_IRK_SIZE) {
15988 error("Cannot read local IRK [%d] : %s", ret, strerror(errno));
15989 g_free(adapter->local_irk);
15998 static void set_privacy_complete(uint8_t status, uint16_t length,
15999 const void *param, void *user_data)
16001 struct btd_adapter *adapter = user_data;
16003 if (status != MGMT_STATUS_SUCCESS)
16004 error("Setting privacy failed for hci%u: %s (0x%02x)",
16005 adapter->dev_id, mgmt_errstr(status), status);
16007 DBG("Privacy feature is set/unset successfully for hci%u",
16011 static bool set_privacy(struct btd_adapter *adapter, bool privacy)
16013 struct mgmt_cp_set_privacy cp;
16015 if (!adapter->local_irk) {
16016 error("Local IRK is not available");
16020 memset(&cp, 0, sizeof(cp));
16021 memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
16026 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
16027 adapter->dev_id, sizeof(cp), &cp,
16028 set_privacy_complete, adapter, NULL) > 0)
16031 error("Failed to set privacy and load local irk for index %u",
16036 static void set_irk_complete(uint8_t status, uint16_t length,
16037 const void *param, void *user_data)
16039 struct btd_adapter *adapter = user_data;
16041 if (status != MGMT_STATUS_SUCCESS)
16042 error("Setting IRK is failed for hci%u: %s (0x%02x)",
16043 adapter->dev_id, mgmt_errstr(status), status);
16045 DBG("Setting IRK is succeed for hci%u", adapter->dev_id);
16048 static bool set_local_irk(struct btd_adapter *adapter)
16050 struct mgmt_cp_set_irk cp;
16052 if (!adapter->local_irk) {
16053 error("Local IRK is not available");
16057 memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
16059 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IRK,
16060 adapter->dev_id, sizeof(cp), &cp,
16061 set_irk_complete, adapter, NULL) > 0)
16064 error("Failed to set irk %u", adapter->dev_id);
16068 int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
16069 const bdaddr_t *bdaddr,
16070 uint8_t bdaddr_type)
16073 struct mgmt_cp_connect_6lowpan cp;
16075 memset(&cp, 0, sizeof(cp));
16076 bacpy(&cp.addr.bdaddr, bdaddr);
16077 cp.addr.type = bdaddr_type;
16079 if (mgmt_send(adapter->mgmt, MGMT_OP_CONNECT_6LOWPAN,
16080 adapter->dev_id, sizeof(cp), &cp,
16081 NULL, NULL, NULL) > 0)
16087 int btd_adapter_disconnect_ipsp(struct btd_adapter *adapter,
16088 const bdaddr_t *bdaddr,
16089 uint8_t bdaddr_type)
16092 struct mgmt_cp_disconnect_6lowpan cp;
16094 memset(&cp, 0, sizeof(cp));
16095 bacpy(&cp.addr.bdaddr, bdaddr);
16096 cp.addr.type = bdaddr_type;
16098 if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT_6LOWPAN,
16099 adapter->dev_id, sizeof(cp), &cp,
16100 NULL, NULL, NULL) > 0)
16106 uint8_t btd_adapter_get_rpa_res_support_value(
16107 struct btd_adapter *adapter)
16109 return adapter->central_rpa_res_support;
16112 static void set_dev_rpa_res_support_complete(uint8_t status,
16113 uint16_t length, const void *param,
16116 if (status != MGMT_STATUS_SUCCESS)
16117 error("Failed to set RPA resolution support of device : %s (0x%02x)",
16118 mgmt_errstr(status), status);
16120 DBG("Set RPA resolution support successful");
16123 int btd_adapter_set_dev_rpa_res_support(struct btd_adapter *adapter,
16124 struct btd_device *device)
16127 struct mgmt_cp_set_dev_rpa_res_support cp;
16129 DBG("btd_adapter_set_dev_rpa_res_support called");
16131 memset(&cp, 0, sizeof(cp));
16133 bacpy(&cp.addr.bdaddr, device_get_address(device));
16134 cp.addr.type = btd_device_get_bdaddr_type(device);
16135 cp.res_support = device_get_rpa_res_char_value(device);
16137 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_RPA_RES_SUPPORT,
16138 adapter->dev_id, sizeof(cp), &cp,
16139 set_dev_rpa_res_support_complete, NULL, NULL) > 0)
16146 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16147 static gboolean adapter_start_idle_cb(gpointer user_data)
16149 struct btd_adapter *adapter = (struct btd_adapter*)user_data;
16151 adapter_start(adapter);
16157 static void set_blocked_keys_complete(uint8_t status, uint16_t length,
16158 const void *param, void *user_data)
16160 struct btd_adapter *adapter = user_data;
16162 if (status != MGMT_STATUS_SUCCESS) {
16163 btd_error(adapter->dev_id,
16164 "Failed to set blocked keys: %s (0x%02x)",
16165 mgmt_errstr(status), status);
16169 DBG("Successfully set blocked keys for index %u", adapter->dev_id);
16172 static bool set_blocked_keys(struct btd_adapter *adapter)
16174 uint8_t buffer[sizeof(struct mgmt_cp_set_blocked_keys) +
16175 sizeof(blocked_keys)] = { 0 };
16176 struct mgmt_cp_set_blocked_keys *cp =
16177 (struct mgmt_cp_set_blocked_keys *)buffer;
16180 cp->key_count = ARRAY_SIZE(blocked_keys);
16181 for (i = 0; i < cp->key_count; ++i) {
16182 cp->keys[i].type = blocked_keys[i].type;
16183 memcpy(cp->keys[i].val, blocked_keys[i].val,
16184 sizeof(cp->keys[i].val));
16187 return mgmt_send(mgmt_primary, MGMT_OP_SET_BLOCKED_KEYS,
16189 sizeof(buffer), buffer,
16190 set_blocked_keys_complete,
16194 #define EXP_FEAT(_flag, _uuid, _func) \
16201 static void set_exp_debug_complete(uint8_t status, uint16_t len,
16202 const void *param, void *user_data)
16204 struct btd_adapter *adapter = user_data;
16208 error("Set Experimental Debug failed with status 0x%02x (%s)",
16209 status, mgmt_errstr(status));
16213 action = btd_kernel_experimental_enabled(debug_uuid.str);
16215 DBG("Experimental Debug successfully %s", action ? "set" : "reset");
16218 queue_push_tail(adapter->exps, (void *)debug_uuid.val);
16221 static void exp_debug_func(struct btd_adapter *adapter, uint8_t action)
16223 struct mgmt_cp_set_exp_feature cp;
16225 memset(&cp, 0, sizeof(cp));
16226 memcpy(cp.uuid, debug_uuid.val, 16);
16227 cp.action = action;
16229 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16230 adapter->dev_id, sizeof(cp), &cp,
16231 set_exp_debug_complete, adapter, NULL) > 0)
16234 btd_error(adapter->dev_id, "Failed to set exp debug");
16237 static void le_simult_central_peripheral_func(struct btd_adapter *adapter,
16241 queue_push_tail(adapter->exps,
16242 (void *)le_simult_central_peripheral_uuid.val);
16245 static void quality_report_func(struct btd_adapter *adapter, uint8_t action)
16248 queue_push_tail(adapter->exps, (void *)quality_report_uuid.val);
16251 static void set_rpa_resolution_complete(uint8_t status, uint16_t len,
16252 const void *param, void *user_data)
16254 struct btd_adapter *adapter = user_data;
16258 error("Set RPA Resolution failed with status 0x%02x (%s)",
16259 status, mgmt_errstr(status));
16263 action = btd_kernel_experimental_enabled(rpa_resolution_uuid.str);
16265 DBG("RPA Resolution successfully %s", action ? "set" : "reset");
16268 queue_push_tail(adapter->exps, (void *)rpa_resolution_uuid.val);
16271 static void rpa_resolution_func(struct btd_adapter *adapter, uint8_t action)
16273 struct mgmt_cp_set_exp_feature cp;
16275 memset(&cp, 0, sizeof(cp));
16276 memcpy(cp.uuid, rpa_resolution_uuid.val, 16);
16277 cp.action = action;
16279 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16280 adapter->dev_id, sizeof(cp), &cp,
16281 set_rpa_resolution_complete, adapter, NULL) > 0)
16284 btd_error(adapter->dev_id, "Failed to set RPA Resolution");
16287 static void codec_offload_complete(uint8_t status, uint16_t len,
16288 const void *param, void *user_data)
16290 struct btd_adapter *adapter = user_data;
16294 error("Set Codec Offload failed with status 0x%02x (%s)",
16295 status, mgmt_errstr(status));
16299 action = btd_kernel_experimental_enabled(codec_offload_uuid.str);
16301 DBG("Codec Offload successfully %s", action ? "set" : "reset");
16304 queue_push_tail(adapter->exps, (void *)codec_offload_uuid.val);
16307 static void codec_offload_func(struct btd_adapter *adapter, uint8_t action)
16309 struct mgmt_cp_set_exp_feature cp;
16311 memset(&cp, 0, sizeof(cp));
16312 memcpy(cp.uuid, codec_offload_uuid.val, 16);
16313 cp.action = action;
16315 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16316 adapter->dev_id, sizeof(cp), &cp,
16317 codec_offload_complete, adapter, NULL) > 0)
16320 btd_error(adapter->dev_id, "Failed to set Codec Offload");
16323 static void iso_socket_complete(uint8_t status, uint16_t len,
16324 const void *param, void *user_data)
16326 struct btd_adapter *adapter = user_data;
16330 error("Set ISO Socket failed with status 0x%02x (%s)",
16331 status, mgmt_errstr(status));
16335 action = btd_kernel_experimental_enabled(iso_socket_uuid.str);
16337 DBG("ISO Socket successfully %s", action ? "set" : "reset");
16340 queue_push_tail(adapter->exps, (void *)iso_socket_uuid.val);
16343 static void iso_socket_func(struct btd_adapter *adapter, uint8_t action)
16345 struct mgmt_cp_set_exp_feature cp;
16347 memset(&cp, 0, sizeof(cp));
16348 memcpy(cp.uuid, iso_socket_uuid.val, 16);
16349 cp.action = action;
16351 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16352 MGMT_INDEX_NONE, sizeof(cp), &cp,
16353 iso_socket_complete, adapter, NULL) > 0)
16356 btd_error(adapter->dev_id, "Failed to set ISO Socket");
16359 static const struct exp_feat {
16361 const struct mgmt_exp_uuid *uuid;
16362 void (*func)(struct btd_adapter *adapter, uint8_t action);
16364 EXP_FEAT(EXP_FEAT_DEBUG, &debug_uuid, exp_debug_func),
16365 EXP_FEAT(EXP_FEAT_LE_SIMULT_ROLES, &le_simult_central_peripheral_uuid,
16366 le_simult_central_peripheral_func),
16367 EXP_FEAT(EXP_FEAT_BQR, &quality_report_uuid, quality_report_func),
16368 EXP_FEAT(EXP_FEAT_RPA_RESOLUTION, &rpa_resolution_uuid,
16369 rpa_resolution_func),
16370 EXP_FEAT(EXP_FEAT_CODEC_OFFLOAD, &codec_offload_uuid,
16371 codec_offload_func),
16372 EXP_FEAT(EXP_FEAT_ISO_SOCKET, &iso_socket_uuid, iso_socket_func),
16375 static void read_exp_features_complete(uint8_t status, uint16_t length,
16376 const void *param, void *user_data)
16378 struct btd_adapter *adapter = user_data;
16379 const struct mgmt_rp_read_exp_features_info *rp = param;
16380 size_t feature_count = 0;
16383 DBG("index %u status 0x%02x", adapter->dev_id, status);
16385 if (status != MGMT_STATUS_SUCCESS) {
16386 btd_error(adapter->dev_id,
16387 "Failed to read exp features info: %s (0x%02x)",
16388 mgmt_errstr(status), status);
16392 if (length < sizeof(*rp)) {
16393 btd_error(adapter->dev_id, "Response too small");
16397 feature_count = le16_to_cpu(rp->feature_count);
16399 if (length < sizeof(*rp) + (sizeof(*rp->features) * feature_count)) {
16400 btd_error(adapter->dev_id, "Response too small");
16404 for (i = 0; i < feature_count; ++i) {
16406 for (j = 0; j < ARRAY_SIZE(exp_table); j++) {
16407 const struct exp_feat *feat = &exp_table[j];
16411 if (memcmp(rp->features[i].uuid, feat->uuid->val,
16412 sizeof(rp->features[i].uuid)))
16415 str = feat->uuid->str;
16416 action = btd_kernel_experimental_enabled(str);
16418 DBG("%s flags %u action %u", str,
16419 rp->features[i].flags, action);
16421 /* If already set don't attempt to set it again */
16422 if (action == (rp->features[i].flags & BIT(0))) {
16423 if (action & BIT(0))
16424 queue_push_tail(adapter->exps,
16425 (void *)feat->uuid->val);
16430 feat->func(adapter, action);
16435 static void read_exp_features(struct btd_adapter *adapter)
16437 if (mgmt_send(adapter->mgmt, MGMT_OP_READ_EXP_FEATURES_INFO,
16438 adapter->dev_id, 0, NULL, read_exp_features_complete,
16439 adapter, NULL) > 0)
16442 btd_error(adapter->dev_id, "Failed to read exp features info");
16445 static void read_info_complete(uint8_t status, uint16_t length,
16446 const void *param, void *user_data)
16448 struct btd_adapter *adapter = user_data;
16449 const struct mgmt_rp_read_info *rp = param;
16450 uint32_t missing_settings;
16453 DBG("index %u status 0x%02x", adapter->dev_id, status);
16455 if (status != MGMT_STATUS_SUCCESS) {
16456 btd_error(adapter->dev_id,
16457 "Failed to read info for index %u: %s (0x%02x)",
16458 adapter->dev_id, mgmt_errstr(status), status);
16462 if (length < sizeof(*rp)) {
16463 btd_error(adapter->dev_id,
16464 "Too small read info complete response");
16469 * Store controller information for class of device, device
16470 * name, short name and settings.
16472 * During the lifetime of the controller these will be updated by
16473 * events and the information is required to keep the current
16474 * state of the controller.
16476 adapter->dev_class = rp->dev_class[0] | (rp->dev_class[1] << 8) |
16477 (rp->dev_class[2] << 16);
16478 adapter->name = g_strdup((const char *) rp->name);
16479 adapter->short_name = g_strdup((const char *) rp->short_name);
16481 adapter->manufacturer = btohs(rp->manufacturer);
16483 adapter->supported_settings = btohl(rp->supported_settings);
16484 adapter->current_settings = btohl(rp->current_settings);
16486 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16487 adapter_check_version(adapter, rp->version);
16489 clear_uuids(adapter);
16490 clear_devices(adapter);
16492 if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
16493 if (!set_static_addr(adapter)) {
16494 btd_error(adapter->dev_id,
16495 "No Bluetooth address for index %u",
16500 struct btd_adapter *tmp;
16502 tmp = adapter_find(&rp->bdaddr);
16504 btd_error(adapter->dev_id,
16505 "Bluetooth address for index %u match index %u",
16506 adapter->dev_id, tmp->dev_id);
16510 bacpy(&adapter->bdaddr, &rp->bdaddr);
16511 if (!(adapter->supported_settings & MGMT_SETTING_LE))
16512 adapter->bdaddr_type = BDADDR_BREDR;
16514 adapter->bdaddr_type = BDADDR_LE_PUBLIC;
16517 missing_settings = adapter->current_settings ^
16518 adapter->supported_settings;
16520 /* If adapter supports PHY CONFIGURATION SETTING, then read PHY configuration and save them */
16521 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16522 if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
16523 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_PHY_CONFIGURATION, adapter->dev_id, 0, NULL,
16524 get_phy_configuration_resp, adapter, NULL) == 0)
16525 error("Unable to send %s cmd",
16526 mgmt_opstr(MGMT_OP_GET_PHY_CONFIGURATION));
16529 switch (btd_opts.mode) {
16531 if (missing_settings & MGMT_SETTING_SSP) {
16532 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16533 if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16534 set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16537 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16539 if (missing_settings & MGMT_SETTING_LE)
16540 set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16541 if (missing_settings & MGMT_SETTING_BREDR)
16542 set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16544 case BT_MODE_BREDR:
16545 if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
16546 btd_error(adapter->dev_id,
16547 "Ignoring adapter withouth BR/EDR support");
16551 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16552 if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16553 set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16555 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16557 if (missing_settings & MGMT_SETTING_SSP)
16558 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16560 if (missing_settings & MGMT_SETTING_BREDR)
16561 set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16562 if (adapter->current_settings & MGMT_SETTING_LE)
16563 set_mode(adapter, MGMT_OP_SET_LE, 0x00);
16566 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
16567 btd_error(adapter->dev_id,
16568 "Ignoring adapter withouth LE support");
16572 if (missing_settings & MGMT_SETTING_LE)
16573 set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16574 if (adapter->current_settings & MGMT_SETTING_BREDR)
16575 set_mode(adapter, MGMT_OP_SET_BREDR, 0x00);
16579 if (missing_settings & MGMT_SETTING_SECURE_CONN)
16580 set_mode(adapter, MGMT_OP_SET_SECURE_CONN,
16581 btd_opts.secure_conn);
16583 if (adapter->supported_settings & MGMT_SETTING_PRIVACY)
16584 set_privacy(adapter, btd_opts.privacy);
16586 if (btd_opts.fast_conn &&
16587 (missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
16588 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
16590 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16591 /* Set the RPA resolution value to '1' if privacy is supported */
16592 if (btd_opts.le_privacy &&
16593 adapter->supported_settings & MGMT_SETTING_PRIVACY)
16594 adapter->central_rpa_res_support = 0x01;
16597 err = adapter_register(adapter);
16599 btd_error(adapter->dev_id, "Unable to register new adapter");
16604 * Register all event notification handlers for controller.
16606 * The handlers are registered after a succcesful read of the
16607 * controller info. From now on they can track updates and
16610 mgmt_register(adapter->mgmt, MGMT_EV_NEW_SETTINGS, adapter->dev_id,
16611 new_settings_callback, adapter, NULL);
16613 mgmt_register(adapter->mgmt, MGMT_EV_CLASS_OF_DEV_CHANGED,
16615 dev_class_changed_callback,
16617 mgmt_register(adapter->mgmt, MGMT_EV_LOCAL_NAME_CHANGED,
16619 local_name_changed_callback,
16622 mgmt_register(adapter->mgmt, MGMT_EV_DISCOVERING,
16624 discovering_callback,
16627 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FOUND,
16629 device_found_callback,
16632 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16633 mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
16635 le_device_found_callback,
16639 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_DISCONNECTED,
16641 disconnected_callback,
16644 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_CONNECTED,
16646 connected_callback,
16649 mgmt_register(adapter->mgmt, MGMT_EV_CONNECT_FAILED,
16651 connect_failed_callback,
16654 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNPAIRED,
16659 mgmt_register(adapter->mgmt, MGMT_EV_AUTH_FAILED,
16661 auth_failed_callback,
16664 mgmt_register(adapter->mgmt, MGMT_EV_NEW_LINK_KEY,
16666 new_link_key_callback,
16669 mgmt_register(adapter->mgmt, MGMT_EV_NEW_LONG_TERM_KEY,
16671 new_long_term_key_callback,
16674 mgmt_register(adapter->mgmt, MGMT_EV_NEW_CSRK,
16679 mgmt_register(adapter->mgmt, MGMT_EV_NEW_IRK,
16684 mgmt_register(adapter->mgmt, MGMT_EV_NEW_CONN_PARAM,
16689 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
16691 device_blocked_callback,
16693 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNBLOCKED,
16695 device_unblocked_callback,
16698 mgmt_register(adapter->mgmt, MGMT_EV_PIN_CODE_REQUEST,
16700 pin_code_request_callback,
16703 mgmt_register(adapter->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
16705 user_confirm_request_callback,
16708 mgmt_register(adapter->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
16710 user_passkey_request_callback,
16713 mgmt_register(adapter->mgmt, MGMT_EV_PASSKEY_NOTIFY,
16715 user_passkey_notify_callback,
16718 mgmt_register(adapter->mgmt, MGMT_EV_CONTROLLER_RESUME,
16720 controller_resume_callback,
16723 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16724 mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
16726 rssi_alert_callback,
16729 mgmt_register(adapter->mgmt, MGMT_EV_RAW_RSSI,
16731 get_raw_rssi_callback,
16734 mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ENABLED,
16736 rssi_enabled_callback,
16739 mgmt_register(adapter->mgmt, MGMT_EV_RSSI_DISABLED,
16741 rssi_disabled_callback,
16744 mgmt_register(adapter->mgmt, MGMT_EV_HARDWARE_ERROR,
16746 hardware_error_callback,
16749 mgmt_register(adapter->mgmt, MGMT_EV_TX_TIMEOUT_ERROR,
16751 tx_timeout_error_callback,
16754 mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_NAME_UPDATE,
16756 device_name_update_callback,
16759 mgmt_register(adapter->mgmt, MGMT_EV_MULTI_ADV_STATE_CHANGED,
16761 multi_adv_state_change_callback,
16764 mgmt_register(adapter->mgmt, MGMT_EV_6LOWPAN_CONN_STATE_CHANGED,
16766 bt_6lowpan_conn_state_change_callback,
16769 mgmt_register(adapter->mgmt, MGMT_EV_LE_DATA_LENGTH_CHANGED,
16771 bt_le_data_length_changed_callback,
16774 mgmt_register(adapter->mgmt, MGMT_EV_CONN_UPDATED,
16776 le_conn_update_completed_callback,
16779 mgmt_register(adapter->mgmt, MGMT_EV_RPA_CHANGED,
16781 rpa_changed_callback,
16785 set_dev_class(adapter);
16787 set_name(adapter, btd_adapter_get_name(adapter));
16789 if (btd_has_kernel_features(KERNEL_BLOCKED_KEYS_SUPPORTED) &&
16790 !set_blocked_keys(adapter)) {
16791 btd_error(adapter->dev_id,
16792 "Failed to set blocked keys for index %u",
16797 if (btd_opts.pairable &&
16798 !(adapter->current_settings & MGMT_SETTING_BONDABLE))
16799 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
16801 if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
16802 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x01);
16803 else if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
16804 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
16806 if (adapter->stored_discoverable && !adapter->discoverable_timeout)
16807 set_discoverable(adapter, 0x01, 0);
16809 if (btd_adapter_get_powered(adapter))
16810 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16811 g_idle_add(adapter_start_idle_cb, adapter);
16813 adapter_start(adapter);
16815 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16817 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
16820 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16821 init_le_static_address(adapter);
16828 * Remove adapter from list in case of a failure.
16830 * Leaving an adapter structure around for a controller that can
16831 * not be initilized makes no sense at the moment.
16833 * This is a simplification to avoid constant checks if the
16834 * adapter is ready to do anything.
16836 adapter_list = g_list_remove(adapter_list, adapter);
16838 btd_adapter_unref(adapter);
16841 static void reset_adv_monitors_complete(uint8_t status, uint16_t length,
16842 const void *param, void *user_data)
16844 const struct mgmt_rp_remove_adv_monitor *rp = param;
16846 if (status != MGMT_STATUS_SUCCESS) {
16847 error("Failed to reset Adv Monitors: %s (0x%02x)",
16848 mgmt_errstr(status), status);
16852 if (length < sizeof(*rp)) {
16853 error("Wrong size of remove Adv Monitor response for reset "
16854 "all Adv Monitors");
16858 DBG("Removed all Adv Monitors");
16861 static void reset_adv_monitors(uint16_t index)
16863 struct mgmt_cp_remove_adv_monitor cp;
16865 DBG("sending remove Adv Monitor command with handle 0");
16867 /* Handle 0 indicates to remove all */
16868 cp.monitor_handle = 0;
16869 if (mgmt_send(mgmt_primary, MGMT_OP_REMOVE_ADV_MONITOR, index,
16870 sizeof(cp), &cp, reset_adv_monitors_complete, NULL,
16875 error("Failed to reset Adv Monitors");
16878 static void index_added(uint16_t index, uint16_t length, const void *param,
16881 struct btd_adapter *adapter;
16883 DBG("index %u", index);
16885 adapter = btd_adapter_lookup(index);
16887 btd_warn(adapter->dev_id,
16888 "Ignoring index added for an already existing adapter");
16892 /* Check if at maximum adapters allowed in the system then ignore the
16895 if (btd_opts.max_adapters &&
16896 btd_opts.max_adapters == g_slist_length(adapters))
16899 reset_adv_monitors(index);
16901 adapter = btd_adapter_new(index);
16904 "Unable to create new adapter for index %u", index);
16908 if (btd_has_kernel_features(KERNEL_EXP_FEATURES))
16909 read_exp_features(adapter);
16912 * Protect against potential two executions of read controller info.
16914 * In case the start of the daemon and the action of adding a new
16915 * controller coincide this function might be called twice.
16917 * To avoid the double execution of reading the controller info,
16918 * add the adapter already to the list. If an adapter is already
16919 * present, the second notification will cause a warning. If the
16920 * command fails the adapter is removed from the list again.
16922 adapter_list = g_list_append(adapter_list, adapter);
16924 DBG("sending read info command for index %u", index);
16926 if (mgmt_send(mgmt_primary, MGMT_OP_READ_INFO, index, 0, NULL,
16927 read_info_complete, adapter, NULL) > 0)
16930 btd_error(adapter->dev_id,
16931 "Failed to read controller info for index %u", index);
16933 adapter_list = g_list_remove(adapter_list, adapter);
16935 btd_adapter_unref(adapter);
16938 static void index_removed(uint16_t index, uint16_t length, const void *param,
16941 struct btd_adapter *adapter;
16943 DBG("index %u", index);
16945 adapter = btd_adapter_lookup(index);
16947 warn("Ignoring index removal for a non-existent adapter");
16951 adapter_unregister(adapter);
16954 static void read_index_list_complete(uint8_t status, uint16_t length,
16955 const void *param, void *user_data)
16957 const struct mgmt_rp_read_index_list *rp = param;
16961 if (status != MGMT_STATUS_SUCCESS) {
16962 error("Failed to read index list: %s (0x%02x)",
16963 mgmt_errstr(status), status);
16967 if (length < sizeof(*rp)) {
16968 error("Wrong size of read index list response");
16972 num = btohs(rp->num_controllers);
16974 DBG("Number of controllers: %d", num);
16976 if (num * sizeof(uint16_t) + sizeof(*rp) != length) {
16977 error("Incorrect packet size for index list response");
16981 for (i = 0; i < num; i++) {
16984 index = btohs(rp->index[i]);
16986 DBG("Found index %u", index);
16989 * Pretend to be index added event notification.
16991 * It is safe to just trigger the procedure for index
16992 * added notification. It does check against itself.
16994 index_added(index, 0, NULL, NULL);
16998 static void read_commands_complete(uint8_t status, uint16_t length,
16999 const void *param, void *user_data)
17001 const struct mgmt_rp_read_commands *rp = param;
17002 uint16_t num_commands, num_events;
17003 size_t expected_len;
17006 if (status != MGMT_STATUS_SUCCESS) {
17007 error("Failed to read supported commands: %s (0x%02x)",
17008 mgmt_errstr(status), status);
17012 if (length < sizeof(*rp)) {
17013 error("Wrong size of read commands response");
17017 num_commands = btohs(rp->num_commands);
17018 num_events = btohs(rp->num_events);
17020 DBG("Number of commands: %d", num_commands);
17021 DBG("Number of events: %d", num_events);
17023 expected_len = sizeof(*rp) + num_commands * sizeof(uint16_t) +
17024 num_events * sizeof(uint16_t);
17026 if (length < expected_len) {
17027 error("Too small reply for supported commands: (%u != %zu)",
17028 length, expected_len);
17032 for (i = 0; i < num_commands; i++) {
17033 uint16_t op = get_le16(rp->opcodes + i);
17036 case MGMT_OP_ADD_DEVICE:
17037 DBG("enabling kernel-side connection control");
17038 kernel_features |= KERNEL_CONN_CONTROL;
17040 case MGMT_OP_SET_BLOCKED_KEYS:
17041 DBG("kernel supports the set_blocked_keys op");
17042 kernel_features |= KERNEL_BLOCKED_KEYS_SUPPORTED;
17044 case MGMT_OP_SET_DEF_SYSTEM_CONFIG:
17045 DBG("kernel supports set system confic");
17046 kernel_features |= KERNEL_SET_SYSTEM_CONFIG;
17048 case MGMT_OP_READ_EXP_FEATURES_INFO:
17049 DBG("kernel supports exp features");
17050 kernel_features |= KERNEL_EXP_FEATURES;
17052 case MGMT_OP_ADD_EXT_ADV_PARAMS:
17053 DBG("kernel supports ext adv commands");
17054 kernel_features |= KERNEL_HAS_EXT_ADV_ADD_CMDS;
17056 case MGMT_OP_READ_CONTROLLER_CAP:
17057 DBG("kernel supports controller cap command");
17058 kernel_features |= KERNEL_HAS_CONTROLLER_CAP_CMD;
17065 for (i = 0; i < num_events; i++) {
17066 uint16_t ev = get_le16(rp->opcodes + num_commands + i);
17069 case MGMT_EV_CONTROLLER_RESUME:
17070 DBG("kernel supports suspend/resume events");
17071 kernel_features |= KERNEL_HAS_RESUME_EVT;
17077 static void read_version_complete(uint8_t status, uint16_t length,
17078 const void *param, void *user_data)
17080 const struct mgmt_rp_read_version *rp = param;
17082 if (status != MGMT_STATUS_SUCCESS) {
17083 error("Failed to read version information: %s (0x%02x)",
17084 mgmt_errstr(status), status);
17088 if (length < sizeof(*rp)) {
17089 error("Wrong size of read version response");
17093 mgmt_version = rp->version;
17094 mgmt_revision = btohs(rp->revision);
17096 info("Bluetooth management interface %u.%u initialized",
17097 mgmt_version, mgmt_revision);
17099 if (mgmt_version < 1) {
17100 error("Version 1.0 or later of management interface required");
17104 DBG("sending read supported commands command");
17107 * It is irrelevant if this command succeeds or fails. In case of
17108 * failure safe settings are assumed.
17110 mgmt_send(mgmt_primary, MGMT_OP_READ_COMMANDS,
17111 MGMT_INDEX_NONE, 0, NULL,
17112 read_commands_complete, NULL, NULL);
17114 mgmt_register(mgmt_primary, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
17115 index_added, NULL, NULL);
17116 mgmt_register(mgmt_primary, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
17117 index_removed, NULL, NULL);
17119 DBG("sending read index list command");
17121 if (mgmt_send(mgmt_primary, MGMT_OP_READ_INDEX_LIST,
17122 MGMT_INDEX_NONE, 0, NULL,
17123 read_index_list_complete, NULL, NULL) > 0)
17126 error("Failed to read controller index list");
17129 static void mgmt_debug(const char *str, void *user_data)
17131 DBG_IDX(0xffff, "%s", str);
17134 int adapter_init(void)
17136 dbus_conn = btd_get_dbus_connection();
17138 mgmt_primary = mgmt_new_default();
17139 if (!mgmt_primary) {
17140 error("Failed to access management interface");
17144 mgmt_set_debug(mgmt_primary, mgmt_debug, NULL, NULL);
17146 DBG("sending read version command");
17148 if (mgmt_send(mgmt_primary, MGMT_OP_READ_VERSION,
17149 MGMT_INDEX_NONE, 0, NULL,
17150 read_version_complete, NULL, NULL) > 0)
17153 error("Failed to read management version information");
17158 void adapter_cleanup(void)
17160 g_list_free(adapter_list);
17163 struct btd_adapter *adapter = adapters->data;
17165 adapter_remove(adapter);
17166 adapters = g_slist_remove(adapters, adapter);
17167 btd_adapter_unref(adapter);
17171 * In case there is another reference active, clear out
17172 * registered handlers for index added and index removed.
17174 * This is just an extra precaution to be safe, and in
17175 * reality should not make a difference.
17177 mgmt_unregister_index(mgmt_primary, MGMT_INDEX_NONE);
17180 * In case there is another reference active, cancel
17181 * all pending global commands.
17183 * This is just an extra precaution to avoid callbacks
17184 * that potentially then could leak memory or access
17185 * an invalid structure.
17187 mgmt_cancel_index(mgmt_primary, MGMT_INDEX_NONE);
17189 mgmt_unref(mgmt_primary);
17190 mgmt_primary = NULL;
17195 void adapter_shutdown(void)
17201 powering_down = true;
17203 for (list = g_list_first(adapter_list); list;
17204 list = g_list_next(list)) {
17205 struct btd_adapter *adapter = list->data;
17207 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
17210 clear_discoverable(adapter);
17211 remove_temporary_devices(adapter);
17212 set_mode(adapter, MGMT_OP_SET_POWERED, 0x00);
17214 adapter_remaining++;
17217 if (!adapter_remaining)
17222 * Check if workaround for broken ATT server socket behavior is needed
17223 * where we need to connect an ATT client socket before pairing to get
17224 * early access to the ATT channel.
17226 bool btd_le_connect_before_pairing(void)
17228 if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 4))
17234 bool btd_adapter_has_settings(struct btd_adapter *adapter, uint32_t settings)
17239 return (adapter->current_settings & settings) ? true : false;
17242 bool btd_has_kernel_features(uint32_t features)
17244 return !!(kernel_features & features);
17247 bool btd_adapter_has_exp_feature(struct btd_adapter *adapter, uint32_t feature)
17251 for (i = 0; i < ARRAY_SIZE(exp_table); i++) {
17252 const struct exp_feat *feat = &exp_table[i];
17254 if ((feat->flag & feature) && queue_find(adapter->exps, NULL,
17262 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
17263 int btd_adapter_set_streaming_mode(struct btd_adapter *adapter,
17264 const bdaddr_t *bdaddr, gboolean enable)
17266 struct mgmt_cp_set_streaming_mode cp;
17269 ba2str(bdaddr, addr);
17270 DBG("hci%u device %s", adapter->dev_id, addr);
17272 memset(&cp, 0, sizeof(cp));
17274 cp.streaming_mode = enable ? 1 : 0;
17275 bacpy(&cp.bdaddr, bdaddr);
17277 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STREAMING_MODE,
17278 adapter->dev_id, sizeof(cp), &cp,
17279 NULL, NULL, NULL) > 0)
17285 void adapter_send_event(const char *event)
17287 struct btd_adapter *adapter = btd_adapter_get_default();
17288 if (adapter == NULL) {
17289 error("adapter is NULL");
17293 g_dbus_emit_signal(dbus_conn, adapter->path,
17294 ADAPTER_INTERFACE, event,
17295 DBUS_TYPE_INVALID);