src/adapter.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *  BlueZ - Bluetooth protocol stack for Linux
   5  *
   6  *  Copyright (C) 2006-2010  Nokia Corporation
   7  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *
   9  *
  10  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 #include <config.h>
  14 #endif
  15
  16 #include <stdio.h>
  17 #include <inttypes.h>
  18 #include <errno.h>
  19 #include <unistd.h>
  20 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <sys/ioctl.h>
  23 #include <sys/file.h>
  24 #include <sys/stat.h>
  25 #include <dirent.h>
  26
  27 #include <glib.h>
  28 #include <dbus/dbus.h>
  29
  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"
  35 #include "lib/uuid.h"
  36 #include "lib/mgmt.h"
  37
  38 #include "gdbus/gdbus.h"
  39
  40 #include "log.h"
  41 #include "textfile.h"
  42
  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"
  49
  50 #include "btio/btio.h"
  51 #include "btd.h"
  52 #include "sdpd.h"
  53 #include "adapter.h"
  54 #include "device.h"
  55 #include "profile.h"
  56 #include "dbus-common.h"
  57 #include "error.h"
  58 #include "uuid-helper.h"
  59 #include "agent.h"
  60 #include "storage.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"
  68 #include "eir.h"
  69 #include "battery.h"
  70
  71 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
  72 #include <ctype.h>
  73 #include "adapter_le_vsc_features.h"
  74 #include "../profile.h"
  75 #endif
  76
  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 */
  83 #endif
  84
  85 #define MODE_OFF                0x00
  86 #define MODE_CONNECTABLE        0x01
  87 #define MODE_DISCOVERABLE       0x02
  88 #define MODE_UNKNOWN            0xff
  89
  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)
  94
  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)
  99
 100 #define HCI_RSSI_INVALID        127
 101 #define DISTANCE_VAL_INVALID    0x7FFF
 102 #define PATHLOSS_MAX            137
 103
 104 /*
 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.
 108  */
 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}},
 117 };
 118
 119 struct mgmt_exp_uuid {
 120         uint8_t val[16];
 121         const char *str;
 122 };
 123
 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"
 129 };
 130
 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"
 136 };
 137
 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"
 143 };
 144
 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"
 150 };
 151
 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"
 157 };
 158
 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"
 164 };
 165
 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
 170
 171 #define LE_BEARER_POSTFIX       " LE"
 172 #define LE_BEARER_POSTFIX_LEN   3
 173 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
 174
 175
 176 static DBusConnection *dbus_conn = NULL;
 177
 178 static uint32_t kernel_features = 0;
 179
 180 static GList *adapter_list = NULL;
 181 static unsigned int adapter_remaining = 0;
 182 static bool powering_down = false;
 183
 184 static GSList *adapters = NULL;
 185
 186 static struct mgmt *mgmt_primary = NULL;
 187
 188 static uint8_t mgmt_version = 0;
 189 static uint8_t mgmt_revision = 0;
 190
 191 static GSList *adapter_drivers = NULL;
 192
 193 static GSList *disconnect_list = NULL;
 194 static GSList *conn_fail_list = NULL;
 195
 196 struct link_key_info {
 197         bdaddr_t bdaddr;
 198         unsigned char key[16];
 199         uint8_t type;
 200         uint8_t pin_len;
 201         bool is_blocked;
 202 };
 203
 204 struct smp_ltk_info {
 205         bdaddr_t bdaddr;
 206         uint8_t bdaddr_type;
 207         uint8_t authenticated;
 208         bool central;
 209         uint8_t enc_size;
 210         uint16_t ediv;
 211         uint64_t rand;
 212         uint8_t val[16];
 213         bool is_blocked;
 214 };
 215
 216 struct irk_info {
 217         bdaddr_t bdaddr;
 218         uint8_t bdaddr_type;
 219         uint8_t val[16];
 220         bool is_blocked;
 221 };
 222
 223 struct conn_param {
 224         bdaddr_t bdaddr;
 225         uint8_t  bdaddr_type;
 226         uint16_t min_interval;
 227         uint16_t max_interval;
 228         uint16_t latency;
 229         uint16_t timeout;
 230 };
 231
 232 struct discovery_filter {
 233         uint8_t type;
 234         char *pattern;
 235         uint16_t pathloss;
 236         int16_t rssi;
 237         GSList *uuids;
 238         bool duplicate;
 239         bool discoverable;
 240 };
 241
 242 struct discovery_client {
 243         struct btd_adapter *adapter;
 244         DBusMessage *msg;
 245         char *owner;
 246         guint watch;
 247         struct discovery_filter *discovery_filter;
 248 };
 249
 250 struct service_auth {
 251         guint id;
 252         unsigned int svc_id;
 253         service_auth_cb cb;
 254         void *user_data;
 255         const char *uuid;
 256         struct btd_device *device;
 257         struct btd_adapter *adapter;
 258         struct agent *agent;            /* NULL for queued auths */
 259 };
 260
 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 */
 265 };
 266
 267 enum {
 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,
 273 };
 274
 275 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 276 struct adv_info {
 277         int slot_id;    /* Reservied slot id is 0 (Single adv) */
 278         bool status;            /* Advertising status */
 279 };
 280
 281 static GSList *read_requests = NULL;
 282
 283 struct le_data_length_read_request {
 284         struct btd_adapter *adapter;
 285         DBusMessage *msg;
 286 };
 287
 288 struct le_batching_request {
 289         struct btd_adapter *adapter;
 290         DBusMessage *msg;
 291 };
 292
 293 struct le_batching_set_param_request {
 294         struct btd_adapter *adapter;
 295         DBusMessage *msg;
 296         bdaddr_t bdaddr;
 297 };
 298 #endif
 299
 300 struct btd_adapter {
 301         int ref_count;
 302
 303         uint16_t dev_id;
 304         struct mgmt *mgmt;
 305
 306         bdaddr_t bdaddr;                /* controller Bluetooth address */
 307 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 308         bdaddr_t le_static_addr;
 309         bdaddr_t rpa;
 310 #endif
 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 */
 319
 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) */
 329
 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 */
 334         uint8_t disc_type;
 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 */
 343 #endif
 344
 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
 348                                          * without delay */
 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
 356                                          */
 357         /* current discovery filter, if any */
 358         struct mgmt_cp_start_service_discovery *current_discovery_filter;
 359
 360         struct discovery_client *client;        /* active discovery client */
 361
 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 */
 365 #endif
 366         unsigned int discovery_idle_timeout; /* timeout between discovery
 367                                                 * runs
 368                                                 */
 369         unsigned int passive_scan_timeout; /* timeout between passive scans */
 370
 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 */
 380
 381         struct btd_gatt_database *database;
 382         struct btd_adv_manager *adv_manager;
 383
 384         struct btd_adv_monitor_manager *adv_monitor_manager;
 385
 386         struct btd_battery_provider_manager *battery_provider_manager;
 387         GHashTable *allowed_uuid_set;   /* Set of allowed service UUIDs */
 388
 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 */
 398 #endif
 399
 400         GSList *pin_callbacks;
 401         GSList *msd_callbacks;
 402
 403         GSList *drivers;
 404         GSList *profiles;
 405
 406         struct oob_handler *oob_handler;
 407
 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 */
 423 #endif
 424 #endif
 425         bool is_default;                /* true if adapter is default one */
 426
 427         struct queue *exps;
 428 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 429         bool le_2m_phy_supported;
 430         bool le_coded_phy_supported;
 431         guint le_batching_available_pkts;
 432 #endif
 433 };
 434
 435 static char *adapter_power_state_str(uint32_t power_state)
 436 {
 437         switch (power_state) {
 438         case ADAPTER_POWER_STATE_OFF:
 439                 return "off";
 440         case ADAPTER_POWER_STATE_ON:
 441                 return "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";
 448         }
 449          DBG("Invalid power state %d", power_state);
 450         return "";
 451 }
 452
 453 typedef enum {
 454         ADAPTER_AUTHORIZE_DISCONNECTED = 0,
 455         ADAPTER_AUTHORIZE_CHECK_CONNECTED
 456 } adapter_authorize_type;
 457
 458 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 459 enum {
 460         DEINIT_6LOWPAN,
 461         INIT_6LOWPAN
 462 };
 463 #endif
 464
 465 static struct btd_adapter *btd_adapter_lookup(uint16_t index)
 466 {
 467         GList *list;
 468
 469         for (list = g_list_first(adapter_list); list;
 470                                                 list = g_list_next(list)) {
 471                 struct btd_adapter *adapter = list->data;
 472
 473                 if (adapter->dev_id == index)
 474                         return adapter;
 475         }
 476
 477         return NULL;
 478 }
 479
 480 struct btd_adapter *btd_adapter_get_default(void)
 481 {
 482         GList *list;
 483
 484         for (list = g_list_first(adapter_list); list;
 485                                                 list = g_list_next(list)) {
 486                 struct btd_adapter *adapter = list->data;
 487
 488                 if (adapter->is_default)
 489                         return adapter;
 490         }
 491
 492         return NULL;
 493 }
 494
 495 bool btd_adapter_is_default(struct btd_adapter *adapter)
 496 {
 497         if (!adapter)
 498                 return false;
 499
 500         return adapter->is_default;
 501 }
 502
 503 uint16_t btd_adapter_get_index(struct btd_adapter *adapter)
 504 {
 505         if (!adapter)
 506                 return MGMT_INDEX_NONE;
 507
 508         return adapter->dev_id;
 509 }
 510
 511 static gboolean process_auth_queue(gpointer user_data);
 512
 513 static void dev_class_changed_callback(uint16_t index, uint16_t length,
 514                                         const void *param, void *user_data)
 515 {
 516         struct btd_adapter *adapter = user_data;
 517         const struct mgmt_cod *rp = param;
 518         uint32_t dev_class;
 519
 520         if (length < sizeof(*rp)) {
 521                 btd_error(adapter->dev_id,
 522                         "Wrong size of class of device changed parameters");
 523                 return;
 524         }
 525
 526         dev_class = rp->val[0] | (rp->val[1] << 8) | (rp->val[2] << 16);
 527
 528         if (dev_class == adapter->dev_class)
 529                 return;
 530
 531         DBG("Class: 0x%06x", dev_class);
 532
 533         adapter->dev_class = dev_class;
 534
 535         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 536                                                 ADAPTER_INTERFACE, "Class");
 537 }
 538
 539 static void set_dev_class_complete(uint8_t status, uint16_t length,
 540                                         const void *param, void *user_data)
 541 {
 542         struct btd_adapter *adapter = user_data;
 543
 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);
 548                 return;
 549         }
 550
 551         /*
 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.
 555          */
 556         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
 557 }
 558
 559 static void set_dev_class(struct btd_adapter *adapter)
 560 {
 561         struct mgmt_cp_set_dev_class cp;
 562
 563         /*
 564          * If the controller does not support BR/EDR operation,
 565          * there is no point in trying to set a major and minor
 566          * class value.
 567          *
 568          * This is an optimization for Low Energy only controllers.
 569          */
 570         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
 571                 return;
 572
 573         memset(&cp, 0, sizeof(cp));
 574
 575         /*
 576          * Silly workaround for a really stupid kernel bug :(
 577          *
 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.
 581          *
 582          * To make this work, shift the value in userspace for now until
 583          * we get a fixed kernel version.
 584          */
 585         cp.major = adapter->major_class & 0x1f;
 586         cp.minor = adapter->minor_class << 2;
 587
 588         DBG("sending set device class command for index %u", adapter->dev_id);
 589
 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)
 593                 return;
 594
 595         btd_error(adapter->dev_id,
 596                 "Failed to set class of device for index %u", adapter->dev_id);
 597 }
 598
 599 void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
 600                                                         uint8_t minor)
 601 {
 602         if (adapter->major_class == major && adapter->minor_class == minor)
 603                 return;
 604
 605         DBG("class: major %u minor %u", major, minor);
 606
 607         adapter->major_class = major;
 608         adapter->minor_class = minor;
 609
 610         set_dev_class(adapter);
 611 }
 612
 613 static uint8_t get_mode(const char *mode)
 614 {
 615         if (strcasecmp("off", mode) == 0)
 616                 return MODE_OFF;
 617         else if (strcasecmp("connectable", mode) == 0)
 618                 return MODE_CONNECTABLE;
 619         else if (strcasecmp("discoverable", mode) == 0)
 620                 return MODE_DISCOVERABLE;
 621         else
 622                 return MODE_UNKNOWN;
 623 }
 624
 625 const char *btd_adapter_get_storage_dir(struct btd_adapter *adapter)
 626 {
 627         static char dir[25];
 628
 629         if (adapter->bdaddr_type == BDADDR_LE_RANDOM) {
 630                 strcpy(dir, "static-");
 631                 ba2str(&adapter->bdaddr, dir + 7);
 632         } else {
 633                 ba2str(&adapter->bdaddr, dir);
 634         }
 635
 636         return dir;
 637 }
 638
 639 uint8_t btd_adapter_get_address_type(struct btd_adapter *adapter)
 640 {
 641         return adapter->bdaddr_type;
 642 }
 643
 644 static void store_adapter_info(struct btd_adapter *adapter)
 645 {
 646         GKeyFile *key_file;
 647         GError *gerr = NULL;
 648         char filename[PATH_MAX];
 649         char *str;
 650         gsize length = 0;
 651         gboolean discoverable;
 652
 653         key_file = g_key_file_new();
 654
 655         if (adapter->pairable_timeout != btd_opts.pairto)
 656                 g_key_file_set_integer(key_file, "General", "PairableTimeout",
 657                                         adapter->pairable_timeout);
 658
 659         if ((adapter->current_settings & MGMT_SETTING_DISCOVERABLE) &&
 660                                                 !adapter->discoverable_timeout)
 661                 discoverable = TRUE;
 662         else
 663                 discoverable = FALSE;
 664
 665         g_key_file_set_boolean(key_file, "General", "Discoverable",
 666                                                         discoverable);
 667
 668         if (adapter->discoverable_timeout != btd_opts.discovto)
 669                 g_key_file_set_integer(key_file, "General",
 670                                         "DiscoverableTimeout",
 671                                         adapter->discoverable_timeout);
 672
 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");
 682         else /* source */
 683                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "source");
 684 #endif
 685
 686         create_filename(filename, PATH_MAX, "/%s/settings",
 687                                                 btd_adapter_get_storage_dir(adapter));
 688         create_file(filename, 0600);
 689
 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,
 693                                                                 gerr->message);
 694                 g_error_free(gerr);
 695         }
 696         g_free(str);
 697
 698         g_key_file_free(key_file);
 699 }
 700
 701 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 702 bluetooth_a2dp_role_t btd_adapter_get_a2dp_role(struct btd_adapter *adapter)
 703 {
 704         if (!adapter)
 705                 return BLUETOOTH_A2DP_SOURCE_ROLE;
 706
 707         return adapter->a2dp_role;
 708 }
 709
 710 void btd_adapter_set_a2dp_role(struct btd_adapter *adapter, bluetooth_a2dp_role_t role)
 711 {
 712         if (!adapter) {
 713                 DBG("Could not set a2dp role");
 714                 return;
 715         }
 716
 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;
 727 #endif
 728         }
 729
 730         store_adapter_info(adapter);
 731 }
 732
 733 void btd_adapter_emit_a2dp_role_changed(struct btd_adapter *adapter)
 734 {
 735         if (!adapter) {
 736                 DBG("Could not emit signal for a2dp role");
 737                 return;
 738         }
 739
 740         DBG("A2dp role: %u", adapter->a2dp_role);
 741
 742         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 743                         ADAPTER_INTERFACE, "A2dpRole");
 744 }
 745 #endif
 746
 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,
 752                                                         uint8_t mode);
 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);
 757 #endif
 758
 759 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 760 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 761 static gboolean charging_state_timeout_cb(gpointer user_data)
 762 {
 763         struct btd_adapter *adapter = user_data;
 764         int bredr_pkt_type = ACL_PTYPE_MASK;
 765
 766         adapter->charging_timeout = 0;
 767
 768         DBG("Set all connections to BR/EDR type");
 769         g_slist_foreach(adapter->devices, device_change_pkt_type,
 770                         (gpointer)bredr_pkt_type);
 771
 772         return FALSE;
 773 }
 774
 775 static void set_charging_state(struct btd_adapter *adapter,
 776                 charging_state_e state)
 777 {
 778         int br_pkt_type = ACL_PTYPE_MASK |
 779                 HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
 780                 HCI_3DH1 | HCI_3DH3 | HCI_3DH5;
 781
 782         if (adapter->charging == state)
 783                 return;
 784
 785         DBG("old charging state : %d, new charging_state : %d",
 786                         adapter->charging, state);
 787
 788         /*
 789          * Only none / wire charging <-> wireless charging state change should
 790          * be handled.
 791          */
 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;
 796                 return;
 797         }
 798
 799         if (adapter->charging_timeout) {
 800                 g_source_remove(adapter->charging_timeout);
 801                 adapter->charging_timeout = 0;
 802         }
 803
 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);
 814         }
 815
 816         return;
 817 }
 818
 819 static gboolean charging_state_changed(DBusConnection *connection,
 820                 DBusMessage *msg, void *user_data)
 821 {
 822         struct btd_adapter *adapter = user_data;
 823         int state = 0;
 824
 825         DBG("charging_state_changed");
 826
 827         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &state,
 828                                 DBUS_TYPE_INVALID))
 829                 return TRUE;
 830
 831         set_charging_state(adapter, state);
 832
 833         return TRUE;
 834 }
 835
 836 charging_state_e get_charging_state(struct btd_adapter *adapter)
 837 {
 838         DBG("charging_state: %d", adapter->charging);
 839         return adapter->charging;
 840 }
 841 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 842
 843 static int compare_slot(gconstpointer a, gconstpointer b)
 844 {
 845         const struct adv_info *adv = a;
 846         const int id = *(int*)b;
 847
 848         return (adv->slot_id == id ? 0 : -1);
 849 }
 850
 851 static struct adv_info *find_advertiser(struct btd_adapter *adapter,
 852                                 int slot_id)
 853 {
 854         GSList *list;
 855
 856         list = g_slist_find_custom(adapter->adv_list, &slot_id,
 857                                                         compare_slot);
 858         if (list)
 859                 return list->data;
 860
 861         return NULL;
 862 }
 863
 864 static struct adv_info *create_advertiser(struct btd_adapter *adapter,
 865                                         int slot_id)
 866 {
 867         struct adv_info *adv;
 868
 869         if (!adapter)
 870                 return NULL;
 871
 872         adv = find_advertiser(adapter, slot_id);
 873         if (adv != NULL) {
 874                 DBG("Aleady existed. solt_id [%d]", slot_id);
 875                 return adv;
 876         }
 877
 878         DBG("Create adv slot id : %d", slot_id);
 879
 880         adv = g_new0(struct adv_info, 1);
 881         if (adv == NULL)
 882                 return NULL;
 883
 884         adv->slot_id = slot_id;
 885
 886         adapter->adv_list = g_slist_append(adapter->adv_list, adv);
 887         return adv;
 888 }
 889
 890
 891 static void advertising_state_changed(struct btd_adapter *adapter,
 892                                         int slot_id, bool enabled)
 893 {
 894         struct adv_info *adv;
 895         int id = slot_id;
 896         int state = enabled;
 897
 898         if (!adapter)
 899                 return;
 900
 901         adv = find_advertiser(adapter, slot_id);
 902         if (!adv) {
 903                 DBG("Unable to find advertiser [%d]", slot_id);
 904                 return;
 905         }
 906
 907         adv->status = enabled;
 908         DBG("slot_id %d, status %d", adv->slot_id, adv->status);
 909
 910         g_dbus_emit_signal(dbus_conn, adapter->path,
 911                         ADAPTER_INTERFACE, "AdvertisingEnabled",
 912                         DBUS_TYPE_INT32, &id,
 913                         DBUS_TYPE_BOOLEAN, &state,
 914                         DBUS_TYPE_INVALID);
 915 }
 916
 917 static void clear_advertiser_cb(gpointer data, gpointer user_data)
 918 {
 919         struct adv_info *adv = data;
 920         struct btd_adapter *adapter = user_data;
 921
 922         if (adv->status)
 923                 advertising_state_changed(adapter, adv->slot_id, 0);
 924 }
 925
 926 static void advertiser_cleanup(struct btd_adapter *adapter)
 927 {
 928         if (!adapter->adv_list)
 929                 return;
 930
 931         g_slist_foreach(adapter->adv_list, clear_advertiser_cb, adapter);
 932         g_slist_free(adapter->adv_list);
 933         adapter->adv_list = NULL;
 934 }
 935
 936 static void update_advertiser_address(gpointer data, gpointer user_data)
 937 {
 938         struct adv_info *adv = data;
 939         struct btd_adapter *adapter = user_data;
 940
 941         if (adv->slot_id > 0 && adv->status == 1)
 942                 adapter_le_set_random_address(adapter, &adapter->rpa, adv->slot_id);
 943 }
 944
 945 static void rpa_changed_callback(uint16_t index, uint16_t length,
 946                                         const void *param, void *user_data)
 947 {
 948         const struct mgmt_ev_rpa_changed *ev = param;
 949         struct btd_adapter *adapter = user_data;
 950         char addr[18];
 951
 952         if (length < sizeof(*ev)) {
 953                 error("Too small rpa changed event");
 954                 return;
 955         }
 956
 957         ba2str(&ev->bdaddr, addr);
 958         DBG("RPA changed %s", addr);
 959         bacpy(&adapter->rpa, &ev->bdaddr);
 960
 961         if (!adapter->adv_list)
 962                 return;
 963
 964         g_slist_foreach(adapter->adv_list, update_advertiser_address, adapter);
 965 }
 966
 967 #endif
 968
 969 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 970 #define OCF_PAGE_SCAN_TIMEOUT                   0x0018
 971 #define OGF_PAGE_SCAN_TIMEOUT           0x03
 972
 973 typedef struct {
 974         uint16_t        timeout;        /* Value */
 975 } __attribute__ ((packed)) hci_page_scan_timeout;
 976 #define HCI_PAGE_SCAN_TIMEOUT_CP_SIZE 2
 977
 978 static gboolean send_sprd_page_scan_timeout(gint value)
 979 {
 980         int dd;
 981         hci_page_scan_timeout cp;
 982         DBG("+");
 983         dd = hci_open_dev(0);
 984         cp.timeout = value;
 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");
 988                 hci_close_dev(dd);
 989                 return FALSE;
 990         }
 991         DBG("Page Scan Timeout Value Patch %d", value);
 992
 993         hci_close_dev(dd);
 994
 995         return TRUE;
 996 }
 997 #endif
 998
 999 static void settings_changed(struct btd_adapter *adapter, uint32_t settings)
1000 {
1001         uint32_t changed_mask;
1002
1003         changed_mask = adapter->current_settings ^ settings;
1004
1005         adapter->current_settings = settings;
1006         adapter->pending_settings &= ~changed_mask;
1007
1008         DBG("Changed settings: 0x%08x", changed_mask);
1009         DBG("Pending settings: 0x%08x", adapter->pending_settings);
1010
1011         if (changed_mask & MGMT_SETTING_POWERED) {
1012                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1013                                         ADAPTER_INTERFACE, "Powered");
1014
1015                 if (adapter->current_settings & MGMT_SETTING_POWERED) {
1016                         adapter_start(adapter);
1017
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);
1027                         }
1028 #endif
1029                 } else {
1030                         adapter_stop(adapter);
1031
1032                         if (powering_down) {
1033                                 adapter_remaining--;
1034
1035                                 if (!adapter_remaining)
1036                                         btd_exit();
1037                         }
1038                 }
1039         }
1040
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);
1045
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.
1051                  */
1052                 if (!adapter->discovery_discoverable)
1053                         store_adapter_info(adapter);
1054                 btd_adv_manager_refresh(adapter->adv_manager);
1055         }
1056
1057         if (changed_mask & MGMT_SETTING_BONDABLE) {
1058                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1059                                         ADAPTER_INTERFACE, "Pairable");
1060
1061                 trigger_pairable_timeout(adapter);
1062         }
1063
1064 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1065         if (changed_mask & MGMT_SETTING_ADVERTISING) {
1066                 if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
1067                         (adapter->advertising)) {
1068                         return;
1069                 }
1070
1071                 adapter->advertising = adapter->current_settings & MGMT_SETTING_ADVERTISING;
1072                 advertising_state_changed(adapter, 0, adapter->advertising);
1073         }
1074
1075         if ((changed_mask & MGMT_SETTING_PRIVACY) &&
1076             !(adapter->current_settings & MGMT_SETTING_PRIVACY)) {
1077                 DBG("LE Privacy feature is disabled");
1078
1079                 /*
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.
1084                  */
1085                 set_local_irk(adapter);
1086         }
1087 #endif
1088 }
1089
1090 static void adapter_set_power_state(struct btd_adapter *adapter, uint32_t value)
1091 {
1092         if (adapter->power_state == value)
1093                 return;
1094
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");
1099 }
1100
1101 static void reset_power_state_target(struct btd_adapter *adapter,
1102                                         uint32_t value)
1103 {
1104         if (value &&
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);
1110         }
1111 }
1112
1113 static void new_settings_callback(uint16_t index, uint16_t length,
1114                                         const void *param, void *user_data)
1115 {
1116         struct btd_adapter *adapter = user_data;
1117         uint32_t settings;
1118
1119         if (length < sizeof(settings)) {
1120                 btd_error(adapter->dev_id,
1121                                 "Wrong size of new settings parameters");
1122                 return;
1123         }
1124
1125         settings = get_le32(param);
1126
1127         if (settings == adapter->current_settings)
1128                 return;
1129
1130         if ((adapter->current_settings ^ settings) & MGMT_SETTING_POWERED) {
1131                 reset_power_state_target(adapter,
1132                                         settings & MGMT_SETTING_POWERED ?
1133                                         0x01 : 0x00);
1134         }
1135
1136         DBG("Settings: 0x%08x", settings);
1137
1138         settings_changed(adapter, settings);
1139 }
1140
1141 struct set_mode_data {
1142         struct btd_adapter *adapter;
1143         uint32_t setting;
1144         uint8_t value;
1145 };
1146
1147 static void set_mode_complete(uint8_t status, uint16_t length,
1148                                         const void *param, void *user_data)
1149 {
1150         struct set_mode_data *data = user_data;
1151         struct btd_adapter *adapter = data->adapter;
1152
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);
1163                 return;
1164         }
1165
1166         /*
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.
1170          */
1171         new_settings_callback(adapter->dev_id, length, param, adapter);
1172 }
1173
1174 static void remove_temporary_devices(struct btd_adapter *adapter)
1175 {
1176         GSList *l, *next;
1177
1178         for (l = adapter->devices; l; l = next) {
1179                 struct btd_device *dev = l->data;
1180
1181                 next = g_slist_next(l);
1182                 if (device_is_temporary(dev))
1183                         btd_adapter_remove_device(adapter, dev);
1184         }
1185 }
1186
1187 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
1188                                                         uint8_t mode)
1189 {
1190         struct mgmt_mode cp;
1191         uint32_t setting = 0;
1192         struct set_mode_data *data;
1193
1194         memset(&cp, 0, sizeof(cp));
1195         cp.val = mode;
1196
1197         switch (opcode) {
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);
1204                 }
1205                 break;
1206         case MGMT_OP_SET_CONNECTABLE:
1207                 setting = MGMT_SETTING_CONNECTABLE;
1208                 break;
1209         case MGMT_OP_SET_FAST_CONNECTABLE:
1210                 setting = MGMT_SETTING_FAST_CONNECTABLE;
1211                 break;
1212         case MGMT_OP_SET_DISCOVERABLE:
1213                 setting = MGMT_SETTING_DISCOVERABLE;
1214                 break;
1215         case MGMT_OP_SET_BONDABLE:
1216                 setting = MGMT_SETTING_BONDABLE;
1217                 break;
1218         }
1219
1220         adapter->pending_settings |= setting;
1221
1222 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1223         DBG("sending 0x%4.4x set mode %d command for index %u", opcode, mode, adapter->dev_id);
1224 #else
1225         DBG("sending set mode command for index %u", adapter->dev_id);
1226 #endif
1227
1228         data = g_new0(struct set_mode_data, 1);
1229         data->adapter = adapter;
1230         data->setting = setting;
1231         data->value = mode;
1232
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;
1237                 return true;
1238         }
1239         g_free(data);
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);
1245         }
1246         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1247                                                         adapter->dev_id);
1248
1249         return false;
1250 }
1251
1252 static bool set_discoverable(struct btd_adapter *adapter, uint8_t mode,
1253                                                         uint16_t timeout)
1254 {
1255         struct mgmt_cp_set_discoverable cp;
1256         struct set_mode_data *data;
1257
1258         memset(&cp, 0, sizeof(cp));
1259         cp.val = mode;
1260         cp.timeout = htobs(timeout);
1261
1262         DBG("sending set mode command for index %u", adapter->dev_id);
1263
1264 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1265         if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
1266                 if (mode)
1267                         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, mode);
1268                 else
1269                         /* This also disables discoverable so we're done */
1270                         return set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
1271                                                                         mode);
1272         }
1273 #endif
1274
1275         data = g_new0(struct set_mode_data, 1);
1276         data->adapter = adapter;
1277         data->setting = 0;
1278
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)
1282                 return true;
1283
1284         g_free(data);
1285         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1286                                                         adapter->dev_id);
1287
1288         return false;
1289 }
1290
1291 static bool pairable_timeout_handler(gpointer user_data)
1292 {
1293         struct btd_adapter *adapter = user_data;
1294
1295         adapter->pairable_timeout_id = 0;
1296
1297         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
1298
1299         return FALSE;
1300 }
1301
1302 static void trigger_pairable_timeout(struct btd_adapter *adapter)
1303 {
1304         if (adapter->pairable_timeout_id > 0) {
1305                 timeout_remove(adapter->pairable_timeout_id);
1306                 adapter->pairable_timeout_id = 0;
1307         }
1308
1309         if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
1310                 return;
1311
1312         if (adapter->pairable_timeout > 0)
1313                 adapter->pairable_timeout_id =
1314                         timeout_add_seconds(adapter->pairable_timeout,
1315                                         pairable_timeout_handler, adapter,
1316                                         NULL);
1317 }
1318
1319 static void local_name_changed_callback(uint16_t index, uint16_t length,
1320                                         const void *param, void *user_data)
1321 {
1322         struct btd_adapter *adapter = user_data;
1323         const struct mgmt_cp_set_local_name *rp = param;
1324
1325         if (length < sizeof(*rp)) {
1326                 btd_error(adapter->dev_id,
1327                                 "Wrong size of local name changed parameters");
1328                 return;
1329         }
1330
1331         if (!g_strcmp0(adapter->short_name, (const char *) rp->short_name) &&
1332                         !g_strcmp0(adapter->name, (const char *) rp->name))
1333                 return;
1334
1335         DBG("Name: %s", rp->name);
1336         DBG("Short name: %s", rp->short_name);
1337
1338         g_free(adapter->name);
1339         adapter->name = g_strdup((const char *) rp->name);
1340
1341         g_free(adapter->short_name);
1342         adapter->short_name = g_strdup((const char *) rp->short_name);
1343
1344         /*
1345          * Changing the name (even manually via HCI) will update the
1346          * current alias property.
1347          *
1348          * In case the name is empty, use the short name.
1349          *
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.
1353          */
1354         if (adapter->name && adapter->name[0] != '\0') {
1355                 g_free(adapter->current_alias);
1356                 adapter->current_alias = g_strdup(adapter->name);
1357         } else {
1358                 g_free(adapter->current_alias);
1359                 adapter->current_alias = g_strdup(adapter->short_name);
1360         }
1361
1362         DBG("Current alias: %s", adapter->current_alias);
1363
1364         if (!adapter->current_alias)
1365                 return;
1366
1367         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1368                                                 ADAPTER_INTERFACE, "Alias");
1369
1370         attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
1371                                 (const uint8_t *) adapter->current_alias,
1372                                         strlen(adapter->current_alias));
1373 }
1374
1375 static void set_local_name_complete(uint8_t status, uint16_t length,
1376                                         const void *param, void *user_data)
1377 {
1378         struct btd_adapter *adapter = user_data;
1379
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);
1384                 return;
1385         }
1386
1387         /*
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.
1391          */
1392         local_name_changed_callback(adapter->dev_id, length, param, adapter);
1393 }
1394
1395 static int set_name(struct btd_adapter *adapter, const char *name)
1396 {
1397         struct mgmt_cp_set_local_name cp;
1398         char maxname[MAX_NAME_LENGTH];
1399
1400         memset(maxname, 0, sizeof(maxname));
1401         strncpy(maxname, name, MAX_NAME_LENGTH - 1);
1402
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");
1406                 return -EINVAL;
1407         }
1408
1409         memset(&cp, 0, sizeof(cp));
1410         strncpy((char *) cp.name, maxname, sizeof(cp.name) - 1);
1411
1412         DBG("sending set local name command for index %u", adapter->dev_id);
1413
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)
1417                 return 0;
1418
1419         btd_error(adapter->dev_id, "Failed to set local name for index %u",
1420                                                         adapter->dev_id);
1421
1422         return -EIO;
1423 }
1424
1425 int adapter_set_name(struct btd_adapter *adapter, const char *name)
1426 {
1427         if (g_strcmp0(adapter->system_name, name) == 0)
1428                 return 0;
1429
1430         DBG("name: %s", name);
1431
1432         g_free(adapter->system_name);
1433         adapter->system_name = g_strdup(name);
1434
1435         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1436                                                 ADAPTER_INTERFACE, "Name");
1437
1438         /* alias is preferred over system name */
1439         if (adapter->stored_alias)
1440                 return 0;
1441
1442         DBG("alias: %s", name);
1443
1444         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1445                                                 ADAPTER_INTERFACE, "Alias");
1446
1447         return set_name(adapter, name);
1448 }
1449
1450 struct btd_device *btd_adapter_find_device(struct btd_adapter *adapter,
1451                                                         const bdaddr_t *dst,
1452                                                         uint8_t bdaddr_type)
1453 {
1454         struct device_addr_type addr;
1455         struct btd_device *device;
1456         GSList *list;
1457
1458         if (!adapter)
1459                 return NULL;
1460
1461         bacpy(&addr.bdaddr, dst);
1462         addr.bdaddr_type = bdaddr_type;
1463
1464 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1465         list = g_slist_find_custom(adapter->devices, &addr,
1466                                                 device_addr_type_strict_cmp);
1467         if (list) {
1468                 device = list->data;
1469                 return device;
1470         }
1471 #endif
1472         list = g_slist_find_custom(adapter->devices, &addr,
1473                                                         device_addr_type_cmp);
1474         if (!list)
1475                 return NULL;
1476
1477         device = list->data;
1478
1479         /*
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.
1483          */
1484         if (bdaddr_type == BDADDR_BREDR)
1485                 device_set_bredr_support(device);
1486         else
1487                 device_set_le_support(device, bdaddr_type);
1488
1489         return device;
1490 }
1491
1492 static int device_path_cmp(gconstpointer a, gconstpointer b)
1493 {
1494         const struct btd_device *device = a;
1495         const char *path = b;
1496         const char *dev_path = device_get_path(device);
1497
1498         return strcasecmp(dev_path, path);
1499 }
1500
1501 struct btd_device *btd_adapter_find_device_by_path(struct btd_adapter *adapter,
1502                                                    const char *path)
1503 {
1504         GSList *list;
1505
1506         if (!adapter)
1507                 return NULL;
1508
1509         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
1510         if (!list)
1511                 return NULL;
1512
1513         return list->data;
1514 }
1515
1516 static void uuid_to_uuid128(uuid_t *uuid128, const uuid_t *uuid)
1517 {
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);
1522         else
1523                 memcpy(uuid128, uuid, sizeof(*uuid));
1524 }
1525
1526 static bool is_supported_uuid(const uuid_t *uuid)
1527 {
1528         uuid_t tmp;
1529
1530         /* mgmt versions from 1.3 onwards support all types of UUIDs */
1531         if (MGMT_VERSION(mgmt_version, mgmt_revision) >= MGMT_VERSION(1, 3))
1532                 return true;
1533
1534         uuid_to_uuid128(&tmp, uuid);
1535
1536         if (!sdp_uuid128_to_uuid(&tmp))
1537                 return false;
1538
1539         if (tmp.type != SDP_UUID16)
1540                 return false;
1541
1542         return true;
1543 }
1544
1545 static void add_uuid_complete(uint8_t status, uint16_t length,
1546                                         const void *param, void *user_data)
1547 {
1548         struct btd_adapter *adapter = user_data;
1549
1550         if (status != MGMT_STATUS_SUCCESS) {
1551                 btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
1552                                                 mgmt_errstr(status), status);
1553                 return;
1554         }
1555
1556         /*
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.
1560          */
1561         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1562
1563         if (adapter->initialized)
1564                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1565                                                 ADAPTER_INTERFACE, "UUIDs");
1566 }
1567
1568 static int add_uuid(struct btd_adapter *adapter, uuid_t *uuid, uint8_t svc_hint)
1569 {
1570         struct mgmt_cp_add_uuid cp;
1571         uuid_t uuid128;
1572         uint128_t uint128;
1573
1574         if (!is_supported_uuid(uuid)) {
1575                 btd_warn(adapter->dev_id,
1576                                 "Ignoring unsupported UUID for addition");
1577                 return 0;
1578         }
1579
1580         uuid_to_uuid128(&uuid128, uuid);
1581
1582         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1583         htob128(&uint128, (uint128_t *) cp.uuid);
1584         cp.svc_hint = svc_hint;
1585
1586         DBG("sending add uuid command for index %u", adapter->dev_id);
1587
1588         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_UUID,
1589                                 adapter->dev_id, sizeof(cp), &cp,
1590                                 add_uuid_complete, adapter, NULL) > 0)
1591                 return 0;
1592
1593         btd_error(adapter->dev_id, "Failed to add UUID for index %u",
1594                                                         adapter->dev_id);
1595
1596         return -EIO;
1597 }
1598
1599 static void remove_uuid_complete(uint8_t status, uint16_t length,
1600                                         const void *param, void *user_data)
1601 {
1602         struct btd_adapter *adapter = user_data;
1603
1604         if (status != MGMT_STATUS_SUCCESS) {
1605                 btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
1606                                                 mgmt_errstr(status), status);
1607                 return;
1608         }
1609
1610         /*
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.
1614          */
1615         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1616
1617         if (adapter->initialized)
1618                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1619                                                 ADAPTER_INTERFACE, "UUIDs");
1620 }
1621
1622 static int remove_uuid(struct btd_adapter *adapter, uuid_t *uuid)
1623 {
1624         struct mgmt_cp_remove_uuid cp;
1625         uuid_t uuid128;
1626         uint128_t uint128;
1627
1628         if (!is_supported_uuid(uuid)) {
1629                 btd_warn(adapter->dev_id,
1630                                 "Ignoring unsupported UUID for removal");
1631                 return 0;
1632         }
1633
1634         uuid_to_uuid128(&uuid128, uuid);
1635
1636         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1637         htob128(&uint128, (uint128_t *) cp.uuid);
1638
1639         DBG("sending remove uuid command for index %u", adapter->dev_id);
1640
1641         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1642                                 adapter->dev_id, sizeof(cp), &cp,
1643                                 remove_uuid_complete, adapter, NULL) > 0)
1644                 return 0;
1645
1646         btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
1647                                                         adapter->dev_id);
1648
1649         return -EIO;
1650 }
1651
1652 static void clear_uuids_complete(uint8_t status, uint16_t length,
1653                                         const void *param, void *user_data)
1654 {
1655         struct btd_adapter *adapter = user_data;
1656
1657         if (status != MGMT_STATUS_SUCCESS) {
1658                 btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
1659                                                 mgmt_errstr(status), status);
1660                 return;
1661         }
1662
1663         /*
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.
1667          */
1668         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1669 }
1670
1671 static int clear_uuids(struct btd_adapter *adapter)
1672 {
1673         struct mgmt_cp_remove_uuid cp;
1674
1675         memset(&cp, 0, sizeof(cp));
1676
1677         DBG("sending clear uuids command for index %u", adapter->dev_id);
1678
1679         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1680                                 adapter->dev_id, sizeof(cp), &cp,
1681                                 clear_uuids_complete, adapter, NULL) > 0)
1682                 return 0;
1683
1684         btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
1685                                                         adapter->dev_id);
1686
1687         return -EIO;
1688 }
1689
1690 static uint8_t get_uuid_mask(uuid_t *uuid)
1691 {
1692         if (uuid->type != SDP_UUID16)
1693                 return 0;
1694
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:
1712         /*
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.
1717          */
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:
1728         case GN_SVCLASS_ID:
1729                 return 0x02;    /* Networking */
1730         default:
1731                 return 0;
1732         }
1733 }
1734
1735 static int uuid_cmp(const void *a, const void *b)
1736 {
1737         const sdp_record_t *rec = a;
1738         const uuid_t *uuid = b;
1739
1740         return sdp_uuid_cmp(&rec->svclass, uuid);
1741 }
1742
1743 static void adapter_service_insert(struct btd_adapter *adapter, sdp_record_t *rec)
1744 {
1745         sdp_list_t *browse_list = NULL;
1746         uuid_t browse_uuid;
1747         gboolean new_uuid;
1748
1749         DBG("%s", adapter->path);
1750
1751 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1752         if (rec == NULL) {
1753                 DBG("record is NULL return");
1754                 return;
1755         }
1756 #endif
1757
1758         /* skip record without a browse group */
1759         if (sdp_get_browse_groups(rec, &browse_list) < 0) {
1760                 DBG("skipping record without browse group");
1761                 return;
1762         }
1763
1764         sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
1765
1766         /* skip record without public browse group */
1767         if (!sdp_list_find(browse_list, &browse_uuid, sdp_uuid_cmp))
1768                 goto done;
1769
1770         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1771                 new_uuid = TRUE;
1772         else
1773                 new_uuid = FALSE;
1774
1775         adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1776                                                                 record_sort);
1777
1778         if (new_uuid) {
1779                 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1780                 add_uuid(adapter, &rec->svclass, svc_hint);
1781         }
1782
1783 done:
1784         sdp_list_free(browse_list, free);
1785 }
1786
1787 int adapter_service_add(struct btd_adapter *adapter, sdp_record_t *rec)
1788 {
1789         int ret;
1790
1791         /*
1792          * If the controller does not support BR/EDR operation,
1793          * there is no point in trying to add SDP records.
1794          */
1795         if (btd_opts.mode == BT_MODE_LE)
1796                 return -ENOTSUP;
1797
1798         DBG("%s", adapter->path);
1799
1800         ret = add_record_to_server(&adapter->bdaddr, rec);
1801         if (ret < 0)
1802                 return ret;
1803
1804         adapter_service_insert(adapter, rec);
1805
1806         return 0;
1807 }
1808
1809 void adapter_service_remove(struct btd_adapter *adapter, uint32_t handle)
1810 {
1811         sdp_record_t *rec;
1812         /*
1813          * If the controller does not support BR/EDR operation,
1814          * there is no point in trying to remote SDP records.
1815          */
1816         if (btd_opts.mode == BT_MODE_LE)
1817                 return;
1818
1819         DBG("%s", adapter->path);
1820
1821         rec = sdp_record_find(handle);
1822         if (!rec)
1823                 return;
1824
1825         adapter->services = sdp_list_remove(adapter->services, rec);
1826
1827         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1828                 remove_uuid(adapter, &rec->svclass);
1829
1830         remove_record_from_server(rec->handle);
1831 }
1832
1833 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1834 static void adapter_print_devices(struct btd_adapter *adapter)
1835 {
1836         GSList *dev;
1837
1838         dev = adapter->devices;
1839         for (; dev; dev = dev->next)
1840                 device_print_addr(dev->data);
1841 }
1842 #endif
1843
1844 static void adapter_add_device(struct btd_adapter *adapter,
1845                                                 struct btd_device *device);
1846
1847 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
1848                                                 const bdaddr_t *bdaddr,
1849                                                 uint8_t bdaddr_type)
1850 {
1851         struct btd_device *device;
1852
1853         device = device_create(adapter, bdaddr, bdaddr_type);
1854         if (!device)
1855                 return NULL;
1856
1857         adapter_add_device(adapter, device);
1858
1859 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1860         device_print_addr(device);
1861         DBG("devices list count : %d", g_slist_length(adapter->devices));
1862 #endif
1863
1864         return device;
1865 }
1866
1867 static void service_auth_cancel(struct service_auth *auth)
1868 {
1869         DBusError derr;
1870
1871         if (auth->svc_id > 0)
1872                 device_remove_svc_complete_callback(auth->device,
1873                                                                 auth->svc_id);
1874
1875         dbus_error_init(&derr);
1876         dbus_set_error_const(&derr, ERROR_INTERFACE ".Canceled", NULL);
1877
1878         auth->cb(&derr, auth->user_data);
1879
1880         dbus_error_free(&derr);
1881
1882         if (auth->agent != NULL) {
1883                 agent_cancel(auth->agent);
1884                 agent_unref(auth->agent);
1885         }
1886
1887         g_free(auth);
1888 }
1889
1890 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1891 void btd_adapter_unpair_device(struct btd_adapter *adapter,
1892                                 struct btd_device *dev)
1893 {
1894         DBG("+");
1895         GList *l;
1896
1897         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1898
1899 //      adapter->devices = g_slist_remove(adapter->devices, dev);
1900 //
1901 //      adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1902 //                                                                      dev);
1903
1904         adapter->connections = g_slist_remove(adapter->connections, dev);
1905
1906         if (adapter->connect_le == dev)
1907                 adapter->connect_le = NULL;
1908
1909         l = adapter->auths->head;
1910         while (l != NULL) {
1911                 struct service_auth *auth = l->data;
1912                 GList *next = g_list_next(l);
1913
1914                 if (auth->device != dev) {
1915                         l = next;
1916                         continue;
1917                 }
1918
1919                 g_queue_delete_link(adapter->auths, l);
1920                 l = next;
1921
1922                 service_auth_cancel(auth);
1923         }
1924
1925         device_unpair(dev, TRUE);
1926         DBG("-");
1927 }
1928 #endif
1929
1930 static void adapter_remove_device(struct btd_adapter *adapter,
1931                                                 struct btd_device *device);
1932
1933 void btd_adapter_remove_device(struct btd_adapter *adapter,
1934                                 struct btd_device *dev)
1935 {
1936         GList *l;
1937
1938         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1939
1940         adapter_remove_device(adapter, dev);
1941 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1942         btd_adv_monitor_device_remove(adapter->adv_monitor_manager, dev);
1943 #endif
1944         adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1945                                                                         dev);
1946
1947         adapter->connections = g_slist_remove(adapter->connections, dev);
1948
1949         if (adapter->connect_le == dev)
1950                 adapter->connect_le = NULL;
1951
1952         l = adapter->auths->head;
1953         while (l != NULL) {
1954                 struct service_auth *auth = l->data;
1955                 GList *next = g_list_next(l);
1956
1957                 if (auth->device != dev) {
1958                         l = next;
1959                         continue;
1960                 }
1961
1962                 g_queue_delete_link(adapter->auths, l);
1963                 l = next;
1964
1965                 service_auth_cancel(auth);
1966         }
1967
1968         device_remove(dev, TRUE);
1969 }
1970
1971 struct btd_device *btd_adapter_get_device(struct btd_adapter *adapter,
1972                                         const bdaddr_t *addr,
1973                                         uint8_t addr_type)
1974 {
1975         struct btd_device *device;
1976
1977         if (!adapter)
1978                 return NULL;
1979
1980 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1981         if (!bacmp(addr, BDADDR_ANY))
1982                 return NULL;
1983 #endif
1984
1985         device = btd_adapter_find_device(adapter, addr, addr_type);
1986         if (device)
1987                 return device;
1988
1989         return adapter_create_device(adapter, addr, addr_type);
1990 }
1991
1992 struct btd_device *btd_adapter_find_device_by_fd(int fd)
1993 {
1994         bdaddr_t src, dst;
1995         uint8_t dst_type;
1996         GIOChannel *io = NULL;
1997         GError *gerr = NULL;
1998         struct btd_adapter *adapter;
1999
2000         io = g_io_channel_unix_new(fd);
2001         if (!io)
2002                 return NULL;
2003
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,
2008                         BT_IO_OPT_INVALID);
2009         if (gerr) {
2010                 error("bt_io_get: %s", gerr->message);
2011                 g_error_free(gerr);
2012                 g_io_channel_unref(io);
2013                 return NULL;
2014         }
2015
2016         g_io_channel_unref(io);
2017
2018         adapter = adapter_find(&src);
2019         if (!adapter)
2020                 return NULL;
2021
2022         return btd_adapter_find_device(adapter, &dst, dst_type);
2023 }
2024
2025 sdp_list_t *btd_adapter_get_services(struct btd_adapter *adapter)
2026 {
2027         return adapter->services;
2028 }
2029
2030 static void passive_scanning_complete(uint8_t status, uint16_t length,
2031                                         const void *param, void *user_data)
2032 {
2033         struct btd_adapter *adapter = user_data;
2034         const struct mgmt_cp_start_discovery *rp = param;
2035
2036         DBG("status 0x%02x", status);
2037
2038         if (length < sizeof(*rp)) {
2039                 btd_error(adapter->dev_id,
2040                         "Wrong size of start scanning return parameters");
2041                 return;
2042         }
2043
2044         if (status == MGMT_STATUS_SUCCESS) {
2045                 adapter->discovery_type = rp->type;
2046                 adapter->discovery_enable = 0x01;
2047         }
2048 }
2049
2050 static bool passive_scanning_timeout(gpointer user_data)
2051 {
2052         struct btd_adapter *adapter = user_data;
2053         struct mgmt_cp_start_discovery cp;
2054
2055         adapter->passive_scan_timeout = 0;
2056
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);
2062 #else
2063         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2064                                 adapter->dev_id, sizeof(cp), &cp,
2065                                 passive_scanning_complete, adapter, NULL);
2066 #endif
2067         return FALSE;
2068 }
2069
2070 static void trigger_passive_scanning(struct btd_adapter *adapter)
2071 {
2072         if (!(adapter->current_settings & MGMT_SETTING_LE))
2073                 return;
2074
2075         DBG("");
2076
2077         if (adapter->passive_scan_timeout > 0) {
2078                 timeout_remove(adapter->passive_scan_timeout);
2079                 adapter->passive_scan_timeout = 0;
2080         }
2081
2082         /*
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.
2086          */
2087         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
2088                 return;
2089
2090         /*
2091          * If any client is running a discovery right now, then do not
2092          * even try to start passive scanning.
2093          *
2094          * The discovery procedure is using interleaved scanning and
2095          * thus will discover Low Energy devices as well.
2096          */
2097 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2098         if (adapter->discovery_list || adapter->le_discovery_list)
2099                 return;
2100 #else
2101         if (adapter->discovery_list)
2102                 return;
2103 #endif
2104
2105         if (adapter->discovery_enable == 0x01)
2106                 return;
2107
2108         /*
2109          * In case the discovery is suspended (for example for an ongoing
2110          * pairing attempt), then also do not start passive scanning.
2111          */
2112         if (adapter->discovery_suspended)
2113                 return;
2114
2115         /*
2116          * If the list of connectable Low Energy devices is empty,
2117          * then do not start passive scanning.
2118          */
2119         if (!adapter->connect_list)
2120                 return;
2121
2122         adapter->passive_scan_timeout = timeout_add_seconds(CONN_SCAN_TIMEOUT,
2123                                         passive_scanning_timeout, adapter,
2124                                         NULL);
2125 }
2126
2127 static void stop_passive_scanning_complete(uint8_t status, uint16_t length,
2128                                         const void *param, void *user_data)
2129 {
2130         struct btd_adapter *adapter = user_data;
2131         struct btd_device *dev;
2132         int err;
2133
2134         DBG("status 0x%02x (%s)", status, mgmt_errstr(status));
2135
2136         dev = adapter->connect_le;
2137         adapter->connect_le = NULL;
2138
2139         /*
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.
2143          */
2144         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
2145                 return;
2146
2147         /*
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().
2151          */
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));
2155                 return;
2156         }
2157
2158         adapter->discovery_type = 0x00;
2159         adapter->discovery_enable = 0x00;
2160
2161         if (!dev) {
2162                 DBG("Device removed while stopping passive scanning");
2163                 trigger_passive_scanning(adapter);
2164                 return;
2165         }
2166
2167         err = device_connect_le(dev);
2168         if (err < 0) {
2169                 btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
2170                                                         strerror(-err), -err);
2171                 trigger_passive_scanning(adapter);
2172         }
2173 }
2174
2175 static void stop_passive_scanning(struct btd_adapter *adapter)
2176 {
2177         struct mgmt_cp_stop_discovery cp;
2178 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2179         struct mgmt_cp_stop_discovery le_cp;
2180 #endif
2181
2182         DBG("");
2183
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)
2188                 return;
2189 #else
2190         if (adapter->discovery_list)
2191                 return;
2192 #endif
2193
2194         if (adapter->discovery_enable == 0x00)
2195                 return;
2196
2197 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2198         if ((adapter->discovery_type & 0x01) > 0) {
2199                 cp.type = 0x01;
2200                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2201                                 adapter->dev_id, sizeof(cp), &cp,
2202                                 stop_passive_scanning_complete, adapter, NULL);
2203         }
2204         if ((adapter->discovery_type & 0x06) > 0) {
2205                 le_cp.type = 0x06;
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);
2209         }
2210 #else
2211         cp.type = adapter->discovery_type;
2212
2213         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2214                         adapter->dev_id, sizeof(cp), &cp,
2215                         stop_passive_scanning_complete, adapter, NULL);
2216 #endif
2217 }
2218
2219 static void cancel_passive_scanning(struct btd_adapter *adapter)
2220 {
2221         if (!(adapter->current_settings & MGMT_SETTING_LE))
2222                 return;
2223
2224         DBG("");
2225
2226         if (adapter->passive_scan_timeout > 0) {
2227                 timeout_remove(adapter->passive_scan_timeout);
2228                 adapter->passive_scan_timeout = 0;
2229         }
2230 }
2231
2232 static uint8_t get_scan_type(struct btd_adapter *adapter)
2233 {
2234         uint8_t type;
2235
2236         if (adapter->current_settings & MGMT_SETTING_BREDR)
2237                 type = SCAN_TYPE_BREDR;
2238         else
2239                 type = 0;
2240
2241         if (adapter->current_settings & MGMT_SETTING_LE)
2242                 type |= SCAN_TYPE_LE;
2243
2244         return type;
2245 }
2246
2247 static void free_discovery_filter(struct discovery_filter *discovery_filter)
2248 {
2249         if (!discovery_filter)
2250                 return;
2251
2252         g_slist_free_full(discovery_filter->uuids, free);
2253         free(discovery_filter->pattern);
2254         g_free(discovery_filter);
2255 }
2256
2257 static void invalidate_rssi_and_tx_power(gpointer a)
2258 {
2259         struct btd_device *dev = a;
2260
2261         device_set_rssi(dev, 0);
2262         device_set_tx_power(dev, 127);
2263 }
2264
2265 static void discovery_cleanup(struct btd_adapter *adapter, int timeout)
2266 {
2267         GSList *l, *next;
2268
2269         adapter->discovery_type = 0x00;
2270
2271         if (adapter->discovery_idle_timeout > 0) {
2272                 timeout_remove(adapter->discovery_idle_timeout);
2273                 adapter->discovery_idle_timeout = 0;
2274         }
2275
2276         g_slist_free_full(adapter->discovery_found,
2277                                                 invalidate_rssi_and_tx_power);
2278         adapter->discovery_found = NULL;
2279
2280         if (!adapter->devices)
2281                 return;
2282
2283         for (l = adapter->devices; l != NULL; l = next) {
2284                 struct btd_device *dev = l->data;
2285
2286                 next = g_slist_next(l);
2287
2288 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2289         if (device_is_temporary(dev) && !device_is_connectable(dev)
2290                 && !btd_device_is_connected(dev))
2291 #else
2292         if (device_is_temporary(dev) && !device_is_connectable(dev))
2293 #endif
2294                 btd_adapter_remove_device(adapter, dev);
2295
2296         }
2297 }
2298
2299 static void discovery_free(void *user_data)
2300 {
2301         struct discovery_client *client = user_data;
2302         struct btd_adapter *adapter = client->adapter;
2303
2304 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2305         DBG("%p", client);
2306 #endif
2307         if (client->watch)
2308                 g_dbus_remove_watch(dbus_conn, client->watch);
2309
2310         if (client->discovery_filter) {
2311                 free_discovery_filter(client->discovery_filter);
2312                 client->discovery_filter = NULL;
2313         }
2314
2315         if (client->msg) {
2316                 if (client == adapter->client) {
2317                         g_dbus_send_message(dbus_conn,
2318                                                 btd_error_busy(client->msg));
2319                         adapter->client = NULL;
2320                 }
2321                 dbus_message_unref(client->msg);
2322         }
2323
2324         g_free(client->owner);
2325         g_free(client);
2326 }
2327
2328 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2329 static void discovery_remove(struct discovery_client *client, bool exit)
2330 #else
2331 static void discovery_remove(struct discovery_client *client)
2332 #endif
2333
2334 {
2335         struct btd_adapter *adapter = client->adapter;
2336
2337         DBG("owner %s", client->owner);
2338
2339         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2340                                                                 client);
2341
2342         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2343                                                                 client);
2344
2345 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2346         if (!exit && client->discovery_filter)
2347 #else
2348         if (adapter->client == client)
2349                 adapter->client = NULL;
2350
2351         if (client->watch && client->discovery_filter)
2352 #endif
2353                 adapter->set_filter_list = g_slist_prepend(
2354                                         adapter->set_filter_list, client);
2355         else
2356                 discovery_free(client);
2357
2358         /*
2359          * If there are other client discoveries in progress, then leave
2360          * it active. If not, then make sure to stop the restart timeout.
2361          */
2362         if (adapter->discovery_list)
2363                 return;
2364
2365         discovery_cleanup(adapter, TEMP_DEV_TIMEOUT);
2366 }
2367
2368 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay);
2369
2370 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2371 static void discovery_reply(struct discovery_client *client, uint8_t status)
2372 #else
2373 static struct discovery_client *discovery_complete(struct btd_adapter *adapter,
2374                                                 uint8_t status)
2375 #endif
2376 {
2377 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2378         struct discovery_client *client = adapter->client;
2379 #endif
2380         DBusMessage *reply;
2381 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2382
2383         if (!client)
2384                 return NULL;
2385
2386         adapter->client = NULL;
2387 #endif
2388
2389         if (!client->msg)
2390 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2391                 return;
2392 #else
2393                 return client;
2394 #endif
2395         if (!status) {
2396                 g_dbus_send_reply(dbus_conn, client->msg, DBUS_TYPE_INVALID);
2397         } else  {
2398                 reply = btd_error_busy(client->msg);
2399                 g_dbus_send_message(dbus_conn, reply);
2400         }
2401
2402         dbus_message_unref(client->msg);
2403         client->msg = NULL;
2404 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2405         return client;
2406 #endif
2407 }
2408
2409 static void start_discovery_complete(uint8_t status, uint16_t length,
2410                                         const void *param, void *user_data)
2411 {
2412         struct btd_adapter *adapter = user_data;
2413         struct discovery_client *client;
2414         const struct mgmt_cp_start_discovery *rp = param;
2415
2416         DBG("status 0x%02x", status);
2417
2418         /* Is there are no clients the discovery must have been stopped while
2419          * discovery command was pending.
2420          */
2421         if (!adapter->discovery_list) {
2422                 struct mgmt_cp_stop_discovery cp;
2423
2424                 if (status != MGMT_STATUS_SUCCESS)
2425                         return;
2426
2427                 /* Stop discovering as there are no clients left */
2428                 cp.type = rp->type;
2429                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2430                                         adapter->dev_id, sizeof(cp), &cp,
2431                                         NULL, NULL, NULL);
2432                 return;
2433         }
2434
2435         client = adapter->discovery_list->data;
2436
2437         if (length < sizeof(*rp)) {
2438                 btd_error(adapter->dev_id,
2439                         "Wrong size of start discovery return parameters");
2440                 if (client->msg)
2441                         goto fail;
2442                 return;
2443         }
2444
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;
2449 #else
2450                 adapter->discovery_type = rp->type;
2451 #endif
2452                 adapter->discovery_enable = 0x01;
2453
2454                 if (adapter->current_discovery_filter)
2455                         adapter->filtered_discovery = true;
2456                 else
2457                         adapter->filtered_discovery = false;
2458
2459 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2460                 discovery_reply(client, status);
2461 #else
2462                 discovery_complete(adapter, status);
2463 #endif
2464                 if (adapter->discovering)
2465                         return;
2466
2467                 adapter->discovering = true;
2468                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2469                                         ADAPTER_INTERFACE, "Discovering");
2470                 return;
2471 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2472         } else {
2473                 adapter->discovering = false;
2474                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2475                                         ADAPTER_INTERFACE, "Discovering");
2476 #endif
2477         }
2478
2479 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2480 fail:
2481         /* Reply with an error if the first discovery has failed */
2482         if (client->msg) {
2483                 discovery_reply(client, status);
2484                 discovery_remove(client, false);
2485 #else
2486         client = discovery_complete(adapter, status);
2487         if (client) {
2488                 discovery_remove(client);
2489 #endif
2490                 return;
2491         }
2492
2493         /*
2494          * In case the restart of the discovery failed, then just trigger
2495          * it for the next idle timeout again.
2496          */
2497 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2498         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
2499 #endif
2500 }
2501
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)
2505 {
2506         struct btd_adapter *adapter = user_data;
2507         const struct mgmt_cp_start_discovery *rp = param;
2508
2509         if (!rp) {
2510                 error("Error ocurred in LEDiscovering, rp is NULL");
2511                 return;
2512         }
2513
2514         DBG("status 0x%02x", status);
2515         if (length < sizeof(*rp)) {
2516                 error("Wrong size of start discovery return parameters");
2517                 return;
2518         }
2519
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;
2524
2525                 if (adapter->le_discovering)
2526                         return;
2527
2528                 adapter->le_discovering = true;
2529                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2530                                         ADAPTER_INTERFACE, "LEDiscovering");
2531
2532                 return;
2533         } else {
2534                 adapter->le_discovering = false;
2535                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2536                                         ADAPTER_INTERFACE, "LEDiscovering");
2537
2538         }
2539 }
2540 #endif
2541
2542 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2543 static bool start_le_discovery_timeout(gpointer user_data)
2544 {
2545         struct btd_adapter *adapter = user_data;
2546         uint8_t new_type;
2547
2548         DBG("");
2549
2550         adapter->le_discovery_idle_timeout = 0;
2551
2552         new_type = SCAN_TYPE_LE;
2553
2554         if (adapter->discovery_enable == 0x01) {
2555                 /*
2556                  * If there is an already running discovery and it has the
2557                  * same type, then just keep it.
2558                  */
2559
2560                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_LE) {
2561                         if (adapter->le_discovering)
2562                                 return FALSE;
2563
2564                         adapter->le_discovering = true;
2565                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2566                                         ADAPTER_INTERFACE, "LEDiscovering");
2567
2568                         return FALSE;
2569                 }
2570         }
2571
2572         struct mgmt_cp_start_discovery cp;
2573
2574         cp.type = new_type;
2575         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2576                         adapter->dev_id, sizeof(cp), &cp,
2577                         start_le_discovery_complete, adapter, NULL);
2578
2579         return FALSE;
2580 }
2581 #endif
2582
2583 static bool start_discovery_timeout(gpointer user_data)
2584 {
2585         struct btd_adapter *adapter = user_data;
2586 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2587         struct mgmt_cp_start_service_discovery *sd_cp;
2588 #endif
2589         uint8_t new_type;
2590
2591         DBG("");
2592
2593         adapter->discovery_idle_timeout = 0;
2594
2595 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2596         new_type = SCAN_TYPE_BREDR;
2597
2598         if (adapter->discovery_enable == 0x01) {
2599                 /*
2600                  * If there is an already running discovery and it has the
2601                  * same type, then just keep it.
2602                  */
2603                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_BREDR) {
2604                         if (adapter->discovering)
2605                                 return FALSE;
2606
2607                         adapter->discovering = true;
2608                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2609                                         ADAPTER_INTERFACE, "Discovering");
2610
2611                         return FALSE;
2612                 }
2613         }
2614
2615         struct mgmt_cp_start_discovery cp;
2616         cp.type = new_type;
2617         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2618                                         adapter->dev_id, sizeof(cp), &cp,
2619                                         start_discovery_complete, adapter,
2620                                         NULL);
2621
2622
2623 #else
2624         /* If we're doing filtered discovery, it must be quickly restarted */
2625         adapter->no_scan_restart_delay = !!adapter->current_discovery_filter;
2626
2627         DBG("adapter->current_discovery_filter == %d",
2628             !!adapter->current_discovery_filter);
2629
2630         new_type = get_scan_type(adapter);
2631
2632         if (adapter->discovery_enable == 0x01) {
2633                 struct mgmt_cp_stop_discovery cp;
2634
2635                 /*
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.
2639                  */
2640                 if (!adapter->current_discovery_filter &&
2641                     !adapter->filtered_discovery &&
2642                     adapter->discovery_type == new_type) {
2643                         if (adapter->discovering)
2644                                 return FALSE;
2645
2646                         adapter->discovering = true;
2647                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2648                                         ADAPTER_INTERFACE, "Discovering");
2649                         return FALSE;
2650                 }
2651
2652                 /*
2653                  * Otherwise the current discovery must be stopped. So
2654                  * queue up a stop discovery command.
2655                  *
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.
2659                  */
2660                 cp.type = adapter->discovery_type;
2661                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2662                                         adapter->dev_id, sizeof(cp), &cp,
2663                                         NULL, NULL, NULL);
2664
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
2668                  * care of that.
2669                  */
2670                 return FALSE;
2671
2672         }
2673
2674         /* Regular discovery is required */
2675         if (!adapter->current_discovery_filter) {
2676                 struct mgmt_cp_start_discovery cp;
2677
2678                 cp.type = new_type;
2679                 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2680                                         adapter->dev_id, sizeof(cp), &cp,
2681                                         start_discovery_complete, adapter,
2682                                         NULL);
2683
2684                 return FALSE;
2685         }
2686
2687         /* Filtered discovery is required */
2688         sd_cp = adapter->current_discovery_filter;
2689
2690         DBG("sending MGMT_OP_START_SERVICE_DISCOVERY %d, %d, %d",
2691                                 sd_cp->rssi, sd_cp->type,
2692                                 btohs(sd_cp->uuid_count));
2693
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);
2698
2699 #endif
2700
2701         return FALSE;
2702 }
2703
2704 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2705 static void trigger_start_le_discovery(struct btd_adapter *adapter, guint delay)
2706 {
2707
2708         DBG("");
2709
2710         cancel_passive_scanning(adapter);
2711
2712         if (adapter->le_discovery_idle_timeout > 0) {
2713                 g_source_remove(adapter->le_discovery_idle_timeout);
2714                 adapter->le_discovery_idle_timeout = 0;
2715         }
2716
2717         /*
2718          * If the controller got powered down in between, then ensure
2719          * that we do not keep trying to restart discovery.
2720          *
2721          * This is safe-guard and should actually never trigger.
2722          */
2723         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2724                 return;
2725
2726         adapter->le_discovery_idle_timeout = timeout_add_seconds(delay,
2727                                         start_le_discovery_timeout, adapter, NULL);
2728 }
2729 #endif
2730
2731 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
2732 {
2733
2734         DBG("");
2735
2736         cancel_passive_scanning(adapter);
2737
2738         if (adapter->discovery_idle_timeout > 0) {
2739                 timeout_remove(adapter->discovery_idle_timeout);
2740                 adapter->discovery_idle_timeout = 0;
2741         }
2742
2743         /*
2744          * If the controller got powered down in between, then ensure
2745          * that we do not keep trying to restart discovery.
2746          *
2747          * This is safe-guard and should actually never trigger.
2748          */
2749         if (!btd_adapter_get_powered(adapter))
2750                 return;
2751
2752         adapter->discovery_idle_timeout = timeout_add_seconds(delay,
2753                                         start_discovery_timeout, adapter, NULL);
2754 }
2755
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)
2759 {
2760         struct btd_adapter *adapter = user_data;
2761
2762         DBG("status 0x%02x", status);
2763
2764         if (status == MGMT_STATUS_SUCCESS) {
2765                 adapter->discovery_type = 0x00;
2766                 adapter->discovery_enable = 0x00;
2767                 return;
2768         }
2769 }
2770
2771 static void suspend_discovery(struct btd_adapter *adapter)
2772 {
2773         struct mgmt_cp_stop_discovery cp;
2774
2775         DBG("");
2776
2777         adapter->discovery_suspended = true;
2778
2779         /*
2780          * If there are no clients discovering right now, then there is
2781          * also nothing to suspend.
2782          */
2783         if (!adapter->discovery_list)
2784                 return;
2785
2786         /*
2787          * In case of being inside the idle phase, make sure to remove
2788          * the timeout to not trigger a restart.
2789          *
2790          * The restart will be triggered when the discovery is resumed.
2791          */
2792         if (adapter->discovery_idle_timeout > 0) {
2793                 timeout_remove(adapter->discovery_idle_timeout);
2794                 adapter->discovery_idle_timeout = 0;
2795         }
2796
2797         if (adapter->discovery_enable == 0x00)
2798                 return;
2799
2800         cp.type = adapter->discovery_type;
2801
2802         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2803                                 adapter->dev_id, sizeof(cp), &cp,
2804                                 suspend_discovery_complete, adapter, NULL);
2805 }
2806
2807 static void resume_discovery(struct btd_adapter *adapter)
2808 {
2809         DBG("");
2810
2811         adapter->discovery_suspended = false;
2812
2813         /*
2814          * If there are no clients discovering right now, then there is
2815          * also nothing to resume.
2816          */
2817         if (!adapter->discovery_list)
2818                 return;
2819
2820         /*
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.
2824          */
2825         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2826 }
2827 #endif
2828
2829 static void discovering_callback(uint16_t index, uint16_t length,
2830                                         const void *param, void *user_data)
2831 {
2832         const struct mgmt_ev_discovering *ev = param;
2833         struct btd_adapter *adapter = user_data;
2834
2835         if (length < sizeof(*ev)) {
2836                 btd_error(adapter->dev_id, "Too small discovering event");
2837                 return;
2838         }
2839
2840         DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
2841                                 ev->discovering, adapter->filtered_discovery);
2842
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;
2849                 } else {
2850                         hci_set_bit(BDADDR_BREDR, &adapter->discovery_type);
2851                         adapter->discovering = true;
2852                 }
2853                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2854                                         ADAPTER_INTERFACE, "Discovering");
2855
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);
2860
2861                         if (adapter->le_discovering == true) {
2862                                 if (adapter->le_discovery_list) {
2863                                         struct discovery_client *client;
2864
2865                                         client = adapter->le_discovery_list->data;
2866                                         g_dbus_remove_watch(dbus_conn, client->watch);
2867                                 }
2868
2869                                 adapter->le_discovering = false;
2870                         }
2871                 } else {
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;
2875                 }
2876
2877                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2878                                         ADAPTER_INTERFACE, "LEDiscovering");
2879         }
2880 #else
2881         if (adapter->discovery_enable == ev->discovering)
2882                 return;
2883
2884         adapter->discovery_type = ev->type;
2885         adapter->discovery_enable = ev->discovering;
2886 #endif
2887
2888         /*
2889          * Check for existing discoveries triggered by client applications
2890          * and ignore all others.
2891          *
2892          * If there are no clients, then it is good idea to trigger a
2893          * passive scanning attempt.
2894          */
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);
2899                 return;
2900         }
2901 #else
2902         if (!adapter->discovery_list) {
2903                 if (!adapter->connect_le)
2904                         trigger_passive_scanning(adapter);
2905                 return;
2906         }
2907 #endif
2908
2909         if (adapter->discovery_suspended)
2910                 return;
2911
2912         switch (adapter->discovery_enable) {
2913         case 0x00:
2914                 if (adapter->no_scan_restart_delay)
2915                         trigger_start_discovery(adapter, 0);
2916                 else
2917                         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2918                 break;
2919
2920         case 0x01:
2921                 if (adapter->discovery_idle_timeout > 0) {
2922                         timeout_remove(adapter->discovery_idle_timeout);
2923                         adapter->discovery_idle_timeout = 0;
2924                 }
2925
2926                 break;
2927         }
2928 }
2929
2930 static bool set_discovery_discoverable(struct btd_adapter *adapter, bool enable)
2931 {
2932         if (adapter->discovery_discoverable == enable)
2933                 return true;
2934
2935         /* Reset discoverable filter if already set */
2936         if (enable && (adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
2937                 return true;
2938
2939         adapter->discovery_discoverable = enable;
2940
2941         return set_discoverable(adapter, enable, 0);
2942 }
2943
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)
2947 {
2948         struct discovery_client *client = user_data;
2949         struct btd_adapter *adapter = client->adapter;
2950         DBusMessage *reply;
2951
2952         DBG("status 0x%02x", status);
2953
2954         if (status != MGMT_STATUS_SUCCESS) {
2955                 if (client->msg) {
2956                         reply = btd_error_busy(client->msg);
2957                         g_dbus_send_message(dbus_conn, reply);
2958                 }
2959
2960                 goto done;
2961         }
2962
2963         if (client->msg) {
2964                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2965                 g_dbus_send_message(dbus_conn, reply);
2966         }
2967
2968         adapter->discovery_type &= (~0x01);
2969         DBG("Discovery Type 0x%02x", adapter->discovery_type);
2970
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");
2976
2977         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2978                 adapter->discovery_enable = 0x00;
2979                 trigger_passive_scanning(adapter);
2980         }
2981
2982 done:
2983         discovery_remove(client, false);
2984 }
2985
2986 static void stop_le_discovery_complete(uint8_t status, uint16_t length,
2987                                         const void *param, void *user_data)
2988 {
2989         struct btd_adapter *adapter = user_data;
2990         struct discovery_client *client;
2991         DBusMessage *reply;
2992
2993         DBG("status 0x%02x", status);
2994
2995         /* Is there are no clients the discovery must have been stopped while
2996           * discovery command was pending.
2997           */
2998         if (!adapter->le_discovery_list)
2999                 return;
3000
3001         client = adapter->le_discovery_list->data;
3002
3003         if (status != MGMT_STATUS_SUCCESS) {
3004                 if (client->msg) {
3005                         reply = btd_error_busy(client->msg);
3006                         g_dbus_send_message(dbus_conn, reply);
3007                 }
3008
3009                 goto done;
3010         }
3011
3012         if (client->msg) {
3013                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
3014                 g_dbus_send_message(dbus_conn, reply);
3015         }
3016
3017         adapter->discovery_type &= (~0x06);
3018         DBG("Discovery Type 0x%02x", adapter->discovery_type);
3019
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");
3025
3026         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
3027                 adapter->discovery_enable = 0x00;
3028                 trigger_passive_scanning(adapter);
3029         }
3030
3031 done:
3032         /*
3033          * The destroy function will cleanup the client information and
3034          * also remove it from the list of discovery clients.
3035          */
3036         g_dbus_remove_watch(dbus_conn, client->watch);
3037 }
3038 #else
3039
3040 static void stop_discovery_complete(uint8_t status, uint16_t length,
3041                                         const void *param, void *user_data)
3042 {
3043         struct btd_adapter *adapter = user_data;
3044         struct discovery_client *client;
3045
3046         DBG("status 0x%02x", status);
3047
3048         client = discovery_complete(adapter, status);
3049         if (client)
3050                 discovery_remove(client);
3051
3052         if (status != MGMT_STATUS_SUCCESS)
3053                 return;
3054
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");
3062
3063         trigger_passive_scanning(adapter);
3064 }
3065 #endif
3066
3067 static int compare_sender(gconstpointer a, gconstpointer b)
3068 {
3069         const struct discovery_client *client = a;
3070         const char *sender = b;
3071
3072         return g_strcmp0(client->owner, sender);
3073 }
3074
3075 static gint g_strcmp(gconstpointer a, gconstpointer b)
3076 {
3077         return strcmp(a, b);
3078 }
3079
3080 static void extract_unique_uuids(gpointer data, gpointer user_data)
3081 {
3082         char *uuid_str = data;
3083         GSList **uuids = user_data;
3084
3085         if (!g_slist_find_custom(*uuids, uuid_str, g_strcmp))
3086                 *uuids = g_slist_insert_sorted(*uuids, uuid_str, g_strcmp);
3087 }
3088
3089 /*
3090  * This method merges all adapter filters into rssi, transport and uuids.
3091  * Returns 1 if there was no filtered scan, 0 otherwise.
3092  */
3093 static int merge_discovery_filters(struct btd_adapter *adapter, int *rssi,
3094                                         uint8_t *transport, GSList **uuids)
3095 {
3096         GSList *l;
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);
3101
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;
3105
3106                 if (!item) {
3107                         has_regular_discovery = true;
3108                         continue;
3109                 }
3110
3111                 /*
3112                  * Detect empty filter with only discoverable
3113                  * (which does not require a kernel filter) set.
3114                  */
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;
3122                         continue;
3123                 }
3124
3125                 has_filtered_discovery = true;
3126
3127                 *transport |= item->type;
3128
3129                 /*
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.
3138                  */
3139                 if (item->rssi == DISTANCE_VAL_INVALID)
3140                         *rssi = HCI_RSSI_INVALID;
3141                 else if (*rssi != HCI_RSSI_INVALID && *rssi >= item->rssi)
3142                         *rssi = item->rssi;
3143                 else if (item->pathloss != DISTANCE_VAL_INVALID)
3144                         *rssi = HCI_RSSI_INVALID;
3145
3146                 if (!g_slist_length(item->uuids))
3147                         empty_uuid = true;
3148
3149                 g_slist_foreach(item->uuids, extract_unique_uuids, uuids);
3150         }
3151
3152         /* If no proximity filtering is set, disable it */
3153         if (*rssi == DISTANCE_VAL_INVALID)
3154                 *rssi = HCI_RSSI_INVALID;
3155
3156         /*
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.
3160          */
3161         if (empty_uuid) {
3162                 g_slist_free(*uuids);
3163                 *uuids = NULL;
3164         }
3165
3166         if (has_regular_discovery) {
3167                 if (!has_filtered_discovery)
3168                         return 1;
3169
3170                 /*
3171                  * It there is both regular and filtered scan running, then
3172                  * clear whole fitler to report all devices.
3173                  */
3174                 *transport = adapter_scan_type;
3175                 *rssi = HCI_RSSI_INVALID;
3176                 g_slist_free(*uuids);
3177                 *uuids = NULL;
3178         }
3179
3180         return 0;
3181 }
3182
3183 static void populate_mgmt_filter_uuids(uint8_t (*mgmt_uuids)[16], GSList *uuids)
3184 {
3185         GSList *l;
3186
3187         for (l = uuids; l != NULL; l = g_slist_next(l)) {
3188                 bt_uuid_t uuid, u128;
3189                 uint128_t uint128;
3190
3191                 bt_string_to_uuid(&uuid, l->data);
3192                 bt_uuid_to_uuid128(&uuid, &u128);
3193
3194                 ntoh128((uint128_t *) u128.value.u128.data, &uint128);
3195                 htob128(&uint128, (uint128_t *) mgmt_uuids);
3196
3197                 mgmt_uuids++;
3198         }
3199 }
3200
3201 /*
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
3205  */
3206 static int discovery_filter_to_mgmt_cp(struct btd_adapter *adapter,
3207                        struct mgmt_cp_start_service_discovery **cp_ptr)
3208 {
3209         GSList *uuids = NULL;
3210         struct mgmt_cp_start_service_discovery *cp;
3211         int rssi = DISTANCE_VAL_INVALID;
3212         int uuid_count;
3213         uint8_t discovery_type = 0;
3214
3215         DBG("");
3216
3217         if (merge_discovery_filters(adapter, &rssi, &discovery_type, &uuids)) {
3218                 /* There are only regular scans, run just regular scan. */
3219                 *cp_ptr = NULL;
3220                 return 0;
3221         }
3222
3223         uuid_count = g_slist_length(uuids);
3224
3225         cp = g_try_malloc(sizeof(*cp) + 16*uuid_count);
3226         *cp_ptr = cp;
3227         if (!cp) {
3228                 g_slist_free(uuids);
3229                 return -1;
3230         }
3231
3232         cp->type = discovery_type;
3233         cp->rssi = rssi;
3234         cp->uuid_count = htobs(uuid_count);
3235         populate_mgmt_filter_uuids(cp->uuids, uuids);
3236
3237         g_slist_free(uuids);
3238         return 0;
3239 }
3240
3241 static bool filters_equal(struct mgmt_cp_start_service_discovery *a,
3242                    struct mgmt_cp_start_service_discovery *b) {
3243         if (!a && !b)
3244                 return true;
3245
3246         if ((!a && b) || (a && !b))
3247                 return false;
3248
3249         if (a->type != b->type)
3250                 return false;
3251
3252         if (a->rssi != b->rssi)
3253                 return false;
3254
3255         /*
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.
3259          */
3260         if (a->uuid_count != b->uuid_count)
3261                 return false;
3262
3263         if (memcmp(a->uuids, b->uuids, 16 * a->uuid_count) != 0)
3264                 return false;
3265
3266         return true;
3267 }
3268
3269 static int update_discovery_filter(struct btd_adapter *adapter)
3270 {
3271         struct mgmt_cp_start_service_discovery *sd_cp;
3272
3273         DBG("");
3274
3275         if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
3276                 btd_error(adapter->dev_id,
3277                                 "discovery_filter_to_mgmt_cp returned error");
3278                 return -ENOMEM;
3279         }
3280
3281         /* Only attempt to overwrite current discoverable setting when not
3282          * discoverable.
3283          */
3284         if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE)) {
3285                 GSList *l;
3286
3287                 for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
3288                         struct discovery_client *client = l->data;
3289
3290                         if (!client->discovery_filter)
3291                                 continue;
3292
3293                         if (client->discovery_filter->discoverable) {
3294                                 set_discovery_discoverable(adapter, true);
3295                                 break;
3296                         }
3297                 }
3298         }
3299
3300         /*
3301          * If filters are equal, then don't update scan, except for when
3302          * starting discovery.
3303          */
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.");
3307                 g_free(sd_cp);
3308                 return 0;
3309         }
3310
3311         g_free(adapter->current_discovery_filter);
3312         adapter->current_discovery_filter = sd_cp;
3313
3314         trigger_start_discovery(adapter, 0);
3315
3316         return -EINPROGRESS;
3317 }
3318
3319 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3320 static int discovery_stop(struct discovery_client *client, bool exit)
3321 #else
3322 static int discovery_stop(struct discovery_client *client)
3323 #endif
3324 {
3325         struct btd_adapter *adapter = client->adapter;
3326         struct mgmt_cp_stop_discovery cp;
3327
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);
3332 #else
3333                 discovery_remove(client);
3334 #endif
3335                 update_discovery_filter(adapter);
3336                 return 0;
3337         }
3338
3339         set_discovery_discoverable(adapter, false);
3340
3341         /*
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.
3344          */
3345         if (adapter->discovery_enable == 0x00) {
3346 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3347                 discovery_remove(client, exit);
3348 #else
3349                 discovery_remove(client);
3350 #endif
3351                 adapter->discovering = false;
3352                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3353                                 ADAPTER_INTERFACE, "Discovering");
3354
3355                 trigger_passive_scanning(adapter);
3356
3357                 return 0;
3358         }
3359 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3360         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3361 #endif
3362         cp.type = adapter->discovery_type;
3363 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
3364         adapter->client = client;
3365 #endif
3366 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3367         cp.type = 0x01;
3368 #endif
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);
3373 #else
3374                         stop_discovery_complete, adapter, NULL);
3375 #endif
3376
3377         return -EINPROGRESS;
3378 }
3379
3380 static void discovery_destroy(void *user_data)
3381 {
3382         struct discovery_client *client = user_data;
3383         struct btd_adapter *adapter = client->adapter;
3384
3385         DBG("owner %s", client->owner);
3386
3387         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
3388                                                                 client);
3389
3390         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
3391                                                                 client);
3392
3393         if (client->discovery_filter) {
3394                 free_discovery_filter(client->discovery_filter);
3395                 client->discovery_filter = NULL;
3396         }
3397
3398         g_free(client->owner);
3399         g_free(client);
3400
3401         /*
3402          * If there are other client discoveries in progress, then leave
3403          * it active. If not, then make sure to stop the restart timeout.
3404          */
3405         if (adapter->discovery_list)
3406                 return;
3407
3408 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3409         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
3410 #else
3411         adapter->discovery_type = 0x00;
3412 #endif
3413
3414         discovery_cleanup(adapter, 0);
3415
3416 }
3417
3418 static void discovery_disconnect(DBusConnection *conn, void *user_data)
3419 {
3420         struct discovery_client *client = user_data;
3421
3422         DBG("owner %s", client->owner);
3423 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3424         discovery_stop(client, true);
3425 #else
3426         client->watch = 0;
3427
3428         discovery_stop(client);
3429 #endif
3430 }
3431
3432 /*
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.
3435  */
3436 static bool get_discovery_client(struct btd_adapter *adapter,
3437                                                 const char *owner,
3438                                                 struct discovery_client **client)
3439 {
3440         GSList *list = g_slist_find_custom(adapter->discovery_list, owner,
3441                                                                 compare_sender);
3442         if (list) {
3443                 *client = list->data;
3444                 return true;
3445         }
3446
3447         list = g_slist_find_custom(adapter->set_filter_list, owner,
3448                                                                 compare_sender);
3449         if (list) {
3450                 *client = list->data;
3451                 return false;
3452         }
3453
3454         *client = NULL;
3455         return false;
3456 }
3457
3458 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3459 static void le_discovery_destroy(void *user_data)
3460 {
3461         struct discovery_client *client = user_data;
3462         struct btd_adapter *adapter = client->adapter;
3463
3464         DBG("owner %s", client->owner);
3465
3466         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3467                                                                 client);
3468
3469         g_free(client->owner);
3470         g_free(client);
3471
3472         /*
3473          * If there are other client discoveries in progress, then leave
3474          * it active. If not, then make sure to stop the restart timeout.
3475          */
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)
3479                 return;
3480
3481         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
3482         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
3483
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;
3488         }
3489
3490         discovery_cleanup(adapter, 0);
3491 }
3492
3493 static void le_discovery_disconnect(DBusConnection *conn, void *user_data)
3494 {
3495         struct discovery_client *client = user_data;
3496         struct btd_adapter *adapter = client->adapter;
3497         struct mgmt_cp_stop_le_discovery cp;
3498
3499         DBG("owner %s", client->owner);
3500
3501         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3502                                                                 client);
3503
3504         /*
3505          * There is no need for extra cleanup of the client since that
3506          * will be done by the destroy callback.
3507          *
3508          * However in case this is the last client, the discovery in
3509          * the kernel needs to be disabled.
3510          */
3511         if (adapter->le_discovery_list)
3512                 return;
3513
3514         /*
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.
3517          */
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");
3522
3523                 if (adapter->discovering == false  && adapter->le_discovering == false) {
3524                         trigger_passive_scanning(adapter);
3525                         return;
3526                 }
3527         }
3528
3529         cp.type = 0x06;
3530
3531         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
3532                                 adapter->dev_id, sizeof(cp), &cp,
3533                                 stop_le_discovery_complete, adapter, NULL);
3534 }
3535
3536 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
3537 static void addr_filter_params_free(gpointer data)
3538 {
3539         adapter_le_address_filter_params_t *params = data;
3540
3541         g_free(params);
3542 }
3543
3544 static void uuid_filter_params_free(gpointer data)
3545 {
3546         adapter_le_uuid_params_t *params = data;
3547
3548         g_free((char *)params->uuid);
3549         g_free((char *)params->uuid_mask);
3550         g_free(params);
3551 }
3552
3553 static void manufacturer_filter_params_free(gpointer data)
3554 {
3555         adapter_le_manf_data_params_t *params = data;
3556
3557         g_free((char *)params->man_data);
3558         g_free((char *)params->man_data_mask);
3559         g_free(params);
3560 }
3561
3562 static void local_name_filter_params_free(gpointer data)
3563 {
3564         adapter_le_local_name_params_t *params = data;
3565
3566         g_free((char *)params->local_name);
3567         g_free(params);
3568 }
3569
3570 static void service_data_filter_params_free(gpointer data)
3571 {
3572         adapter_le_service_data_params_t *params = data;
3573
3574         g_free((char *)params->service_data);
3575         g_free((char *)params->service_data_mask);
3576         g_free(params);
3577 }
3578
3579 static void scan_filter_params_free(gpointer data)
3580 {
3581         adapter_le_scan_filter_param_t *params = data;
3582         g_free(params);
3583 }
3584
3585 int adapter_le_address_cmp(gconstpointer a, gconstpointer b)
3586 {
3587         const adapter_le_address_filter_params_t *params = a;
3588         const char *address = b;
3589         char addr[18];
3590
3591         ba2str(&params->broadcaster_addr, addr);
3592         return strcasecmp(addr, address);
3593 }
3594
3595 int adapter_le_uuid_cmp(gconstpointer a, gconstpointer b)
3596 {
3597         const adapter_le_uuid_params_t *params = a;
3598         const char *uuid = b;
3599
3600         return strcasecmp((const char *)params->uuid, uuid);
3601 }
3602
3603 int adapter_le_manufacturer_data_cmp(gconstpointer a, gconstpointer b)
3604 {
3605         const adapter_le_manf_data_params_t *params = a;
3606         const struct eir_msd *msd = b;
3607
3608         if (msd->company == params->company_id) {
3609                 /* if the advertisiement packet is an iBeacon */
3610                 if (msd->company == COMPANY_ID_APPLE)
3611                         return 0;
3612                 return strncasecmp((const char *)params->man_data,
3613                                                 (const char *)msd->data,
3614                                                 params->man_data_len);
3615         } else {
3616                 return -1;
3617         }
3618 }
3619
3620 int adapter_le_local_name_cmp(gconstpointer a, gconstpointer b)
3621 {
3622         const adapter_le_local_name_params_t *params = a;
3623         const char *name = b;
3624
3625         return strcasecmp(params->local_name, name);
3626 }
3627
3628 int adapter_le_service_data_cmp(gconstpointer a, gconstpointer b)
3629 {
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,
3636                                         sd->data_len);
3637 }
3638
3639 int adapter_le_address_filter_index_cmp(gconstpointer a, gconstpointer b)
3640 {
3641         const adapter_le_address_filter_params_t *params = a;
3642         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3643
3644         return params->filter_index - filter_inex;
3645 }
3646
3647 int adapter_le_uuid_filter_index_cmp(gconstpointer a, gconstpointer b)
3648 {
3649         const adapter_le_uuid_params_t *params = a;
3650         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3651
3652         return params->filter_index - filter_inex;
3653 }
3654
3655 int adapter_le_manufacturer_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3656 {
3657         const adapter_le_manf_data_params_t *params = a;
3658         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3659
3660         return params->filter_index - filter_inex;
3661 }
3662
3663 int adapter_le_local_name_filter_index_cmp(gconstpointer a, gconstpointer b)
3664 {
3665         const adapter_le_local_name_params_t *params = a;
3666         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3667
3668         return params->filter_index - filter_inex;
3669 }
3670
3671 int adapter_le_service_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3672 {
3673         const adapter_le_service_data_params_t *params = a;
3674         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3675
3676         return params->filter_index - filter_inex;
3677 }
3678
3679 int adapter_le_scan_params_filter_index_cmp(gconstpointer a, gconstpointer b)
3680 {
3681         const adapter_le_scan_filter_param_t *params = a;
3682         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3683
3684         return params->index - filter_inex;
3685 }
3686
3687 static gboolean adapter_le_clear_platform_scan_filter_data(
3688                         struct btd_adapter *adapter, int filter_index)
3689 {
3690         DBG("");
3691         GSList *list;
3692         if (!adapter)
3693                 return FALSE;
3694
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);
3700         }
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);
3706         }
3707
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);
3713         }
3714
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);
3720         }
3721
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);
3727         }
3728
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);
3734         }
3735
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);
3741         }
3742
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);
3748         }
3749
3750         return TRUE;
3751 }
3752
3753 static gboolean adapter_le_enable_platform_scan_filtering(
3754                         struct btd_adapter *adapter, gboolean enable)
3755 {
3756         if (!adapter)
3757                 return FALSE;
3758
3759         DBG("Platform scan filtering enable[%d]", enable);
3760
3761         adapter->scan_filter_support = enable;
3762
3763         return TRUE;
3764 }
3765
3766
3767 static gboolean adapter_le_service_add_addr_scan_filter_data(struct btd_adapter *adapter,
3768                                                 int filter_index, gchar *string, int addr_type)
3769 {
3770         /* TYPE_DEVICE_ADDRESS */
3771         adapter_le_address_filter_params_t *params;
3772
3773         DBG("");
3774
3775         params = g_new0(adapter_le_address_filter_params_t, 1);
3776         if (!params)
3777                 return FALSE;
3778
3779         params->filter_index = filter_index;
3780         str2ba(string, &params->broadcaster_addr);
3781         params->bdaddr_type = addr_type;
3782
3783         /* Store the struct to list */
3784         adapter->addr_filters = g_slist_append(adapter->addr_filters, params);
3785         return TRUE;
3786 }
3787
3788 static const char *adapter_le_service_find_addr_scan_filter_data(
3789                                                 struct btd_adapter *adapter, gchar *string)
3790 {
3791         GSList *list;
3792         DBG("");
3793
3794         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3795         if (!list)
3796                 return NULL;
3797         else
3798                 return list->data;
3799
3800         return NULL;
3801 }
3802
3803 static gboolean adapter_le_service_delete_addr_scan_filter_data(struct btd_adapter *adapter,
3804                                                 int filter_index, gchar *string, int addr_type)
3805 {
3806         GSList *list;
3807         DBG("");
3808
3809         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3810         if (!list)
3811                 return FALSE;
3812         else
3813                 /* Delete info from the struct to list */
3814                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3815
3816         return TRUE;
3817 }
3818
3819 static gboolean adapter_le_service_clear_addr_scan_filter_data(struct btd_adapter *adapter)
3820 {
3821         DBG("");
3822
3823         g_slist_free_full(adapter->addr_filters, addr_filter_params_free);
3824         adapter->addr_filters = NULL;
3825
3826         return TRUE;
3827 }
3828
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)
3832 {
3833
3834         adapter_le_uuid_params_t *params;
3835         bt_uuid_t uuid;
3836
3837         DBG("");
3838
3839         params = g_new0(adapter_le_uuid_params_t, 1);
3840         if (!params)
3841                 return FALSE;
3842
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));
3849         } else {
3850                 sdp_uuid128_create((uuid_t *)&uuid, p_uuid);
3851         }
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;
3857
3858         /* Store the struct to list */
3859         adapter->solicit_data_filters = g_slist_append(adapter->solicit_data_filters, params);
3860
3861         return TRUE;
3862 }
3863
3864 static adapter_le_uuid_params_t *adapter_le_service_find_uuid_scan_filter_data(struct btd_adapter *adapter,
3865                                                         uint8_t *p_uuid)
3866 {
3867         GSList *list;
3868         DBG("");
3869
3870         list = g_slist_find_custom(adapter->solicit_data_filters, p_uuid, adapter_le_uuid_cmp);
3871         if (!list)
3872                 return NULL;
3873         else
3874                 /* Delete info from the struct to list */
3875                 return list->data;
3876
3877         return NULL;
3878 }
3879
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)
3883 {
3884         GSList *list;
3885         DBG("");
3886
3887         list = g_slist_find_custom(adapter->solicit_data_filters, GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3888         if (!list)
3889                 return FALSE;
3890         else {
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);
3895                 }
3896         }
3897
3898         return TRUE;
3899 }
3900
3901 static gboolean adapter_le_service_clear_uuid_scan_filter_data(struct btd_adapter *adapter)
3902 {
3903         DBG("");
3904
3905         g_slist_free_full(adapter->solicit_data_filters, uuid_filter_params_free);
3906         adapter->solicit_data_filters = NULL;
3907
3908         return TRUE;
3909 }
3910
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)
3914 {
3915
3916         adapter_le_manf_data_params_t *params;
3917
3918         DBG("");
3919
3920         params = g_new0(adapter_le_manf_data_params_t, 1);
3921         if (!params)
3922                 return FALSE;
3923
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;
3932
3933         /* Store the struct to list */
3934         adapter->manufaturer_data_filters = g_slist_append(adapter->manufaturer_data_filters, params);
3935
3936         return TRUE;
3937 }
3938
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)
3941 {
3942         GSList *list;
3943         DBG("");
3944         list = g_slist_find_custom(adapter->manufaturer_data_filters, msd, adapter_le_manufacturer_data_cmp);
3945         if (!list)
3946                 return NULL;
3947         else
3948                 return list->data;
3949
3950         return NULL;
3951 }
3952
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)
3956 {
3957         GSList *list;
3958         DBG("");
3959         list = g_slist_find_custom(adapter->manufaturer_data_filters, GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3960         if (!list)
3961                 return FALSE;
3962         else {
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);
3967                 }
3968         }
3969
3970         return TRUE;
3971 }
3972
3973 static gboolean adapter_le_service_clear_manufacturer_scan_filter_data(struct btd_adapter *adapter)
3974 {
3975         DBG("");
3976
3977         g_slist_free_full(adapter->manufaturer_data_filters, manufacturer_filter_params_free);
3978         adapter->manufaturer_data_filters = NULL;
3979
3980         return TRUE;
3981 }
3982
3983 static gboolean adapter_le_service_add_local_name_scan_filter_data(struct btd_adapter *adapter,
3984                                                                                         int filter_index, gchar *name)
3985 {
3986
3987         adapter_le_local_name_params_t *params;
3988
3989         DBG("");
3990
3991         params = g_new0(adapter_le_local_name_params_t, 1);
3992         if (!params)
3993                 return FALSE;
3994
3995         params->filter_index = filter_index;
3996         params->local_name = g_strdup(name);
3997         params->name_len = strlen(name);
3998
3999         /* Store the struct to list */
4000         adapter->local_name_filters = g_slist_append(adapter->local_name_filters, params);
4001
4002         return TRUE;
4003 }
4004
4005 static adapter_le_local_name_params_t *adapter_le_service_find_local_name_scan_filter_data(
4006                                                                                                 struct btd_adapter *adapter,
4007                                                                                                 gchar *name)
4008 {
4009         GSList *list;
4010         DBG("");
4011         list = g_slist_find_custom(adapter->local_name_filters, name, adapter_le_local_name_cmp);
4012         if (!list)
4013                 return NULL;
4014         else
4015                 return list->data;
4016
4017         return NULL;
4018 }
4019
4020 static gboolean adapter_le_service_delete_local_name_scan_filter_data(struct btd_adapter *adapter,
4021                                                                                                 int filter_index, gchar *name)
4022 {
4023         GSList *list;
4024         DBG("");
4025         list = g_slist_find_custom(adapter->local_name_filters, GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
4026         if (!list)
4027                 return FALSE;
4028         else {
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);
4033                 }
4034         }
4035
4036         return TRUE;
4037 }
4038
4039 static gboolean adapter_le_service_clear_local_name_scan_filter_data(struct btd_adapter *adapter)
4040 {
4041         DBG("");
4042
4043         g_slist_free_full(adapter->local_name_filters, local_name_filter_params_free);
4044         adapter->local_name_filters = NULL;
4045
4046         return TRUE;
4047 }
4048
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)
4051 {
4052         adapter_le_service_data_params_t *params;
4053
4054         DBG("");
4055
4056         params = g_new0(adapter_le_service_data_params_t, 1);
4057         if (!params)
4058                 return FALSE;
4059
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;
4066
4067         /* Store the struct to list */
4068         adapter->service_data_filters = g_slist_append(adapter->service_data_filters, params);
4069
4070         return TRUE;
4071 }
4072
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)
4075 {
4076         GSList *list;
4077         DBG("");
4078
4079         list = g_slist_find_custom(adapter->service_data_filters, sd, adapter_le_service_data_cmp);
4080         if (!list)
4081                 return NULL;
4082         else
4083                 return list->data;
4084
4085         return NULL;
4086 }
4087
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)
4090 {
4091         GSList *list;
4092         DBG("");
4093
4094         list = g_slist_find_custom(adapter->service_data_filters, GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
4095         if (!list)
4096                 return FALSE;
4097         else {
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);
4102                 }
4103         }
4104         return TRUE;
4105 }
4106
4107 static gboolean adapter_le_service_clear_service_scan_filter_data(struct btd_adapter *adapter)
4108 {
4109         DBG("");
4110
4111         g_slist_free_full(adapter->service_data_filters, service_data_filter_params_free);
4112         adapter->service_data_filters = NULL;
4113
4114         return TRUE;
4115 }
4116
4117 static gboolean adapter_le_service_add_scan_filter_params(struct btd_adapter *adapter,
4118                                                         adapter_le_scan_filter_param_t *params)
4119 {
4120         adapter_le_scan_filter_param_t *l_params;
4121
4122         DBG("");
4123
4124         l_params = g_new0(adapter_le_scan_filter_param_t, 1);
4125         if (!l_params)
4126                 return FALSE;
4127
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;
4138
4139         /* Store the struct to list */
4140         adapter->scan_params = g_slist_append(adapter->scan_params, l_params);
4141
4142         return TRUE;
4143 }
4144
4145 static adapter_le_scan_filter_param_t *adapter_le_service_find_scan_filter_params(
4146                                                         struct btd_adapter *adapter, int filter_index)
4147 {
4148         GSList *list;
4149         DBG("");
4150
4151         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
4152         if (!list)
4153                 return NULL;
4154         else
4155                 return list->data;
4156
4157         return NULL;
4158 }
4159
4160 static gboolean adapter_le_service_delete_scan_filter_params(struct btd_adapter *adapter,
4161                                                         adapter_le_scan_filter_param_t *params)
4162 {
4163         GSList *list;
4164         DBG("");
4165
4166         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(params->index), adapter_le_scan_params_filter_index_cmp);
4167         if (!list)
4168                 return FALSE;
4169         else
4170                 adapter->scan_params = g_slist_remove(adapter->scan_params, list);
4171
4172         return TRUE;
4173 }
4174
4175 static gboolean adapter_le_service_clear_scan_filter_params(struct btd_adapter *adapter)
4176 {
4177         DBG("");
4178
4179         g_slist_free_full(adapter->scan_params, scan_filter_params_free);
4180         adapter->scan_params = NULL;
4181
4182         return TRUE;
4183 }
4184
4185 int adapter_byte_arr_cmp_with_mask(const char *data1, const char *data2,
4186         const char *mask, int data_len)
4187 {
4188         int i;
4189         char a, b;
4190         if (data1 == NULL || data2 == NULL || mask == NULL)
4191                 return -1;
4192         for (i = 0; i < data_len; i++) {
4193                 a = data1[i] & mask[i];
4194                 b = data2[i] & mask[i];
4195                 if (a != b)
4196                         return (int)(a - b);
4197         }
4198         return 0;
4199 }
4200
4201 static uint8_t validate_for_filter_policy(struct btd_adapter *adapter,
4202                                                                 const struct eir_data *eir, gchar *addr)
4203 {
4204         uint8_t allow_report = NONE_REPORT;
4205
4206         if (adapter->scan_filter_support == FALSE)
4207                 allow_report = SCAN_REPORT;
4208         else {
4209                 if (adapter_le_service_find_addr_scan_filter_data(adapter, addr))
4210                         allow_report = SCAN_REPORT;
4211                 if (eir->name) {
4212                         if(adapter_le_service_find_local_name_scan_filter_data(adapter, eir->name))
4213                                 allow_report = SCAN_REPORT;
4214                         }
4215                 if (eir->sd_list) {
4216                         GSList *list = NULL;
4217                         for (list = eir->sd_list; list != NULL; list = g_slist_next(list)) {
4218                                 struct eir_sd *sd = list->data;
4219                                 if (sd != NULL) {
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;
4234                                                 }
4235                                         }
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;
4245                                                 }
4246                                         }
4247                                         if (allow_report)
4248                                                 break;
4249                                 }
4250                         }
4251                 }
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;
4256                                 if (msd != NULL) {
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,
4260                                                         msd);
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;
4270                                                 }
4271                                                 if (msd->company == COMPANY_ID_APPLE)
4272                                                         allow_report = IBEACON_REPORT;
4273                                         }
4274                                 }
4275                         }
4276                 }
4277         }
4278         return allow_report;
4279 }
4280
4281 gboolean adapter_le_set_platform_scan_filter_params(struct btd_adapter *adapter,
4282                                         adapter_le_scan_filter_param_t *params)
4283 {
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;
4287
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);
4294         } else {
4295                 DBG("filter_action error");
4296                 ret = FALSE;
4297         }
4298
4299         DBG("Scan Filter VSC :: Action [%x]",
4300                                         params->action);
4301         return ret;
4302 }
4303
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,
4307                                                 int company_id,
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)
4314 {
4315         gboolean ret = TRUE;
4316
4317         DBG("");
4318
4319         switch (filt_type) {
4320         case TYPE_DEVICE_ADDRESS: {
4321                 /* TYPE_DEVICE_ADDRESS */
4322                 adapter_le_scan_filter_action_type action_type = action;
4323
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);
4332                 } else {
4333                         DBG("filter_action error");
4334                         ret = FALSE;
4335                 }
4336
4337                 break;
4338         }
4339
4340         case TYPE_SERVICE_UUID:
4341         case TYPE_SOLICIT_UUID: {
4342                 adapter_le_scan_filter_action_type action_type = action;
4343
4344                 gboolean is_solicited = (filt_type == TYPE_SOLICIT_UUID) ? TRUE : FALSE;
4345
4346                 if (uuid_len != UUID_16_LEN && uuid_len != UUID_32_LEN
4347                         && uuid_len != UUID_128_LEN) {
4348                         DBG("UUID length error");
4349                         return FALSE;
4350                 }
4351
4352                 if (uuid_len != uuid_mask_len) {
4353                         DBG("Both UUID and UUID_MASK length shoule be samed");
4354                         return FALSE;
4355                 }
4356
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);
4367                 } else {
4368                         DBG("filter_action error");
4369                         ret = FALSE;
4370                 }
4371
4372                 break;
4373         }
4374
4375         case TYPE_LOCAL_NAME: {
4376                 adapter_le_scan_filter_action_type action_type = action;
4377
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);
4386                 } else {
4387                         DBG("filter_action error");
4388                         ret = FALSE;
4389                 }
4390
4391                 break;
4392         }
4393
4394         case TYPE_MANUFACTURER_DATA: {
4395                 adapter_le_scan_filter_action_type action_type = action;
4396
4397                 if (data_len == 0 || (data_len != mask_len)) {
4398                         DBG("parameter length error");
4399                         return FALSE;
4400                 }
4401
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);
4410                 } else {
4411                         DBG("filter_action error");
4412                         ret = FALSE;
4413                 }
4414
4415                 break;
4416         }
4417
4418         case TYPE_SERVICE_DATA: {
4419                 adapter_le_scan_filter_action_type action_type = action;
4420
4421                 if (data_len == 0 || (data_len != mask_len)) {
4422                         DBG("parameter length error");
4423                         return FALSE;
4424                 }
4425
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);
4434                 } else {
4435                         DBG("filter_action error");
4436                         ret = FALSE;
4437                 }
4438
4439                 break;
4440         }
4441
4442         default:
4443                 DBG("filter_type error");
4444                 ret = FALSE;
4445         }
4446
4447         return ret;
4448 }
4449 #endif
4450
4451 static bool is_set_adv_data_flag(uint8_t *data, int data_len)
4452 {
4453         int adv_type;
4454         for (int i = 0; i < data_len; i++) {
4455                 adv_type = data[i + 1];
4456                 if (adv_type == EIR_FLAGS)
4457                         return true;
4458                 else
4459                         i = i + data[i];
4460         }
4461         return false;
4462 }
4463
4464 static int set_adv_data_flag(uint8_t *adv_data, uint8_t *data, int data_len, void *user_data)
4465 {
4466         struct btd_adapter *adapter = user_data;
4467
4468         if (is_set_adv_data_flag(data, data_len))
4469                 return data_len;
4470
4471         adv_data[0] = 2;
4472         adv_data[1] = EIR_FLAGS;
4473
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;
4477         else {
4478                 if (TIZEN_FEATURE_BLUEZ_DA) {
4479                         DBG("Disable LE General Discoverable Mode");
4480                         adv_data[2] = EIR_CONTROLLER | EIR_SIM_HOST;
4481                 } else
4482                         adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER | EIR_SIM_HOST;
4483         }
4484
4485         memcpy(adv_data + 3, data, data_len);
4486         return data_len + 3;
4487 }
4488
4489 static int set_adv_data_device_name(uint8_t *adv_data, int adv_len, char *name)
4490 {
4491         int ad_type;
4492         int ad_len;
4493         int i, j;
4494         int name_len;
4495         uint8_t *data = NULL;
4496
4497         if (!name)
4498                 return adv_len;
4499
4500         data = g_memdup(adv_data, adv_len);
4501         if (!data)
4502                 return adv_len;
4503
4504         name_len = strlen(name);
4505
4506         for (i = 0; i <adv_len ; i++) {
4507                 ad_len = data[i];
4508                 ad_type = data[i + 1];
4509
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];
4514
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);
4520                                 g_free(data);
4521                                 return ADV_DATA_MAX_LENGTH;
4522                         } else {
4523                                 adv_data[j + 1] = EIR_NAME_COMPLETE;
4524                                 memcpy(adv_data + j + 2, name, name_len);
4525                                 g_free(data);
4526                                 return adv_len + name_len;
4527                         }
4528
4529                 } else {
4530                         memcpy(adv_data + i, &data[i], ad_len + 1);
4531                         i = i + data[i];
4532                 }
4533         }
4534
4535         g_free(data);
4536         return adv_len;
4537 }
4538
4539 static int set_adv_data_tx_power(uint8_t *adv_data, int adv_len, int8_t tx_power)
4540 {
4541         int ad_type;
4542         int ad_len;
4543         int i, j;
4544         uint8_t *data = NULL;
4545
4546         data = g_memdup(adv_data, adv_len);
4547         if (!data)
4548                 return adv_len;
4549
4550         for (i = 0; i <adv_len ; i++) {
4551                 ad_len = data[i];
4552                 ad_type = data[i + 1];
4553
4554                 if (ad_type == EIR_TX_POWER) {
4555                         adv_data[i] = 2;
4556                         adv_data[i + 1] = EIR_TX_POWER;
4557                         adv_data[i + 2] = tx_power;
4558
4559                         for(j = i + 2; j < adv_len; j++)
4560                                 adv_data[j + 1] = data[j];
4561
4562                         g_free(data);
4563                         return adv_len + 1;
4564                 } else {
4565                         memcpy(adv_data + i, &data[i], ad_len + 1);
4566                         i = i + data[i];
4567                 }
4568         }
4569
4570         g_free(data);
4571         return adv_len;
4572 }
4573
4574
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,
4577                 void *user_data)
4578 {
4579         uint8_t *data;
4580         int len;
4581
4582         data = g_malloc0(ADV_DATA_MAX_LENGTH);
4583         memcpy(data, p_data, data_len);
4584         len = data_len;
4585
4586         /* In case multi advertising, need to update the below AD type
4587                 since it handled into kernel */
4588         if (!is_scan_rsp) {
4589                 len = set_adv_data_flag(data, p_data, data_len, user_data);
4590         }
4591
4592         len = set_adv_data_tx_power(data, len, tx_power);
4593
4594         len = set_adv_data_device_name(data, len, adapter_name);
4595
4596         *adv_data = data;
4597         *adv_len = len;
4598         return 0;
4599 }
4600
4601 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
4602 static DBusMessage *adapter_get_psm_l2cap_le(DBusConnection *conn,
4603                                                 DBusMessage *msg, void *user_data)
4604 {
4605         return get_psm_l2cap_le(conn, msg);
4606 }
4607
4608 static DBusMessage *adapter_listen_l2cap_le_socket(DBusConnection *conn,
4609                                                 DBusMessage *msg, void *user_data)
4610 {
4611         return listen_l2cap_le_socket(conn, msg, user_data);
4612 }
4613
4614 static DBusMessage *adapter_remove_l2cap_le_socket(DBusConnection *conn,
4615                                                 DBusMessage *msg, void *user_data)
4616 {
4617         return remove_l2cap_le_socket(conn, msg);
4618 }
4619
4620 #endif
4621
4622 static DBusMessage *adapter_start_custom_discovery(DBusConnection *conn,
4623                                         DBusMessage *msg, void *user_data)
4624 {
4625         struct btd_adapter *adapter = user_data;
4626         const char *sender = dbus_message_get_sender(msg);
4627         struct discovery_client *client;
4628         GSList *list;
4629         const gchar *disc_type;
4630
4631         DBG("sender %s", sender);
4632
4633         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4634                 return btd_error_not_ready(msg);
4635
4636         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &disc_type,
4637                                                         DBUS_TYPE_INVALID)) {
4638                 return btd_error_invalid_args(msg);
4639         }
4640
4641         DBG("discovery type = %s", disc_type);
4642
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;
4650         else
4651                 return btd_error_invalid_args(msg);
4652
4653         /*
4654          * Every client can only start one discovery, if the client
4655          * already started a discovery then return an error.
4656          */
4657         list = g_slist_find_custom(adapter->discovery_list, sender,
4658                                                 compare_sender);
4659         if (list)
4660                 return btd_error_busy(msg);
4661
4662         client = g_new0(struct discovery_client, 1);
4663
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,
4668                                                 discovery_destroy);
4669
4670         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
4671                                                                 client);
4672
4673         /*
4674          * Just trigger the discovery here. In case an already running
4675          * discovery in idle phase exists, it will be restarted right
4676          * away.
4677          */
4678         trigger_start_discovery(adapter, 0);
4679
4680         return dbus_message_new_method_return(msg);
4681 }
4682
4683 static DBusMessage *adapter_start_le_discovery(DBusConnection *conn,
4684                                         DBusMessage *msg, void *user_data)
4685 {
4686         struct btd_adapter *adapter = user_data;
4687         const char *sender = dbus_message_get_sender(msg);
4688         struct discovery_client *client;
4689         GSList *list;
4690
4691         DBG("sender %s", sender);
4692
4693         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4694                 return btd_error_not_ready(msg);
4695
4696         /*
4697          * Every client can only start one discovery, if the client
4698          * already started a discovery then return an error.
4699          */
4700
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);
4704
4705         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4706                                                 compare_sender);
4707         if (list)
4708                 return btd_error_busy(msg);
4709
4710         client = g_new0(struct discovery_client, 1);
4711
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);
4717
4718         adapter->le_discovery_list = g_slist_prepend(adapter->le_discovery_list,
4719                                                                 client);
4720
4721         /*
4722          * Just trigger the discovery here. In case an already running
4723          * discovery in idle phase exists, it will be restarted right
4724          * away.
4725          */
4726         trigger_start_le_discovery(adapter, 0);
4727
4728         return dbus_message_new_method_return(msg);
4729 }
4730
4731 static DBusMessage *adapter_stop_le_discovery(DBusConnection *conn,
4732                                         DBusMessage *msg, void *user_data)
4733 {
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;
4738         GSList *list;
4739
4740         DBG("sender %s", sender);
4741
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;
4746         }
4747
4748         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4749                 return btd_error_not_ready(msg);
4750
4751         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4752                                                 compare_sender);
4753         if (!list)
4754                 return btd_error_failed(msg, "No discovery started");
4755
4756         client = list->data;
4757
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);
4761
4762         cp.type = adapter->discovery_type;
4763         DBG("cp.type %d", cp.type);
4764
4765         /*
4766          * As long as other discovery clients are still active, just
4767          * clenup client info and return success.
4768          */
4769         DBG("adapter->le_discovery_list %p", adapter->le_discovery_list);
4770         if (g_slist_next(adapter->le_discovery_list)) {
4771                 /*
4772                  * The destroy function will cleanup the client information and
4773                  * also remove it from the list of discovery clients.
4774                  */
4775                 g_dbus_remove_watch(dbus_conn, client->watch);
4776                 return dbus_message_new_method_return(msg);
4777         }
4778
4779         /*
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.
4782          */
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");
4790
4791                 trigger_passive_scanning(adapter);
4792                 return dbus_message_new_method_return(msg);
4793         }
4794
4795         DBG("adapter->discovery_type %d", adapter->discovery_type);
4796         cp.type = 0x06;
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);
4801
4802         client->msg = dbus_message_ref(msg);
4803         return NULL;
4804 }
4805
4806 static DBusMessage *adapter_set_advertising(DBusConnection *conn,
4807                                                 DBusMessage *msg, void *data)
4808 {
4809         struct btd_adapter *adapter = data;
4810         dbus_bool_t err;
4811         dbus_bool_t enable = FALSE;
4812         dbus_int32_t slot_id;
4813
4814         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4815                 return btd_error_not_ready(msg);
4816
4817         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &enable,
4818                                                 DBUS_TYPE_INT32, &slot_id,
4819                                                 DBUS_TYPE_INVALID))
4820                 return btd_error_invalid_args(msg);
4821
4822         if (adapter->adv_restart_timeout > 0)
4823                 return btd_error_in_progress(msg);
4824
4825         DBG("%s advertising slot_id %d", enable ? "Enable" : "Disable", slot_id);
4826
4827         if (adapter_le_is_supported_multi_advertising() && slot_id > 0)
4828                 err = adapter_le_enable_multi_adv(adapter, enable, slot_id);
4829         else
4830                 err = set_mode(adapter, MGMT_OP_SET_ADVERTISING, enable);
4831
4832         if (!err)
4833                 return btd_error_failed(msg, "Set Advertising failed");
4834
4835         if (enable)
4836                 create_advertiser(adapter, slot_id);
4837
4838         if (err && slot_id > 0)
4839                 advertising_state_changed(adapter, slot_id, enable);
4840
4841         return dbus_message_new_method_return(msg);
4842 }
4843
4844 static DBusMessage *adapter_set_advertising_params(DBusConnection *conn,
4845                                                 DBusMessage *msg, void *data)
4846 {
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;
4852         dbus_uint32_t type;
4853         dbus_int32_t tx_power_level;
4854         dbus_int32_t slot_id;
4855         gboolean ret;
4856
4857         DBG("Set customised advertising parameters");
4858
4859         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4860                 return btd_error_not_ready(msg);
4861
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,
4869                                 DBUS_TYPE_INVALID))
4870                 return btd_error_invalid_args(msg);
4871
4872         memset(&cp, 0, sizeof(cp));
4873
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);
4876
4877         if (filter_policy > 0x03)
4878                 return btd_error_invalid_args(msg);
4879
4880         if (type > 0x04)
4881                 return btd_error_invalid_args(msg);
4882
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;
4886
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;
4896
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);
4903                 } else {
4904                         p_inst->bdaddr_type = 0x00;
4905                         bacpy(&p_inst->bdaddr, &adapter->bdaddr);
4906                 }
4907
4908                 ret = adapter_le_set_multi_adv_params(p_inst, p_params);
4909
4910                 g_free(p_inst);
4911                 g_free(p_params);
4912
4913                 if (ret)
4914                         return dbus_message_new_method_return(msg);
4915                 else
4916                         return btd_error_failed(msg, "set advertising param failed");
4917         } else {
4918                 cp.interval_max = interval_max;
4919                 cp.interval_min = interval_min;
4920                 cp.filter_policy = filter_policy;
4921                 cp.type = type;
4922
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);
4927
4928                 return btd_error_failed(msg, "set advertising param failed");
4929         }
4930 }
4931
4932 static DBusMessage *adapter_set_advertising_data(DBusConnection *conn,
4933                                                 DBusMessage *msg, void *data)
4934 {
4935         struct btd_adapter *adapter = data;
4936         struct mgmt_cp_set_advertising_data cp;
4937         uint8_t *value;
4938         int32_t len = 0;
4939         dbus_int32_t slot_id;
4940         uint8_t *adv_data = NULL;
4941         int adv_len = 0;
4942         char *adapter_name = adapter->name;
4943         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
4944
4945         DBG("Set advertising data");
4946
4947         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4948                 return btd_error_not_ready(msg);
4949
4950         if (!dbus_message_get_args(msg, NULL,
4951                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4952                         DBUS_TYPE_INT32, &slot_id,
4953                         DBUS_TYPE_INVALID))
4954                 return btd_error_invalid_args(msg);
4955
4956         if (is_set_adv_data_flag(value, len)) {
4957                 if (len > ADV_DATA_MAX_LENGTH)
4958                         return btd_error_invalid_args(msg);
4959         } else {
4960                 if (len > ADV_DATA_MAX_LENGTH - 3)
4961                         return btd_error_invalid_args(msg);
4962         }
4963
4964         if (adapter->le_static_addr.b[5] != 0) {
4965                 char *ptr = NULL;
4966
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))
4970                         *ptr = '\0';
4971
4972                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
4973                 adapter_name = le_name;
4974         }
4975
4976         adapter_le_set_missed_adv_data(value, len, FALSE,
4977                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
4978
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)) {
4981                         g_free(adv_data);
4982                         return dbus_message_new_method_return(msg);
4983                 } else {
4984                         g_free(adv_data);
4985                         return btd_error_failed(msg, "set advertising data failed");
4986                 }
4987         } else {
4988                 memcpy(&cp, adv_data, adv_len);
4989
4990                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_DATA,
4991                                                 adapter->dev_id, adv_len,
4992                                                 &cp, NULL, NULL, NULL) > 0) {
4993                         g_free(adv_data);
4994                         return dbus_message_new_method_return(msg);
4995                 }
4996
4997                 g_free(adv_data);
4998                 return btd_error_failed(msg, "set advertising data failed");
4999         }
5000 }
5001
5002 static DBusMessage *adapter_le_scan_filter_param_setup(DBusConnection *conn,
5003                                                 DBusMessage *msg, void *data)
5004 {
5005         struct btd_adapter *adapter = data;
5006 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5007         dbus_bool_t ctlr_filter_support = TRUE;
5008 #endif
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;
5014         gboolean err;
5015
5016         DBG("adapter_le_scan_filter_param_setup");
5017
5018         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5019                 return btd_error_not_ready(msg);
5020
5021         if (adapter_le_get_scan_filter_size() == 0)
5022 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5023                 return btd_error_not_supported(msg);
5024 #else
5025                 ctlr_filter_support = FALSE;
5026 #endif
5027
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,
5040                                                 DBUS_TYPE_INVALID))
5041                 return btd_error_invalid_args(msg);
5042
5043         memset(&params, 0, sizeof(params));
5044
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;
5052
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;
5058         }
5059
5060 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5061         if (ctlr_filter_support)
5062 #endif
5063         err = adapter_le_set_scan_filter_params(&params);
5064 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5065         else
5066                 err = adapter_le_set_platform_scan_filter_params(adapter, &params);
5067 #endif
5068
5069         if (!err)
5070                 return btd_error_failed(msg, "Failed to scan filter param setup");
5071
5072         return dbus_message_new_method_return(msg);
5073 }
5074
5075 static DBusMessage *adapter_le_scan_filter_add_remove(DBusConnection *conn,
5076                                                 DBusMessage *msg, void *data)
5077 {
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;
5082         gchar *str = NULL;
5083         dbus_uint32_t address_type = 0;
5084         uint8_t addr_type = 0;
5085         GSList *list;
5086         char string[30];
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;
5089         gboolean err;
5090 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5091         dbus_bool_t ctlr_filter_support = TRUE;
5092 #endif
5093
5094         DBG("adapter_le_scan_filter_add_remove");
5095
5096         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5097                 return btd_error_not_ready(msg);
5098
5099         /* if controller does not support vendor specific scan filtering feature
5100          * then add the filter into platform supported scan filters.
5101          */
5102         if (adapter_le_get_scan_filter_size() == 0) {
5103 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5104                 return btd_error_not_supported(msg);
5105 #else
5106                 ctlr_filter_support = FALSE;
5107 #endif
5108         }
5109
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,
5122                                                 DBUS_TYPE_INVALID))
5123                 return btd_error_invalid_args(msg);
5124
5125         if (filt_type == TYPE_DEVICE_ADDRESS) {
5126                 list = g_slist_find_custom(adapter->devices, str, device_rpa_cmp);
5127                 if (!list)
5128                         list = g_slist_find_custom(adapter->devices, str,
5129                                                                 device_address_cmp);
5130                 if (list)
5131                         dev = list->data;
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)
5135                                 addr_type = 0x00;
5136                         else
5137                                 addr_type = 0x01;
5138                 } else {
5139                         strncpy(string, str, sizeof(string) - 1);
5140                         addr_type = 0x00;
5141                 }
5142
5143                 DBG("addr %s, type %d", string, addr_type);
5144         } else {
5145                 strncpy(string, str, sizeof(string) - 1 );
5146         }
5147
5148 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5149         if (ctlr_filter_support)
5150 #endif
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
5156         else
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);
5161 #endif
5162         if (!err)
5163                 return btd_error_failed(msg, "Failed to add/remove filter");
5164
5165         return dbus_message_new_method_return(msg);
5166 }
5167
5168 static DBusMessage *adapter_le_scan_filter_clear(DBusConnection *conn,
5169                                                 DBusMessage *msg, void *data)
5170 {
5171         struct btd_adapter *adapter = data;
5172         dbus_int32_t client_if = 0;
5173         dbus_int32_t filt_index = 0;
5174         gboolean err;
5175 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5176         dbus_bool_t ctlr_filter_support = TRUE;
5177 #endif
5178
5179         DBG("adapter_le_scan_filter_clear");
5180
5181         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5182                 return btd_error_not_ready(msg);
5183
5184         if (adapter_le_get_scan_filter_size() == 0)
5185 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5186                 return btd_error_not_supported(msg);
5187 #else
5188                 ctlr_filter_support = FALSE;
5189 #endif
5190
5191         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5192                                                 DBUS_TYPE_INT32, &filt_index,
5193                                                 DBUS_TYPE_INVALID))
5194                 return btd_error_invalid_args(msg);
5195
5196 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5197         if (ctlr_filter_support)
5198 #endif
5199         err = adapter_le_clear_scan_filter_data(client_if, filt_index);
5200 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5201         else
5202                 err = adapter_le_clear_platform_scan_filter_data(adapter, filt_index);
5203 #endif
5204
5205         if (!err)
5206                 return btd_error_failed(msg, "Failed to clear filter");
5207
5208         return dbus_message_new_method_return(msg);
5209 }
5210
5211
5212 static DBusMessage *adapter_le_scan_filter_enable(DBusConnection *conn,
5213                                                 DBusMessage *msg, void *data)
5214 {
5215         struct btd_adapter *adapter = data;
5216         dbus_bool_t enable = FALSE;
5217         dbus_int32_t client_if = 0;
5218         gboolean err;
5219 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5220         dbus_bool_t ctlr_filter_support = TRUE;
5221 #endif
5222
5223         DBG("adapter_le_scan_filter_enable");
5224
5225         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5226                 return btd_error_not_ready(msg);
5227
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.
5231          */
5232 #endif
5233         if (adapter_le_get_scan_filter_size() == 0)
5234 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5235                 return btd_error_not_supported(msg);
5236 #else
5237                 ctlr_filter_support = FALSE;
5238 #endif
5239
5240         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5241                                                 DBUS_TYPE_BOOLEAN, &enable,
5242                                                 DBUS_TYPE_INVALID))
5243                 return btd_error_invalid_args(msg);
5244
5245 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5246         if (ctlr_filter_support)
5247 #endif
5248         err = adapter_le_enable_scan_filtering(enable);
5249 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5250         else
5251                 err = adapter_le_enable_platform_scan_filtering(adapter, enable);
5252 #endif
5253
5254         if (!err)
5255                 return btd_error_failed(msg, "Failed to enable scan filtering");
5256
5257         return dbus_message_new_method_return(msg);
5258 }
5259
5260 static DBusMessage *adapter_le_set_scan_params(DBusConnection *conn,
5261                                                 DBusMessage *msg, void *data)
5262 {
5263         struct btd_adapter *adapter = data;
5264         struct mgmt_cp_le_set_scan_params cp;
5265         uint32_t type;
5266         uint32_t interval;
5267         uint32_t window;
5268
5269         DBG("Set scan parameters");
5270
5271         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5272                 return btd_error_not_ready(msg);
5273
5274         if (!dbus_message_get_args(msg, NULL,
5275                                 DBUS_TYPE_UINT32, &type,
5276                                 DBUS_TYPE_UINT32, &interval,
5277                                 DBUS_TYPE_UINT32, &window,
5278                                 DBUS_TYPE_INVALID))
5279                 return btd_error_invalid_args(msg);
5280
5281         DBG("scan type %x, interval %x, window %x",
5282                                 type, interval, window);
5283         memset(&cp, 0, sizeof(cp));
5284
5285         cp.type = type;
5286         cp.interval = interval;
5287         cp.window = window;
5288 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5289         adapter->scan_type = type;
5290 #endif
5291
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);
5296
5297         return btd_error_failed(msg, "set scan parameters failed");
5298 }
5299
5300 static DBusMessage *adapter_set_scan_rsp_data(DBusConnection *conn,
5301                                                 DBusMessage *msg, void *data)
5302 {
5303         struct btd_adapter *adapter = data;
5304         struct mgmt_cp_set_scan_rsp_data cp;
5305         uint8_t *value;
5306         int32_t len = 0;
5307         dbus_int32_t slot_id;
5308         uint8_t *adv_data = NULL;
5309         int adv_len = 0;
5310
5311         char *adapter_name = adapter->name;
5312         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
5313
5314         DBG("Set scan response data");
5315
5316         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5317                 return btd_error_not_ready(msg);
5318
5319         if (!dbus_message_get_args(msg, NULL,
5320                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
5321                         DBUS_TYPE_INT32, &slot_id,
5322                         DBUS_TYPE_INVALID))
5323                 return btd_error_invalid_args(msg);
5324
5325         if (len > SCAN_RESPONSE_DATA_LENGTH_MAX)
5326                 return btd_error_invalid_args(msg);
5327
5328         if (adapter->le_static_addr.b[5] != 0) {
5329                 char *ptr = NULL;
5330
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))
5334                         *ptr = '\0';
5335
5336                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
5337                 adapter_name = le_name;
5338         }
5339
5340         adapter_le_set_missed_adv_data(value, len, TRUE,
5341                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
5342
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)) {
5345                         g_free(adv_data);
5346                         return dbus_message_new_method_return(msg);
5347                 } else {
5348                         g_free(adv_data);
5349                         return btd_error_failed(msg, "set advertising data failed");
5350                 }
5351         } else {
5352                 memcpy(&cp, adv_data, adv_len);
5353
5354                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_SCAN_RSP_DATA,
5355                                                 adapter->dev_id, adv_len, &cp,
5356                                                 NULL, NULL, NULL) > 0) {
5357                         g_free(adv_data);
5358                         return dbus_message_new_method_return(msg);
5359                 }
5360
5361                 g_free(adv_data);
5362                 return btd_error_failed(msg, "set scan reponse data failed");
5363         }
5364 }
5365
5366 static DBusMessage *adapter_add_device_white_list(DBusConnection *conn,
5367                                         DBusMessage *msg, void *data)
5368 {
5369         struct btd_adapter *adapter = data;
5370         struct mgmt_cp_add_dev_white_list cp;
5371         const gchar *address;
5372         bdaddr_t bdaddr;
5373         dbus_uint32_t address_type;
5374         struct btd_device *dev;
5375
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);
5382
5383         if (bachk(address) < 0)
5384                 return btd_error_invalid_args(msg);
5385
5386         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5387                 return btd_error_not_ready(msg);
5388
5389         DBG("addr %s, type %d", address, address_type);
5390         str2ba(address, &bdaddr);
5391
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);
5398                 }
5399
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);
5405                 } else {
5406                         return btd_error_failed(msg, "Add LE IRK to list failed");
5407                 }
5408         }
5409
5410         memset(&cp, 0, sizeof(cp));
5411
5412         cp.bdaddr_type = address_type;
5413         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5414
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);
5419
5420         return btd_error_failed(msg, "add device white list failed");
5421 }
5422
5423 static DBusMessage *adapter_remove_device_white_list(DBusConnection *conn,
5424                                         DBusMessage *msg, void *data)
5425 {
5426         struct btd_adapter *adapter = data;
5427         struct mgmt_cp_remove_dev_white_list cp;
5428         const gchar *address;
5429         bdaddr_t bdaddr;
5430         dbus_uint32_t address_type;
5431         struct btd_device *dev;
5432
5433         DBG("Remove device whie list");
5434
5435         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5436                 return btd_error_not_ready(msg);
5437
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);
5443
5444         if (bachk(address) < 0)
5445                 return btd_error_invalid_args(msg);
5446
5447         DBG("addr %s, type %d", address, address_type);
5448         str2ba(address, &bdaddr);
5449
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);
5456                 }
5457
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);
5462                 } else {
5463                         return btd_error_failed(msg, "Remove IRK is failed");
5464                 }
5465         }
5466
5467         memset(&cp, 0, sizeof(cp));
5468
5469         cp.bdaddr_type = address_type;
5470         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5471
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);
5476
5477         return btd_error_failed(msg, "remove device white list failed");
5478 }
5479
5480 static DBusMessage *adapter_clear_device_white_list(DBusConnection *conn,
5481                                         DBusMessage *msg, void *data)
5482 {
5483         struct btd_adapter *adapter = data;
5484
5485         DBG("Clear device whie list");
5486
5487         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5488                 return btd_error_not_ready(msg);
5489
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);
5494
5495         return btd_error_failed(msg, "clear white list failed");
5496 }
5497
5498 static DBusMessage *adapter_set_le_privacy(DBusConnection *conn,
5499                                         DBusMessage *msg, void *data)
5500 {
5501         struct btd_adapter *adapter = data;
5502         dbus_bool_t err;
5503         dbus_bool_t enable_privacy = FALSE;
5504
5505         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
5506                 return btd_error_not_supported(msg);
5507
5508         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
5509                                 &enable_privacy, DBUS_TYPE_INVALID))
5510                 return btd_error_invalid_args(msg);
5511
5512         if (enable_privacy) {
5513                 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
5514                         return btd_error_already_exists(msg);
5515         } else {
5516                 if (!(adapter->current_settings & MGMT_SETTING_PRIVACY))
5517                         return btd_error_already_exists(msg);
5518         }
5519
5520         err = set_privacy(adapter, enable_privacy);
5521
5522         if (!err) {
5523                 return btd_error_failed(msg, "Set Le Privacy failed");
5524         } else {
5525                 if (enable_privacy)
5526                         adapter->current_settings = adapter->current_settings | MGMT_SETTING_PRIVACY;
5527                 else
5528                         adapter->current_settings = adapter->current_settings & ~(SETTING_PRIVACY_MASK);
5529         }
5530
5531         return dbus_message_new_method_return(msg);
5532 }
5533
5534 static void init_le_static_address(struct btd_adapter *adapter)
5535 {
5536         int fd;
5537         int ret;
5538         char address[18];
5539         char dirname[PATH_MAX];
5540         int i;
5541         bdaddr_t le_static_addr;
5542
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;
5548         }
5549
5550         /*
5551          * < How to get Public address from above static address >
5552          *
5553          * for (i = 0; i < 5; i++) {
5554          *      bredr_addr.b[i] =
5555          *              (adapter->le_static_addr.b[i] & 0xfe) >> 1 |
5556          *              (adapter->le_static_addr.b[i] & 0x01) << 7;
5557          * }
5558          * bredr_addr.b[5] = {the value from advertising data}
5559          */
5560
5561         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5562         fd = open(dirname, O_WRONLY | O_CREAT, 0644);
5563
5564         if (fd >= 0) {
5565                 ba2str(&le_static_addr, address);
5566                 DBG("LE static random : %s", address);
5567                 ret = write(fd, address, strlen(address));
5568                 if (ret < 0) {
5569                         error("Cannot save LE address : %s",
5570                                         strerror(errno));
5571                 }
5572
5573                 ret = fdatasync(fd);
5574                 if (ret < 0)
5575                         error("sync failed : %s", strerror(errno));
5576
5577                 close(fd);
5578         } else {
5579                 error("Cannot save LE address");
5580         }
5581 }
5582
5583 static void set_le_static_address(struct btd_adapter *adapter)
5584 {
5585         int fd;
5586         int ret;
5587         char address[18];
5588         char dirname[PATH_MAX];
5589
5590         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5591         if (access(dirname, F_OK) < 0)
5592                 init_le_static_address(adapter);
5593
5594         fd = open(dirname, O_RDONLY);
5595         if (fd >= 0) {
5596                 ret = read(fd, address, sizeof(address));
5597                 if (ret >= 17) {
5598                         /* xx:xx:xx:xx:xx:xx */
5599                         address[17] = '\0';
5600                         DBG("LE static random : %s", address);
5601                         str2ba(address, &adapter->le_static_addr);
5602                         adapter->le_static_addr.b[5] |= 0xc0;
5603                 } else
5604                         error("Invalid LE address");
5605                 close(fd);
5606         } else {
5607                 error("Cannot get LE address");
5608         }
5609
5610         return;
5611 }
5612
5613 static void set_le_static_address_complete(uint8_t status, uint16_t length,
5614                                         const void *param, void *user_data)
5615 {
5616         struct btd_adapter *adapter = user_data;
5617
5618         DBG("index %u status 0x%02x", adapter->dev_id, status);
5619
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);
5625                 else
5626                         set_le_static_address(adapter);
5627                 return;
5628         }
5629
5630         return;
5631 }
5632
5633 static DBusMessage *adapter_set_le_static_address(DBusConnection *conn,
5634                                         DBusMessage *msg, void *data)
5635 {
5636         struct btd_adapter *adapter = data;
5637         dbus_bool_t is_enable = FALSE;
5638         struct mgmt_cp_set_static_address cp;
5639
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);
5643         }
5644
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);
5649         }
5650
5651         memset(&cp, 0x00, sizeof(cp));
5652         if (is_enable)  {
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);
5656                 }
5657                 set_le_static_address(adapter);
5658                 bacpy(&cp.bdaddr, &adapter->le_static_addr);
5659         } else {
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);
5663                 }
5664                 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5665         }
5666         DBG("Set static random address : %d", is_enable);
5667
5668         if (mgmt_send(mgmt_primary, MGMT_OP_SET_STATIC_ADDRESS, adapter->dev_id,
5669                         sizeof(cp), &cp,
5670                         set_le_static_address_complete, adapter, NULL) <= 0) {
5671                 error("Failed to set static address : %d", is_enable);
5672                 if (is_enable)
5673                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5674                 else
5675                         set_le_static_address(adapter);
5676                 return btd_error_failed(msg, "Unable to set static address");
5677         }
5678
5679         return dbus_message_new_method_return(msg);
5680 }
5681
5682 static DBusMessage *adapter_enable_rssi(DBusConnection *conn,
5683                                                 DBusMessage *msg, void *data)
5684 {
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;
5690
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;
5696
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);
5701
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,
5708                                 DBUS_TYPE_INVALID))
5709                 return btd_error_invalid_args(msg);
5710
5711         DBG("Enable RSSI: [%s %d %d %d %d]", address, link_type,
5712                         low_threshold, in_range_threshold, high_threshold);
5713
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));
5719
5720         if (bachk(address) < 0)
5721                 return btd_error_invalid_args(msg);
5722
5723 //      if (!btd_adapter_find_device(adapter, address))
5724 //              return btd_error_not_found(msg);
5725
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);
5734         } else {
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);
5745         }
5746         return btd_error_failed(msg, "Enable/Disable RSSI Failed");
5747 }
5748
5749 static DBusMessage *adapter_get_rssi(DBusConnection *conn,
5750                                                 DBusMessage *msg, void *data)
5751 {
5752         struct btd_adapter *adapter = data;
5753         struct mgmt_cp_get_raw_rssi cp;
5754         bdaddr_t bt_addr;
5755         const gchar *address = NULL;
5756         dbus_int32_t link_type;
5757         const char *sender = dbus_message_get_sender(msg);
5758
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);
5763
5764         if (!dbus_message_get_args(msg, NULL,
5765                                 DBUS_TYPE_STRING, &address,
5766                                 DBUS_TYPE_INT32, &link_type,
5767                                 DBUS_TYPE_INVALID))
5768                 return btd_error_invalid_args(msg);
5769
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));
5774
5775         if (bachk(address) < 0)
5776                 return btd_error_invalid_args(msg);
5777
5778 //      if (!btd_adapter_find_device(adapter, address))
5779 //              return btd_error_not_found(msg);
5780
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);
5788
5789         return btd_error_failed(msg, "Get Raw RSSI Failed");
5790 }
5791
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)
5795 {
5796         struct btd_adapter *adapter = user_data;
5797         const struct mgmt_rp_get_adv_tx_power *rp = param;
5798
5799         if (!rp) {
5800                 error("Error ocurred in Getting adv tx power, rp is NULL");
5801                 return;
5802         }
5803
5804         if (status != MGMT_STATUS_SUCCESS) {
5805                 error("Failed to get adv tx power: %s (0x%02x)",
5806                                                 mgmt_errstr(status), status);
5807                 return;
5808         }
5809
5810         if (length < sizeof(*rp)) {
5811                 error("Wrong size of get adv tx power");
5812                 return;
5813         }
5814
5815         adapter->adv_tx_power = rp->adv_tx_power;
5816         return;
5817 }
5818
5819 static  void adapter_get_adv_tx_power(void *data)
5820 {
5821         struct btd_adapter *adapter = data;
5822
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);
5826         return;
5827 }
5828 #endif
5829
5830 static DBusMessage *set_wbs_parameters(DBusConnection *conn,
5831                                 DBusMessage *msg, void *data)
5832 {
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, } };
5838
5839         DBG("+");
5840
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);
5846         }
5847
5848         DBG("Role = %s", role);
5849         DBG("Address = %s", address);
5850
5851         memset(&cp, 0, sizeof(cp));
5852
5853         cp.voice_setting = BT_VOICE_TRANSPARENT | BT_VOICE_CVSD_16BIT;
5854
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;
5859
5860         str2ba(address, &bt_addr);
5861         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5862
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");
5867
5868         DBG("-");
5869         return dbus_message_new_method_return(msg);
5870 }
5871
5872 static DBusMessage *set_nb_parameters(DBusConnection *conn,
5873                                 DBusMessage *msg, void *data)
5874 {
5875         struct btd_adapter *adapter = data;
5876         const gchar *role;
5877         const gchar *address = NULL;
5878         struct mgmt_cp_set_voice_setting cp;
5879         bdaddr_t bt_addr = { { 0, } };
5880
5881         DBG("+");
5882
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);
5888         }
5889
5890         DBG("Role = %s", role);
5891         DBG("Address = %s", address);
5892
5893         memset(&cp, 0, sizeof(cp));
5894
5895         cp.voice_setting = BT_VOICE_CVSD_16BIT;
5896
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;
5901
5902         str2ba(address, &bt_addr);
5903         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5904
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");
5909
5910         DBG("-");
5911
5912         return dbus_message_new_method_return(msg);
5913 }
5914
5915 void btd_adapter_set_read_le_data_length_handler(
5916                         struct btd_adapter *adapter,
5917                         struct le_data_length_read_handler *handler)
5918 {
5919         adapter->read_handler = handler;
5920 }
5921
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)
5925 {
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;
5932         int err = 0;
5933
5934         if (!rp) {
5935                 error("Error ocurred in Reading maximum data length, rp is NULL");
5936                 err = -EIO;
5937                 goto done;
5938         }
5939
5940         if (status != MGMT_STATUS_SUCCESS) {
5941                 error("le read maximum data length failed: %s (0x%02x)",
5942                         mgmt_errstr(status), status);
5943                 err = -EIO;
5944                 goto done;
5945         }
5946
5947         if (length < sizeof(*rp)) {
5948                 error("Too small le read maximum data length response");
5949                 err = -EIO;
5950                 goto done;
5951         } else {
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;
5956         }
5957
5958 done:
5959         if (!adapter->read_handler ||
5960                 !adapter->read_handler->read_callback) {
5961                 g_free(adapter->read_handler);
5962                 return;
5963         }
5964
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);
5969
5970         g_free(adapter->read_handler);
5971         adapter->read_handler = NULL;
5972 }
5973
5974 int btd_adapter_le_read_maximum_data_length(
5975         struct btd_adapter *adapter)
5976 {
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,
5981                          adapter, NULL) > 0)
5982                 return 0;
5983
5984         return -EIO;
5985 }
5986
5987 static gint read_request_cmp(gconstpointer a, gconstpointer b)
5988 {
5989         const struct le_data_length_read_request *data = a;
5990         const struct btd_adapter *adapter = b;
5991
5992         return data->adapter !=  adapter;
5993 }
5994
5995 static struct le_data_length_read_request *find_read_le_data_length_request(
5996         struct btd_adapter *adapter)
5997 {
5998         GSList *match;
5999
6000         match = g_slist_find_custom(read_requests, adapter, read_request_cmp);
6001
6002         if (match)
6003                 return match->data;
6004
6005         return NULL;
6006 }
6007
6008 static void le_read_data_length_complete(
6009                         struct btd_adapter *adapter,
6010                         int err,
6011                         uint16_t max_tx_octects, uint16_t max_tx_time,
6012                         uint16_t max_rx_octects, uint16_t max_rx_time,
6013                         void *user_data)
6014 {
6015         DBusMessage *reply;
6016         struct le_data_length_read_request *read_request;
6017
6018         read_request = find_read_le_data_length_request(adapter);
6019
6020         if (!read_request)
6021                 return;
6022
6023         if (err) {
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");
6027         } else {
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,
6033                                         DBUS_TYPE_INVALID);
6034
6035                 if (!reply) {
6036                         reply = btd_error_failed(read_request->msg,
6037                                                 "Failed to create reply.");
6038                 }
6039         }
6040
6041         read_requests = g_slist_remove(read_requests, read_request);
6042         dbus_message_unref(read_request->msg);
6043         g_free(read_request);
6044
6045         if (!g_dbus_send_message(dbus_conn, reply))
6046                 error("D-Bus send failed");
6047 }
6048
6049 static DBusMessage *le_read_maximum_data_length(
6050                         DBusConnection *conn, DBusMessage *msg,
6051                         void *user_data)
6052 {
6053         struct btd_adapter *adapter = user_data;
6054         struct le_data_length_read_request *read_request;
6055         struct le_data_length_read_handler *handler;
6056
6057         if (find_read_le_data_length_request(adapter))
6058                 return btd_error_in_progress(msg);
6059
6060         if (btd_adapter_le_read_maximum_data_length(adapter))
6061                 return btd_error_failed(msg, "Unable to read maximum le data length");
6062
6063         read_request = g_new(struct le_data_length_read_request, 1);
6064
6065         read_request->msg = dbus_message_ref(msg);
6066         read_request->adapter = adapter;
6067
6068         read_requests = g_slist_append(read_requests, read_request);
6069
6070         handler = g_new0(struct le_data_length_read_handler, 1);
6071
6072         handler->read_callback =
6073                 (read_max_data_length_cb_t)le_read_data_length_complete;
6074
6075         btd_adapter_set_read_le_data_length_handler(
6076                         read_request->adapter, handler);
6077
6078         return NULL;
6079
6080 }
6081
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)
6085 {
6086         if (status != MGMT_STATUS_SUCCESS) {
6087                 error("le write host suggested data length failed: %s (0x%02x)",
6088                         mgmt_errstr(status), status);
6089         }
6090
6091         return;
6092 }
6093
6094 static DBusMessage *le_write_host_suggested_default_data_length(
6095                         DBusConnection *conn, DBusMessage *msg,
6096                         void *user_data)
6097 {
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;
6102
6103         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6104                 return btd_error_not_ready(msg);
6105
6106         if (!dbus_message_get_args(msg, NULL,
6107                                         DBUS_TYPE_UINT16, &def_tx_Octets,
6108                                         DBUS_TYPE_UINT16, &def_tx_time,
6109                                         DBUS_TYPE_INVALID))
6110                 return btd_error_invalid_args(msg);
6111
6112         memset(&cp, 0, sizeof(cp));
6113         cp.def_tx_octets = def_tx_Octets;
6114         cp.def_tx_time = def_tx_time;
6115
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,
6120                          adapter, NULL) > 0)
6121                 return dbus_message_new_method_return(msg);
6122
6123         return btd_error_failed(msg, "Unable to write host suggested le data length values");
6124 }
6125
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)
6129 {
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;
6133
6134         if (!rp) {
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);
6138
6139                 g_free(adapter->def_read_handler);
6140                 return;
6141         }
6142
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);
6146                 def_tx_octects = 0;
6147                 def_tx_time =0;
6148
6149                 if (adapter->def_read_handler)
6150                         g_free(adapter->def_read_handler->user_data);
6151
6152                 g_free(adapter->def_read_handler);
6153                 return;
6154         }
6155
6156         if (length < sizeof(*rp)) {
6157                 goto done;
6158         } else {
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);
6162         }
6163
6164         if (!adapter->def_read_handler)
6165                 return;
6166
6167         if(!adapter->def_read_handler->read_callback) {
6168                 goto done;
6169         }
6170
6171         adapter->def_read_handler->read_callback(adapter,
6172                         def_tx_octects, def_tx_time,
6173                         adapter->def_read_handler->user_data);
6174 done:
6175         if (adapter->def_read_handler)
6176                 g_free(adapter->def_read_handler->user_data);
6177
6178         g_free(adapter->def_read_handler);
6179         adapter->def_read_handler = NULL;
6180 }
6181
6182 int btd_adapter_le_read_suggested_default_data_length(
6183         struct btd_adapter *adapter)
6184 {
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) {
6190                 return 0;
6191         }
6192
6193         return -EIO;
6194 }
6195
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,
6199                         void *user_data)
6200 {
6201         DBusMessage *reply;
6202         struct le_data_length_read_request *read_request;
6203
6204         read_request = find_read_le_data_length_request(adapter);
6205         if (!read_request)
6206                 return;
6207
6208         reply = g_dbus_create_reply(read_request->msg,
6209                         DBUS_TYPE_UINT16, &def_tx_octects,
6210                         DBUS_TYPE_UINT16, &def_tx_time,
6211                         DBUS_TYPE_INVALID);
6212
6213         if (!reply) {
6214                 btd_error_failed(read_request->msg,
6215                         "Failed to read host suggested def data length values");
6216                 return;
6217         }
6218
6219         read_requests = g_slist_remove(read_requests, read_request);
6220         dbus_message_unref(read_request->msg);
6221         g_free(read_request);
6222
6223         if (!g_dbus_send_message(dbus_conn, reply))
6224                 error("D-Bus send failed");
6225 }
6226
6227 static DBusMessage *le_read_host_suggested_default_data_length(
6228                         DBusConnection *conn, DBusMessage *msg,
6229                         void *user_data)
6230 {
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;
6234
6235         if (find_read_le_data_length_request(adapter))
6236                 return btd_error_in_progress(msg);
6237
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");
6240
6241         read_request = g_new(struct le_data_length_read_request, 1);
6242
6243         read_request->msg = dbus_message_ref(msg);
6244         read_request->adapter = adapter;
6245
6246         read_requests = g_slist_append(read_requests, read_request);
6247
6248         handler = g_new0(struct le_data_length_read_default_data_length_handler, 1);
6249
6250         handler->read_callback =
6251                 (read_host_suggested_default_data_length_cb_t)le_read_host_suggested_default_length_complete;
6252
6253         read_request->adapter->def_read_handler = handler;
6254
6255         return NULL;
6256 }
6257
6258 static void get_le_batching_available_pkts_complete(
6259                         uint8_t status, uint16_t length,
6260                         const void *param, void *user_data)
6261 {
6262         const struct mgmt_rp_get_le_batching_buffer *rp = param;
6263         struct le_batching_request *request =
6264                 (struct le_batching_request*)user_data;
6265         DBusMessage *reply;
6266
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);
6271                 else
6272                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6273                 goto done;
6274         }
6275
6276         if (length < sizeof(*rp)) {
6277                 reply = btd_error_failed(request->msg,
6278                         "Wrong size of get le batching buffer");
6279                 goto done;
6280         }
6281
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,
6286                                 DBUS_TYPE_INVALID);
6287         if (!reply)
6288                 reply = btd_error_failed(request->msg,
6289                                         "Failed to create reply.");
6290
6291 done:
6292         if (!g_dbus_send_message(dbus_conn, reply))
6293                 error("D-Bus send failed");
6294
6295         dbus_message_unref(request->msg);
6296         g_free(request);
6297 }
6298
6299 static DBusMessage *adapter_get_le_batching_available_pkts(DBusConnection *conn,
6300                                                 DBusMessage *msg, void *data)
6301 {
6302         struct btd_adapter *adapter = data;
6303         struct le_batching_request *request;
6304         DBusMessage *reply;
6305         dbus_uint32_t val;
6306
6307         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6308                 return btd_error_not_ready(msg);
6309
6310         if (adapter->le_batching_available_pkts < 0)
6311                 return btd_error_not_supported(msg);
6312
6313         if (adapter->le_batching_available_pkts > 0) {
6314                 reply = dbus_message_new_method_return(msg);
6315                 if (!reply)
6316                         return NULL;
6317
6318                 val = adapter->le_batching_available_pkts;
6319                 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &val,
6320                                                                 DBUS_TYPE_INVALID);
6321                 DBG("LE Batching buffer: [%u]", val);
6322                 return reply;
6323         }
6324
6325         request = g_new(struct le_batching_request, 1);
6326
6327         request->msg = dbus_message_ref(msg);
6328         request->adapter = adapter;
6329
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);
6334                 g_free(request);
6335                 return btd_error_failed(msg, "Unable to get le batching buffer");
6336         }
6337
6338         return NULL;
6339 }
6340
6341 static void set_le_batching_enable_complete(
6342                         uint8_t status, uint16_t length,
6343                         const void *param, void *user_data)
6344 {
6345         const struct mgmt_rp_set_le_batching_enable *rp = param;
6346         struct le_batching_request *request =
6347                 (struct le_batching_request*)user_data;
6348         DBusMessage *reply;
6349
6350         DBG("");
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);
6355                 else
6356                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6357                 goto done;
6358         }
6359
6360         if (length < sizeof(*rp)) {
6361                 reply = btd_error_failed(request->msg,
6362                         "Wrong size of set le batching enable");
6363                 goto done;
6364         }
6365
6366         reply = g_dbus_create_reply(request->msg,
6367                                 DBUS_TYPE_INVALID);
6368         if (!reply)
6369                 reply = btd_error_failed(request->msg,
6370                                         "Failed to create reply.");
6371
6372 done:
6373         if (!g_dbus_send_message(dbus_conn, reply))
6374                 error("D-Bus send failed");
6375
6376         dbus_message_unref(request->msg);
6377         g_free(request);
6378 }
6379
6380 static void set_le_batching_param_complete(
6381                         uint8_t status, uint16_t length,
6382                         const void *param, void *user_data)
6383 {
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;
6388         DBusMessage *reply;
6389
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);
6394                 else
6395                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6396                 goto done;
6397         }
6398
6399         if (length < sizeof(*rp)) {
6400                 reply = btd_error_failed(request->msg,
6401                         "Wrong size of set le batching param");
6402                 goto done;
6403         }
6404
6405         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6406         cp.bdaddr = request->bdaddr;
6407         cp.enable = 1;
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");
6412                 goto done;
6413         }
6414
6415         return;
6416 done:
6417         if (!g_dbus_send_message(dbus_conn, reply))
6418                 error("D-Bus send failed");
6419
6420         dbus_message_unref(request->msg);
6421         g_free(request);
6422 }
6423
6424 static DBusMessage *adapter_enable_le_batching(DBusConnection *conn,
6425                                                 DBusMessage *msg, void *data)
6426 {
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;
6434
6435         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6436                 return btd_error_not_ready(msg);
6437
6438         if (!dbus_message_get_args(msg, NULL,
6439                                 DBUS_TYPE_STRING, &address,
6440                                 DBUS_TYPE_INT32, &packet_threshold,
6441                                 DBUS_TYPE_INT32, &timeout,
6442                                 DBUS_TYPE_INVALID))
6443                 return btd_error_invalid_args(msg);
6444
6445         if (packet_threshold < 0 || packet_threshold > 0x7fff ||
6446                 timeout < 0 || timeout > 0x7fff)
6447                 return btd_error_invalid_args(msg);
6448
6449         DBG("Set LE batching param: [%s %d %d]", address,
6450                         packet_threshold, timeout);
6451
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));
6455
6456         if (bachk(address) < 0)
6457                 return btd_error_invalid_args(msg);
6458
6459         cp.bdaddr = bt_addr;
6460         cp.pkt_th = packet_threshold;
6461         /* 1sec = 100 */
6462         cp.timeout = timeout * 100;
6463
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);
6472                 g_free(request);
6473                 return btd_error_failed(msg, "Unable to set le batching param");
6474         }
6475
6476         return NULL;
6477 }
6478
6479 static DBusMessage *adapter_disable_le_batching(DBusConnection *conn,
6480                                                 DBusMessage *msg, void *data)
6481 {
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;
6487
6488         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6489                 return btd_error_not_ready(msg);
6490
6491         if (!dbus_message_get_args(msg, NULL,
6492                                 DBUS_TYPE_STRING, &address,
6493                                 DBUS_TYPE_INVALID))
6494                 return btd_error_invalid_args(msg);
6495
6496         DBG("Disable LE Batching: [%s]", address);
6497
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));
6501
6502         if (bachk(address) < 0)
6503                 return btd_error_invalid_args(msg);
6504
6505         cp.bdaddr = bt_addr;
6506         cp.enable = 0;
6507
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);
6515                 g_free(request);
6516                 return btd_error_failed(msg, "Unable to set le batching enable");
6517         }
6518
6519         return NULL;
6520 }
6521
6522 void le_set_data_length_return_param_complete(
6523                         uint8_t status, uint16_t length,
6524                         const void *param, void *user_data)
6525 {
6526         if (status != MGMT_STATUS_SUCCESS) {
6527                 error("le_set_data_length failed: %s (0x%02x)",
6528                         mgmt_errstr(status), status);
6529         }
6530
6531         return;
6532 }
6533
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)
6536 {
6537         struct mgmt_cp_le_set_data_length cp;
6538
6539         memset(&cp, 0, sizeof(cp));
6540
6541         bacpy(&cp.bdaddr, bdaddr);
6542
6543         cp.max_tx_octets = max_tx_octets;
6544         cp.max_tx_time = max_tx_time;
6545
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,
6549                         adapter, NULL) > 0)
6550                 return 0;
6551
6552         return -EIO;
6553 }
6554
6555 static DBusMessage *adapter_set_manufacturer_data(DBusConnection *conn,
6556                                                 DBusMessage *msg, void *data)
6557 {
6558         struct btd_adapter *adapter = data;
6559         struct mgmt_cp_set_manufacturer_data cp;
6560         uint8_t *value;
6561         int32_t len = 0;
6562
6563         DBG("Set manufacturer data");
6564
6565         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6566                 return btd_error_not_ready(msg);
6567
6568         if (!dbus_message_get_args(msg, NULL,
6569                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
6570                         DBUS_TYPE_INVALID))
6571                 return btd_error_invalid_args(msg);
6572
6573         if (len > EIR_MANUFACTURER_DATA_LENGTH_MAX)
6574                 return btd_error_invalid_args(msg);
6575
6576         memcpy(&cp, value, len);
6577
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);
6582
6583         return btd_error_failed(msg, "Set manufacturer data failed");
6584 }
6585
6586 static DBusMessage *adapter_get_energy_info(DBusConnection *conn,
6587                                                 DBusMessage *msg, void *user_data)
6588 {
6589         DBusMessage *reply;
6590         uint32_t tx_time = 0;
6591         uint32_t rx_time = 0;
6592         uint32_t idle_time = 0;
6593         uint32_t energy_used = 0;
6594
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);
6599                 goto done;
6600         }
6601
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,
6607                                 DBUS_TYPE_INVALID);
6608
6609         if (!reply)
6610                 reply = btd_error_failed(msg,
6611                                         "Failed to create reply.");
6612
6613 done:
6614         return reply;
6615 }
6616
6617
6618 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
6619
6620 static DBusMessage *start_discovery(DBusConnection *conn,
6621                                         DBusMessage *msg, void *user_data)
6622 {
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;
6627         int err;
6628
6629         DBG("sender %s", sender);
6630
6631         if (!btd_adapter_get_powered(adapter))
6632                 return btd_error_not_ready(msg);
6633
6634         is_discovering = get_discovery_client(adapter, sender, &client);
6635
6636         /*
6637          * Every client can only start one discovery, if the client
6638          * already started a discovery then return an error.
6639          */
6640         if (is_discovering)
6641                 return btd_error_busy(msg);
6642
6643         /*
6644          * If there was pre-set filter, just reconnect it to discovery_list,
6645          * and trigger scan.
6646          */
6647         if (client) {
6648                 if (client->msg)
6649                         return btd_error_busy(msg);
6650
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);
6655
6656                 goto done;
6657         }
6658
6659         client = g_new0(struct discovery_client, 1);
6660
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,
6666                                                 NULL);
6667         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
6668                                                                 client);
6669
6670 done:
6671         /*
6672          * Just trigger the discovery here. In case an already running
6673          * discovery in idle phase exists, it will be restarted right
6674          * away.
6675          */
6676         err = update_discovery_filter(adapter);
6677         if (!err)
6678                 return dbus_message_new_method_return(msg);
6679
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;
6685 #endif
6686                 return NULL;
6687
6688         }
6689
6690         return btd_error_failed(msg, strerror(-err));
6691 }
6692
6693 static bool parse_uuids(DBusMessageIter *value, struct discovery_filter *filter)
6694 {
6695         DBusMessageIter arriter;
6696
6697         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_ARRAY)
6698                 return false;
6699
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];
6704                 char *uuid_param;
6705
6706                 if (dbus_message_iter_get_arg_type(&arriter) !=
6707                                                 DBUS_TYPE_STRING)
6708                         return false;
6709
6710                 dbus_message_iter_get_basic(&arriter, &uuid_param);
6711
6712                 if (bt_string_to_uuid(&uuid, uuid_param))
6713                         return false;
6714
6715                 bt_uuid_to_uuid128(&uuid, &u128);
6716                 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
6717
6718                 filter->uuids = g_slist_prepend(filter->uuids, g_strdup(uuidstr));
6719
6720                 dbus_message_iter_next(&arriter);
6721         }
6722
6723         return true;
6724 }
6725
6726 static bool parse_rssi(DBusMessageIter *value, struct discovery_filter *filter)
6727 {
6728         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_INT16)
6729                 return false;
6730
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)
6734                 return false;
6735
6736         return true;
6737 }
6738
6739 static bool parse_pathloss(DBusMessageIter *value,
6740                                 struct discovery_filter *filter)
6741 {
6742         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT16)
6743                 return false;
6744
6745         dbus_message_iter_get_basic(value, &filter->pathloss);
6746         /* pathloss filter must be smaller that PATHLOSS_MAX */
6747         if (filter->pathloss > PATHLOSS_MAX)
6748                 return false;
6749
6750         return true;
6751 }
6752
6753 static bool parse_transport(DBusMessageIter *value,
6754                                         struct discovery_filter *filter)
6755 {
6756         char *transport_str;
6757
6758         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6759                 return false;
6760
6761         dbus_message_iter_get_basic(value, &transport_str);
6762
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"))
6768                 return false;
6769
6770         return true;
6771 }
6772
6773 static bool parse_duplicate_data(DBusMessageIter *value,
6774                                         struct discovery_filter *filter)
6775 {
6776         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6777                 return false;
6778
6779         dbus_message_iter_get_basic(value, &filter->duplicate);
6780
6781         return true;
6782 }
6783
6784 static bool parse_discoverable(DBusMessageIter *value,
6785                                         struct discovery_filter *filter)
6786 {
6787         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6788                 return false;
6789
6790         dbus_message_iter_get_basic(value, &filter->discoverable);
6791
6792         return true;
6793 }
6794
6795 static bool parse_pattern(DBusMessageIter *value,
6796                                         struct discovery_filter *filter)
6797 {
6798         const char *pattern;
6799
6800         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6801                 return false;
6802
6803         dbus_message_iter_get_basic(value, &pattern);
6804
6805         free(filter->pattern);
6806         filter->pattern = strdup(pattern);
6807
6808         return true;
6809 }
6810
6811 struct filter_parser {
6812         const char *name;
6813         bool (*func)(DBusMessageIter *iter, struct discovery_filter *filter);
6814 } parsers[] = {
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 },
6822         { }
6823 };
6824
6825 static bool parse_discovery_filter_entry(char *key, DBusMessageIter *value,
6826                                                 struct discovery_filter *filter)
6827 {
6828         struct filter_parser *parser;
6829
6830         for (parser = parsers; parser && parser->name; parser++) {
6831                 if (!strcmp(parser->name, key))
6832                         return parser->func(value, filter);
6833         }
6834
6835         DBG("Unknown key parameter: %s!\n", key);
6836         return false;
6837 }
6838
6839 /*
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.
6844  */
6845 static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
6846                                         struct discovery_filter **filter,
6847                                         DBusMessage *msg)
6848 {
6849         DBusMessageIter iter, subiter, dictiter, variantiter;
6850         bool is_empty = true;
6851
6852         *filter = g_try_malloc(sizeof(**filter));
6853         if (!*filter)
6854                 return false;
6855
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;
6863
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)
6867                 goto invalid_args;
6868
6869         dbus_message_iter_recurse(&iter, &subiter);
6870         do {
6871                 int type = dbus_message_iter_get_arg_type(&subiter);
6872                 char *key;
6873
6874                 if (type == DBUS_TYPE_INVALID)
6875                         break;
6876
6877                 is_empty = false;
6878                 dbus_message_iter_recurse(&subiter, &dictiter);
6879
6880                 dbus_message_iter_get_basic(&dictiter, &key);
6881                 if (!dbus_message_iter_next(&dictiter))
6882                         goto invalid_args;
6883
6884                 if (dbus_message_iter_get_arg_type(&dictiter) !=
6885                                                              DBUS_TYPE_VARIANT)
6886                         goto invalid_args;
6887
6888                 dbus_message_iter_recurse(&dictiter, &variantiter);
6889
6890                 if (!parse_discovery_filter_entry(key, &variantiter, *filter))
6891                         goto invalid_args;
6892
6893                 dbus_message_iter_next(&subiter);
6894         } while (true);
6895
6896         if (is_empty) {
6897                 g_free(*filter);
6898                 *filter = NULL;
6899                 return true;
6900         }
6901
6902         /* only pathlos or rssi can be set, never both */
6903         if ((*filter)->pathloss != DISTANCE_VAL_INVALID &&
6904             (*filter)->rssi != DISTANCE_VAL_INVALID)
6905                 goto invalid_args;
6906
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);
6913
6914         return true;
6915
6916 invalid_args:
6917         g_slist_free_full((*filter)->uuids, g_free);
6918         g_free(*filter);
6919         *filter = NULL;
6920         return false;
6921 }
6922
6923 static DBusMessage *set_discovery_filter(DBusConnection *conn,
6924                                         DBusMessage *msg, void *user_data)
6925 {
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;
6931
6932         DBG("sender %s", sender);
6933
6934         if (!btd_adapter_get_powered(adapter))
6935                 return btd_error_not_ready(msg);
6936
6937         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 8))
6938                 return btd_error_not_supported(msg);
6939
6940         /* parse parameters */
6941         if (!parse_discovery_filter_dict(adapter, &discovery_filter, msg))
6942                 return btd_error_invalid_args(msg);
6943
6944         is_discovering = get_discovery_client(adapter, sender, &client);
6945
6946         if (client) {
6947                 free_discovery_filter(client->discovery_filter);
6948                 client->discovery_filter = discovery_filter;
6949
6950                 if (is_discovering)
6951                         update_discovery_filter(adapter);
6952
6953                 if (discovery_filter || is_discovering)
6954                         return dbus_message_new_method_return(msg);
6955
6956                 /* Removing pre-set filter */
6957                 adapter->set_filter_list = g_slist_remove(
6958                                               adapter->set_filter_list,
6959                                               client);
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,
6970                                                 NULL);
6971                 adapter->set_filter_list = g_slist_prepend(
6972                                              adapter->set_filter_list, client);
6973
6974                 DBG("successfully pre-set filter");
6975         }
6976
6977         return dbus_message_new_method_return(msg);
6978 }
6979
6980 static DBusMessage *stop_discovery(DBusConnection *conn,
6981                                         DBusMessage *msg, void *user_data)
6982 {
6983         struct btd_adapter *adapter = user_data;
6984         const char *sender = dbus_message_get_sender(msg);
6985         struct discovery_client *client;
6986         GSList *list;
6987         int err;
6988
6989         DBG("sender %s", sender);
6990
6991         if (!btd_adapter_get_powered(adapter))
6992                 return btd_error_not_ready(msg);
6993
6994         list = g_slist_find_custom(adapter->discovery_list, sender,
6995                         compare_sender);
6996         if (!list)
6997                 return btd_error_failed(msg, "No discovery started");
6998
6999         client = list->data;
7000
7001         if (client->msg)
7002                 return btd_error_busy(msg);
7003
7004 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7005         err = discovery_stop(client, false);
7006 #else
7007         err = discovery_stop(client);
7008 #endif
7009         switch (err) {
7010                 case 0:
7011                         return dbus_message_new_method_return(msg);
7012                 case -EINPROGRESS:
7013                         client->msg = dbus_message_ref(msg);
7014 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7015                         adapter->client = client;
7016 #endif
7017                         return NULL;
7018                 default:
7019                         return btd_error_failed(msg, strerror(-err));
7020         }
7021 }
7022
7023 static gboolean property_get_address(const GDBusPropertyTable *property,
7024                                         DBusMessageIter *iter, void *user_data)
7025 {
7026         struct btd_adapter *adapter = user_data;
7027         char addr[18];
7028         const char *str = addr;
7029
7030         ba2str(&adapter->bdaddr, addr);
7031
7032         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7033
7034         return TRUE;
7035 }
7036
7037 static gboolean property_get_address_type(const GDBusPropertyTable *property,
7038                                         DBusMessageIter *iter, void *user_data)
7039 {
7040         struct btd_adapter *adapter = user_data;
7041         const char *str;
7042
7043         if ((adapter->current_settings & MGMT_SETTING_LE) &&
7044                                 (adapter->bdaddr_type == BDADDR_LE_RANDOM))
7045                 str = "random";
7046         else
7047                 str = "public";
7048
7049         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7050
7051         return TRUE;
7052 }
7053
7054 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7055 static gboolean property_get_le_address(const GDBusPropertyTable *property,
7056                                         DBusMessageIter *iter, void *user_data)
7057 {
7058         struct btd_adapter *adapter = user_data;
7059         DBusMessageIter entry;
7060         char addr[18];
7061         const char *str = addr;
7062         char *type = NULL;
7063
7064         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7065                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7066
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);
7070         } else {
7071                 ba2str(&adapter->bdaddr, addr);
7072                 type = g_strdup_printf("%d", BDADDR_LE_PUBLIC);
7073         }
7074
7075         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &type);
7076         g_free((void *)type);
7077
7078         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7079
7080         dbus_message_iter_close_container(iter, &entry);
7081
7082         return TRUE;
7083 }
7084 #endif
7085
7086 static gboolean property_get_name(const GDBusPropertyTable *property,
7087                                         DBusMessageIter *iter, void *user_data)
7088 {
7089         struct btd_adapter *adapter = user_data;
7090         const char *str = adapter->system_name ? : "";
7091
7092         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7093
7094         return TRUE;
7095 }
7096
7097 static gboolean property_get_alias(const GDBusPropertyTable *property,
7098                                         DBusMessageIter *iter, void *user_data)
7099 {
7100         struct btd_adapter *adapter = user_data;
7101         const char *str;
7102
7103         if (adapter->current_alias)
7104                 str = adapter->current_alias;
7105         else if (adapter->stored_alias)
7106                 str = adapter->stored_alias;
7107         else
7108                 str = adapter->system_name ? : "";
7109
7110         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7111
7112         return TRUE;
7113 }
7114
7115 static void property_set_alias(const GDBusPropertyTable *property,
7116                                 DBusMessageIter *iter,
7117                                 GDBusPendingPropertySet id, void *user_data)
7118 {
7119         struct btd_adapter *adapter = user_data;
7120         const char *name;
7121         int ret;
7122
7123         dbus_message_iter_get_basic(iter, &name);
7124
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);
7129                         return;
7130                 }
7131
7132                 /* restore to system name */
7133                 ret = set_name(adapter, adapter->system_name);
7134         } else {
7135                 if (g_strcmp0(adapter->stored_alias, name) == 0) {
7136                         /* alias already set, nothing to do */
7137                         g_dbus_pending_property_success(id);
7138                         return;
7139                 }
7140
7141                 /* set to alias */
7142                 ret = set_name(adapter, name);
7143         }
7144
7145         if (ret >= 0) {
7146                 g_free(adapter->stored_alias);
7147
7148                 if (g_str_equal(name, "")  == TRUE)
7149                         adapter->stored_alias = NULL;
7150                 else
7151                         adapter->stored_alias = g_strdup(name);
7152
7153                 store_adapter_info(adapter);
7154
7155                 g_dbus_pending_property_success(id);
7156                 return;
7157         }
7158
7159         if (ret == -EINVAL)
7160                 g_dbus_pending_property_error(id,
7161                                         ERROR_INTERFACE ".InvalidArguments",
7162                                         "Invalid arguments in method call");
7163         else
7164                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7165                                                         strerror(-ret));
7166 }
7167
7168 static gboolean property_get_class(const GDBusPropertyTable *property,
7169                                         DBusMessageIter *iter, void *user_data)
7170 {
7171         struct btd_adapter *adapter = user_data;
7172         dbus_uint32_t val = adapter->dev_class;
7173
7174         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
7175
7176         return TRUE;
7177 }
7178
7179 static gboolean property_get_a2dp_role(const GDBusPropertyTable *property,
7180                                         DBusMessageIter *iter, void *user_data)
7181 {
7182         struct btd_adapter *adapter = user_data;
7183         dbus_uint32_t val = adapter->a2dp_role;
7184
7185         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
7186
7187         return TRUE;
7188 }
7189
7190 static gboolean property_get_mode(struct btd_adapter *adapter,
7191                                 uint32_t setting, DBusMessageIter *iter)
7192 {
7193         dbus_bool_t enable;
7194
7195         enable = (adapter->current_settings & setting) ? TRUE : FALSE;
7196
7197         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
7198
7199         return TRUE;
7200 }
7201
7202 struct property_set_data {
7203         struct btd_adapter *adapter;
7204         uint32_t setting;
7205         GDBusPendingPropertySet id;
7206         uint8_t value;
7207 };
7208
7209 static void property_set_mode_complete(uint8_t status, uint16_t length,
7210                                         const void *param, void *user_data)
7211 {
7212         struct property_set_data *data = user_data;
7213         struct btd_adapter *adapter = data->adapter;
7214
7215         DBG("%s (0x%02x)", mgmt_errstr(status), status);
7216
7217         if (status != MGMT_STATUS_SUCCESS) {
7218                 const char *dbus_err;
7219
7220                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
7221                                                 mgmt_errstr(status), status);
7222
7223                 if (status == MGMT_STATUS_RFKILLED) {
7224                         dbus_err = ERROR_INTERFACE ".Blocked";
7225                         adapter_set_power_state(adapter,
7226                                         ADAPTER_POWER_STATE_OFF_BLOCKED);
7227                 } else {
7228                         dbus_err = ERROR_INTERFACE ".Failed";
7229                 }
7230
7231                 g_dbus_pending_property_error(data->id, dbus_err,
7232                                                         mgmt_errstr(status));
7233
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);
7238                 return;
7239         }
7240
7241         g_dbus_pending_property_success(data->id);
7242
7243         /*
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.
7247          */
7248         new_settings_callback(adapter->dev_id, length, param, adapter);
7249 }
7250
7251 static void clear_discoverable(struct btd_adapter *adapter)
7252 {
7253         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
7254                 return;
7255
7256         if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
7257                 return;
7258
7259         /* If no timeout is set do nothing as both connectable and discoverable
7260          * flags are persistent on power toggle.
7261          */
7262         if (!adapter->discoverable_timeout)
7263                 return;
7264
7265         /* If timeout was set kernel clears discoverable on its own when
7266          * powering off controller. This would leave connectable flag set
7267          * after power on.
7268          *
7269          * With kernel control clearing connectable clear also discoverable
7270          * flag so we need to clear connectable.
7271          */
7272         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
7273 }
7274
7275 static void property_set_mode(struct btd_adapter *adapter, uint32_t setting,
7276                                                 DBusMessageIter *value,
7277                                                 GDBusPendingPropertySet id)
7278 {
7279         struct property_set_data *data;
7280         struct mgmt_cp_set_discoverable cp;
7281         void *param;
7282         dbus_bool_t enable, current_enable;
7283         uint16_t opcode, len;
7284         uint8_t mode;
7285
7286         dbus_message_iter_get_basic(value, &enable);
7287
7288         if (adapter->pending_settings & setting) {
7289                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Busy",
7290                                                 NULL);
7291                 return;
7292         }
7293
7294         if (adapter->current_settings & setting)
7295                 current_enable = TRUE;
7296         else
7297                 current_enable = FALSE;
7298
7299         if (enable == current_enable) {
7300                 g_dbus_pending_property_success(id);
7301                 return;
7302         }
7303
7304         mode = (enable == TRUE) ? 0x01 : 0x00;
7305
7306         switch (setting) {
7307         case MGMT_SETTING_POWERED:
7308                 opcode = MGMT_OP_SET_POWERED;
7309                 param = &mode;
7310                 len = sizeof(mode);
7311
7312                 if (!mode) {
7313                         btd_adv_monitor_power_down(
7314                                                 adapter->adv_monitor_manager);
7315                         clear_discoverable(adapter);
7316                         remove_temporary_devices(adapter);
7317                 }
7318
7319                 break;
7320         case MGMT_SETTING_DISCOVERABLE:
7321 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7322                 if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
7323                         if (mode) {
7324                                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
7325                                                                         mode);
7326                         } else {
7327                                 opcode = MGMT_OP_SET_CONNECTABLE;
7328                                 param = &mode;
7329                                 len = sizeof(mode);
7330                                 break;
7331                         }
7332                 }
7333 #endif
7334
7335                 memset(&cp, 0, sizeof(cp));
7336                 cp.val = mode;
7337                 if (cp.val)
7338                         cp.timeout = htobs(adapter->discoverable_timeout);
7339
7340                 opcode = MGMT_OP_SET_DISCOVERABLE;
7341                 param = &cp;
7342                 len = sizeof(cp);
7343                 break;
7344         case MGMT_SETTING_BONDABLE:
7345                 opcode = MGMT_OP_SET_BONDABLE;
7346                 param = &mode;
7347                 len = sizeof(mode);
7348                 break;
7349 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7350         case MGMT_SETTING_CONNECTABLE:
7351                 opcode = MGMT_OP_SET_CONNECTABLE;
7352                 param = &mode;
7353                 len = sizeof(mode);
7354                 break;
7355 #endif
7356         default:
7357                 goto failed;
7358         }
7359
7360         DBG("sending %s command for index %u", mgmt_opstr(opcode),
7361                                                         adapter->dev_id);
7362
7363         data = g_try_new0(struct property_set_data, 1);
7364         if (!data)
7365                 goto failed;
7366
7367         data->adapter = adapter;
7368         data->setting = setting;
7369         data->id = id;
7370         data->setting = setting;
7371         data->value = mode;
7372
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);
7378         }
7379
7380 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7381         /*
7382          * Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
7383          */
7384         if (mgmt_send_nowait(adapter->mgmt, opcode, adapter->dev_id, len, param,
7385                                 property_set_mode_complete, data, g_free) > 0)
7386                 return;
7387 #else
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;
7391                 return;
7392         }
7393 #endif
7394
7395         g_free(data);
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);
7401         }
7402
7403 failed:
7404         btd_error(adapter->dev_id, "Failed to set mode for index %u",
7405                                                         adapter->dev_id);
7406
7407         g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
7408 }
7409
7410 static gboolean property_get_powered(const GDBusPropertyTable *property,
7411                                         DBusMessageIter *iter, void *user_data)
7412 {
7413         struct btd_adapter *adapter = user_data;
7414
7415         return property_get_mode(adapter, MGMT_SETTING_POWERED, iter);
7416 }
7417
7418 static void property_set_powered(const GDBusPropertyTable *property,
7419                                 DBusMessageIter *iter,
7420                                 GDBusPendingPropertySet id, void *user_data)
7421 {
7422         struct btd_adapter *adapter = user_data;
7423
7424         if (powering_down) {
7425                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7426                                                         "Powering down");
7427                 return;
7428         }
7429
7430         property_set_mode(adapter, MGMT_SETTING_POWERED, iter, id);
7431 }
7432
7433 static gboolean property_get_power_state(const GDBusPropertyTable *property,
7434                                         DBusMessageIter *iter, void *user_data)
7435 {
7436         struct btd_adapter *adapter = user_data;
7437         const char *str;
7438
7439         str = adapter_power_state_str(adapter->power_state);
7440         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7441
7442         return TRUE;
7443 }
7444
7445 static gboolean property_get_discoverable(const GDBusPropertyTable *property,
7446                                         DBusMessageIter *iter, void *user_data)
7447 {
7448         struct btd_adapter *adapter = user_data;
7449
7450         return property_get_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter);
7451 }
7452
7453 static void property_set_discoverable(const GDBusPropertyTable *property,
7454                                 DBusMessageIter *iter,
7455                                 GDBusPendingPropertySet id, void *user_data)
7456 {
7457         struct btd_adapter *adapter = user_data;
7458
7459         if (adapter->discoverable_timeout > 0 &&
7460                         !btd_adapter_get_powered(adapter)) {
7461                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7462                                                                 "Not Powered");
7463                 return;
7464         }
7465
7466         /* Reset discovery_discoverable as Discoverable takes precedence */
7467         adapter->discovery_discoverable = false;
7468
7469         property_set_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter, id);
7470 }
7471
7472 static gboolean property_get_discoverable_timeout(
7473                                         const GDBusPropertyTable *property,
7474                                         DBusMessageIter *iter, void *user_data)
7475 {
7476         struct btd_adapter *adapter = user_data;
7477         dbus_uint32_t value = adapter->discoverable_timeout;
7478
7479         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7480
7481         return TRUE;
7482 }
7483
7484 static void property_set_discoverable_timeout(
7485                                 const GDBusPropertyTable *property,
7486                                 DBusMessageIter *iter,
7487                                 GDBusPendingPropertySet id, void *user_data)
7488 {
7489         struct btd_adapter *adapter = user_data;
7490         bool enabled;
7491         dbus_uint32_t value;
7492
7493         dbus_message_iter_get_basic(iter, &value);
7494
7495         adapter->discoverable_timeout = value;
7496
7497         g_dbus_pending_property_success(id);
7498
7499         store_adapter_info(adapter);
7500
7501         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7502                                 ADAPTER_INTERFACE, "DiscoverableTimeout");
7503
7504         if (adapter->pending_settings & MGMT_SETTING_DISCOVERABLE) {
7505                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7506                         enabled = false;
7507                 else
7508                         enabled = true;
7509         } else {
7510                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7511                         enabled = true;
7512                 else
7513                         enabled = false;
7514         }
7515
7516         if (enabled)
7517                 set_discoverable(adapter, 0x01, adapter->discoverable_timeout);
7518 }
7519
7520 static gboolean property_get_pairable(const GDBusPropertyTable *property,
7521                                         DBusMessageIter *iter, void *user_data)
7522 {
7523         struct btd_adapter *adapter = user_data;
7524
7525         return property_get_mode(adapter, MGMT_SETTING_BONDABLE, iter);
7526 }
7527
7528 static void property_set_pairable(const GDBusPropertyTable *property,
7529                                 DBusMessageIter *iter,
7530                                 GDBusPendingPropertySet id, void *user_data)
7531 {
7532         struct btd_adapter *adapter = user_data;
7533
7534         property_set_mode(adapter, MGMT_SETTING_BONDABLE, iter, id);
7535 }
7536
7537 static gboolean property_get_pairable_timeout(
7538                                         const GDBusPropertyTable *property,
7539                                         DBusMessageIter *iter, void *user_data)
7540 {
7541         struct btd_adapter *adapter = user_data;
7542         dbus_uint32_t value = adapter->pairable_timeout;
7543
7544         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7545
7546         return TRUE;
7547 }
7548
7549 static void property_set_pairable_timeout(const GDBusPropertyTable *property,
7550                                 DBusMessageIter *iter,
7551                                 GDBusPendingPropertySet id, void *user_data)
7552 {
7553         struct btd_adapter *adapter = user_data;
7554         dbus_uint32_t value;
7555
7556         dbus_message_iter_get_basic(iter, &value);
7557
7558         adapter->pairable_timeout = value;
7559
7560         g_dbus_pending_property_success(id);
7561
7562         store_adapter_info(adapter);
7563
7564         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7565                                         ADAPTER_INTERFACE, "PairableTimeout");
7566
7567         trigger_pairable_timeout(adapter);
7568 }
7569
7570 static gboolean property_get_discovering(const GDBusPropertyTable *property,
7571                                         DBusMessageIter *iter, void *user_data)
7572 {
7573         struct btd_adapter *adapter = user_data;
7574         dbus_bool_t discovering = adapter->discovering;
7575
7576         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7577
7578         return TRUE;
7579 }
7580
7581 static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
7582 {
7583         GHashTable *uuids = user_data;
7584         bt_uuid_t uuid, u128;
7585         char uuidstr[MAX_LEN_UUID_STR + 1];
7586
7587         if (!gatt_db_service_get_active(attrib))
7588                 return;
7589
7590         if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
7591                 return;
7592
7593         bt_uuid_to_uuid128(&uuid, &u128);
7594         bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
7595
7596         g_hash_table_add(uuids, strdup(uuidstr));
7597 }
7598
7599 static void iter_append_uuid(gpointer key, gpointer value, gpointer user_data)
7600 {
7601         DBusMessageIter *iter = user_data;
7602         const char *uuid = key;
7603
7604         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
7605 }
7606
7607 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7608 static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
7609                                         DBusMessageIter *iter, void *user_data)
7610 {
7611         struct btd_adapter *adapter = user_data;
7612         dbus_bool_t discovering = adapter->le_discovering;
7613
7614         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7615
7616         return TRUE;
7617 }
7618
7619 static gboolean property_get_connectable(const GDBusPropertyTable *property,
7620                                         DBusMessageIter *iter, void *user_data)
7621 {
7622         struct btd_adapter *adapter = user_data;
7623
7624         return property_get_mode(adapter, MGMT_SETTING_CONNECTABLE, iter);
7625 }
7626
7627 static void property_set_connectable(const GDBusPropertyTable *property,
7628                                 DBusMessageIter *iter,
7629                                 GDBusPendingPropertySet id, void *user_data)
7630 {
7631         struct btd_adapter *adapter = user_data;
7632
7633         property_set_mode(adapter, MGMT_SETTING_CONNECTABLE, iter, id);
7634 }
7635
7636 static gboolean property_get_version(const GDBusPropertyTable *property,
7637                                         DBusMessageIter *iter, void *user_data)
7638 {
7639         struct btd_adapter *adapter = user_data;
7640         const char *str = adapter->version ? : "";
7641
7642         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7643
7644         return TRUE;
7645 }
7646
7647 static gboolean property_get_supported_le_features(
7648                                         const GDBusPropertyTable *property,
7649                                         DBusMessageIter *iter, void *user_data)
7650 {
7651         const char *str, *val;
7652         int value;
7653         DBusMessageIter entry;
7654         struct btd_adapter *adapter = user_data;
7655
7656         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7657                         DBUS_TYPE_STRING_AS_STRING, &entry);
7658
7659         value = adapter_le_get_max_adv_instance();
7660         if (value > 0) {
7661                 str = g_strdup("adv_inst_max");
7662                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7663
7664                 val = g_strdup_printf("%d", value);
7665                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7666
7667                 g_free((void *)str);
7668                 g_free((void *)val);
7669         }
7670
7671         value = adapter_le_is_supported_offloading();
7672         if (value > 0) {
7673                 str = g_strdup("rpa_offloading");
7674                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7675
7676                 val = g_strdup_printf("%d", value);
7677                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7678
7679                 g_free((void *)str);
7680                 g_free((void *)val);
7681         }
7682
7683         value = adapter_le_get_scan_filter_size();
7684 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
7685         if (value <= 0)
7686                 value = SCAN_FILTER_SLOTS_MAX;
7687 #endif
7688         if (value >= 0) {
7689                 str = g_strdup("max_filter");
7690                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7691
7692                 val = g_strdup_printf("%d", value);
7693                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7694
7695                 g_free((void *)str);
7696                 g_free((void *)val);
7697         }
7698
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);
7703
7704                 if (adapter->le_2m_phy_supported)
7705                         val = g_strdup("true");
7706                 else
7707                         val = g_strdup("false");
7708
7709                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7710
7711                 g_free((void *)str);
7712                 g_free((void *)val);
7713
7714                 /* CODED PHY Support */
7715                 str = g_strdup("coded_phy");
7716                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7717
7718                 if (adapter->le_coded_phy_supported)
7719                         val = g_strdup("true");
7720                 else
7721                         val = g_strdup("false");
7722
7723                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7724
7725                 g_free((void *)str);
7726                 g_free((void *)val);
7727         }
7728
7729         dbus_message_iter_close_container(iter, &entry);
7730
7731         return TRUE;
7732 }
7733
7734 static gboolean property_get_ipsp_init_state(
7735                                         const GDBusPropertyTable *property,
7736                                         DBusMessageIter *iter, void *data)
7737 {
7738         struct btd_adapter *adapter = data;
7739         dbus_bool_t ipsp_initialized;
7740
7741         if (adapter->ipsp_intialized)
7742                 ipsp_initialized = TRUE;
7743         else
7744                 ipsp_initialized = FALSE;
7745
7746         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
7747                                         &ipsp_initialized);
7748
7749         return TRUE;
7750 }
7751 #endif
7752
7753 static gboolean property_get_uuids(const GDBusPropertyTable *property,
7754                                         DBusMessageIter *iter, void *user_data)
7755 {
7756         struct btd_adapter *adapter = user_data;
7757         DBusMessageIter entry;
7758         sdp_list_t *l;
7759         struct gatt_db *db;
7760         GHashTable *uuids;
7761
7762         uuids = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
7763         if (!uuids)
7764                 return FALSE;
7765
7766         /* SDP records */
7767         for (l = adapter->services; l != NULL; l = l->next) {
7768                 sdp_record_t *rec = l->data;
7769                 char *uuid;
7770
7771                 uuid = bt_uuid2string(&rec->svclass);
7772                 if (uuid == NULL)
7773                         continue;
7774
7775                 g_hash_table_add(uuids, uuid);
7776         }
7777
7778         /* GATT services */
7779         db = btd_gatt_database_get_db(adapter->database);
7780         if (db)
7781                 gatt_db_foreach_service(db, NULL, add_gatt_uuid, uuids);
7782
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);
7787
7788         g_hash_table_destroy(uuids);
7789
7790         return TRUE;
7791 }
7792
7793 static gboolean property_exists_modalias(const GDBusPropertyTable *property,
7794                                                         void *user_data)
7795 {
7796         struct btd_adapter *adapter = user_data;
7797
7798         return adapter->modalias ? TRUE : FALSE;
7799 }
7800
7801 static gboolean property_get_modalias(const GDBusPropertyTable *property,
7802                                         DBusMessageIter *iter, void *user_data)
7803 {
7804         struct btd_adapter *adapter = user_data;
7805         const char *str = adapter->modalias ? : "";
7806
7807         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7808
7809         return TRUE;
7810 }
7811
7812 static gboolean property_get_roles(const GDBusPropertyTable *property,
7813                                         DBusMessageIter *iter, void *user_data)
7814 {
7815         struct btd_adapter *adapter = user_data;
7816         DBusMessageIter entry;
7817
7818         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7819                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7820
7821         if (adapter->supported_settings & MGMT_SETTING_LE) {
7822                 const char *str = "central";
7823                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7824         }
7825
7826         if (adapter->supported_settings & MGMT_SETTING_ADVERTISING) {
7827                 const char *str = "peripheral";
7828                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7829         }
7830
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);
7835         }
7836
7837         dbus_message_iter_close_container(iter, &entry);
7838
7839         return TRUE;
7840 }
7841
7842 static void property_append_experimental(void *data, void *user_data)
7843 {
7844         uint8_t *feature = data;
7845         DBusMessageIter *iter = user_data;
7846         uint128_t value;
7847         bt_uuid_t uuid;
7848         char str[MAX_LEN_UUID_STR + 1];
7849         char *ptr;
7850
7851         bswap_128(feature, &value);
7852         bt_uuid128_create(&uuid, value);
7853         bt_uuid_to_string(&uuid, str, sizeof(str));
7854
7855         ptr = str;
7856
7857         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &ptr);
7858 }
7859
7860 static gboolean property_get_experimental(const GDBusPropertyTable *property,
7861                                         DBusMessageIter *iter, void *user_data)
7862 {
7863         struct btd_adapter *adapter = user_data;
7864         DBusMessageIter entry;
7865
7866         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7867                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7868
7869         queue_foreach(adapter->exps, property_append_experimental, &entry);
7870
7871         dbus_message_iter_close_container(iter, &entry);
7872
7873         return TRUE;
7874 }
7875
7876 static gboolean property_experimental_exists(const GDBusPropertyTable *property,
7877                                                                 void *data)
7878 {
7879         struct btd_adapter *adapter = data;
7880
7881         return !queue_isempty(adapter->exps);
7882 }
7883
7884 static DBusMessage *remove_device(DBusConnection *conn,
7885                                         DBusMessage *msg, void *user_data)
7886 {
7887         struct btd_adapter *adapter = user_data;
7888         struct btd_device *device;
7889         const char *path;
7890         GSList *list;
7891
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);
7895
7896         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7897         if (!list)
7898                 return btd_error_does_not_exist(msg);
7899
7900         if (!btd_adapter_get_powered(adapter))
7901                 return btd_error_not_ready(msg);
7902
7903         device = list->data;
7904
7905         btd_device_set_temporary(device, true);
7906
7907         if (!btd_device_is_connected(device)) {
7908                 btd_adapter_remove_device(adapter, device);
7909                 return dbus_message_new_method_return(msg);
7910         }
7911
7912         device_request_disconnect(device, msg);
7913
7914         return NULL;
7915 }
7916
7917 static DBusMessage *get_discovery_filters(DBusConnection *conn,
7918                                         DBusMessage *msg, void *user_data)
7919 {
7920         DBusMessage *reply;
7921         DBusMessageIter iter, array;
7922         struct filter_parser *parser;
7923
7924         reply = dbus_message_new_method_return(msg);
7925
7926         dbus_message_iter_init_append(reply, &iter);
7927
7928         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
7929                                         DBUS_TYPE_STRING_AS_STRING, &array);
7930
7931         for (parser = parsers; parser && parser->name; parser++) {
7932                 dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
7933                                                         &parser->name);
7934         }
7935
7936         dbus_message_iter_close_container(&iter, &array);
7937
7938         return reply;
7939 }
7940
7941 struct device_connect_data {
7942         struct btd_adapter *adapter;
7943         bdaddr_t dst;
7944         uint8_t dst_type;
7945         DBusMessage *msg;
7946 };
7947
7948 static void device_browse_cb(struct btd_device *dev, int err, void *user_data)
7949 {
7950         DBG("err %d (%s)", err, strerror(-err));
7951
7952         if (!err)
7953                 btd_device_connect_services(dev, NULL);
7954 }
7955
7956 static void device_connect_cb(GIOChannel *io, GError *gerr, gpointer user_data)
7957 {
7958         struct device_connect_data *data = user_data;
7959         struct btd_adapter *adapter = data->adapter;
7960         struct btd_device *device;
7961         const char *path;
7962
7963         DBG("%s", gerr ? gerr->message : "");
7964
7965         if (gerr)
7966                 goto failed;
7967
7968         /* object might already exist due to mgmt socket event */
7969         device = btd_adapter_get_device(adapter, &data->dst, data->dst_type);
7970         if (!device)
7971                 goto failed;
7972
7973         path = device_get_path(device);
7974
7975         g_dbus_send_reply(dbus_conn, data->msg, DBUS_TYPE_OBJECT_PATH, &path,
7976                                                         DBUS_TYPE_INVALID);
7977
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);
7982 #else
7983         device_update_last_seen(device, data->dst_type, true);
7984 #endif
7985
7986         if (data->dst_type != BDADDR_BREDR){
7987                 g_io_channel_set_close_on_unref(io, FALSE);
7988                 device_attach_att(device, io);
7989         }
7990
7991         device_discover_services(device);
7992         device_wait_for_svc_complete(device, device_browse_cb, NULL);
7993
7994         g_io_channel_unref(io);
7995         dbus_message_unref(data->msg);
7996         free(data);
7997         return;
7998
7999 failed:
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);
8003         free(data);
8004 }
8005
8006 static void device_connect(struct btd_adapter *adapter, const bdaddr_t *dst,
8007                                         uint8_t dst_type, DBusMessage *msg)
8008 {
8009         struct device_connect_data *data;
8010         GIOChannel *io;
8011
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);
8017
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,
8026                                 BT_IO_OPT_INVALID);
8027         else
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,
8035                                 BT_IO_OPT_INVALID);
8036
8037         if (!io) {
8038                 g_dbus_send_message(dbus_conn,
8039                                 btd_error_failed(msg, "Connect failed"));
8040                 dbus_message_unref(data->msg);
8041                 free(data);
8042         }
8043 }
8044
8045 static DBusMessage *connect_device(DBusConnection *conn,
8046                                         DBusMessage *msg, void *user_data)
8047 {
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;
8052
8053         DBG("sender %s", dbus_message_get_sender(msg));
8054
8055         if (!btd_adapter_get_powered(adapter))
8056                 return btd_error_not_ready(msg);
8057
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);
8062
8063         dbus_message_iter_recurse(&iter, &subiter);
8064         while (true) {
8065                 int type = dbus_message_iter_get_arg_type(&subiter);
8066                 char *key;
8067                 char *str;
8068
8069                 if (type == DBUS_TYPE_INVALID)
8070                         break;
8071
8072                 dbus_message_iter_recurse(&subiter, &dictiter);
8073
8074                 dbus_message_iter_get_basic(&dictiter, &key);
8075                 if (!dbus_message_iter_next(&dictiter))
8076                         return btd_error_invalid_args(msg);
8077
8078                 if (dbus_message_iter_get_arg_type(&dictiter) !=
8079                                                         DBUS_TYPE_VARIANT)
8080                         return btd_error_invalid_args(msg);
8081
8082                 dbus_message_iter_recurse(&dictiter, &value);
8083
8084                 if (!strcmp(key, "Address")) {
8085                         if (dbus_message_iter_get_arg_type(&value) !=
8086                                                         DBUS_TYPE_STRING)
8087                                 return btd_error_invalid_args(msg);
8088
8089                         dbus_message_iter_get_basic(&value, &str);
8090
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) !=
8095                                                         DBUS_TYPE_STRING)
8096                                 return btd_error_invalid_args(msg);
8097
8098                         dbus_message_iter_get_basic(&value, &str);
8099
8100
8101                         if (!strcmp(str, "public"))
8102                                 addr_type = BDADDR_LE_PUBLIC;
8103                         else if (!strcmp(str, "random"))
8104                                 addr_type = BDADDR_LE_RANDOM;
8105                         else
8106                                 return btd_error_invalid_args(msg);
8107                 } else {
8108                         return btd_error_invalid_args(msg);
8109                 }
8110
8111                 dbus_message_iter_next(&subiter);
8112         }
8113
8114         if (!bacmp(&addr, BDADDR_ANY))
8115                 return btd_error_invalid_args(msg);
8116
8117         device_connect(adapter, &addr, addr_type, msg);
8118         return NULL;
8119 }
8120
8121 static void update_device_allowed_services(void *data, void *user_data)
8122 {
8123         struct btd_device *device = data;
8124
8125         btd_device_update_allowed_services(device);
8126 }
8127
8128 static void add_uuid_to_uuid_set(void *data, void *user_data)
8129 {
8130         bt_uuid_t *uuid = data;
8131         GHashTable *uuid_set = user_data;
8132
8133         if (!uuid) {
8134                 error("Found NULL in UUID allowed list");
8135                 return;
8136         }
8137
8138         g_hash_table_add(uuid_set, uuid);
8139 }
8140
8141 static guint bt_uuid_hash(gconstpointer key)
8142 {
8143         const bt_uuid_t *uuid = key;
8144         uint64_t uuid_128[2];
8145
8146         if (!uuid)
8147                 return 0;
8148
8149         bt_uuid_to_uuid128(uuid, (bt_uuid_t *)uuid_128);
8150
8151         return g_int64_hash(uuid_128) ^ g_int64_hash(uuid_128+1);
8152 }
8153
8154 static gboolean bt_uuid_equal(gconstpointer v1, gconstpointer v2)
8155 {
8156         const bt_uuid_t *uuid1 = v1;
8157         const bt_uuid_t *uuid2 = v2;
8158
8159         if (!uuid1 || !uuid2)
8160                 return !uuid1 && !uuid2;
8161
8162         return bt_uuid_cmp(uuid1, uuid2) == 0;
8163 }
8164
8165 bool btd_adapter_set_allowed_uuids(struct btd_adapter *adapter,
8166                                                         struct queue *uuids)
8167 {
8168         if (!adapter)
8169                 return false;
8170
8171         if (adapter->allowed_uuid_set)
8172                 g_hash_table_destroy(adapter->allowed_uuid_set);
8173
8174         adapter->allowed_uuid_set = g_hash_table_new(bt_uuid_hash,
8175                                                                 bt_uuid_equal);
8176         if (!adapter->allowed_uuid_set) {
8177                 btd_error(adapter->dev_id,
8178                                         "Failed to allocate allowed_uuid_set");
8179                 return false;
8180         }
8181
8182         queue_foreach(uuids, add_uuid_to_uuid_set, adapter->allowed_uuid_set);
8183         g_slist_foreach(adapter->devices, update_device_allowed_services, NULL);
8184
8185         return true;
8186 }
8187
8188 bool btd_adapter_is_uuid_allowed(struct btd_adapter *adapter,
8189                                                         const char *uuid_str)
8190 {
8191         bt_uuid_t uuid;
8192
8193         if (!adapter || !adapter->allowed_uuid_set)
8194                 return true;
8195
8196         if (bt_string_to_uuid(&uuid, uuid_str)) {
8197                 btd_error(adapter->dev_id,
8198                                 "Failed to parse UUID string '%s'", uuid_str);
8199                 return false;
8200         }
8201
8202         return !g_hash_table_size(adapter->allowed_uuid_set) ||
8203                 g_hash_table_contains(adapter->allowed_uuid_set, &uuid);
8204 }
8205
8206 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8207 static DBusMessage *adapter_unpair_device(DBusConnection *conn,
8208                                         DBusMessage *msg, void *user_data)
8209 {
8210         DBG("+");
8211         struct btd_adapter *adapter = user_data;
8212         struct btd_device *device;
8213         const char *path;
8214         GSList *list;
8215
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);
8219
8220         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
8221         if (!list)
8222                 return btd_error_does_not_exist(msg);
8223
8224         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8225                 return btd_error_not_ready(msg);
8226
8227         device = list->data;
8228
8229         btd_device_set_temporary(device, TRUE);
8230
8231         if (!btd_device_is_connected(device)) {
8232                 btd_adapter_unpair_device(adapter, device);
8233                 return dbus_message_new_method_return(msg);
8234         }
8235
8236         device_request_disconnect(device, msg);
8237
8238         DBG("-");
8239         return NULL;
8240 }
8241
8242 static DBusMessage *create_device(DBusConnection *conn,
8243                                         DBusMessage *msg, void *data)
8244 {
8245         struct btd_adapter *adapter = data;
8246         const gchar *address;
8247         bdaddr_t addr;
8248         DBG("+");
8249
8250         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8251                                                 DBUS_TYPE_INVALID) == FALSE)
8252                 return btd_error_invalid_args(msg);
8253
8254         if (bachk(address) < 0)
8255                 return btd_error_invalid_args(msg);
8256
8257         DBG("%s", address);
8258
8259         str2ba(address, &addr);
8260         btd_adapter_get_device(adapter, &addr, BDADDR_BREDR);
8261
8262         DBG("-");
8263         return dbus_message_new_method_return(msg);
8264 }
8265
8266 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
8267                                         void *data)
8268 {
8269         struct btd_adapter *adapter = data;
8270         struct btd_device *device;
8271         DBusMessage *reply;
8272         const gchar *address;
8273         GSList *l;
8274         const gchar *dev_path;
8275
8276         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8277                                 DBUS_TYPE_INVALID))
8278                 return btd_error_invalid_args(msg);
8279
8280         l = g_slist_find_custom(adapter->devices, address, device_rpa_cmp);
8281         if (!l)
8282                 l = g_slist_find_custom(adapter->devices, address,
8283                                                         device_address_cmp);
8284         if (!l)
8285                 return btd_error_does_not_exist(msg);
8286
8287         device = l->data;
8288
8289         reply = dbus_message_new_method_return(msg);
8290         if (!reply)
8291                 return NULL;
8292
8293         dev_path = device_get_path(device);
8294
8295         dbus_message_append_args(reply,
8296                         DBUS_TYPE_OBJECT_PATH, &dev_path,
8297                         DBUS_TYPE_INVALID);
8298
8299         return reply;
8300 }
8301
8302 static gboolean adapter_ipsp_connected(struct btd_adapter *adapter)
8303 {
8304         GSList *l, *next;
8305
8306         DBG("%s", adapter->path);
8307
8308         for (l = adapter->connections; l != NULL; l = next) {
8309                 struct btd_device *dev = l->data;
8310
8311                 next = g_slist_next(l);
8312
8313                 if (device_is_ipsp_connected(dev))
8314                         return TRUE;
8315         }
8316
8317         return FALSE;
8318 }
8319
8320 static void adapter_set_ipsp_init_state(struct btd_adapter *adapter, gboolean initialized)
8321 {
8322         if (adapter->ipsp_intialized == initialized)
8323                 return;
8324
8325         adapter->ipsp_intialized = initialized;
8326
8327         g_dbus_emit_property_changed(dbus_conn, adapter->path,
8328                                                 ADAPTER_INTERFACE, "IpspInitStateChanged");
8329 }
8330
8331 static void deinitialize_6lowpan_complete(uint8_t status, uint16_t length,
8332         const void *param, void *user_data)
8333 {
8334         struct btd_adapter *adapter = user_data;
8335         bool initialized = FALSE;
8336
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);
8340         else {
8341                 adapter_set_ipsp_init_state(adapter, initialized);
8342                 DBG("De-Initialize BT 6lowpan successfully for hci%u",
8343                         adapter->dev_id);
8344         }
8345 }
8346
8347 static bool deinitialize_6lowpan(struct btd_adapter *adapter)
8348 {
8349         struct mgmt_cp_enable_6lowpan cp;
8350
8351         memset(&cp, 0, sizeof(cp));
8352
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)
8357                 return true;
8358
8359         error("Failed to de-initialize BT 6Lowpan for index %u",
8360                 adapter->dev_id);
8361         return false;
8362 }
8363
8364 static void initialize_6lowpan_complete(uint8_t status, uint16_t length,
8365         const void *param, void *user_data)
8366 {
8367         struct btd_adapter *adapter = user_data;
8368         bool initialized = TRUE;
8369
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);
8373         else {
8374                 adapter_set_ipsp_init_state(adapter, initialized);
8375                 DBG("Initialize BT 6lowpan successfully for hci%u",
8376                         adapter->dev_id);
8377         }
8378 }
8379
8380 static bool initialize_6lowpan(struct btd_adapter *adapter)
8381 {
8382         struct mgmt_cp_enable_6lowpan cp;
8383
8384         memset(&cp, 0, sizeof(cp));
8385
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)
8390                 return true;
8391
8392         error("Failed to initialize BT 6Lowpan for index %u",
8393                 adapter->dev_id);
8394         return false;
8395 }
8396
8397 static DBusMessage *adapter_initialize_ipsp(DBusConnection *conn,
8398                                         DBusMessage *msg, void *data)
8399 {
8400         struct btd_adapter *adapter = data;
8401         dbus_bool_t err;
8402
8403         DBG("Initialize IPSP");
8404
8405         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8406                 return btd_error_not_ready(msg);
8407
8408         if (adapter->ipsp_intialized)
8409                 return btd_error_already_exists(msg);
8410
8411         /* Enable BT 6lowpan in kernel */
8412         err = initialize_6lowpan(adapter);
8413
8414         if (!err)
8415                 return btd_error_failed(msg, "Failed to initialize BT 6lowpan");
8416
8417         return dbus_message_new_method_return(msg);
8418 }
8419
8420 static DBusMessage *adapter_deinitialize_ipsp(DBusConnection *conn,
8421                                         DBusMessage *msg, void *data)
8422 {
8423         struct btd_adapter *adapter = data;
8424         dbus_bool_t err;
8425
8426         DBG("De-initialize IPSP");
8427
8428         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8429                 return btd_error_not_ready(msg);
8430
8431         if (!adapter->ipsp_intialized)
8432                 return btd_error_not_permitted(msg, "IPSP not initialized");
8433
8434         if (adapter_ipsp_connected(adapter))
8435                 return btd_error_not_permitted(msg, "IPSP Client device found connected");
8436
8437         /* Disable BT 6lowpan in kernel */
8438         err = deinitialize_6lowpan(adapter);
8439
8440         if (!err)
8441                 return btd_error_failed(msg, "Failed to deinitialize BT 6lowpan");
8442
8443         return dbus_message_new_method_return(msg);
8444 }
8445 #endif
8446
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" },
8478                                 { "type", "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",
8515                         NULL, NULL,
8516                         adapter_initialize_ipsp) },
8517         { GDBUS_METHOD("DeinitializeIpsp",
8518                         NULL, NULL,
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",
8533                         NULL, NULL,
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" },
8544                                 { "low_th", "i" },
8545                                 { "in_range_th", "i" },
8546                                 { "high_th", "i"}),
8547                         NULL,
8548                         adapter_enable_rssi) },
8549         { GDBUS_ASYNC_METHOD("GetRssiStrength",
8550                         GDBUS_ARGS({ "bt_address", "s" }, { "link_type", "i" }),
8551                         NULL,
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" }),
8558                         find_device) },
8559         { GDBUS_METHOD("SetWbsParameters",
8560                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8561                         NULL,
8562                         set_wbs_parameters) },
8563         { GDBUS_METHOD("SetNbParameters",
8564                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8565                         NULL,
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,
8572                         create_device) },
8573         { GDBUS_METHOD("GetEnergyInfo",
8574                         NULL,
8575                         GDBUS_ARGS({ "tx_time", "u" },
8576                                 { "rx_time", "u" },
8577                                 { "idle_time", "u" },
8578                                 { "energy_used", "u" }),
8579                         adapter_get_energy_info) },
8580 #endif
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",
8595                         NULL,
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" },
8601                                 { "timeout", "i"}),
8602                         NULL,
8603                         adapter_enable_le_batching) },
8604         { GDBUS_ASYNC_METHOD("DisableLeBatching",
8605                         GDBUS_ARGS({ "bt_address", "s" }),
8606                         NULL,
8607                         adapter_disable_le_batching) },
8608 #endif
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,
8614                                 connect_device) },
8615         { }
8616 };
8617
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) },
8638         { }
8639 };
8640 #endif
8641
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 },
8661 #endif
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 },
8676 #endif
8677
8678         { }
8679 };
8680
8681 static int str2buf(const char *str, uint8_t *buf, size_t blen)
8682 {
8683         int i, dlen;
8684
8685         if (str == NULL)
8686                 return -EINVAL;
8687
8688         memset(buf, 0, blen);
8689
8690         dlen = MIN((strlen(str) / 2), blen);
8691
8692         for (i = 0; i < dlen; i++)
8693                 sscanf(str + (i * 2), "%02hhX", &buf[i]);
8694
8695         return 0;
8696 }
8697
8698 static bool is_blocked_key(uint8_t key_type, uint8_t *key_value)
8699 {
8700         uint32_t i = 0;
8701
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)))
8706                         return true;
8707         }
8708
8709         return false;
8710 }
8711
8712 static struct link_key_info *get_key_info(GKeyFile *key_file, const char *peer)
8713 {
8714         struct link_key_info *info = NULL;
8715         char *str;
8716
8717         str = g_key_file_get_string(key_file, "LinkKey", "Key", NULL);
8718         if (!str || strlen(str) < 32)
8719                 goto failed;
8720
8721         info = g_new0(struct link_key_info, 1);
8722
8723         str2ba(peer, &info->bdaddr);
8724
8725         if (!strncmp(str, "0x", 2))
8726                 str2buf(&str[2], info->key, sizeof(info->key));
8727         else
8728                 str2buf(&str[0], info->key, sizeof(info->key));
8729
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",
8732                                                 NULL);
8733
8734         info->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8735                                                                 info->key);
8736
8737 failed:
8738         g_free(str);
8739
8740         return info;
8741 }
8742
8743 static struct smp_ltk_info *get_ltk(GKeyFile *key_file, const char *peer,
8744                                         uint8_t peer_type, const char *group)
8745 {
8746         struct smp_ltk_info *ltk = NULL;
8747         char *key;
8748         char *rand = NULL;
8749
8750         key = g_key_file_get_string(key_file, group, "Key", NULL);
8751         if (!key || strlen(key) < 32)
8752                 goto failed;
8753
8754         rand = g_key_file_get_string(key_file, group, "Rand", NULL);
8755         if (!rand)
8756                 goto failed;
8757
8758         ltk = g_new0(struct smp_ltk_info, 1);
8759
8760         /* Default to assuming a central key */
8761         ltk->central = true;
8762
8763         str2ba(peer, &ltk->bdaddr);
8764         ltk->bdaddr_type = peer_type;
8765
8766         /*
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
8770          * are ignored.
8771          *
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.
8775          */
8776         if (ltk->bdaddr_type == BDADDR_LE_RANDOM &&
8777                                         (ltk->bdaddr.b[5] & 0xc0) != 0xc0) {
8778                 g_free(ltk);
8779                 ltk = NULL;
8780                 goto failed;
8781         }
8782
8783         if (!strncmp(key, "0x", 2))
8784                 str2buf(&key[2], ltk->val, sizeof(ltk->val));
8785         else
8786                 str2buf(&key[0], ltk->val, sizeof(ltk->val));
8787
8788         if (!strncmp(rand, "0x", 2)) {
8789                 uint64_t rand_le;
8790                 str2buf(&rand[2], (uint8_t *) &rand_le, sizeof(rand_le));
8791                 ltk->rand = le64_to_cpu(rand_le);
8792         } else {
8793                 sscanf(rand, "%" PRIu64, &ltk->rand);
8794         }
8795
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",
8799                                                                         NULL);
8800         ltk->ediv = g_key_file_get_integer(key_file, group, "EDiv", NULL);
8801
8802         ltk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LTK,
8803                                                                 ltk->val);
8804
8805 failed:
8806         g_free(key);
8807         g_free(rand);
8808
8809         return ltk;
8810 }
8811
8812 static struct smp_ltk_info *get_ltk_info(GKeyFile *key_file, const char *peer,
8813                                                         uint8_t bdaddr_type)
8814 {
8815         DBG("%s", peer);
8816
8817         return get_ltk(key_file, peer, bdaddr_type, "LongTermKey");
8818 }
8819
8820 static struct smp_ltk_info *get_peripheral_ltk_info(GKeyFile *key_file,
8821                                                         const char *peer,
8822                                                         uint8_t bdaddr_type)
8823 {
8824         struct smp_ltk_info *ltk;
8825
8826         DBG("%s", peer);
8827
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.
8831          */
8832         ltk = get_ltk(key_file, peer, bdaddr_type, "PeripheralLongTermKey");
8833         if (!ltk)
8834                 ltk = get_ltk(key_file, peer, bdaddr_type, "SlaveLongTermKey");
8835
8836         if (ltk)
8837                 ltk->central = false;
8838
8839         return ltk;
8840 }
8841
8842 static struct irk_info *get_irk_info(GKeyFile *key_file, const char *peer,
8843                                                         uint8_t bdaddr_type)
8844 {
8845         struct irk_info *irk = NULL;
8846         char *str;
8847
8848         str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
8849 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8850         if (!str)
8851                 return NULL;
8852         if (strlen(str) < 32) {
8853                 g_free(str);
8854                 return NULL;
8855         }
8856 #else
8857         if (!str || strlen(str) < 32)
8858                 goto failed;
8859 #endif
8860
8861         irk = g_new0(struct irk_info, 1);
8862
8863         str2ba(peer, &irk->bdaddr);
8864         irk->bdaddr_type = bdaddr_type;
8865
8866         if (!strncmp(str, "0x", 2))
8867                 str2buf(&str[2], irk->val, sizeof(irk->val));
8868         else
8869                 str2buf(&str[0], irk->val, sizeof(irk->val));
8870
8871         irk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8872                                                                 irk->val);
8873
8874 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
8875 failed:
8876 #endif
8877         g_free(str);
8878
8879         return irk;
8880 }
8881
8882 static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
8883                                                         uint8_t bdaddr_type)
8884 {
8885         struct conn_param *param;
8886
8887         if (!g_key_file_has_group(key_file, "ConnectionParameters"))
8888                 return NULL;
8889
8890         param = g_new0(struct conn_param, 1);
8891
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",
8900                                                         "Latency", NULL);
8901         param->timeout = g_key_file_get_integer(key_file,
8902                                                         "ConnectionParameters",
8903                                                         "Timeout", NULL);
8904         str2ba(peer, &param->bdaddr);
8905         param->bdaddr_type = bdaddr_type;
8906
8907         return param;
8908 }
8909
8910 #if 0
8911 static int generate_and_write_irk(uint8_t *irk, GKeyFile *key_file,
8912                                                         const char *filename)
8913 {
8914         struct bt_crypto *crypto;
8915         char str_irk_out[33];
8916         gsize length = 0;
8917         GError *gerr = NULL;
8918         char *str;
8919         int i;
8920
8921         crypto = bt_crypto_new();
8922         if (!crypto) {
8923                 error("Failed to open crypto");
8924                 return -1;
8925         }
8926
8927         if (!bt_crypto_random_bytes(crypto, irk, 16)) {
8928                 error("Failed to generate IRK");
8929                 bt_crypto_unref(crypto);
8930                 return -1;
8931         }
8932
8933         bt_crypto_unref(crypto);
8934
8935         for (i = 0; i < 16; i++)
8936                 sprintf(str_irk_out + (i * 2), "%02x", irk[i]);
8937
8938         str_irk_out[32] = '\0';
8939         info("Generated IRK successfully");
8940
8941         g_key_file_set_string(key_file, "General", "IdentityResolvingKey",
8942                                                                 str_irk_out);
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,
8947                                                                 gerr->message);
8948                 g_error_free(gerr);
8949         }
8950         g_free(str);
8951         DBG("Generated IRK written to file");
8952         return 0;
8953 }
8954
8955 static int load_irk(struct btd_adapter *adapter, uint8_t *irk)
8956 {
8957         char filename[PATH_MAX];
8958         GKeyFile *key_file;
8959         GError *gerr = NULL;
8960         char *str_irk;
8961         int ret;
8962
8963         create_filename(filename, PATH_MAX, "/%s/identity",
8964                                         btd_adapter_get_storage_dir(adapter));
8965
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,
8969                                                                 gerr->message);
8970                 g_error_free(gerr);
8971         }
8972
8973         str_irk = g_key_file_get_string(key_file, "General",
8974                                                 "IdentityResolvingKey", NULL);
8975         if (!str_irk) {
8976                 info("No IRK stored");
8977                 ret = generate_and_write_irk(irk, key_file, filename);
8978                 g_key_file_free(key_file);
8979                 return ret;
8980         }
8981
8982         g_key_file_free(key_file);
8983
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");
8987                 g_free(str_irk);
8988                 return -1;
8989         }
8990
8991         g_free(str_irk);
8992         DBG("Successfully read IRK from file");
8993         return 0;
8994 }
8995
8996 static void set_privacy_complete(uint8_t status, uint16_t length,
8997                                         const void *param, void *user_data)
8998 {
8999         struct btd_adapter *adapter = user_data;
9000
9001         if (status != MGMT_STATUS_SUCCESS) {
9002                 btd_error(adapter->dev_id, "Failed to set privacy: %s (0x%02x)",
9003                                                 mgmt_errstr(status), status);
9004                 return;
9005         }
9006
9007         DBG("Successfuly set privacy for index %u", adapter->dev_id);
9008 }
9009
9010 static int set_privacy(struct btd_adapter *adapter, uint8_t privacy)
9011 {
9012         struct mgmt_cp_set_privacy cp;
9013
9014         memset(&cp, 0, sizeof(cp));
9015
9016         if (privacy) {
9017                 uint8_t irk[16];
9018
9019                 if (load_irk(adapter, irk) == 0) {
9020                         cp.privacy = privacy;
9021                         memcpy(cp.irk, irk, 16);
9022                 }
9023         }
9024
9025         DBG("sending set privacy command for index %u", adapter->dev_id);
9026         DBG("setting privacy mode 0x%02x for index %u", cp.privacy,
9027                                                         adapter->dev_id);
9028
9029         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
9030                                 adapter->dev_id, sizeof(cp), &cp,
9031                                 set_privacy_complete, adapter, NULL) > 0)
9032                 return 0;
9033
9034         btd_error(adapter->dev_id, "Failed to set privacy for index %u",
9035                                                         adapter->dev_id);
9036
9037         return -1;
9038 }
9039 #endif
9040
9041 static void load_link_keys_complete(uint8_t status, uint16_t length,
9042                                         const void *param, void *user_data)
9043 {
9044         struct btd_adapter *adapter = user_data;
9045
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);
9050                 return;
9051         }
9052
9053         DBG("link keys loaded for hci%u", adapter->dev_id);
9054 }
9055
9056 static void load_link_keys(struct btd_adapter *adapter, GSList *keys,
9057                                                         bool debug_keys)
9058 {
9059         struct mgmt_cp_load_link_keys *cp;
9060         struct mgmt_link_key_info *key;
9061         size_t key_count, cp_size;
9062         unsigned int id;
9063         GSList *l;
9064
9065         /*
9066          * If the controller does not support BR/EDR operation,
9067          * there is no point in trying to load the link keys into
9068          * the kernel.
9069          *
9070          * This is an optimization for Low Energy only controllers.
9071          */
9072         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
9073                 return;
9074
9075         key_count = g_slist_length(keys);
9076
9077         DBG("hci%u keys %zu debug_keys %d", adapter->dev_id, key_count,
9078                                                                 debug_keys);
9079
9080         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
9081
9082         cp = g_try_malloc0(cp_size);
9083         if (cp == NULL) {
9084                 btd_error(adapter->dev_id, "No memory for link keys for hci%u",
9085                                                         adapter->dev_id);
9086                 return;
9087         }
9088
9089         /*
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.
9093          *
9094          * In addition it is also the only way to toggle the different
9095          * behavior for debug keys.
9096          */
9097         cp->debug_keys = debug_keys;
9098         cp->key_count = htobs(key_count);
9099
9100         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
9101                 struct link_key_info *info = l->data;
9102
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;
9108         }
9109
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);
9113
9114         g_free(cp);
9115
9116         if (id == 0)
9117                 btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
9118                                                         adapter->dev_id);
9119 }
9120
9121 static void load_ltks_complete(uint8_t status, uint16_t length,
9122                                         const void *param, void *user_data)
9123 {
9124         struct btd_adapter *adapter = user_data;
9125
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);
9130         }
9131
9132         DBG("LTKs loaded for hci%u", adapter->dev_id);
9133 }
9134
9135 static void load_ltks(struct btd_adapter *adapter, GSList *keys)
9136 {
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;
9140         GSList *l;
9141         uint16_t mtu;
9142
9143         /*
9144          * If the controller does not support Low Energy operation,
9145          * there is no point in trying to load the long term keys
9146          * into the kernel.
9147          *
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).
9152          */
9153         if (!(adapter->supported_settings & MGMT_SETTING_LE))
9154                 return;
9155
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);
9160
9161         DBG("hci%u keys %zu", adapter->dev_id, key_count);
9162
9163         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
9164
9165         cp = g_try_malloc0(cp_size);
9166         if (cp == NULL) {
9167                 btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
9168                                                         adapter->dev_id);
9169                 return;
9170         }
9171
9172         /*
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.
9176          */
9177         cp->key_count = htobs(key_count);
9178
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;
9183
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;
9192
9193                 /* Mark device as paired as their LTKs can be loaded. */
9194                 dev = btd_adapter_find_device(adapter, &info->bdaddr,
9195                                                         info->bdaddr_type);
9196                 if (dev) {
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,
9200                                                 info->enc_size);
9201                 }
9202         }
9203
9204         /*
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.
9208          */
9209         if (!mgmt_send_timeout(adapter->mgmt, MGMT_OP_LOAD_LONG_TERM_KEYS,
9210                         adapter->dev_id, cp_size, cp, load_ltks_complete,
9211                         adapter, NULL, 2))
9212                 btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
9213                                                         adapter->dev_id);
9214
9215         g_free(cp);
9216 }
9217
9218 static void load_irks_complete(uint8_t status, uint16_t length,
9219                                         const void *param, void *user_data)
9220 {
9221         struct btd_adapter *adapter = user_data;
9222
9223         if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
9224                 btd_info(adapter->dev_id,
9225                         "Load IRKs failed: Kernel doesn't support LE Privacy");
9226                 return;
9227         }
9228
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);
9233                 return;
9234         }
9235
9236         DBG("IRKs loaded for hci%u", adapter->dev_id);
9237 }
9238
9239 static void load_irks(struct btd_adapter *adapter, GSList *irks)
9240 {
9241         struct mgmt_cp_load_irks *cp;
9242         struct mgmt_irk_info *irk;
9243         size_t irk_count, cp_size;
9244         unsigned int id;
9245         GSList *l;
9246
9247         /*
9248          * If the controller does not support LE Privacy operation,
9249          * there is no support for loading identity resolving keys
9250          * into the kernel.
9251          */
9252         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
9253                 return;
9254
9255         irk_count = g_slist_length(irks);
9256
9257         DBG("hci%u irks %zu", adapter->dev_id, irk_count);
9258
9259         cp_size = sizeof(*cp) + (irk_count * sizeof(*irk));
9260
9261         cp = g_try_malloc0(cp_size);
9262         if (cp == NULL) {
9263                 btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
9264                                                         adapter->dev_id);
9265                 return;
9266         }
9267
9268         /*
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.
9272          */
9273         cp->irk_count = htobs(irk_count);
9274
9275         for (l = irks, irk = cp->irks; l != NULL; l = g_slist_next(l), irk++) {
9276                 struct irk_info *info = l->data;
9277
9278                 bacpy(&irk->addr.bdaddr, &info->bdaddr);
9279                 irk->addr.type = info->bdaddr_type;
9280                 memcpy(irk->val, info->val, sizeof(irk->val));
9281         }
9282
9283         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_IRKS, adapter->dev_id,
9284                         cp_size, cp, load_irks_complete, adapter, NULL);
9285
9286         g_free(cp);
9287
9288         if (id == 0)
9289                 btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
9290                                                         adapter->dev_id);
9291 }
9292
9293 static void load_conn_params_complete(uint8_t status, uint16_t length,
9294                                         const void *param, void *user_data)
9295 {
9296         struct btd_adapter *adapter = user_data;
9297
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);
9302                 return;
9303         }
9304
9305         DBG("Connection Parameters loaded for hci%u", adapter->dev_id);
9306 }
9307
9308 static void load_conn_params(struct btd_adapter *adapter, GSList *params)
9309 {
9310         struct mgmt_cp_load_conn_param *cp;
9311         struct mgmt_conn_param *param;
9312         size_t param_count, cp_size;
9313         unsigned int id;
9314         GSList *l;
9315
9316         /*
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.
9320          */
9321         if (!(adapter->supported_settings & MGMT_SETTING_LE))
9322                 return;
9323
9324         param_count = g_slist_length(params);
9325
9326         DBG("hci%u conn params %zu", adapter->dev_id, param_count);
9327
9328         cp_size = sizeof(*cp) + (param_count * sizeof(*param));
9329
9330         cp = g_try_malloc0(cp_size);
9331         if (cp == NULL) {
9332                 btd_error(adapter->dev_id,
9333                         "Failed to allocate memory for connection parameters");
9334                 return;
9335         }
9336
9337         cp->param_count = htobs(param_count);
9338
9339         for (l = params, param = cp->params; l; l = g_slist_next(l), param++) {
9340                 struct conn_param *info = l->data;
9341
9342                 bacpy(&param->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);
9348         }
9349
9350         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_PARAM, adapter->dev_id,
9351                         cp_size, cp, load_conn_params_complete, adapter, NULL);
9352
9353         g_free(cp);
9354
9355         if (id == 0)
9356                 btd_error(adapter->dev_id, "Load connection parameters failed");
9357 }
9358
9359 static uint8_t get_le_addr_type(GKeyFile *keyfile)
9360 {
9361         uint8_t addr_type;
9362         char *type;
9363
9364         type = g_key_file_get_string(keyfile, "General", "AddressType", NULL);
9365         if (!type)
9366                 return BDADDR_LE_PUBLIC;
9367
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;
9372         else
9373                 addr_type = BDADDR_LE_PUBLIC;
9374
9375         g_free(type);
9376
9377         return addr_type;
9378 }
9379
9380 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9381 static uint8_t get_addr_type(GKeyFile *keyfile)
9382 {
9383         char **techno, **t;
9384         char *str;
9385         uint8_t bdaddr_type = BDADDR_BREDR;
9386         bool le = false;
9387
9388         /* Load device technology */
9389         techno = g_key_file_get_string_list(keyfile, "General",
9390                                         "SupportedTechnologies", NULL, NULL);
9391         if (!techno)
9392                 return 0xff;
9393
9394         for (t = techno; *t; t++) {
9395                 if (g_str_equal(*t, "LE"))
9396                         le = true;
9397         }
9398
9399         if (!le) {
9400                 bdaddr_type = BDADDR_BREDR;
9401         } else {
9402                 str = g_key_file_get_string(keyfile, "General",
9403                                                 "AddressType", NULL);
9404
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;
9409                 else
9410                         error("Unknown LE device technology");
9411
9412                 g_free(str);
9413         }
9414
9415         g_strfreev(techno);
9416
9417         return bdaddr_type;
9418 }
9419 #endif
9420
9421 static void probe_devices(void *user_data)
9422 {
9423         struct btd_device *device = user_data;
9424
9425         device_probe_profiles(device, btd_device_get_uuids(device));
9426         device_resolved_drivers(device_get_adapter(device), device);
9427 }
9428
9429 static bool load_bredr_defaults(struct btd_adapter *adapter,
9430                                 struct mgmt_tlv_list *list,
9431                                 struct btd_br_defaults *defaults)
9432 {
9433         if (btd_opts.mode == BT_MODE_LE)
9434                 return true;
9435
9436         if (defaults->page_scan_type != 0xFFFF) {
9437                 if (!mgmt_tlv_add_fixed(list, 0x0000,
9438                                         &defaults->page_scan_type))
9439                         return false;
9440         }
9441
9442         if (defaults->page_scan_interval) {
9443                 if (!mgmt_tlv_add_fixed(list, 0x0001,
9444                                         &defaults->page_scan_interval))
9445                         return false;
9446         }
9447
9448         if (defaults->page_scan_win) {
9449                 if (!mgmt_tlv_add_fixed(list, 0x0002,
9450                                         &defaults->page_scan_win))
9451                         return false;
9452         }
9453
9454         if (defaults->scan_type != 0xFFFF) {
9455                 if (!mgmt_tlv_add_fixed(list, 0x0003,
9456                                         &defaults->scan_type))
9457                         return false;
9458         }
9459
9460         if (defaults->scan_interval) {
9461                 if (!mgmt_tlv_add_fixed(list, 0x0004,
9462                                         &defaults->scan_interval))
9463                         return false;
9464         }
9465
9466         if (defaults->scan_win) {
9467                 if (!mgmt_tlv_add_fixed(list, 0x0005,
9468                                         &defaults->scan_win))
9469                         return false;
9470         }
9471
9472         if (defaults->link_supervision_timeout) {
9473                 if (!mgmt_tlv_add_fixed(list, 0x0006,
9474                                         &defaults->link_supervision_timeout))
9475                         return false;
9476         }
9477
9478         if (defaults->page_timeout) {
9479                 if (!mgmt_tlv_add_fixed(list, 0x0007,
9480                                         &defaults->page_timeout))
9481                         return false;
9482         }
9483
9484         if (defaults->min_sniff_interval) {
9485                 if (!mgmt_tlv_add_fixed(list, 0x0008,
9486                                         &defaults->min_sniff_interval))
9487                         return false;
9488         }
9489
9490         if (defaults->max_sniff_interval) {
9491                 if (!mgmt_tlv_add_fixed(list, 0x0009,
9492                                         &defaults->max_sniff_interval))
9493                         return false;
9494         }
9495
9496         return true;
9497 }
9498
9499 static bool load_le_defaults(struct btd_adapter *adapter,
9500                                 struct mgmt_tlv_list *list,
9501                                 struct btd_le_defaults *defaults)
9502 {
9503         if (btd_opts.mode == BT_MODE_BREDR)
9504                 return true;
9505
9506         if (defaults->min_adv_interval) {
9507                 if (!mgmt_tlv_add_fixed(list, 0x000a,
9508                                         &defaults->min_adv_interval))
9509                         return false;
9510         }
9511
9512         if (defaults->max_adv_interval) {
9513                 if (!mgmt_tlv_add_fixed(list, 0x000b,
9514                                         &defaults->max_adv_interval))
9515                         return false;
9516         }
9517
9518         if (defaults->adv_rotation_interval) {
9519                 if (!mgmt_tlv_add_fixed(list, 0x000c,
9520                                         &defaults->adv_rotation_interval))
9521                         return false;
9522         }
9523
9524         if (defaults->scan_interval_autoconnect) {
9525                 if (!mgmt_tlv_add_fixed(list, 0x000d,
9526                                         &defaults->scan_interval_autoconnect))
9527                         return false;
9528         }
9529
9530         if (defaults->scan_win_autoconnect) {
9531                 if (!mgmt_tlv_add_fixed(list, 0x000e,
9532                                         &defaults->scan_win_autoconnect))
9533                         return false;
9534         }
9535
9536         if (defaults->scan_interval_suspend) {
9537                 if (!mgmt_tlv_add_fixed(list, 0x000f,
9538                                         &defaults->scan_interval_suspend))
9539                         return false;
9540         }
9541
9542         if (defaults->scan_win_suspend) {
9543                 if (!mgmt_tlv_add_fixed(list, 0x0010,
9544                                         &defaults->scan_win_suspend))
9545                         return false;
9546         }
9547
9548         if (defaults->scan_interval_discovery) {
9549                 if (!mgmt_tlv_add_fixed(list, 0x0011,
9550                                         &defaults->scan_interval_discovery))
9551                         return false;
9552         }
9553
9554         if (defaults->scan_win_discovery) {
9555                 if (!mgmt_tlv_add_fixed(list, 0x0012,
9556                                         &defaults->scan_win_discovery))
9557                         return false;
9558         }
9559
9560         if (defaults->scan_interval_adv_monitor) {
9561                 if (!mgmt_tlv_add_fixed(list, 0x0013,
9562                                         &defaults->scan_interval_adv_monitor))
9563                         return false;
9564         }
9565
9566         if (defaults->scan_win_adv_monitor) {
9567                 if (!mgmt_tlv_add_fixed(list, 0x0014,
9568                                         &defaults->scan_win_adv_monitor))
9569                         return false;
9570         }
9571
9572         if (defaults->scan_interval_connect) {
9573                 if (!mgmt_tlv_add_fixed(list, 0x0015,
9574                                         &defaults->scan_interval_connect))
9575                         return false;
9576         }
9577
9578         if (defaults->scan_win_connect) {
9579                 if (!mgmt_tlv_add_fixed(list, 0x0016,
9580                                         &defaults->scan_win_connect))
9581                         return false;
9582         }
9583
9584         if (defaults->min_conn_interval) {
9585                 if (!mgmt_tlv_add_fixed(list, 0x0017,
9586                                         &defaults->min_conn_interval))
9587                         return false;
9588         }
9589
9590         if (defaults->max_conn_interval) {
9591                 if (!mgmt_tlv_add_fixed(list, 0x0018,
9592                                         &defaults->max_conn_interval))
9593                         return false;
9594         }
9595
9596         if (defaults->conn_latency) {
9597                 if (!mgmt_tlv_add_fixed(list, 0x0019,
9598                                         &defaults->conn_latency))
9599                         return false;
9600         }
9601
9602         if (defaults->conn_lsto) {
9603                 if (!mgmt_tlv_add_fixed(list, 0x001a,
9604                                         &defaults->conn_lsto))
9605                         return false;
9606         }
9607
9608         if (defaults->autoconnect_timeout) {
9609                 if (!mgmt_tlv_add_fixed(list, 0x001b,
9610                                         &defaults->autoconnect_timeout))
9611                         return false;
9612         }
9613
9614         if (defaults->advmon_allowlist_scan_duration) {
9615                 if (!mgmt_tlv_add_fixed(list, 0x001d,
9616                                 &defaults->advmon_allowlist_scan_duration))
9617                         return false;
9618         }
9619
9620         if (defaults->advmon_no_filter_scan_duration) {
9621                 if (!mgmt_tlv_add_fixed(list, 0x001e,
9622                                 &defaults->advmon_no_filter_scan_duration))
9623                         return false;
9624         }
9625
9626         if (defaults->enable_advmon_interleave_scan != 0xFF) {
9627                 if (!mgmt_tlv_add_fixed(list, 0x001f,
9628                                 &defaults->enable_advmon_interleave_scan))
9629                         return false;
9630         }
9631
9632         return true;
9633 }
9634
9635 static void load_defaults(struct btd_adapter *adapter)
9636 {
9637         struct mgmt_tlv_list *list;
9638         unsigned int err = 0;
9639
9640         if (!btd_opts.defaults.num_entries ||
9641             !btd_has_kernel_features(KERNEL_SET_SYSTEM_CONFIG))
9642                 return;
9643
9644         list = mgmt_tlv_list_new();
9645
9646         if (!load_bredr_defaults(adapter, list, &btd_opts.defaults.br))
9647                 goto done;
9648
9649         if (!load_le_defaults(adapter, list, &btd_opts.defaults.le))
9650                 goto done;
9651
9652         err = mgmt_send_tlv(adapter->mgmt, MGMT_OP_SET_DEF_SYSTEM_CONFIG,
9653                         adapter->dev_id, list, NULL, NULL, NULL);
9654
9655 done:
9656         if (!err)
9657                 btd_error(adapter->dev_id,
9658                                 "Failed to set default system config for hci%u",
9659                                 adapter->dev_id);
9660
9661         mgmt_tlv_list_free(list);
9662 }
9663
9664 static void load_devices(struct btd_adapter *adapter)
9665 {
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;
9673         DIR *dir;
9674         struct dirent *entry;
9675
9676         create_filename(dirname, PATH_MAX, "/%s",
9677                                 btd_adapter_get_storage_dir(adapter));
9678
9679         dir = opendir(dirname);
9680         if (!dir) {
9681                 btd_error(adapter->dev_id,
9682                                 "Unable to open adapter storage directory: %s",
9683                                                                 dirname);
9684                 return;
9685         }
9686
9687         while ((entry = readdir(dir)) != NULL) {
9688                 struct btd_device *device;
9689                 char filename[PATH_MAX];
9690                 GKeyFile *key_file;
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;
9697 #else
9698                 struct link_key_info *key_info;
9699                 struct smp_ltk_info *ltk_info;
9700                 struct smp_ltk_info *peripheral_ltk_info;
9701                 GSList *list;
9702 #endif
9703                 struct irk_info *irk_info;
9704                 struct conn_param *param;
9705                 uint8_t bdaddr_type;
9706
9707                 if (entry->d_type == DT_UNKNOWN)
9708                         entry->d_type = util_get_dt(dirname, entry->d_name);
9709
9710                 if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
9711                         continue;
9712
9713 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9714 {
9715                 bdaddr_t bdaddr;
9716
9717                 str2ba(entry->d_name, &bdaddr);
9718
9719                 if (!bacmp(&bdaddr, BDADDR_ANY)) {
9720                         error("No Bluetooth address");
9721                         continue;
9722                 }
9723 }
9724 #endif
9725         create_filename(filename, PATH_MAX, "/%s/%s/info",
9726                                         btd_adapter_get_storage_dir(adapter),
9727                                         entry->d_name);
9728
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,
9732                                                                 gerr->message);
9733                         g_clear_error(&gerr);
9734                 }
9735
9736                 key_info = get_key_info(key_file, entry->d_name);
9737
9738                 bdaddr_type = get_le_addr_type(key_file);
9739
9740                 ltk_info = get_ltk_info(key_file, entry->d_name, bdaddr_type);
9741
9742                 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9743                                                 entry->d_name, bdaddr_type);
9744
9745                 irk_info = get_irk_info(key_file, entry->d_name, bdaddr_type);
9746
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)) {
9753
9754                         if (key_info) {
9755                                 g_free(key_info);
9756                                 key_info = NULL;
9757                         }
9758
9759                         if (ltk_info) {
9760                                 g_free(ltk_info);
9761                                 ltk_info = NULL;
9762                         }
9763
9764                         if (peripheral_ltk_info) {
9765                                 g_free(peripheral_ltk_info);
9766                                 peripheral_ltk_info = NULL;
9767                         }
9768
9769                         if (irk_info) {
9770                                 g_free(irk_info);
9771                                 irk_info = NULL;
9772                         }
9773
9774                         goto free;
9775                 }
9776
9777                 if (key_info)
9778                         keys = g_slist_append(keys, key_info);
9779
9780                 if (ltk_info)
9781                         ltks = g_slist_append(ltks, ltk_info);
9782
9783                 if (peripheral_ltk_info)
9784                         ltks = g_slist_append(ltks, peripheral_ltk_info);
9785
9786                 if (irk_info)
9787                         irks = g_slist_append(irks, irk_info);
9788
9789                 param = get_conn_param(key_file, entry->d_name, bdaddr_type);
9790                 if (param)
9791                         params = g_slist_append(params, param);
9792
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");
9798                         goto free;
9799                 }
9800
9801                 list = g_slist_find_custom(adapter->devices, &addr,
9802                                                 device_addr_type_strict_cmp);
9803 #else
9804                 list = g_slist_find_custom(adapter->devices, entry->d_name,
9805                                                         device_address_cmp);
9806 #endif
9807                 if (list) {
9808 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9809                         DBG("Skip already loaded device [%s] [%d]",
9810                                         entry->d_name, addr.bdaddr_type);
9811 #endif
9812                         device = list->data;
9813                         goto device_exist;
9814                 }
9815
9816                 device = device_create_from_storage(adapter, entry->d_name,
9817                                                         key_file);
9818                 if (!device)
9819                         goto free;
9820
9821 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9822 {
9823                 char idaddr[18];
9824
9825                 /*
9826                  * After loading IRK information from file,
9827                  * store it into device->bdaddr.
9828                  * RPA is stored in device->rpa_addr
9829                  */
9830                 ba2str(device_get_address(device), idaddr);
9831
9832                 DBG("irk address: %s, rpa_exist %d",
9833                                 idaddr, device_get_rpa_exist(device));
9834
9835                 if (device_get_rpa_exist(device) == true) {
9836                         if (key_info)
9837                                 str2ba(idaddr, &key_info->bdaddr);
9838
9839                         if (ltk_info) {
9840                                 ltks = g_slist_remove(ltks, ltk_info);
9841                                 ltk_info = get_ltk_info(key_file,
9842                                                 idaddr, bdaddr_type);
9843                                 if (ltk_info)
9844                                         ltks = g_slist_append(ltks, ltk_info);
9845                         }
9846
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);
9853                         }
9854
9855                         if (irk_info) {
9856                                 str2ba(idaddr, &irk_info->bdaddr);
9857                                 device_set_irk_value(device, irk_info->val);
9858                         }
9859
9860                         if (param)
9861                                 str2ba(idaddr, &param->bdaddr);
9862                 }
9863 }
9864 #endif
9865                 if (irk_info)
9866                         device_set_rpa(device, true);
9867
9868                 btd_device_set_temporary(device, false);
9869                 adapter_add_device(adapter, device);
9870
9871                 /* TODO: register services from pre-loaded list of primaries */
9872
9873                 added_devices = g_slist_append(added_devices, device);
9874
9875 device_exist:
9876                 if (key_info) {
9877                         device_set_paired(device, BDADDR_BREDR);
9878                         device_set_bonded(device, BDADDR_BREDR);
9879                 }
9880
9881 free:
9882                 g_key_file_free(key_file);
9883         }
9884
9885         closedir(dir);
9886
9887         load_link_keys(adapter, keys, btd_opts.debug_keys);
9888         g_slist_free_full(keys, g_free);
9889
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);
9896
9897         g_slist_free_full(added_devices, probe_devices);
9898 }
9899
9900 int btd_adapter_block_address(struct btd_adapter *adapter,
9901                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9902 {
9903         struct mgmt_cp_block_device cp;
9904         char addr[18];
9905
9906         ba2str(bdaddr, addr);
9907         DBG("hci%u %s", adapter->dev_id, addr);
9908
9909         memset(&cp, 0, sizeof(cp));
9910         bacpy(&cp.addr.bdaddr, bdaddr);
9911         cp.addr.type = bdaddr_type;
9912
9913         if (mgmt_send(adapter->mgmt, MGMT_OP_BLOCK_DEVICE,
9914                                 adapter->dev_id, sizeof(cp), &cp,
9915                                 NULL, NULL, NULL) > 0)
9916                 return 0;
9917
9918         return -EIO;
9919 }
9920
9921 int btd_adapter_unblock_address(struct btd_adapter *adapter,
9922                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9923 {
9924         struct mgmt_cp_unblock_device cp;
9925         char addr[18];
9926
9927         ba2str(bdaddr, addr);
9928         DBG("hci%u %s", adapter->dev_id, addr);
9929
9930         memset(&cp, 0, sizeof(cp));
9931         bacpy(&cp.addr.bdaddr, bdaddr);
9932         cp.addr.type = bdaddr_type;
9933
9934         if (mgmt_send(adapter->mgmt, MGMT_OP_UNBLOCK_DEVICE,
9935                                 adapter->dev_id, sizeof(cp), &cp,
9936                                 NULL, NULL, NULL) > 0)
9937                 return 0;
9938
9939         return -EIO;
9940 }
9941
9942 static int clear_blocked(struct btd_adapter *adapter)
9943 {
9944         return btd_adapter_unblock_address(adapter, BDADDR_ANY, 0);
9945 }
9946
9947 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
9948 {
9949         struct btd_adapter_driver *driver = user_data;
9950         int err;
9951
9952         if (driver->probe == NULL)
9953                 return;
9954
9955         err = driver->probe(adapter);
9956         if (err < 0) {
9957                 btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
9958                                                         strerror(-err), -err);
9959                 return;
9960         }
9961
9962         adapter->drivers = g_slist_prepend(adapter->drivers, driver);
9963 }
9964
9965 static void load_drivers(struct btd_adapter *adapter)
9966 {
9967         GSList *l;
9968
9969         for (l = adapter_drivers; l; l = l->next)
9970                 probe_driver(adapter, l->data);
9971 }
9972
9973 static void probe_profile(struct btd_profile *profile, void *data)
9974 {
9975         struct btd_adapter *adapter = data;
9976         int err;
9977
9978         if (profile->adapter_probe == NULL)
9979                 return;
9980
9981         err = profile->adapter_probe(profile, adapter);
9982         if (err < 0) {
9983                 btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
9984                                                         strerror(-err), -err);
9985                 return;
9986         }
9987
9988         adapter->profiles = g_slist_prepend(adapter->profiles, profile);
9989 }
9990
9991 void adapter_add_profile(struct btd_adapter *adapter, gpointer p)
9992 {
9993         struct btd_profile *profile = p;
9994
9995         if (!adapter->initialized)
9996                 return;
9997
9998         probe_profile(profile, adapter);
9999
10000         g_slist_foreach(adapter->devices, device_probe_profile, profile);
10001 }
10002
10003 void adapter_remove_profile(struct btd_adapter *adapter, gpointer p)
10004 {
10005         struct btd_profile *profile = p;
10006
10007         if (!adapter->initialized)
10008                 return;
10009
10010         if (profile->device_remove)
10011                 g_slist_foreach(adapter->devices, device_remove_profile, p);
10012
10013         adapter->profiles = g_slist_remove(adapter->profiles, profile);
10014
10015         if (profile->adapter_remove)
10016                 profile->adapter_remove(profile, adapter);
10017 }
10018
10019 static void device_added_drivers(struct btd_adapter *adapter,
10020                                                 struct btd_device *device)
10021 {
10022         struct btd_adapter_driver *driver;
10023         GSList *l;
10024
10025         for (l = adapter_drivers; l; l = l->next) {
10026                 driver = l->data;
10027
10028                 if (driver->device_added)
10029                         driver->device_added(adapter, device);
10030         }
10031 }
10032
10033 static void device_removed_drivers(struct btd_adapter *adapter,
10034                                                 struct btd_device *device)
10035 {
10036         struct btd_adapter_driver *driver;
10037         GSList *l;
10038
10039         for (l = adapter_drivers; l; l = l->next) {
10040                 driver = l->data;
10041
10042                 if (driver->device_removed)
10043                         driver->device_removed(adapter, device);
10044         }
10045 }
10046
10047 void device_resolved_drivers(struct btd_adapter *adapter,
10048                                                 struct btd_device *device)
10049 {
10050         struct btd_adapter_driver *driver;
10051         GSList *l;
10052
10053         for (l = adapter_drivers; l; l = l->next) {
10054                 driver = l->data;
10055
10056                 if (driver->device_resolved)
10057                         driver->device_resolved(adapter, device);
10058         }
10059 }
10060
10061 static void adapter_add_device(struct btd_adapter *adapter,
10062                                                 struct btd_device *device)
10063 {
10064         adapter->devices = g_slist_append(adapter->devices, device);
10065         device_added_drivers(adapter, device);
10066 }
10067
10068 static void adapter_remove_device(struct btd_adapter *adapter,
10069                                                 struct btd_device *device)
10070 {
10071         adapter->devices = g_slist_remove(adapter->devices, device);
10072         device_removed_drivers(adapter, device);
10073 }
10074
10075 static void adapter_add_connection(struct btd_adapter *adapter,
10076                                                 struct btd_device *device,
10077                                                 uint8_t bdaddr_type)
10078 {
10079         device_add_connection(device, bdaddr_type);
10080
10081         if (g_slist_find(adapter->connections, device)) {
10082                 btd_error(adapter->dev_id,
10083                                 "Device is already marked as connected");
10084                 return;
10085         }
10086
10087         adapter->connections = g_slist_append(adapter->connections, device);
10088 }
10089
10090 static void get_connections_complete(uint8_t status, uint16_t length,
10091                                         const void *param, void *user_data)
10092 {
10093         struct btd_adapter *adapter = user_data;
10094         const struct mgmt_rp_get_connections *rp = param;
10095         uint16_t i, conn_count;
10096
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);
10101                 return;
10102         }
10103
10104         if (length < sizeof(*rp)) {
10105                 btd_error(adapter->dev_id,
10106                                 "Wrong size of get connections response");
10107                 return;
10108         }
10109
10110         conn_count = btohs(rp->conn_count);
10111
10112         DBG("Connection count: %d", conn_count);
10113
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");
10118                 return;
10119         }
10120
10121         for (i = 0; i < conn_count; i++) {
10122                 const struct mgmt_addr_info *addr = &rp->addr[i];
10123                 struct btd_device *device;
10124                 char address[18];
10125
10126                 ba2str(&addr->bdaddr, address);
10127                 DBG("Adding existing connection to %s", address);
10128
10129                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
10130                                                                 addr->type);
10131                 if (device)
10132                         adapter_add_connection(adapter, device, addr->type);
10133         }
10134 }
10135
10136 static void load_connections(struct btd_adapter *adapter)
10137 {
10138         DBG("sending get connections command for index %u", adapter->dev_id);
10139
10140         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_CONNECTIONS,
10141                                 adapter->dev_id, 0, NULL,
10142                                 get_connections_complete, adapter, NULL) > 0)
10143                 return;
10144
10145         btd_error(adapter->dev_id, "Failed to get connections for index %u",
10146                                                         adapter->dev_id);
10147 }
10148
10149 bool btd_adapter_get_pairable(struct btd_adapter *adapter)
10150 {
10151         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
10152                 return true;
10153
10154         return false;
10155 }
10156
10157 bool btd_adapter_get_powered(struct btd_adapter *adapter)
10158 {
10159         if ((adapter->current_settings & MGMT_SETTING_POWERED) &&
10160                         !(adapter->pending_settings & MGMT_SETTING_POWERED))
10161                 return true;
10162
10163         return false;
10164 }
10165
10166 bool btd_adapter_get_connectable(struct btd_adapter *adapter)
10167 {
10168         if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
10169                 return true;
10170
10171         return false;
10172 }
10173
10174 bool btd_adapter_get_discoverable(struct btd_adapter *adapter)
10175 {
10176         if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
10177                 return true;
10178
10179         return false;
10180 }
10181
10182 bool btd_adapter_get_bredr(struct btd_adapter *adapter)
10183 {
10184         if (adapter->current_settings & MGMT_SETTING_BREDR)
10185                 return true;
10186
10187         return false;
10188 }
10189
10190 struct btd_gatt_database *btd_adapter_get_database(struct btd_adapter *adapter)
10191 {
10192         if (!adapter)
10193                 return NULL;
10194
10195         return adapter->database;
10196 }
10197
10198 uint32_t btd_adapter_get_class(struct btd_adapter *adapter)
10199 {
10200         return adapter->dev_class;
10201 }
10202
10203 const char *btd_adapter_get_name(struct btd_adapter *adapter)
10204 {
10205         if (adapter->stored_alias)
10206                 return adapter->stored_alias;
10207
10208         if (adapter->system_name)
10209                 return adapter->system_name;
10210
10211         return NULL;
10212 }
10213
10214 int adapter_connect_list_add(struct btd_adapter *adapter,
10215                                         struct btd_device *device)
10216 {
10217         /*
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
10221          */
10222         if (device == adapter->connect_le)
10223                 adapter->connect_le = NULL;
10224
10225         /*
10226          * If kernel background scanning is supported then the
10227          * adapter_auto_connect_add() function is used to maintain what to
10228          * connect.
10229          */
10230         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10231                 return 0;
10232
10233         if (g_slist_find(adapter->connect_list, device)) {
10234                 DBG("ignoring already added device %s",
10235                                                 device_get_path(device));
10236                 goto done;
10237         }
10238
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));
10243                 return -ENOTSUP;
10244         }
10245
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);
10249
10250 done:
10251         if (!btd_adapter_get_powered(adapter))
10252                 return 0;
10253
10254         trigger_passive_scanning(adapter);
10255
10256         return 0;
10257 }
10258
10259 void adapter_connect_list_remove(struct btd_adapter *adapter,
10260                                         struct btd_device *device)
10261 {
10262         /*
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
10266          */
10267         if (device == adapter->connect_le)
10268                 adapter->connect_le = NULL;
10269
10270         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10271                 return;
10272
10273         if (!g_slist_find(adapter->connect_list, device)) {
10274                 DBG("device %s is not on the list, ignoring",
10275                                                 device_get_path(device));
10276                 return;
10277         }
10278
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);
10282
10283         if (!adapter->connect_list) {
10284                 stop_passive_scanning(adapter);
10285                 return;
10286         }
10287
10288         if (!btd_adapter_get_powered(adapter))
10289                 return;
10290
10291         trigger_passive_scanning(adapter);
10292 }
10293
10294 static void add_accept_list_complete(uint8_t status, uint16_t length,
10295                                         const void *param, void *user_data)
10296 {
10297         const struct mgmt_rp_add_device *rp = param;
10298         struct btd_adapter *adapter = user_data;
10299         struct btd_device *dev;
10300         char addr[18];
10301
10302         if (length < sizeof(*rp)) {
10303                 btd_error(adapter->dev_id,
10304                                 "Too small Add Device complete event");
10305                 return;
10306         }
10307
10308         ba2str(&rp->addr.bdaddr, addr);
10309
10310         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10311                                                         rp->addr.type);
10312         if (!dev) {
10313                 btd_error(adapter->dev_id,
10314                         "Add Device complete for unknown device %s", addr);
10315                 return;
10316         }
10317
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);
10322                 return;
10323         }
10324
10325         DBG("%s added to kernel accept list", addr);
10326 }
10327
10328 void adapter_accept_list_add(struct btd_adapter *adapter,
10329                                                         struct btd_device *dev)
10330 {
10331         struct mgmt_cp_add_device cp;
10332
10333         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10334                 return;
10335
10336         memset(&cp, 0, sizeof(cp));
10337         bacpy(&cp.addr.bdaddr, device_get_address(dev));
10338         cp.addr.type = BDADDR_BREDR;
10339         cp.action = 0x01;
10340
10341         mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10342                                 adapter->dev_id, sizeof(cp), &cp,
10343                                 add_accept_list_complete, adapter, NULL);
10344 }
10345
10346 static void remove_accept_list_complete(uint8_t status, uint16_t length,
10347                                         const void *param, void *user_data)
10348 {
10349         const struct mgmt_rp_remove_device *rp = param;
10350         char addr[18];
10351
10352         if (length < sizeof(*rp)) {
10353                 error("Too small Remove Device complete event");
10354                 return;
10355         }
10356
10357         ba2str(&rp->addr.bdaddr, addr);
10358
10359         if (status != MGMT_STATUS_SUCCESS) {
10360                 error("Failed to remove device %s: %s (0x%02x)",
10361                                         addr, mgmt_errstr(status), status);
10362                 return;
10363         }
10364
10365         DBG("%s removed from kernel accept list", addr);
10366 }
10367
10368 void adapter_accept_list_remove(struct btd_adapter *adapter,
10369                                                         struct btd_device *dev)
10370 {
10371         struct mgmt_cp_remove_device cp;
10372
10373         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10374                 return;
10375
10376         memset(&cp, 0, sizeof(cp));
10377         bacpy(&cp.addr.bdaddr, device_get_address(dev));
10378         cp.addr.type = BDADDR_BREDR;
10379
10380         mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10381                                 adapter->dev_id, sizeof(cp), &cp,
10382                                 remove_accept_list_complete, adapter, NULL);
10383 }
10384
10385 static void set_device_privacy_complete(uint8_t status, uint16_t length,
10386                                          const void *param, void *user_data)
10387 {
10388         const struct mgmt_rp_set_device_flags *rp = param;
10389
10390         if (status != MGMT_STATUS_SUCCESS) {
10391                 error("Set device flags return status: %s",
10392                                         mgmt_errstr(status));
10393                 return;
10394         }
10395
10396         if (length < sizeof(*rp)) {
10397                 error("Too small Set Device Flags complete event: %d", length);
10398                 return;
10399         }
10400 }
10401
10402 static void add_device_complete(uint8_t status, uint16_t length,
10403                                         const void *param, void *user_data)
10404 {
10405         const struct mgmt_rp_add_device *rp = param;
10406         struct btd_adapter *adapter = user_data;
10407         struct btd_device *dev;
10408         char addr[18];
10409
10410         if (length < sizeof(*rp)) {
10411                 btd_error(adapter->dev_id,
10412                                 "Too small Add Device complete event");
10413                 return;
10414         }
10415
10416         ba2str(&rp->addr.bdaddr, addr);
10417
10418         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10419                                                         rp->addr.type);
10420         if (!dev) {
10421                 btd_error(adapter->dev_id,
10422                         "Add Device complete for unknown device %s", addr);
10423                 return;
10424         }
10425
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,
10431                                                                         dev);
10432                 return;
10433         }
10434
10435         DBG("%s (%u) added to kernel connect list", addr, rp->addr.type);
10436
10437         if (btd_opts.device_privacy) {
10438                 uint32_t flags = btd_device_get_current_flags(dev);
10439
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,
10445                                                 NULL);
10446                 }
10447         }
10448 }
10449
10450 void adapter_auto_connect_add(struct btd_adapter *adapter,
10451                                         struct btd_device *device)
10452 {
10453         struct mgmt_cp_add_device cp;
10454         const bdaddr_t *bdaddr;
10455         uint8_t bdaddr_type;
10456         unsigned int id;
10457
10458         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10459                 return;
10460
10461         if (g_slist_find(adapter->connect_list, device)) {
10462                 DBG("ignoring already added device %s",
10463                                                 device_get_path(device));
10464                 return;
10465         }
10466
10467         bdaddr = device_get_address(device);
10468         bdaddr_type = btd_device_get_bdaddr_type(device);
10469
10470         if (bdaddr_type == BDADDR_BREDR) {
10471                 DBG("auto-connection feature is not avaiable for BR/EDR");
10472                 return;
10473         }
10474
10475         memset(&cp, 0, sizeof(cp));
10476         bacpy(&cp.addr.bdaddr, bdaddr);
10477         cp.addr.type = bdaddr_type;
10478         cp.action = 0x02;
10479
10480         id = mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10481                         adapter->dev_id, sizeof(cp), &cp, add_device_complete,
10482                         adapter, NULL);
10483         if (id == 0)
10484                 return;
10485
10486         adapter->connect_list = g_slist_append(adapter->connect_list, device);
10487 }
10488
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)
10492 {
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;
10497
10498         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL) ||
10499                                 (supported | flags) != supported)
10500                 return;
10501
10502         bdaddr = device_get_address(device);
10503         bdaddr_type = btd_device_get_bdaddr_type(device);
10504
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);
10509
10510         mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_FLAGS, adapter->dev_id,
10511                   sizeof(cp), &cp, func, user_data, NULL);
10512 }
10513
10514 static void device_flags_changed_callback(uint16_t index, uint16_t length,
10515                                           const void *param, void *user_data)
10516 {
10517         const struct mgmt_ev_device_flags_changed *ev = param;
10518         struct btd_adapter *adapter = user_data;
10519         struct btd_device *dev;
10520         char addr[18];
10521
10522         if (length < sizeof(*ev)) {
10523                 btd_error(adapter->dev_id,
10524                           "Too small Device Flags Changed event: %d",
10525                           length);
10526                 return;
10527         }
10528
10529         ba2str(&ev->addr.bdaddr, addr);
10530
10531         dev = btd_adapter_find_device(adapter, &ev->addr.bdaddr, ev->addr.type);
10532         if (!dev) {
10533                 btd_error(adapter->dev_id,
10534                         "Device Flags Changed for unknown device %s", addr);
10535                 return;
10536         }
10537
10538         btd_device_flags_changed(dev, ev->supported_flags, ev->current_flags);
10539 }
10540
10541
10542 static void remove_device_complete(uint8_t status, uint16_t length,
10543                                         const void *param, void *user_data)
10544 {
10545         const struct mgmt_rp_remove_device *rp = param;
10546         char addr[18];
10547
10548         if (length < sizeof(*rp)) {
10549                 error("Too small Remove Device complete event");
10550                 return;
10551         }
10552
10553         ba2str(&rp->addr.bdaddr, addr);
10554
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);
10558                 return;
10559         }
10560
10561         DBG("%s (%u) removed from kernel connect list", addr, rp->addr.type);
10562 }
10563
10564 void adapter_auto_connect_remove(struct btd_adapter *adapter,
10565                                         struct btd_device *device)
10566 {
10567         struct mgmt_cp_remove_device cp;
10568         const bdaddr_t *bdaddr;
10569         uint8_t bdaddr_type;
10570         unsigned int id;
10571
10572         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10573                 return;
10574
10575         if (!g_slist_find(adapter->connect_list, device)) {
10576                 DBG("ignoring not added device %s", device_get_path(device));
10577                 return;
10578         }
10579
10580         bdaddr = device_get_address(device);
10581         bdaddr_type = btd_device_get_bdaddr_type(device);
10582
10583         if (bdaddr_type == BDADDR_BREDR) {
10584                 DBG("auto-connection feature is not avaiable for BR/EDR");
10585                 return;
10586         }
10587
10588         memset(&cp, 0, sizeof(cp));
10589         bacpy(&cp.addr.bdaddr, bdaddr);
10590         cp.addr.type = bdaddr_type;
10591
10592         id = mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10593                         adapter->dev_id, sizeof(cp), &cp,
10594                         remove_device_complete, adapter, NULL);
10595         if (id == 0)
10596                 return;
10597
10598         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10599 }
10600
10601 #if defined (TIZEN_FEATURE_BLUEZ_MODIFY)
10602 static void get_phy_configuration_resp(uint8_t status, uint16_t len, const void *param,
10603                                                         void *user_data)
10604 {
10605         uint32_t supported_phys;
10606         uint32_t configurable_phys;
10607         uint32_t selected_phys;
10608
10609         const struct mgmt_rp_get_phy_confguration *rp = param;
10610         struct btd_adapter *adapter = user_data;
10611
10612         if (status != MGMT_STATUS_SUCCESS) {
10613                 error("Get PHY Configuration failed with status 0x%02x (%s)",
10614                                 status, mgmt_errstr(status));
10615                 return;
10616         }
10617
10618         if (len < sizeof(*rp)) {
10619                 error("Too small get-phy reply (%u bytes)", len);
10620                 return;
10621         }
10622
10623         supported_phys = get_le32(&rp->supported_phys);
10624         configurable_phys = get_le32(&rp-> configurable_phys);
10625         selected_phys = get_le16(&rp->selected_phys);
10626
10627         DBG("Supported phys: [0x%x]", supported_phys);
10628         DBG("Configurable phys: [0x%x]", configurable_phys);
10629         DBG("Selected phys: [0x%x]", selected_phys);
10630
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;
10636                 } else
10637                         DBG("Adapter does not support LE 2M PHY");
10638
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");
10643                 } else
10644                         DBG("Adapter does not support LE CODED PHY");
10645         }
10646
10647         /* Emit Property Changed Signal */
10648          g_dbus_emit_property_changed(dbus_conn, adapter->path,
10649                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10650
10651 }
10652 #endif
10653
10654 static void adapter_start(struct btd_adapter *adapter)
10655 {
10656
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
10662         else
10663                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10664                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10665 #endif
10666
10667         adapter_get_adv_tx_power(adapter);
10668
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);
10673 #endif
10674
10675 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
10676         g_dbus_emit_property_changed(dbus_conn, adapter->path,
10677                                                 ADAPTER_INTERFACE, "Powered");
10678 #else
10679         g_dbus_emit_property_changed_full(dbus_conn, adapter->path,
10680                                                 ADAPTER_INTERFACE, "Powered", 1);
10681 #endif
10682         adapter_set_power_state(adapter, ADAPTER_POWER_STATE_ON);
10683
10684         DBG("adapter %s has been enabled", adapter->path);
10685
10686         trigger_passive_scanning(adapter);
10687 }
10688
10689 static void reply_pending_requests(struct btd_adapter *adapter)
10690 {
10691         GSList *l;
10692
10693         if (!adapter)
10694                 return;
10695
10696         /* pending bonding */
10697         for (l = adapter->devices; l; l = l->next) {
10698                 struct btd_device *device = l->data;
10699
10700                 if (device_is_bonding(device, NULL))
10701                         device_bonding_failed(device,
10702                                                 HCI_OE_USER_ENDED_CONNECTION);
10703         }
10704 }
10705
10706 static void remove_driver(gpointer data, gpointer user_data)
10707 {
10708         struct btd_adapter_driver *driver = data;
10709         struct btd_adapter *adapter = user_data;
10710
10711         if (driver->remove)
10712                 driver->remove(adapter);
10713 }
10714
10715 static void remove_profile(gpointer data, gpointer user_data)
10716 {
10717         struct btd_profile *profile = data;
10718         struct btd_adapter *adapter = user_data;
10719
10720         if (profile->adapter_remove)
10721                 profile->adapter_remove(profile, adapter);
10722 }
10723
10724 static void unload_drivers(struct btd_adapter *adapter)
10725 {
10726         g_slist_foreach(adapter->drivers, remove_driver, adapter);
10727         g_slist_free(adapter->drivers);
10728         adapter->drivers = NULL;
10729
10730         g_slist_foreach(adapter->profiles, remove_profile, adapter);
10731         g_slist_free(adapter->profiles);
10732         adapter->profiles = NULL;
10733 }
10734
10735 static void free_service_auth(gpointer data, gpointer user_data)
10736 {
10737         struct service_auth *auth = data;
10738
10739         g_free(auth);
10740 }
10741
10742 static void remove_discovery_list(struct btd_adapter *adapter)
10743 {
10744         g_slist_free_full(adapter->set_filter_list, discovery_free);
10745         adapter->set_filter_list = NULL;
10746
10747         g_slist_free_full(adapter->discovery_list, discovery_free);
10748         adapter->discovery_list = NULL;
10749 }
10750
10751 static void adapter_free(gpointer user_data)
10752 {
10753         struct btd_adapter *adapter = user_data;
10754
10755         DBG("%p", adapter);
10756
10757         /* Make sure the adapter's discovery list is cleaned up before freeing
10758          * the adapter.
10759          */
10760         remove_discovery_list(adapter);
10761
10762         if (adapter->pairable_timeout_id > 0) {
10763                 timeout_remove(adapter->pairable_timeout_id);
10764                 adapter->pairable_timeout_id = 0;
10765         }
10766
10767         if (adapter->passive_scan_timeout > 0) {
10768                 timeout_remove(adapter->passive_scan_timeout);
10769                 adapter->passive_scan_timeout = 0;
10770         }
10771
10772         if (adapter->auth_idle_id)
10773                 timeout_remove(adapter->auth_idle_id);
10774
10775         g_queue_foreach(adapter->auths, free_service_auth, NULL);
10776         g_queue_free(adapter->auths);
10777         queue_destroy(adapter->exps, NULL);
10778
10779         /*
10780          * Unregister all handlers for this specific index since
10781          * the adapter bound to them is no longer valid.
10782          *
10783          * This also avoids having multiple instances of the same
10784          * handler in case indexes got removed and re-added.
10785          */
10786         mgmt_unregister_index(adapter->mgmt, adapter->dev_id);
10787
10788         /*
10789          * Cancel all pending commands for this specific index
10790          * since the adapter bound to them is no longer valid.
10791          */
10792         mgmt_cancel_index(adapter->mgmt, adapter->dev_id);
10793
10794         mgmt_unref(adapter->mgmt);
10795
10796         sdp_list_free(adapter->services, NULL);
10797
10798         g_slist_free(adapter->connections);
10799
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);
10807
10808         if (adapter->allowed_uuid_set)
10809                 g_hash_table_destroy(adapter->allowed_uuid_set);
10810
10811         g_free(adapter);
10812 }
10813
10814 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
10815 {
10816         __sync_fetch_and_add(&adapter->ref_count, 1);
10817
10818         return adapter;
10819 }
10820
10821 void btd_adapter_unref(struct btd_adapter *adapter)
10822 {
10823         if (__sync_sub_and_fetch(&adapter->ref_count, 1))
10824                 return;
10825
10826         if (!adapter->path) {
10827                 DBG("Freeing adapter %u", adapter->dev_id);
10828
10829                 adapter_free(adapter);
10830                 return;
10831         }
10832
10833         DBG("Freeing adapter %s", adapter->path);
10834
10835         g_dbus_unregister_interface(dbus_conn, adapter->path,
10836                                                 ADAPTER_INTERFACE);
10837 }
10838
10839 static void convert_names_entry(char *key, char *value, void *user_data)
10840 {
10841         char *address = user_data;
10842         char *str = key;
10843         char filename[PATH_MAX];
10844         GKeyFile *key_file;
10845         GError *gerr = NULL;
10846         char *data;
10847         gsize length = 0;
10848
10849         if (strchr(key, '#'))
10850                 str[17] = '\0';
10851
10852         if (bachk(str) != 0)
10853                 return;
10854
10855         create_filename(filename, PATH_MAX, "/%s/cache/%s", address, str);
10856         create_file(filename, 0600);
10857
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,
10861                                                                 gerr->message);
10862                 g_clear_error(&gerr);
10863         }
10864         g_key_file_set_string(key_file, "General", "Name", value);
10865
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,
10869                                                                 gerr->message);
10870                 g_error_free(gerr);
10871         }
10872         g_free(data);
10873
10874         g_key_file_free(key_file);
10875 }
10876
10877 struct device_converter {
10878         char *address;
10879         void (*cb)(GKeyFile *key_file, void *value);
10880         gboolean force;
10881 };
10882
10883 static void set_device_type(GKeyFile *key_file, char type)
10884 {
10885         char *techno;
10886         char *addr_type = NULL;
10887         char *str;
10888
10889         switch (type) {
10890         case BDADDR_BREDR:
10891                 techno = "BR/EDR";
10892                 break;
10893         case BDADDR_LE_PUBLIC:
10894                 techno = "LE";
10895                 addr_type = "public";
10896                 break;
10897         case BDADDR_LE_RANDOM:
10898                 techno = "LE";
10899                 addr_type = "static";
10900                 break;
10901         default:
10902                 return;
10903         }
10904
10905         str = g_key_file_get_string(key_file, "General",
10906                                         "SupportedTechnologies", NULL);
10907         if (!str)
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");
10913
10914         g_free(str);
10915
10916         if (addr_type)
10917                 g_key_file_set_string(key_file, "General", "AddressType",
10918                                         addr_type);
10919 }
10920
10921 static void convert_aliases_entry(GKeyFile *key_file, void *value)
10922 {
10923         g_key_file_set_string(key_file, "General", "Alias", value);
10924 }
10925
10926 static void convert_trusts_entry(GKeyFile *key_file, void *value)
10927 {
10928         g_key_file_set_boolean(key_file, "General", "Trusted", TRUE);
10929 }
10930
10931 static void convert_classes_entry(GKeyFile *key_file, void *value)
10932 {
10933         g_key_file_set_string(key_file, "General", "Class", value);
10934 }
10935
10936 static void convert_blocked_entry(GKeyFile *key_file, void *value)
10937 {
10938         g_key_file_set_boolean(key_file, "General", "Blocked", TRUE);
10939 }
10940
10941 static void convert_did_entry(GKeyFile *key_file, void *value)
10942 {
10943         char *vendor_str, *product_str, *version_str;
10944         uint16_t val;
10945
10946         vendor_str = strchr(value, ' ');
10947         if (!vendor_str)
10948                 return;
10949
10950         *(vendor_str++) = 0;
10951
10952         if (g_str_equal(value, "FFFF"))
10953                 return;
10954
10955         product_str = strchr(vendor_str, ' ');
10956         if (!product_str)
10957                 return;
10958
10959         *(product_str++) = 0;
10960
10961         version_str = strchr(product_str, ' ');
10962         if (!version_str)
10963                 return;
10964
10965         *(version_str++) = 0;
10966
10967         val = (uint16_t) strtol(value, NULL, 16);
10968         g_key_file_set_integer(key_file, "DeviceID", "Source", val);
10969
10970         val = (uint16_t) strtol(vendor_str, NULL, 16);
10971         g_key_file_set_integer(key_file, "DeviceID", "Vendor", val);
10972
10973         val = (uint16_t) strtol(product_str, NULL, 16);
10974         g_key_file_set_integer(key_file, "DeviceID", "Product", val);
10975
10976         val = (uint16_t) strtol(version_str, NULL, 16);
10977         g_key_file_set_integer(key_file, "DeviceID", "Version", val);
10978 }
10979
10980 static void convert_linkkey_entry(GKeyFile *key_file, void *value)
10981 {
10982         char *type_str, *length_str, *str;
10983         int val;
10984
10985         type_str = strchr(value, ' ');
10986         if (!type_str)
10987                 return;
10988
10989         *(type_str++) = 0;
10990
10991         length_str = strchr(type_str, ' ');
10992         if (!length_str)
10993                 return;
10994
10995         *(length_str++) = 0;
10996
10997         str = g_strconcat("0x", value, NULL);
10998         g_key_file_set_string(key_file, "LinkKey", "Key", str);
10999         g_free(str);
11000
11001         val = strtol(type_str, NULL, 16);
11002         g_key_file_set_integer(key_file, "LinkKey", "Type", val);
11003
11004         val = strtol(length_str, NULL, 16);
11005         g_key_file_set_integer(key_file, "LinkKey", "PINLength", val);
11006 }
11007
11008 static void convert_ltk_entry(GKeyFile *key_file, void *value)
11009 {
11010         char *auth_str, *rand_str, *str;
11011         int i, ret;
11012         unsigned char auth, central, enc_size;
11013         unsigned short ediv;
11014
11015         auth_str = strchr(value, ' ');
11016         if (!auth_str)
11017                 return;
11018
11019         *(auth_str++) = 0;
11020
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')
11024                         return;
11025
11026                 rand_str++;
11027         }
11028
11029         ret = sscanf(auth_str, " %hhd %hhd %hhd %hd", &auth, &central,
11030                                                         &enc_size, &ediv);
11031         if (ret < 4)
11032                 return;
11033
11034         str = g_strconcat("0x", value, NULL);
11035         g_key_file_set_string(key_file, "LongTermKey", "Key", str);
11036         g_free(str);
11037
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);
11041
11042         str = g_strconcat("0x", rand_str, NULL);
11043         g_key_file_set_string(key_file, "LongTermKey", "Rand", str);
11044         g_free(str);
11045 }
11046
11047 static void convert_profiles_entry(GKeyFile *key_file, void *value)
11048 {
11049         g_strdelimit(value, " ", ';');
11050         g_key_file_set_string(key_file, "General", "Services", value);
11051 }
11052
11053 static void convert_appearances_entry(GKeyFile *key_file, void *value)
11054 {
11055         g_key_file_set_string(key_file, "General", "Appearance", value);
11056 }
11057
11058 static void convert_entry(char *key, char *value, void *user_data)
11059 {
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;
11065         char *data;
11066         gsize length = 0;
11067
11068         if (strchr(key, '#')) {
11069                 key[17] = '\0';
11070                 type = key[18] - '0';
11071         }
11072
11073         if (bachk(key) != 0)
11074                 return;
11075
11076         if (converter->force == FALSE) {
11077                 struct stat st;
11078                 int err;
11079
11080                 create_filename(filename, PATH_MAX, "/%s/%s",
11081                                 converter->address, key);
11082
11083                 err = stat(filename, &st);
11084                 if (err || !S_ISDIR(st.st_mode))
11085                         return;
11086         }
11087
11088         create_filename(filename, PATH_MAX, "/%s/%s/info",
11089                         converter->address, key);
11090
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,
11094                                                                 gerr->message);
11095                 g_clear_error(&gerr);
11096         }
11097
11098         set_device_type(key_file, type);
11099
11100         converter->cb(key_file, value);
11101
11102         data = g_key_file_to_data(key_file, &length, NULL);
11103         if (length > 0) {
11104                 create_file(filename, 0600);
11105                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11106                         error("Unable set contents for %s: (%s)", filename,
11107                                                                 gerr->message);
11108                         g_error_free(gerr);
11109                 }
11110         }
11111
11112         g_free(data);
11113
11114         g_key_file_free(key_file);
11115 }
11116
11117 static void convert_file(char *file, char *address,
11118                                 void (*cb)(GKeyFile *key_file, void *value),
11119                                 gboolean force)
11120 {
11121         char filename[PATH_MAX];
11122         struct device_converter converter;
11123
11124         create_filename(filename, PATH_MAX, "/%s/%s", address, file);
11125
11126         converter.address = address;
11127         converter.cb = cb;
11128         converter.force = force;
11129
11130         textfile_foreach(filename, convert_entry, &converter);
11131 }
11132
11133 static gboolean record_has_uuid(const sdp_record_t *rec,
11134                                 const char *profile_uuid)
11135 {
11136         sdp_list_t *pat;
11137
11138         for (pat = rec->pattern; pat != NULL; pat = pat->next) {
11139                 char *uuid;
11140                 int ret;
11141
11142                 uuid = bt_uuid2string(pat->data);
11143                 if (!uuid)
11144                         continue;
11145
11146                 ret = strcasecmp(uuid, profile_uuid);
11147
11148                 free(uuid);
11149
11150                 if (ret == 0)
11151                         return TRUE;
11152         }
11153
11154         return FALSE;
11155 }
11156
11157 static void store_attribute_uuid(GKeyFile *key_file, uint16_t start,
11158                                         uint16_t end, char *att_uuid,
11159                                         uuid_t uuid)
11160 {
11161         char handle[6], uuid_str[33];
11162         int i;
11163
11164         switch (uuid.type) {
11165         case SDP_UUID16:
11166                 sprintf(uuid_str, "%4.4X", uuid.value.uuid16);
11167                 break;
11168         case SDP_UUID32:
11169                 sprintf(uuid_str, "%8.8X", uuid.value.uuid32);
11170                 break;
11171         case SDP_UUID128:
11172                 for (i = 0; i < 16; i++)
11173                         sprintf(uuid_str + (i * 2), "%2.2X",
11174                                         uuid.value.uuid128.data[i]);
11175                 break;
11176         default:
11177                 uuid_str[0] = '\0';
11178         }
11179
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);
11184 }
11185
11186 static void store_sdp_record(char *local, char *peer, int handle, char *value)
11187 {
11188         char filename[PATH_MAX];
11189         GKeyFile *key_file;
11190         GError *gerr = NULL;
11191         char handle_str[11];
11192         char *data;
11193         gsize length = 0;
11194
11195         create_filename(filename, PATH_MAX, "/%s/cache/%s", local, peer);
11196
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,
11200                                                                 gerr->message);
11201                 g_clear_error(&gerr);
11202         }
11203
11204         sprintf(handle_str, "0x%8.8X", handle);
11205         g_key_file_set_string(key_file, "ServiceRecords", handle_str, value);
11206
11207         data = g_key_file_to_data(key_file, &length, NULL);
11208         if (length > 0) {
11209                 create_file(filename, 0600);
11210                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11211                         error("Unable set contents for %s: (%s)", filename,
11212                                                                 gerr->message);
11213                         g_error_free(gerr);
11214                 }
11215         }
11216
11217         g_free(data);
11218
11219         g_key_file_free(key_file);
11220 }
11221
11222 static void convert_sdp_entry(char *key, char *value, void *user_data)
11223 {
11224         char *src_addr = user_data;
11225         char dst_addr[18];
11226         char type = BDADDR_BREDR;
11227         int handle, ret;
11228         char filename[PATH_MAX];
11229         GKeyFile *key_file;
11230         GError *gerr = NULL;
11231         struct stat st;
11232         sdp_record_t *rec;
11233         uuid_t uuid;
11234         char *att_uuid, *prim_uuid;
11235         uint16_t start = 0, end = 0, psm = 0;
11236         int err;
11237         char *data;
11238         gsize length = 0;
11239
11240         ret = sscanf(key, "%17s#%hhu#%08X", dst_addr, &type, &handle);
11241         if (ret < 3) {
11242                 ret = sscanf(key, "%17s#%08X", dst_addr, &handle);
11243                 if (ret < 2)
11244                         return;
11245         }
11246
11247         if (bachk(dst_addr) != 0)
11248                 return;
11249
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);
11253
11254         err = stat(filename, &st);
11255         if (err || !S_ISDIR(st.st_mode))
11256                 return;
11257
11258         /* store device records in cache */
11259         store_sdp_record(src_addr, dst_addr, handle, value);
11260
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);
11265
11266         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11267         prim_uuid = bt_uuid2string(&uuid);
11268
11269         rec = record_from_string(value);
11270
11271         if (record_has_uuid(rec, att_uuid))
11272                 goto failed;
11273
11274         /* TODO: Do this through btd_gatt_database */
11275         if (!gatt_parse_record(rec, &uuid, &psm, &start, &end))
11276                 goto failed;
11277
11278         create_filename(filename, PATH_MAX, "/%s/%s/attributes", src_addr,
11279                                                                 dst_addr);
11280
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,
11284                                                                 gerr->message);
11285                 g_clear_error(&gerr);
11286         }
11287
11288         store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11289
11290         data = g_key_file_to_data(key_file, &length, NULL);
11291         if (length > 0) {
11292                 create_file(filename, 0600);
11293                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11294                         error("Unable set contents for %s: (%s)", filename,
11295                                                                 gerr->message);
11296                         g_error_free(gerr);
11297                 }
11298         }
11299
11300         g_free(data);
11301         g_key_file_free(key_file);
11302
11303 failed:
11304         sdp_record_free(rec);
11305         free(prim_uuid);
11306         free(att_uuid);
11307 }
11308
11309 static void convert_primaries_entry(char *key, char *value, void *user_data)
11310 {
11311         char *address = user_data;
11312         int device_type = -1;
11313         uuid_t uuid;
11314         char **services, **service, *prim_uuid;
11315         char filename[PATH_MAX];
11316         GKeyFile *key_file;
11317         GError *gerr = NULL;
11318         int ret;
11319         uint16_t start, end;
11320         char uuid_str[MAX_LEN_UUID_STR + 1];
11321         char *data;
11322         gsize length = 0;
11323
11324         if (strchr(key, '#')) {
11325                 key[17] = '\0';
11326                 device_type = key[18] - '0';
11327         }
11328
11329         if (bachk(key) != 0)
11330                 return;
11331
11332         services = g_strsplit(value, " ", 0);
11333         if (services == NULL)
11334                 return;
11335
11336         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11337         prim_uuid = bt_uuid2string(&uuid);
11338
11339         create_filename(filename, PATH_MAX, "/%s/%s/attributes", address, key);
11340
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,
11344                                                                 gerr->message);
11345                 g_clear_error(&gerr);
11346         }
11347
11348         for (service = services; *service; service++) {
11349                 ret = sscanf(*service, "%04hX#%04hX#%s", &start, &end,
11350                                                                 uuid_str);
11351                 if (ret < 3)
11352                         continue;
11353
11354                 bt_string2uuid(&uuid, uuid_str);
11355                 sdp_uuid128_to_uuid(&uuid);
11356
11357                 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11358         }
11359
11360         g_strfreev(services);
11361
11362         data = g_key_file_to_data(key_file, &length, NULL);
11363         if (length == 0)
11364                 goto end;
11365
11366         create_file(filename, 0600);
11367         if (!g_file_set_contents(filename, data, length, &gerr)) {
11368                 error("Unable set contents for %s: (%s)", filename,
11369                                                                 gerr->message);
11370                 g_clear_error(&gerr);
11371         }
11372
11373         if (device_type < 0)
11374                 goto end;
11375
11376         g_free(data);
11377         g_key_file_free(key_file);
11378
11379         create_filename(filename, PATH_MAX, "/%s/%s/info", address, key);
11380
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,
11384                                                                 gerr->message);
11385                 g_clear_error(&gerr);
11386         }
11387         set_device_type(key_file, device_type);
11388
11389         data = g_key_file_to_data(key_file, &length, NULL);
11390         if (length > 0) {
11391                 create_file(filename, 0600);
11392                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11393                         error("Unable set contents for %s: (%s)", filename,
11394                                                                 gerr->message);
11395                         g_error_free(gerr);
11396                 }
11397         }
11398
11399 end:
11400         g_free(data);
11401         free(prim_uuid);
11402         g_key_file_free(key_file);
11403 }
11404
11405 static void convert_ccc_entry(char *key, char *value, void *user_data)
11406 {
11407         char *src_addr = user_data;
11408         char dst_addr[18];
11409         char type = BDADDR_BREDR;
11410         uint16_t handle;
11411         int ret, err;
11412         char filename[PATH_MAX];
11413         GKeyFile *key_file;
11414         GError *gerr = NULL;
11415         struct stat st;
11416         char group[6];
11417         char *data;
11418         gsize length = 0;
11419
11420         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11421         if (ret < 3)
11422                 return;
11423
11424         if (bachk(dst_addr) != 0)
11425                 return;
11426
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);
11430
11431         err = stat(filename, &st);
11432         if (err || !S_ISDIR(st.st_mode))
11433                 return;
11434
11435         create_filename(filename, PATH_MAX, "/%s/%s/ccc", src_addr, dst_addr);
11436
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,
11440                                                                 gerr->message);
11441                 g_clear_error(&gerr);
11442         }
11443
11444         sprintf(group, "%hu", handle);
11445         g_key_file_set_string(key_file, group, "Value", value);
11446
11447         data = g_key_file_to_data(key_file, &length, NULL);
11448         if (length > 0) {
11449                 create_file(filename, 0600);
11450                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11451                         error("Unable set contents for %s: (%s)", filename,
11452                                                                 gerr->message);
11453                         g_error_free(gerr);
11454                 }
11455         }
11456
11457         g_free(data);
11458         g_key_file_free(key_file);
11459 }
11460
11461 static void convert_gatt_entry(char *key, char *value, void *user_data)
11462 {
11463         char *src_addr = user_data;
11464         char dst_addr[18];
11465         char type = BDADDR_BREDR;
11466         uint16_t handle;
11467         int ret, err;
11468         char filename[PATH_MAX];
11469         GKeyFile *key_file;
11470         GError *gerr = NULL;
11471         struct stat st;
11472         char group[6];
11473         char *data;
11474         gsize length = 0;
11475
11476         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11477         if (ret < 3)
11478                 return;
11479
11480         if (bachk(dst_addr) != 0)
11481                 return;
11482
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);
11486
11487         err = stat(filename, &st);
11488         if (err || !S_ISDIR(st.st_mode))
11489                 return;
11490
11491         create_filename(filename, PATH_MAX, "/%s/%s/gatt", src_addr, dst_addr);
11492
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,
11496                                                                 gerr->message);
11497                 g_clear_error(&gerr);
11498         }
11499
11500         sprintf(group, "%hu", handle);
11501         g_key_file_set_string(key_file, group, "Value", value);
11502
11503         data = g_key_file_to_data(key_file, &length, NULL);
11504         if (length > 0) {
11505                 create_file(filename, 0600);
11506                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11507                         error("Unable set contents for %s: (%s)", filename,
11508                                                                 gerr->message);
11509                         g_error_free(gerr);
11510                 }
11511         }
11512
11513         g_free(data);
11514         g_key_file_free(key_file);
11515 }
11516
11517 static void convert_proximity_entry(char *key, char *value, void *user_data)
11518 {
11519         char *src_addr = user_data;
11520         char *alert;
11521         char filename[PATH_MAX];
11522         GKeyFile *key_file;
11523         GError *gerr = NULL;
11524         struct stat st;
11525         int err;
11526         char *data;
11527         gsize length = 0;
11528
11529         if (!strchr(key, '#'))
11530                 return;
11531
11532         key[17] = '\0';
11533         alert = &key[18];
11534
11535         if (bachk(key) != 0)
11536                 return;
11537
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);
11541
11542         err = stat(filename, &st);
11543         if (err || !S_ISDIR(st.st_mode))
11544                 return;
11545
11546         create_filename(filename, PATH_MAX, "/%s/%s/proximity", src_addr, key);
11547
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,
11551                                                                 gerr->message);
11552                 g_clear_error(&gerr);
11553         }
11554
11555         g_key_file_set_string(key_file, alert, "Level", value);
11556
11557         data = g_key_file_to_data(key_file, &length, NULL);
11558         if (length > 0) {
11559                 create_file(filename, 0600);
11560                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11561                         error("Unable set contents for %s: (%s)", filename,
11562                                                                 gerr->message);
11563                         g_error_free(gerr);
11564                 }
11565         }
11566
11567         g_free(data);
11568         g_key_file_free(key_file);
11569 }
11570
11571 static void convert_device_storage(struct btd_adapter *adapter)
11572 {
11573         char filename[PATH_MAX];
11574         char address[18];
11575
11576         ba2str(&adapter->bdaddr, address);
11577
11578         /* Convert device's name cache */
11579         create_filename(filename, PATH_MAX, "/%s/names", address);
11580         textfile_foreach(filename, convert_names_entry, address);
11581
11582         /* Convert aliases */
11583         convert_file("aliases", address, convert_aliases_entry, TRUE);
11584
11585         /* Convert trusts */
11586         convert_file("trusts", address, convert_trusts_entry, TRUE);
11587
11588         /* Convert blocked */
11589         convert_file("blocked", address, convert_blocked_entry, TRUE);
11590
11591         /* Convert profiles */
11592         convert_file("profiles", address, convert_profiles_entry, TRUE);
11593
11594         /* Convert primaries */
11595         create_filename(filename, PATH_MAX, "/%s/primaries", address);
11596         textfile_foreach(filename, convert_primaries_entry, address);
11597
11598         /* Convert linkkeys */
11599         convert_file("linkkeys", address, convert_linkkey_entry, TRUE);
11600
11601         /* Convert longtermkeys */
11602         convert_file("longtermkeys", address, convert_ltk_entry, TRUE);
11603
11604         /* Convert classes */
11605         convert_file("classes", address, convert_classes_entry, FALSE);
11606
11607         /* Convert device ids */
11608         convert_file("did", address, convert_did_entry, FALSE);
11609
11610         /* Convert sdp */
11611         create_filename(filename, PATH_MAX, "/%s/sdp", address);
11612         textfile_foreach(filename, convert_sdp_entry, address);
11613
11614         /* Convert ccc */
11615         create_filename(filename, PATH_MAX, "/%s/ccc", address);
11616         textfile_foreach(filename, convert_ccc_entry, address);
11617
11618         /* Convert appearances */
11619         convert_file("appearances", address, convert_appearances_entry, FALSE);
11620
11621         /* Convert gatt */
11622         create_filename(filename, PATH_MAX, "/%s/gatt", address);
11623         textfile_foreach(filename, convert_gatt_entry, address);
11624
11625         /* Convert proximity */
11626         create_filename(filename, PATH_MAX, "/%s/proximity", address);
11627         textfile_foreach(filename, convert_proximity_entry, address);
11628 }
11629
11630 static void convert_config(struct btd_adapter *adapter, const char *filename,
11631                                                         GKeyFile *key_file)
11632 {
11633         char address[18];
11634         char str[MAX_NAME_LENGTH + 1];
11635         char config_path[PATH_MAX];
11636         int timeout;
11637         uint8_t mode;
11638         char *data;
11639         gsize length = 0;
11640         GError *gerr = NULL;
11641
11642         ba2str(&adapter->bdaddr, address);
11643         create_filename(config_path, PATH_MAX, "/%s/config", address);
11644
11645         if (read_pairable_timeout(address, &timeout) == 0)
11646                 g_key_file_set_integer(key_file, "General",
11647                                                 "PairableTimeout", timeout);
11648
11649         if (read_discoverable_timeout(address, &timeout) == 0)
11650                 g_key_file_set_integer(key_file, "General",
11651                                                 "DiscoverableTimeout", timeout);
11652
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);
11657         }
11658
11659         if (read_local_name(&adapter->bdaddr, str) == 0)
11660                 g_key_file_set_string(key_file, "General", "Alias", str);
11661
11662         create_file(filename, 0600);
11663
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,
11667                                                                 gerr->message);
11668                 g_error_free(gerr);
11669         }
11670         g_free(data);
11671 }
11672
11673 static void fix_storage(struct btd_adapter *adapter)
11674 {
11675         char filename[PATH_MAX];
11676         char address[18];
11677         char *converted;
11678
11679         ba2str(&adapter->bdaddr, address);
11680
11681         create_filename(filename, PATH_MAX, "/%s/config", address);
11682
11683         converted = textfile_get(filename, "converted");
11684         if (!converted)
11685                 return;
11686
11687         free(converted);
11688
11689         textfile_del(filename, "converted");
11690
11691         create_filename(filename, PATH_MAX, "/%s/names", address);
11692         textfile_del(filename, "converted");
11693
11694         create_filename(filename, PATH_MAX, "/%s/aliases", address);
11695         textfile_del(filename, "converted");
11696
11697         create_filename(filename, PATH_MAX, "/%s/trusts", address);
11698         textfile_del(filename, "converted");
11699
11700         create_filename(filename, PATH_MAX, "/%s/blocked", address);
11701         textfile_del(filename, "converted");
11702
11703         create_filename(filename, PATH_MAX, "/%s/profiles", address);
11704         textfile_del(filename, "converted");
11705
11706         create_filename(filename, PATH_MAX, "/%s/primaries", address);
11707         textfile_del(filename, "converted");
11708
11709         create_filename(filename, PATH_MAX, "/%s/linkkeys", address);
11710         textfile_del(filename, "converted");
11711
11712         create_filename(filename, PATH_MAX, "/%s/longtermkeys", address);
11713         textfile_del(filename, "converted");
11714
11715         create_filename(filename, PATH_MAX, "/%s/classes", address);
11716         textfile_del(filename, "converted");
11717
11718         create_filename(filename, PATH_MAX, "/%s/did", address);
11719         textfile_del(filename, "converted");
11720
11721         create_filename(filename, PATH_MAX, "/%s/sdp", address);
11722         textfile_del(filename, "converted");
11723
11724         create_filename(filename, PATH_MAX, "/%s/ccc", address);
11725         textfile_del(filename, "converted");
11726
11727         create_filename(filename, PATH_MAX, "/%s/appearances", address);
11728         textfile_del(filename, "converted");
11729
11730         create_filename(filename, PATH_MAX, "/%s/gatt", address);
11731         textfile_del(filename, "converted");
11732
11733         create_filename(filename, PATH_MAX, "/%s/proximity", address);
11734         textfile_del(filename, "converted");
11735 }
11736
11737 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11738 static bool is_tempfile(const char *filename)
11739 {
11740         char *p;
11741         int i;
11742
11743         /* tempfile has ^[A-Z0-9]{6}$ suffix (e.g. "settings.1LS4BZ") */
11744         p = strrchr(filename, '.');
11745         if (p == NULL)
11746                 return false;
11747
11748         if (strlen(++p) != 6)
11749                 return false;
11750
11751         for (i = 0; i < 6; i++) {
11752                 if (isdigit(p[i]) || isupper(p[i]))
11753                         continue;
11754                 else
11755                         return false;
11756         }
11757         return true;
11758 }
11759
11760 static void delete_tempfiles(const char *dirname)
11761 {
11762         DIR *dir;
11763         struct dirent *entry;
11764         char filename[PATH_MAX];
11765
11766         dir = opendir(dirname);
11767         if (dir == NULL)
11768                 return;
11769
11770         while ((entry = readdir(dir)) != NULL) {
11771                 if (g_str_equal(entry->d_name, ".") || g_str_equal(entry->d_name, ".."))
11772                         continue;
11773
11774                 if (entry->d_type == DT_UNKNOWN)
11775                         entry->d_type = util_get_dt(dirname, entry->d_name);
11776
11777                 snprintf(filename, PATH_MAX, "%s/%s", dirname, entry->d_name);
11778
11779                 if (entry->d_type == DT_DIR) {
11780                         delete_tempfiles(filename);
11781                 } else if (entry->d_type == DT_REG && is_tempfile(entry->d_name)) {
11782                         unlink(filename);
11783                 }
11784         }
11785         closedir(dir);
11786 }
11787 #endif
11788
11789 static void load_config(struct btd_adapter *adapter)
11790 {
11791         GKeyFile *key_file;
11792         char filename[PATH_MAX];
11793         struct stat st;
11794         GError *gerr = NULL;
11795 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11796         char *str;
11797 #endif
11798
11799         key_file = g_key_file_new();
11800
11801         create_filename(filename, PATH_MAX, "/%s/settings",
11802                                         btd_adapter_get_storage_dir(adapter));
11803
11804         if (stat(filename, &st) < 0) {
11805                 convert_config(adapter, filename, key_file);
11806                 convert_device_storage(adapter);
11807         }
11808
11809         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11810                 error("Unable to load key file from %s: (%s)", filename,
11811                                                                 gerr->message);
11812                 g_clear_error(&gerr);
11813         }
11814
11815         /* Get alias */
11816         adapter->stored_alias = g_key_file_get_string(key_file, "General",
11817                                                                 "Alias", NULL);
11818         if (!adapter->stored_alias) {
11819                 /* fallback */
11820                 adapter->stored_alias = g_key_file_get_string(key_file,
11821                                                 "General", "Name", NULL);
11822         }
11823
11824         /* Get pairable timeout */
11825         adapter->pairable_timeout = g_key_file_get_integer(key_file, "General",
11826                                                 "PairableTimeout", &gerr);
11827         if (gerr) {
11828                 adapter->pairable_timeout = btd_opts.pairto;
11829                 g_error_free(gerr);
11830                 gerr = NULL;
11831         }
11832
11833         /* Get discoverable mode */
11834         adapter->stored_discoverable = g_key_file_get_boolean(key_file,
11835                                         "General", "Discoverable", &gerr);
11836         if (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;
11841                 } else
11842 #endif
11843                         adapter->stored_discoverable = false;
11844                 g_error_free(gerr);
11845                 gerr = NULL;
11846         }
11847
11848         /* Get discoverable timeout */
11849         adapter->discoverable_timeout = g_key_file_get_integer(key_file,
11850                                 "General", "DiscoverableTimeout", &gerr);
11851         if (gerr) {
11852                 adapter->discoverable_timeout = btd_opts.discovto;
11853                 g_error_free(gerr);
11854                 gerr = NULL;
11855         }
11856
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;
11869                         }
11870                 } else {
11871                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11872                 }
11873                 g_error_free(gerr);
11874                 gerr = NULL;
11875         } else {
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;
11880                 else /* source */
11881                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11882                 g_free(str);
11883         }
11884 #endif
11885
11886         g_key_file_free(key_file);
11887 }
11888
11889 static struct btd_adapter *btd_adapter_new(uint16_t index)
11890 {
11891         struct btd_adapter *adapter;
11892         int blocked;
11893
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 */
11901 #endif
11902
11903         adapter = g_try_new0(struct btd_adapter, 1);
11904         if (!adapter)
11905                 return NULL;
11906
11907         adapter->dev_id = index;
11908         adapter->mgmt = mgmt_ref(mgmt_primary);
11909         adapter->pincode_requested = false;
11910         blocked = rfkill_get_blocked(index);
11911         if (blocked > 0)
11912                 adapter->power_state = ADAPTER_POWER_STATE_OFF_BLOCKED;
11913
11914         /*
11915          * Setup default configuration values. These are either adapter
11916          * defaults or from a system wide configuration file.
11917          *
11918          * Some value might be overwritten later on by adapter specific
11919          * configuration. This is to make sure that sane defaults are
11920          * always present.
11921          */
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;
11933 #endif
11934
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);
11941         if (blocked > 0)
11942                 DBG("Power state: %s",
11943                         adapter_power_state_str(adapter->power_state));
11944
11945         adapter->auths = g_queue_new();
11946         adapter->exps = queue_new();
11947
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");
11956
11957         msg = dbus_message_new_method_call(DEVICED_DEST,
11958                         DEVICED_BATT_OBJECT_PATH,
11959                         DEVICED_BATT_INTERFACE, "ChargerType");
11960         if (msg) {
11961                 reply = dbus_connection_send_with_reply_and_block(conn,
11962                                 msg, 1000, NULL);
11963                 if (reply) {
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);
11968                         }
11969                         dbus_message_unref(reply);
11970                 } else {
11971                         error("Reply is NULL");
11972                 }
11973                 dbus_message_unref(msg);
11974         } else {
11975                 error("Unable to create dbus message for charging state");
11976         }
11977 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11978 #endif
11979
11980         return btd_adapter_ref(adapter);
11981 }
11982
11983 static void adapter_remove(struct btd_adapter *adapter)
11984 {
11985         GSList *l;
11986 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11987         struct gatt_db *db;
11988 #endif
11989
11990         DBG("Removing adapter %s", adapter->path);
11991
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;
11998         }
11999
12000         if (adapter->charging_timeout) {
12001                 g_source_remove(adapter->charging_timeout);
12002                 adapter->charging_timeout = 0;
12003         }
12004 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
12005 #endif
12006
12007         if (adapter->discovery_idle_timeout > 0) {
12008                 g_source_remove(adapter->discovery_idle_timeout);
12009                 adapter->discovery_idle_timeout = 0;
12010         }
12011
12012         discovery_cleanup(adapter, 0);
12013
12014         g_slist_free(adapter->connect_list);
12015         adapter->connect_list = NULL;
12016
12017         for (l = adapter->devices; l; l = l->next) {
12018                 device_removed_drivers(adapter, l->data);
12019                 device_remove(l->data, FALSE);
12020         }
12021
12022         g_slist_free(adapter->devices);
12023         adapter->devices = NULL;
12024
12025         discovery_cleanup(adapter, 0);
12026
12027         unload_drivers(adapter);
12028
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;
12033
12034         btd_gatt_database_destroy(adapter->database);
12035         adapter->database = NULL;
12036 #else
12037         btd_adapter_gatt_server_stop(adapter);
12038 #endif
12039         btd_adv_manager_destroy(adapter->adv_manager);
12040         adapter->adv_manager = NULL;
12041
12042         btd_adv_monitor_manager_destroy(adapter->adv_monitor_manager);
12043         adapter->adv_monitor_manager = NULL;
12044
12045         btd_battery_provider_manager_destroy(adapter->battery_provider_manager);
12046         adapter->battery_provider_manager = NULL;
12047
12048         g_slist_free(adapter->pin_callbacks);
12049         adapter->pin_callbacks = NULL;
12050
12051         g_slist_free(adapter->msd_callbacks);
12052         adapter->msd_callbacks = NULL;
12053 }
12054
12055 const char *adapter_get_path(struct btd_adapter *adapter)
12056 {
12057         if (!adapter)
12058                 return NULL;
12059
12060         return adapter->path;
12061 }
12062
12063 const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter)
12064 {
12065         return &adapter->bdaddr;
12066 }
12067
12068 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12069 const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter)
12070 {
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;
12075         else
12076                 return &adapter->bdaddr;
12077 }
12078
12079 uint8_t btd_adapter_get_le_address_type(struct btd_adapter * adapter)
12080 {
12081         if (adapter->current_settings & MGMT_SETTING_PRIVACY ||
12082                                 adapter->le_static_addr.b[5] != 0)
12083                         return BDADDR_LE_RANDOM;
12084                 else
12085                         return BDADDR_LE_PUBLIC;
12086 }
12087 #endif
12088
12089 static void confirm_name_complete(uint8_t status, uint16_t length,
12090                                         const void *param, void *user_data)
12091 {
12092         struct btd_adapter *adapter = user_data;
12093
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);
12098                 return;
12099         }
12100
12101         DBG("Confirm name complete for hci%u", adapter->dev_id);
12102 }
12103
12104 static void confirm_name(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12105                                         uint8_t bdaddr_type, bool name_known)
12106 {
12107         struct mgmt_cp_confirm_name cp;
12108         char addr[18];
12109
12110         ba2str(bdaddr, addr);
12111         DBG("hci%d bdaddr %s name_known %u", adapter->dev_id, addr,
12112                                                                 name_known);
12113
12114         memset(&cp, 0, sizeof(cp));
12115         bacpy(&cp.addr.bdaddr, bdaddr);
12116         cp.addr.type = bdaddr_type;
12117         cp.name_known = name_known;
12118
12119         /*
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.
12123          */
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",
12128                                                         adapter->dev_id);
12129 }
12130
12131 static void adapter_msd_notify(struct btd_adapter *adapter,
12132                                                         struct btd_device *dev,
12133                                                         GSList *msd_list)
12134 {
12135         GSList *cb_l, *cb_next;
12136         GSList *msd_l, *msd_next;
12137
12138         for (cb_l = adapter->msd_callbacks; cb_l != NULL; cb_l = cb_next) {
12139                 btd_msd_cb_t cb = cb_l->data;
12140
12141                 cb_next = g_slist_next(cb_l);
12142
12143                 for (msd_l = msd_list; msd_l != NULL; msd_l = msd_next) {
12144                         const struct eir_msd *msd = msd_l->data;
12145
12146                         msd_next = g_slist_next(msd_l);
12147
12148                         cb(adapter, dev, msd->company, msd->data,
12149                                                                 msd->data_len);
12150                 }
12151         }
12152 }
12153
12154 static bool is_filter_match(GSList *discovery_filter, struct eir_data *eir_data,
12155                                                                 int8_t rssi)
12156 {
12157         GSList *l, *m;
12158         bool got_match = false;
12159
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;
12164
12165                 /*
12166                  * If one of currently running scans is regular scan, then
12167                  * return all devices as matches
12168                  */
12169                 if (!item) {
12170                         got_match = true;
12171                         continue;
12172                 }
12173
12174                 /* if someone started discovery with empty uuids, he wants all
12175                  * devices in given proximity.
12176                  */
12177                 if (!item->uuids)
12178                         got_match = true;
12179                 else {
12180                         for (m = item->uuids; m != NULL && got_match != true;
12181                                                         m = g_slist_next(m)) {
12182                                 /* m->data contains string representation of
12183                                  * uuid.
12184                                  */
12185                                 if (g_slist_find_custom(eir_data->services,
12186                                                         m->data,
12187                                                         g_strcmp) != NULL)
12188                                         got_match = true;
12189                         }
12190                 }
12191
12192                 if (got_match) {
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))
12199                                 return true;
12200
12201                         got_match = false;
12202                 }
12203         }
12204
12205         return got_match;
12206 }
12207
12208 static void filter_duplicate_data(void *data, void *user_data)
12209 {
12210         struct discovery_client *client = data;
12211         bool *duplicate = user_data;
12212
12213         if (*duplicate || !client->discovery_filter)
12214                 return;
12215
12216         *duplicate = client->discovery_filter->duplicate;
12217 }
12218
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)
12223 {
12224         GSList *l;
12225         bool discoverable;
12226
12227         if (bdaddr_type == BDADDR_BREDR || adapter->filtered_discovery)
12228                 discoverable = true;
12229         else
12230                 discoverable = eir->flags & (EIR_LIM_DISC | EIR_GEN_DISC);
12231
12232         /*
12233          * Mark as not discoverable if no client has requested discovery and
12234          * report has not set any discoverable flags.
12235          */
12236         if (!adapter->discovery_list && !discoverable)
12237                 return false;
12238
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;
12244
12245                 if (!filter || !filter->pattern)
12246                         continue;
12247
12248                 /* Reset discoverable if a client has a pattern filter */
12249                 discoverable = false;
12250
12251                 pattern_len = strlen(filter->pattern);
12252                 if (!pattern_len)
12253                         return true;
12254
12255                 if (!strncmp(filter->pattern, addr, pattern_len))
12256                         return true;
12257
12258                 if (eir->name && !strncmp(filter->pattern, eir->name,
12259                                                         pattern_len))
12260                         return true;
12261         }
12262
12263         return discoverable;
12264 }
12265 #endif
12266
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,
12273                                         bool monitoring)
12274 #else
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,
12280                                         bool monitoring)
12281 #endif
12282 {
12283         struct btd_device *dev;
12284 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12285         struct bt_ad *ad = NULL;
12286 #endif
12287         struct eir_data eir_data;
12288 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12289         bool name_known, discoverable;
12290         bool not_connectable;
12291 #else
12292         bool name_known;
12293 #endif
12294 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12295         uint8_t allow_report;
12296 #endif
12297         char addr[18];
12298         bool confirm;
12299         bool legacy;
12300 //      bool not_connectable;
12301         bool name_resolve_failed;
12302         bool scan_rsp;
12303         bool duplicate = false;
12304
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);
12309 #endif
12310         name_resolve_failed = (flags & MGMT_DEV_FOUND_NAME_REQUEST_FAILED);
12311         scan_rsp = (flags & MGMT_DEV_FOUND_SCAN_RSP);
12312
12313 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12314         struct queue *matched_monitors = NULL;
12315
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);
12321
12322                 /* During the background scanning, update the device only when
12323                 * the data match at least one Adv monitor
12324                 */
12325                 if (ad) {
12326                         matched_monitors = btd_adv_monitor_content_filter(
12327                                                 adapter->adv_monitor_manager,
12328                                                 ad);
12329                         bt_ad_unref(ad);
12330                         ad = NULL;
12331                         monitoring = matched_monitors ? true : false;
12332                 }
12333         }
12334
12335         if (!adapter->discovering && !monitoring)
12336                 return;
12337 #endif
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,
12343                                                         bdaddr_type);
12344
12345 #endif
12346
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);
12354                 return;
12355         }
12356 #endif
12357         dev = btd_adapter_find_device(adapter, bdaddr, bdaddr_type);
12358         if (!dev) {
12359                 /*
12360                  * If no client has requested discovery or the device is
12361                  * not marked as discoverable, then do not create new
12362                  * device objects.
12363                  */
12364
12365                 /* In case of being just a scan response don't attempt to create
12366                  * the device.
12367                  */
12368                 if (scan_rsp) {
12369                         eir_data_free(&eir_data);
12370                         return;
12371                 }
12372
12373 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12374                 /*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
12375                         adapter->le_discovery_list, discoverable);*/
12376                 if ((adapter->discovery_list == NULL &&
12377                                 adapter->le_discovery_list == NULL)) {
12378                         DBG("discovery list is NULL");
12379                         eir_data_free(&eir_data);
12380                         return;
12381                 }
12382 #else
12383                 if (!adapter->discovery_list || !discoverable &&
12384                          !matched_monitors && !eir_data.rsi) {
12385                         eir_data_free(&eir_data);
12386                         return;
12387                 }
12388 #endif
12389
12390                 dev = adapter_create_device(adapter, bdaddr, bdaddr_type);
12391         }
12392
12393         if (!dev) {
12394                 btd_error(adapter->dev_id,
12395                         "Unable to create object for found device %s", addr);
12396                 eir_data_free(&eir_data);
12397                 return;
12398         }
12399
12400 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12401         if (device_get_rpa_exist(dev) == true)
12402                 bdaddr_type = BDADDR_LE_RANDOM;
12403
12404         device_update_last_seen(dev, bdaddr_type);
12405 #else
12406         device_update_last_seen(dev, bdaddr_type, !not_connectable);
12407 #endif
12408
12409         /*
12410          * FIXME: We need to check for non-zero flags first because
12411          * older kernels send separate adv_ind and scan_rsp. Newer
12412          * kernels send them merged, so once we know which mgmt version
12413          * supports this we can make the non-zero check conditional.
12414          */
12415 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12416         if (bdaddr_type == BDADDR_LE_PUBLIC && eir_data.flags &&
12417                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
12418                 device_set_bredr_support(dev);
12419                 /* Update last seen for BR/EDR in case its flag is set */
12420                 device_update_last_seen(dev, BDADDR_BREDR);
12421         }
12422 #else
12423         if (bdaddr_type != BDADDR_BREDR && 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, !not_connectable);
12428         }
12429 #endif
12430
12431         if (eir_data.name != NULL && eir_data.name_complete)
12432                 device_store_cached_name(dev, eir_data.name);
12433
12434         /*
12435          * Only skip devices that are not connected, are temporary, and there
12436          * is no active discovery session ongoing and no matched Adv monitors
12437          */
12438 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12439         if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
12440                         adapter->le_discovery_list == NULL) {
12441                 DBG("discovery list is NULL");
12442                 eir_data_free(&eir_data);
12443                 return;
12444         }
12445
12446         device_set_last_addr_type(dev, bdaddr_type);
12447         device_set_ipsp_connected(dev, FALSE, NULL);
12448 #else
12449         if (!btd_device_is_connected(dev) &&
12450                 (device_is_temporary(dev) && !adapter->discovery_list) &&
12451                 !monitoring) {
12452                 eir_data_free(&eir_data);
12453                 return;
12454         }
12455 #endif
12456
12457 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12458         if (bdaddr_type == BDADDR_BREDR) {
12459         if (adapter->filtered_discovery &&
12460             !is_filter_match(adapter->discovery_list, &eir_data, rssi)) {
12461 #else
12462         /* If there is no matched Adv monitors, don't continue if not
12463          * discoverable or if active discovery filter don't match.
12464          */
12465         if (!eir_data.rsi && !monitoring && (!discoverable ||
12466                 (adapter->filtered_discovery && !is_filter_match(
12467                                 adapter->discovery_list, &eir_data, rssi)))) {
12468 #endif
12469                 eir_data_free(&eir_data);
12470                 return;
12471         }
12472
12473         device_set_legacy(dev, legacy);
12474
12475         if (name_resolve_failed)
12476                 device_name_resolve_fail(dev);
12477
12478         if (adapter->filtered_discovery)
12479                 device_set_rssi_with_delta(dev, rssi, 0);
12480         else
12481                 device_set_rssi(dev, rssi);
12482
12483         if (eir_data.tx_power != 127)
12484                 device_set_tx_power(dev, eir_data.tx_power);
12485 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12486         }
12487 #endif
12488
12489         if (eir_data.appearance != 0)
12490                 device_set_appearance(dev, eir_data.appearance);
12491
12492         /* Report an unknown name to the kernel even if there is a short name
12493          * known, but still update the name with the known short name. */
12494 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12495         if (eir_data.name_complete)
12496                 name_known = device_name_known(dev);
12497         else
12498                 name_known = false;
12499 #else
12500         name_known = device_name_known(dev);
12501 #endif
12502
12503         if (eir_data.name && (eir_data.name_complete || !name_known))
12504                 btd_device_device_set_name(dev, eir_data.name);
12505
12506         if (eir_data.class != 0)
12507                 device_set_class(dev, eir_data.class);
12508
12509         if (eir_data.did_source || eir_data.did_vendor ||
12510                         eir_data.did_product || eir_data.did_version)
12511                 btd_device_set_pnpid(dev, eir_data.did_source,
12512                                                         eir_data.did_vendor,
12513                                                         eir_data.did_product,
12514                                                         eir_data.did_version);
12515
12516         device_add_eir_uuids(dev, eir_data.services);
12517
12518         if (adapter->discovery_list)
12519                 g_slist_foreach(adapter->discovery_list, filter_duplicate_data,
12520                                                                 &duplicate);
12521 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12522         if (eir_data.flags != 0)
12523                 device_set_remote_feature_flag(dev, eir_data.flags);
12524
12525         if (bdaddr_type == BDADDR_BREDR)
12526                 device_set_manufacturer_info(dev, &eir_data);
12527         else {
12528                 /* if the application has registered for iBeacon report,
12529                  * then send ibeacon report along with advertisement report */
12530                 device_set_adv_report_info(dev, (void*)data, data_len, adv_type, rssi);
12531         }
12532 #endif
12533
12534         if (eir_data.msd_list) {
12535                 device_set_manufacturer_data(dev, eir_data.msd_list, duplicate);
12536                 adapter_msd_notify(adapter, dev, eir_data.msd_list);
12537         }
12538
12539         if (eir_data.sd_list)
12540                 device_set_service_data(dev, eir_data.sd_list, duplicate);
12541
12542         if (eir_data.data_list)
12543                 device_set_data(dev, eir_data.data_list, duplicate);
12544
12545 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12546         if (bdaddr_type != BDADDR_BREDR && adv_type != ADV_TYPE_SCAN_RESPONSE) {
12547                 device_set_flags(dev, eir_data.flags);
12548                 device_set_le_connectable(dev, adv_type);
12549         }
12550 #else
12551         if (bdaddr_type != BDADDR_BREDR)
12552                 device_set_flags(dev, eir_data.flags);
12553 #endif
12554
12555         eir_data_free(&eir_data);
12556
12557 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12558         /* After the device is updated, notify the matched Adv monitors */
12559         if (matched_monitors) {
12560                 btd_adv_monitor_notify_monitors(adapter->adv_monitor_manager,
12561                                                 dev, rssi, matched_monitors);
12562                 queue_destroy(matched_monitors, NULL);
12563                 matched_monitors = NULL;
12564         }
12565 #endif
12566         /*
12567          * Only if at least one client has requested discovery, maintain
12568          * list of found devices and name confirming for legacy devices.
12569          * Otherwise, this is an event from passive discovery and we
12570          * should check if the device needs connecting to.
12571          */
12572 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12573         if (!adapter->discovery_list && !adapter->le_discovery_list)
12574 #else
12575         if (!adapter->discovery_list)
12576 #endif
12577                 goto connect_le;
12578
12579         if (g_slist_find(adapter->discovery_found, dev))
12580                 return;
12581
12582         /* If name is unknown but it's not allowed to resolve, don't send
12583          * MGMT_OP_CONFIRM_NAME.
12584          */
12585         if (confirm && (name_known || device_is_name_resolve_allowed(dev)))
12586                 confirm_name(adapter, bdaddr, bdaddr_type, name_known);
12587
12588         adapter->discovery_found = g_slist_prepend(adapter->discovery_found,
12589                                                                         dev);
12590
12591         return;
12592
12593 connect_le:
12594 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12595         /* Ignore non-connectable events */
12596         if (not_connectable)
12597                 return;
12598 #endif
12599
12600         /*
12601          * If we're in the process of stopping passive scanning and
12602          * connecting another (or maybe even the same) LE device just
12603          * ignore this one.
12604          */
12605         if (adapter->connect_le)
12606                 return;
12607
12608         /*
12609          * If kernel background scan is used then the kernel is
12610          * responsible for connecting.
12611          */
12612         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
12613                 return;
12614
12615         /*
12616          * If this is an LE device that's not connected and part of the
12617          * connect_list stop passive scanning so that a connection
12618          * attempt to it can be made
12619          */
12620         if (bdaddr_type != BDADDR_BREDR && !btd_device_is_connected(dev) &&
12621                                 g_slist_find(adapter->connect_list, dev)) {
12622                 adapter->connect_le = dev;
12623                 stop_passive_scanning(adapter);
12624         }
12625 }
12626
12627 static void device_found_callback(uint16_t index, uint16_t length,
12628                                         const void *param, void *user_data)
12629 {
12630         const struct mgmt_ev_device_found *ev = param;
12631         struct btd_adapter *adapter = user_data;
12632         const uint8_t *eir;
12633         uint16_t eir_len;
12634         uint32_t flags;
12635         char addr[18];
12636         if (length < sizeof(*ev)) {
12637                 btd_error(adapter->dev_id,
12638                         "Too short device found event (%u bytes)", length);
12639                 return;
12640         }
12641
12642         eir_len = btohs(ev->eir_len);
12643         if (length != sizeof(*ev) + eir_len) {
12644                 btd_error(adapter->dev_id,
12645                                 "Device found event size mismatch (%u != %zu)",
12646                                         length, sizeof(*ev) + eir_len);
12647                 return;
12648         }
12649
12650         if (eir_len == 0)
12651                 eir = NULL;
12652         else
12653                 eir = ev->eir;
12654
12655         flags = le32_to_cpu(ev->flags);
12656
12657         ba2str(&ev->addr.bdaddr, addr);
12658         DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12659                         index, addr, ev->rssi, flags, eir_len);
12660
12661 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12662         btd_adapter_device_found(adapter, &ev->addr.bdaddr,
12663                                         ev->addr.type, ev->rssi, 0, flags,
12664                                         eir, eir_len, false);
12665 #else
12666         btd_adapter_device_found(adapter, &ev->addr.bdaddr,
12667                                         ev->addr.type, ev->rssi, 0, flags,
12668                                         eir, eir_len, false);
12669 #endif
12670 }
12671
12672 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12673 static void le_device_found_callback(uint16_t index, uint16_t length,
12674                                         const void *param, void *user_data)
12675 {
12676         const struct mgmt_ev_le_device_found *ev = param;
12677         struct btd_adapter *adapter = user_data;
12678         const uint8_t *eir;
12679         uint16_t eir_len;
12680         uint32_t flags;
12681         char addr[18];
12682
12683         if (length < sizeof(*ev)) {
12684                 error("Too short device found event (%u bytes)", length);
12685                 return;
12686         }
12687
12688         eir_len = btohs(ev->eir_len);
12689         if (length != sizeof(*ev) + eir_len) {
12690                 error("Device found event size mismatch (%u != %zu)",
12691                                         length, sizeof(*ev) + eir_len);
12692                 return;
12693         }
12694
12695         if (eir_len == 0)
12696                 eir = NULL;
12697         else
12698                 eir = ev->eir;
12699
12700         flags = btohl(ev->flags);
12701
12702         ba2str(&ev->addr.bdaddr, addr);
12703         /*DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12704                         index, addr, ev->rssi, flags, eir_len);*/
12705
12706         btd_adapter_device_found(adapter, &ev->addr.bdaddr, ev->addr.type,
12707                                         ev->rssi, ev->adv_type, flags,
12708                                         eir, eir_len, false);
12709 }
12710 #endif
12711
12712 struct agent *adapter_get_agent(struct btd_adapter *adapter)
12713 {
12714         return agent_get(NULL);
12715 }
12716
12717 static void adapter_remove_connection(struct btd_adapter *adapter,
12718                                                 struct btd_device *device,
12719                                                 uint8_t bdaddr_type)
12720 {
12721         bool remove_device = false;
12722
12723         DBG("");
12724
12725         if (!g_slist_find(adapter->connections, device)) {
12726                 btd_error(adapter->dev_id, "No matching connection for device");
12727                 return;
12728         }
12729
12730         device_remove_connection(device, bdaddr_type, &remove_device);
12731
12732 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12733         if (device_is_authenticating(device, bdaddr_type))
12734 #else
12735         if (device_is_authenticating(device))
12736 #endif
12737                 device_cancel_authentication(device, TRUE);
12738
12739         /* If another bearer is still connected */
12740         if (btd_device_is_connected(device))
12741                 return;
12742
12743         adapter->connections = g_slist_remove(adapter->connections, device);
12744
12745         if (remove_device) {
12746                 const char *path = device_get_path(device);
12747
12748                 DBG("Removing temporary device %s", path);
12749                 btd_adapter_remove_device(adapter, device);
12750         }
12751
12752 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12753         DBG("isPaired %d, isBonded %d", device_is_paired(device, bdaddr_type),
12754                         device_is_bonded(device, bdaddr_type));
12755         if ((device_is_temporary(device) && !device_is_retrying(device)) ||
12756                         (!device_is_bonded(device, bdaddr_type))) {
12757
12758                 const char *path = device_get_path(device);
12759
12760                 DBG("Removing temporary device %s", path);
12761
12762                 /* device_is_paired is added incase of tempoary bonded
12763                  * oop file transfer in that device is not bonded it's paired.
12764                  */
12765                 if (!(device_is_bonded(device, bdaddr_type) ||
12766                                 device_is_paired(device, bdaddr_type))) {
12767                         DBG("addr type %d, bonded", bdaddr_type);
12768                         return;
12769                 }
12770
12771                 btd_adapter_unpair_device(adapter, device);
12772 #endif
12773         }
12774 }
12775
12776 static void adapter_stop(struct btd_adapter *adapter)
12777 {
12778         /* check pending requests */
12779         reply_pending_requests(adapter);
12780
12781         cancel_passive_scanning(adapter);
12782
12783         remove_discovery_list(adapter);
12784
12785         discovery_cleanup(adapter, 0);
12786
12787         adapter->filtered_discovery = false;
12788         adapter->no_scan_restart_delay = false;
12789         g_free(adapter->current_discovery_filter);
12790         adapter->current_discovery_filter = NULL;
12791
12792         set_discovery_discoverable(adapter, false);
12793         adapter->discovering = false;
12794
12795         while (adapter->connections) {
12796                 struct btd_device *device = adapter->connections->data;
12797                 uint8_t addr_type = btd_device_get_bdaddr_type(device);
12798
12799                 adapter_remove_connection(adapter, device, BDADDR_BREDR);
12800                 if (addr_type != BDADDR_BREDR)
12801                         adapter_remove_connection(adapter, device, addr_type);
12802         }
12803
12804         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12805                                         ADAPTER_INTERFACE, "Discovering");
12806 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12807         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12808                                                 ADAPTER_INTERFACE, "LEDiscovering");
12809 #endif
12810
12811         if (adapter->dev_class) {
12812                 /* the kernel should reset the class of device when powering
12813                  * down, but it does not. So force it here ... */
12814                 adapter->dev_class = 0;
12815                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12816                                                 ADAPTER_INTERFACE, "Class");
12817         }
12818
12819 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12820         advertiser_cleanup(adapter);
12821 #endif
12822         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12823                                                 ADAPTER_INTERFACE, "Powered");
12824         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12825                                                 ADAPTER_INTERFACE,
12826                                                 "PowerState");
12827
12828         DBG("adapter %s has been disabled", adapter->path);
12829 }
12830
12831 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
12832 {
12833         if (driver->experimental && !(g_dbus_get_flags() &
12834                                         G_DBUS_FLAG_ENABLE_EXPERIMENTAL)) {
12835                 DBG("D-Bus experimental not enabled");
12836                 return -ENOTSUP;
12837         }
12838
12839         adapter_drivers = g_slist_append(adapter_drivers, driver);
12840
12841         if (driver->probe == NULL)
12842                 return 0;
12843
12844         adapter_foreach(probe_driver, driver);
12845
12846         return 0;
12847 }
12848
12849 static void unload_driver(struct btd_adapter *adapter, gpointer data)
12850 {
12851         struct btd_adapter_driver *driver = data;
12852
12853         if (driver->remove)
12854                 driver->remove(adapter);
12855
12856         adapter->drivers = g_slist_remove(adapter->drivers, data);
12857 }
12858
12859 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
12860 {
12861         adapter_drivers = g_slist_remove(adapter_drivers, driver);
12862
12863         adapter_foreach(unload_driver, driver);
12864 }
12865
12866 static void agent_auth_cb(struct agent *agent, DBusError *derr,
12867                                                         void *user_data)
12868 {
12869         struct btd_adapter *adapter = user_data;
12870         struct service_auth *auth = g_queue_pop_head(adapter->auths);
12871
12872         if (!auth) {
12873                 DBG("No pending authorization");
12874                 return;
12875         }
12876
12877         auth->cb(derr, auth->user_data);
12878
12879         if (auth->agent)
12880                 agent_unref(auth->agent);
12881
12882         g_free(auth);
12883
12884         /* Stop processing if queue is empty */
12885         if (g_queue_is_empty(adapter->auths)) {
12886                 if (adapter->auth_idle_id > 0)
12887                         g_source_remove(adapter->auth_idle_id);
12888                 return;
12889         }
12890
12891         if (adapter->auth_idle_id > 0)
12892                 return;
12893
12894         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12895 }
12896
12897 static gboolean process_auth_queue(gpointer user_data)
12898 {
12899         struct btd_adapter *adapter = user_data;
12900         DBusError err;
12901
12902         adapter->auth_idle_id = 0;
12903
12904         dbus_error_init(&err);
12905         dbus_set_error_const(&err, ERROR_INTERFACE ".Rejected", NULL);
12906
12907         while (!g_queue_is_empty(adapter->auths)) {
12908                 struct service_auth *auth = adapter->auths->head->data;
12909                 struct btd_device *device = auth->device;
12910
12911                 /* Wait services to be resolved before asking authorization */
12912                 if (auth->svc_id > 0) {
12913 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12914                         DBG("Wait services to be resolved before asking authorization");
12915 #endif
12916                         return FALSE;
12917                 }
12918                 if (!btd_adapter_is_uuid_allowed(adapter, auth->uuid)) {
12919                         auth->cb(&err, auth->user_data);
12920                         goto next;
12921                 }
12922
12923 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12924                 if (btd_device_is_trusted(device) == TRUE) {
12925 #else
12926                 if (btd_device_is_trusted(device) == TRUE
12927                                 || device_is_profile_trusted(device, auth->uuid)
12928                                 || btd_opts.pin_code) {
12929                         /* In headless device(pin_code is existing),
12930                            no need to request to agent */
12931 #endif
12932                         auth->cb(NULL, auth->user_data);
12933                         goto next;
12934                 }
12935
12936 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12937                 /* If Profile is Blocked, Simply reject Authorization*/
12938                 if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
12939                         auth->cb(&err, auth->user_data);
12940                         goto next;
12941                 }
12942 #endif
12943
12944                 /* If agent is set authorization is already ongoing */
12945                 if (auth->agent)
12946                         return FALSE;
12947
12948                 auth->agent = agent_get(NULL);
12949                 if (auth->agent == NULL) {
12950                         btd_warn(adapter->dev_id,
12951                                         "Authentication attempt without agent");
12952                         auth->cb(&err, auth->user_data);
12953                         goto next;
12954                 }
12955
12956                 if (agent_authorize_service(auth->agent, device, auth->uuid,
12957                                         agent_auth_cb, adapter, NULL) < 0) {
12958                         auth->cb(&err, auth->user_data);
12959                         goto next;
12960                 }
12961
12962                 break;
12963
12964 next:
12965                 if (auth->agent)
12966                         agent_unref(auth->agent);
12967
12968                 g_free(auth);
12969
12970                 g_queue_pop_head(adapter->auths);
12971         }
12972
12973         dbus_error_free(&err);
12974
12975         return FALSE;
12976 }
12977
12978 static void svc_complete(struct btd_device *dev, int err, void *user_data)
12979 {
12980         struct service_auth *auth = user_data;
12981         struct btd_adapter *adapter = auth->adapter;
12982
12983         auth->svc_id = 0;
12984
12985         if (adapter->auth_idle_id != 0)
12986                 return;
12987
12988         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12989 }
12990
12991 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
12992                                         const char *uuid,
12993                                         adapter_authorize_type check_for_connection,
12994                                         service_auth_cb cb, void *user_data)
12995 {
12996         struct service_auth *auth;
12997         struct btd_device *device;
12998         static guint id = 0;
12999
13000 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13001         if (!strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
13002                 device = btd_adapter_find_device(adapter, dst, BDADDR_LE_PUBLIC);
13003         else
13004                 device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
13005 #else
13006         device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
13007 #endif
13008
13009         if (!device)
13010                 return 0;
13011
13012         if (device_is_disconnecting(device)) {
13013                 DBG("Authorization request while disconnecting");
13014                 return 0;
13015         }
13016
13017         /* Device connected? */
13018         if (check_for_connection && !g_slist_find(adapter->connections, device))
13019                 btd_error(adapter->dev_id,
13020                         "Authorization request for non-connected device!?");
13021
13022         auth = g_try_new0(struct service_auth, 1);
13023         if (!auth)
13024                 return 0;
13025
13026         auth->cb = cb;
13027         auth->user_data = user_data;
13028         auth->uuid = uuid;
13029         auth->device = device;
13030         auth->adapter = adapter;
13031         auth->id = ++id;
13032 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13033         if (check_for_connection &&
13034                 strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
13035 #else
13036         if (check_for_connection)
13037 #endif
13038                 auth->svc_id = device_wait_for_svc_complete(device, svc_complete, auth);
13039         else {
13040                 if (adapter->auth_idle_id == 0)
13041                         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
13042         }
13043
13044         g_queue_push_tail(adapter->auths, auth);
13045
13046         return auth->id;
13047 }
13048
13049 guint btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
13050                                         const char *uuid, service_auth_cb cb,
13051                                         void *user_data)
13052 {
13053         struct btd_adapter *adapter;
13054         GSList *l;
13055
13056         if (bacmp(src, BDADDR_ANY) != 0) {
13057                 adapter = adapter_find(src);
13058                 if (!adapter)
13059                         return 0;
13060
13061                 return adapter_authorize(adapter, dst, uuid,
13062                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
13063         }
13064
13065         for (l = adapters; l != NULL; l = g_slist_next(l)) {
13066                 guint id;
13067
13068                 adapter = l->data;
13069
13070                 id = adapter_authorize(adapter, dst, uuid,
13071                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
13072                 if (id != 0)
13073                         return id;
13074         }
13075
13076         return 0;
13077 }
13078
13079 guint btd_request_authorization_cable_configured(const bdaddr_t *src, const bdaddr_t *dst,
13080                                                 const char *uuid, service_auth_cb cb,
13081                                                 void *user_data)
13082 {
13083         struct btd_adapter *adapter;
13084
13085         if (bacmp(src, BDADDR_ANY) == 0)
13086                 return 0;
13087
13088         adapter = adapter_find(src);
13089         if (!adapter)
13090                 return 0;
13091
13092         return adapter_authorize(adapter, dst, uuid,
13093                         ADAPTER_AUTHORIZE_DISCONNECTED, cb, user_data);
13094 }
13095
13096 static struct service_auth *find_authorization(guint id)
13097 {
13098         GSList *l;
13099         GList *l2;
13100
13101         for (l = adapters; l != NULL; l = g_slist_next(l)) {
13102                 struct btd_adapter *adapter = l->data;
13103
13104                 for (l2 = adapter->auths->head; l2 != NULL; l2 = l2->next) {
13105                         struct service_auth *auth = l2->data;
13106
13107                         if (auth->id == id)
13108                                 return auth;
13109                 }
13110         }
13111
13112         return NULL;
13113 }
13114
13115 int btd_cancel_authorization(guint id)
13116 {
13117         struct service_auth *auth;
13118
13119         auth = find_authorization(id);
13120         if (auth == NULL)
13121                 return -EPERM;
13122
13123         if (auth->svc_id > 0)
13124                 device_remove_svc_complete_callback(auth->device,
13125                                                                 auth->svc_id);
13126
13127         g_queue_remove(auth->adapter->auths, auth);
13128
13129         if (auth->agent) {
13130                 agent_cancel(auth->agent);
13131                 agent_unref(auth->agent);
13132         }
13133
13134         g_free(auth);
13135
13136         return 0;
13137 }
13138
13139 int btd_adapter_restore_powered(struct btd_adapter *adapter)
13140 {
13141         bool powered;
13142
13143         powered = btd_adapter_get_powered(adapter);
13144         if (adapter->power_state == ADAPTER_POWER_STATE_OFF_BLOCKED &&
13145             rfkill_get_blocked(adapter->dev_id) == 0) {
13146                 adapter_set_power_state(adapter,
13147                                         powered ?
13148                                         ADAPTER_POWER_STATE_ON :
13149                                         ADAPTER_POWER_STATE_OFF);
13150         }
13151
13152         if (powered)
13153                 return 0;
13154
13155         set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
13156
13157         return 0;
13158 }
13159
13160 int btd_adapter_set_blocked(struct btd_adapter *adapter)
13161 {
13162         adapter_set_power_state(adapter, ADAPTER_POWER_STATE_OFF_BLOCKED);
13163         return 0;
13164 }
13165
13166 void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
13167                                                         btd_adapter_pin_cb_t cb)
13168 {
13169         adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
13170 }
13171
13172 void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
13173                                                         btd_adapter_pin_cb_t cb)
13174 {
13175         adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
13176 }
13177
13178 void btd_adapter_unregister_msd_cb(struct btd_adapter *adapter,
13179                                                         btd_msd_cb_t cb)
13180 {
13181         adapter->msd_callbacks = g_slist_remove(adapter->msd_callbacks, cb);
13182 }
13183
13184 void btd_adapter_register_msd_cb(struct btd_adapter *adapter,
13185                                                         btd_msd_cb_t cb)
13186 {
13187         adapter->msd_callbacks = g_slist_prepend(adapter->msd_callbacks, cb);
13188 }
13189
13190 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
13191                                                         gboolean enable)
13192 {
13193         if (!btd_adapter_get_powered(adapter))
13194                 return -EINVAL;
13195
13196         set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, enable ? 0x01 : 0x00);
13197
13198         return 0;
13199 }
13200
13201 int btd_adapter_read_clock(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13202                                 int which, int timeout, uint32_t *clock,
13203                                 uint16_t *accuracy)
13204 {
13205         if (!btd_adapter_get_powered(adapter))
13206                 return -EINVAL;
13207
13208         return -ENOSYS;
13209 }
13210
13211 int btd_adapter_remove_bonding(struct btd_adapter *adapter,
13212                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
13213 {
13214         struct mgmt_cp_unpair_device cp;
13215
13216         memset(&cp, 0, sizeof(cp));
13217         bacpy(&cp.addr.bdaddr, bdaddr);
13218         cp.addr.type = bdaddr_type;
13219         cp.disconnect = 1;
13220
13221         if (mgmt_send(adapter->mgmt, MGMT_OP_UNPAIR_DEVICE,
13222                                 adapter->dev_id, sizeof(cp), &cp,
13223                                 NULL, NULL, NULL) > 0)
13224                 return 0;
13225
13226         return -EIO;
13227 }
13228
13229 static void pincode_reply_complete(uint8_t status, uint16_t length,
13230                                         const void *param, void *user_data)
13231 {
13232         struct btd_device *device = user_data;
13233
13234         /* If the MGMT_OP_PIN_CODE_REPLY command is acknowledged, move the
13235          * starting time to that point. This give a better sense of time
13236          * evaluating the pincode. */
13237         device_bonding_restart_timer(device);
13238 }
13239
13240 int btd_adapter_pincode_reply(struct btd_adapter *adapter,
13241                                         const bdaddr_t *bdaddr,
13242                                         const char *pin, size_t pin_len)
13243 {
13244         struct btd_device *device;
13245         unsigned int id;
13246         char addr[18];
13247
13248         ba2str(bdaddr, addr);
13249         DBG("hci%u addr %s pinlen %zu", adapter->dev_id, addr, pin_len);
13250
13251         if (pin == NULL) {
13252                 struct mgmt_cp_pin_code_neg_reply cp;
13253
13254                 memset(&cp, 0, sizeof(cp));
13255                 bacpy(&cp.addr.bdaddr, bdaddr);
13256                 cp.addr.type = BDADDR_BREDR;
13257
13258                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
13259                                         adapter->dev_id, sizeof(cp), &cp,
13260                                         NULL, NULL, NULL);
13261         } else {
13262                 struct mgmt_cp_pin_code_reply cp;
13263
13264                 if (pin_len > 16)
13265                         return -EINVAL;
13266
13267                 memset(&cp, 0, sizeof(cp));
13268                 bacpy(&cp.addr.bdaddr, bdaddr);
13269                 cp.addr.type = BDADDR_BREDR;
13270                 cp.pin_len = pin_len;
13271                 memcpy(cp.pin_code, pin, pin_len);
13272
13273                 /* Since a pincode was requested, update the starting time to
13274                  * the point where the pincode is provided. */
13275                 device = btd_adapter_find_device(adapter, bdaddr, BDADDR_BREDR);
13276                 device_bonding_restart_timer(device);
13277
13278                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_REPLY,
13279                                         adapter->dev_id, sizeof(cp), &cp,
13280                                         pincode_reply_complete, device, NULL);
13281         }
13282
13283         if (id == 0)
13284                 return -EIO;
13285
13286         return 0;
13287 }
13288
13289 int btd_adapter_confirm_reply(struct btd_adapter *adapter,
13290                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13291                                 gboolean success)
13292 {
13293         struct mgmt_cp_user_confirm_reply cp;
13294         uint16_t opcode;
13295         char addr[18];
13296
13297         ba2str(bdaddr, addr);
13298         DBG("hci%u addr %s success %d", adapter->dev_id, addr, success);
13299
13300         if (success)
13301                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
13302         else
13303                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
13304
13305         memset(&cp, 0, sizeof(cp));
13306         bacpy(&cp.addr.bdaddr, bdaddr);
13307         cp.addr.type = bdaddr_type;
13308
13309         if (mgmt_reply(adapter->mgmt, opcode, adapter->dev_id, sizeof(cp), &cp,
13310                                                         NULL, NULL, NULL) > 0)
13311                 return 0;
13312
13313         return -EIO;
13314 }
13315
13316 static void user_confirm_request_callback(uint16_t index, uint16_t length,
13317                                         const void *param, void *user_data)
13318 {
13319         const struct mgmt_ev_user_confirm_request *ev = param;
13320         struct btd_adapter *adapter = user_data;
13321         struct btd_device *device;
13322         char addr[18];
13323         int err;
13324
13325         if (length < sizeof(*ev)) {
13326                 btd_error(adapter->dev_id,
13327                                 "Too small user confirm request event");
13328                 return;
13329         }
13330
13331         ba2str(&ev->addr.bdaddr, addr);
13332         DBG("hci%u %s confirm_hint %u", adapter->dev_id, addr,
13333                                                         ev->confirm_hint);
13334         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13335                                                                 ev->addr.type);
13336         if (!device) {
13337                 btd_error(adapter->dev_id,
13338                                 "Unable to get device object for %s", addr);
13339                 return;
13340         }
13341
13342 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13343         device_set_auth_addr_type(device, ev->addr.type);
13344 #endif
13345         err = device_confirm_passkey(device, ev->addr.type, btohl(ev->value),
13346                                                         ev->confirm_hint);
13347         if (err < 0) {
13348                 btd_error(adapter->dev_id,
13349                                 "device_confirm_passkey: %s", strerror(-err));
13350                 btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
13351                                                         ev->addr.type, FALSE);
13352         }
13353 }
13354
13355 int btd_adapter_passkey_reply(struct btd_adapter *adapter,
13356                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13357                                 uint32_t passkey)
13358 {
13359         unsigned int id;
13360         char addr[18];
13361
13362         ba2str(bdaddr, addr);
13363         DBG("hci%u addr %s passkey %06u", adapter->dev_id, addr, passkey);
13364
13365         if (passkey == INVALID_PASSKEY) {
13366                 struct mgmt_cp_user_passkey_neg_reply cp;
13367
13368                 memset(&cp, 0, sizeof(cp));
13369                 bacpy(&cp.addr.bdaddr, bdaddr);
13370                 cp.addr.type = bdaddr_type;
13371
13372                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
13373                                         adapter->dev_id, sizeof(cp), &cp,
13374                                         NULL, NULL, NULL);
13375         } else {
13376                 struct mgmt_cp_user_passkey_reply cp;
13377
13378                 memset(&cp, 0, sizeof(cp));
13379                 bacpy(&cp.addr.bdaddr, bdaddr);
13380                 cp.addr.type = bdaddr_type;
13381                 cp.passkey = htobl(passkey);
13382
13383                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_REPLY,
13384                                         adapter->dev_id, sizeof(cp), &cp,
13385                                         NULL, NULL, NULL);
13386         }
13387
13388         if (id == 0)
13389                 return -EIO;
13390
13391         return 0;
13392 }
13393
13394 static void user_passkey_request_callback(uint16_t index, uint16_t length,
13395                                         const void *param, void *user_data)
13396 {
13397         const struct mgmt_ev_user_passkey_request *ev = param;
13398         struct btd_adapter *adapter = user_data;
13399         struct btd_device *device;
13400         char addr[18];
13401         int err;
13402
13403         if (length < sizeof(*ev)) {
13404                 btd_error(adapter->dev_id, "Too small passkey request event");
13405                 return;
13406         }
13407
13408         ba2str(&ev->addr.bdaddr, addr);
13409         DBG("hci%u %s", index, addr);
13410
13411         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13412                                                                 ev->addr.type);
13413         if (!device) {
13414                 btd_error(adapter->dev_id,
13415                                 "Unable to get device object for %s", addr);
13416                 return;
13417         }
13418
13419 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13420         device_set_auth_addr_type(device, ev->addr.type);
13421 #endif
13422         err = device_request_passkey(device, ev->addr.type);
13423         if (err < 0) {
13424                 btd_error(adapter->dev_id,
13425                                 "device_request_passkey: %s", strerror(-err));
13426                 btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
13427                                         ev->addr.type, INVALID_PASSKEY);
13428         }
13429 }
13430
13431 static void user_passkey_notify_callback(uint16_t index, uint16_t length,
13432                                         const void *param, void *user_data)
13433 {
13434         const struct mgmt_ev_passkey_notify *ev = param;
13435         struct btd_adapter *adapter = user_data;
13436         struct btd_device *device;
13437         uint32_t passkey;
13438         char addr[18];
13439         int err;
13440
13441         if (length < sizeof(*ev)) {
13442                 btd_error(adapter->dev_id, "Too small passkey notify event");
13443                 return;
13444         }
13445
13446         ba2str(&ev->addr.bdaddr, addr);
13447         DBG("hci%u %s", index, addr);
13448
13449         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13450                                                                 ev->addr.type);
13451         if (!device) {
13452                 btd_error(adapter->dev_id,
13453                                 "Unable to get device object for %s", addr);
13454                 return;
13455         }
13456
13457         passkey = get_le32(&ev->passkey);
13458
13459         DBG("passkey %06u entered %u", passkey, ev->entered);
13460
13461         err = device_notify_passkey(device, ev->addr.type, passkey,
13462                                                                 ev->entered);
13463         if (err < 0)
13464                 btd_error(adapter->dev_id,
13465                                 "device_notify_passkey: %s", strerror(-err));
13466 }
13467
13468 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13469 static void rssi_alert_callback(uint16_t index, uint16_t length,
13470                                         const void *param, void *user_data)
13471 {
13472         const struct mgmt_ev_vendor_specific_rssi_alert *ev = param;
13473         struct btd_adapter *adapter = user_data;
13474         char addr[18];
13475         char *bt_addr =  NULL;
13476         int link_type = -1;
13477         int alert_type = -1;
13478         int rssi_dbm = 0;
13479
13480         if (length < sizeof(*ev)) {
13481                 error("Too small rssi alert event");
13482                 return;
13483         }
13484
13485         ba2str(&ev->bdaddr, addr);
13486         DBG("hci%u %s %d", index, addr, ev->link_type);
13487         DBG("RSSI Alert Params [%d %d]", ev->alert_type, ev->rssi_dbm);
13488
13489         bt_addr = (char *)&addr;
13490         link_type = ev->link_type;
13491         alert_type = ev->alert_type;
13492         rssi_dbm = ev->rssi_dbm;
13493         g_dbus_emit_signal(dbus_conn, adapter->path,
13494                         ADAPTER_INTERFACE, "RssiAlert",
13495                         DBUS_TYPE_STRING, &bt_addr,
13496                         DBUS_TYPE_INT32, &link_type,
13497                         DBUS_TYPE_INT32, &alert_type,
13498                         DBUS_TYPE_INT32, &rssi_dbm,
13499                         DBUS_TYPE_INVALID);
13500 }
13501
13502 static void get_raw_rssi_callback(uint16_t index, uint16_t length,
13503                                         const void *param, void *user_data)
13504 {
13505         const struct mgmt_cc_rp_get_raw_rssi *ev = param;
13506         struct btd_adapter *adapter = user_data;
13507         char addr[18];
13508         char *bt_addr =  NULL;
13509         int link_type = -1;
13510         int rssi_dbm = 0;
13511
13512         if (length < sizeof(*ev)) {
13513                 error("Too small raw RSSI event");
13514                 return;
13515         }
13516
13517         ba2str(&ev->bt_address, addr);
13518         DBG("hci%u %s", index, addr);
13519         DBG("Raw RSSI Params [%d %d]", ev->link_type, ev->rssi_dbm);
13520
13521         bt_addr = (char *)&addr;
13522         link_type = ev->link_type;
13523         rssi_dbm = ev->rssi_dbm;
13524
13525         g_dbus_emit_signal(dbus_conn, adapter->path,
13526                         ADAPTER_INTERFACE, "RawRssi",
13527                         DBUS_TYPE_STRING, &bt_addr,
13528                         DBUS_TYPE_INT32, &link_type,
13529                         DBUS_TYPE_INT32, &rssi_dbm,
13530                         DBUS_TYPE_INVALID);
13531 }
13532
13533 static void rssi_enabled_callback(uint16_t index, uint16_t length,
13534                                         const void *param, void *user_data)
13535 {
13536         const struct mgmt_cc_rsp_enable_rssi *ev = param;
13537         struct btd_adapter *adapter = user_data;
13538         char addr[18];
13539         char *bt_addr =  NULL;
13540         int enabled = TRUE;
13541         int link_type = -1;
13542
13543         if (length < sizeof(*ev)) {
13544                 error("Too small rssi enabled event");
13545                 return;
13546         }
13547
13548         ba2str(&ev->bt_address, addr);
13549         DBG("hci%u %s %d", index, addr, ev->link_type);
13550         DBG("RSSI Enabled [%d %d]", ev->le_ext_opcode, ev->status);
13551
13552         bt_addr = (char *)&addr;
13553         link_type = ev->link_type;
13554
13555         g_dbus_emit_signal(dbus_conn, adapter->path,
13556                         ADAPTER_INTERFACE, "RssiEnabled",
13557                         DBUS_TYPE_STRING, &bt_addr,
13558                         DBUS_TYPE_INT32, &link_type,
13559                         DBUS_TYPE_BOOLEAN, &enabled,
13560                         DBUS_TYPE_INVALID);
13561 }
13562
13563 static void rssi_disabled_callback(uint16_t index, uint16_t length,
13564                                         const void *param, void *user_data)
13565 {
13566         const struct mgmt_cc_rp_disable_rssi *ev = param;
13567         struct btd_adapter *adapter = user_data;
13568         char addr[18];
13569         char *bt_addr =  NULL;
13570         int disabled = FALSE;
13571         int link_type = -1;
13572
13573         if (length < sizeof(*ev)) {
13574                 error("Too small RSSI disabled event");
13575                 return;
13576         }
13577
13578         ba2str(&ev->bt_address, addr);
13579         DBG("hci%u %s %d", index, addr, ev->link_type);
13580         DBG("RSSI Disabled Params [%d %d]", ev->le_ext_opcode, ev->status);
13581
13582         bt_addr = (char *)&addr;
13583         link_type = ev->link_type;
13584
13585         g_dbus_emit_signal(dbus_conn, adapter->path,
13586                         ADAPTER_INTERFACE, "RssiEnabled",
13587                         DBUS_TYPE_STRING, &bt_addr,
13588                         DBUS_TYPE_INT32, &link_type,
13589                         DBUS_TYPE_BOOLEAN, &disabled,
13590                         DBUS_TYPE_INVALID);
13591 }
13592
13593 void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver)
13594 {
13595         char *ver;
13596
13597         switch (hci_ver) {
13598         case 0:
13599                 ver = "Bluetooth 1.0b";
13600                 break;
13601         case 1:
13602                 ver = "Bluetooth 1.1";
13603                 break;
13604         case 2:
13605                 ver = "Bluetooth 1.2";
13606                 break;
13607         case 3:
13608                 ver = "Bluetooth 2.0 + EDR";
13609                 break;
13610         case 4:
13611                 ver = "Bluetooth 2.1 + EDR";
13612                 break;
13613         case 5:
13614                 ver = "Bluetooth 3.0 + HS";
13615                 break;
13616         case 6:
13617                 ver = "Bluetooth 4.0";
13618                 break;
13619         case 7:
13620                 ver = "Bluetooth 4.1";
13621                 break;
13622         default:
13623                 ver = "Unknown";
13624                 break;
13625         }
13626
13627         if (adapter->version)
13628                 g_free(adapter->version);
13629
13630         adapter->version = g_strdup(ver);
13631 }
13632
13633 static void hardware_error_callback(uint16_t index, uint16_t length,
13634                 const void *param, void *user_data)
13635 {
13636         const struct mgmt_ev_hardware_error *ev = param;
13637         struct btd_adapter *adapter = user_data;
13638
13639         if (length < sizeof(*ev)) {
13640                 error("Too small Hardware error event");
13641                 return;
13642         }
13643
13644         error("Hardware error occurred : %d", ev->error_code);
13645         g_dbus_emit_signal(dbus_conn, adapter->path,
13646                         ADAPTER_INTERFACE, "HardwareError",
13647                         DBUS_TYPE_INVALID);
13648 }
13649
13650 static void tx_timeout_error_callback(uint16_t index, uint16_t length,
13651                 const void *param, void *user_data)
13652 {
13653         struct btd_adapter *adapter = user_data;
13654
13655         error("Tx Timeout error occurred");
13656         g_dbus_emit_signal(dbus_conn, adapter->path,
13657                         ADAPTER_INTERFACE, "TxTimeoutError",
13658                         DBUS_TYPE_INVALID);
13659 }
13660
13661 static void device_name_update_callback(uint16_t index, uint16_t length,
13662                 const void *param, void *user_data)
13663 {
13664         const struct mgmt_ev_device_name_update *ev = param;
13665         struct btd_adapter *adapter = user_data;
13666         struct btd_device *device;
13667         char addr[18];
13668         const uint8_t *eir_name;
13669         struct eir_data eir_data;
13670
13671         if (length < sizeof(*ev)) {
13672                 error("Name update error event");
13673                 return;
13674         }
13675
13676         ba2str(&ev->addr.bdaddr, addr);
13677         DBG("hci%u %s", index, addr);
13678
13679         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13680                                                                 ev->addr.type);
13681         if (!device) {
13682                 error("Unable to get device object for %s", addr);
13683                 return;
13684         }
13685
13686         if (ev->eir_len == 0)
13687                 return;
13688
13689         eir_name = ev->eir;
13690
13691         memset(&eir_data, 0, sizeof(eir_data));
13692         eir_parse(&eir_data, eir_name, ev->eir_len);
13693
13694         if (eir_data.name)
13695                 btd_device_device_set_name(device, eir_data.name);
13696
13697         eir_data_free(&eir_data);
13698 }
13699
13700 struct multi_adv_data {
13701         struct btd_adapter *adapter;
13702         uint8_t slot_id;
13703 };
13704
13705 static gboolean multi_adv_start_timeout_cb(gpointer user_data)
13706 {
13707         struct multi_adv_data *data = user_data;
13708         struct btd_adapter *adapter = data->adapter;
13709         dbus_bool_t err;
13710
13711         adapter->adv_restart_timeout = 0;
13712
13713         err = adapter_le_enable_multi_adv(adapter, TRUE, data->slot_id);
13714         if (!err)
13715                 advertising_state_changed(adapter, data->slot_id, FALSE);
13716
13717         g_free(data);
13718         return FALSE;
13719 }
13720
13721 static void multi_adv_state_change_callback(uint16_t index, uint16_t length,
13722                                         const void *param, void *user_data)
13723 {
13724         const struct mgmt_ev_vendor_specific_multi_adv_state_changed *ev = param;
13725         struct btd_adapter *adapter = user_data;
13726         struct multi_adv_data *data;
13727
13728         if (length < sizeof(*ev)) {
13729                 error("Too small adv state change event");
13730                 return;
13731         }
13732
13733         DBG("adv id %d, state change reason %d, connection_handle %x",
13734                 ev->adv_instance, ev->state_change_reason, ev->connection_handle);
13735
13736         if ((ev->adv_instance > 0 && ev->adv_instance < adapter_le_get_max_adv_instance()) &&
13737                         ev->state_change_reason == 0) {
13738                 /* advertising is stopped by controller, it should be enabled again.
13739                 * If fails, state should be changed to FALSE */
13740                 data = g_new0(struct multi_adv_data, 1);
13741                 data->adapter = adapter;
13742                 data->slot_id = ev->adv_instance;
13743
13744                 adapter->adv_restart_timeout =
13745                         g_timeout_add(300, multi_adv_start_timeout_cb, data);
13746         }
13747 }
13748
13749 static void le_conn_update_completed_callback(uint16_t index, uint16_t length,
13750                                         const void *param, void *user_data)
13751 {
13752         const struct mgmt_ev_conn_updated *ev = param;
13753         struct btd_adapter *adapter = user_data;
13754         struct btd_device *device;
13755         char addr[18];
13756         GSList *list = NULL;
13757
13758         if (length < sizeof(*ev)) {
13759                 error("Too small le conn update completed event");
13760                 return;
13761         }
13762
13763         ba2str(&ev->addr.bdaddr, addr);
13764         if (ev->addr.type == BDADDR_LE_PUBLIC) {
13765                 /* Private Random Address */
13766                 list = g_slist_find_custom(adapter->devices, addr,
13767                                                 device_rpa_ida_cmp);
13768                 /* LE Public */
13769                 if (!list)
13770                         list = g_slist_find_custom(adapter->devices, addr,
13771                                                         device_address_cmp);
13772         } else if (ev->addr.type == BDADDR_LE_RANDOM) {
13773                 /* LE Static Random address */
13774                 list = g_slist_find_custom(adapter->devices, addr,
13775                                                         device_address_cmp);
13776         }
13777
13778         if (list) {
13779                 device = list->data;
13780                 device_print_addr(device);
13781
13782                 if (device_get_conn_update_state(device))
13783                         device_set_conn_update_state(device, false);
13784         }
13785 }
13786
13787 static void bt_6lowpan_conn_state_change_callback(uint16_t index, uint16_t length,
13788                                         const void *param, void *user_data)
13789 {
13790         const struct mgmt_ev_6lowpan_conn_state_changed *ev = param;
13791         struct btd_adapter *adapter = user_data;
13792         struct btd_device *device;
13793         char addr[18];
13794         gboolean connected = 0;
13795
13796         if (length < sizeof(*ev)) {
13797                 btd_error(adapter->dev_id,
13798                         "Too small device connected event");
13799                 return;
13800         }
13801
13802         ba2str(&ev->addr.bdaddr, addr);
13803
13804         DBG("hci%u device %s", index, addr);
13805
13806         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13807                                                                 ev->addr.type);
13808         if (!device) {
13809                 btd_error(adapter->dev_id,
13810                         "Unable to get device object for %s", addr);
13811                 return;
13812         }
13813
13814         if (ev->connected)
13815                 connected = TRUE;
13816         else
13817                 connected = FALSE;
13818
13819         device_set_ipsp_connected(device, connected, ev->ifname);
13820 }
13821
13822 static void bt_le_data_length_changed_callback(uint16_t index, uint16_t length,
13823                                         const void *param, void *user_data)
13824 {
13825         const struct mgmt_ev_le_data_length_changed *ev = param;
13826         struct btd_adapter *adapter = user_data;
13827         struct btd_device *device;
13828         char addr[18];
13829
13830         if (length < sizeof(*ev)) {
13831                 btd_error(adapter->dev_id,
13832                         "Too small data length changed event");
13833                 return;
13834         }
13835
13836         ba2str(&ev->addr.bdaddr, addr);
13837
13838         DBG("hci%u device %s", index, addr);
13839
13840         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13841                                                                 ev->addr.type);
13842         if (!device) {
13843                 btd_error(adapter->dev_id,
13844                         "Unable to get device object for %s", addr);
13845                 return;
13846         }
13847
13848         device_le_data_length_changed(device, ev->max_tx_octets, ev->max_tx_time,
13849                 ev->max_rx_octets, ev->max_rx_time);
13850 }
13851
13852 #endif
13853
13854 struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
13855                                                 struct btd_adapter *adapter)
13856 {
13857         struct btd_adapter_pin_cb_iter *iter =
13858                                 g_new0(struct btd_adapter_pin_cb_iter, 1);
13859
13860         iter->it = adapter->pin_callbacks;
13861         iter->attempt = 1;
13862
13863         return iter;
13864 }
13865
13866 void btd_adapter_pin_cb_iter_free(struct btd_adapter_pin_cb_iter *iter)
13867 {
13868         g_free(iter);
13869 }
13870
13871 bool btd_adapter_pin_cb_iter_end(struct btd_adapter_pin_cb_iter *iter)
13872 {
13873         return iter->it == NULL && iter->attempt == 0;
13874 }
13875
13876 static ssize_t btd_adapter_pin_cb_iter_next(
13877                                         struct btd_adapter_pin_cb_iter *iter,
13878                                         struct btd_adapter *adapter,
13879                                         struct btd_device *device,
13880                                         char *pin_buf, bool *display)
13881 {
13882         btd_adapter_pin_cb_t cb;
13883         ssize_t ret;
13884
13885         while (iter->it != NULL) {
13886                 cb = iter->it->data;
13887                 ret = cb(adapter, device, pin_buf, display, iter->attempt);
13888                 iter->attempt++;
13889                 if (ret > 0)
13890                         return ret;
13891                 iter->attempt = 1;
13892                 iter->it = g_slist_next(iter->it);
13893         }
13894         iter->attempt = 0;
13895
13896         return 0;
13897 }
13898
13899 static void pin_code_request_callback(uint16_t index, uint16_t length,
13900                                         const void *param, void *user_data)
13901 {
13902         const struct mgmt_ev_pin_code_request *ev = param;
13903         struct btd_adapter *adapter = user_data;
13904         struct btd_device *device;
13905         bool display = false;
13906         char pin[17];
13907         ssize_t pinlen;
13908         char addr[18];
13909         int err;
13910         struct btd_adapter_pin_cb_iter *iter;
13911
13912         if (length < sizeof(*ev)) {
13913                 btd_error(adapter->dev_id, "Too small PIN code request event");
13914                 return;
13915         }
13916
13917         ba2str(&ev->addr.bdaddr, addr);
13918
13919         DBG("hci%u %s", adapter->dev_id, addr);
13920
13921         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13922                                                                 ev->addr.type);
13923         if (!device) {
13924                 btd_error(adapter->dev_id,
13925                                 "Unable to get device object for %s", addr);
13926                 return;
13927         }
13928
13929         /* Flag the request of a pincode to allow a bonding retry. */
13930         adapter->pincode_requested = true;
13931 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13932         btd_device_set_legacy_pairing(device, true);
13933 #endif
13934
13935         memset(pin, 0, sizeof(pin));
13936
13937         iter = device_bonding_iter(device);
13938         if (iter == NULL)
13939                 pinlen = 0;
13940         else
13941                 pinlen = btd_adapter_pin_cb_iter_next(iter, adapter, device,
13942                                                                 pin, &display);
13943
13944         if (pinlen > 0 && (!ev->secure || pinlen == 16)) {
13945                 if (display && device_is_bonding(device, NULL)) {
13946                         err = device_notify_pincode(device, ev->secure, pin);
13947                         if (err < 0) {
13948                                 btd_error(adapter->dev_id,
13949                                                 "device_notify_pin: %s",
13950                                                         strerror(-err));
13951                                 btd_adapter_pincode_reply(adapter,
13952                                                         &ev->addr.bdaddr,
13953                                                         NULL, 0);
13954                         }
13955                 } else {
13956                         btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
13957                                                                 pin, pinlen);
13958                 }
13959                 return;
13960         }
13961
13962 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13963         if (btd_opts.pin_code) {
13964                 /* Because we can't receive user input on headless device,
13965                    no need to request pincode. Use the 'PinCode' in headless conf file */
13966                 DBG("Use configured PinCode in headless device");
13967                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
13968                                 btd_opts.pin_code, strlen(btd_opts.pin_code));
13969                 return;
13970         }
13971 #endif
13972
13973         err = device_request_pincode(device, ev->secure);
13974         if (err < 0) {
13975                 btd_error(adapter->dev_id, "device_request_pin: %s",
13976                                                         strerror(-err));
13977                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
13978         }
13979 }
13980
13981 int adapter_cancel_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13982                                                         uint8_t addr_type)
13983 {
13984         struct mgmt_addr_info cp;
13985         char addr[18];
13986
13987         ba2str(bdaddr, addr);
13988         DBG("hci%u bdaddr %s type %u", adapter->dev_id, addr, addr_type);
13989
13990         memset(&cp, 0, sizeof(cp));
13991         bacpy(&cp.bdaddr, bdaddr);
13992         cp.type = addr_type;
13993
13994         if (mgmt_reply(adapter->mgmt, MGMT_OP_CANCEL_PAIR_DEVICE,
13995                                 adapter->dev_id, sizeof(cp), &cp,
13996                                 NULL, NULL, NULL) > 0)
13997                 return 0;
13998
13999         return -EIO;
14000 }
14001
14002 static void check_oob_bonding_complete(struct btd_adapter *adapter,
14003                                         const bdaddr_t *bdaddr, uint8_t status)
14004 {
14005         if (!adapter->oob_handler || !adapter->oob_handler->bonding_cb)
14006                 return;
14007
14008         if (bacmp(bdaddr, &adapter->oob_handler->remote_addr) != 0)
14009                 return;
14010
14011         adapter->oob_handler->bonding_cb(adapter, bdaddr, status,
14012                                         adapter->oob_handler->user_data);
14013
14014         g_free(adapter->oob_handler);
14015         adapter->oob_handler = NULL;
14016 }
14017
14018 static void bonding_complete(struct btd_adapter *adapter,
14019                                         const bdaddr_t *bdaddr,
14020                                         uint8_t addr_type, uint8_t status)
14021 {
14022         struct btd_device *device;
14023
14024         if (status == 0)
14025                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
14026         else
14027                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
14028
14029         if (device != NULL)
14030                 device_bonding_complete(device, addr_type, status);
14031
14032 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14033         resume_discovery(adapter);
14034 #endif
14035         check_oob_bonding_complete(adapter, bdaddr, status);
14036 }
14037
14038 /* bonding_attempt_complete() handles the end of a "bonding attempt" checking if
14039  * it should begin a new attempt or complete the bonding.
14040  */
14041 static void bonding_attempt_complete(struct btd_adapter *adapter,
14042                                         const bdaddr_t *bdaddr,
14043                                         uint8_t addr_type, uint8_t status)
14044 {
14045         struct btd_device *device;
14046         char addr[18];
14047
14048         ba2str(bdaddr, addr);
14049         DBG("hci%u bdaddr %s type %u status 0x%x", adapter->dev_id, addr,
14050                                                         addr_type, status);
14051
14052         if (status == 0)
14053                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
14054         else
14055                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
14056
14057         if (status == MGMT_STATUS_AUTH_FAILED && adapter->pincode_requested) {
14058                 /* On faliure, issue a bonding_retry if possible. */
14059                 if (device != NULL) {
14060                         if (device_bonding_attempt_retry(device) == 0)
14061                                 return;
14062                 }
14063         }
14064
14065         /* Ignore disconnects during retry. */
14066         if (status == MGMT_STATUS_DISCONNECTED &&
14067                                         device && device_is_retrying(device))
14068                 return;
14069
14070         /* In any other case, finish the bonding. */
14071         bonding_complete(adapter, bdaddr, addr_type, status);
14072 }
14073
14074 struct pair_device_data {
14075         struct btd_adapter *adapter;
14076         bdaddr_t bdaddr;
14077         uint8_t addr_type;
14078 };
14079
14080 static void free_pair_device_data(void *user_data)
14081 {
14082         struct pair_device_data *data = user_data;
14083
14084         g_free(data);
14085 }
14086
14087 static void pair_device_complete(uint8_t status, uint16_t length,
14088                                         const void *param, void *user_data)
14089 {
14090         const struct mgmt_rp_pair_device *rp = param;
14091         struct pair_device_data *data = user_data;
14092         struct btd_adapter *adapter = data->adapter;
14093
14094         DBG("%s (0x%02x)", mgmt_errstr(status), status);
14095
14096         /* Workaround for a kernel bug
14097          *
14098          * Broken kernels may reply to device pairing command with command
14099          * status instead of command complete event e.g. if adapter was not
14100          * powered.
14101          */
14102         if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
14103                 btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
14104                                                 mgmt_errstr(status), status);
14105
14106                 bonding_attempt_complete(adapter, &data->bdaddr,
14107                                                 data->addr_type, status);
14108                 return;
14109         }
14110
14111         if (length < sizeof(*rp)) {
14112                 btd_error(adapter->dev_id, "Too small pair device response");
14113                 return;
14114         }
14115
14116         bonding_attempt_complete(adapter, &rp->addr.bdaddr, rp->addr.type,
14117                                                                         status);
14118 }
14119
14120 int adapter_create_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14121                                         uint8_t addr_type, uint8_t io_cap)
14122 {
14123 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14124         suspend_discovery(adapter);
14125 #endif
14126         return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
14127 }
14128
14129 /* Starts a new bonding attempt in a fresh new bonding_req or a retried one. */
14130 int adapter_bonding_attempt(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14131                                         uint8_t addr_type, uint8_t io_cap)
14132 {
14133         struct mgmt_cp_pair_device cp;
14134         char addr[18];
14135         struct pair_device_data *data;
14136         unsigned int id;
14137
14138         ba2str(bdaddr, addr);
14139         DBG("hci%u bdaddr %s type %d io_cap 0x%02x",
14140                                 adapter->dev_id, addr, addr_type, io_cap);
14141
14142         /* Reset the pincode_requested flag for a new bonding attempt. */
14143         adapter->pincode_requested = false;
14144
14145         memset(&cp, 0, sizeof(cp));
14146         bacpy(&cp.addr.bdaddr, bdaddr);
14147         cp.addr.type = addr_type;
14148         cp.io_cap = io_cap;
14149
14150         data = g_new0(struct pair_device_data, 1);
14151         data->adapter = adapter;
14152         bacpy(&data->bdaddr, bdaddr);
14153         data->addr_type = addr_type;
14154
14155         /* Due to a bug in the kernel it is possible that a LE pairing
14156          * request never times out. Therefore, add a timer to clean up
14157          * if no response arrives
14158          */
14159         id = mgmt_send_timeout(adapter->mgmt, MGMT_OP_PAIR_DEVICE,
14160                                 adapter->dev_id, sizeof(cp), &cp,
14161                                 pair_device_complete, data,
14162                                 free_pair_device_data, BONDING_TIMEOUT);
14163         if (id == 0) {
14164                 btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
14165                                                         addr, adapter->dev_id);
14166                 free_pair_device_data(data);
14167                 return -EIO;
14168         }
14169
14170         return 0;
14171 }
14172
14173 static void disconnect_notify(struct btd_device *dev, uint8_t reason)
14174 {
14175         GSList *l;
14176
14177         for (l = disconnect_list; l; l = g_slist_next(l)) {
14178                 btd_disconnect_cb disconnect_cb = l->data;
14179                 disconnect_cb(dev, reason);
14180         }
14181 }
14182
14183 static void dev_disconnected(struct btd_adapter *adapter,
14184                                         const struct mgmt_addr_info *addr,
14185                                         uint8_t reason)
14186 {
14187         struct btd_device *device;
14188         char dst[18];
14189 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14190         struct device_addr_type t_addr;
14191 #endif
14192
14193         ba2str(&addr->bdaddr, dst);
14194
14195         DBG("Device %s disconnected, reason %u", dst, reason);
14196
14197         device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
14198
14199 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14200         if (device) {
14201                 device_get_tizen_addr(device, addr->type, &t_addr);
14202
14203                 device_set_disconnect_reason(device, reason);
14204                 adapter_remove_connection(adapter, device, t_addr.bdaddr_type);
14205                 disconnect_notify(device, reason);
14206                 if (device_is_bonded(device, t_addr.bdaddr_type)) {
14207                         DBG("addr type %d, bonded", t_addr.bdaddr_type);
14208                         return;
14209                 }
14210
14211                 bonding_attempt_complete(adapter, &t_addr.bdaddr,
14212                                 t_addr.bdaddr_type, MGMT_STATUS_DISCONNECTED);
14213                 return;
14214         }
14215 #else
14216         if (device) {
14217                 adapter_remove_connection(adapter, device, addr->type);
14218                 disconnect_notify(device, reason);
14219         }
14220 #endif
14221
14222         bonding_attempt_complete(adapter, &addr->bdaddr, addr->type,
14223                                                 MGMT_STATUS_DISCONNECTED);
14224 }
14225
14226 void btd_add_disconnect_cb(btd_disconnect_cb func)
14227 {
14228         disconnect_list = g_slist_append(disconnect_list, func);
14229 }
14230
14231 void btd_remove_disconnect_cb(btd_disconnect_cb func)
14232 {
14233         disconnect_list = g_slist_remove(disconnect_list, func);
14234 }
14235
14236 static void disconnect_complete(uint8_t status, uint16_t length,
14237                                         const void *param, void *user_data)
14238 {
14239         const struct mgmt_rp_disconnect *rp = param;
14240         struct btd_adapter *adapter = user_data;
14241
14242         if (status == MGMT_STATUS_NOT_CONNECTED) {
14243                 btd_warn(adapter->dev_id,
14244                                 "Disconnecting failed: already disconnected");
14245         } else if (status != MGMT_STATUS_SUCCESS) {
14246                 btd_error(adapter->dev_id,
14247                                 "Failed to disconnect device: %s (0x%02x)",
14248                                                 mgmt_errstr(status), status);
14249                 return;
14250         }
14251
14252         if (length < sizeof(*rp)) {
14253                 btd_error(adapter->dev_id,
14254                                 "Too small device disconnect response");
14255                 return;
14256         }
14257
14258 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14259         /* Use HCI error code instead of MGMT disconnection reason */
14260         dev_disconnected(adapter, &rp->addr, 0x16);
14261 #else
14262         dev_disconnected(adapter, &rp->addr, MGMT_DEV_DISCONN_LOCAL_HOST);
14263 #endif
14264 }
14265
14266 int btd_adapter_disconnect_device(struct btd_adapter *adapter,
14267                                                 const bdaddr_t *bdaddr,
14268                                                 uint8_t bdaddr_type)
14269
14270 {
14271         struct mgmt_cp_disconnect cp;
14272
14273         memset(&cp, 0, sizeof(cp));
14274         bacpy(&cp.addr.bdaddr, bdaddr);
14275         cp.addr.type = bdaddr_type;
14276
14277         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT,
14278                                 adapter->dev_id, sizeof(cp), &cp,
14279                                 disconnect_complete, adapter, NULL) > 0)
14280                 return 0;
14281
14282         return -EIO;
14283 }
14284
14285 static void auth_failed_callback(uint16_t index, uint16_t length,
14286                                         const void *param, void *user_data)
14287 {
14288         const struct mgmt_ev_auth_failed *ev = param;
14289         struct btd_adapter *adapter = user_data;
14290
14291         if (length < sizeof(*ev)) {
14292                 btd_error(adapter->dev_id, "Too small auth failed mgmt event");
14293                 return;
14294         }
14295
14296         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
14297                                                                 ev->status);
14298 }
14299
14300 static void store_link_key(struct btd_adapter *adapter,
14301                                 struct btd_device *device, const uint8_t *key,
14302                                 uint8_t type, uint8_t pin_length)
14303 {
14304         char device_addr[18];
14305         char filename[PATH_MAX];
14306         GKeyFile *key_file;
14307         GError *gerr = NULL;
14308         gsize length = 0;
14309         char key_str[33];
14310         char *str;
14311         int i;
14312
14313         ba2str(device_get_address(device), device_addr);
14314
14315         create_filename(filename, PATH_MAX, "/%s/%s/info",
14316                         btd_adapter_get_storage_dir(adapter), device_addr);
14317         create_file(filename, 0600);
14318
14319         key_file = g_key_file_new();
14320         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14321                 error("Unable to load key file from %s: (%s)", filename,
14322                                                                 gerr->message);
14323                 g_error_free(gerr);
14324                 g_key_file_free(key_file);
14325                 return;
14326         }
14327
14328         for (i = 0; i < 16; i++)
14329                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14330
14331         g_key_file_set_string(key_file, "LinkKey", "Key", key_str);
14332
14333         g_key_file_set_integer(key_file, "LinkKey", "Type", type);
14334         g_key_file_set_integer(key_file, "LinkKey", "PINLength", pin_length);
14335
14336         str = g_key_file_to_data(key_file, &length, NULL);
14337         if (!g_file_set_contents(filename, str, length, &gerr)) {
14338                 error("Unable set contents for %s: (%s)", filename,
14339                                                                 gerr->message);
14340                 g_error_free(gerr);
14341         }
14342         g_free(str);
14343
14344         g_key_file_free(key_file);
14345 }
14346
14347 static void new_link_key_callback(uint16_t index, uint16_t length,
14348                                         const void *param, void *user_data)
14349 {
14350         const struct mgmt_ev_new_link_key *ev = param;
14351         const struct mgmt_addr_info *addr = &ev->key.addr;
14352         struct btd_adapter *adapter = user_data;
14353         struct btd_device *device;
14354         char dst[18];
14355
14356         if (length < sizeof(*ev)) {
14357                 btd_error(adapter->dev_id, "Too small new link key event");
14358                 return;
14359         }
14360
14361         ba2str(&addr->bdaddr, dst);
14362
14363         DBG("hci%u new key for %s type %u pin_len %u store_hint %u",
14364                 adapter->dev_id, dst, ev->key.type, ev->key.pin_len,
14365                 ev->store_hint);
14366
14367         if (ev->key.pin_len > 16) {
14368                 btd_error(adapter->dev_id,
14369                                 "Invalid PIN length (%u) in new_key event",
14370                                                         ev->key.pin_len);
14371                 return;
14372         }
14373
14374         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14375         if (!device) {
14376                 btd_error(adapter->dev_id,
14377                                 "Unable to get device object for %s", dst);
14378                 return;
14379         }
14380
14381         if (ev->store_hint) {
14382                 const struct mgmt_link_key_info *key = &ev->key;
14383
14384                 store_link_key(adapter, device, key->val, key->type,
14385                                                                 key->pin_len);
14386
14387                 device_set_bonded(device, BDADDR_BREDR);
14388 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14389         } else {
14390                 if (btd_adapter_get_a2dp_role(adapter) & BLUETOOTH_A2DP_SINK_ROLE) {
14391                         DBG("store_hint %d", ev->store_hint);
14392                         btd_device_set_temporary(device, false);
14393                 }
14394 #endif
14395         }
14396
14397         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14398 }
14399
14400 static void store_ltk_group(struct btd_adapter *adapter, const bdaddr_t *peer,
14401                                 uint8_t bdaddr_type, const unsigned char *key,
14402                                 const char *group, uint8_t authenticated,
14403                                 uint8_t enc_size, uint16_t ediv,
14404                                 uint64_t rand)
14405 {
14406         char device_addr[18];
14407         char filename[PATH_MAX];
14408         GKeyFile *key_file;
14409         GError *gerr = NULL;
14410         char key_str[33];
14411         gsize length = 0;
14412         char *str;
14413         int i;
14414
14415         ba2str(peer, device_addr);
14416
14417         create_filename(filename, PATH_MAX, "/%s/%s/info",
14418                         btd_adapter_get_storage_dir(adapter), device_addr);
14419         create_file(filename, 0600);
14420
14421         key_file = g_key_file_new();
14422         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14423                 error("Unable to load key file from %s: (%s)", filename,
14424                                                                 gerr->message);
14425                 g_error_free(gerr);
14426                 g_key_file_free(key_file);
14427                 return;
14428         }
14429
14430         for (i = 0; i < 16; i++)
14431                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14432
14433         g_key_file_set_string(key_file, group, "Key", key_str);
14434
14435         g_key_file_set_integer(key_file, group, "Authenticated",
14436                         authenticated);
14437         g_key_file_set_integer(key_file, group, "EncSize", enc_size);
14438
14439         g_key_file_set_integer(key_file, group, "EDiv", ediv);
14440         g_key_file_set_uint64(key_file, group, "Rand", rand);
14441
14442         create_file(filename, 0600);
14443
14444         str = g_key_file_to_data(key_file, &length, NULL);
14445         if (!g_file_set_contents(filename, str, length, &gerr)) {
14446                 error("Unable set contents for %s: (%s)", filename,
14447                                                                 gerr->message);
14448                 g_error_free(gerr);
14449         }
14450         g_free(str);
14451
14452         g_key_file_free(key_file);
14453 }
14454
14455 static void store_longtermkey(struct btd_adapter *adapter, const bdaddr_t *peer,
14456                                 uint8_t bdaddr_type, const unsigned char *key,
14457                                 uint8_t central, uint8_t authenticated,
14458                                 uint8_t enc_size, uint16_t ediv,
14459                                 uint64_t rand)
14460 {
14461         if (central != 0x00 && central != 0x01) {
14462                 error("Unsupported LTK type %u", central);
14463                 return;
14464         }
14465
14466         if (central) {
14467                 store_ltk_group(adapter, peer, bdaddr_type, key, "LongTermKey",
14468                                 authenticated, enc_size, ediv, rand);
14469         } else {
14470                 /* Peripheral* is the proper term, but for now keep duplicates
14471                  * so it won't break when user up/downgrades. Remove the other
14472                  * term after a few releases.
14473                  */
14474                 store_ltk_group(adapter, peer, bdaddr_type, key,
14475                                 "PeripheralLongTermKey", authenticated,
14476                                 enc_size, ediv, rand);
14477                 store_ltk_group(adapter, peer, bdaddr_type, key,
14478                                 "SlaveLongTermKey", authenticated,
14479                                 enc_size, ediv, rand);
14480         }
14481 }
14482
14483 static void new_long_term_key_callback(uint16_t index, uint16_t length,
14484                                         const void *param, void *user_data)
14485 {
14486         const struct mgmt_ev_new_long_term_key *ev = param;
14487         const struct mgmt_addr_info *addr = &ev->key.addr;
14488         struct btd_adapter *adapter = user_data;
14489         struct btd_device *device;
14490         bool persistent;
14491         char dst[18];
14492 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14493         struct device_addr_type t_addr;
14494 #endif
14495
14496         if (length < sizeof(*ev)) {
14497                 btd_error(adapter->dev_id, "Too small long term key event");
14498                 return;
14499         }
14500
14501         ba2str(&addr->bdaddr, dst);
14502
14503         DBG("hci%u new LTK for %s type %u enc_size %u",
14504                 adapter->dev_id, dst, ev->key.type, ev->key.enc_size);
14505
14506         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14507         if (!device) {
14508                 btd_error(adapter->dev_id,
14509                                 "Unable to get device object for %s", dst);
14510                 return;
14511         }
14512
14513         /*
14514          * Some older kernel versions set store_hint for long term keys
14515          * from resolvable and unresolvable random addresses, but there
14516          * is no point in storing these. Next time around the device
14517          * address will be invalid.
14518          *
14519          * So only for identity addresses (public and static random) use
14520          * the store_hint as an indication if the long term key should
14521          * be persistently stored.
14522          *
14523          */
14524         if (addr->type == BDADDR_LE_RANDOM &&
14525                                 (addr->bdaddr.b[5] & 0xc0) != 0xc0)
14526                 persistent = false;
14527         else
14528                 persistent = !!ev->store_hint;
14529
14530         if (persistent) {
14531                 const struct mgmt_ltk_info *key = &ev->key;
14532                 uint16_t ediv;
14533                 uint64_t rand;
14534
14535                 ediv = le16_to_cpu(key->ediv);
14536                 rand = le64_to_cpu(key->rand);
14537
14538 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14539                 device_get_tizen_addr(device, addr->type, &t_addr);
14540                 store_longtermkey(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14541                                         key->val, key->central, key->type,
14542                                         key->enc_size, ediv, rand);
14543 #else
14544                 store_longtermkey(adapter, &key->addr.bdaddr,
14545                                         key->addr.type, key->val, key->central,
14546                                         key->type, key->enc_size, ediv, rand);
14547 #endif
14548
14549                 device_set_bonded(device, addr->type);
14550         }
14551
14552         device_set_ltk(device, ev->key.val, ev->key.central, ev->key.enc_size);
14553
14554         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14555 }
14556
14557 static void store_csrk(struct btd_adapter *adapter, const bdaddr_t *peer,
14558                                 uint8_t bdaddr_type, const unsigned char *key,
14559                                 uint32_t counter, uint8_t type)
14560 {
14561         const char *group;
14562         char device_addr[18];
14563         char filename[PATH_MAX];
14564         GKeyFile *key_file;
14565         GError *gerr = NULL;
14566         char key_str[33];
14567         gsize length = 0;
14568         gboolean auth;
14569         char *str;
14570         int i;
14571
14572         switch (type) {
14573         case 0x00:
14574                 group = "LocalSignatureKey";
14575                 auth = FALSE;
14576                 break;
14577         case 0x01:
14578                 group = "RemoteSignatureKey";
14579                 auth = FALSE;
14580                 break;
14581         case 0x02:
14582                 group = "LocalSignatureKey";
14583                 auth = TRUE;
14584                 break;
14585         case 0x03:
14586                 group = "RemoteSignatureKey";
14587                 auth = TRUE;
14588                 break;
14589         default:
14590                 warn("Unsupported CSRK type %u", type);
14591                 return;
14592         }
14593
14594         ba2str(peer, device_addr);
14595
14596         create_filename(filename, PATH_MAX, "/%s/%s/info",
14597                         btd_adapter_get_storage_dir(adapter), device_addr);
14598
14599         key_file = g_key_file_new();
14600         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14601                 error("Unable to load key file from %s: (%s)", filename,
14602                                                                 gerr->message);
14603                 g_clear_error(&gerr);
14604         }
14605
14606         for (i = 0; i < 16; i++)
14607                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14608
14609         g_key_file_set_string(key_file, group, "Key", key_str);
14610         g_key_file_set_integer(key_file, group, "Counter", counter);
14611         g_key_file_set_boolean(key_file, group, "Authenticated", auth);
14612
14613         create_file(filename, 0600);
14614
14615         str = g_key_file_to_data(key_file, &length, NULL);
14616         if (!g_file_set_contents(filename, str, length, &gerr)) {
14617                 error("Unable set contents for %s: (%s)", filename,
14618                                                                 gerr->message);
14619                 g_error_free(gerr);
14620         }
14621         g_free(str);
14622
14623         g_key_file_free(key_file);
14624 }
14625
14626 static void new_csrk_callback(uint16_t index, uint16_t length,
14627                                         const void *param, void *user_data)
14628 {
14629         const struct mgmt_ev_new_csrk *ev = param;
14630         const struct mgmt_addr_info *addr = &ev->key.addr;
14631         const struct mgmt_csrk_info *key = &ev->key;
14632         struct btd_adapter *adapter = user_data;
14633         struct btd_device *device;
14634         char dst[18];
14635 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14636         struct device_addr_type t_addr;
14637 #endif
14638
14639         if (length < sizeof(*ev)) {
14640                 btd_error(adapter->dev_id, "Too small CSRK event");
14641                 return;
14642         }
14643
14644         ba2str(&addr->bdaddr, dst);
14645
14646         DBG("hci%u new CSRK for %s type %u", adapter->dev_id, dst,
14647                                                                 ev->key.type);
14648
14649         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14650         if (!device) {
14651                 btd_error(adapter->dev_id,
14652                                 "Unable to get device object for %s", dst);
14653                 return;
14654         }
14655
14656         if (!ev->store_hint)
14657                 return;
14658
14659 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14660         device_get_tizen_addr(device, addr->type, &t_addr);
14661         store_csrk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, key->val, 0,
14662                                                                 key->type);
14663 #else
14664         store_csrk(adapter, &key->addr.bdaddr, key->addr.type, key->val, 0,
14665                                                                 key->type);
14666 #endif
14667
14668         btd_device_set_temporary(device, false);
14669 }
14670
14671 static void store_irk(struct btd_adapter *adapter, const bdaddr_t *peer,
14672                                 uint8_t bdaddr_type, const unsigned char *key)
14673 {
14674         char device_addr[18];
14675         char filename[PATH_MAX];
14676         GKeyFile *key_file;
14677         GError *gerr = NULL;
14678         char *store_data;
14679         char str[33];
14680         size_t length = 0;
14681         int i;
14682
14683         ba2str(peer, device_addr);
14684
14685         create_filename(filename, PATH_MAX, "/%s/%s/info",
14686                         btd_adapter_get_storage_dir(adapter), device_addr);
14687         key_file = g_key_file_new();
14688         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14689                 error("Unable to load key file from %s: (%s)", filename,
14690                                                                 gerr->message);
14691                 g_clear_error(&gerr);
14692         }
14693
14694         for (i = 0; i < 16; i++)
14695                 sprintf(str + (i * 2), "%2.2X", key[i]);
14696
14697         g_key_file_set_string(key_file, "IdentityResolvingKey", "Key", str);
14698
14699         store_data = g_key_file_to_data(key_file, &length, NULL);
14700         if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14701                 error("Unable set contents for %s: (%s)", filename,
14702                                                                 gerr->message);
14703                 g_error_free(gerr);
14704         }
14705         g_free(store_data);
14706
14707         g_key_file_free(key_file);
14708 }
14709
14710 static void new_irk_callback(uint16_t index, uint16_t length,
14711                                         const void *param, void *user_data)
14712 {
14713         const struct mgmt_ev_new_irk *ev = param;
14714         const struct mgmt_addr_info *addr = &ev->key.addr;
14715         const struct mgmt_irk_info *irk = &ev->key;
14716         struct btd_adapter *adapter = user_data;
14717         struct btd_device *device, *duplicate;
14718         bool persistent;
14719         char dst[18], rpa[18];
14720 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14721         struct device_addr_type t_addr;
14722 #endif
14723
14724         if (length < sizeof(*ev)) {
14725                 btd_error(adapter->dev_id, "Too small New IRK event");
14726                 return;
14727         }
14728
14729         ba2str(&addr->bdaddr, dst);
14730         ba2str(&ev->rpa, rpa);
14731
14732         DBG("hci%u new IRK for %s RPA %s", adapter->dev_id, dst, rpa);
14733
14734         if (bacmp(&ev->rpa, BDADDR_ANY)) {
14735                 device = btd_adapter_get_device(adapter, &ev->rpa,
14736                                 BDADDR_LE_RANDOM);
14737 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14738                 device = btd_adapter_get_device(adapter, &ev->rpa,
14739                                                         BDADDR_LE_RANDOM);
14740                 duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
14741                                                                 addr->type);
14742                 if (duplicate == device)
14743                         duplicate = NULL;
14744 #else
14745                 device_set_rpa_addr(device, &ev->rpa);
14746                 duplicate = NULL;
14747 #endif
14748         } else {
14749                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
14750                                                                 addr->type);
14751                 duplicate = NULL;
14752         }
14753
14754         if (!device) {
14755                 btd_error(adapter->dev_id,
14756                                 "Unable to get device object for %s", dst);
14757                 return;
14758         }
14759
14760         device_update_addr(device, &addr->bdaddr, addr->type);
14761
14762         if (duplicate)
14763                 device_merge_duplicate(device, duplicate);
14764
14765 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14766         device_set_irk_value(device, irk->val);
14767 #endif
14768
14769         persistent = !!ev->store_hint;
14770         if (!persistent)
14771                 return;
14772
14773 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14774         device_get_tizen_addr(device, addr->type, &t_addr);
14775         store_irk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, irk->val);
14776 #else
14777         store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
14778 #endif
14779
14780         btd_device_set_temporary(device, false);
14781 }
14782
14783 static void store_conn_param(struct btd_adapter *adapter, const bdaddr_t *peer,
14784                                 uint8_t bdaddr_type, uint16_t min_interval,
14785                                 uint16_t max_interval, uint16_t latency,
14786                                 uint16_t timeout)
14787 {
14788         char device_addr[18];
14789         char filename[PATH_MAX];
14790         GKeyFile *key_file;
14791         GError *gerr = NULL;
14792         char *store_data;
14793         size_t length = 0;
14794
14795         ba2str(peer, device_addr);
14796
14797         DBG("");
14798
14799         create_filename(filename, PATH_MAX, "/%s/%s/info",
14800                         btd_adapter_get_storage_dir(adapter), device_addr);
14801         key_file = g_key_file_new();
14802         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14803                 error("Unable to load key file from %s: (%s)", filename,
14804                                                                 gerr->message);
14805                 g_clear_error(&gerr);
14806         }
14807
14808         g_key_file_set_integer(key_file, "ConnectionParameters",
14809                                                 "MinInterval", min_interval);
14810         g_key_file_set_integer(key_file, "ConnectionParameters",
14811                                                 "MaxInterval", max_interval);
14812         g_key_file_set_integer(key_file, "ConnectionParameters",
14813                                                 "Latency", latency);
14814         g_key_file_set_integer(key_file, "ConnectionParameters",
14815                                                 "Timeout", timeout);
14816
14817         create_file(filename, 0600);
14818
14819         store_data = g_key_file_to_data(key_file, &length, NULL);
14820         if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14821                 error("Unable set contents for %s: (%s)", filename,
14822                                                                 gerr->message);
14823                 g_error_free(gerr);
14824         }
14825         g_free(store_data);
14826
14827         g_key_file_free(key_file);
14828 }
14829
14830 static void new_conn_param(uint16_t index, uint16_t length,
14831                                         const void *param, void *user_data)
14832 {
14833         const struct mgmt_ev_new_conn_param *ev = param;
14834         struct btd_adapter *adapter = user_data;
14835         uint16_t min, max, latency, timeout;
14836         struct btd_device *dev;
14837         char dst[18];
14838 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14839         struct device_addr_type t_addr;
14840 #endif
14841
14842         if (length < sizeof(*ev)) {
14843                 btd_error(adapter->dev_id,
14844                                 "Too small New Connection Parameter event");
14845                 return;
14846         }
14847
14848         ba2str(&ev->addr.bdaddr, dst);
14849
14850         min = btohs(ev->min_interval);
14851         max = btohs(ev->max_interval);
14852         latency = btohs(ev->latency);
14853         timeout = btohs(ev->timeout);
14854
14855         DBG("hci%u %s (%u) min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
14856                 adapter->dev_id, dst, ev->addr.type, min, max, latency, timeout);
14857
14858         dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
14859         if (!dev) {
14860                 btd_error(adapter->dev_id,
14861                                 "Unable to get device object for %s", dst);
14862                 return;
14863         }
14864
14865         if (!ev->store_hint)
14866                 return;
14867
14868 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14869         device_get_tizen_addr(dev, ev->addr.type, &t_addr);
14870         store_conn_param(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14871                                         ev->min_interval, ev->max_interval,
14872                                         ev->latency, ev->timeout);
14873 #else
14874         store_conn_param(adapter, &ev->addr.bdaddr, ev->addr.type,
14875                                         ev->min_interval, ev->max_interval,
14876                                         ev->latency, ev->timeout);
14877 #endif
14878 }
14879
14880 int adapter_set_io_capability(struct btd_adapter *adapter, uint8_t io_cap)
14881 {
14882         struct mgmt_cp_set_io_capability cp;
14883
14884         if (!btd_opts.pairable) {
14885                 if (io_cap == IO_CAPABILITY_INVALID) {
14886                         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
14887                                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
14888
14889                         return 0;
14890                 }
14891
14892                 if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
14893                         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
14894         } else if (io_cap == IO_CAPABILITY_INVALID)
14895                 io_cap = IO_CAPABILITY_NOINPUTNOOUTPUT;
14896
14897         memset(&cp, 0, sizeof(cp));
14898         cp.io_capability = io_cap;
14899
14900         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IO_CAPABILITY,
14901                                 adapter->dev_id, sizeof(cp), &cp,
14902                                 NULL, NULL, NULL) > 0)
14903                 return 0;
14904
14905         return -EIO;
14906 }
14907
14908 int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
14909                                         const bdaddr_t *bdaddr,
14910                                         uint8_t *hash, uint8_t *randomizer)
14911 {
14912         struct mgmt_cp_add_remote_oob_data cp;
14913         char addr[18];
14914
14915         ba2str(bdaddr, addr);
14916         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14917
14918         memset(&cp, 0, sizeof(cp));
14919         bacpy(&cp.addr.bdaddr, bdaddr);
14920         memcpy(cp.hash192, hash, 16);
14921
14922         if (randomizer)
14923                 memcpy(cp.rand192, randomizer, 16);
14924
14925         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14926                                 adapter->dev_id, sizeof(cp), &cp,
14927                                 NULL, NULL, NULL) > 0)
14928                 return 0;
14929
14930         return -EIO;
14931 }
14932
14933 int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
14934                                                         const bdaddr_t *bdaddr)
14935 {
14936         struct mgmt_cp_remove_remote_oob_data cp;
14937         char addr[18];
14938
14939         ba2str(bdaddr, addr);
14940         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14941
14942         memset(&cp, 0, sizeof(cp));
14943         bacpy(&cp.addr.bdaddr, bdaddr);
14944
14945         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
14946                                 adapter->dev_id, sizeof(cp), &cp,
14947                                 NULL, NULL, NULL) > 0)
14948                 return 0;
14949
14950         return -EIO;
14951 }
14952
14953 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14954 int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
14955                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
14956                                 uint8_t *hash192, uint8_t *randomizer192,
14957                                 uint8_t *hash256, uint8_t *randomizer256)
14958 {
14959         struct mgmt_cp_add_remote_oob_data cp;
14960         char addr[18];
14961
14962         ba2str(bdaddr, addr);
14963         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
14964
14965         memset(&cp, 0, sizeof(cp));
14966         bacpy(&cp.addr.bdaddr, bdaddr);
14967         cp.addr.type = bdaddr_type;
14968
14969         if (hash192 && randomizer192) {
14970                 memcpy(cp.hash192, hash192, 16);
14971                 memcpy(cp.rand192, randomizer192, 16);
14972         }
14973
14974         if (hash256 && randomizer256) {
14975                 memcpy(cp.hash256, hash256, 16);
14976                 memcpy(cp.rand256, randomizer256, 16);
14977         }
14978
14979         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14980                                 adapter->dev_id, sizeof(cp), &cp,
14981                                 NULL, NULL, NULL) > 0)
14982                 return 0;
14983
14984         return -EIO;
14985 }
14986
14987 int btd_adapter_remove_remote_oob_ext_data(struct btd_adapter *adapter,
14988                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
14989 {
14990         struct mgmt_cp_remove_remote_oob_data cp;
14991         char addr[18];
14992
14993         ba2str(bdaddr, addr);
14994         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
14995
14996         memset(&cp, 0, sizeof(cp));
14997         bacpy(&cp.addr.bdaddr, bdaddr);
14998         cp.addr.type = bdaddr_type;
14999
15000         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
15001                                 adapter->dev_id, sizeof(cp), &cp,
15002                                 NULL, NULL, NULL) > 0)
15003                 return 0;
15004
15005         return -EIO;
15006 }
15007 #endif
15008
15009 bool btd_adapter_ssp_enabled(struct btd_adapter *adapter)
15010 {
15011         if (adapter->current_settings & MGMT_SETTING_SSP)
15012                 return true;
15013
15014         return false;
15015 }
15016
15017 void btd_adapter_set_oob_handler(struct btd_adapter *adapter,
15018                                                 struct oob_handler *handler)
15019 {
15020         adapter->oob_handler = handler;
15021 }
15022
15023 gboolean btd_adapter_check_oob_handler(struct btd_adapter *adapter)
15024 {
15025         return adapter->oob_handler != NULL;
15026 }
15027
15028 static void read_local_oob_data_complete(uint8_t status, uint16_t length,
15029                                         const void *param, void *user_data)
15030 {
15031         const struct mgmt_rp_read_local_oob_data *rp = param;
15032         struct btd_adapter *adapter = user_data;
15033         const uint8_t *hash, *randomizer;
15034 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15035         const uint8_t *hash256 = NULL;
15036         const uint8_t *randomizer256 = NULL;
15037 #endif
15038
15039         if (status != MGMT_STATUS_SUCCESS) {
15040                 btd_error(adapter->dev_id,
15041                                 "Read local OOB data failed: %s (0x%02x)",
15042                                                 mgmt_errstr(status), status);
15043                 hash = NULL;
15044                 randomizer = NULL;
15045 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15046         } else if (length < 32) {
15047 #else
15048         } else if (length < sizeof(*rp)) {
15049 #endif
15050                 btd_error(adapter->dev_id,
15051                                 "Too small read local OOB data response");
15052                 return;
15053         } else {
15054                 hash = rp->hash192;
15055                 randomizer = rp->rand192;
15056 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15057                 if (length > 32) {
15058                         hash256 = rp->hash256;
15059                         randomizer256 = rp->rand256;
15060                 }
15061 #endif
15062         }
15063
15064         if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
15065                 return;
15066
15067 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15068         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
15069                                         hash256, randomizer256,
15070                                         adapter->oob_handler->user_data);
15071 #else
15072         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
15073                                         adapter->oob_handler->user_data);
15074 #endif
15075
15076         g_free(adapter->oob_handler);
15077         adapter->oob_handler = NULL;
15078 }
15079
15080 int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
15081 {
15082         DBG("hci%u", adapter->dev_id);
15083
15084         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_DATA,
15085                         adapter->dev_id, 0, NULL, read_local_oob_data_complete,
15086                         adapter, NULL) > 0)
15087                 return 0;
15088
15089         return -EIO;
15090 }
15091
15092 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15093 static void le_read_local_oob_data_complete(uint8_t status, uint16_t length,
15094                                         const void *param, void *user_data)
15095 {
15096         const struct mgmt_rp_read_local_oob_ext_data *rp = param;
15097         struct btd_adapter *adapter = user_data;
15098
15099         if (status != MGMT_STATUS_SUCCESS) {
15100                 btd_error(adapter->dev_id, "LE Read local OOB data failed: %s (0x%02x)",
15101                                                 mgmt_errstr(status), status);
15102         } else if (length < sizeof(struct mgmt_rp_read_local_oob_ext_data)) {
15103                 btd_error(adapter->dev_id,
15104                                 "Too small read local OOB ext data response");
15105                 return;
15106         }
15107
15108         if (!adapter->oob_handler || !adapter->oob_handler->le_read_local_cb) {
15109                 btd_error(adapter->dev_id, "oob_handler is not valid : %p",
15110                                 adapter->oob_handler);
15111                 return;
15112         }
15113
15114         adapter->oob_handler->le_read_local_cb(adapter, rp->eir_len, rp->eir,
15115                         adapter->oob_handler->user_data);
15116
15117         g_free(adapter->oob_handler);
15118         adapter->oob_handler = NULL;
15119 }
15120
15121 int btd_adapter_le_read_local_oob_data(struct btd_adapter *adapter)
15122 {
15123         struct mgmt_cp_read_local_oob_ext_data cp;
15124
15125         DBG("hci%u", adapter->dev_id);
15126
15127         memset(&cp, 0, sizeof(cp));
15128         cp.type = (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
15129
15130         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
15131                         adapter->dev_id, sizeof(cp), &cp, le_read_local_oob_data_complete,
15132                         adapter, NULL) > 0)
15133                 return 0;
15134
15135         return -EIO;
15136 }
15137 #endif
15138
15139 void btd_adapter_for_each_device(struct btd_adapter *adapter,
15140                         void (*cb)(struct btd_device *device, void *data),
15141                         void *data)
15142 {
15143         g_slist_foreach(adapter->devices, (GFunc) cb, data);
15144 }
15145
15146 static int adapter_cmp(gconstpointer a, gconstpointer b)
15147 {
15148         struct btd_adapter *adapter = (struct btd_adapter *) a;
15149         const bdaddr_t *bdaddr = b;
15150
15151         return bacmp(&adapter->bdaddr, bdaddr);
15152 }
15153
15154 static int adapter_id_cmp(gconstpointer a, gconstpointer b)
15155 {
15156         struct btd_adapter *adapter = (struct btd_adapter *) a;
15157         uint16_t id = GPOINTER_TO_UINT(b);
15158
15159         return adapter->dev_id == id ? 0 : -1;
15160 }
15161
15162 struct btd_adapter *adapter_find(const bdaddr_t *sba)
15163 {
15164         GSList *match;
15165
15166         match = g_slist_find_custom(adapters, sba, adapter_cmp);
15167         if (!match)
15168                 return NULL;
15169
15170         return match->data;
15171 }
15172
15173 struct btd_adapter *adapter_find_by_id(int id)
15174 {
15175         GSList *match;
15176
15177         match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
15178                                                         adapter_id_cmp);
15179         if (!match)
15180                 return NULL;
15181
15182         return match->data;
15183 }
15184
15185 void adapter_foreach(adapter_cb func, gpointer user_data)
15186 {
15187         g_slist_foreach(adapters, (GFunc) func, user_data);
15188 }
15189
15190 static int set_did(struct btd_adapter *adapter, uint16_t vendor,
15191                         uint16_t product, uint16_t version, uint16_t source)
15192 {
15193         struct mgmt_cp_set_device_id cp;
15194
15195         DBG("hci%u source %x vendor %x product %x version %x",
15196                         adapter->dev_id, source, vendor, product, version);
15197
15198         memset(&cp, 0, sizeof(cp));
15199
15200         cp.source = htobs(source);
15201         cp.vendor = htobs(vendor);
15202         cp.product = htobs(product);
15203         cp.version = htobs(version);
15204
15205         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_ID,
15206                                 adapter->dev_id, sizeof(cp), &cp,
15207                                 NULL, NULL, NULL) > 0)
15208                 return 0;
15209
15210         return -EIO;
15211 }
15212
15213 static void services_modified(struct gatt_db_attribute *attrib, void *user_data)
15214 {
15215         struct btd_adapter *adapter = user_data;
15216
15217         g_dbus_emit_property_changed(dbus_conn, adapter->path,
15218                                                 ADAPTER_INTERFACE, "UUIDs");
15219 }
15220
15221 static int adapter_register(struct btd_adapter *adapter)
15222 {
15223         struct agent *agent;
15224         struct gatt_db *db;
15225 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15226         char address[18] = { 0 };
15227         char filename[PATH_MAX] = { 0 };
15228 #endif
15229
15230         if (powering_down)
15231                 return -EBUSY;
15232
15233         adapter->path = g_strdup_printf("/org/bluez/hci%d", adapter->dev_id);
15234
15235         if (!g_dbus_register_interface(dbus_conn,
15236                                         adapter->path, ADAPTER_INTERFACE,
15237 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15238                                         adapter_methods, adapter_signals,
15239 #else
15240                                         adapter_methods, NULL,
15241 #endif
15242                                         adapter_properties, adapter,
15243                                         adapter_free)) {
15244                 btd_error(adapter->dev_id,
15245                                 "Adapter interface init failed on path %s",
15246                                                         adapter->path);
15247                 g_free(adapter->path);
15248                 adapter->path = NULL;
15249                 return -EINVAL;
15250         }
15251
15252         if (adapters == NULL)
15253                 adapter->is_default = true;
15254
15255         adapters = g_slist_append(adapters, adapter);
15256
15257         agent = agent_get(NULL);
15258         if (agent) {
15259                 uint8_t io_cap = agent_get_io_capability(agent);
15260                 adapter_set_io_capability(adapter, io_cap);
15261                 agent_unref(agent);
15262         }
15263
15264         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15265                 adapter->battery_provider_manager =
15266                         btd_battery_provider_manager_create(adapter);
15267         }
15268
15269         /* Don't start GATT database and advertising managers on
15270          * non-LE controllers.
15271          */
15272         if (!(adapter->supported_settings & MGMT_SETTING_LE) ||
15273                                         btd_opts.mode == BT_MODE_BREDR)
15274                 goto load;
15275
15276         adapter->database = btd_gatt_database_new(adapter);
15277         if (!adapter->database) {
15278                 btd_error(adapter->dev_id,
15279                                 "Failed to create GATT database for adapter");
15280                 adapters = g_slist_remove(adapters, adapter);
15281                 return -EINVAL;
15282         }
15283
15284         adapter->adv_manager = btd_adv_manager_new(adapter, adapter->mgmt);
15285
15286         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15287                 if (adapter->supported_settings & MGMT_SETTING_LE) {
15288                         adapter->adv_monitor_manager =
15289                                 btd_adv_monitor_manager_create(adapter,
15290                                                                 adapter->mgmt);
15291                         if (!adapter->adv_monitor_manager) {
15292                                 btd_error(adapter->dev_id,
15293                                                 "Failed to create Adv Monitor "
15294                                                 "Manager for adapter");
15295                                 return -EINVAL;
15296                         }
15297                 } else {
15298                         btd_info(adapter->dev_id, "Adv Monitor Manager "
15299                                         "skipped, LE unavailable");
15300                 }
15301         }
15302
15303         db = btd_gatt_database_get_db(adapter->database);
15304         adapter->db_id = gatt_db_register(db, services_modified,
15305                                                         services_modified,
15306                                                         adapter, NULL);
15307
15308 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15309         ba2str(&adapter->bdaddr, address);
15310         snprintf(filename, PATH_MAX, STORAGEDIR "/%s", address);
15311         delete_tempfiles(filename);
15312 #endif
15313
15314 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15315         adapter_print_devices(adapter);
15316
15317         if (load_local_irk(adapter)) {
15318                 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
15319                         btd_opts.le_privacy = false;
15320
15321                 /*
15322                  * Some Android devices don't consider the device as LE one,
15323                  * if the device doesn't distribute IRK when pairing.
15324                  * Because of this compatibility issue, set IRK
15325                  * even though privacy feature is disabled.
15326                  */
15327                 set_local_irk(adapter);
15328
15329                 if (btd_opts.le_privacy) {
15330                         DBG("Enable LE Privacy feature");
15331                         set_privacy(adapter, true);
15332                 } else {
15333                         DBG("Disable LE Privacy feature");
15334                 }
15335         }
15336 #endif
15337
15338 load:
15339         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FLAGS_CHANGED,
15340                                                 adapter->dev_id,
15341                                                 device_flags_changed_callback,
15342                                                 adapter, NULL);
15343
15344         load_config(adapter);
15345         fix_storage(adapter);
15346         load_drivers(adapter);
15347         btd_profile_foreach(probe_profile, adapter);
15348         clear_blocked(adapter);
15349         load_defaults(adapter);
15350         load_devices(adapter);
15351
15352         /* restore Service Changed CCC value for bonded devices */
15353         btd_gatt_database_restore_svc_chng_ccc(adapter->database);
15354
15355         /* retrieve the active connections: address the scenario where
15356          * the are active connections before the daemon've started */
15357         if (btd_adapter_get_powered(adapter))
15358                 load_connections(adapter);
15359
15360         adapter->initialized = TRUE;
15361
15362         if (btd_opts.did_source) {
15363                 /* DeviceID record is added by sdpd-server before any other
15364                  * record is registered. */
15365                 adapter_service_insert(adapter, sdp_record_find(0x10000));
15366                 set_did(adapter, btd_opts.did_vendor, btd_opts.did_product,
15367                                 btd_opts.did_version, btd_opts.did_source);
15368         }
15369
15370         DBG("Adapter %s registered", adapter->path);
15371
15372         return 0;
15373 }
15374
15375 static int adapter_unregister(struct btd_adapter *adapter)
15376 {
15377         DBG("Unregister path: %s", adapter->path);
15378
15379         adapters = g_slist_remove(adapters, adapter);
15380
15381         if (adapter->is_default && adapters != NULL) {
15382                 struct btd_adapter *new_default;
15383
15384                 new_default = adapter_find_by_id(hci_get_route(NULL));
15385                 if (new_default == NULL)
15386                         new_default = adapters->data;
15387
15388                 new_default->is_default = true;
15389         }
15390
15391         adapter_list = g_list_remove(adapter_list, adapter);
15392
15393         adapter_remove(adapter);
15394         btd_adapter_unref(adapter);
15395
15396         return 0;
15397 }
15398
15399 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15400 /* ---- HCI Error Codes ---- */
15401 #define HCI_ERROR_AUTH_FAILURE          0x05
15402 #define HCI_ERROR_PIN_OR_KEY_MISSING    0x06
15403 #define HCI_ERROR_MEMORY_EXCEEDED       0x07
15404 #define HCI_ERROR_CONNECTION_TIMEOUT    0x08
15405 #define HCI_ERROR_REJ_LIMITED_RESOURCES 0x0d
15406 #define HCI_ERROR_REJ_BAD_ADDR          0x0f
15407 #define HCI_ERROR_REMOTE_USER_TERM      0x13
15408 #define HCI_ERROR_REMOTE_LOW_RESOURCES  0x14
15409 #define HCI_ERROR_REMOTE_POWER_OFF      0x15
15410 #define HCI_ERROR_LOCAL_HOST_TERM       0x16
15411 #define HCI_ERROR_PAIRING_NOT_ALLOWED   0x18
15412 #define HCI_ERROR_INVALID_LL_PARAMS     0x1e
15413 #define HCI_ERROR_UNSPECIFIED           0x1f
15414 #define HCI_ERROR_ADVERTISING_TIMEOUT   0x3c
15415
15416 static uint8_t mgmt_to_hci_reason(uint8_t err)
15417 {
15418         switch (err) {
15419         case MGMT_DEV_DISCONN_TIMEOUT:
15420                 return HCI_ERROR_CONNECTION_TIMEOUT;
15421         case MGMT_DEV_DISCONN_REMOTE:
15422                 return HCI_ERROR_REMOTE_USER_TERM;
15423         case MGMT_DEV_DISCONN_LOCAL_HOST:
15424                 return HCI_ERROR_LOCAL_HOST_TERM;
15425         default:
15426                 error("No match MGMT error");
15427                 return err;
15428         }
15429 }
15430 #endif
15431
15432 static void disconnected_callback(uint16_t index, uint16_t length,
15433                                         const void *param, void *user_data)
15434 {
15435         const struct mgmt_ev_device_disconnected *ev = param;
15436         struct btd_adapter *adapter = user_data;
15437         uint8_t reason;
15438
15439         if (length < sizeof(struct mgmt_addr_info)) {
15440                 btd_error(adapter->dev_id,
15441                                 "Too small device disconnected event");
15442                 return;
15443         }
15444
15445         if (length < sizeof(*ev))
15446                 reason = MGMT_DEV_DISCONN_UNKNOWN;
15447         else
15448                 reason = ev->reason;
15449
15450 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15451          /* Use HCI error code instead of MGMT disconnection reason */
15452         dev_disconnected(adapter, &ev->addr, mgmt_to_hci_reason(reason));
15453 #else
15454         dev_disconnected(adapter, &ev->addr, reason);
15455 #endif
15456 }
15457
15458 static void connected_callback(uint16_t index, uint16_t length,
15459                                         const void *param, void *user_data)
15460 {
15461         const struct mgmt_ev_device_connected *ev = param;
15462         struct btd_adapter *adapter = user_data;
15463         struct btd_device *device;
15464         struct eir_data eir_data;
15465         uint16_t eir_len;
15466         char addr[18];
15467         bool name_known;
15468
15469         if (length < sizeof(*ev)) {
15470                 btd_error(adapter->dev_id, "Too small device connected event");
15471                 return;
15472         }
15473
15474         eir_len = btohs(ev->eir_len);
15475         if (length < sizeof(*ev) + eir_len) {
15476                 btd_error(adapter->dev_id, "Too small device connected event");
15477                 return;
15478         }
15479
15480         ba2str(&ev->addr.bdaddr, addr);
15481
15482         DBG("hci%u device %s connected eir_len %u", index, addr, eir_len);
15483
15484         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
15485                                                                 ev->addr.type);
15486         if (!device) {
15487                 btd_error(adapter->dev_id,
15488                                 "Unable to get device object for %s", addr);
15489                 return;
15490         }
15491
15492         memset(&eir_data, 0, sizeof(eir_data));
15493         if (eir_len > 0)
15494                 eir_parse(&eir_data, ev->eir, eir_len);
15495
15496         if (eir_data.class != 0)
15497                 device_set_class(device, eir_data.class);
15498
15499         adapter_add_connection(adapter, device, ev->addr.type);
15500
15501         name_known = device_name_known(device);
15502
15503         if (eir_data.name && (eir_data.name_complete || !name_known)) {
15504                 device_store_cached_name(device, eir_data.name);
15505                 btd_device_device_set_name(device, eir_data.name);
15506         }
15507
15508         if (eir_data.msd_list)
15509                 adapter_msd_notify(adapter, device, eir_data.msd_list);
15510
15511         eir_data_free(&eir_data);
15512 }
15513
15514 static void controller_resume_notify(struct btd_adapter *adapter)
15515 {
15516         GSList *l;
15517
15518         for (l = adapter->drivers; l; l = g_slist_next(l)) {
15519                 struct btd_adapter_driver *driver = l->data;
15520                 if (driver->resume)
15521                         driver->resume(adapter);
15522         }
15523 }
15524
15525 static void controller_resume_callback(uint16_t index, uint16_t length,
15526                                        const void *param, void *user_data)
15527 {
15528         const struct mgmt_ev_controller_resume *ev = param;
15529         struct btd_adapter *adapter = user_data;
15530
15531         if (length < sizeof(*ev)) {
15532                 btd_error(adapter->dev_id, "Too small device resume event");
15533                 return;
15534         }
15535
15536         info("Controller resume with wake event 0x%x", ev->wake_reason);
15537
15538         controller_resume_notify(adapter);
15539 }
15540
15541 static void device_blocked_callback(uint16_t index, uint16_t length,
15542                                         const void *param, void *user_data)
15543 {
15544         const struct mgmt_ev_device_blocked *ev = param;
15545         struct btd_adapter *adapter = user_data;
15546         struct btd_device *device;
15547         char addr[18];
15548
15549         if (length < sizeof(*ev)) {
15550                 btd_error(adapter->dev_id, "Too small device blocked event");
15551                 return;
15552         }
15553
15554         ba2str(&ev->addr.bdaddr, addr);
15555         DBG("hci%u %s blocked", index, addr);
15556
15557         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15558                                                                 ev->addr.type);
15559         if (device)
15560                 device_block(device, TRUE);
15561 }
15562
15563 static void device_unblocked_callback(uint16_t index, uint16_t length,
15564                                         const void *param, void *user_data)
15565 {
15566         const struct mgmt_ev_device_unblocked *ev = param;
15567         struct btd_adapter *adapter = user_data;
15568         struct btd_device *device;
15569         char addr[18];
15570
15571         if (length < sizeof(*ev)) {
15572                 btd_error(adapter->dev_id, "Too small device unblocked event");
15573                 return;
15574         }
15575
15576         ba2str(&ev->addr.bdaddr, addr);
15577         DBG("hci%u %s unblocked", index, addr);
15578
15579         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15580                                                                 ev->addr.type);
15581         if (device)
15582                 device_unblock(device, FALSE, TRUE);
15583 }
15584
15585 static void conn_fail_notify(struct btd_device *dev, uint8_t status)
15586 {
15587         GSList *l;
15588
15589         for (l = conn_fail_list; l; l = g_slist_next(l)) {
15590                 btd_conn_fail_cb conn_fail_cb = l->data;
15591                 conn_fail_cb(dev, status);
15592         }
15593 }
15594
15595 void btd_add_conn_fail_cb(btd_conn_fail_cb func)
15596 {
15597         conn_fail_list = g_slist_append(conn_fail_list, func);
15598 }
15599
15600 void btd_remove_conn_fail_cb(btd_conn_fail_cb func)
15601 {
15602         conn_fail_list = g_slist_remove(conn_fail_list, func);
15603 }
15604
15605 static void connect_failed_callback(uint16_t index, uint16_t length,
15606                                         const void *param, void *user_data)
15607 {
15608         const struct mgmt_ev_connect_failed *ev = param;
15609         struct btd_adapter *adapter = user_data;
15610         struct btd_device *device;
15611         char addr[18];
15612
15613         if (length < sizeof(*ev)) {
15614                 btd_error(adapter->dev_id, "Too small connect failed event");
15615                 return;
15616         }
15617
15618         ba2str(&ev->addr.bdaddr, addr);
15619
15620         DBG("hci%u %s status %u", index, addr, ev->status);
15621
15622         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15623                                                                 ev->addr.type);
15624         if (device) {
15625                 conn_fail_notify(device, ev->status);
15626
15627                 /* If the device is in a bonding process cancel any auth request
15628                  * sent to the agent before proceeding, but keep the bonding
15629                  * request structure. */
15630                 if (device_is_bonding(device, NULL))
15631                         device_cancel_authentication(device, FALSE);
15632         }
15633
15634         /* In the case of security mode 3 devices */
15635         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
15636                                                                 ev->status);
15637
15638         /* If the device is scheduled to retry the bonding wait until the retry
15639          * happens. In other case, proceed with cancel the bondig.
15640          */
15641         if (device && device_is_bonding(device, NULL)
15642                                         && !device_is_retrying(device)) {
15643                 device_cancel_authentication(device, TRUE);
15644                 device_bonding_failed(device, ev->status);
15645         }
15646
15647 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
15648         /* In the case the bonding was canceled or did exists, remove the device
15649          * when it is temporary. */
15650         if (device && !device_is_bonding(device, NULL)
15651                                                 && device_is_temporary(device))
15652                 btd_adapter_remove_device(adapter, device);
15653 #endif
15654 }
15655
15656 static void remove_keys(struct btd_adapter *adapter,
15657                                         struct btd_device *device, uint8_t type)
15658 {
15659         char device_addr[18];
15660         char filename[PATH_MAX];
15661         GKeyFile *key_file;
15662         GError *gerr = NULL;
15663         gsize length = 0;
15664         char *str;
15665
15666         ba2str(device_get_address(device), device_addr);
15667
15668 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15669         if (device_get_rpa_exist(device) == true)
15670                 ba2str(device_get_rpa(device), device_addr);
15671 #endif
15672
15673         create_filename(filename, PATH_MAX, "/%s/%s/info",
15674                         btd_adapter_get_storage_dir(adapter), device_addr);
15675
15676         key_file = g_key_file_new();
15677         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
15678                 error("Unable to load key file from %s: (%s)", filename,
15679                                                                 gerr->message);
15680                 g_clear_error(&gerr);
15681         }
15682
15683         if (type == BDADDR_BREDR) {
15684                 g_key_file_remove_group(key_file, "LinkKey", NULL);
15685         } else {
15686                 g_key_file_remove_group(key_file, "LongTermKey", NULL);
15687                 g_key_file_remove_group(key_file, "LocalSignatureKey", NULL);
15688                 g_key_file_remove_group(key_file, "RemoteSignatureKey", NULL);
15689                 g_key_file_remove_group(key_file, "IdentityResolvingKey", NULL);
15690         }
15691
15692         str = g_key_file_to_data(key_file, &length, NULL);
15693         if (!g_file_set_contents(filename, str, length, &gerr)) {
15694                 error("Unable set contents for %s: (%s)", filename,
15695                                                                 gerr->message);
15696                 g_error_free(gerr);
15697         }
15698         g_free(str);
15699
15700         g_key_file_free(key_file);
15701 }
15702
15703 static void unpaired_callback(uint16_t index, uint16_t length,
15704                                         const void *param, void *user_data)
15705 {
15706         const struct mgmt_ev_device_unpaired *ev = param;
15707         struct btd_adapter *adapter = user_data;
15708         struct btd_device *device;
15709         char addr[18];
15710
15711         if (length < sizeof(*ev)) {
15712                 btd_error(adapter->dev_id, "Too small device unpaired event");
15713                 return;
15714         }
15715
15716         ba2str(&ev->addr.bdaddr, addr);
15717
15718         DBG("hci%u addr %s", index, addr);
15719
15720         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15721                                                                 ev->addr.type);
15722         if (!device) {
15723                 btd_warn(adapter->dev_id,
15724                         "No device object for unpaired device %s", addr);
15725                 return;
15726         }
15727
15728         remove_keys(adapter, device, ev->addr.type);
15729         device_set_unpaired(device, ev->addr.type);
15730 }
15731
15732 static void clear_devices_complete(uint8_t status, uint16_t length,
15733                                         const void *param, void *user_data)
15734 {
15735         if (status != MGMT_STATUS_SUCCESS) {
15736                 error("Failed to clear devices: %s (0x%02x)",
15737                                                 mgmt_errstr(status), status);
15738                 return;
15739         }
15740 }
15741
15742 static int clear_devices(struct btd_adapter *adapter)
15743 {
15744         struct mgmt_cp_remove_device cp;
15745
15746         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
15747                 return 0;
15748
15749         memset(&cp, 0, sizeof(cp));
15750
15751         DBG("sending clear devices command for index %u", adapter->dev_id);
15752
15753         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
15754                                 adapter->dev_id, sizeof(cp), &cp,
15755                                 clear_devices_complete, adapter, NULL) > 0)
15756                 return 0;
15757
15758         btd_error(adapter->dev_id, "Failed to clear devices for index %u",
15759                                                         adapter->dev_id);
15760
15761         return -EIO;
15762 }
15763
15764 static bool get_static_addr(struct btd_adapter *adapter)
15765 {
15766         struct bt_crypto *crypto;
15767         GKeyFile *file;
15768         GError *gerr = NULL;
15769         char filename[PATH_MAX];
15770         char **addrs;
15771         char mfg[7];
15772         char *str;
15773         bool ret;
15774         gsize len, i;
15775
15776         snprintf(mfg, sizeof(mfg), "0x%04x", adapter->manufacturer);
15777
15778         create_filename(filename, PATH_MAX, "/addresses");
15779
15780         file = g_key_file_new();
15781         if (!g_key_file_load_from_file(file, filename, 0, &gerr)) {
15782                 error("Unable to load key file from %s: (%s)",
15783                                         filename, gerr->message);
15784                 g_clear_error(&gerr);
15785         }
15786         addrs = g_key_file_get_string_list(file, "Static", mfg, &len, NULL);
15787         if (addrs) {
15788                 for (i = 0; i < len; i++) {
15789                         bdaddr_t addr;
15790
15791                         str2ba(addrs[i], &addr);
15792                         if (adapter_find(&addr))
15793                                 continue;
15794
15795                         /* Usable address found in list */
15796                         bacpy(&adapter->bdaddr, &addr);
15797                         adapter->bdaddr_type = BDADDR_LE_RANDOM;
15798                         ret = true;
15799                         goto done;
15800                 }
15801
15802                 len++;
15803                 addrs = g_renew(char *, addrs, len + 1);
15804         } else {
15805                 len = 1;
15806                 addrs = g_new(char *, len + 1);
15807         }
15808
15809         /* Initialize slot for new address */
15810         addrs[len - 1] = g_malloc(18);
15811         addrs[len] = NULL;
15812
15813         crypto = bt_crypto_new();
15814         if (!crypto) {
15815                 error("Failed to open crypto");
15816                 ret = false;
15817                 goto done;
15818         }
15819
15820         ret = bt_crypto_random_bytes(crypto, &adapter->bdaddr,
15821                                                 sizeof(adapter->bdaddr));
15822         if (!ret) {
15823                 error("Failed to generate static address");
15824                 bt_crypto_unref(crypto);
15825                 goto done;
15826         }
15827
15828         bt_crypto_unref(crypto);
15829
15830         adapter->bdaddr.b[5] |= 0xc0;
15831         adapter->bdaddr_type = BDADDR_LE_RANDOM;
15832
15833         ba2str(&adapter->bdaddr, addrs[len - 1]);
15834
15835         g_key_file_set_string_list(file, "Static", mfg,
15836                                                 (const char **)addrs, len);
15837
15838         str = g_key_file_to_data(file, &len, NULL);
15839         if (!g_file_set_contents(filename, str, len, &gerr)) {
15840                 error("Unable set contents for %s: (%s)",
15841                                         filename, gerr->message);
15842                 g_error_free(gerr);
15843         }
15844         g_free(str);
15845
15846         ret = true;
15847
15848 done:
15849         g_key_file_free(file);
15850         g_strfreev(addrs);
15851
15852         return ret;
15853 }
15854
15855 static bool set_static_addr(struct btd_adapter *adapter)
15856 {
15857         struct mgmt_cp_set_static_address cp;
15858
15859         /* dual-mode adapters must have a public address */
15860         if (adapter->supported_settings & MGMT_SETTING_BREDR)
15861                 return false;
15862
15863         if (!(adapter->supported_settings & MGMT_SETTING_LE))
15864                 return false;
15865
15866         DBG("Setting static address");
15867
15868         if (!get_static_addr(adapter))
15869                 return false;
15870
15871         bacpy(&cp.bdaddr, &adapter->bdaddr);
15872         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STATIC_ADDRESS,
15873                                 adapter->dev_id, sizeof(cp), &cp,
15874                                 NULL, NULL, NULL) > 0) {
15875                 return true;
15876         }
15877
15878         return false;
15879 }
15880
15881 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15882 static uint8_t *generate_irk(void)
15883 {
15884         int fd;
15885         uint8_t *irk;
15886
15887         DBG("Generate IRK");
15888
15889         fd = open("/dev/urandom", O_RDONLY);
15890         if (fd < 0)
15891                 return NULL;
15892
15893         irk = g_malloc0(MGMT_IRK_SIZE);
15894         if (read(fd, irk, MGMT_IRK_SIZE) != MGMT_IRK_SIZE) {
15895                 error("Cannot read random bytes");
15896                 g_free(irk);
15897                 close(fd);
15898                 return NULL;
15899         }
15900         close(fd);
15901
15902         return irk;
15903 }
15904
15905 #define LOCAL_IRK_DIRNAME       "/csa/bluetooth"
15906 #define LOCAL_IRK_FILENAME      ".local_irk"
15907
15908 static bool store_local_irk(struct btd_adapter *adapter)
15909 {
15910         int fd;
15911         int ret;
15912
15913         if (adapter->local_irk == NULL) {
15914                 error("Local IRK is not proper");
15915                 return false;
15916         }
15917
15918         if (access(LOCAL_IRK_DIRNAME, F_OK) < 0) {
15919                 if (mkdir(LOCAL_IRK_DIRNAME, 0755) < 0) {
15920                         error("Cannot create a directory for local IRK : %s",
15921                                         strerror(errno));
15922                         return false;
15923                 }
15924         }
15925
15926         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME,
15927                         O_WRONLY | O_CREAT | O_TRUNC, 0644);
15928         if (fd < 0) {
15929                 error("Cannot open a file for local IRK : %s", strerror(errno));
15930                 return false;
15931         }
15932
15933         ret = write(fd, adapter->local_irk, MGMT_IRK_SIZE);
15934         if (ret != MGMT_IRK_SIZE) {
15935                 error("Cannot write local IRK [%d] : %s", ret, strerror(errno));
15936
15937                 close(fd);
15938                 unlink(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME);
15939                 return false;
15940         }
15941
15942         ret = fdatasync(fd);
15943         if (ret < 0)
15944                 error("sync failed : %s", strerror(errno));
15945
15946         close(fd);
15947         return true;
15948 }
15949
15950 static bool load_local_irk(struct btd_adapter *adapter)
15951 {
15952         int fd;
15953         int ret;
15954
15955         if (access(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, F_OK) < 0) {
15956                 adapter->local_irk = generate_irk();
15957                 if (store_local_irk(adapter) == false) {
15958                         error("Cannot store Local IRK");
15959                         g_free(adapter->local_irk);
15960                         return false;
15961                 }
15962
15963                 return true;
15964         }
15965
15966         if (adapter->local_irk) {
15967                 DBG("Local IRK is already loaded");
15968                 return true;
15969         }
15970
15971         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, O_RDONLY);
15972         if (fd < 0) {
15973                 error("Cannot open local IRK file : %s", strerror(errno));
15974                 return false;
15975         }
15976
15977         adapter->local_irk = g_malloc0(MGMT_IRK_SIZE);
15978
15979         ret = read(fd, adapter->local_irk, MGMT_IRK_SIZE);
15980         if (ret != MGMT_IRK_SIZE) {
15981                 error("Cannot read local IRK [%d] : %s", ret, strerror(errno));
15982                 g_free(adapter->local_irk);
15983                 close(fd);
15984                 return false;
15985         }
15986
15987         close(fd);
15988         return true;
15989 }
15990
15991 static void set_privacy_complete(uint8_t status, uint16_t length,
15992         const void *param, void *user_data)
15993 {
15994         struct btd_adapter *adapter = user_data;
15995
15996         if (status != MGMT_STATUS_SUCCESS)
15997                 error("Setting privacy failed for hci%u: %s (0x%02x)",
15998                         adapter->dev_id, mgmt_errstr(status), status);
15999         else
16000                 DBG("Privacy feature is set/unset successfully for hci%u",
16001                         adapter->dev_id);
16002 }
16003
16004 static bool set_privacy(struct btd_adapter *adapter, bool privacy)
16005 {
16006         struct mgmt_cp_set_privacy cp;
16007
16008         if (!adapter->local_irk) {
16009                 error("Local IRK is not available");
16010                 return false;
16011         }
16012
16013         memset(&cp, 0, sizeof(cp));
16014         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
16015
16016         if (privacy)
16017                 cp.privacy = 0x01;
16018
16019         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
16020                                 adapter->dev_id, sizeof(cp), &cp,
16021                                 set_privacy_complete, adapter, NULL) > 0)
16022                 return true;
16023
16024         error("Failed to set privacy and load local irk for index %u",
16025                         adapter->dev_id);
16026         return false;
16027 }
16028
16029 static void set_irk_complete(uint8_t status, uint16_t length,
16030                 const void *param, void *user_data)
16031 {
16032         struct btd_adapter *adapter = user_data;
16033
16034         if (status != MGMT_STATUS_SUCCESS)
16035                 error("Setting IRK is failed for hci%u: %s (0x%02x)",
16036                         adapter->dev_id, mgmt_errstr(status), status);
16037         else
16038                 DBG("Setting IRK is succeed for hci%u", adapter->dev_id);
16039 }
16040
16041 static bool set_local_irk(struct btd_adapter *adapter)
16042 {
16043         struct mgmt_cp_set_irk cp;
16044
16045         if (!adapter->local_irk) {
16046                 error("Local IRK is not available");
16047                 return false;
16048         }
16049
16050         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
16051
16052         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IRK,
16053                                 adapter->dev_id, sizeof(cp), &cp,
16054                                 set_irk_complete, adapter, NULL) > 0)
16055                 return true;
16056
16057         error("Failed to set irk %u", adapter->dev_id);
16058         return false;
16059 }
16060
16061 int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
16062                                                 const bdaddr_t *bdaddr,
16063                                                 uint8_t bdaddr_type)
16064
16065 {
16066         struct mgmt_cp_connect_6lowpan cp;
16067
16068         memset(&cp, 0, sizeof(cp));
16069         bacpy(&cp.addr.bdaddr, bdaddr);
16070         cp.addr.type = bdaddr_type;
16071
16072         if (mgmt_send(adapter->mgmt, MGMT_OP_CONNECT_6LOWPAN,
16073                                 adapter->dev_id, sizeof(cp), &cp,
16074                                 NULL, NULL, NULL) > 0)
16075                 return 0;
16076
16077         return -EIO;
16078 }
16079
16080 int btd_adapter_disconnect_ipsp(struct btd_adapter *adapter,
16081                                                 const bdaddr_t *bdaddr,
16082                                                 uint8_t bdaddr_type)
16083
16084 {
16085         struct mgmt_cp_disconnect_6lowpan cp;
16086
16087         memset(&cp, 0, sizeof(cp));
16088         bacpy(&cp.addr.bdaddr, bdaddr);
16089         cp.addr.type = bdaddr_type;
16090
16091         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT_6LOWPAN,
16092                                 adapter->dev_id, sizeof(cp), &cp,
16093                                 NULL, NULL, NULL) > 0)
16094                 return 0;
16095
16096         return -EIO;
16097 }
16098
16099 uint8_t btd_adapter_get_rpa_res_support_value(
16100                 struct btd_adapter *adapter)
16101 {
16102         return adapter->central_rpa_res_support;
16103 }
16104
16105 static void set_dev_rpa_res_support_complete(uint8_t status,
16106                                         uint16_t length, const void *param,
16107                                         void *user_data)
16108 {
16109         if (status != MGMT_STATUS_SUCCESS)
16110                 error("Failed to set RPA resolution support of device : %s (0x%02x)",
16111                                                 mgmt_errstr(status), status);
16112         else
16113                 DBG("Set RPA resolution support successful");
16114 }
16115
16116 int btd_adapter_set_dev_rpa_res_support(struct btd_adapter *adapter,
16117                                         struct btd_device *device)
16118
16119 {
16120         struct mgmt_cp_set_dev_rpa_res_support cp;
16121
16122         DBG("btd_adapter_set_dev_rpa_res_support called");
16123
16124         memset(&cp, 0, sizeof(cp));
16125
16126         bacpy(&cp.addr.bdaddr, device_get_address(device));
16127         cp.addr.type = btd_device_get_bdaddr_type(device);
16128         cp.res_support = device_get_rpa_res_char_value(device);
16129
16130         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_RPA_RES_SUPPORT,
16131                                 adapter->dev_id, sizeof(cp), &cp,
16132                                 set_dev_rpa_res_support_complete, NULL, NULL) > 0)
16133                 return 0;
16134
16135         return -EIO;
16136 }
16137 #endif
16138
16139 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16140 static gboolean adapter_start_idle_cb(gpointer user_data)
16141 {
16142         struct btd_adapter *adapter = (struct btd_adapter*)user_data;
16143
16144         adapter_start(adapter);
16145
16146         return FALSE;
16147 }
16148 #endif
16149
16150 static void set_blocked_keys_complete(uint8_t status, uint16_t length,
16151                                         const void *param, void *user_data)
16152 {
16153         struct btd_adapter *adapter = user_data;
16154
16155         if (status != MGMT_STATUS_SUCCESS) {
16156                 btd_error(adapter->dev_id,
16157                                 "Failed to set blocked keys: %s (0x%02x)",
16158                                 mgmt_errstr(status), status);
16159                 return;
16160         }
16161
16162         DBG("Successfully set blocked keys for index %u", adapter->dev_id);
16163 }
16164
16165 static bool set_blocked_keys(struct btd_adapter *adapter)
16166 {
16167         uint8_t buffer[sizeof(struct mgmt_cp_set_blocked_keys) +
16168                                         sizeof(blocked_keys)] = { 0 };
16169         struct mgmt_cp_set_blocked_keys *cp =
16170                                 (struct mgmt_cp_set_blocked_keys *)buffer;
16171         int i;
16172
16173         cp->key_count = ARRAY_SIZE(blocked_keys);
16174         for (i = 0; i < cp->key_count; ++i) {
16175                 cp->keys[i].type = blocked_keys[i].type;
16176                 memcpy(cp->keys[i].val, blocked_keys[i].val,
16177                                                 sizeof(cp->keys[i].val));
16178         }
16179
16180         return mgmt_send(mgmt_primary, MGMT_OP_SET_BLOCKED_KEYS,
16181                                                 adapter->dev_id,
16182                                                 sizeof(buffer), buffer,
16183                                                 set_blocked_keys_complete,
16184                                                 adapter, NULL);
16185 }
16186
16187 #define EXP_FEAT(_flag, _uuid, _func) \
16188 { \
16189         .flag = _flag, \
16190         .uuid = _uuid, \
16191         .func = _func, \
16192 }
16193
16194 static void set_exp_debug_complete(uint8_t status, uint16_t len,
16195                                         const void *param, void *user_data)
16196 {
16197         struct btd_adapter *adapter = user_data;
16198         uint8_t action;
16199
16200         if (status != 0) {
16201                 error("Set Experimental Debug failed with status 0x%02x (%s)",
16202                                                 status, mgmt_errstr(status));
16203                 return;
16204         }
16205
16206         action = btd_kernel_experimental_enabled(debug_uuid.str);
16207
16208         DBG("Experimental Debug successfully %s", action ? "set" : "reset");
16209
16210         if (action)
16211                 queue_push_tail(adapter->exps, (void *)debug_uuid.val);
16212 }
16213
16214 static void exp_debug_func(struct btd_adapter *adapter, uint8_t action)
16215 {
16216         struct mgmt_cp_set_exp_feature cp;
16217
16218         memset(&cp, 0, sizeof(cp));
16219         memcpy(cp.uuid, debug_uuid.val, 16);
16220         cp.action = action;
16221
16222         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16223                         adapter->dev_id, sizeof(cp), &cp,
16224                         set_exp_debug_complete, adapter, NULL) > 0)
16225                 return;
16226
16227         btd_error(adapter->dev_id, "Failed to set exp debug");
16228 }
16229
16230 static void le_simult_central_peripheral_func(struct btd_adapter *adapter,
16231                                                         uint8_t action)
16232 {
16233         if (action)
16234                 queue_push_tail(adapter->exps,
16235                                 (void *)le_simult_central_peripheral_uuid.val);
16236 }
16237
16238 static void quality_report_func(struct btd_adapter *adapter, uint8_t action)
16239 {
16240         if (action)
16241                 queue_push_tail(adapter->exps, (void *)quality_report_uuid.val);
16242 }
16243
16244 static void set_rpa_resolution_complete(uint8_t status, uint16_t len,
16245                                         const void *param, void *user_data)
16246 {
16247         struct btd_adapter *adapter = user_data;
16248         uint8_t action;
16249
16250         if (status != 0) {
16251                 error("Set RPA Resolution failed with status 0x%02x (%s)",
16252                                                 status, mgmt_errstr(status));
16253                 return;
16254         }
16255
16256         action = btd_kernel_experimental_enabled(rpa_resolution_uuid.str);
16257
16258         DBG("RPA Resolution successfully %s", action ? "set" : "reset");
16259
16260         if (action)
16261                 queue_push_tail(adapter->exps, (void *)rpa_resolution_uuid.val);
16262 }
16263
16264 static void rpa_resolution_func(struct btd_adapter *adapter, uint8_t action)
16265 {
16266         struct mgmt_cp_set_exp_feature cp;
16267
16268         memset(&cp, 0, sizeof(cp));
16269         memcpy(cp.uuid, rpa_resolution_uuid.val, 16);
16270         cp.action = action;
16271
16272         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16273                         adapter->dev_id, sizeof(cp), &cp,
16274                         set_rpa_resolution_complete, adapter, NULL) > 0)
16275                 return;
16276
16277         btd_error(adapter->dev_id, "Failed to set RPA Resolution");
16278 }
16279
16280 static void codec_offload_complete(uint8_t status, uint16_t len,
16281                                         const void *param, void *user_data)
16282 {
16283         struct btd_adapter *adapter = user_data;
16284         uint8_t action;
16285
16286         if (status != 0) {
16287                 error("Set Codec Offload failed with status 0x%02x (%s)",
16288                                                 status, mgmt_errstr(status));
16289                 return;
16290         }
16291
16292         action = btd_kernel_experimental_enabled(codec_offload_uuid.str);
16293
16294         DBG("Codec Offload successfully %s", action ? "set" : "reset");
16295
16296         if (action)
16297                 queue_push_tail(adapter->exps, (void *)codec_offload_uuid.val);
16298 }
16299
16300 static void codec_offload_func(struct btd_adapter *adapter, uint8_t action)
16301 {
16302         struct mgmt_cp_set_exp_feature cp;
16303
16304         memset(&cp, 0, sizeof(cp));
16305         memcpy(cp.uuid, codec_offload_uuid.val, 16);
16306         cp.action = action;
16307
16308         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16309                         adapter->dev_id, sizeof(cp), &cp,
16310                         codec_offload_complete, adapter, NULL) > 0)
16311                 return;
16312
16313         btd_error(adapter->dev_id, "Failed to set Codec Offload");
16314 }
16315
16316 static void iso_socket_complete(uint8_t status, uint16_t len,
16317                                 const void *param, void *user_data)
16318 {
16319         struct btd_adapter *adapter = user_data;
16320         uint8_t action;
16321
16322         if (status != 0) {
16323                 error("Set ISO Socket failed with status 0x%02x (%s)",
16324                                                 status, mgmt_errstr(status));
16325                 return;
16326         }
16327
16328         action = btd_kernel_experimental_enabled(iso_socket_uuid.str);
16329
16330         DBG("ISO Socket successfully %s", action ? "set" : "reset");
16331
16332         if (action)
16333                 queue_push_tail(adapter->exps, (void *)iso_socket_uuid.val);
16334 }
16335
16336 static void iso_socket_func(struct btd_adapter *adapter, uint8_t action)
16337 {
16338         struct mgmt_cp_set_exp_feature cp;
16339
16340         memset(&cp, 0, sizeof(cp));
16341         memcpy(cp.uuid, iso_socket_uuid.val, 16);
16342         cp.action = action;
16343
16344         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16345                         MGMT_INDEX_NONE, sizeof(cp), &cp,
16346                         iso_socket_complete, adapter, NULL) > 0)
16347                 return;
16348
16349         btd_error(adapter->dev_id, "Failed to set ISO Socket");
16350 }
16351
16352 static const struct exp_feat {
16353         uint32_t flag;
16354         const struct mgmt_exp_uuid *uuid;
16355         void (*func)(struct btd_adapter *adapter, uint8_t action);
16356 } exp_table[] = {
16357         EXP_FEAT(EXP_FEAT_DEBUG, &debug_uuid, exp_debug_func),
16358         EXP_FEAT(EXP_FEAT_LE_SIMULT_ROLES, &le_simult_central_peripheral_uuid,
16359                  le_simult_central_peripheral_func),
16360         EXP_FEAT(EXP_FEAT_BQR, &quality_report_uuid, quality_report_func),
16361         EXP_FEAT(EXP_FEAT_RPA_RESOLUTION, &rpa_resolution_uuid,
16362                 rpa_resolution_func),
16363         EXP_FEAT(EXP_FEAT_CODEC_OFFLOAD, &codec_offload_uuid,
16364                 codec_offload_func),
16365         EXP_FEAT(EXP_FEAT_ISO_SOCKET, &iso_socket_uuid, iso_socket_func),
16366 };
16367
16368 static void read_exp_features_complete(uint8_t status, uint16_t length,
16369                                         const void *param, void *user_data)
16370 {
16371         struct btd_adapter *adapter = user_data;
16372         const struct mgmt_rp_read_exp_features_info *rp = param;
16373         size_t feature_count = 0;
16374         size_t i = 0;
16375
16376         DBG("index %u status 0x%02x", adapter->dev_id, status);
16377
16378         if (status != MGMT_STATUS_SUCCESS) {
16379                 btd_error(adapter->dev_id,
16380                                 "Failed to read exp features info: %s (0x%02x)",
16381                                 mgmt_errstr(status), status);
16382                 return;
16383         }
16384
16385         if (length < sizeof(*rp)) {
16386                 btd_error(adapter->dev_id, "Response too small");
16387                 return;
16388         }
16389
16390         feature_count = le16_to_cpu(rp->feature_count);
16391
16392         if (length < sizeof(*rp) + (sizeof(*rp->features) * feature_count)) {
16393                 btd_error(adapter->dev_id, "Response too small");
16394                 return;
16395         }
16396
16397         for (i = 0; i < feature_count; ++i) {
16398                 size_t j;
16399                 for (j = 0; j < ARRAY_SIZE(exp_table); j++) {
16400                         const struct exp_feat *feat = &exp_table[j];
16401                         const char *str;
16402                         uint8_t action;
16403
16404                         if (memcmp(rp->features[i].uuid, feat->uuid->val,
16405                                         sizeof(rp->features[i].uuid)))
16406                                 continue;
16407
16408                         str = feat->uuid->str;
16409                         action = btd_kernel_experimental_enabled(str);
16410
16411                         DBG("%s flags %u action %u", str,
16412                                         rp->features[i].flags, action);
16413
16414                         /* If already set don't attempt to set it again */
16415                         if (action == (rp->features[i].flags & BIT(0))) {
16416                                 if (action & BIT(0))
16417                                         queue_push_tail(adapter->exps,
16418                                                 (void *)feat->uuid->val);
16419                                 continue;
16420                         }
16421
16422                         if (feat->func)
16423                                 feat->func(adapter, action);
16424                 }
16425         }
16426 }
16427
16428 static void read_exp_features(struct btd_adapter *adapter)
16429 {
16430         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_EXP_FEATURES_INFO,
16431                         adapter->dev_id, 0, NULL, read_exp_features_complete,
16432                         adapter, NULL) > 0)
16433                 return;
16434
16435         btd_error(adapter->dev_id, "Failed to read exp features info");
16436 }
16437
16438 static void read_info_complete(uint8_t status, uint16_t length,
16439                                         const void *param, void *user_data)
16440 {
16441         struct btd_adapter *adapter = user_data;
16442         const struct mgmt_rp_read_info *rp = param;
16443         uint32_t missing_settings;
16444         int err;
16445
16446         DBG("index %u status 0x%02x", adapter->dev_id, status);
16447
16448         if (status != MGMT_STATUS_SUCCESS) {
16449                 btd_error(adapter->dev_id,
16450                                 "Failed to read info for index %u: %s (0x%02x)",
16451                                 adapter->dev_id, mgmt_errstr(status), status);
16452                 goto failed;
16453         }
16454
16455         if (length < sizeof(*rp)) {
16456                 btd_error(adapter->dev_id,
16457                                 "Too small read info complete response");
16458                 goto failed;
16459         }
16460
16461         /*
16462          * Store controller information for class of device, device
16463          * name, short name and settings.
16464          *
16465          * During the lifetime of the controller these will be updated by
16466          * events and the information is required to keep the current
16467          * state of the controller.
16468          */
16469         adapter->dev_class = rp->dev_class[0] | (rp->dev_class[1] << 8) |
16470                                                 (rp->dev_class[2] << 16);
16471         adapter->name = g_strdup((const char *) rp->name);
16472         adapter->short_name = g_strdup((const char *) rp->short_name);
16473
16474         adapter->manufacturer = btohs(rp->manufacturer);
16475
16476         adapter->supported_settings = btohl(rp->supported_settings);
16477         adapter->current_settings = btohl(rp->current_settings);
16478
16479 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16480         adapter_check_version(adapter, rp->version);
16481 #endif
16482         clear_uuids(adapter);
16483         clear_devices(adapter);
16484
16485         if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
16486                 if (!set_static_addr(adapter)) {
16487                         btd_error(adapter->dev_id,
16488                                         "No Bluetooth address for index %u",
16489                                         adapter->dev_id);
16490                         goto failed;
16491                 }
16492         } else {
16493                 struct btd_adapter *tmp;
16494
16495                 tmp = adapter_find(&rp->bdaddr);
16496                 if (tmp) {
16497                         btd_error(adapter->dev_id,
16498                                 "Bluetooth address for index %u match index %u",
16499                                 adapter->dev_id, tmp->dev_id);
16500                         goto failed;
16501                 }
16502
16503                 bacpy(&adapter->bdaddr, &rp->bdaddr);
16504                 if (!(adapter->supported_settings & MGMT_SETTING_LE))
16505                         adapter->bdaddr_type = BDADDR_BREDR;
16506                 else
16507                         adapter->bdaddr_type = BDADDR_LE_PUBLIC;
16508         }
16509
16510         missing_settings = adapter->current_settings ^
16511                                                 adapter->supported_settings;
16512
16513 /* If adapter supports PHY CONFIGURATION SETTING, then read PHY configuration and save them */
16514 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16515         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
16516                 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_PHY_CONFIGURATION, adapter->dev_id, 0, NULL,
16517                                         get_phy_configuration_resp, adapter, NULL) == 0)
16518                         error("Unable to send %s cmd",
16519                                         mgmt_opstr(MGMT_OP_GET_PHY_CONFIGURATION));
16520         }
16521 #endif
16522         switch (btd_opts.mode) {
16523         case BT_MODE_DUAL:
16524                 if (missing_settings & MGMT_SETTING_SSP) {
16525 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16526                         if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16527                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16528                         else
16529 #endif
16530                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16531                 }
16532                 if (missing_settings & MGMT_SETTING_LE)
16533                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16534                 if (missing_settings & MGMT_SETTING_BREDR)
16535                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16536                 break;
16537         case BT_MODE_BREDR:
16538                 if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
16539                         btd_error(adapter->dev_id,
16540                                 "Ignoring adapter withouth BR/EDR support");
16541                         goto failed;
16542                 }
16543
16544 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16545                 if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16546                         set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16547                 else
16548                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16549 #else
16550                 if (missing_settings & MGMT_SETTING_SSP)
16551                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16552 #endif
16553                 if (missing_settings & MGMT_SETTING_BREDR)
16554                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16555                 if (adapter->current_settings & MGMT_SETTING_LE)
16556                         set_mode(adapter, MGMT_OP_SET_LE, 0x00);
16557                 break;
16558         case BT_MODE_LE:
16559                 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
16560                         btd_error(adapter->dev_id,
16561                                 "Ignoring adapter withouth LE support");
16562                         goto failed;
16563                 }
16564
16565                 if (missing_settings & MGMT_SETTING_LE)
16566                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16567                 if (adapter->current_settings & MGMT_SETTING_BREDR)
16568                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x00);
16569                 break;
16570         }
16571
16572         if (missing_settings & MGMT_SETTING_SECURE_CONN)
16573                 set_mode(adapter, MGMT_OP_SET_SECURE_CONN,
16574                                         btd_opts.secure_conn);
16575
16576         if (adapter->supported_settings & MGMT_SETTING_PRIVACY)
16577                 set_privacy(adapter, btd_opts.privacy);
16578
16579         if (btd_opts.fast_conn &&
16580                         (missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
16581                 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
16582
16583 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16584         /* Set the RPA resolution value to '1' if privacy is supported */
16585         if (btd_opts.le_privacy &&
16586                         adapter->supported_settings & MGMT_SETTING_PRIVACY)
16587                 adapter->central_rpa_res_support = 0x01;
16588 #endif
16589
16590         err = adapter_register(adapter);
16591         if (err < 0) {
16592                 btd_error(adapter->dev_id, "Unable to register new adapter");
16593                 goto failed;
16594         }
16595
16596         /*
16597          * Register all event notification handlers for controller.
16598          *
16599          * The handlers are registered after a succcesful read of the
16600          * controller info. From now on they can track updates and
16601          * notifications.
16602          */
16603         mgmt_register(adapter->mgmt, MGMT_EV_NEW_SETTINGS, adapter->dev_id,
16604                                         new_settings_callback, adapter, NULL);
16605
16606         mgmt_register(adapter->mgmt, MGMT_EV_CLASS_OF_DEV_CHANGED,
16607                                                 adapter->dev_id,
16608                                                 dev_class_changed_callback,
16609                                                 adapter, NULL);
16610         mgmt_register(adapter->mgmt, MGMT_EV_LOCAL_NAME_CHANGED,
16611                                                 adapter->dev_id,
16612                                                 local_name_changed_callback,
16613                                                 adapter, NULL);
16614
16615         mgmt_register(adapter->mgmt, MGMT_EV_DISCOVERING,
16616                                                 adapter->dev_id,
16617                                                 discovering_callback,
16618                                                 adapter, NULL);
16619
16620         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FOUND,
16621                                                 adapter->dev_id,
16622                                                 device_found_callback,
16623                                                 adapter, NULL);
16624
16625 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16626         mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
16627                                                 adapter->dev_id,
16628                                                 le_device_found_callback,
16629                                                 adapter, NULL);
16630 #endif
16631
16632         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_DISCONNECTED,
16633                                                 adapter->dev_id,
16634                                                 disconnected_callback,
16635                                                 adapter, NULL);
16636
16637         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_CONNECTED,
16638                                                 adapter->dev_id,
16639                                                 connected_callback,
16640                                                 adapter, NULL);
16641
16642         mgmt_register(adapter->mgmt, MGMT_EV_CONNECT_FAILED,
16643                                                 adapter->dev_id,
16644                                                 connect_failed_callback,
16645                                                 adapter, NULL);
16646
16647         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNPAIRED,
16648                                                 adapter->dev_id,
16649                                                 unpaired_callback,
16650                                                 adapter, NULL);
16651
16652         mgmt_register(adapter->mgmt, MGMT_EV_AUTH_FAILED,
16653                                                 adapter->dev_id,
16654                                                 auth_failed_callback,
16655                                                 adapter, NULL);
16656
16657         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LINK_KEY,
16658                                                 adapter->dev_id,
16659                                                 new_link_key_callback,
16660                                                 adapter, NULL);
16661
16662         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LONG_TERM_KEY,
16663                                                 adapter->dev_id,
16664                                                 new_long_term_key_callback,
16665                                                 adapter, NULL);
16666
16667         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CSRK,
16668                                                 adapter->dev_id,
16669                                                 new_csrk_callback,
16670                                                 adapter, NULL);
16671
16672         mgmt_register(adapter->mgmt, MGMT_EV_NEW_IRK,
16673                                                 adapter->dev_id,
16674                                                 new_irk_callback,
16675                                                 adapter, NULL);
16676
16677         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CONN_PARAM,
16678                                                 adapter->dev_id,
16679                                                 new_conn_param,
16680                                                 adapter, NULL);
16681
16682         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
16683                                                 adapter->dev_id,
16684                                                 device_blocked_callback,
16685                                                 adapter, NULL);
16686         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNBLOCKED,
16687                                                 adapter->dev_id,
16688                                                 device_unblocked_callback,
16689                                                 adapter, NULL);
16690
16691         mgmt_register(adapter->mgmt, MGMT_EV_PIN_CODE_REQUEST,
16692                                                 adapter->dev_id,
16693                                                 pin_code_request_callback,
16694                                                 adapter, NULL);
16695
16696         mgmt_register(adapter->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
16697                                                 adapter->dev_id,
16698                                                 user_confirm_request_callback,
16699                                                 adapter, NULL);
16700
16701         mgmt_register(adapter->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
16702                                                 adapter->dev_id,
16703                                                 user_passkey_request_callback,
16704                                                 adapter, NULL);
16705
16706         mgmt_register(adapter->mgmt, MGMT_EV_PASSKEY_NOTIFY,
16707                                                 adapter->dev_id,
16708                                                 user_passkey_notify_callback,
16709                                                 adapter, NULL);
16710
16711         mgmt_register(adapter->mgmt, MGMT_EV_CONTROLLER_RESUME,
16712                                                 adapter->dev_id,
16713                                                 controller_resume_callback,
16714                                                 adapter, NULL);
16715
16716 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16717         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
16718                                                 adapter->dev_id,
16719                                                 rssi_alert_callback,
16720                                                 adapter, NULL);
16721
16722         mgmt_register(adapter->mgmt, MGMT_EV_RAW_RSSI,
16723                                                 adapter->dev_id,
16724                                                 get_raw_rssi_callback,
16725                                                 adapter, NULL);
16726
16727         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ENABLED,
16728                                                         adapter->dev_id,
16729                                                         rssi_enabled_callback,
16730                                                         adapter, NULL);
16731
16732         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_DISABLED,
16733                                                         adapter->dev_id,
16734                                                         rssi_disabled_callback,
16735                                                         adapter, NULL);
16736
16737         mgmt_register(adapter->mgmt, MGMT_EV_HARDWARE_ERROR,
16738                                                 adapter->dev_id,
16739                                                 hardware_error_callback,
16740                                                 adapter, NULL);
16741
16742         mgmt_register(adapter->mgmt, MGMT_EV_TX_TIMEOUT_ERROR,
16743                                                 adapter->dev_id,
16744                                                 tx_timeout_error_callback,
16745                                                 adapter, NULL);
16746
16747         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_NAME_UPDATE,
16748                                         adapter->dev_id,
16749                                         device_name_update_callback,
16750                                         adapter, NULL);
16751
16752         mgmt_register(adapter->mgmt, MGMT_EV_MULTI_ADV_STATE_CHANGED,
16753                                         adapter->dev_id,
16754                                         multi_adv_state_change_callback,
16755                                         adapter, NULL);
16756
16757         mgmt_register(adapter->mgmt, MGMT_EV_6LOWPAN_CONN_STATE_CHANGED,
16758                                                 adapter->dev_id,
16759                                                 bt_6lowpan_conn_state_change_callback,
16760                                                 adapter, NULL);
16761
16762         mgmt_register(adapter->mgmt, MGMT_EV_LE_DATA_LENGTH_CHANGED,
16763                                                 adapter->dev_id,
16764                                                 bt_le_data_length_changed_callback,
16765                                                 adapter, NULL);
16766
16767         mgmt_register(adapter->mgmt, MGMT_EV_CONN_UPDATED,
16768                                         adapter->dev_id,
16769                                         le_conn_update_completed_callback,
16770                                         adapter, NULL);
16771
16772         mgmt_register(adapter->mgmt, MGMT_EV_RPA_CHANGED,
16773                                         adapter->dev_id,
16774                                         rpa_changed_callback,
16775                                         adapter, NULL);
16776 #endif
16777
16778         set_dev_class(adapter);
16779
16780         set_name(adapter, btd_adapter_get_name(adapter));
16781
16782         if (btd_has_kernel_features(KERNEL_BLOCKED_KEYS_SUPPORTED) &&
16783                         !set_blocked_keys(adapter)) {
16784                 btd_error(adapter->dev_id,
16785                                 "Failed to set blocked keys for index %u",
16786                                 adapter->dev_id);
16787                 goto failed;
16788         }
16789
16790         if (btd_opts.pairable &&
16791                         !(adapter->current_settings & MGMT_SETTING_BONDABLE))
16792                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
16793
16794         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
16795                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x01);
16796         else if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
16797                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
16798
16799         if (adapter->stored_discoverable && !adapter->discoverable_timeout)
16800                 set_discoverable(adapter, 0x01, 0);
16801
16802         if (btd_adapter_get_powered(adapter))
16803 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16804                 g_idle_add(adapter_start_idle_cb, adapter);
16805 #else
16806                 adapter_start(adapter);
16807 #endif
16808 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16809         else
16810                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
16811 #endif
16812
16813 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16814         init_le_static_address(adapter);
16815 #endif
16816
16817         return;
16818
16819 failed:
16820         /*
16821          * Remove adapter from list in case of a failure.
16822          *
16823          * Leaving an adapter structure around for a controller that can
16824          * not be initilized makes no sense at the moment.
16825          *
16826          * This is a simplification to avoid constant checks if the
16827          * adapter is ready to do anything.
16828          */
16829         adapter_list = g_list_remove(adapter_list, adapter);
16830
16831         btd_adapter_unref(adapter);
16832 }
16833
16834 static void reset_adv_monitors_complete(uint8_t status, uint16_t length,
16835                                         const void *param, void *user_data)
16836 {
16837         const struct mgmt_rp_remove_adv_monitor *rp = param;
16838
16839         if (status != MGMT_STATUS_SUCCESS) {
16840                 error("Failed to reset Adv Monitors: %s (0x%02x)",
16841                         mgmt_errstr(status), status);
16842                 return;
16843         }
16844
16845         if (length < sizeof(*rp)) {
16846                 error("Wrong size of remove Adv Monitor response for reset "
16847                         "all Adv Monitors");
16848                 return;
16849         }
16850
16851         DBG("Removed all Adv Monitors");
16852 }
16853
16854 static void reset_adv_monitors(uint16_t index)
16855 {
16856         struct mgmt_cp_remove_adv_monitor cp;
16857
16858         DBG("sending remove Adv Monitor command with handle 0");
16859
16860         /* Handle 0 indicates to remove all */
16861         cp.monitor_handle = 0;
16862         if (mgmt_send(mgmt_primary, MGMT_OP_REMOVE_ADV_MONITOR, index,
16863                         sizeof(cp), &cp, reset_adv_monitors_complete, NULL,
16864                         NULL) > 0) {
16865                 return;
16866         }
16867
16868         error("Failed to reset Adv Monitors");
16869 }
16870
16871 static void index_added(uint16_t index, uint16_t length, const void *param,
16872                                                         void *user_data)
16873 {
16874         struct btd_adapter *adapter;
16875
16876         DBG("index %u", index);
16877
16878         adapter = btd_adapter_lookup(index);
16879         if (adapter) {
16880                 btd_warn(adapter->dev_id,
16881                         "Ignoring index added for an already existing adapter");
16882                 return;
16883         }
16884
16885         /* Check if at maximum adapters allowed in the system then ignore the
16886          * adapter.
16887          */
16888         if (btd_opts.max_adapters &&
16889                         btd_opts.max_adapters == g_slist_length(adapters))
16890                 return;
16891
16892         reset_adv_monitors(index);
16893
16894         adapter = btd_adapter_new(index);
16895         if (!adapter) {
16896                 btd_error(index,
16897                         "Unable to create new adapter for index %u", index);
16898                 return;
16899         }
16900
16901         if (btd_has_kernel_features(KERNEL_EXP_FEATURES))
16902                 read_exp_features(adapter);
16903
16904         /*
16905          * Protect against potential two executions of read controller info.
16906          *
16907          * In case the start of the daemon and the action of adding a new
16908          * controller coincide this function might be called twice.
16909          *
16910          * To avoid the double execution of reading the controller info,
16911          * add the adapter already to the list. If an adapter is already
16912          * present, the second notification will cause a warning. If the
16913          * command fails the adapter is removed from the list again.
16914          */
16915         adapter_list = g_list_append(adapter_list, adapter);
16916
16917         DBG("sending read info command for index %u", index);
16918
16919         if (mgmt_send(mgmt_primary, MGMT_OP_READ_INFO, index, 0, NULL,
16920                                         read_info_complete, adapter, NULL) > 0)
16921                 return;
16922
16923         btd_error(adapter->dev_id,
16924                         "Failed to read controller info for index %u", index);
16925
16926         adapter_list = g_list_remove(adapter_list, adapter);
16927
16928         btd_adapter_unref(adapter);
16929 }
16930
16931 static void index_removed(uint16_t index, uint16_t length, const void *param,
16932                                                         void *user_data)
16933 {
16934         struct btd_adapter *adapter;
16935
16936         DBG("index %u", index);
16937
16938         adapter = btd_adapter_lookup(index);
16939         if (!adapter) {
16940                 warn("Ignoring index removal for a non-existent adapter");
16941                 return;
16942         }
16943
16944         adapter_unregister(adapter);
16945 }
16946
16947 static void read_index_list_complete(uint8_t status, uint16_t length,
16948                                         const void *param, void *user_data)
16949 {
16950         const struct mgmt_rp_read_index_list *rp = param;
16951         uint16_t num;
16952         int i;
16953
16954         if (status != MGMT_STATUS_SUCCESS) {
16955                 error("Failed to read index list: %s (0x%02x)",
16956                                                 mgmt_errstr(status), status);
16957                 return;
16958         }
16959
16960         if (length < sizeof(*rp)) {
16961                 error("Wrong size of read index list response");
16962                 return;
16963         }
16964
16965         num = btohs(rp->num_controllers);
16966
16967         DBG("Number of controllers: %d", num);
16968
16969         if (num * sizeof(uint16_t) + sizeof(*rp) != length) {
16970                 error("Incorrect packet size for index list response");
16971                 return;
16972         }
16973
16974         for (i = 0; i < num; i++) {
16975                 uint16_t index;
16976
16977                 index = btohs(rp->index[i]);
16978
16979                 DBG("Found index %u", index);
16980
16981                 /*
16982                  * Pretend to be index added event notification.
16983                  *
16984                  * It is safe to just trigger the procedure for index
16985                  * added notification. It does check against itself.
16986                  */
16987                 index_added(index, 0, NULL, NULL);
16988         }
16989 }
16990
16991 static void read_commands_complete(uint8_t status, uint16_t length,
16992                                         const void *param, void *user_data)
16993 {
16994         const struct mgmt_rp_read_commands *rp = param;
16995         uint16_t num_commands, num_events;
16996         size_t expected_len;
16997         int i;
16998
16999         if (status != MGMT_STATUS_SUCCESS) {
17000                 error("Failed to read supported commands: %s (0x%02x)",
17001                                                 mgmt_errstr(status), status);
17002                 return;
17003         }
17004
17005         if (length < sizeof(*rp)) {
17006                 error("Wrong size of read commands response");
17007                 return;
17008         }
17009
17010         num_commands = btohs(rp->num_commands);
17011         num_events = btohs(rp->num_events);
17012
17013         DBG("Number of commands: %d", num_commands);
17014         DBG("Number of events: %d", num_events);
17015
17016         expected_len = sizeof(*rp) + num_commands * sizeof(uint16_t) +
17017                                                 num_events * sizeof(uint16_t);
17018
17019         if (length < expected_len) {
17020                 error("Too small reply for supported commands: (%u != %zu)",
17021                                                         length, expected_len);
17022                 return;
17023         }
17024
17025         for (i = 0; i < num_commands; i++) {
17026                 uint16_t op = get_le16(rp->opcodes + i);
17027
17028                 switch (op) {
17029                 case MGMT_OP_ADD_DEVICE:
17030                         DBG("enabling kernel-side connection control");
17031                         kernel_features |= KERNEL_CONN_CONTROL;
17032                         break;
17033                 case MGMT_OP_SET_BLOCKED_KEYS:
17034                         DBG("kernel supports the set_blocked_keys op");
17035                         kernel_features |= KERNEL_BLOCKED_KEYS_SUPPORTED;
17036                         break;
17037                 case MGMT_OP_SET_DEF_SYSTEM_CONFIG:
17038                         DBG("kernel supports set system confic");
17039                         kernel_features |= KERNEL_SET_SYSTEM_CONFIG;
17040                         break;
17041                 case MGMT_OP_READ_EXP_FEATURES_INFO:
17042                         DBG("kernel supports exp features");
17043                         kernel_features |= KERNEL_EXP_FEATURES;
17044                         break;
17045                 case MGMT_OP_ADD_EXT_ADV_PARAMS:
17046                         DBG("kernel supports ext adv commands");
17047                         kernel_features |= KERNEL_HAS_EXT_ADV_ADD_CMDS;
17048                         break;
17049                 case MGMT_OP_READ_CONTROLLER_CAP:
17050                         DBG("kernel supports controller cap command");
17051                         kernel_features |= KERNEL_HAS_CONTROLLER_CAP_CMD;
17052                         break;
17053                 default:
17054                         break;
17055                 }
17056         }
17057
17058         for (i = 0; i < num_events; i++) {
17059                 uint16_t ev = get_le16(rp->opcodes + num_commands + i);
17060
17061                 switch(ev) {
17062                 case MGMT_EV_CONTROLLER_RESUME:
17063                         DBG("kernel supports suspend/resume events");
17064                         kernel_features |= KERNEL_HAS_RESUME_EVT;
17065                         break;
17066                 }
17067         }
17068 }
17069
17070 static void read_version_complete(uint8_t status, uint16_t length,
17071                                         const void *param, void *user_data)
17072 {
17073         const struct mgmt_rp_read_version *rp = param;
17074
17075         if (status != MGMT_STATUS_SUCCESS) {
17076                 error("Failed to read version information: %s (0x%02x)",
17077                                                 mgmt_errstr(status), status);
17078                 return;
17079         }
17080
17081         if (length < sizeof(*rp)) {
17082                 error("Wrong size of read version response");
17083                 return;
17084         }
17085
17086         mgmt_version = rp->version;
17087         mgmt_revision = btohs(rp->revision);
17088
17089         info("Bluetooth management interface %u.%u initialized",
17090                                                 mgmt_version, mgmt_revision);
17091
17092         if (mgmt_version < 1) {
17093                 error("Version 1.0 or later of management interface required");
17094                 abort();
17095         }
17096
17097         DBG("sending read supported commands command");
17098
17099         /*
17100          * It is irrelevant if this command succeeds or fails. In case of
17101          * failure safe settings are assumed.
17102          */
17103         mgmt_send(mgmt_primary, MGMT_OP_READ_COMMANDS,
17104                                 MGMT_INDEX_NONE, 0, NULL,
17105                                 read_commands_complete, NULL, NULL);
17106
17107         mgmt_register(mgmt_primary, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
17108                                                 index_added, NULL, NULL);
17109         mgmt_register(mgmt_primary, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
17110                                                 index_removed, NULL, NULL);
17111
17112         DBG("sending read index list command");
17113
17114         if (mgmt_send(mgmt_primary, MGMT_OP_READ_INDEX_LIST,
17115                                 MGMT_INDEX_NONE, 0, NULL,
17116                                 read_index_list_complete, NULL, NULL) > 0)
17117                 return;
17118
17119         error("Failed to read controller index list");
17120 }
17121
17122 static void mgmt_debug(const char *str, void *user_data)
17123 {
17124         DBG_IDX(0xffff, "%s", str);
17125 }
17126
17127 int adapter_init(void)
17128 {
17129         dbus_conn = btd_get_dbus_connection();
17130
17131         mgmt_primary = mgmt_new_default();
17132         if (!mgmt_primary) {
17133                 error("Failed to access management interface");
17134                 return -EIO;
17135         }
17136
17137         mgmt_set_debug(mgmt_primary, mgmt_debug, NULL, NULL);
17138
17139         DBG("sending read version command");
17140
17141         if (mgmt_send(mgmt_primary, MGMT_OP_READ_VERSION,
17142                                 MGMT_INDEX_NONE, 0, NULL,
17143                                 read_version_complete, NULL, NULL) > 0)
17144                 return 0;
17145
17146         error("Failed to read management version information");
17147
17148         return -EIO;
17149 }
17150
17151 void adapter_cleanup(void)
17152 {
17153         g_list_free(adapter_list);
17154
17155         while (adapters) {
17156                 struct btd_adapter *adapter = adapters->data;
17157
17158                 adapter_remove(adapter);
17159                 adapters = g_slist_remove(adapters, adapter);
17160                 btd_adapter_unref(adapter);
17161         }
17162
17163         /*
17164          * In case there is another reference active, clear out
17165          * registered handlers for index added and index removed.
17166          *
17167          * This is just an extra precaution to be safe, and in
17168          * reality should not make a difference.
17169          */
17170         mgmt_unregister_index(mgmt_primary, MGMT_INDEX_NONE);
17171
17172         /*
17173          * In case there is another reference active, cancel
17174          * all pending global commands.
17175          *
17176          * This is just an extra precaution to avoid callbacks
17177          * that potentially then could leak memory or access
17178          * an invalid structure.
17179          */
17180         mgmt_cancel_index(mgmt_primary, MGMT_INDEX_NONE);
17181
17182         mgmt_unref(mgmt_primary);
17183         mgmt_primary = NULL;
17184
17185         dbus_conn = NULL;
17186 }
17187
17188 void adapter_shutdown(void)
17189 {
17190         GList *list;
17191
17192         DBG("");
17193
17194         powering_down = true;
17195
17196         for (list = g_list_first(adapter_list); list;
17197                                                 list = g_list_next(list)) {
17198                 struct btd_adapter *adapter = list->data;
17199
17200                 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
17201                         continue;
17202
17203                 clear_discoverable(adapter);
17204                 remove_temporary_devices(adapter);
17205                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x00);
17206
17207                 adapter_remaining++;
17208         }
17209
17210         if (!adapter_remaining)
17211                 btd_exit();
17212 }
17213
17214 /*
17215  * Check if workaround for broken ATT server socket behavior is needed
17216  * where we need to connect an ATT client socket before pairing to get
17217  * early access to the ATT channel.
17218  */
17219 bool btd_le_connect_before_pairing(void)
17220 {
17221         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 4))
17222                 return true;
17223
17224         return false;
17225 }
17226
17227 bool btd_adapter_has_settings(struct btd_adapter *adapter, uint32_t settings)
17228 {
17229         if (!adapter)
17230                 return false;
17231
17232         return (adapter->current_settings & settings) ? true : false;
17233 }
17234
17235 bool btd_has_kernel_features(uint32_t features)
17236 {
17237         return !!(kernel_features & features);
17238 }
17239
17240 bool btd_adapter_has_exp_feature(struct btd_adapter *adapter, uint32_t feature)
17241 {
17242         size_t i;
17243
17244         for (i = 0; i < ARRAY_SIZE(exp_table); i++) {
17245                 const struct exp_feat *feat = &exp_table[i];
17246
17247                 if ((feat->flag & feature) && queue_find(adapter->exps, NULL,
17248                                                         feat->uuid->val))
17249                 return true;
17250         }
17251
17252         return false;
17253 }
17254
17255 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
17256 int btd_adapter_set_streaming_mode(struct btd_adapter *adapter,
17257                                    const bdaddr_t *bdaddr, gboolean enable)
17258 {
17259         struct mgmt_cp_set_streaming_mode cp;
17260         char addr[18];
17261
17262         ba2str(bdaddr, addr);
17263         DBG("hci%u device %s", adapter->dev_id, addr);
17264
17265         memset(&cp, 0, sizeof(cp));
17266
17267         cp.streaming_mode = enable ? 1 : 0;
17268         bacpy(&cp.bdaddr, bdaddr);
17269
17270         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STREAMING_MODE,
17271                                         adapter->dev_id, sizeof(cp), &cp,
17272                                         NULL, NULL, NULL) > 0)
17273                 return 0;
17274
17275         return -EIO;
17276 }
17277
17278 void adapter_send_event(const char *event)
17279 {
17280         struct btd_adapter *adapter = btd_adapter_get_default();
17281         if (adapter == NULL) {
17282                 error("adapter is NULL");
17283                 return;
17284         }
17285
17286         g_dbus_emit_signal(dbus_conn, adapter->path,
17287                         ADAPTER_INTERFACE, event,
17288                         DBUS_TYPE_INVALID);
17289 }
17290
17291 #endif