src/adapter.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <inttypes.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <stdbool.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/file.h>
  37 #include <sys/stat.h>
  38 #include <dirent.h>
  39
  40 #include <glib.h>
  41 #include <dbus/dbus.h>
  42
  43 #include "bluetooth/bluetooth.h"
  44 #include "bluetooth/hci.h"
  45 #include "bluetooth/hci_lib.h"
  46 #include "bluetooth/sdp.h"
  47 #include "bluetooth/sdp_lib.h"
  48 #include "lib/uuid.h"
  49 #include "lib/mgmt.h"
  50
  51 #include "gdbus/gdbus.h"
  52
  53 #include "log.h"
  54 #include "textfile.h"
  55
  56 #include "src/shared/mgmt.h"
  57 #include "src/shared/util.h"
  58 #include "src/shared/queue.h"
  59 #include "src/shared/att.h"
  60 #include "src/shared/gatt-db.h"
  61
  62 #include "hcid.h"
  63 #include "sdpd.h"
  64 #include "adapter.h"
  65 #include "device.h"
  66 #include "profile.h"
  67 #include "dbus-common.h"
  68 #include "error.h"
  69 #include "uuid-helper.h"
  70 #include "agent.h"
  71 #include "storage.h"
  72 #include "attrib/gattrib.h"
  73 #include "attrib/att.h"
  74 #include "attrib/gatt.h"
  75 #include "attrib-server.h"
  76 #include "gatt-database.h"
  77 #include "advertising.h"
  78 #include "eir.h"
  79
  80 #ifdef __TIZEN_PATCH__
  81 #include "adapter_le_vsc_features.h"
  82 #endif
  83
  84 #define ADAPTER_INTERFACE       "org.bluez.Adapter1"
  85
  86 #ifdef __TIZEN_PATCH__
  87 #ifdef TIZEN_WEARABLE
  88 #define DEVICED_DEST                    "org.tizen.system.deviced"
  89 #define DEVICED_BATT_INTERFACE          "org.tizen.system.deviced.Battery"
  90 #define DEVICED_BATT_OBJECT_PATH        "/Org/Tizen/System/DeviceD/Battery"
  91 #endif  /* TIZEN_WEARABLE */
  92 #endif
  93
  94 #define MODE_OFF                0x00
  95 #define MODE_CONNECTABLE        0x01
  96 #define MODE_DISCOVERABLE       0x02
  97 #define MODE_UNKNOWN            0xff
  98
  99 #define CONN_SCAN_TIMEOUT (3)
 100 #define IDLE_DISCOV_TIMEOUT (5)
 101 #define TEMP_DEV_TIMEOUT (3 * 60)
 102 #define BONDING_TIMEOUT (2 * 60)
 103
 104 #define SCAN_TYPE_BREDR (1 << BDADDR_BREDR)
 105 #define SCAN_TYPE_LE ((1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM))
 106 #define SCAN_TYPE_DUAL (SCAN_TYPE_BREDR | SCAN_TYPE_LE)
 107
 108 #define HCI_RSSI_INVALID        127
 109 #define DISTANCE_VAL_INVALID    0x7FFF
 110 #define PATHLOSS_MAX            137
 111
 112 #ifdef __TIZEN_PATCH__
 113 #define check_address(address) bachk(address)
 114 #define ADV_DATA_MAX_LENGTH 31
 115 #define SCAN_RESPONSE_DATA_LENGTH_MAX 31
 116 #define MANUFACTURER_DATA_LENGTH_MAX 28
 117 #define PRIVATE_ADDR_TIMEOUT (15 * 60)
 118
 119 #define BT_DISC_TYPE_BREDR      1
 120 #define BT_DISC_TYPE_LE  2
 121 #define IDLE_LE_DISCOV_TIMEOUT (3)
 122
 123 #define DISCOV_TYPE_BREDR       1
 124 #define DISCOV_TYPE_LE  6
 125
 126 #endif /* __TIZEN_PATCH__ */
 127
 128
 129 static DBusConnection *dbus_conn = NULL;
 130
 131 static bool kernel_conn_control = false;
 132
 133 static GList *adapter_list = NULL;
 134 static unsigned int adapter_remaining = 0;
 135 static bool powering_down = false;
 136
 137 static GSList *adapters = NULL;
 138
 139 static struct mgmt *mgmt_master = NULL;
 140
 141 static uint8_t mgmt_version = 0;
 142 static uint8_t mgmt_revision = 0;
 143
 144 static GSList *adapter_drivers = NULL;
 145
 146 static GSList *disconnect_list = NULL;
 147 static GSList *conn_fail_list = NULL;
 148
 149 struct link_key_info {
 150         bdaddr_t bdaddr;
 151         unsigned char key[16];
 152         uint8_t type;
 153         uint8_t pin_len;
 154 };
 155
 156 struct smp_ltk_info {
 157         bdaddr_t bdaddr;
 158         uint8_t bdaddr_type;
 159         uint8_t authenticated;
 160         bool master;
 161         uint8_t enc_size;
 162         uint16_t ediv;
 163         uint64_t rand;
 164         uint8_t val[16];
 165 };
 166
 167 struct irk_info {
 168         bdaddr_t bdaddr;
 169         uint8_t bdaddr_type;
 170         uint8_t val[16];
 171 };
 172
 173 struct conn_param {
 174         bdaddr_t bdaddr;
 175         uint8_t  bdaddr_type;
 176         uint16_t min_interval;
 177         uint16_t max_interval;
 178         uint16_t latency;
 179         uint16_t timeout;
 180 };
 181
 182 struct discovery_filter {
 183         uint8_t type;
 184         uint16_t pathloss;
 185         int16_t rssi;
 186         GSList *uuids;
 187 };
 188
 189 struct watch_client {
 190         struct btd_adapter *adapter;
 191         char *owner;
 192         guint watch;
 193         struct discovery_filter *discovery_filter;
 194 };
 195
 196 struct service_auth {
 197         guint id;
 198         unsigned int svc_id;
 199         service_auth_cb cb;
 200         void *user_data;
 201         const char *uuid;
 202         struct btd_device *device;
 203         struct btd_adapter *adapter;
 204         struct agent *agent;            /* NULL for queued auths */
 205 };
 206
 207 struct btd_adapter_pin_cb_iter {
 208         GSList *it;                     /* current callback function */
 209         unsigned int attempt;           /* numer of times it() was called */
 210         /* When the iterator reaches the end, it is NULL and attempt is 0 */
 211 };
 212
 213 #ifdef __TIZEN_PATCH__
 214 struct adv_info {
 215         int slot_id;    /* Reservied slot id is 0 (Single adv) */
 216         bool status;            /* Advertising status */
 217 };
 218
 219 static GSList *read_requests = NULL;
 220
 221 struct le_data_length_read_request {
 222         struct btd_adapter *adapter;
 223         DBusMessage *msg;
 224 };
 225 #endif
 226
 227 struct btd_adapter {
 228         int ref_count;
 229
 230         uint16_t dev_id;
 231         struct mgmt *mgmt;
 232
 233         bdaddr_t bdaddr;                /* controller Bluetooth address */
 234 #ifdef __TIZEN_PATCH__
 235         bdaddr_t le_static_addr;
 236         bdaddr_t rpaddr;                /* controller RPA */
 237 #endif
 238         uint32_t dev_class;             /* controller class of device */
 239         char *name;                     /* controller device name */
 240         char *short_name;               /* controller short name */
 241         uint32_t supported_settings;    /* controller supported settings */
 242         uint32_t current_settings;      /* current controller settings */
 243
 244         char *path;                     /* adapter object path */
 245         uint8_t major_class;            /* configured major class */
 246         uint8_t minor_class;            /* configured minor class */
 247         char *system_name;              /* configured system name */
 248         char *modalias;                 /* device id (modalias) */
 249         bool stored_discoverable;       /* stored discoverable mode */
 250         uint32_t discoverable_timeout;  /* discoverable time(sec) */
 251         uint32_t pairable_timeout;      /* pairable time(sec) */
 252
 253         char *current_alias;            /* current adapter name alias */
 254         char *stored_alias;             /* stored adapter name alias */
 255 #ifdef __TIZEN_PATCH__
 256         bool le_privacy_enabled;        /* whether LE Privacy feature enabled */
 257         char local_irk[MGMT_IRK_SIZE];  /* adapter local IRK */
 258         uint8_t disc_type;
 259         bool ipsp_intialized;           /* Ipsp Initialization state */
 260         struct le_data_length_read_handler *read_handler;
 261         struct le_data_length_read_default_data_length_handler *def_read_handler;
 262 #ifdef TIZEN_WEARABLE
 263         guint charging_watch;
 264         guint charging_timeout;
 265         charging_state_e charging;
 266 #endif  /* TIZEN_WEARABLE */
 267 #endif
 268
 269         bool discovering;               /* discovering property state */
 270         bool filtered_discovery;        /* we are doing filtered discovery */
 271         bool no_scan_restart_delay;     /* when this flag is set, restart scan
 272                                          * without delay */
 273         uint8_t discovery_type;         /* current active discovery type */
 274         uint8_t discovery_enable;       /* discovery enabled/disabled */
 275         bool discovery_suspended;       /* discovery has been suspended */
 276         GSList *discovery_list;         /* list of discovery clients */
 277         GSList *set_filter_list;        /* list of clients that specified
 278                                          * filter, but don't scan yet
 279                                          */
 280         /* current discovery filter, if any */
 281         struct mgmt_cp_start_service_discovery *current_discovery_filter;
 282
 283         GSList *discovery_found;        /* list of found devices */
 284         guint discovery_idle_timeout;   /* timeout between discovery runs */
 285         guint passive_scan_timeout;     /* timeout between passive scans */
 286         guint temp_devices_timeout;     /* timeout for temporary devices */
 287
 288         guint pairable_timeout_id;      /* pairable timeout id */
 289         guint auth_idle_id;             /* Pending authorization dequeue */
 290         GQueue *auths;                  /* Ongoing and pending auths */
 291         bool pincode_requested;         /* PIN requested during last bonding */
 292         GSList *connections;            /* Connected devices */
 293         GSList *devices;                /* Devices structure pointers */
 294         GSList *connect_list;           /* Devices to connect when found */
 295         struct btd_device *connect_le;  /* LE device waiting to be connected */
 296         sdp_list_t *services;           /* Services associated to adapter */
 297
 298         struct btd_gatt_database *database;
 299         struct btd_advertising *adv_manager;
 300
 301         gboolean initialized;
 302 #ifdef __TIZEN_PATCH__
 303         GSList *adv_list;       /* List of advertising instance */
 304         bool advertising;               /* Advertising active */
 305         gchar *version;                 /* Bluetooth Version */
 306 #if 0 // Not used
 307         bool secure_connection;         /* Secure Connection active*/
 308         uint16_t auth_payload_timeout; /* Authenticated payload timeout value*/
 309
 310         bool set_new_rpa;               /* RPA to be set */
 311         bool rpa_is_set;                /* RPA is set */
 312 #endif
 313
 314         uint8_t adv_tx_power;
 315
 316         bool le_discovering;                    /* LE Discovery active */
 317         GSList *le_discovery_list;              /* list of LE discovery clients */
 318         gboolean le_auto_connect;               /* LE Auto connection */
 319 #endif
 320
 321         GSList *pin_callbacks;
 322         GSList *msd_callbacks;
 323
 324         GSList *drivers;
 325         GSList *profiles;
 326
 327         struct oob_handler *oob_handler;
 328
 329         unsigned int load_ltks_id;
 330         guint load_ltks_timeout;
 331
 332         unsigned int confirm_name_id;
 333         guint confirm_name_timeout;
 334
 335         unsigned int pair_device_id;
 336         guint pair_device_timeout;
 337
 338         unsigned int db_id;             /* Service event handler for GATT db */
 339 #ifdef __TIZEN_PATCH__
 340         guint private_addr_timeout;
 341         uint8_t central_rpa_res_support;
 342 #endif
 343         bool is_default;                /* true if adapter is default one */
 344 };
 345
 346
 347 #ifdef __TIZEN_PATCH__
 348 enum {
 349         DISABLE_PRIVACY,
 350         ENABLE_PRIVACY,
 351         GEN_IRK_THEN_ENABLE_PRIVACY
 352 };
 353
 354 enum {
 355         DEINIT_6LOWPAN,
 356         INIT_6LOWPAN
 357 };
 358 #endif
 359
 360 static struct btd_adapter *btd_adapter_lookup(uint16_t index)
 361 {
 362         GList *list;
 363
 364         for (list = g_list_first(adapter_list); list;
 365                                                 list = g_list_next(list)) {
 366                 struct btd_adapter *adapter = list->data;
 367
 368                 if (adapter->dev_id == index)
 369                         return adapter;
 370         }
 371
 372         return NULL;
 373 }
 374
 375 struct btd_adapter *btd_adapter_get_default(void)
 376 {
 377         GList *list;
 378
 379         for (list = g_list_first(adapter_list); list;
 380                                                 list = g_list_next(list)) {
 381                 struct btd_adapter *adapter = list->data;
 382
 383                 if (adapter->is_default)
 384                         return adapter;
 385         }
 386
 387         return NULL;
 388 }
 389
 390 bool btd_adapter_is_default(struct btd_adapter *adapter)
 391 {
 392         if (!adapter)
 393                 return false;
 394
 395         return adapter->is_default;
 396 }
 397
 398 uint16_t btd_adapter_get_index(struct btd_adapter *adapter)
 399 {
 400         if (!adapter)
 401                 return MGMT_INDEX_NONE;
 402
 403         return adapter->dev_id;
 404 }
 405
 406 static gboolean process_auth_queue(gpointer user_data);
 407
 408 static void dev_class_changed_callback(uint16_t index, uint16_t length,
 409                                         const void *param, void *user_data)
 410 {
 411         struct btd_adapter *adapter = user_data;
 412         const struct mgmt_cod *rp = param;
 413         uint32_t dev_class;
 414
 415         if (length < sizeof(*rp)) {
 416                 btd_error(adapter->dev_id,
 417                         "Wrong size of class of device changed parameters");
 418                 return;
 419         }
 420
 421         dev_class = rp->val[0] | (rp->val[1] << 8) | (rp->val[2] << 16);
 422
 423         if (dev_class == adapter->dev_class)
 424                 return;
 425
 426         DBG("Class: 0x%06x", dev_class);
 427
 428         adapter->dev_class = dev_class;
 429
 430         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 431                                                 ADAPTER_INTERFACE, "Class");
 432 }
 433
 434 static void set_dev_class_complete(uint8_t status, uint16_t length,
 435                                         const void *param, void *user_data)
 436 {
 437         struct btd_adapter *adapter = user_data;
 438
 439         if (status != MGMT_STATUS_SUCCESS) {
 440                 btd_error(adapter->dev_id,
 441                                 "Failed to set device class: %s (0x%02x)",
 442                                                 mgmt_errstr(status), status);
 443                 return;
 444         }
 445
 446         /*
 447          * The parameters are identical and also the task that is
 448          * required in both cases. So it is safe to just call the
 449          * event handling functions here.
 450          */
 451         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
 452 }
 453
 454 static void set_dev_class(struct btd_adapter *adapter)
 455 {
 456         struct mgmt_cp_set_dev_class cp;
 457
 458         /*
 459          * If the controller does not support BR/EDR operation,
 460          * there is no point in trying to set a major and minor
 461          * class value.
 462          *
 463          * This is an optimization for Low Energy only controllers.
 464          */
 465         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
 466                 return;
 467
 468         memset(&cp, 0, sizeof(cp));
 469
 470         /*
 471          * Silly workaround for a really stupid kernel bug :(
 472          *
 473          * All current kernel versions assign the major and minor numbers
 474          * straight to dev_class[0] and dev_class[1] without considering
 475          * the proper bit shifting.
 476          *
 477          * To make this work, shift the value in userspace for now until
 478          * we get a fixed kernel version.
 479          */
 480         cp.major = adapter->major_class & 0x1f;
 481         cp.minor = adapter->minor_class << 2;
 482
 483         DBG("sending set device class command for index %u", adapter->dev_id);
 484
 485         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_CLASS,
 486                                 adapter->dev_id, sizeof(cp), &cp,
 487                                 set_dev_class_complete, adapter, NULL) > 0)
 488                 return;
 489
 490         btd_error(adapter->dev_id,
 491                 "Failed to set class of device for index %u", adapter->dev_id);
 492 }
 493
 494 void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
 495                                                         uint8_t minor)
 496 {
 497         if (adapter->major_class == major && adapter->minor_class == minor)
 498                 return;
 499
 500         DBG("class: major %u minor %u", major, minor);
 501
 502         adapter->major_class = major;
 503         adapter->minor_class = minor;
 504
 505         set_dev_class(adapter);
 506 }
 507
 508 static uint8_t get_mode(const char *mode)
 509 {
 510         if (strcasecmp("off", mode) == 0)
 511                 return MODE_OFF;
 512         else if (strcasecmp("connectable", mode) == 0)
 513                 return MODE_CONNECTABLE;
 514         else if (strcasecmp("discoverable", mode) == 0)
 515                 return MODE_DISCOVERABLE;
 516         else
 517                 return MODE_UNKNOWN;
 518 }
 519
 520 static void store_adapter_info(struct btd_adapter *adapter)
 521 {
 522         GKeyFile *key_file;
 523         char filename[PATH_MAX];
 524         char address[18];
 525         char *str;
 526         gsize length = 0;
 527         gboolean discoverable;
 528 #ifdef __TIZEN_PATCH__
 529         char key_str[35];
 530         static const char testblock[MGMT_IRK_SIZE];
 531         int i;
 532 #endif
 533
 534         key_file = g_key_file_new();
 535
 536         if (adapter->pairable_timeout != main_opts.pairto)
 537                 g_key_file_set_integer(key_file, "General", "PairableTimeout",
 538                                         adapter->pairable_timeout);
 539
 540         if ((adapter->current_settings & MGMT_SETTING_DISCOVERABLE) &&
 541                                                 !adapter->discoverable_timeout)
 542                 discoverable = TRUE;
 543         else
 544                 discoverable = FALSE;
 545
 546         g_key_file_set_boolean(key_file, "General", "Discoverable",
 547                                                         discoverable);
 548
 549         if (adapter->discoverable_timeout != main_opts.discovto)
 550                 g_key_file_set_integer(key_file, "General",
 551                                         "DiscoverableTimeout",
 552                                         adapter->discoverable_timeout);
 553
 554         if (adapter->stored_alias)
 555                 g_key_file_set_string(key_file, "General", "Alias",
 556                                                         adapter->stored_alias);
 557 #ifdef __TIZEN_PATCH__
 558         if (memcmp(adapter->local_irk, testblock , MGMT_IRK_SIZE)) {
 559                 key_str[0] = '0';
 560                 key_str[1] = 'x';
 561                 for (i = 0; i < MGMT_IRK_SIZE; i++)
 562                         sprintf(key_str + 2 + (i * 2), "%2.2X",
 563                         adapter->local_irk[i]);
 564                 g_key_file_set_string(key_file, "General",
 565                         "LocalIrk", key_str);
 566         }
 567 #endif
 568
 569         ba2str(&adapter->bdaddr, address);
 570         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/settings", address);
 571
 572         create_file(filename, S_IRUSR | S_IWUSR);
 573
 574         str = g_key_file_to_data(key_file, &length, NULL);
 575         g_file_set_contents(filename, str, length, NULL);
 576         g_free(str);
 577
 578         g_key_file_free(key_file);
 579 }
 580
 581 static void trigger_pairable_timeout(struct btd_adapter *adapter);
 582 static void adapter_start(struct btd_adapter *adapter);
 583 static void adapter_stop(struct btd_adapter *adapter);
 584 static void trigger_passive_scanning(struct btd_adapter *adapter);
 585 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
 586                                                         uint8_t mode);
 587 #ifdef __TIZEN_PATCH__
 588 static bool set_privacy(struct btd_adapter *adapter, bool privacy);
 589 #endif
 590
 591 #ifdef __TIZEN_PATCH__
 592 #ifdef TIZEN_WEARABLE
 593 static gboolean charging_state_timeout_cb(gpointer user_data)
 594 {
 595         struct btd_adapter *adapter = user_data;
 596         int bredr_pkt_type = ACL_PTYPE_MASK;
 597
 598         adapter->charging_timeout = 0;
 599
 600         DBG("Set all connections to BR/EDR type");
 601         g_slist_foreach(adapter->devices, device_change_pkt_type,
 602                         (gpointer)bredr_pkt_type);
 603
 604         return FALSE;
 605 }
 606
 607 static void set_charging_state(struct btd_adapter *adapter,
 608                 charging_state_e state)
 609 {
 610         int br_pkt_type = ACL_PTYPE_MASK |
 611                 HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
 612                 HCI_3DH1 | HCI_3DH3 | HCI_3DH5;
 613
 614         if (adapter->charging == state)
 615                 return;
 616
 617         DBG("old charging state : %d, new charging_state : %d",
 618                         adapter->charging, state);
 619
 620         /*
 621          * Only none / wire charging <-> wireless charging state change should
 622          * be handled.
 623          */
 624         if ((adapter->charging == NONE_CHARGING && state == WIRE_CHARGING) ||
 625             (adapter->charging == WIRE_CHARGING && state == NONE_CHARGING)) {
 626                 DBG("Just update charging state");
 627                 adapter->charging = state;
 628                 return;
 629         }
 630
 631         if (adapter->charging_timeout) {
 632                 g_source_remove(adapter->charging_timeout);
 633                 adapter->charging_timeout = 0;
 634         }
 635
 636         adapter->charging = state;
 637         if (adapter->charging == NONE_CHARGING ||
 638             adapter->charging == WIRE_CHARGING) {
 639                 DBG("Trigger timeout to set connection to BR/EDR type");
 640                 adapter->charging_timeout = g_timeout_add(2000,
 641                                 charging_state_timeout_cb, adapter);
 642         } else if (adapter->charging == WIRELESS_CHARGING) {
 643                 DBG("Set all connections to BR type");
 644                 g_slist_foreach(adapter->devices, device_change_pkt_type,
 645                                 (gpointer)br_pkt_type);
 646         }
 647
 648         return;
 649 }
 650
 651 static gboolean charging_state_changed(DBusConnection *connection,
 652                 DBusMessage *msg, void *user_data)
 653 {
 654         struct btd_adapter *adapter = user_data;
 655         int state = 0;
 656
 657         DBG("charging_state_changed");
 658
 659         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &state,
 660                                 DBUS_TYPE_INVALID))
 661                 return TRUE;
 662
 663         set_charging_state(adapter, state);
 664
 665         return TRUE;
 666 }
 667
 668 charging_state_e get_charging_state(struct btd_adapter *adapter)
 669 {
 670         DBG("charging_state: %d", adapter->charging);
 671         return adapter->charging;
 672 }
 673 #endif  /* TIZEN_WEARABLE */
 674
 675 static int compare_slot(gconstpointer a, gconstpointer b)
 676 {
 677         const struct adv_info *adv = a;
 678         const int id = *(int*)b;
 679
 680         return (adv->slot_id == id ? 0 : -1);
 681 }
 682
 683 static struct adv_info *find_advertiser(struct btd_adapter *adapter,
 684                                 int slot_id)
 685 {
 686         GSList *list;
 687
 688         list = g_slist_find_custom(adapter->adv_list, &slot_id,
 689                                                         compare_slot);
 690         if (list)
 691                 return list->data;
 692
 693         return NULL;
 694 }
 695
 696 static void create_advertiser(struct btd_adapter *adapter,
 697                                         int slot_id)
 698 {
 699         struct adv_info *adv;
 700
 701         if (!adapter)
 702                 return;
 703
 704         if (find_advertiser(adapter, slot_id) != NULL) {
 705                 error("Aleady existed [%d]", slot_id);
 706                 return;
 707         }
 708
 709         DBG("Create adv slot id : %d", slot_id);
 710
 711         adv = g_new0(struct adv_info, 1);
 712         if (adv == NULL)
 713                 return;
 714
 715         adv->slot_id = slot_id;
 716
 717         adapter->adv_list= g_slist_append(adapter->adv_list, adv);
 718         return;
 719 }
 720
 721
 722 static void advertising_state_changed(struct btd_adapter *adapter,
 723                                         int slot_id, bool enabled)
 724 {
 725         struct adv_info *adv;
 726         int id = slot_id;
 727         int state = enabled;
 728
 729         if (!adapter)
 730                 return;
 731
 732         adv = find_advertiser(adapter, slot_id);
 733         if (!adv) {
 734                 DBG("Unable to find advertiser [%d]", slot_id);
 735                 return;
 736         }
 737
 738         adv->status = enabled;
 739         DBG("slot_id %d, status %d", adv->slot_id, adv->status);
 740
 741         g_dbus_emit_signal(dbus_conn, adapter->path,
 742                         ADAPTER_INTERFACE, "AdvertisingEnabled",
 743                         DBUS_TYPE_INT32, &id,
 744                         DBUS_TYPE_BOOLEAN, &state,
 745                         DBUS_TYPE_INVALID);
 746 }
 747
 748 static void clear_advertiser_cb(gpointer data, gpointer user_data)
 749 {
 750         struct adv_info *adv = data;
 751         struct btd_adapter *adapter = user_data;
 752
 753         if (adv->status)
 754                 advertising_state_changed(adapter, adv->slot_id, 0);
 755 }
 756
 757 static void advertiser_cleanup(struct btd_adapter *adapter)
 758 {
 759         if (!adapter->adv_list)
 760                 return;
 761
 762         g_slist_foreach(adapter->adv_list, clear_advertiser_cb, adapter);
 763         g_slist_free(adapter->adv_list);
 764         adapter->adv_list = NULL;
 765 }
 766 #endif
 767
 768 #if defined __TIZEN_PATCH__ && defined __SPRD_PAGE_SCAN_PATCH__
 769 #define OCF_PAGE_SCAN_TIMEOUT                   0x0018
 770 #define OGF_PAGE_SCAN_TIMEOUT           0x03
 771
 772 typedef struct {
 773         uint16_t        timeout;        /* Value */
 774 } __attribute__ ((packed)) hci_page_scan_timeout;
 775 #define HCI_PAGE_SCAN_TIMEOUT_CP_SIZE 2
 776
 777 static gboolean send_sprd_page_scan_timeout(gint value)
 778 {
 779         int dd;
 780         hci_page_scan_timeout cp;
 781         DBG("+");
 782         dd = hci_open_dev(0);
 783         cp.timeout = value;
 784         if (hci_send_cmd(dd, OGF_PAGE_SCAN_TIMEOUT, OCF_PAGE_SCAN_TIMEOUT,
 785                                 HCI_PAGE_SCAN_TIMEOUT_CP_SIZE, &cp) < 0) {
 786                 DBG("Error: While setting Page Timeout value");
 787                 hci_close_dev(dd);
 788                 return FALSE;
 789         }
 790         DBG("Page Scan Timeout Value Patch %d", value);
 791
 792         hci_close_dev(dd);
 793
 794         return TRUE;
 795 }
 796 #endif
 797
 798 static void settings_changed(struct btd_adapter *adapter, uint32_t settings)
 799 {
 800         uint32_t changed_mask;
 801
 802         changed_mask = adapter->current_settings ^ settings;
 803
 804         adapter->current_settings = settings;
 805
 806         DBG("Changed settings: 0x%08x", changed_mask);
 807
 808         if (changed_mask & MGMT_SETTING_POWERED) {
 809                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 810                                         ADAPTER_INTERFACE, "Powered");
 811
 812                 if (adapter->current_settings & MGMT_SETTING_POWERED) {
 813                         adapter_start(adapter);
 814 #if defined __TIZEN_PATCH__ && defined __SPRD_PAGE_SCAN_PATCH__
 815                         /* Approx 6.4 Seconds of timeout */
 816                         /* This Added because Z3 device was not able to connect with
 817                           * some device as it was getting Page Timeout
 818                           * (LG HBS800, sony carkit) etc. So, Increasing Page timeout value
 819                           * from 5.12 Sec (which is default) to ~6.4sec*/
 820                         DBG("Setting value");
 821                         send_sprd_page_scan_timeout(10240);
 822 #endif /* __SPRD_QOS_PATCH__ */
 823                 } else {
 824                         adapter_stop(adapter);
 825
 826                         if (powering_down) {
 827                                 adapter_remaining--;
 828
 829                                 if (!adapter_remaining)
 830                                         btd_exit();
 831                         }
 832                 }
 833         }
 834
 835         if (changed_mask & MGMT_SETTING_LE) {
 836                 if ((adapter->current_settings & MGMT_SETTING_POWERED) &&
 837                                 (adapter->current_settings & MGMT_SETTING_LE))
 838                         trigger_passive_scanning(adapter);
 839         }
 840
 841         if (changed_mask & MGMT_SETTING_CONNECTABLE)
 842                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 843                                         ADAPTER_INTERFACE, "Connectable");
 844
 845         if (changed_mask & MGMT_SETTING_DISCOVERABLE) {
 846                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 847                                         ADAPTER_INTERFACE, "Discoverable");
 848                 store_adapter_info(adapter);
 849         }
 850
 851         if (changed_mask & MGMT_SETTING_BONDABLE) {
 852                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 853                                         ADAPTER_INTERFACE, "Pairable");
 854
 855                 trigger_pairable_timeout(adapter);
 856         }
 857
 858 #ifdef __TIZEN_PATCH__
 859         if (changed_mask & MGMT_SETTING_ADVERTISING) {
 860                 if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
 861                         (adapter->advertising)) {
 862                         return;
 863                 }
 864
 865                 adapter->advertising = adapter->current_settings & MGMT_SETTING_ADVERTISING;
 866                 advertising_state_changed(adapter, 0, adapter->advertising);
 867         }
 868 #endif
 869 }
 870
 871 static void new_settings_callback(uint16_t index, uint16_t length,
 872                                         const void *param, void *user_data)
 873 {
 874         struct btd_adapter *adapter = user_data;
 875         uint32_t settings;
 876
 877         if (length < sizeof(settings)) {
 878                 btd_error(adapter->dev_id,
 879                                 "Wrong size of new settings parameters");
 880                 return;
 881         }
 882
 883         settings = get_le32(param);
 884
 885         if (settings == adapter->current_settings)
 886                 return;
 887
 888         DBG("Settings: 0x%08x", settings);
 889
 890         settings_changed(adapter, settings);
 891 }
 892
 893 static void set_mode_complete(uint8_t status, uint16_t length,
 894                                         const void *param, void *user_data)
 895 {
 896         struct btd_adapter *adapter = user_data;
 897
 898         if (status != MGMT_STATUS_SUCCESS) {
 899                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
 900                                                 mgmt_errstr(status), status);
 901                 return;
 902         }
 903
 904         /*
 905          * The parameters are identical and also the task that is
 906          * required in both cases. So it is safe to just call the
 907          * event handling functions here.
 908          */
 909         new_settings_callback(adapter->dev_id, length, param, adapter);
 910 }
 911
 912 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
 913                                                         uint8_t mode)
 914 {
 915         struct mgmt_mode cp;
 916
 917         memset(&cp, 0, sizeof(cp));
 918         cp.val = mode;
 919
 920         DBG("sending set mode command for index %u", adapter->dev_id);
 921
 922         if (mgmt_send(adapter->mgmt, opcode,
 923                                 adapter->dev_id, sizeof(cp), &cp,
 924                                 set_mode_complete, adapter, NULL) > 0)
 925                 return true;
 926
 927         btd_error(adapter->dev_id, "Failed to set mode for index %u",
 928                                                         adapter->dev_id);
 929
 930         return false;
 931 }
 932
 933 static bool set_discoverable(struct btd_adapter *adapter, uint8_t mode,
 934                                                         uint16_t timeout)
 935 {
 936         struct mgmt_cp_set_discoverable cp;
 937
 938         memset(&cp, 0, sizeof(cp));
 939         cp.val = mode;
 940         cp.timeout = htobs(timeout);
 941
 942         DBG("sending set mode command for index %u", adapter->dev_id);
 943
 944         if (kernel_conn_control) {
 945                 if (mode)
 946                         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, mode);
 947                 else
 948                         /* This also disables discoverable so we're done */
 949                         return set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
 950                                                                         mode);
 951         }
 952
 953         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DISCOVERABLE,
 954                                 adapter->dev_id, sizeof(cp), &cp,
 955                                 set_mode_complete, adapter, NULL) > 0)
 956                 return true;
 957
 958         btd_error(adapter->dev_id, "Failed to set mode for index %u",
 959                                                         adapter->dev_id);
 960
 961         return false;
 962 }
 963
 964 static gboolean pairable_timeout_handler(gpointer user_data)
 965 {
 966         struct btd_adapter *adapter = user_data;
 967
 968         adapter->pairable_timeout_id = 0;
 969
 970         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
 971
 972         return FALSE;
 973 }
 974
 975 static void trigger_pairable_timeout(struct btd_adapter *adapter)
 976 {
 977         if (adapter->pairable_timeout_id > 0) {
 978                 g_source_remove(adapter->pairable_timeout_id);
 979                 adapter->pairable_timeout_id = 0;
 980         }
 981
 982         if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
 983                 return;
 984
 985         if (adapter->pairable_timeout > 0)
 986                 g_timeout_add_seconds(adapter->pairable_timeout,
 987                                         pairable_timeout_handler, adapter);
 988 }
 989
 990 static void local_name_changed_callback(uint16_t index, uint16_t length,
 991                                         const void *param, void *user_data)
 992 {
 993         struct btd_adapter *adapter = user_data;
 994         const struct mgmt_cp_set_local_name *rp = param;
 995
 996         if (length < sizeof(*rp)) {
 997                 btd_error(adapter->dev_id,
 998                                 "Wrong size of local name changed parameters");
 999                 return;
1000         }
1001
1002         if (!g_strcmp0(adapter->short_name, (const char *) rp->short_name) &&
1003                         !g_strcmp0(adapter->name, (const char *) rp->name))
1004                 return;
1005
1006         DBG("Name: %s", rp->name);
1007         DBG("Short name: %s", rp->short_name);
1008
1009         g_free(adapter->name);
1010         adapter->name = g_strdup((const char *) rp->name);
1011
1012         g_free(adapter->short_name);
1013         adapter->short_name = g_strdup((const char *) rp->short_name);
1014
1015         /*
1016          * Changing the name (even manually via HCI) will update the
1017          * current alias property.
1018          *
1019          * In case the name is empty, use the short name.
1020          *
1021          * There is a difference between the stored alias (which is
1022          * configured by the user) and the current alias. The current
1023          * alias is temporary for the lifetime of the daemon.
1024          */
1025         if (adapter->name && adapter->name[0] != '\0') {
1026                 g_free(adapter->current_alias);
1027                 adapter->current_alias = g_strdup(adapter->name);
1028         } else {
1029                 g_free(adapter->current_alias);
1030                 adapter->current_alias = g_strdup(adapter->short_name);
1031         }
1032
1033         DBG("Current alias: %s", adapter->current_alias);
1034
1035         if (!adapter->current_alias)
1036                 return;
1037
1038         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1039                                                 ADAPTER_INTERFACE, "Alias");
1040
1041         attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
1042                                 (const uint8_t *) adapter->current_alias,
1043                                         strlen(adapter->current_alias));
1044 }
1045
1046 static void set_local_name_complete(uint8_t status, uint16_t length,
1047                                         const void *param, void *user_data)
1048 {
1049         struct btd_adapter *adapter = user_data;
1050
1051         if (status != MGMT_STATUS_SUCCESS) {
1052                 btd_error(adapter->dev_id,
1053                                 "Failed to set local name: %s (0x%02x)",
1054                                                 mgmt_errstr(status), status);
1055                 return;
1056         }
1057
1058         /*
1059          * The parameters are identical and also the task that is
1060          * required in both cases. So it is safe to just call the
1061          * event handling functions here.
1062          */
1063         local_name_changed_callback(adapter->dev_id, length, param, adapter);
1064 }
1065
1066 static int set_name(struct btd_adapter *adapter, const char *name)
1067 {
1068         struct mgmt_cp_set_local_name cp;
1069         char maxname[MAX_NAME_LENGTH + 1];
1070
1071         memset(maxname, 0, sizeof(maxname));
1072         strncpy(maxname, name, MAX_NAME_LENGTH);
1073
1074         if (!g_utf8_validate(maxname, -1, NULL)) {
1075                 btd_error(adapter->dev_id,
1076                         "Name change failed: supplied name isn't valid UTF-8");
1077                 return -EINVAL;
1078         }
1079
1080         memset(&cp, 0, sizeof(cp));
1081         strncpy((char *) cp.name, maxname, sizeof(cp.name) - 1);
1082
1083         DBG("sending set local name command for index %u", adapter->dev_id);
1084
1085         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LOCAL_NAME,
1086                                 adapter->dev_id, sizeof(cp), &cp,
1087                                 set_local_name_complete, adapter, NULL) > 0)
1088                 return 0;
1089
1090         btd_error(adapter->dev_id, "Failed to set local name for index %u",
1091                                                         adapter->dev_id);
1092
1093         return -EIO;
1094 }
1095
1096 int adapter_set_name(struct btd_adapter *adapter, const char *name)
1097 {
1098         if (g_strcmp0(adapter->system_name, name) == 0)
1099                 return 0;
1100
1101         DBG("name: %s", name);
1102
1103         g_free(adapter->system_name);
1104         adapter->system_name = g_strdup(name);
1105
1106         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1107                                                 ADAPTER_INTERFACE, "Name");
1108
1109         /* alias is preferred over system name */
1110         if (adapter->stored_alias)
1111                 return 0;
1112
1113         DBG("alias: %s", name);
1114
1115         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1116                                                 ADAPTER_INTERFACE, "Alias");
1117
1118         return set_name(adapter, name);
1119 }
1120
1121 struct btd_device *btd_adapter_find_device(struct btd_adapter *adapter,
1122                                                         const bdaddr_t *dst,
1123                                                         uint8_t bdaddr_type)
1124 {
1125         struct device_addr_type addr;
1126         struct btd_device *device;
1127         GSList *list;
1128
1129         if (!adapter)
1130                 return NULL;
1131
1132         bacpy(&addr.bdaddr, dst);
1133         addr.bdaddr_type = bdaddr_type;
1134
1135         list = g_slist_find_custom(adapter->devices, &addr,
1136                                                         device_addr_type_cmp);
1137
1138 /* Find the device based on RPA */
1139 #ifdef __TIZEN_PATCH__
1140         if (!list) {
1141                 uint8_t msb = 0x00;
1142                 char address[18];
1143
1144                 ba2str(&addr.bdaddr, address);
1145
1146                 msb = addr.bdaddr.b[5] >> 6;
1147
1148                 /* Check whether address is RPA */
1149                 if (msb == 0x00 || msb == 0x01) {
1150                         list = g_slist_find_custom(adapter->devices,
1151                                 address, (GCompareFunc) device_rpa_cmp);
1152                 }
1153         } else {
1154                 device = list->data;
1155
1156                 if (device_get_rpa_exist(device) == true) {
1157                         GSList *rpa_list;
1158
1159                         rpa_list = g_slist_find_custom(adapter->devices,
1160                                                                         device_get_address(device),
1161                                                                         device_addr_cmp);
1162                         if (rpa_list) {
1163                                 list = rpa_list;
1164                                 bdaddr_type = BDADDR_LE_RANDOM;
1165                         }
1166                 }
1167         }
1168 #endif
1169
1170         if (!list)
1171                 return NULL;
1172
1173         device = list->data;
1174
1175         /*
1176          * If we're looking up based on public address and the address
1177          * was not previously used over this bearer we may need to
1178          * update LE or BR/EDR support information.
1179          */
1180         if (bdaddr_type == BDADDR_BREDR)
1181                 device_set_bredr_support(device);
1182         else
1183                 device_set_le_support(device, bdaddr_type);
1184
1185         return device;
1186 }
1187
1188 static void uuid_to_uuid128(uuid_t *uuid128, const uuid_t *uuid)
1189 {
1190         if (uuid->type == SDP_UUID16)
1191                 sdp_uuid16_to_uuid128(uuid128, uuid);
1192         else if (uuid->type == SDP_UUID32)
1193                 sdp_uuid32_to_uuid128(uuid128, uuid);
1194         else
1195                 memcpy(uuid128, uuid, sizeof(*uuid));
1196 }
1197
1198 static bool is_supported_uuid(const uuid_t *uuid)
1199 {
1200         uuid_t tmp;
1201
1202         /* mgmt versions from 1.3 onwards support all types of UUIDs */
1203         if (MGMT_VERSION(mgmt_version, mgmt_revision) >= MGMT_VERSION(1, 3))
1204                 return true;
1205
1206         uuid_to_uuid128(&tmp, uuid);
1207
1208         if (!sdp_uuid128_to_uuid(&tmp))
1209                 return false;
1210
1211         if (tmp.type != SDP_UUID16)
1212                 return false;
1213
1214         return true;
1215 }
1216
1217 static void add_uuid_complete(uint8_t status, uint16_t length,
1218                                         const void *param, void *user_data)
1219 {
1220         struct btd_adapter *adapter = user_data;
1221
1222         if (status != MGMT_STATUS_SUCCESS) {
1223                 btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
1224                                                 mgmt_errstr(status), status);
1225                 return;
1226         }
1227
1228         /*
1229          * The parameters are identical and also the task that is
1230          * required in both cases. So it is safe to just call the
1231          * event handling functions here.
1232          */
1233         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1234
1235         if (adapter->initialized)
1236                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1237                                                 ADAPTER_INTERFACE, "UUIDs");
1238 }
1239
1240 static int add_uuid(struct btd_adapter *adapter, uuid_t *uuid, uint8_t svc_hint)
1241 {
1242         struct mgmt_cp_add_uuid cp;
1243         uuid_t uuid128;
1244         uint128_t uint128;
1245
1246         if (!is_supported_uuid(uuid)) {
1247                 btd_warn(adapter->dev_id,
1248                                 "Ignoring unsupported UUID for addition");
1249                 return 0;
1250         }
1251
1252         uuid_to_uuid128(&uuid128, uuid);
1253
1254         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1255         htob128(&uint128, (uint128_t *) cp.uuid);
1256         cp.svc_hint = svc_hint;
1257
1258         DBG("sending add uuid command for index %u", adapter->dev_id);
1259
1260         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_UUID,
1261                                 adapter->dev_id, sizeof(cp), &cp,
1262                                 add_uuid_complete, adapter, NULL) > 0)
1263                 return 0;
1264
1265         btd_error(adapter->dev_id, "Failed to add UUID for index %u",
1266                                                         adapter->dev_id);
1267
1268         return -EIO;
1269 }
1270
1271 static void remove_uuid_complete(uint8_t status, uint16_t length,
1272                                         const void *param, void *user_data)
1273 {
1274         struct btd_adapter *adapter = user_data;
1275
1276         if (status != MGMT_STATUS_SUCCESS) {
1277                 btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
1278                                                 mgmt_errstr(status), status);
1279                 return;
1280         }
1281
1282         /*
1283          * The parameters are identical and also the task that is
1284          * required in both cases. So it is safe to just call the
1285          * event handling functions here.
1286          */
1287         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1288
1289         if (adapter->initialized)
1290                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1291                                                 ADAPTER_INTERFACE, "UUIDs");
1292 }
1293
1294 static int remove_uuid(struct btd_adapter *adapter, uuid_t *uuid)
1295 {
1296         struct mgmt_cp_remove_uuid cp;
1297         uuid_t uuid128;
1298         uint128_t uint128;
1299
1300         if (!is_supported_uuid(uuid)) {
1301                 btd_warn(adapter->dev_id,
1302                                 "Ignoring unsupported UUID for removal");
1303                 return 0;
1304         }
1305
1306         uuid_to_uuid128(&uuid128, uuid);
1307
1308         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1309         htob128(&uint128, (uint128_t *) cp.uuid);
1310
1311         DBG("sending remove uuid command for index %u", adapter->dev_id);
1312
1313         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1314                                 adapter->dev_id, sizeof(cp), &cp,
1315                                 remove_uuid_complete, adapter, NULL) > 0)
1316                 return 0;
1317
1318         btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
1319                                                         adapter->dev_id);
1320
1321         return -EIO;
1322 }
1323
1324 static void clear_uuids_complete(uint8_t status, uint16_t length,
1325                                         const void *param, void *user_data)
1326 {
1327         struct btd_adapter *adapter = user_data;
1328
1329         if (status != MGMT_STATUS_SUCCESS) {
1330                 btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
1331                                                 mgmt_errstr(status), status);
1332                 return;
1333         }
1334
1335         /*
1336          * The parameters are identical and also the task that is
1337          * required in both cases. So it is safe to just call the
1338          * event handling functions here.
1339          */
1340         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1341 }
1342
1343 static int clear_uuids(struct btd_adapter *adapter)
1344 {
1345         struct mgmt_cp_remove_uuid cp;
1346
1347         memset(&cp, 0, sizeof(cp));
1348
1349         DBG("sending clear uuids command for index %u", adapter->dev_id);
1350
1351         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1352                                 adapter->dev_id, sizeof(cp), &cp,
1353                                 clear_uuids_complete, adapter, NULL) > 0)
1354                 return 0;
1355
1356         btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
1357                                                         adapter->dev_id);
1358
1359         return -EIO;
1360 }
1361
1362 static uint8_t get_uuid_mask(uuid_t *uuid)
1363 {
1364         if (uuid->type != SDP_UUID16)
1365                 return 0;
1366
1367         switch (uuid->value.uuid16) {
1368         case DIALUP_NET_SVCLASS_ID:
1369         case CIP_SVCLASS_ID:
1370                 return 0x42;    /* Telephony & Networking */
1371         case IRMC_SYNC_SVCLASS_ID:
1372         case OBEX_OBJPUSH_SVCLASS_ID:
1373         case OBEX_FILETRANS_SVCLASS_ID:
1374         case IRMC_SYNC_CMD_SVCLASS_ID:
1375         case PBAP_PSE_SVCLASS_ID:
1376                 return 0x10;    /* Object Transfer */
1377         case HEADSET_SVCLASS_ID:
1378         case HANDSFREE_SVCLASS_ID:
1379                 return 0x20;    /* Audio */
1380         case CORDLESS_TELEPHONY_SVCLASS_ID:
1381         case INTERCOM_SVCLASS_ID:
1382         case FAX_SVCLASS_ID:
1383         case SAP_SVCLASS_ID:
1384         /*
1385          * Setting the telephony bit for the handsfree audio gateway
1386          * role is not required by the HFP specification, but the
1387          * Nokia 616 carkit is just plain broken! It will refuse
1388          * pairing without this bit set.
1389          */
1390         case HANDSFREE_AGW_SVCLASS_ID:
1391                 return 0x40;    /* Telephony */
1392         case AUDIO_SOURCE_SVCLASS_ID:
1393         case VIDEO_SOURCE_SVCLASS_ID:
1394                 return 0x08;    /* Capturing */
1395         case AUDIO_SINK_SVCLASS_ID:
1396         case VIDEO_SINK_SVCLASS_ID:
1397                 return 0x04;    /* Rendering */
1398         case PANU_SVCLASS_ID:
1399         case NAP_SVCLASS_ID:
1400         case GN_SVCLASS_ID:
1401                 return 0x02;    /* Networking */
1402         default:
1403                 return 0;
1404         }
1405 }
1406
1407 static int uuid_cmp(const void *a, const void *b)
1408 {
1409         const sdp_record_t *rec = a;
1410         const uuid_t *uuid = b;
1411
1412         return sdp_uuid_cmp(&rec->svclass, uuid);
1413 }
1414
1415 static void adapter_service_insert(struct btd_adapter *adapter, sdp_record_t *rec)
1416 {
1417         sdp_list_t *browse_list = NULL;
1418         uuid_t browse_uuid;
1419         gboolean new_uuid;
1420
1421         DBG("%s", adapter->path);
1422
1423 #ifdef __TIZEN_PATCH__
1424         if (rec == NULL) {
1425                 DBG("record is NULL return");
1426                 return;
1427         }
1428 #endif
1429
1430         /* skip record without a browse group */
1431         if (sdp_get_browse_groups(rec, &browse_list) < 0) {
1432                 DBG("skipping record without browse group");
1433                 return;
1434         }
1435
1436         sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
1437
1438         /* skip record without public browse group */
1439         if (!sdp_list_find(browse_list, &browse_uuid, sdp_uuid_cmp))
1440                 goto done;
1441
1442         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1443                 new_uuid = TRUE;
1444         else
1445                 new_uuid = FALSE;
1446
1447         adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1448                                                                 record_sort);
1449
1450         if (new_uuid) {
1451                 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1452                 add_uuid(adapter, &rec->svclass, svc_hint);
1453         }
1454
1455 done:
1456         sdp_list_free(browse_list, free);
1457 }
1458
1459 int adapter_service_add(struct btd_adapter *adapter, sdp_record_t *rec)
1460 {
1461         int ret;
1462
1463         DBG("%s", adapter->path);
1464
1465         ret = add_record_to_server(&adapter->bdaddr, rec);
1466         if (ret < 0)
1467                 return ret;
1468
1469         adapter_service_insert(adapter, rec);
1470
1471         return 0;
1472 }
1473
1474 void adapter_service_remove(struct btd_adapter *adapter, uint32_t handle)
1475 {
1476         sdp_record_t *rec = sdp_record_find(handle);
1477
1478         DBG("%s", adapter->path);
1479
1480         if (!rec)
1481                 return;
1482
1483         adapter->services = sdp_list_remove(adapter->services, rec);
1484
1485         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1486                 remove_uuid(adapter, &rec->svclass);
1487
1488         remove_record_from_server(rec->handle);
1489 }
1490
1491 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
1492                                                 const bdaddr_t *bdaddr,
1493                                                 uint8_t bdaddr_type)
1494 {
1495         struct btd_device *device;
1496
1497         device = device_create(adapter, bdaddr, bdaddr_type);
1498         if (!device)
1499                 return NULL;
1500
1501         adapter->devices = g_slist_append(adapter->devices, device);
1502
1503         return device;
1504 }
1505
1506 static void service_auth_cancel(struct service_auth *auth)
1507 {
1508         DBusError derr;
1509
1510         if (auth->svc_id > 0)
1511                 device_remove_svc_complete_callback(auth->device,
1512                                                                 auth->svc_id);
1513
1514         dbus_error_init(&derr);
1515         dbus_set_error_const(&derr, ERROR_INTERFACE ".Canceled", NULL);
1516
1517         auth->cb(&derr, auth->user_data);
1518
1519         dbus_error_free(&derr);
1520
1521         if (auth->agent != NULL) {
1522                 agent_cancel(auth->agent);
1523                 agent_unref(auth->agent);
1524         }
1525
1526         g_free(auth);
1527 }
1528
1529 #ifdef __TIZEN_PATCH__
1530 void btd_adapter_unpair_device(struct btd_adapter *adapter,
1531                                 struct btd_device *dev)
1532 {
1533         DBG("+");
1534         GList *l;
1535
1536         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1537
1538 //      adapter->devices = g_slist_remove(adapter->devices, dev);
1539 //
1540 //      adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1541 //                                                                      dev);
1542
1543         adapter->connections = g_slist_remove(adapter->connections, dev);
1544
1545         if (adapter->connect_le == dev)
1546                 adapter->connect_le = NULL;
1547
1548         l = adapter->auths->head;
1549         while (l != NULL) {
1550                 struct service_auth *auth = l->data;
1551                 GList *next = g_list_next(l);
1552
1553                 if (auth->device != dev) {
1554                         l = next;
1555                         continue;
1556                 }
1557
1558                 g_queue_delete_link(adapter->auths, l);
1559                 l = next;
1560
1561                 service_auth_cancel(auth);
1562         }
1563
1564         device_unpair(dev, TRUE);
1565         DBG("-");
1566 }
1567
1568 gboolean adapter_clear_le_white_list(struct btd_adapter *adapter)
1569 {
1570         if (mgmt_send(adapter->mgmt, MGMT_OP_CLEAR_DEV_WHITE_LIST,
1571                                    adapter->dev_id, 0, NULL,
1572                                    NULL, NULL, NULL) > 0)
1573                 return TRUE;
1574         else
1575                 return FALSE;
1576 }
1577
1578 gboolean adapter_add_le_white_list(struct btd_adapter *adapter, struct btd_device *device)
1579 {
1580         struct mgmt_cp_add_dev_white_list cp;
1581         const bdaddr_t *dst;
1582         char device_addr[18];
1583
1584         memset(&cp, 0, sizeof(cp));
1585
1586         dst = device_get_address(device);
1587
1588         ba2str(device_get_address(device), device_addr);
1589         DBG("addr %s  bdaddr type  %d", device_addr, btd_device_get_bdaddr_type(device));
1590
1591         if ( btd_device_get_bdaddr_type(device) == BDADDR_LE_PUBLIC)
1592                 cp.bdaddr_type =  0x0;
1593         else
1594                 cp.bdaddr_type =  0x1;
1595
1596         memcpy(&cp.bdaddr, dst, sizeof(bdaddr_t));
1597
1598         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEV_WHITE_LIST,
1599                                         adapter->dev_id, sizeof(cp), &cp,
1600                                         NULL, NULL, NULL) > 0)
1601                         return TRUE;
1602
1603         DBG("Unable to add white list");
1604
1605         return FALSE;
1606 }
1607
1608 gboolean btd_adapter_is_le_auto_connect(struct btd_adapter *adapter)
1609 {
1610         return adapter->le_auto_connect;
1611 }
1612
1613 void btd_adapter_set_le_auto_connect(struct btd_adapter *adapter, gboolean auto_connect)
1614 {
1615         adapter->le_auto_connect = auto_connect;
1616 }
1617
1618 gboolean btd_adapter_disable_le_auto_connect(struct btd_adapter *adapter)
1619 {
1620         if (btd_adapter_is_le_auto_connect(adapter) == FALSE) {
1621                 error("le auto connection is not going on");
1622                 return FALSE;
1623         }
1624
1625         DBG("disable le auto connect : %u", adapter->dev_id);
1626
1627         if (mgmt_send(adapter->mgmt, MGMT_OP_DISABLE_LE_AUTO_CONNECT,
1628                                 adapter->dev_id, 0, NULL,
1629                                 NULL, NULL, NULL) > 0) {
1630                 btd_adapter_set_le_auto_connect(adapter, FALSE);
1631                 return TRUE;
1632         }
1633
1634         error("Failed to disable le auto conn : %u", adapter->dev_id);
1635
1636         return FALSE;
1637 }
1638 #endif
1639
1640 void btd_adapter_remove_device(struct btd_adapter *adapter,
1641                                 struct btd_device *dev)
1642 {
1643         GList *l;
1644
1645         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1646
1647         adapter->devices = g_slist_remove(adapter->devices, dev);
1648
1649         adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1650                                                                         dev);
1651
1652         adapter->connections = g_slist_remove(adapter->connections, dev);
1653
1654         if (adapter->connect_le == dev)
1655                 adapter->connect_le = NULL;
1656
1657         l = adapter->auths->head;
1658         while (l != NULL) {
1659                 struct service_auth *auth = l->data;
1660                 GList *next = g_list_next(l);
1661
1662                 if (auth->device != dev) {
1663                         l = next;
1664                         continue;
1665                 }
1666
1667                 g_queue_delete_link(adapter->auths, l);
1668                 l = next;
1669
1670                 service_auth_cancel(auth);
1671         }
1672
1673         device_remove(dev, TRUE);
1674 }
1675
1676 struct btd_device *btd_adapter_get_device(struct btd_adapter *adapter,
1677                                         const bdaddr_t *addr,
1678                                         uint8_t addr_type)
1679 {
1680         struct btd_device *device;
1681
1682         if (!adapter)
1683                 return NULL;
1684
1685 #ifdef __TIZEN_PATCH__
1686         if (!bacmp(addr, BDADDR_ANY))
1687                 return NULL;
1688 #endif
1689
1690         device = btd_adapter_find_device(adapter, addr, addr_type);
1691         if (device)
1692                 return device;
1693
1694         return adapter_create_device(adapter, addr, addr_type);
1695 }
1696
1697 sdp_list_t *btd_adapter_get_services(struct btd_adapter *adapter)
1698 {
1699         return adapter->services;
1700 }
1701
1702 static void passive_scanning_complete(uint8_t status, uint16_t length,
1703                                         const void *param, void *user_data)
1704 {
1705         struct btd_adapter *adapter = user_data;
1706         const struct mgmt_cp_start_discovery *rp = param;
1707
1708         DBG("status 0x%02x", status);
1709
1710         if (length < sizeof(*rp)) {
1711                 btd_error(adapter->dev_id,
1712                         "Wrong size of start scanning return parameters");
1713                 return;
1714         }
1715
1716         if (status == MGMT_STATUS_SUCCESS) {
1717                 adapter->discovery_type = rp->type;
1718                 adapter->discovery_enable = 0x01;
1719         }
1720 }
1721
1722 static gboolean passive_scanning_timeout(gpointer user_data)
1723 {
1724         struct btd_adapter *adapter = user_data;
1725         struct mgmt_cp_start_discovery cp;
1726
1727         adapter->passive_scan_timeout = 0;
1728
1729         cp.type = SCAN_TYPE_LE;
1730 #ifdef __TIZEN_PATCH__
1731         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
1732                                 adapter->dev_id, sizeof(cp), &cp,
1733                                 passive_scanning_complete, adapter, NULL);
1734 #else
1735         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
1736                                 adapter->dev_id, sizeof(cp), &cp,
1737                                 passive_scanning_complete, adapter, NULL);
1738 #endif
1739         return FALSE;
1740 }
1741
1742 static void trigger_passive_scanning(struct btd_adapter *adapter)
1743 {
1744         if (!(adapter->current_settings & MGMT_SETTING_LE))
1745                 return;
1746
1747         DBG("");
1748
1749         if (adapter->passive_scan_timeout > 0) {
1750                 g_source_remove(adapter->passive_scan_timeout);
1751                 adapter->passive_scan_timeout = 0;
1752         }
1753
1754         /*
1755          * When the kernel background scanning is available, there is
1756          * no need to start any discovery. The kernel will keep scanning
1757          * as long as devices are in its auto-connection list.
1758          */
1759         if (kernel_conn_control)
1760                 return;
1761
1762         /*
1763          * If any client is running a discovery right now, then do not
1764          * even try to start passive scanning.
1765          *
1766          * The discovery procedure is using interleaved scanning and
1767          * thus will discover Low Energy devices as well.
1768          */
1769 #ifdef __TIZEN_PATCH__
1770         if (adapter->discovery_list || adapter->le_discovery_list)
1771                 return;
1772 #else
1773         if (adapter->discovery_list)
1774                 return;
1775 #endif
1776
1777         if (adapter->discovery_enable == 0x01)
1778                 return;
1779
1780         /*
1781          * In case the discovery is suspended (for example for an ongoing
1782          * pairing attempt), then also do not start passive scanning.
1783          */
1784         if (adapter->discovery_suspended)
1785                 return;
1786
1787         /*
1788          * If the list of connectable Low Energy devices is empty,
1789          * then do not start passive scanning.
1790          */
1791         if (!adapter->connect_list)
1792                 return;
1793
1794         adapter->passive_scan_timeout = g_timeout_add_seconds(CONN_SCAN_TIMEOUT,
1795                                         passive_scanning_timeout, adapter);
1796 }
1797
1798 static void stop_passive_scanning_complete(uint8_t status, uint16_t length,
1799                                         const void *param, void *user_data)
1800 {
1801         struct btd_adapter *adapter = user_data;
1802         struct btd_device *dev;
1803         int err;
1804
1805         DBG("status 0x%02x (%s)", status, mgmt_errstr(status));
1806
1807         dev = adapter->connect_le;
1808         adapter->connect_le = NULL;
1809
1810         /*
1811          * When the kernel background scanning is available, there is
1812          * no need to stop any discovery. The kernel will handle the
1813          * auto-connection by itself.
1814          */
1815         if (kernel_conn_control)
1816                 return;
1817
1818         /*
1819          * MGMT_STATUS_REJECTED may be returned from kernel because the passive
1820          * scan timer had expired in kernel and passive scan was disabled just
1821          * around the time we called stop_passive_scanning().
1822          */
1823         if (status != MGMT_STATUS_SUCCESS && status != MGMT_STATUS_REJECTED) {
1824                 btd_error(adapter->dev_id, "Stopping passive scanning failed: %s",
1825                                                         mgmt_errstr(status));
1826                 return;
1827         }
1828
1829         adapter->discovery_type = 0x00;
1830         adapter->discovery_enable = 0x00;
1831
1832         if (!dev) {
1833                 DBG("Device removed while stopping passive scanning");
1834                 trigger_passive_scanning(adapter);
1835                 return;
1836         }
1837
1838         err = device_connect_le(dev);
1839         if (err < 0) {
1840                 btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
1841                                                         strerror(-err), -err);
1842                 trigger_passive_scanning(adapter);
1843         }
1844 }
1845
1846 static void stop_passive_scanning(struct btd_adapter *adapter)
1847 {
1848         struct mgmt_cp_stop_discovery cp;
1849 #ifdef __TIZEN_PATCH__
1850         struct mgmt_cp_stop_discovery le_cp;
1851 #endif
1852
1853         DBG("");
1854
1855         /* If there are any normal discovery clients passive scanning
1856          * wont be running */
1857 #ifdef __TIZEN_PATCH__
1858         if (adapter->discovery_list || adapter->le_discovery_list)
1859                 return;
1860 #else
1861         if (adapter->discovery_list)
1862                 return;
1863 #endif
1864
1865         if (adapter->discovery_enable == 0x00)
1866                 return;
1867
1868 #ifdef __TIZEN_PATCH__
1869         if ((adapter->discovery_type & 0x01) > 0)
1870                 cp.type = 0x01;
1871                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
1872                                 adapter->dev_id, sizeof(cp), &cp,
1873                                 stop_passive_scanning_complete, adapter, NULL);
1874         if ((adapter->discovery_type & 0x06) > 0)
1875                 le_cp.type = 0x06;
1876                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
1877                                 adapter->dev_id, sizeof(le_cp), &le_cp,
1878                                 stop_passive_scanning_complete, adapter, NULL);
1879 #else
1880         cp.type = adapter->discovery_type;
1881
1882         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
1883                         adapter->dev_id, sizeof(cp), &cp,
1884                         stop_passive_scanning_complete, adapter, NULL);
1885 #endif
1886 }
1887
1888 static void cancel_passive_scanning(struct btd_adapter *adapter)
1889 {
1890         if (!(adapter->current_settings & MGMT_SETTING_LE))
1891                 return;
1892
1893         DBG("");
1894
1895         if (adapter->passive_scan_timeout > 0) {
1896                 g_source_remove(adapter->passive_scan_timeout);
1897                 adapter->passive_scan_timeout = 0;
1898         }
1899 }
1900
1901 static uint8_t get_scan_type(struct btd_adapter *adapter)
1902 {
1903         uint8_t type;
1904
1905         if (adapter->current_settings & MGMT_SETTING_BREDR)
1906                 type = SCAN_TYPE_BREDR;
1907         else
1908                 type = 0;
1909
1910         if (adapter->current_settings & MGMT_SETTING_LE)
1911                 type |= SCAN_TYPE_LE;
1912
1913         return type;
1914 }
1915
1916 static void free_discovery_filter(struct discovery_filter *discovery_filter)
1917 {
1918         if (!discovery_filter)
1919                 return;
1920
1921         g_slist_free_full(discovery_filter->uuids, g_free);
1922         g_free(discovery_filter);
1923 }
1924
1925 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay);
1926
1927 static void start_discovery_complete(uint8_t status, uint16_t length,
1928                                         const void *param, void *user_data)
1929 {
1930         struct btd_adapter *adapter = user_data;
1931         const struct mgmt_cp_start_discovery *rp = param;
1932
1933         DBG("status 0x%02x", status);
1934 #ifndef __TIZEN_PATCH__
1935         DBG("Discovery Type 0x%02x", rp->type);
1936 #endif
1937
1938         if (length < sizeof(*rp)) {
1939                 btd_error(adapter->dev_id,
1940                         "Wrong size of start discovery return parameters");
1941                 return;
1942         }
1943
1944         if (status == MGMT_STATUS_SUCCESS) {
1945 #ifdef __TIZEN_PATCH__
1946                 DBG("Return param discovery type 0x%02x", rp->type);
1947                 adapter->discovery_type |= rp->type;
1948 #else
1949                 adapter->discovery_type = rp->type;
1950 #endif
1951                 adapter->discovery_enable = 0x01;
1952
1953                 if (adapter->current_discovery_filter)
1954                         adapter->filtered_discovery = true;
1955                 else
1956                         adapter->filtered_discovery = false;
1957
1958                 if (adapter->discovering)
1959                         return;
1960
1961                 adapter->discovering = true;
1962                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1963                                         ADAPTER_INTERFACE, "Discovering");
1964                 return;
1965
1966 #ifdef __TIZEN_PATCH__
1967         } else {
1968                 adapter->discovering = false;
1969                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1970                                         ADAPTER_INTERFACE, "Discovering");
1971 #endif
1972
1973         }
1974
1975         /*
1976          * In case the restart of the discovery failed, then just trigger
1977          * it for the next idle timeout again.
1978          */
1979 #ifndef __TIZEN_PATCH__
1980         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
1981 #endif
1982 }
1983
1984 #ifdef __TIZEN_PATCH__
1985 static void start_le_discovery_complete(uint8_t status, uint16_t length,
1986                                         const void *param, void *user_data)
1987 {
1988         struct btd_adapter *adapter = user_data;
1989         const struct mgmt_cp_start_discovery *rp = param;
1990
1991         DBG("status 0x%02x", status);
1992         if (length < sizeof(*rp)) {
1993                 error("Wrong size of start discovery return parameters");
1994                 return;
1995         }
1996
1997         if (status == MGMT_STATUS_SUCCESS) {
1998                 adapter->discovery_type |= rp->type;
1999                 adapter->discovery_enable = 0x01;
2000
2001                 DBG("Discovery Type 0x%02x", rp->type);
2002
2003                 if (adapter->le_discovering)
2004                         return;
2005
2006                 adapter->le_discovering = true;
2007                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2008                                         ADAPTER_INTERFACE, "LEDiscovering");
2009
2010                 return;
2011         } else {
2012                 adapter->le_discovering = false;
2013                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2014                                         ADAPTER_INTERFACE, "LEDiscovering");
2015
2016         }
2017
2018         /*
2019          * In case the restart of the discovery failed, then just trigger
2020          * it for the next idle timeout again.
2021          */
2022 //      trigger_start_discovery(adapter, IDLE_LE_DISCOV_TIMEOUT * 2);
2023 }
2024 #endif
2025
2026 static gboolean start_discovery_timeout(gpointer user_data)
2027 {
2028         struct btd_adapter *adapter = user_data;
2029 #ifdef __TIZEN_PATCH__
2030         struct mgmt_cp_start_discovery cp;
2031         uint8_t new_type = 0;
2032 #else
2033         struct mgmt_cp_start_service_discovery *sd_cp;
2034         uint8_t new_type;
2035 #endif
2036
2037         DBG("");
2038
2039         adapter->discovery_idle_timeout = 0;
2040
2041 #ifdef __TIZEN_PATCH__
2042         if (adapter->disc_type == BT_DISC_TYPE_BREDR_ONLY) {
2043
2044                 if (adapter->current_settings & MGMT_SETTING_BREDR)
2045                         new_type = (1 << BDADDR_BREDR);
2046                 else
2047                         new_type = 0;
2048
2049         } else if (adapter->disc_type == BT_DISC_TYPE_LE_ONLY) {
2050
2051                 if (adapter->current_settings & MGMT_SETTING_LE)
2052                         new_type = (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
2053
2054         } else if (adapter->disc_type == BT_DISC_TYPE_LE_BREDR) {
2055
2056                 if (adapter->current_settings & MGMT_SETTING_BREDR)
2057                         new_type = (1 << BDADDR_BREDR);
2058                 else
2059                         new_type = 0;
2060                 if (adapter->current_settings & MGMT_SETTING_LE)
2061                         new_type |= (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
2062         }
2063
2064         if (adapter->discovery_enable == 0x01) {
2065                 /*
2066                  * If there is an already running discovery and it has the
2067                  * same type, then just keep it.
2068                  */
2069                 if (adapter->disc_type == BT_DISC_TYPE_BREDR_ONLY) {
2070                         if ((adapter->discovery_type & new_type) == 0x01) {
2071                                 if (adapter->discovering)
2072                                         return FALSE;
2073
2074                                 adapter->discovering = true;
2075                                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2076                                                 ADAPTER_INTERFACE, "Discovering");
2077
2078                                 return FALSE;
2079                         }
2080
2081                 }  else if (adapter->disc_type == BT_DISC_TYPE_LE_ONLY) {
2082                         if ((adapter->discovery_type & new_type) == 0x06) {
2083                                 if (adapter->le_discovering)
2084                                         return FALSE;
2085
2086                                 adapter->le_discovering = true;
2087                                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2088                                                 ADAPTER_INTERFACE, "LEDiscovering");
2089
2090                                 return FALSE;
2091                         }
2092                 }
2093         }
2094
2095         DBG("adapter->disc_type [%d]", adapter->disc_type);
2096         if (adapter->disc_type == BT_DISC_TYPE_BREDR_ONLY) {
2097                 cp.type = 0x01;
2098                 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2099                                         adapter->dev_id, sizeof(cp), &cp,
2100                                         start_discovery_complete, adapter, NULL);
2101
2102         } else if (adapter->disc_type == BT_DISC_TYPE_LE_ONLY) {
2103                 cp.type = 0x06;
2104                 mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2105                                         adapter->dev_id, sizeof(cp), &cp,
2106                                         start_le_discovery_complete, adapter, NULL);
2107         }
2108 #else
2109         /* If we're doing filtered discovery, it must be quickly restarted */
2110         adapter->no_scan_restart_delay = !!adapter->current_discovery_filter;
2111
2112         DBG("adapter->current_discovery_filter == %d",
2113             !!adapter->current_discovery_filter);
2114
2115         new_type = get_scan_type(adapter);
2116
2117         if (adapter->discovery_enable == 0x01) {
2118                 struct mgmt_cp_stop_discovery cp;
2119
2120                 /*
2121                  * If we're asked to start regular discovery, and there is an
2122                  * already running regular discovery and it has the same type,
2123                  * then just keep it.
2124                  */
2125                 if (!adapter->current_discovery_filter &&
2126                     !adapter->filtered_discovery &&
2127                     adapter->discovery_type == new_type) {
2128                         if (adapter->discovering)
2129                                 return FALSE;
2130
2131                         adapter->discovering = true;
2132                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2133                                         ADAPTER_INTERFACE, "Discovering");
2134                         return FALSE;
2135                 }
2136
2137                 /*
2138                  * Otherwise the current discovery must be stopped. So
2139                  * queue up a stop discovery command.
2140                  *
2141                  * This can happen if a passive scanning for Low Energy
2142                  * devices is ongoing, or scan type is changed between
2143                  * regular and filtered, or filter was updated.
2144                  */
2145                 cp.type = adapter->discovery_type;
2146                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2147                                         adapter->dev_id, sizeof(cp), &cp,
2148                                         NULL, NULL, NULL);
2149
2150                 /* Don't even bother to try to quickly start discovery
2151                  * just after stopping it, it would fail with status
2152                  * MGMT_BUSY. Instead discovering_callback will take
2153                  * care of that.
2154                  */
2155                 return FALSE;
2156
2157         }
2158
2159         /* Regular discovery is required */
2160         if (!adapter->current_discovery_filter) {
2161                 struct mgmt_cp_start_discovery cp;
2162
2163                 cp.type = new_type;
2164                 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2165                                 adapter->dev_id, sizeof(cp), &cp,
2166                                 start_discovery_complete, adapter, NULL);
2167                 return FALSE;
2168         }
2169
2170         /* Filtered discovery is required */
2171         sd_cp = adapter->current_discovery_filter;
2172
2173         DBG("sending MGMT_OP_START_SERVICE_DISCOVERY %d, %d, %d",
2174                                 sd_cp->rssi, sd_cp->type, sd_cp->uuid_count);
2175
2176         mgmt_send(adapter->mgmt, MGMT_OP_START_SERVICE_DISCOVERY,
2177                   adapter->dev_id, sizeof(*sd_cp) + sd_cp->uuid_count * 16,
2178                   sd_cp, start_discovery_complete, adapter, NULL);
2179
2180 #endif
2181
2182         return FALSE;
2183 }
2184
2185 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
2186 {
2187
2188         DBG("");
2189
2190         cancel_passive_scanning(adapter);
2191
2192         if (adapter->discovery_idle_timeout > 0) {
2193                 g_source_remove(adapter->discovery_idle_timeout);
2194                 adapter->discovery_idle_timeout = 0;
2195         }
2196
2197         /*
2198          * If the controller got powered down in between, then ensure
2199          * that we do not keep trying to restart discovery.
2200          *
2201          * This is safe-guard and should actually never trigger.
2202          */
2203         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2204                 return;
2205
2206 #ifdef __TIZEN_PATCH__
2207         if (delay == 0) {
2208                 start_discovery_timeout((gpointer)adapter);
2209                 return;
2210         }
2211 #endif
2212         adapter->discovery_idle_timeout = g_timeout_add_seconds(delay,
2213                                         start_discovery_timeout, adapter);
2214 }
2215
2216 #ifndef __TIZEN_PATCH__
2217 static void suspend_discovery_complete(uint8_t status, uint16_t length,
2218                                         const void *param, void *user_data)
2219 {
2220         struct btd_adapter *adapter = user_data;
2221
2222         DBG("status 0x%02x", status);
2223
2224         if (status == MGMT_STATUS_SUCCESS) {
2225 #ifdef __TIZEN_PATCH__
2226                 adapter->discovery_type &= (~0x01);
2227 #else
2228                 adapter->discovery_type = 0x00;
2229 #endif
2230                 adapter->discovery_enable = 0x00;
2231                 return;
2232         }
2233 }
2234
2235 #ifdef __TIZEN_PATCH__
2236 static void suspend_le_discovery_complete(uint8_t status, uint16_t length,
2237                                         const void *param, void *user_data)
2238 {
2239         struct btd_adapter *adapter = user_data;
2240
2241         DBG("status 0x%02x", status);
2242
2243         if (status == MGMT_STATUS_SUCCESS) {
2244                 adapter->discovery_type &= (~0x06);
2245                 adapter->discovery_enable = 0x00;
2246                 return;
2247         }
2248 }
2249 #endif
2250
2251 static void suspend_discovery(struct btd_adapter *adapter)
2252 {
2253         struct mgmt_cp_stop_discovery cp;
2254 #ifdef __TIZEN_PATCH__
2255         struct mgmt_cp_stop_le_discovery le_cp;
2256 #endif
2257
2258         DBG("");
2259
2260         adapter->discovery_suspended = true;
2261
2262         /*
2263          * If there are no clients discovering right now, then there is
2264          * also nothing to suspend.
2265          */
2266 #ifdef __TIZEN_PATCH__
2267         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL )
2268                 return;
2269 #else
2270         if (!adapter->discovery_list)
2271                 return;
2272 #endif
2273
2274
2275         /*
2276          * In case of being inside the idle phase, make sure to remove
2277          * the timeout to not trigger a restart.
2278          *
2279          * The restart will be triggered when the discovery is resumed.
2280          */
2281         if (adapter->discovery_idle_timeout > 0) {
2282                 g_source_remove(adapter->discovery_idle_timeout);
2283                 adapter->discovery_idle_timeout = 0;
2284         }
2285
2286         if (adapter->discovery_enable == 0x00)
2287                 return;
2288
2289 #ifdef __TIZEN_PATCH__
2290         if (adapter->discovery_list) {
2291                 cp.type = 0x01;
2292                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2293                                         adapter->dev_id, sizeof(cp), &cp,
2294                                         suspend_discovery_complete, adapter, NULL);
2295         }
2296         if (adapter->le_discovery_list) {
2297                 le_cp.type = 0x06;
2298                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
2299                                 adapter->dev_id, sizeof(le_cp), &le_cp,
2300                                 suspend_le_discovery_complete, adapter, NULL);
2301         }
2302 #else
2303         cp.type = adapter->discovery_type;
2304
2305         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2306                                 adapter->dev_id, sizeof(cp), &cp,
2307                                 suspend_discovery_complete, adapter, NULL);
2308 #endif
2309 }
2310
2311 static void resume_discovery(struct btd_adapter *adapter)
2312 {
2313         DBG("");
2314
2315         adapter->discovery_suspended = false;
2316
2317         /*
2318          * If there are no clients discovering right now, then there is
2319          * also nothing to resume.
2320          */
2321         if (!adapter->discovery_list)
2322                 return;
2323
2324         /*
2325          * Treat a suspended discovery session the same as extra long
2326          * idle time for a normal discovery. So just trigger the default
2327          * restart procedure.
2328          */
2329 #ifdef __TIZEN_PATCH__
2330         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
2331 #endif
2332         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2333 }
2334
2335 #ifdef __TIZEN_PATCH__
2336 static void resume_le_discovery(struct btd_adapter *adapter)
2337 {
2338         DBG("");
2339
2340         adapter->discovery_suspended = false;
2341
2342         /*
2343          * If there are no clients discovering right now, then there is
2344          * also nothing to resume.
2345          */
2346         if (adapter->le_discovery_list == NULL)
2347                 return;
2348
2349         /*
2350          * Treat a suspended discovery session the same as extra long
2351          * idle time for a normal discovery. So just trigger the default
2352          * restart procedure.
2353          */
2354         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
2355         trigger_start_discovery(adapter, IDLE_LE_DISCOV_TIMEOUT);
2356 }
2357 #endif
2358 #endif
2359
2360 static void discovering_callback(uint16_t index, uint16_t length,
2361                                         const void *param, void *user_data)
2362 {
2363         const struct mgmt_ev_discovering *ev = param;
2364         struct btd_adapter *adapter = user_data;
2365
2366         if (length < sizeof(*ev)) {
2367                 btd_error(adapter->dev_id, "Too small discovering event");
2368                 return;
2369         }
2370
2371         DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
2372                                 ev->discovering, adapter->filtered_discovery);
2373
2374 #ifdef __TIZEN_PATCH__
2375         DBG("info discov_type %d", adapter->discovery_type);
2376         if (ev->type == DISCOV_TYPE_BREDR) {
2377                 if (ev->discovering == FALSE) {
2378                         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
2379                         adapter->discovering = false;
2380                 } else {
2381                         hci_set_bit(BDADDR_BREDR, &adapter->discovery_type);
2382                         adapter->discovering = true;
2383                 }
2384                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2385                                         ADAPTER_INTERFACE, "Discovering");
2386
2387         } else if (ev->type == DISCOV_TYPE_LE) {
2388                 if (ev->discovering == FALSE) {
2389                         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2390                         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2391                         adapter->le_discovering = false;
2392                 } else {
2393                         hci_set_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2394                         hci_set_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2395                         adapter->le_discovering = true;
2396                 }
2397
2398                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2399                                         ADAPTER_INTERFACE, "LEDiscovering");
2400         }
2401 #else
2402         if (adapter->discovery_enable == ev->discovering)
2403                 return;
2404
2405         adapter->discovery_type = ev->type;
2406         adapter->discovery_enable = ev->discovering;
2407 #endif
2408
2409         /*
2410          * Check for existing discoveries triggered by client applications
2411          * and ignore all others.
2412          *
2413          * If there are no clients, then it is good idea to trigger a
2414          * passive scanning attempt.
2415          */
2416 #ifdef __TIZEN_PATCH__
2417         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2418                 if (!adapter->connect_le)
2419                         trigger_passive_scanning(adapter);
2420                 return;
2421         }
2422 #else
2423         if (!adapter->discovery_list) {
2424                 if (!adapter->connect_le)
2425                         trigger_passive_scanning(adapter);
2426                 return;
2427         }
2428 #endif
2429
2430         if (adapter->discovery_suspended)
2431                 return;
2432
2433         switch (adapter->discovery_enable) {
2434         case 0x00:
2435                 if (adapter->no_scan_restart_delay)
2436                         trigger_start_discovery(adapter, 0);
2437                 else
2438                         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2439                 break;
2440
2441         case 0x01:
2442                 if (adapter->discovery_idle_timeout > 0) {
2443                         g_source_remove(adapter->discovery_idle_timeout);
2444                         adapter->discovery_idle_timeout = 0;
2445                 }
2446
2447                 break;
2448         }
2449 }
2450
2451 #ifdef __TIZEN_PATCH__
2452 static void stop_discovery_complete(uint8_t status, uint16_t length,
2453                                         const void *param, void *user_data)
2454 {
2455         struct btd_adapter *adapter = user_data;
2456
2457         DBG("status 0x%02x", status);
2458
2459         if (status == MGMT_STATUS_SUCCESS) {
2460                 adapter->discovery_type &= (~0x01);
2461                 DBG("Discovery Type 0x%02x", adapter->discovery_type);
2462
2463                 adapter->filtered_discovery = false;
2464                 adapter->no_scan_restart_delay = false;
2465                 adapter->discovering = false;
2466                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2467                                         ADAPTER_INTERFACE, "Discovering");
2468
2469                 if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2470                         adapter->discovery_enable = 0x00;
2471                         trigger_passive_scanning(adapter);
2472                 }
2473         }
2474 }
2475
2476 static void stop_le_discovery_complete(uint8_t status, uint16_t length,
2477                                         const void *param, void *user_data)
2478 {
2479         struct btd_adapter *adapter = user_data;
2480
2481         DBG("status 0x%02x", status);
2482
2483         if (status == MGMT_STATUS_SUCCESS) {
2484                 adapter->discovery_type &= (~0x06);
2485                 DBG("Discovery Type 0x%02x", adapter->discovery_type);
2486
2487                 adapter->filtered_discovery = false;
2488                 adapter->no_scan_restart_delay = false;
2489                 adapter->le_discovering = false;
2490                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2491                                         ADAPTER_INTERFACE, "LEDiscovering");
2492
2493                 if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2494                         adapter->discovery_enable = 0x00;
2495                         trigger_passive_scanning(adapter);
2496                 }
2497         }
2498 }
2499
2500 #else
2501
2502 static void stop_discovery_complete(uint8_t status, uint16_t length,
2503                                         const void *param, void *user_data)
2504 {
2505         struct btd_adapter *adapter = user_data;
2506
2507         DBG("status 0x%02x", status);
2508
2509         if (status == MGMT_STATUS_SUCCESS) {
2510                 adapter->discovery_type = 0x00;
2511                 adapter->discovery_enable = 0x00;
2512                 adapter->filtered_discovery = false;
2513                 adapter->no_scan_restart_delay = false;
2514                 adapter->discovering = false;
2515                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2516                                         ADAPTER_INTERFACE, "Discovering");
2517
2518                 trigger_passive_scanning(adapter);
2519         }
2520 }
2521 #endif
2522
2523
2524 static int compare_sender(gconstpointer a, gconstpointer b)
2525 {
2526         const struct watch_client *client = a;
2527         const char *sender = b;
2528
2529         return g_strcmp0(client->owner, sender);
2530 }
2531
2532 static void invalidate_rssi_and_tx_power(gpointer a)
2533 {
2534         struct btd_device *dev = a;
2535
2536         device_set_rssi(dev, 0);
2537         device_set_tx_power(dev, 127);
2538 }
2539
2540 static void discovery_cleanup(struct btd_adapter *adapter)
2541 {
2542         g_slist_free_full(adapter->discovery_found,
2543                                                 invalidate_rssi_and_tx_power);
2544         adapter->discovery_found = NULL;
2545 }
2546
2547 #ifndef __TIZEN_PATCH__
2548 static gboolean remove_temp_devices(gpointer user_data)
2549 {
2550         struct btd_adapter *adapter = user_data;
2551         GSList *l, *next;
2552
2553         DBG("%s", adapter->path);
2554
2555         adapter->temp_devices_timeout = 0;
2556
2557         for (l = adapter->devices; l != NULL; l = next) {
2558                 struct btd_device *dev = l->data;
2559
2560                 next = g_slist_next(l);
2561
2562                 if (device_is_temporary(dev) && !btd_device_is_connected(dev))
2563                         btd_adapter_remove_device(adapter, dev);
2564         }
2565
2566         return FALSE;
2567 }
2568 #endif
2569
2570 static gint g_strcmp(gconstpointer a, gconstpointer b)
2571 {
2572         return strcmp(a, b);
2573 }
2574
2575 static void extract_unique_uuids(gpointer data, gpointer user_data)
2576 {
2577         char *uuid_str = data;
2578         GSList **uuids = user_data;
2579
2580         if (!g_slist_find_custom(*uuids, uuid_str, g_strcmp))
2581                 *uuids = g_slist_insert_sorted(*uuids, uuid_str, g_strcmp);
2582 }
2583
2584 /*
2585  * This method merges all adapter filters into rssi, transport and uuids.
2586  * Returns 1 if there was no filtered scan, 0 otherwise.
2587  */
2588 static int merge_discovery_filters(struct btd_adapter *adapter, int *rssi,
2589                                         uint8_t *transport, GSList **uuids)
2590 {
2591         GSList *l;
2592         bool empty_uuid = false;
2593         bool has_regular_discovery = false;
2594         bool has_filtered_discovery = false;
2595
2596         for (l = adapter->discovery_list; l != NULL; l = g_slist_next(l)) {
2597                 struct watch_client *client = l->data;
2598                 struct discovery_filter *item = client->discovery_filter;
2599
2600                 if (!item) {
2601                         has_regular_discovery = true;
2602                         continue;
2603                 }
2604
2605                 has_filtered_discovery = true;
2606
2607                 *transport |= item->type;
2608
2609                 /*
2610                  * Rule for merging rssi and pathloss into rssi field of kernel
2611                  * filter is as follow:
2612                  * - if there's any client without proximity filter, then do no
2613                  *   proximity filtering,
2614                  * - if all clients specified RSSI, then use lowest value,
2615                  * - if any client specified pathloss, then kernel filter should
2616                  *   do no proximity, as kernel can't compute pathloss. We'll do
2617                  *   filtering on our own.
2618                  */
2619                 if (item->rssi == DISTANCE_VAL_INVALID)
2620                         *rssi = HCI_RSSI_INVALID;
2621                 else if (*rssi != HCI_RSSI_INVALID && *rssi >= item->rssi)
2622                         *rssi = item->rssi;
2623                 else if (item->pathloss != DISTANCE_VAL_INVALID)
2624                         *rssi = HCI_RSSI_INVALID;
2625
2626                 if (!g_slist_length(item->uuids))
2627                         empty_uuid = true;
2628
2629                 g_slist_foreach(item->uuids, extract_unique_uuids, uuids);
2630         }
2631
2632         /* If no proximity filtering is set, disable it */
2633         if (*rssi == DISTANCE_VAL_INVALID)
2634                 *rssi = HCI_RSSI_INVALID;
2635
2636         /*
2637          * Empty_uuid variable determines wether there was any filter with no
2638          * uuids. In this case someone might be looking for all devices in
2639          * certain proximity, and we need to have empty uuids in kernel filter.
2640          */
2641         if (empty_uuid) {
2642                 g_slist_free(*uuids);
2643                 *uuids = NULL;
2644         }
2645
2646         if (has_regular_discovery) {
2647                 if (!has_filtered_discovery)
2648                         return 1;
2649
2650                 /*
2651                  * It there is both regular and filtered scan running, then
2652                  * clear whole fitler to report all devices.
2653                  */
2654                 *transport = get_scan_type(adapter);
2655                 *rssi = HCI_RSSI_INVALID;
2656                 g_slist_free(*uuids);
2657                 *uuids = NULL;
2658         }
2659
2660         return 0;
2661 }
2662
2663 static void populate_mgmt_filter_uuids(uint8_t (*mgmt_uuids)[16], GSList *uuids)
2664 {
2665         GSList *l;
2666
2667         for (l = uuids; l != NULL; l = g_slist_next(l)) {
2668                 bt_uuid_t uuid, u128;
2669                 uint128_t uint128;
2670
2671                 bt_string_to_uuid(&uuid, l->data);
2672                 bt_uuid_to_uuid128(&uuid, &u128);
2673
2674                 ntoh128((uint128_t *) u128.value.u128.data, &uint128);
2675                 htob128(&uint128, (uint128_t *) mgmt_uuids);
2676
2677                 mgmt_uuids++;
2678         }
2679 }
2680
2681 /*
2682  * This method merges all adapter filters into one that will be send to kernel.
2683  * cp_ptr is set to null when regular non-filtered discovery is needed,
2684  * otherwise it's pointing to filter. Returns 0 on succes, -1 on error
2685  */
2686 static int discovery_filter_to_mgmt_cp(struct btd_adapter *adapter,
2687                        struct mgmt_cp_start_service_discovery **cp_ptr)
2688 {
2689         GSList *uuids = NULL;
2690         struct mgmt_cp_start_service_discovery *cp;
2691         int rssi = DISTANCE_VAL_INVALID;
2692         int uuid_count;
2693         uint8_t discovery_type = 0;
2694
2695         DBG("");
2696
2697         if (merge_discovery_filters(adapter, &rssi, &discovery_type, &uuids)) {
2698                 /* There are only regular scans, run just regular scan. */
2699                 *cp_ptr = NULL;
2700                 return 0;
2701         }
2702
2703         uuid_count = g_slist_length(uuids);
2704
2705         cp = g_try_malloc(sizeof(*cp) + 16*uuid_count);
2706         *cp_ptr = cp;
2707         if (!cp) {
2708                 g_slist_free(uuids);
2709                 return -1;
2710         }
2711
2712         cp->type = discovery_type;
2713         cp->rssi = rssi;
2714         cp->uuid_count = uuid_count;
2715         populate_mgmt_filter_uuids(cp->uuids, uuids);
2716
2717         g_slist_free(uuids);
2718         return 0;
2719 }
2720
2721 static bool filters_equal(struct mgmt_cp_start_service_discovery *a,
2722                    struct mgmt_cp_start_service_discovery *b) {
2723         if (!a && !b)
2724                 return true;
2725
2726         if ((!a && b) || (a && !b))
2727                 return false;
2728
2729         if (a->type != b->type)
2730                 return false;
2731
2732         if (a->rssi != b->rssi)
2733                 return false;
2734
2735         /*
2736          * When we create mgmt_cp_start_service_discovery structure inside
2737          * discovery_filter_to_mgmt_cp, we always keep uuids sorted, and
2738          * unique, so we're safe to compare uuid_count, and uuids like that.
2739          */
2740         if (a->uuid_count != b->uuid_count)
2741                 return false;
2742
2743         if (memcmp(a->uuids, b->uuids, 16 * a->uuid_count) != 0)
2744                 return false;
2745
2746         return true;
2747 }
2748
2749 static void update_discovery_filter(struct btd_adapter *adapter)
2750 {
2751         struct mgmt_cp_start_service_discovery *sd_cp;
2752
2753         DBG("");
2754
2755         if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
2756                 btd_error(adapter->dev_id,
2757                                 "discovery_filter_to_mgmt_cp returned error");
2758                 return;
2759         }
2760
2761         /*
2762          * If filters are equal, then don't update scan, except for when
2763          * starting discovery.
2764          */
2765         if (filters_equal(adapter->current_discovery_filter, sd_cp) &&
2766             adapter->discovering != 0) {
2767                 DBG("filters were equal, deciding to not restart the scan.");
2768                 g_free(sd_cp);
2769                 return;
2770         }
2771
2772         g_free(adapter->current_discovery_filter);
2773         adapter->current_discovery_filter = sd_cp;
2774
2775         trigger_start_discovery(adapter, 0);
2776 }
2777
2778 static void discovery_destroy(void *user_data)
2779 {
2780         struct watch_client *client = user_data;
2781         struct btd_adapter *adapter = client->adapter;
2782
2783         DBG("owner %s", client->owner);
2784
2785         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2786                                                                 client);
2787
2788         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2789                                                                 client);
2790
2791         if (client->discovery_filter) {
2792                 free_discovery_filter(client->discovery_filter);
2793                 client->discovery_filter = NULL;
2794         }
2795
2796         g_free(client->owner);
2797         g_free(client);
2798
2799         /*
2800          * If there are other client discoveries in progress, then leave
2801          * it active. If not, then make sure to stop the restart timeout.
2802          */
2803
2804 #ifdef __TIZEN_PATCH__
2805         if (adapter->discovery_list || adapter->le_discovery_list)
2806                 return;
2807 #else
2808         if (adapter->discovery_list)
2809                 return;
2810 #endif
2811
2812         adapter->discovery_type = 0x00;
2813
2814         if (adapter->discovery_idle_timeout > 0) {
2815                 g_source_remove(adapter->discovery_idle_timeout);
2816                 adapter->discovery_idle_timeout = 0;
2817         }
2818
2819         if (adapter->temp_devices_timeout > 0) {
2820                 g_source_remove(adapter->temp_devices_timeout);
2821                 adapter->temp_devices_timeout = 0;
2822         }
2823
2824         discovery_cleanup(adapter);
2825 #ifndef __TIZEN_PATCH__
2826         adapter->temp_devices_timeout = g_timeout_add_seconds(TEMP_DEV_TIMEOUT,
2827                                                 remove_temp_devices, adapter);
2828 #endif
2829 }
2830
2831 /*
2832  * Returns true if client was already discovering, false otherwise. *client
2833  * will point to discovering client, or client that have pre-set his filter.
2834  */
2835 static bool get_discovery_client(struct btd_adapter *adapter,
2836                                                 const char *owner,
2837                                                 struct watch_client **client)
2838 {
2839         GSList *list = g_slist_find_custom(adapter->discovery_list, owner,
2840                                                                 compare_sender);
2841         if (list) {
2842                 *client = list->data;
2843                 return true;
2844         }
2845
2846         list = g_slist_find_custom(adapter->set_filter_list, owner,
2847                                                                 compare_sender);
2848         if (list) {
2849                 *client = list->data;
2850                 return false;
2851         }
2852
2853         *client = NULL;
2854         return false;
2855 }
2856
2857
2858 #ifdef __TIZEN_PATCH__
2859 static void le_discovery_destroy(void *user_data)
2860 {
2861         struct watch_client *client = user_data;
2862         struct btd_adapter *adapter = client->adapter;
2863
2864         DBG("owner %s", client->owner);
2865
2866         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
2867                                                                 client);
2868
2869         g_free(client->owner);
2870         g_free(client);
2871
2872         /*
2873          * If there are other client discoveries in progress, then leave
2874          * it active. If not, then make sure to stop the restart timeout.
2875          */
2876         DBG("adapter->discovery_list[%p] adapter->le_discovery_list[%p]",
2877                         adapter->discovery_list, adapter->le_discovery_list);
2878         if (adapter->discovery_list || adapter->le_discovery_list)
2879                 return;
2880
2881         adapter->discovery_type = 0x00;
2882         DBG("Restart Timer... adapter->discovery_type[%d]", adapter->discovery_type);
2883         if (adapter->discovery_idle_timeout > 0) {
2884                 g_source_remove(adapter->discovery_idle_timeout);
2885                 adapter->discovery_idle_timeout = 0;
2886         }
2887
2888         if (adapter->temp_devices_timeout > 0) {
2889                 g_source_remove(adapter->temp_devices_timeout);
2890                 adapter->temp_devices_timeout = 0;
2891         }
2892
2893         discovery_cleanup(adapter);
2894 #ifndef __TIZEN_PATCH__
2895         adapter->temp_devices_timeout = g_timeout_add_seconds(TEMP_DEV_TIMEOUT,
2896                                                 remove_temp_devices, adapter);
2897 #endif
2898 }
2899 #endif
2900
2901 static void discovery_disconnect(DBusConnection *conn, void *user_data)
2902 {
2903         struct watch_client *client = user_data;
2904         struct btd_adapter *adapter = client->adapter;
2905         struct mgmt_cp_stop_discovery cp;
2906
2907         DBG("owner %s", client->owner);
2908
2909         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2910                                                                 client);
2911
2912         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2913                                                                 client);
2914
2915         /*
2916          * There is no need for extra cleanup of the client since that
2917          * will be done by the destroy callback.
2918          *
2919          * However in case this is the last client, the discovery in
2920          * the kernel needs to be disabled.
2921          */
2922         if (adapter->discovery_list) {
2923                 update_discovery_filter(adapter);
2924                 return;
2925         }
2926
2927         /*
2928          * In the idle phase of a discovery, there is no need to stop it
2929          * and so it is enough to send out the signal and just return.
2930          */
2931         if (adapter->discovery_enable == 0x00) {
2932                 adapter->discovering = false;
2933                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2934                                         ADAPTER_INTERFACE, "Discovering");
2935
2936 #ifdef __TIZEN_PATCH__
2937                 if (adapter->discovering == false  && adapter->le_discovering == false) {
2938                         trigger_passive_scanning(adapter);
2939                         return;
2940                 }
2941 #else
2942                 trigger_passive_scanning(adapter);
2943                 return;
2944 #endif
2945         }
2946
2947 #ifdef __TIZEN_PATCH__
2948         cp.type = 0x01;
2949 #else
2950         cp.type = adapter->discovery_type;
2951 #endif
2952
2953         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2954                                 adapter->dev_id, sizeof(cp), &cp,
2955                                 stop_discovery_complete, adapter, NULL);
2956 }
2957
2958 #ifdef __TIZEN_PATCH__
2959 static void le_discovery_disconnect(DBusConnection *conn, void *user_data)
2960 {
2961         struct watch_client *client = user_data;
2962         struct btd_adapter *adapter = client->adapter;
2963         struct mgmt_cp_stop_le_discovery cp;
2964
2965         DBG("owner %s", client->owner);
2966
2967         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
2968                                                                 client);
2969
2970         /*
2971          * There is no need for extra cleanup of the client since that
2972          * will be done by the destroy callback.
2973          *
2974          * However in case this is the last client, the discovery in
2975          * the kernel needs to be disabled.
2976          */
2977         if (adapter->le_discovery_list)
2978                 return;
2979
2980         /*
2981          * In the idle phase of a discovery, there is no need to stop it
2982          * and so it is enough to send out the signal and just return.
2983          */
2984         if (adapter->discovery_enable == 0x00) {
2985                 adapter->le_discovering = false;
2986                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2987                                         ADAPTER_INTERFACE, "LEDiscovering");
2988
2989                 if (adapter->discovering == false  && adapter->le_discovering == false) {
2990                         trigger_passive_scanning(adapter);
2991                         return;
2992                 }
2993         }
2994
2995         cp.type = 0x06;
2996
2997         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
2998                                 adapter->dev_id, sizeof(cp), &cp,
2999                                 stop_discovery_complete, adapter, NULL);
3000 }
3001 #endif
3002
3003 static DBusMessage *start_discovery(DBusConnection *conn,
3004                                         DBusMessage *msg, void *user_data)
3005 {
3006         struct btd_adapter *adapter = user_data;
3007         const char *sender = dbus_message_get_sender(msg);
3008         struct watch_client *client;
3009         bool is_discovering;
3010
3011         DBG("sender %s", sender);
3012
3013         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3014                 return btd_error_not_ready(msg);
3015
3016         is_discovering = get_discovery_client(adapter, sender, &client);
3017
3018         /*
3019          * Every client can only start one discovery, if the client
3020          * already started a discovery then return an error.
3021          */
3022         if (is_discovering)
3023                 return btd_error_busy(msg);
3024
3025         /*
3026          * If there was pre-set filter, just reconnect it to discovery_list,
3027          * and trigger scan.
3028          */
3029         if (client) {
3030                 adapter->set_filter_list = g_slist_remove(
3031                                              adapter->set_filter_list, client);
3032                 adapter->discovery_list = g_slist_prepend(
3033                                               adapter->discovery_list, client);
3034                 update_discovery_filter(adapter);
3035                 return dbus_message_new_method_return(msg);
3036         }
3037
3038         client = g_new0(struct watch_client, 1);
3039
3040         client->adapter = adapter;
3041         client->owner = g_strdup(sender);
3042         client->discovery_filter = NULL;
3043         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
3044                                                 discovery_disconnect, client,
3045                                                 discovery_destroy);
3046         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
3047                                                                 client);
3048
3049 #ifdef __TIZEN_PATCH__
3050         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3051 #endif
3052
3053         /*
3054          * Just trigger the discovery here. In case an already running
3055          * discovery in idle phase exists, it will be restarted right
3056          * away.
3057          */
3058         update_discovery_filter(adapter);
3059
3060         return dbus_message_new_method_return(msg);
3061 }
3062
3063 #ifdef __TIZEN_PATCH__
3064 static int set_adv_data_flag(uint8_t *adv_data, uint8_t *data, int data_len)
3065 {
3066         adv_data[0] = 2;
3067         adv_data[1] = EIR_FLAGS;
3068         adv_data[2] = EIR_GEN_DISC;
3069
3070         memcpy(adv_data + 3, data, data_len);
3071         return data_len + 3;
3072 }
3073
3074 static int set_adv_data_device_name(uint8_t *adv_data, int adv_len, char *name)
3075 {
3076         int ad_type;
3077         int ad_len;
3078         int i, j;
3079         int name_len;
3080         uint8_t *data = NULL;
3081
3082         if (!name)
3083                 return adv_len;
3084
3085         data = g_memdup(adv_data, adv_len);
3086         if (!data)
3087                 return adv_len;
3088
3089         name_len = strlen(name);
3090
3091         for (i = 0; i <adv_len ; i++) {
3092                 ad_len = data[i];
3093                 ad_type = data[i + 1];
3094
3095                 if (ad_type == EIR_NAME_COMPLETE) {
3096                         /* Move to last position and update local name */
3097                         for (j = i; j < adv_len - 2; j++)
3098                                 adv_data[j] = data[j + 2];
3099
3100                         adv_data[j] = name_len + 1;
3101                         if (name_len > ADV_DATA_MAX_LENGTH - adv_len) {
3102                                 adv_data[j] = ADV_DATA_MAX_LENGTH - adv_len + 1;
3103                                 adv_data[j + 1] = EIR_NAME_SHORT;
3104                                 memcpy(adv_data + j + 2, name, ADV_DATA_MAX_LENGTH - adv_len);
3105                                 g_free(data);
3106                                 return ADV_DATA_MAX_LENGTH;
3107                         } else {
3108                                 adv_data[j + 1] = EIR_NAME_COMPLETE;
3109                                 memcpy(adv_data + j + 2, name, name_len);
3110                                 g_free(data);
3111                                 return adv_len + name_len;
3112                         }
3113
3114                 } else {
3115                         memcpy(adv_data + i, &data[i], ad_len + 1);
3116                         i = i + data[i];
3117                 }
3118         }
3119
3120         g_free(data);
3121         return adv_len;
3122 }
3123
3124 static int set_adv_data_tx_power(uint8_t *adv_data, int adv_len, int8_t tx_power)
3125 {
3126         int ad_type;
3127         int ad_len;
3128         int i, j;
3129         uint8_t *data = NULL;
3130
3131         data = g_memdup(adv_data, adv_len);
3132         if (!data)
3133                 return adv_len;
3134
3135         for (i = 0; i <adv_len ; i++) {
3136                 ad_len = data[i];
3137                 ad_type = data[i + 1];
3138
3139                 if (ad_type == EIR_TX_POWER) {
3140                         adv_data[i] = 2;
3141                         adv_data[i + 1] = EIR_TX_POWER;
3142                         adv_data[i + 2] = tx_power;
3143
3144                         for(j = i + 2; j < adv_len; j++)
3145                                 adv_data[j + 1] = data[j];
3146
3147                         g_free(data);
3148                         return adv_len + 1;
3149                 } else {
3150                         memcpy(adv_data + i, &data[i], ad_len + 1);
3151                         i = i + data[i];
3152                 }
3153         }
3154
3155         g_free(data);
3156         return adv_len;
3157 }
3158
3159
3160 int adapter_le_set_missed_adv_data(uint8_t *p_data, uint8_t data_len,
3161                 gboolean is_scan_rsp, char *adapter_name, int8_t tx_power, uint8_t **adv_data, int *adv_len)
3162 {
3163         uint8_t *data;
3164         int len;
3165
3166         data = g_malloc0(ADV_DATA_MAX_LENGTH);
3167         /* Fix : NULL_RETURNS */
3168         if (data == NULL) {
3169                 return -1;
3170         }
3171
3172         memcpy(data, p_data, data_len);
3173         len = data_len;
3174
3175         /* In case multi advertising, need to update the below AD type
3176                 since it handled into kernel */
3177         if (!is_scan_rsp) {
3178                 len = set_adv_data_flag(data, p_data, data_len);
3179         }
3180
3181         len = set_adv_data_tx_power(data, len, tx_power);
3182
3183         len = set_adv_data_device_name(data, len, adapter_name);
3184
3185         *adv_data = data;
3186         *adv_len = len;
3187         return 0;
3188 }
3189
3190 static DBusMessage *adapter_start_custom_discovery(DBusConnection *conn,
3191                                         DBusMessage *msg, void *user_data)
3192 {
3193         struct btd_adapter *adapter = user_data;
3194         const char *sender = dbus_message_get_sender(msg);
3195         struct watch_client *client;
3196         GSList *list;
3197         const gchar *disc_type;
3198
3199         DBG("sender %s", sender);
3200
3201         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3202                 return btd_error_not_ready(msg);
3203
3204         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &disc_type,
3205                                                         DBUS_TYPE_INVALID)) {
3206                 return btd_error_invalid_args(msg);
3207         }
3208
3209         DBG("discovery type = %s", disc_type);
3210
3211         /*Valid strings: "BREDR", "LE", "LE_BREDR" */
3212         if (g_strcmp0(disc_type, "BREDR") == 0)
3213                 adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3214         else if (g_strcmp0(disc_type, "LE") == 0)
3215                 adapter->disc_type =  BT_DISC_TYPE_LE_ONLY;
3216         else if (g_strcmp0(disc_type, "LE_BREDR") == 0)
3217                 adapter->disc_type =  BT_DISC_TYPE_LE_BREDR;
3218         else
3219                 return btd_error_invalid_args(msg);
3220
3221         /*
3222          * Every client can only start one discovery, if the client
3223          * already started a discovery then return an error.
3224          */
3225         list = g_slist_find_custom(adapter->discovery_list, sender,
3226                                                 compare_sender);
3227         if (list)
3228                 return btd_error_busy(msg);
3229
3230         client = g_new0(struct watch_client, 1);
3231
3232         client->adapter = adapter;
3233         client->owner = g_strdup(sender);
3234         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
3235                                                 discovery_disconnect, client,
3236                                                 discovery_destroy);
3237
3238         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
3239                                                                 client);
3240
3241         /*
3242          * Just trigger the discovery here. In case an already running
3243          * discovery in idle phase exists, it will be restarted right
3244          * away.
3245          */
3246         trigger_start_discovery(adapter, 0);
3247
3248         return dbus_message_new_method_return(msg);
3249 }
3250
3251 static DBusMessage *adapter_start_le_discovery(DBusConnection *conn,
3252                                         DBusMessage *msg, void *user_data)
3253 {
3254         struct btd_adapter *adapter = user_data;
3255         const char *sender = dbus_message_get_sender(msg);
3256         struct watch_client *client;
3257         GSList *list;
3258
3259         DBG("sender %s", sender);
3260
3261         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3262                 return btd_error_not_ready(msg);
3263
3264         /*
3265          * Every client can only start one discovery, if the client
3266          * already started a discovery then return an error.
3267          */
3268
3269         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
3270         DBG("adapter->disc_type[%d]", adapter->disc_type);
3271         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
3272
3273         list = g_slist_find_custom(adapter->le_discovery_list, sender,
3274                                                 compare_sender);
3275         if (list)
3276                 return btd_error_busy(msg);
3277
3278         client = g_new0(struct watch_client, 1);
3279
3280         client->adapter = adapter;
3281         client->owner = g_strdup(sender);
3282         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
3283                                                 le_discovery_disconnect, client,
3284                                                 le_discovery_destroy);
3285
3286         adapter->le_discovery_list = g_slist_prepend(adapter->le_discovery_list,
3287                                                                 client);
3288
3289         /*
3290          * Just trigger the discovery here. In case an already running
3291          * discovery in idle phase exists, it will be restarted right
3292          * away.
3293          */
3294         trigger_start_discovery(adapter, 0);
3295
3296         return dbus_message_new_method_return(msg);
3297 }
3298
3299 static DBusMessage *adapter_stop_le_discovery(DBusConnection *conn,
3300                                         DBusMessage *msg, void *user_data)
3301 {
3302         struct btd_adapter *adapter = user_data;
3303         const char *sender = dbus_message_get_sender(msg);
3304         struct mgmt_cp_stop_le_discovery cp;
3305         struct watch_client *client;
3306         GSList *list;
3307
3308         DBG("sender %s", sender);
3309
3310         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3311                 return btd_error_not_ready(msg);
3312
3313         list = g_slist_find_custom(adapter->le_discovery_list, sender,
3314                                                 compare_sender);
3315         if (!list)
3316                 return btd_error_failed(msg, "No discovery started");
3317
3318         client = list->data;
3319
3320         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
3321         DBG("adapter->disc_type[%d]", adapter->disc_type);
3322         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
3323
3324         cp.type = adapter->discovery_type;
3325         DBG("cp.type %d", cp.type);
3326
3327         /*
3328          * The destroy function will cleanup the client information and
3329          * also remove it from the list of discovery clients.
3330          */
3331         g_dbus_remove_watch(dbus_conn, client->watch);
3332
3333         /*
3334          * As long as other discovery clients are still active, just
3335          * return success.
3336          */
3337         DBG("cp.type %d", cp.type);
3338         DBG("adapter->le_discovery_list %d", adapter->discovery_type);
3339         if (adapter->le_discovery_list)
3340                 return dbus_message_new_method_return(msg);
3341
3342         /*
3343          * In the idle phase of a discovery, there is no need to stop it
3344          * and so it is enough to send out the signal and just return.
3345          */
3346         DBG("cp.type %d", cp.type);
3347         DBG("adapter->discovery_enable %d", adapter->discovery_enable);
3348         if (adapter->discovery_enable == 0x00) {
3349                 adapter->le_discovering = false;
3350                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3351                                         ADAPTER_INTERFACE, "LEDiscovering");
3352
3353                 trigger_passive_scanning(adapter);
3354
3355                 return dbus_message_new_method_return(msg);
3356         }
3357         DBG("adapter->discovery_type %d", adapter->discovery_type);
3358         cp.type = 0x06;
3359         DBG("cp.type %d", cp.type);
3360         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
3361                                 adapter->dev_id, sizeof(cp), &cp,
3362                                 stop_le_discovery_complete, adapter, NULL);
3363
3364         return dbus_message_new_method_return(msg);
3365 }
3366
3367 static DBusMessage *adapter_set_advertising(DBusConnection *conn,
3368                                                 DBusMessage *msg, void *data)
3369 {
3370         struct btd_adapter *adapter = data;
3371         dbus_bool_t err;
3372         dbus_bool_t enable = FALSE;
3373         dbus_int32_t slot_id;
3374
3375         DBG("adapter_set_advertising");
3376
3377         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3378                 return btd_error_not_ready(msg);
3379
3380         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &enable,
3381                                                 DBUS_TYPE_INT32, &slot_id,
3382                                                 DBUS_TYPE_INVALID))
3383                 return btd_error_invalid_args(msg);
3384
3385         if (adapter_le_is_supported_multi_advertising() && slot_id > 0)
3386                 err = adapter_le_enable_multi_adv(enable, slot_id);
3387         else
3388                 err = set_mode(adapter, MGMT_OP_SET_ADVERTISING, enable);
3389
3390         if (!err)
3391                 return btd_error_failed(msg, "Set Advertising failed");
3392
3393         if (enable)
3394                 create_advertiser(adapter, slot_id);
3395
3396         if (err && slot_id > 0)
3397                 advertising_state_changed(adapter, slot_id, enable);
3398
3399         return dbus_message_new_method_return(msg);
3400 }
3401
3402 static DBusMessage *adapter_set_advertising_params(DBusConnection *conn,
3403                                                 DBusMessage *msg, void *data)
3404 {
3405         struct btd_adapter *adapter = data;
3406         struct mgmt_cp_set_advertising_params cp;
3407         dbus_uint32_t interval_min;
3408         dbus_uint32_t interval_max;
3409         dbus_uint32_t filter_policy;
3410         dbus_uint32_t type;
3411         dbus_int32_t slot_id;
3412         gboolean ret;
3413
3414         DBG("Set customised advertising parameters");
3415
3416         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3417                 return btd_error_not_ready(msg);
3418
3419         if (!dbus_message_get_args(msg, NULL,
3420                                 DBUS_TYPE_UINT32, &interval_min,
3421                                 DBUS_TYPE_UINT32, &interval_max,
3422                                 DBUS_TYPE_UINT32, &filter_policy,
3423                                 DBUS_TYPE_UINT32, &type,
3424                                 DBUS_TYPE_INT32, &slot_id,
3425                                 DBUS_TYPE_INVALID))
3426                 return btd_error_invalid_args(msg);
3427
3428         memset(&cp, 0, sizeof(cp));
3429
3430         DBG("advertising interval min %x, max %x, filter %x type %x",
3431                                 interval_min, interval_max, filter_policy, type);
3432
3433         if (filter_policy > 0x03)
3434                 return btd_error_invalid_args(msg);
3435
3436         if (type > 0x04)
3437                 return btd_error_invalid_args(msg);
3438
3439         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
3440                 adapter_le_adv_inst_info_t *p_inst;
3441                 adapter_le_adv_param_t *p_params;
3442
3443                 p_inst = malloc(sizeof(adapter_le_adv_inst_info_t));
3444                 p_params = malloc(sizeof(adapter_le_adv_param_t));
3445                 memset(p_inst, 0, sizeof(adapter_le_adv_inst_info_t));
3446                 memset(p_params, 0, sizeof(adapter_le_adv_param_t));
3447                 p_inst->inst_id = slot_id;
3448                 p_params->adv_int_min = interval_min;
3449                 p_params->adv_int_max = interval_max;
3450                 p_params->adv_type = type;
3451                 p_params->channel_map = 0x07;   /* fixed channel :: will be used all */
3452                 p_params->adv_filter_policy = filter_policy;
3453                 p_params->tx_power = BLE_ADV_TX_POWER_MID;      /* TODO:need to optimize */
3454                 if (adapter->le_static_addr.b[5] != 0) {
3455                         p_inst->bdaddr_type = 0x01;
3456                         bacpy(&p_inst->bdaddr, &adapter->le_static_addr);
3457                 } else {
3458                         p_inst->bdaddr_type = 0x00;
3459                         bacpy(&p_inst->bdaddr, &adapter->bdaddr);
3460                 }
3461
3462                 ret = adapter_le_set_multi_adv_params(p_inst, p_params);
3463
3464                 free(p_inst);
3465                 free(p_params);
3466
3467                 if (ret)
3468                         return dbus_message_new_method_return(msg);
3469                 else
3470                         return btd_error_failed(msg, "set advertising param failed");
3471         } else {
3472                 cp.interval_max = interval_max;
3473                 cp.interval_min = interval_min;
3474                 cp.filter_policy = filter_policy;
3475                 cp.type = type;
3476
3477                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_PARAMS,
3478                                         adapter->dev_id, sizeof(cp), &cp,
3479                                         NULL, NULL, NULL) > 0)
3480                         return dbus_message_new_method_return(msg);
3481
3482                 return btd_error_failed(msg, "set advertising param failed");
3483         }
3484 }
3485
3486 static DBusMessage *adapter_set_advertising_data(DBusConnection *conn,
3487                                                 DBusMessage *msg, void *data)
3488 {
3489         struct btd_adapter *adapter = data;
3490         struct mgmt_cp_set_advertising_data cp;
3491         uint8_t *value;
3492         int32_t len = 0;
3493         dbus_int32_t slot_id;
3494         uint8_t *adv_data = NULL;
3495         int adv_len = 0;
3496
3497         DBG("Set advertising data");
3498
3499         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3500                 return btd_error_not_ready(msg);
3501
3502         if (!dbus_message_get_args(msg, NULL,
3503                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
3504                         DBUS_TYPE_INT32, &slot_id,
3505                         DBUS_TYPE_INVALID))
3506                 return btd_error_invalid_args(msg);
3507
3508         if (len > ADV_DATA_MAX_LENGTH - 3)
3509                 return btd_error_invalid_args(msg);
3510
3511         adapter_le_set_missed_adv_data(value, len, FALSE,
3512                         adapter->name, adapter->adv_tx_power, &adv_data, &adv_len);
3513
3514         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
3515                 if (adapter_le_set_multi_adv_data(slot_id, FALSE, adv_len, adv_data)) {
3516                         g_free(adv_data);
3517                         return dbus_message_new_method_return(msg);
3518                 } else {
3519                         g_free(adv_data);
3520                         return btd_error_failed(msg, "set advertising data failed");
3521                 }
3522         } else {
3523                 memcpy(&cp, adv_data, adv_len);
3524
3525                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_DATA,
3526                                                 adapter->dev_id, adv_len,
3527                                                 &cp, NULL, NULL, NULL) > 0) {
3528                         g_free(adv_data);
3529                         return dbus_message_new_method_return(msg);
3530                 }
3531
3532                 g_free(adv_data);
3533                 return btd_error_failed(msg, "set advertising data failed");
3534         }
3535 }
3536
3537 static DBusMessage *adapter_le_scan_filter_param_setup(DBusConnection *conn,
3538                                                 DBusMessage *msg, void *data)
3539 {
3540         struct btd_adapter *adapter = data;
3541         dbus_bool_t err;
3542         dbus_int32_t client_if, action, filt_index;
3543         dbus_int32_t feat_seln, list_logic_type, filt_logic_type;
3544         dbus_int32_t rssi_high_thres, rssi_low_thres, dely_mode;
3545         dbus_int32_t found_timeout, lost_timeout, found_timeout_cnt;
3546         adapter_le_scan_filter_param_t params;
3547
3548         DBG("adapter_le_scan_filter_param_setup");
3549
3550         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3551                 return btd_error_not_ready(msg);
3552
3553         if (adapter_le_get_scan_filter_size() == 0)
3554                 return btd_error_not_supported(msg);
3555
3556         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
3557                                                 DBUS_TYPE_INT32, &action,
3558                                                 DBUS_TYPE_INT32, &filt_index,
3559                                                 DBUS_TYPE_INT32, &feat_seln,
3560                                                 DBUS_TYPE_INT32, &list_logic_type,
3561                                                 DBUS_TYPE_INT32, &filt_logic_type,
3562                                                 DBUS_TYPE_INT32, &rssi_high_thres,
3563                                                 DBUS_TYPE_INT32, &rssi_low_thres,
3564                                                 DBUS_TYPE_INT32, &dely_mode,
3565                                                 DBUS_TYPE_INT32, &found_timeout,
3566                                                 DBUS_TYPE_INT32, &lost_timeout,
3567                                                 DBUS_TYPE_INT32, &found_timeout_cnt,
3568                                                 DBUS_TYPE_INVALID))
3569                 return btd_error_invalid_args(msg);
3570
3571         memset(&params, 0, sizeof(params));
3572
3573         params.action = action;
3574         params.index = filt_index;
3575         params.feature = feat_seln;
3576         params.filter_logic_type = filt_logic_type;
3577         params.list_logic_type = list_logic_type;
3578         params.delivery_mode = dely_mode;
3579         params.rssi_high_threshold = rssi_high_thres;
3580
3581         if (params.delivery_mode == ON_FOUND) {
3582                 params.rssi_low_threshold = rssi_low_thres;
3583                 params.onfound_timeout = found_timeout;
3584                 params.onfound_timeout_cnt = found_timeout_cnt;
3585                 params.onlost_timeout = lost_timeout;
3586         }
3587
3588         err = adapter_le_set_scan_filter_params(&params);
3589
3590         if (!err)
3591                 return btd_error_failed(msg, "Failed to scan filter param setup");
3592
3593         return dbus_message_new_method_return(msg);
3594 }
3595
3596 static DBusMessage *adapter_le_scan_filter_add_remove(DBusConnection *conn,
3597                                                 DBusMessage *msg, void *data)
3598 {
3599         struct btd_adapter *adapter = data;
3600         struct btd_device *dev;
3601         bdaddr_t bdaddr;
3602         dbus_bool_t err;
3603         dbus_int32_t client_if, action, filt_type, filt_index;
3604         dbus_int32_t company_id, company_id_mask;
3605         gchar *string;
3606         char ida_string[18];
3607         dbus_uint32_t address_type;
3608         uint8_t *p_uuid, *p_uuid_mask, *p_data, *p_mask;
3609         int32_t uuid_len = 0, uuid_mask_len = 0, data_len = 0, mask_len = 0;
3610
3611         DBG("adapter_le_scan_filter_add_remove");
3612
3613         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3614                 return btd_error_not_ready(msg);
3615
3616         if (adapter_le_get_scan_filter_size() == 0)
3617                 return btd_error_not_supported(msg);
3618
3619         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
3620                                                 DBUS_TYPE_INT32, &action,
3621                                                 DBUS_TYPE_INT32, &filt_type,
3622                                                 DBUS_TYPE_INT32, &filt_index,
3623                                                 DBUS_TYPE_INT32, &company_id,
3624                                                 DBUS_TYPE_INT32, &company_id_mask,
3625                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid, &uuid_len,
3626                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid_mask, &uuid_mask_len,
3627                                                 DBUS_TYPE_STRING, &string,
3628                                                 DBUS_TYPE_UINT32, &address_type,
3629                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_data, &data_len,
3630                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_mask, &mask_len,
3631                                                 DBUS_TYPE_INVALID))
3632                 return btd_error_invalid_args(msg);
3633
3634         DBG("addr %s, type %d", string, address_type);
3635
3636         str2ba(string, &bdaddr);
3637
3638         dev = btd_adapter_find_device(adapter, &bdaddr, address_type);
3639         if (dev && device_get_rpa_exist(dev) == true) {
3640                 ba2str(device_get_address(dev), ida_string);
3641                 if (btd_device_get_bdaddr_type(dev) == BDADDR_LE_PUBLIC)
3642                         address_type = 0x0;
3643                 else
3644                         address_type = 0x1;
3645         } else {
3646                 memcpy(ida_string, string, sizeof(ida_string));
3647         }
3648
3649         err = adapter_le_set_scan_filter_data(client_if, action, filt_type,
3650                         filt_index, company_id, company_id_mask,
3651                         uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
3652                         ida_string, address_type, data_len, p_data, mask_len, p_mask);
3653
3654         if (!err)
3655                 return btd_error_failed(msg, "Failed to add/remove filter");
3656
3657         return dbus_message_new_method_return(msg);
3658 }
3659
3660 static DBusMessage *adapter_le_scan_filter_clear(DBusConnection *conn,
3661                                                 DBusMessage *msg, void *data)
3662 {
3663         struct btd_adapter *adapter = data;
3664         dbus_bool_t err;
3665         dbus_int32_t client_if;
3666         dbus_int32_t filt_index;
3667
3668         DBG("adapter_le_scan_filter_clear");
3669
3670         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3671                 return btd_error_not_ready(msg);
3672
3673         if (adapter_le_get_scan_filter_size() == 0)
3674                 return btd_error_not_supported(msg);
3675
3676         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
3677                                                 DBUS_TYPE_INT32, &filt_index,
3678                                                 DBUS_TYPE_INVALID))
3679                 return btd_error_invalid_args(msg);
3680
3681         err = adapter_le_clear_scan_filter_data(client_if, filt_index);
3682
3683         if (!err)
3684                 return btd_error_failed(msg, "Failed to clear filter");
3685
3686         return dbus_message_new_method_return(msg);
3687 }
3688
3689
3690 static DBusMessage *adapter_le_scan_filter_enable(DBusConnection *conn,
3691                                                 DBusMessage *msg, void *data)
3692 {
3693         struct btd_adapter *adapter = data;
3694         dbus_bool_t err;
3695         dbus_bool_t enable = FALSE;
3696         dbus_int32_t client_if;
3697
3698         DBG("adapter_le_scan_filter_enable");
3699
3700         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3701                 return btd_error_not_ready(msg);
3702
3703         if (adapter_le_get_scan_filter_size() == 0)
3704                 return btd_error_not_supported(msg);
3705
3706         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
3707                                                 DBUS_TYPE_BOOLEAN, &enable,
3708                                                 DBUS_TYPE_INVALID))
3709                 return btd_error_invalid_args(msg);
3710
3711         err = adapter_le_enable_scan_filtering(enable);
3712
3713         if (!err)
3714                 return btd_error_failed(msg, "Failed to enable scan filtering");
3715
3716         return dbus_message_new_method_return(msg);
3717 }
3718
3719 static DBusMessage *adapter_le_set_scan_params(DBusConnection *conn,
3720                                                 DBusMessage *msg, void *data)
3721 {
3722         struct btd_adapter *adapter = data;
3723         struct mgmt_cp_le_set_scan_params cp;
3724         uint32_t type;
3725         uint32_t interval;
3726         uint32_t window;
3727
3728         DBG("Set scan parameters");
3729
3730         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3731                 return btd_error_not_ready(msg);
3732
3733         if (!dbus_message_get_args(msg, NULL,
3734                                 DBUS_TYPE_UINT32, &type,
3735                                 DBUS_TYPE_UINT32, &interval,
3736                                 DBUS_TYPE_UINT32, &window,
3737                                 DBUS_TYPE_INVALID))
3738                 return btd_error_invalid_args(msg);
3739
3740         DBG("scan type %x, interval %x, window %x",
3741                                 type, interval, window);
3742         memset(&cp, 0, sizeof(cp));
3743
3744         cp.type = type;
3745         cp.interval = interval;
3746         cp.window = window;
3747
3748         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_SCAN_PARAMS,
3749                                         adapter->dev_id, sizeof(cp), &cp,
3750                                         NULL, NULL, NULL) > 0)
3751                 return dbus_message_new_method_return(msg);
3752
3753         return btd_error_failed(msg, "set scan parameters failed");
3754 }
3755
3756 static DBusMessage *adapter_set_scan_rsp_data(DBusConnection *conn,
3757                                                 DBusMessage *msg, void *data)
3758 {
3759         struct btd_adapter *adapter = data;
3760         struct mgmt_cp_set_scan_rsp_data cp;
3761         uint8_t *value;
3762         int32_t len = 0;
3763         dbus_int32_t slot_id;
3764         uint8_t *adv_data = NULL;
3765         int adv_len = 0;
3766
3767         DBG("Set scan response data");
3768
3769         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3770                 return btd_error_not_ready(msg);
3771
3772         if (!dbus_message_get_args(msg, NULL,
3773                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
3774                         DBUS_TYPE_INT32, &slot_id,
3775                         DBUS_TYPE_INVALID))
3776                 return btd_error_invalid_args(msg);
3777
3778         if (len > SCAN_RESPONSE_DATA_LENGTH_MAX)
3779                 return btd_error_invalid_args(msg);
3780
3781         adapter_le_set_missed_adv_data(value, len, TRUE,
3782                         adapter->name, adapter->adv_tx_power, &adv_data, &adv_len);
3783
3784         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
3785                 if (adapter_le_set_multi_adv_data(slot_id, TRUE, adv_len, (uint8_t *)adv_data)) {
3786                         g_free(adv_data);
3787                         return dbus_message_new_method_return(msg);
3788                 } else {
3789                         g_free(adv_data);
3790                         return btd_error_failed(msg, "set advertising data failed");
3791                 }
3792         } else {
3793                 memcpy(&cp, adv_data, adv_len);
3794
3795                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_SCAN_RSP_DATA,
3796                                                 adapter->dev_id, adv_len, &cp,
3797                                                 NULL, NULL, NULL) > 0) {
3798                         g_free(adv_data);
3799                         return dbus_message_new_method_return(msg);
3800                 }
3801
3802                 g_free(adv_data);
3803                 return btd_error_failed(msg, "set scan reponse data failed");
3804         }
3805 }
3806
3807 static DBusMessage *adapter_add_device_white_list(DBusConnection *conn,
3808                                         DBusMessage *msg, void *data)
3809 {
3810         struct btd_adapter *adapter = data;
3811         struct mgmt_cp_add_dev_white_list cp;
3812         const gchar *address;
3813         bdaddr_t bdaddr;
3814         dbus_uint32_t address_type;
3815         struct btd_device *dev;
3816
3817         DBG("Add device whie list");
3818         if (dbus_message_get_args(msg, NULL,
3819                                         DBUS_TYPE_STRING, &address,
3820                                         DBUS_TYPE_UINT32, &address_type,
3821                                         DBUS_TYPE_INVALID) == FALSE)
3822                 return btd_error_invalid_args(msg);
3823
3824         if (check_address(address) < 0)
3825                 return btd_error_invalid_args(msg);
3826
3827         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3828                 return btd_error_not_ready(msg);
3829
3830
3831         DBG("addr %s, type %d", address, address_type);
3832         str2ba(address, &bdaddr);
3833
3834         dev = btd_adapter_find_device(adapter, &bdaddr, address_type);
3835         if (dev && device_get_rpa_exist(dev) == true) {
3836                 if (adapter_le_is_supported_offloading() == FALSE) {
3837                         error("Spec based command is not supported yet");
3838                         return btd_error_not_supported(msg);
3839                 }
3840
3841                 /* Add IRK value to list */
3842                 if (adapter_le_add_irk_to_list(device_get_irk_value(dev),
3843                                                                 device_get_address(dev),
3844                                                                 btd_device_get_bdaddr_type(dev))) {
3845                         return dbus_message_new_method_return(msg);
3846                 } else {
3847                         return btd_error_failed(msg, "Add LE IRK to list failed");
3848                 }
3849         }
3850
3851         memset(&cp, 0, sizeof(cp));
3852
3853         cp.bdaddr_type = address_type;
3854         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
3855
3856         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEV_WHITE_LIST,
3857                                         adapter->dev_id, sizeof(cp), &cp,
3858                                         NULL, NULL, NULL) > 0)
3859                 return dbus_message_new_method_return(msg);
3860
3861         return btd_error_failed(msg, "add device white list failed");
3862 }
3863
3864 static DBusMessage *adapter_remove_device_white_list(DBusConnection *conn,
3865                                         DBusMessage *msg, void *data)
3866 {
3867         struct btd_adapter *adapter = data;
3868         struct mgmt_cp_remove_dev_white_list cp;
3869         const gchar *address;
3870         bdaddr_t bdaddr;
3871         dbus_uint32_t address_type;
3872         struct btd_device *dev;
3873
3874         DBG("Remove device whie list");
3875
3876         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3877                 return btd_error_not_ready(msg);
3878
3879         if (dbus_message_get_args(msg, NULL,
3880                                         DBUS_TYPE_STRING, &address,
3881                                         DBUS_TYPE_UINT32, &address_type,
3882                                         DBUS_TYPE_INVALID) == FALSE)
3883                 return btd_error_invalid_args(msg);
3884
3885         if (check_address(address) < 0)
3886                 return btd_error_invalid_args(msg);
3887
3888         DBG("addr %s, type %d", address, address_type);
3889         str2ba(address, &bdaddr);
3890
3891         dev = btd_adapter_find_device(adapter, &bdaddr, address_type);
3892         if (dev && device_get_rpa_exist(dev) == true) {
3893                 if (adapter_le_is_supported_offloading() == FALSE) {
3894                         error("Spec based command is not supported yet");
3895                         return btd_error_not_supported(msg);
3896                 }
3897
3898                 /* Remove IRK value to list */
3899                 if (adapter_le_remove_irk_to_list(device_get_address(dev),
3900                                                                 btd_device_get_bdaddr_type(dev))) {
3901                         return dbus_message_new_method_return(msg);
3902                 } else {
3903                         return btd_error_failed(msg, "Remove LE IRK to list failed");
3904                 }
3905         }
3906
3907         memset(&cp, 0, sizeof(cp));
3908
3909         cp.bdaddr_type = address_type;
3910         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
3911
3912         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEV_FROM_WHITE_LIST,
3913                                         adapter->dev_id, sizeof(cp), &cp,
3914                                         NULL, NULL, NULL) > 0)
3915                 return dbus_message_new_method_return(msg);
3916
3917         return btd_error_failed(msg, "remove device white list failed");
3918 }
3919
3920 static DBusMessage *adapter_clear_device_white_list(DBusConnection *conn,
3921                                         DBusMessage *msg, void *data)
3922 {
3923         struct btd_adapter *adapter = data;
3924
3925         DBG("Clear device whie list");
3926
3927         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
3928                 return btd_error_not_ready(msg);
3929
3930         if (mgmt_send(adapter->mgmt, MGMT_OP_CLEAR_DEV_WHITE_LIST,
3931                                         adapter->dev_id, 0, NULL,
3932                                         NULL, NULL, NULL) > 0)
3933                 return dbus_message_new_method_return(msg);
3934
3935         return btd_error_failed(msg, "clear white list failed");
3936 }
3937
3938 static DBusMessage *adapter_set_le_privacy(DBusConnection *conn,
3939                                         DBusMessage *msg, void *data)
3940 {
3941         struct btd_adapter *adapter = data;
3942         dbus_bool_t err;
3943         dbus_bool_t enable_privacy = FALSE;
3944
3945         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
3946                 return btd_error_not_supported(msg);
3947
3948         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
3949                                 &enable_privacy, DBUS_TYPE_INVALID))
3950                 return btd_error_invalid_args(msg);
3951
3952         if (enable_privacy) {
3953                 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
3954                         return btd_error_already_exists(msg);
3955         } else {
3956                 if (!(adapter->current_settings & MGMT_SETTING_PRIVACY))
3957                         return btd_error_already_exists(msg);
3958         }
3959
3960         err = set_privacy(adapter, enable_privacy);
3961
3962         if (!err)
3963                 return btd_error_failed(msg, "Set Le Privacy failed");
3964
3965         return dbus_message_new_method_return(msg);
3966 }
3967
3968 static void set_le_static_address(struct btd_adapter *adapter)
3969 {
3970         int fd;
3971         int ret;
3972         char address[18];
3973         char dirname[PATH_MAX];
3974
3975         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
3976         if (access(dirname, F_OK) < 0) {
3977                 int i;
3978                 bdaddr_t le_static_addr;
3979
3980                 le_static_addr.b[5] = adapter->bdaddr.b[5] | 0xc0;
3981                 for (i = 0; i < 5; i++) {
3982                         le_static_addr.b[i] =
3983                                 (adapter->bdaddr.b[i] & 0x7f) << 1 |
3984                                 (adapter->bdaddr.b[i] & 0x80) >> 7;
3985                 }
3986
3987                 /*
3988                  * < How to get Public address from above static address >
3989                  *
3990                  * for (i = 0; i < 5; i++) {
3991                  *      bredr_addr.b[i] =
3992                  *              (adapter->le_static_addr.b[i] & 0xfe) >> 1 |
3993                  *              (adapter->le_static_addr.b[i] & 0x01) << 7;
3994                  * }
3995                  * bredr_addr.b[5] = {the value from advertising data}
3996                  */
3997
3998                 fd = open(dirname, O_WRONLY | O_CREAT, 0644);
3999                 if (fd >= 0) {
4000                         ba2str(&le_static_addr, address);
4001                         DBG("LE static random : %s", address);
4002                         ret = write(fd, address, strlen(address));
4003                         if (ret < 0) {
4004                                 error("Cannot save LE address : %s",
4005                                                 strerror(errno));
4006                         }
4007                         close(fd);
4008                 } else {
4009                         error("Cannot save LE address");
4010                 }
4011                 bacpy(&adapter->le_static_addr, &le_static_addr);
4012         } else {
4013                 fd = open(dirname, O_RDONLY);
4014                 if (fd >= 0) {
4015                         ret = read(fd, address, sizeof(address));
4016                         if (ret >= 17) {
4017                                 /* xx:xx:xx:xx:xx:xx */
4018                                 address[17] = '\0';
4019                                 DBG("LE static random : %s", address);
4020                                 str2ba(address, &adapter->le_static_addr);
4021                                 adapter->le_static_addr.b[5] |= 0xc0;
4022                         } else
4023                                 error("Invalid LE address");
4024                         close(fd);
4025                 } else {
4026                         error("Cannot get LE address");
4027                 }
4028         }
4029
4030         return;
4031 }
4032
4033 static void set_le_static_address_complete(uint8_t status, uint16_t length,
4034                                         const void *param, void *user_data)
4035 {
4036         struct btd_adapter *adapter = user_data;
4037
4038         DBG("index %u status 0x%02x", adapter->dev_id, status);
4039
4040         if (status != MGMT_STATUS_SUCCESS) {
4041                 error("Failed to set static address for index %u: %s (0x%02x)",
4042                                 adapter->dev_id, mgmt_errstr(status), status);
4043                 if (adapter->le_static_addr.b[5] != 0)
4044                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
4045                 else
4046                         set_le_static_address(adapter);
4047                 return;
4048         }
4049
4050         return;
4051 }
4052
4053 static DBusMessage *adapter_set_le_static_address(DBusConnection *conn,
4054                                         DBusMessage *msg, void *data)
4055 {
4056         struct btd_adapter *adapter = data;
4057         dbus_bool_t is_enable = FALSE;
4058         struct mgmt_cp_set_static_address cp;
4059
4060         if (!(adapter->supported_settings & MGMT_OP_SET_STATIC_ADDRESS)) {
4061                 error("LE static address is not supported");
4062                 return btd_error_not_supported(msg);
4063         }
4064
4065         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &is_enable,
4066                                 DBUS_TYPE_INVALID)) {
4067                 error("Invalid arguments");
4068                 return btd_error_invalid_args(msg);
4069         }
4070
4071         memset(&cp, 0x00, sizeof(cp));
4072         if (is_enable)  {
4073                 if (adapter->le_static_addr.b[5] != 0) {
4074                         DBG("LE static address is already configured");
4075                         return dbus_message_new_method_return(msg);
4076                 }
4077                 set_le_static_address(adapter);
4078                 bacpy(&cp.bdaddr, &adapter->le_static_addr);
4079         } else {
4080                 if (adapter->le_static_addr.b[5] == 0) {
4081                         DBG("LE static address is not configured");
4082                         return dbus_message_new_method_return(msg);
4083                 }
4084                 bacpy(&adapter->le_static_addr, BDADDR_ANY);
4085         }
4086         DBG("Set static random address : %d", is_enable);
4087
4088         if (mgmt_send(mgmt_master, MGMT_OP_SET_STATIC_ADDRESS, adapter->dev_id,
4089                         sizeof(cp), &cp,
4090                         set_le_static_address_complete, adapter, NULL) <= 0) {
4091                 error("Failed to set static address : %d", is_enable);
4092                 if (is_enable)
4093                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
4094                 else
4095                         set_le_static_address(adapter);
4096                 return btd_error_failed(msg, "Unable to set static address");
4097         }
4098
4099         return dbus_message_new_method_return(msg);
4100 }
4101
4102 #if 0 // Not used
4103 static void read_sec_conn_host_support_complete(uint8_t status, uint16_t length,
4104                                         const void *param, void *user_data)
4105 {
4106         const struct mgmt_rp_read_sec_conn_host_support *rp = param;
4107         struct btd_adapter *adapter = user_data;
4108
4109         if (status != MGMT_STATUS_SUCCESS) {
4110                 error("Failed to read secure conn parameter: %s (0x%02x)",
4111                    mgmt_errstr(status), status);
4112                 return;
4113         }
4114
4115         if (length < sizeof(*rp)) {
4116                 error("Wrong size of read secure connections host support");
4117                 return;
4118         }
4119
4120         if (rp->sec_conn_host_support)
4121                 adapter->secure_connection = TRUE;
4122         else
4123                 adapter->secure_connection = FALSE;
4124
4125         g_dbus_emit_property_changed(dbus_conn, adapter->path,
4126                         ADAPTER_INTERFACE, "SecureConnection");
4127 }
4128
4129 static DBusMessage *read_sec_conn_host_support(DBusConnection *conn,
4130                                         DBusMessage *msg, void *user_data)
4131 {
4132         struct btd_adapter *adapter = user_data;
4133
4134         mgmt_send(adapter->mgmt, MGMT_OP_READ_SEC_CONN_HOST_SUPPORT,
4135               adapter->dev_id, 0, NULL,
4136               read_sec_conn_host_support_complete, adapter, NULL);
4137
4138         return dbus_message_new_method_return(msg);
4139 }
4140
4141 static void write_sec_conn_host_support_complete(uint8_t status,
4142                 uint16_t length, const void *param, void *user_data)
4143 {
4144         const struct mgmt_rp_write_sec_conn_host_support *rp = param;
4145         if (status != MGMT_STATUS_SUCCESS) {
4146                 error("Failed to write secure connections host \
4147                                 support parameter: %s (0x%02x)",
4148                                                 mgmt_errstr(status), status);
4149                 return;
4150         }
4151
4152         if (length < sizeof(*rp)) {
4153                 error("Wrong size of write secure connections host\
4154                                  support parameter");
4155                 return;
4156         }
4157 }
4158
4159 static DBusMessage *write_sec_conn_host_support(DBusConnection *conn,
4160                                         DBusMessage *msg, void *user_data)
4161 {
4162
4163         struct mgmt_cp_write_sec_conn_host_support cp;
4164         dbus_bool_t enable = FALSE;
4165         struct btd_adapter *adapter = user_data;
4166
4167         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
4168                                         &enable, DBUS_TYPE_INVALID))
4169                 return btd_error_invalid_args(msg);
4170
4171         memset(&cp, 0, sizeof(cp));
4172         cp.secure_connection_host_support = enable;
4173         mgmt_send(adapter->mgmt, MGMT_OP_WRITE_SEC_CONN_HOST_SUPPORT,
4174                         adapter->dev_id, sizeof(cp), &cp,
4175                         write_sec_conn_host_support_complete,
4176                         NULL, NULL);
4177         return dbus_message_new_method_return(msg);
4178 }
4179 #endif
4180
4181 static DBusMessage *adapter_enable_rssi(DBusConnection *conn,
4182                                                 DBusMessage *msg, void *data)
4183 {
4184         struct btd_adapter *adapter = data;
4185         struct mgmt_cp_set_enable_rssi cp;
4186         struct mgmt_cp_disable_rssi cp_dis;
4187         bdaddr_t bt_addr = { { 0, } };
4188         const gchar *address = NULL;
4189
4190         const char *sender = dbus_message_get_sender(msg);
4191         dbus_int32_t link_type;
4192         dbus_int32_t low_threshold;
4193         dbus_int32_t in_range_threshold;
4194         dbus_int32_t high_threshold;
4195
4196         DBG("Enable RSSI called");
4197         DBG("sender %s", sender);
4198         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4199                 return btd_error_not_ready(msg);
4200
4201         if (!dbus_message_get_args(msg, NULL,
4202                                 DBUS_TYPE_STRING, &address,
4203                                 DBUS_TYPE_INT32, &link_type,
4204                                 DBUS_TYPE_INT32, &low_threshold,
4205                                 DBUS_TYPE_INT32, &in_range_threshold,
4206                                 DBUS_TYPE_INT32, &high_threshold,
4207                                 DBUS_TYPE_INVALID))
4208                 return btd_error_invalid_args(msg);
4209
4210         DBG("Enable RSSI: [%s %d %d %d %d]", address, link_type,
4211                         low_threshold, in_range_threshold, high_threshold);
4212
4213         DBG("BT address [%s]", address);
4214         memset(&bt_addr, 0, sizeof(bdaddr_t));
4215         str2ba(address, &bt_addr);
4216         memset(&cp, 0, sizeof(struct mgmt_cp_set_enable_rssi));
4217         memset(&cp_dis, 0, sizeof(struct mgmt_cp_disable_rssi));
4218
4219         if (check_address(address) < 0)
4220                 return btd_error_invalid_args(msg);
4221
4222 //      if (!btd_adapter_find_device(adapter, address))
4223 //              return btd_error_not_found(msg);
4224
4225         if (low_threshold == 0 && in_range_threshold == 0 && high_threshold == 0) {
4226                 cp_dis.bdaddr = bt_addr;
4227                 cp_dis.link_type = link_type;
4228                 DBG("Disable Request");
4229                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_DISABLE,
4230                                         adapter->dev_id, sizeof(cp_dis), &cp_dis,
4231                                         NULL, NULL, NULL) > 0)
4232                                         return dbus_message_new_method_return(msg);
4233         } else {
4234                 cp.low_th = low_threshold;
4235                 cp.in_range_th = in_range_threshold;
4236                 cp.high_th = high_threshold;
4237                 cp.bdaddr = bt_addr;
4238                 cp.link_type = link_type;
4239                 DBG("Enable Request");
4240                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_ENABLE,
4241                                         adapter->dev_id, sizeof(cp), &cp,
4242                                         NULL, NULL, NULL) > 0)
4243                         return dbus_message_new_method_return(msg);
4244         }
4245         return btd_error_failed(msg, "Enable/Disable RSSI Failed");
4246 }
4247
4248 static DBusMessage *adapter_get_rssi(DBusConnection *conn,
4249                                                 DBusMessage *msg, void *data)
4250 {
4251         struct btd_adapter *adapter = data;
4252         struct mgmt_cp_get_raw_rssi cp;
4253         bdaddr_t bt_addr;
4254         const gchar *address = NULL;
4255         dbus_int32_t link_type;
4256         const char *sender = dbus_message_get_sender(msg);
4257
4258         DBG("Get RSSI called");
4259         DBG("sender %s", sender);
4260         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4261                 return btd_error_not_ready(msg);
4262
4263         if (!dbus_message_get_args(msg, NULL,
4264                                 DBUS_TYPE_STRING, &address,
4265                                 DBUS_TYPE_INT32, &link_type,
4266                                 DBUS_TYPE_INVALID))
4267                 return btd_error_invalid_args(msg);
4268
4269         DBG("BT address [%s] link type [%d]", address, link_type);
4270         memset(&bt_addr, 0, sizeof(bdaddr_t));
4271         str2ba(address, &bt_addr);
4272         memset(&cp, 0, sizeof(struct mgmt_cp_get_raw_rssi));
4273
4274         if (check_address(address) < 0)
4275                 return btd_error_invalid_args(msg);
4276
4277 //      if (!btd_adapter_find_device(adapter, address))
4278 //              return btd_error_not_found(msg);
4279
4280         memcpy(&(cp.bt_address), &bt_addr, sizeof(bdaddr_t));
4281         cp.link_type = link_type;
4282         DBG("RAW RSSI Request");
4283         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_RAW_RSSI,
4284                                         adapter->dev_id, sizeof(cp), &cp,
4285                                         NULL, NULL, NULL) > 0)
4286                         return dbus_message_new_method_return(msg);
4287
4288         return btd_error_failed(msg, "Get Raw RSSI Failed");
4289 }
4290
4291 #if !defined(__SPRD_PATCH__)
4292 static void get_adv_tx_power_complete(uint8_t status, uint16_t length,
4293                                         const void *param, void *user_data)
4294 {
4295         struct btd_adapter *adapter = user_data;
4296         const struct mgmt_rp_get_adv_tx_power *rp = param;
4297
4298         if (status != MGMT_STATUS_SUCCESS) {
4299                 error("Failed to get adv tx power: %s (0x%02x)",
4300                                                 mgmt_errstr(status), status);
4301                 return;
4302         }
4303
4304         if (length < sizeof(*rp)) {
4305                 error("Wrong size of get adv tx power");
4306                 return;
4307         }
4308
4309         adapter->adv_tx_power = rp->adv_tx_power;
4310         return;
4311 }
4312
4313 static  void adapter_get_adv_tx_power(void *data)
4314 {
4315         struct btd_adapter *adapter = data;
4316
4317         mgmt_send(adapter->mgmt, MGMT_OP_GET_ADV_TX_POWER,
4318                                         adapter->dev_id, 0, NULL,
4319                                         get_adv_tx_power_complete, adapter, NULL);
4320         return;
4321 }
4322 #endif
4323
4324 #ifdef __BROADCOM_PATCH__
4325 static DBusMessage *set_wbs_parameters(DBusConnection *conn,
4326                                 DBusMessage *msg, void *data)
4327 {
4328         struct btd_adapter *adapter = data;
4329         const gchar *role = NULL;
4330         const gchar *address = NULL;
4331         struct mgmt_cp_set_voice_setting cp;
4332         bdaddr_t bt_addr = { { 0, } };
4333
4334         DBG("+");
4335
4336         if (!dbus_message_get_args(msg, NULL,
4337                                 DBUS_TYPE_STRING, &role,
4338                                 DBUS_TYPE_STRING, &address,
4339                                 DBUS_TYPE_INVALID)) {
4340                 return btd_error_invalid_args(msg);
4341         }
4342
4343         DBG("Role = %s", role);
4344         DBG("Address = %s", address);
4345
4346         memset(&cp, 0, sizeof(cp));
4347
4348         cp.voice_setting = BT_VOICE_TRANSPARENT | BT_VOICE_CVSD_16BIT;
4349
4350         if (g_strcmp0(role, "Handsfree") == 0)
4351                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
4352         else if (g_strcmp0(role, "Gateway") == 0)
4353                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
4354
4355         str2ba(address, &bt_addr);
4356         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
4357
4358         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
4359                                 adapter->dev_id, sizeof(cp), &cp,
4360                                 NULL, NULL, NULL) == 0)
4361                 error("mgmt_send failed for voice setting");
4362
4363         DBG("-");
4364         return dbus_message_new_method_return(msg);
4365 }
4366
4367 static DBusMessage *set_nb_parameters(DBusConnection *conn,
4368                                 DBusMessage *msg, void *data)
4369 {
4370         struct btd_adapter *adapter = data;
4371         const gchar *role;
4372         const gchar *address = NULL;
4373         struct mgmt_cp_set_voice_setting cp;
4374         bdaddr_t bt_addr = { { 0, } };
4375
4376         DBG("+");
4377
4378         if (!dbus_message_get_args(msg, NULL,
4379                                 DBUS_TYPE_STRING, &role,
4380                                 DBUS_TYPE_STRING, &address,
4381                                 DBUS_TYPE_INVALID)) {
4382                 return btd_error_invalid_args(msg);
4383         }
4384
4385         DBG("Role = %s", role);
4386         DBG("Address = %s", address);
4387
4388         memset(&cp, 0, sizeof(cp));
4389
4390         cp.voice_setting = BT_VOICE_CVSD_16BIT;
4391
4392         if (g_strcmp0(role, "Handsfree") == 0)
4393                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
4394         else if (g_strcmp0(role, "Gateway") == 0)
4395                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
4396
4397         str2ba(address, &bt_addr);
4398         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
4399
4400         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
4401                                 adapter->dev_id, sizeof(cp), &cp,
4402                                 NULL, NULL, NULL) == 0)
4403                 error("mgmt_send failed for voice setting");
4404
4405         DBG("-");
4406
4407         return dbus_message_new_method_return(msg);
4408 }
4409 #endif /* __BROADCOM_PATCH__ */
4410
4411 #ifdef __TIZEN_PATCH__
4412 void btd_adapter_set_read_le_data_length_handler(
4413                         struct btd_adapter *adapter,
4414                         struct le_data_length_read_handler *handler)
4415 {
4416         adapter->read_handler = handler;
4417 }
4418
4419 static void le_read_maximum_data_length_return_param_complete(
4420                         uint8_t status, uint16_t length,
4421                         const void *param, void *user_data)
4422 {
4423         struct btd_adapter *adapter = user_data;
4424         const struct mgmt_rp_le_read_maximum_data_length *rp = param;
4425         uint16_t max_tx_octects, max_tx_time;
4426         uint16_t max_rx_octects, max_rx_time;
4427
4428         if (status != MGMT_STATUS_SUCCESS) {
4429                 error("le read maximum data length failed: %s (0x%02x)",
4430                         mgmt_errstr(status), status);
4431                 max_tx_octects = 0;
4432                 max_tx_time =0;
4433                 max_rx_octects = 0;
4434                 max_rx_time = 0;
4435                 return;
4436         }
4437
4438         if (length < sizeof(*rp)) {
4439                 error("Too small le read maximum data length response");
4440                 g_free(adapter->read_handler);
4441                 return;
4442         } else {
4443                 max_tx_octects = rp->max_tx_octets;
4444                 max_tx_time =rp->max_tx_time;
4445                 max_rx_octects = rp->max_rx_octets;
4446                 max_rx_time = rp->max_rx_time;
4447         }
4448
4449         if (!adapter->read_handler ||
4450                 !adapter->read_handler->read_callback) {
4451                 g_free(adapter->read_handler);
4452                 return;
4453         }
4454
4455         adapter->read_handler->read_callback(adapter,
4456                         max_tx_octects, max_tx_time,
4457                         max_rx_octects, max_rx_time,
4458                         adapter->read_handler->user_data);
4459
4460         g_free(adapter->read_handler);
4461         adapter->read_handler = NULL;
4462 }
4463
4464 int btd_adapter_le_read_maximum_data_length(
4465         struct btd_adapter *adapter)
4466 {
4467         if (mgmt_send(adapter->mgmt,
4468                          MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
4469                          adapter->dev_id, 0, NULL,
4470                          le_read_maximum_data_length_return_param_complete,
4471                          adapter, NULL) > 0)
4472                 return 0;
4473
4474         return -EIO;
4475 }
4476
4477 static gint read_request_cmp(gconstpointer a, gconstpointer b)
4478 {
4479         const struct le_data_length_read_request *data = a;
4480         const struct btd_adapter *adapter = b;
4481
4482         return data->adapter !=  adapter;
4483 }
4484
4485 static struct le_data_length_read_request *find_read_le_data_length_request(
4486         struct btd_adapter *adapter)
4487 {
4488         GSList *match;
4489
4490         match = g_slist_find_custom(read_requests, adapter, read_request_cmp);
4491
4492         if (match)
4493                 return match->data;
4494
4495         return NULL;
4496 }
4497
4498 static void le_read_data_length_complete(
4499                         struct btd_adapter *adapter,
4500                         uint16_t max_tx_octects, uint16_t max_tx_time,
4501                         uint16_t max_rx_octects, uint16_t max_rx_time,
4502                         void *user_data)
4503 {
4504         DBusMessage *reply;
4505         struct le_data_length_read_request *read_request;
4506
4507         read_request = find_read_le_data_length_request(adapter);
4508         if (!read_request)
4509                 return;
4510
4511         reply = g_dbus_create_reply(read_request->msg,
4512                                 DBUS_TYPE_UINT16, &max_tx_octects,
4513                                 DBUS_TYPE_UINT16, &max_tx_time,
4514                                 DBUS_TYPE_UINT16, &max_rx_octects,
4515                                 DBUS_TYPE_UINT16, &max_rx_time,
4516                                 DBUS_TYPE_INVALID);
4517
4518         if (!reply) {
4519                 btd_error_failed(read_request->msg,
4520                                         "Failed to read max data length.");
4521                 return;
4522         }
4523
4524         read_requests = g_slist_remove(read_requests, read_request);
4525         dbus_message_unref(read_request->msg);
4526         g_free(read_request);
4527
4528         if (!g_dbus_send_message(dbus_conn, reply))
4529                 error("D-Bus send failed");
4530 }
4531
4532 static DBusMessage *le_read_maximum_data_length(
4533                         DBusConnection *conn, DBusMessage *msg,
4534                         void *user_data)
4535 {
4536         struct btd_adapter *adapter = user_data;
4537         struct le_data_length_read_request *read_request;
4538         struct le_data_length_read_handler *handler;
4539
4540         if (find_read_le_data_length_request(adapter))
4541                 return btd_error_in_progress(msg);
4542
4543         if (btd_adapter_le_read_maximum_data_length(adapter))
4544                 return btd_error_failed(msg, "Unable to read maximum le data length");
4545
4546         read_request = g_new(struct le_data_length_read_request, 1);
4547
4548         read_request->msg = dbus_message_ref(msg);
4549         read_request->adapter = adapter;
4550
4551         read_requests = g_slist_append(read_requests, read_request);
4552
4553         handler = g_new0(struct le_data_length_read_handler, 1);
4554
4555         handler->read_callback =
4556                 (read_max_data_length_cb_t)le_read_data_length_complete;
4557
4558         btd_adapter_set_read_le_data_length_handler(
4559                         read_request->adapter, handler);
4560
4561         return NULL;
4562
4563 }
4564
4565 void le_write_host_suggested_data_length_return_param_complete(
4566                         uint8_t status, uint16_t length,
4567                         const void *param, void *user_data)
4568 {
4569         if (status != MGMT_STATUS_SUCCESS) {
4570                 error("le write host suggested data length failed: %s (0x%02x)",
4571                         mgmt_errstr(status), status);
4572         }
4573
4574         return;
4575 }
4576
4577 static DBusMessage *le_write_host_suggested_default_data_length(
4578                         DBusConnection *conn, DBusMessage *msg,
4579                         void *user_data)
4580 {
4581         struct btd_adapter *adapter = user_data;
4582         struct mgmt_cp_le_write_host_suggested_data_length cp;
4583         dbus_uint16_t def_tx_Octets;
4584         dbus_uint16_t def_tx_time;
4585
4586         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4587                 return btd_error_not_ready(msg);
4588
4589         if (!dbus_message_get_args(msg, NULL,
4590                                         DBUS_TYPE_UINT16, &def_tx_Octets,
4591                                         DBUS_TYPE_UINT16, &def_tx_time,
4592                                         DBUS_TYPE_INVALID))
4593                 return btd_error_invalid_args(msg);
4594
4595         memset(&cp, 0, sizeof(cp));
4596         cp.def_tx_octets = def_tx_Octets;
4597         cp.def_tx_time = def_tx_time;
4598
4599         if (mgmt_send(adapter->mgmt,
4600                          MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
4601                          adapter->dev_id, sizeof(cp), &cp,
4602                          le_write_host_suggested_data_length_return_param_complete,
4603                          adapter, NULL) > 0)
4604                 return dbus_message_new_method_return(msg);
4605
4606         return btd_error_failed(msg, "Unable to write host suggested le data length values");
4607 }
4608
4609 static void le_read_suggested_default_data_length_return_param_complete(
4610                         uint8_t status, uint16_t length,
4611                         const void *param, void *user_data)
4612 {
4613         struct btd_adapter *adapter = user_data;
4614         const struct mgmt_rp_le_read_host_suggested_data_length *rp = param;
4615         uint16_t def_tx_octects, def_tx_time;
4616
4617         if (status != MGMT_STATUS_SUCCESS) {
4618                 error("Read host suggested def le data length values failed: %s (0x%02x)",
4619                         mgmt_errstr(status), status);
4620                 def_tx_octects = 0;
4621                 def_tx_time =0;
4622                 return;
4623         }
4624
4625         if (length < sizeof(*rp)) {
4626                 goto done;
4627         } else {
4628                 def_tx_octects = rp->def_tx_octets;
4629                 def_tx_time =rp->def_tx_time;
4630                 DBG("retrieving host suggested data length values %d %d", def_tx_octects, def_tx_time);
4631         }
4632
4633         if (!adapter->def_read_handler)
4634                 return;
4635
4636         if(!adapter->def_read_handler->read_callback) {
4637                 goto done;
4638         }
4639
4640         adapter->def_read_handler->read_callback(adapter,
4641                         def_tx_octects, def_tx_time,
4642                         adapter->def_read_handler->user_data);
4643 done:
4644         if (adapter->def_read_handler)
4645                 g_free(adapter->def_read_handler->user_data);
4646
4647         g_free(adapter->def_read_handler);
4648         adapter->def_read_handler = NULL;
4649 }
4650
4651 int btd_adapter_le_read_suggested_default_data_length(
4652         struct btd_adapter *adapter)
4653 {
4654         if (mgmt_send(adapter->mgmt,
4655                          MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
4656                          adapter->dev_id, 0, NULL,
4657                          le_read_suggested_default_data_length_return_param_complete,
4658                          adapter, NULL) > 0) {
4659                 return 0;
4660         }
4661
4662         return -EIO;
4663 }
4664
4665 static void le_read_host_suggested_default_length_complete(
4666                         struct btd_adapter *adapter,
4667                         uint16_t def_tx_octects, uint16_t def_tx_time,
4668                         void *user_data)
4669 {
4670         DBusMessage *reply;
4671         struct le_data_length_read_request *read_request;
4672
4673         read_request = find_read_le_data_length_request(adapter);
4674         if (!read_request)
4675                 return;
4676
4677         reply = g_dbus_create_reply(read_request->msg,
4678                         DBUS_TYPE_UINT16, &def_tx_octects,
4679                         DBUS_TYPE_UINT16, &def_tx_time,
4680                         DBUS_TYPE_INVALID);
4681
4682         if (!reply) {
4683                 btd_error_failed(read_request->msg,
4684                         "Failed to read host suggested def data length values");
4685                 return;
4686         }
4687
4688         read_requests = g_slist_remove(read_requests, read_request);
4689         dbus_message_unref(read_request->msg);
4690         g_free(read_request);
4691
4692         if (!g_dbus_send_message(dbus_conn, reply))
4693                 error("D-Bus send failed");
4694 }
4695
4696 static DBusMessage *le_read_host_suggested_default_data_length(
4697                         DBusConnection *conn, DBusMessage *msg,
4698                         void *user_data)
4699 {
4700         struct btd_adapter *adapter = user_data;
4701         struct le_data_length_read_request *read_request;
4702         struct le_data_length_read_default_data_length_handler *handler;
4703
4704         if (find_read_le_data_length_request(adapter))
4705                 return btd_error_in_progress(msg);
4706
4707         if (btd_adapter_le_read_suggested_default_data_length(adapter))
4708                 return btd_error_failed(msg, "Unable to read host suggested def data length");
4709
4710         read_request = g_new(struct le_data_length_read_request, 1);
4711
4712         read_request->msg = dbus_message_ref(msg);
4713         read_request->adapter = adapter;
4714
4715         read_requests = g_slist_append(read_requests, read_request);
4716
4717         handler = g_new0(struct le_data_length_read_default_data_length_handler, 1);
4718
4719         handler->read_callback =
4720                 (read_host_suggested_default_data_length_cb_t)le_read_host_suggested_default_length_complete;
4721
4722         read_request->adapter->def_read_handler = handler;
4723
4724         return NULL;
4725 }
4726
4727 void le_set_data_length_return_param_complete(
4728                         uint8_t status, uint16_t length,
4729                         const void *param, void *user_data)
4730 {
4731         if (status != MGMT_STATUS_SUCCESS) {
4732                 error("le_set_data_length failed: %s (0x%02x)",
4733                         mgmt_errstr(status), status);
4734         }
4735
4736         return;
4737 }
4738
4739 int btd_adapter_le_set_data_length(struct btd_adapter *adapter, bdaddr_t *bdaddr,
4740                                 uint16_t max_tx_octets, uint16_t max_tx_time)
4741 {
4742         struct mgmt_cp_le_set_data_length cp;
4743
4744         memset(&cp, 0, sizeof(cp));
4745
4746         bacpy(&cp.bdaddr, bdaddr);
4747
4748         cp.max_tx_octets = max_tx_octets;
4749         cp.max_tx_time = max_tx_time;
4750
4751         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_DATA_LENGTH,
4752                         adapter->dev_id, sizeof(cp), &cp,
4753                         le_set_data_length_return_param_complete,
4754                         adapter, NULL) > 0)
4755                 return 0;
4756
4757         return -EIO;
4758 }
4759
4760 #endif
4761
4762 static DBusMessage *adapter_set_manufacturer_data(DBusConnection *conn,
4763                                                 DBusMessage *msg, void *data)
4764 {
4765         struct btd_adapter *adapter = data;
4766         struct mgmt_cp_set_manufacturer_data cp;
4767         uint8_t *value;
4768         int32_t len = 0;
4769
4770         DBG("Set manufacturer data");
4771
4772         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4773                 return btd_error_not_ready(msg);
4774
4775         if (!dbus_message_get_args(msg, NULL,
4776                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4777                         DBUS_TYPE_INVALID))
4778                 return btd_error_invalid_args(msg);
4779
4780         if (len > MANUFACTURER_DATA_LENGTH_MAX)
4781                 return btd_error_invalid_args(msg);
4782
4783         memcpy(&cp, value, len);
4784
4785         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_MANUFACTURER_DATA,
4786                                         adapter->dev_id, MANUFACTURER_DATA_LENGTH_MAX,
4787                                         &cp, NULL, NULL, NULL) > 0)
4788                 return dbus_message_new_method_return(msg);
4789
4790         return btd_error_failed(msg, "Set manufacturer data failed");
4791 }
4792 #endif /* __TIZEN_PATCH__ */
4793
4794 static bool parse_uuids(DBusMessageIter *value, GSList **uuids)
4795 {
4796         DBusMessageIter arriter;
4797
4798         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_ARRAY)
4799                 return false;
4800
4801         dbus_message_iter_recurse(value, &arriter);
4802         while (dbus_message_iter_get_arg_type(&arriter) != DBUS_TYPE_INVALID) {
4803                 bt_uuid_t uuid, u128;
4804                 char uuidstr[MAX_LEN_UUID_STR + 1];
4805                 char *uuid_param;
4806
4807                 if (dbus_message_iter_get_arg_type(&arriter) !=
4808                                                 DBUS_TYPE_STRING)
4809                         return false;
4810
4811                 dbus_message_iter_get_basic(&arriter, &uuid_param);
4812
4813                 if (bt_string_to_uuid(&uuid, uuid_param))
4814                         return false;
4815
4816                 bt_uuid_to_uuid128(&uuid, &u128);
4817                 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
4818
4819                 *uuids = g_slist_prepend(*uuids, strdup(uuidstr));
4820
4821                 dbus_message_iter_next(&arriter);
4822         }
4823
4824         return true;
4825 }
4826
4827 static bool parse_rssi(DBusMessageIter *value, int16_t *rssi)
4828 {
4829         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_INT16)
4830                 return false;
4831
4832         dbus_message_iter_get_basic(value, rssi);
4833         /* -127 <= RSSI <= +20 (spec V4.2 [Vol 2, Part E] 7.7.65.2) */
4834         if (*rssi > 20 || *rssi < -127)
4835                 return false;
4836
4837         return true;
4838 }
4839
4840 static bool parse_pathloss(DBusMessageIter *value, uint16_t *pathloss)
4841 {
4842         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT16)
4843                 return false;
4844
4845         dbus_message_iter_get_basic(value, pathloss);
4846         /* pathloss filter must be smaller that PATHLOSS_MAX */
4847         if (*pathloss > PATHLOSS_MAX)
4848                 return false;
4849
4850         return true;
4851 }
4852
4853 static bool parse_transport(DBusMessageIter *value, uint8_t *transport)
4854 {
4855         char *transport_str;
4856
4857         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
4858                 return false;
4859
4860         dbus_message_iter_get_basic(value, &transport_str);
4861
4862         if (!strcmp(transport_str, "bredr"))
4863                 *transport = SCAN_TYPE_BREDR;
4864         else if (!strcmp(transport_str, "le"))
4865                 *transport = SCAN_TYPE_LE;
4866         else if (!strcmp(transport_str, "auto"))
4867                 *transport = SCAN_TYPE_DUAL;
4868         else
4869                 return false;
4870
4871         return true;
4872 }
4873
4874 static bool parse_discovery_filter_entry(char *key, DBusMessageIter *value,
4875                                                 struct discovery_filter *filter)
4876 {
4877         if (!strcmp("UUIDs", key))
4878                 return parse_uuids(value, &filter->uuids);
4879
4880         if (!strcmp("RSSI", key))
4881                 return parse_rssi(value, &filter->rssi);
4882
4883         if (!strcmp("Pathloss", key))
4884                 return parse_pathloss(value, &filter->pathloss);
4885
4886         if (!strcmp("Transport", key))
4887                 return parse_transport(value, &filter->type);
4888
4889         DBG("Unknown key parameter: %s!\n", key);
4890         return false;
4891 }
4892
4893 /*
4894  * This method is responsible for parsing parameters to SetDiscoveryFilter. If
4895  * filter in msg was empty, sets *filter to NULL. If whole parsing was
4896  * successful, sets *filter to proper value.
4897  * Returns false on any error, and true on success.
4898  */
4899 static bool parse_discovery_filter_dict(struct discovery_filter **filter,
4900                                                         DBusMessage *msg)
4901 {
4902         DBusMessageIter iter, subiter, dictiter, variantiter;
4903         bool is_empty = true;
4904
4905         *filter = g_try_malloc(sizeof(**filter));
4906         if (!*filter)
4907                 return false;
4908
4909         (*filter)->uuids = NULL;
4910         (*filter)->pathloss = DISTANCE_VAL_INVALID;
4911         (*filter)->rssi = DISTANCE_VAL_INVALID;
4912         (*filter)->type = SCAN_TYPE_DUAL;
4913
4914         dbus_message_iter_init(msg, &iter);
4915         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
4916             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
4917                 goto invalid_args;
4918
4919         dbus_message_iter_recurse(&iter, &subiter);
4920         do {
4921                 int type = dbus_message_iter_get_arg_type(&subiter);
4922                 char *key;
4923
4924                 if (type == DBUS_TYPE_INVALID)
4925                         break;
4926
4927                 is_empty = false;
4928                 dbus_message_iter_recurse(&subiter, &dictiter);
4929
4930                 dbus_message_iter_get_basic(&dictiter, &key);
4931                 if (!dbus_message_iter_next(&dictiter))
4932                         goto invalid_args;
4933
4934                 if (dbus_message_iter_get_arg_type(&dictiter) !=
4935                                                              DBUS_TYPE_VARIANT)
4936                         goto invalid_args;
4937
4938                 dbus_message_iter_recurse(&dictiter, &variantiter);
4939
4940                 if (!parse_discovery_filter_entry(key, &variantiter, *filter))
4941                         goto invalid_args;
4942
4943                 dbus_message_iter_next(&subiter);
4944         } while (true);
4945
4946         if (is_empty) {
4947                 g_free(*filter);
4948                 *filter = NULL;
4949                 return true;
4950         }
4951
4952         /* only pathlos or rssi can be set, never both */
4953         if ((*filter)->pathloss != DISTANCE_VAL_INVALID &&
4954             (*filter)->rssi != DISTANCE_VAL_INVALID)
4955                 goto invalid_args;
4956
4957         DBG("filtered discovery params: transport: %d rssi: %d pathloss: %d",
4958             (*filter)->type, (*filter)->rssi, (*filter)->pathloss);
4959
4960         return true;
4961
4962 invalid_args:
4963         g_slist_free_full((*filter)->uuids, g_free);
4964         g_free(*filter);
4965         *filter = NULL;
4966         return false;
4967 }
4968
4969 static DBusMessage *set_discovery_filter(DBusConnection *conn,
4970                                         DBusMessage *msg, void *user_data)
4971 {
4972         struct btd_adapter *adapter = user_data;
4973         struct watch_client *client;
4974         struct discovery_filter *discovery_filter;
4975         const char *sender = dbus_message_get_sender(msg);
4976         bool is_discovering;
4977
4978         DBG("sender %s", sender);
4979
4980         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4981                 return btd_error_not_ready(msg);
4982
4983         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 8))
4984                 return btd_error_not_supported(msg);
4985
4986         /* parse parameters */
4987         if (!parse_discovery_filter_dict(&discovery_filter, msg))
4988                 return btd_error_invalid_args(msg);
4989
4990         is_discovering = get_discovery_client(adapter, sender, &client);
4991
4992         if (client) {
4993                 free_discovery_filter(client->discovery_filter);
4994                 client->discovery_filter = discovery_filter;
4995
4996                 if (is_discovering)
4997                         update_discovery_filter(adapter);
4998
4999                 if (discovery_filter || is_discovering)
5000                         return dbus_message_new_method_return(msg);
5001
5002                 /* Removing pre-set filter */
5003                 adapter->set_filter_list = g_slist_remove(
5004                                               adapter->set_filter_list,
5005                                               client);
5006                 g_free(client->owner);
5007                 g_free(client);
5008                 DBG("successfully cleared pre-set filter");
5009         } else if (discovery_filter) {
5010                 /* Client pre-setting his filter for first time */
5011                 client = g_new0(struct watch_client, 1);
5012                 client->adapter = adapter;
5013                 client->owner = g_strdup(sender);
5014                 client->discovery_filter = discovery_filter;
5015                 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
5016                                                 discovery_disconnect, client,
5017                                                 discovery_destroy);
5018                 adapter->set_filter_list = g_slist_prepend(
5019                                              adapter->set_filter_list, client);
5020
5021                 DBG("successfully pre-set filter");
5022         }
5023
5024         return dbus_message_new_method_return(msg);
5025 }
5026
5027 static DBusMessage *stop_discovery(DBusConnection *conn,
5028                                         DBusMessage *msg, void *user_data)
5029 {
5030         struct btd_adapter *adapter = user_data;
5031         const char *sender = dbus_message_get_sender(msg);
5032         struct mgmt_cp_stop_discovery cp;
5033         struct watch_client *client;
5034         GSList *list;
5035
5036         DBG("sender %s", sender);
5037
5038         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5039                 return btd_error_not_ready(msg);
5040
5041         list = g_slist_find_custom(adapter->discovery_list, sender,
5042                                                 compare_sender);
5043         if (!list)
5044                 return btd_error_failed(msg, "No discovery started");
5045
5046         client = list->data;
5047
5048 #ifdef __TIZEN_PATCH__
5049         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
5050 #endif
5051         cp.type = adapter->discovery_type;
5052
5053         /*
5054          * The destroy function will cleanup the client information and
5055          * also remove it from the list of discovery clients.
5056          */
5057         g_dbus_remove_watch(dbus_conn, client->watch);
5058
5059         if (adapter->discovery_list) {
5060                 update_discovery_filter(adapter);
5061                 return dbus_message_new_method_return(msg);
5062         }
5063
5064         /*
5065          * In the idle phase of a discovery, there is no need to stop it
5066          * and so it is enough to send out the signal and just return.
5067          */
5068         if (adapter->discovery_enable == 0x00) {
5069                 adapter->discovering = false;
5070                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
5071                                         ADAPTER_INTERFACE, "Discovering");
5072
5073                 trigger_passive_scanning(adapter);
5074
5075                 return dbus_message_new_method_return(msg);
5076         }
5077 #ifdef __TIZEN_PATCH__
5078         cp.type = 0x01;
5079 #endif
5080         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
5081                                 adapter->dev_id, sizeof(cp), &cp,
5082                                 stop_discovery_complete, adapter, NULL);
5083
5084         return dbus_message_new_method_return(msg);
5085 }
5086
5087 static gboolean property_get_address(const GDBusPropertyTable *property,
5088                                         DBusMessageIter *iter, void *user_data)
5089 {
5090         struct btd_adapter *adapter = user_data;
5091         char addr[18];
5092         const char *str = addr;
5093
5094         ba2str(&adapter->bdaddr, addr);
5095
5096         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
5097
5098         return TRUE;
5099 }
5100
5101 #ifdef __TIZEN_PATCH__
5102 static gboolean property_get_le_address(const GDBusPropertyTable *property,
5103                                         DBusMessageIter *iter, void *user_data)
5104 {
5105         struct btd_adapter *adapter = user_data;
5106         DBusMessageIter entry;
5107         char addr[18];
5108         const char *str = addr;
5109         char *type = NULL;
5110
5111         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
5112                                         DBUS_TYPE_STRING_AS_STRING, &entry);
5113
5114         if (adapter->le_static_addr.b[5] != 0) {
5115                 ba2str(&adapter->le_static_addr, addr);
5116                 type = g_strdup_printf("%d", BDADDR_LE_RANDOM);
5117         } else {
5118                 ba2str(&adapter->bdaddr, addr);
5119                 type = g_strdup_printf("%d", BDADDR_LE_PUBLIC);
5120         }
5121
5122         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &type);
5123         g_free((void *)type);
5124
5125         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
5126
5127         dbus_message_iter_close_container(iter, &entry);
5128
5129         return TRUE;
5130 }
5131 #endif
5132
5133 static gboolean property_get_name(const GDBusPropertyTable *property,
5134                                         DBusMessageIter *iter, void *user_data)
5135 {
5136         struct btd_adapter *adapter = user_data;
5137         const char *str = adapter->system_name ? : "";
5138
5139         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
5140
5141         return TRUE;
5142 }
5143
5144 static gboolean property_get_alias(const GDBusPropertyTable *property,
5145                                         DBusMessageIter *iter, void *user_data)
5146 {
5147         struct btd_adapter *adapter = user_data;
5148         const char *str;
5149
5150         if (adapter->current_alias)
5151                 str = adapter->current_alias;
5152         else if (adapter->stored_alias)
5153                 str = adapter->stored_alias;
5154         else
5155                 str = adapter->system_name ? : "";
5156
5157         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
5158
5159         return TRUE;
5160 }
5161
5162 static void property_set_alias(const GDBusPropertyTable *property,
5163                                 DBusMessageIter *iter,
5164                                 GDBusPendingPropertySet id, void *user_data)
5165 {
5166         struct btd_adapter *adapter = user_data;
5167         const char *name;
5168         int ret;
5169
5170         dbus_message_iter_get_basic(iter, &name);
5171
5172         if (g_str_equal(name, "")  == TRUE) {
5173                 if (adapter->stored_alias == NULL) {
5174                         /* no alias set, nothing to restore */
5175                         g_dbus_pending_property_success(id);
5176                         return;
5177                 }
5178
5179                 /* restore to system name */
5180                 ret = set_name(adapter, adapter->system_name);
5181         } else {
5182                 if (g_strcmp0(adapter->stored_alias, name) == 0) {
5183                         /* alias already set, nothing to do */
5184                         g_dbus_pending_property_success(id);
5185                         return;
5186                 }
5187
5188                 /* set to alias */
5189                 ret = set_name(adapter, name);
5190         }
5191
5192         if (ret >= 0) {
5193                 g_free(adapter->stored_alias);
5194
5195                 if (g_str_equal(name, "")  == TRUE)
5196                         adapter->stored_alias = NULL;
5197                 else
5198                         adapter->stored_alias = g_strdup(name);
5199
5200                 store_adapter_info(adapter);
5201
5202                 g_dbus_pending_property_success(id);
5203                 return;
5204         }
5205
5206         if (ret == -EINVAL)
5207                 g_dbus_pending_property_error(id,
5208                                         ERROR_INTERFACE ".InvalidArguments",
5209                                         "Invalid arguments in method call");
5210         else
5211                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
5212                                                         strerror(-ret));
5213 }
5214
5215 static gboolean property_get_class(const GDBusPropertyTable *property,
5216                                         DBusMessageIter *iter, void *user_data)
5217 {
5218         struct btd_adapter *adapter = user_data;
5219         dbus_uint32_t val = adapter->dev_class;
5220
5221         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
5222
5223         return TRUE;
5224 }
5225
5226 static gboolean property_get_mode(struct btd_adapter *adapter,
5227                                 uint32_t setting, DBusMessageIter *iter)
5228 {
5229         dbus_bool_t enable;
5230
5231         enable = (adapter->current_settings & setting) ? TRUE : FALSE;
5232
5233         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
5234
5235         return TRUE;
5236 }
5237
5238 struct property_set_data {
5239         struct btd_adapter *adapter;
5240         GDBusPendingPropertySet id;
5241 };
5242
5243 static void property_set_mode_complete(uint8_t status, uint16_t length,
5244                                         const void *param, void *user_data)
5245 {
5246         struct property_set_data *data = user_data;
5247         struct btd_adapter *adapter = data->adapter;
5248
5249         DBG("%s (0x%02x)", mgmt_errstr(status), status);
5250
5251         if (status != MGMT_STATUS_SUCCESS) {
5252                 const char *dbus_err;
5253
5254                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
5255                                                 mgmt_errstr(status), status);
5256
5257                 if (status == MGMT_STATUS_RFKILLED)
5258                         dbus_err = ERROR_INTERFACE ".Blocked";
5259                 else
5260                         dbus_err = ERROR_INTERFACE ".Failed";
5261
5262                 g_dbus_pending_property_error(data->id, dbus_err,
5263                                                         mgmt_errstr(status));
5264                 return;
5265         }
5266
5267         g_dbus_pending_property_success(data->id);
5268
5269         /*
5270          * The parameters are identical and also the task that is
5271          * required in both cases. So it is safe to just call the
5272          * event handling functions here.
5273          */
5274         new_settings_callback(adapter->dev_id, length, param, adapter);
5275 }
5276
5277 static void property_set_mode(struct btd_adapter *adapter, uint32_t setting,
5278                                                 DBusMessageIter *value,
5279                                                 GDBusPendingPropertySet id)
5280 {
5281         struct property_set_data *data;
5282         struct mgmt_cp_set_discoverable cp;
5283         void *param;
5284         dbus_bool_t enable, current_enable;
5285         uint16_t opcode, len;
5286         uint8_t mode;
5287
5288         dbus_message_iter_get_basic(value, &enable);
5289
5290         if (adapter->current_settings & setting)
5291                 current_enable = TRUE;
5292         else
5293                 current_enable = FALSE;
5294
5295         if (enable == current_enable) {
5296                 g_dbus_pending_property_success(id);
5297                 return;
5298         }
5299
5300         mode = (enable == TRUE) ? 0x01 : 0x00;
5301
5302         switch (setting) {
5303         case MGMT_SETTING_POWERED:
5304                 opcode = MGMT_OP_SET_POWERED;
5305                 param = &mode;
5306                 len = sizeof(mode);
5307                 break;
5308         case MGMT_SETTING_DISCOVERABLE:
5309 #ifndef __TIZEN_PATCH__
5310                 if (kernel_conn_control) {
5311                         if (mode) {
5312                                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
5313                                                                         mode);
5314                         } else {
5315                                 opcode = MGMT_OP_SET_CONNECTABLE;
5316                                 param = &mode;
5317                                 len = sizeof(mode);
5318                                 break;
5319                         }
5320                 }
5321 #endif
5322
5323                 memset(&cp, 0, sizeof(cp));
5324                 cp.val = mode;
5325                 if (cp.val)
5326                         cp.timeout = htobs(adapter->discoverable_timeout);
5327
5328                 opcode = MGMT_OP_SET_DISCOVERABLE;
5329                 param = &cp;
5330                 len = sizeof(cp);
5331                 break;
5332         case MGMT_SETTING_BONDABLE:
5333                 opcode = MGMT_OP_SET_BONDABLE;
5334                 param = &mode;
5335                 len = sizeof(mode);
5336                 break;
5337 #ifdef __TIZEN_PATCH__
5338         case MGMT_SETTING_CONNECTABLE:
5339                 opcode = MGMT_OP_SET_CONNECTABLE;
5340                 param = &mode;
5341                 len = sizeof(mode);
5342                 break;
5343 #endif
5344         default:
5345                 goto failed;
5346         }
5347
5348         DBG("sending %s command for index %u", mgmt_opstr(opcode),
5349                                                         adapter->dev_id);
5350
5351         data = g_try_new0(struct property_set_data, 1);
5352         if (!data)
5353                 goto failed;
5354
5355         data->adapter = adapter;
5356         data->id = id;
5357
5358 /* Because of timing issue, sometimes pscan / iscan value was wrong. */
5359 #if 0
5360 /* #ifdef __TIZEN_PATCH__ */
5361         /*
5362          * Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
5363          */
5364         if (mgmt_send_nowait(adapter->mgmt, opcode, adapter->dev_id, len, param,
5365                                 property_set_mode_complete, data, g_free) > 0)
5366 #else
5367         if (mgmt_send(adapter->mgmt, opcode, adapter->dev_id, len, param,
5368                                 property_set_mode_complete, data, g_free) > 0)
5369 #endif
5370                 return;
5371
5372         g_free(data);
5373
5374 failed:
5375         btd_error(adapter->dev_id, "Failed to set mode for index %u",
5376                                                         adapter->dev_id);
5377
5378         g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
5379 }
5380
5381 static gboolean property_get_powered(const GDBusPropertyTable *property,
5382                                         DBusMessageIter *iter, void *user_data)
5383 {
5384         struct btd_adapter *adapter = user_data;
5385
5386         return property_get_mode(adapter, MGMT_SETTING_POWERED, iter);
5387 }
5388
5389 static void property_set_powered(const GDBusPropertyTable *property,
5390                                 DBusMessageIter *iter,
5391                                 GDBusPendingPropertySet id, void *user_data)
5392 {
5393         struct btd_adapter *adapter = user_data;
5394
5395         if (powering_down) {
5396                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
5397                                                         "Powering down");
5398                 return;
5399         }
5400
5401         property_set_mode(adapter, MGMT_SETTING_POWERED, iter, id);
5402 }
5403
5404 static gboolean property_get_discoverable(const GDBusPropertyTable *property,
5405                                         DBusMessageIter *iter, void *user_data)
5406 {
5407         struct btd_adapter *adapter = user_data;
5408
5409         return property_get_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter);
5410 }
5411
5412 static void property_set_discoverable(const GDBusPropertyTable *property,
5413                                 DBusMessageIter *iter,
5414                                 GDBusPendingPropertySet id, void *user_data)
5415 {
5416         struct btd_adapter *adapter = user_data;
5417
5418         if (adapter->discoverable_timeout > 0 &&
5419                         !(adapter->current_settings & MGMT_SETTING_POWERED)) {
5420                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
5421                                                                 "Not Powered");
5422                 return;
5423         }
5424
5425         property_set_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter, id);
5426 }
5427
5428 static gboolean property_get_discoverable_timeout(
5429                                         const GDBusPropertyTable *property,
5430                                         DBusMessageIter *iter, void *user_data)
5431 {
5432         struct btd_adapter *adapter = user_data;
5433         dbus_uint32_t value = adapter->discoverable_timeout;
5434
5435         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
5436
5437         return TRUE;
5438 }
5439
5440 static void property_set_discoverable_timeout(
5441                                 const GDBusPropertyTable *property,
5442                                 DBusMessageIter *iter,
5443                                 GDBusPendingPropertySet id, void *user_data)
5444 {
5445         struct btd_adapter *adapter = user_data;
5446         dbus_uint32_t value;
5447
5448         dbus_message_iter_get_basic(iter, &value);
5449
5450         adapter->discoverable_timeout = value;
5451
5452         g_dbus_pending_property_success(id);
5453
5454         store_adapter_info(adapter);
5455
5456         g_dbus_emit_property_changed(dbus_conn, adapter->path,
5457                                 ADAPTER_INTERFACE, "DiscoverableTimeout");
5458
5459
5460         if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
5461                 set_discoverable(adapter, 0x01, adapter->discoverable_timeout);
5462 }
5463
5464 static gboolean property_get_pairable(const GDBusPropertyTable *property,
5465                                         DBusMessageIter *iter, void *user_data)
5466 {
5467         struct btd_adapter *adapter = user_data;
5468
5469         return property_get_mode(adapter, MGMT_SETTING_BONDABLE, iter);
5470 }
5471
5472 static void property_set_pairable(const GDBusPropertyTable *property,
5473                                 DBusMessageIter *iter,
5474                                 GDBusPendingPropertySet id, void *user_data)
5475 {
5476         struct btd_adapter *adapter = user_data;
5477
5478         property_set_mode(adapter, MGMT_SETTING_BONDABLE, iter, id);
5479 }
5480
5481 static gboolean property_get_pairable_timeout(
5482                                         const GDBusPropertyTable *property,
5483                                         DBusMessageIter *iter, void *user_data)
5484 {
5485         struct btd_adapter *adapter = user_data;
5486         dbus_uint32_t value = adapter->pairable_timeout;
5487
5488         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
5489
5490         return TRUE;
5491 }
5492
5493 static void property_set_pairable_timeout(const GDBusPropertyTable *property,
5494                                 DBusMessageIter *iter,
5495                                 GDBusPendingPropertySet id, void *user_data)
5496 {
5497         struct btd_adapter *adapter = user_data;
5498         dbus_uint32_t value;
5499
5500         dbus_message_iter_get_basic(iter, &value);
5501
5502         adapter->pairable_timeout = value;
5503
5504         g_dbus_pending_property_success(id);
5505
5506         store_adapter_info(adapter);
5507
5508         g_dbus_emit_property_changed(dbus_conn, adapter->path,
5509                                         ADAPTER_INTERFACE, "PairableTimeout");
5510
5511         trigger_pairable_timeout(adapter);
5512 }
5513
5514 static gboolean property_get_discovering(const GDBusPropertyTable *property,
5515                                         DBusMessageIter *iter, void *user_data)
5516 {
5517         struct btd_adapter *adapter = user_data;
5518         dbus_bool_t discovering = adapter->discovering;
5519
5520         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
5521
5522         return TRUE;
5523 }
5524
5525 static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
5526 {
5527         GHashTable *uuids = user_data;
5528         bt_uuid_t uuid, u128;
5529         char uuidstr[MAX_LEN_UUID_STR + 1];
5530
5531         if (!gatt_db_service_get_active(attrib))
5532                 return;
5533
5534         if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
5535                 return;
5536
5537         bt_uuid_to_uuid128(&uuid, &u128);
5538         bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
5539
5540         g_hash_table_add(uuids, strdup(uuidstr));
5541 }
5542
5543 static void iter_append_uuid(gpointer key, gpointer value, gpointer user_data)
5544 {
5545         DBusMessageIter *iter = user_data;
5546         const char *uuid = key;
5547
5548         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
5549 }
5550
5551 #ifdef __TIZEN_PATCH__
5552
5553 static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
5554                                         DBusMessageIter *iter, void *user_data)
5555 {
5556         struct btd_adapter *adapter = user_data;
5557         dbus_bool_t discovering = adapter->le_discovering;
5558
5559         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
5560
5561         return TRUE;
5562 }
5563
5564 #if 0 // Not used
5565 static gboolean property_get_secure_connection(const GDBusPropertyTable
5566                           *property, DBusMessageIter *iter, void *user_data)
5567 {
5568         struct btd_adapter *adapter = user_data;
5569         dbus_bool_t secure_connection = adapter->secure_connection;
5570
5571         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
5572                                   &secure_connection);
5573
5574         return TRUE;
5575 }
5576 #endif
5577
5578 static gboolean property_get_connectable(const GDBusPropertyTable *property,
5579                                         DBusMessageIter *iter, void *user_data)
5580 {
5581         struct btd_adapter *adapter = user_data;
5582
5583         return property_get_mode(adapter, MGMT_SETTING_CONNECTABLE, iter);
5584 }
5585
5586 static void property_set_connectable(const GDBusPropertyTable *property,
5587                                 DBusMessageIter *iter,
5588                                 GDBusPendingPropertySet id, void *user_data)
5589 {
5590         struct btd_adapter *adapter = user_data;
5591
5592         property_set_mode(adapter, MGMT_SETTING_CONNECTABLE, iter, id);
5593 }
5594
5595 static gboolean property_get_version(const GDBusPropertyTable *property,
5596                                         DBusMessageIter *iter, void *user_data)
5597 {
5598         struct btd_adapter *adapter = user_data;
5599         const char *str = adapter->version ? : "";
5600
5601         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
5602
5603         return TRUE;
5604 }
5605
5606 static gboolean property_get_supported_le_features(
5607                                         const GDBusPropertyTable *property,
5608                                         DBusMessageIter *iter, void *user_data)
5609 {
5610         const char *str, *val;
5611         int value;
5612         DBusMessageIter entry;
5613
5614         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
5615                                         DBUS_TYPE_STRING_AS_STRING, &entry);
5616
5617         value = adapter_le_get_max_adv_instance();
5618         if (value > 0) {
5619                 str = g_strdup("adv_inst_max");
5620                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
5621
5622                 val = g_strdup_printf("%d", value);
5623                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
5624
5625                 g_free((void *)str);
5626                 g_free((void *)val);
5627         }
5628
5629         value = adapter_le_is_supported_offloading();
5630         if (value > 0) {
5631                 str = g_strdup("rpa_offloading");
5632                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
5633
5634                 val = g_strdup_printf("%d", value);
5635                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
5636
5637                 g_free((void *)str);
5638                 g_free((void *)val);
5639         }
5640
5641         value = adapter_le_get_scan_filter_size();
5642         if (value > 0) {
5643                 str = g_strdup("max_filter");
5644                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
5645
5646                 val = g_strdup_printf("%d", value);
5647                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
5648
5649                 g_free((void *)str);
5650                 g_free((void *)val);
5651         }
5652
5653         dbus_message_iter_close_container(iter, &entry);
5654
5655         return TRUE;
5656 }
5657
5658 static gboolean property_get_ipsp_init_state(
5659                                         const GDBusPropertyTable *property,
5660                                         DBusMessageIter *iter, void *data)
5661 {
5662         struct btd_adapter *adapter = data;
5663         dbus_bool_t ipsp_initialized;
5664
5665         DBG("property_get_ipsp_init_state called");
5666         if (adapter->ipsp_intialized)
5667                 ipsp_initialized = TRUE;
5668         else
5669                 ipsp_initialized = FALSE;
5670
5671         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
5672                                         &ipsp_initialized);
5673
5674         return TRUE;
5675 }
5676 #endif
5677
5678 static gboolean property_get_uuids(const GDBusPropertyTable *property,
5679                                         DBusMessageIter *iter, void *user_data)
5680 {
5681         struct btd_adapter *adapter = user_data;
5682         DBusMessageIter entry;
5683         sdp_list_t *l;
5684         struct gatt_db *db;
5685         GHashTable *uuids;
5686
5687         uuids = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
5688         if (!uuids)
5689                 return FALSE;
5690
5691         /* SDP records */
5692         for (l = adapter->services; l != NULL; l = l->next) {
5693                 sdp_record_t *rec = l->data;
5694                 char *uuid;
5695
5696                 uuid = bt_uuid2string(&rec->svclass);
5697                 if (uuid == NULL)
5698                         continue;
5699
5700                 g_hash_table_add(uuids, uuid);
5701         }
5702
5703         /* GATT services */
5704         db = btd_gatt_database_get_db(adapter->database);
5705         if (db)
5706                 gatt_db_foreach_service(db, NULL, add_gatt_uuid, uuids);
5707
5708         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
5709                                         DBUS_TYPE_STRING_AS_STRING, &entry);
5710         g_hash_table_foreach(uuids, iter_append_uuid, &entry);
5711         dbus_message_iter_close_container(iter, &entry);
5712
5713         g_hash_table_destroy(uuids);
5714
5715         return TRUE;
5716 }
5717
5718 static gboolean property_exists_modalias(const GDBusPropertyTable *property,
5719                                                         void *user_data)
5720 {
5721         struct btd_adapter *adapter = user_data;
5722
5723         return adapter->modalias ? TRUE : FALSE;
5724 }
5725
5726 static gboolean property_get_modalias(const GDBusPropertyTable *property,
5727                                         DBusMessageIter *iter, void *user_data)
5728 {
5729         struct btd_adapter *adapter = user_data;
5730         const char *str = adapter->modalias ? : "";
5731
5732         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
5733
5734         return TRUE;
5735 }
5736
5737 static int device_path_cmp(gconstpointer a, gconstpointer b)
5738 {
5739         const struct btd_device *device = a;
5740         const char *path = b;
5741         const char *dev_path = device_get_path(device);
5742
5743         return strcasecmp(dev_path, path);
5744 }
5745
5746 #ifdef __TIZEN_PATCH__
5747 static DBusMessage *adapter_unpair_device(DBusConnection *conn,
5748                                         DBusMessage *msg, void *user_data)
5749 {
5750         DBG("+");
5751         struct btd_adapter *adapter = user_data;
5752         struct btd_device *device;
5753         const char *path;
5754         GSList *list;
5755
5756         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
5757                                                 DBUS_TYPE_INVALID) == FALSE)
5758                 return btd_error_invalid_args(msg);
5759
5760         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
5761         if (!list)
5762                 return btd_error_does_not_exist(msg);
5763
5764         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5765                 return btd_error_not_ready(msg);
5766
5767         device = list->data;
5768
5769         btd_device_set_temporary(device, TRUE);
5770
5771         if (!btd_device_is_connected(device)) {
5772                 btd_adapter_unpair_device(adapter, device);
5773                 return dbus_message_new_method_return(msg);
5774         }
5775
5776         device_request_disconnect(device, msg);
5777
5778         DBG("-");
5779         return NULL;
5780 }
5781
5782 static DBusMessage *create_device(DBusConnection *conn,
5783                                         DBusMessage *msg, void *data)
5784 {
5785         struct btd_adapter *adapter = data;
5786         const gchar *address;
5787         bdaddr_t addr;
5788         DBG("+");
5789
5790         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
5791                                                 DBUS_TYPE_INVALID) == FALSE)
5792                 return btd_error_invalid_args(msg);
5793
5794         if (check_address(address) < 0)
5795                 return btd_error_invalid_args(msg);
5796
5797         DBG("%s", address);
5798
5799         str2ba(address, &addr);
5800         btd_adapter_get_device(adapter, &addr, BDADDR_BREDR);
5801
5802         DBG("-");
5803         return dbus_message_new_method_return(msg);
5804 }
5805
5806 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
5807                                         void *data)
5808 {
5809         struct btd_adapter *adapter = data;
5810         struct btd_device *device;
5811         DBusMessage *reply;
5812         const gchar *address;
5813         GSList *l;
5814         const gchar *dev_path;
5815         bdaddr_t rpa;
5816         uint8_t msb = 0x00;
5817
5818         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
5819                                                                                         DBUS_TYPE_INVALID))
5820                         return btd_error_invalid_args(msg);
5821
5822         str2ba(address, &rpa);
5823
5824         l = g_slist_find_custom(adapter->devices,
5825                                         address, (GCompareFunc) device_address_cmp);
5826
5827         if (!l) {
5828                 msb = rpa.b[5] >> 6;
5829
5830                 /* Check whether address is RPA */
5831                 if (msb == 0x00 || msb == 0x01)
5832                 l = g_slist_find_custom(adapter->devices,
5833                                         address, (GCompareFunc) device_rpa_cmp);
5834         }
5835
5836         if (!l)
5837                 return btd_error_does_not_exist(msg);
5838
5839         device = l->data;
5840
5841         reply = dbus_message_new_method_return(msg);
5842         if (!reply)
5843                         return NULL;
5844
5845         dev_path = device_get_path(device);
5846
5847         dbus_message_append_args(reply,
5848                                                         DBUS_TYPE_OBJECT_PATH, &dev_path,
5849                                                         DBUS_TYPE_INVALID);
5850
5851         return reply;
5852 }
5853
5854 static gboolean adapter_ipsp_connected(struct btd_adapter *adapter)
5855 {
5856         GSList *l, *next;
5857
5858         DBG("%s", adapter->path);
5859
5860         for (l = adapter->connections; l != NULL; l = next) {
5861                 struct btd_device *dev = l->data;
5862
5863                 next = g_slist_next(l);
5864
5865                 if (device_is_ipsp_connected(dev))
5866                         return TRUE;
5867         }
5868
5869         return FALSE;
5870 }
5871
5872 static void adapter_set_ipsp_init_state(struct btd_adapter *adapter, gboolean initialized)
5873 {
5874         if (adapter->ipsp_intialized == initialized)
5875                 return;
5876
5877         adapter->ipsp_intialized = initialized;
5878
5879         DBG("Set Ipsp init state for adapter %s", adapter->path);
5880
5881         g_dbus_emit_property_changed(dbus_conn, adapter->path,
5882                                                 ADAPTER_INTERFACE, "IpspInitStateChanged");
5883 }
5884
5885 static void deinitialize_6lowpan_complete(uint8_t status, uint16_t length,
5886         const void *param, void *user_data)
5887 {
5888         struct btd_adapter *adapter = user_data;
5889         bool initialized = FALSE;
5890
5891         if (status != MGMT_STATUS_SUCCESS)
5892                 error("De-Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
5893                         adapter->dev_id, mgmt_errstr(status), status);
5894         else {
5895                 adapter_set_ipsp_init_state(adapter, initialized);
5896                 DBG("De-Initialize BT 6lowpan successfully for hci%u",
5897                         adapter->dev_id);
5898         }
5899 }
5900
5901 static bool deinitialize_6lowpan(struct btd_adapter *adapter)
5902 {
5903         struct mgmt_cp_enable_6lowpan cp;
5904
5905         memset(&cp, 0, sizeof(cp));
5906
5907         cp.enable_6lowpan = DEINIT_6LOWPAN;
5908         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
5909                         adapter->dev_id, sizeof(cp), &cp,
5910                         deinitialize_6lowpan_complete, adapter, NULL) > 0)
5911                 return true;
5912
5913         error("Failed to de-initialize BT 6Lowpan for index %u",
5914                 adapter->dev_id);
5915         return false;
5916 }
5917
5918 static void initialize_6lowpan_complete(uint8_t status, uint16_t length,
5919         const void *param, void *user_data)
5920 {
5921         struct btd_adapter *adapter = user_data;
5922         bool initialized = TRUE;
5923
5924         if (status != MGMT_STATUS_SUCCESS)
5925                 error("Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
5926                         adapter->dev_id, mgmt_errstr(status), status);
5927         else {
5928                 adapter_set_ipsp_init_state(adapter, initialized);
5929                 DBG("Initialize BT 6lowpan successfully for hci%u",
5930                         adapter->dev_id);
5931         }
5932 }
5933
5934 static bool initialize_6lowpan(struct btd_adapter *adapter)
5935 {
5936         struct mgmt_cp_enable_6lowpan cp;
5937
5938         memset(&cp, 0, sizeof(cp));
5939
5940         cp.enable_6lowpan = INIT_6LOWPAN;
5941         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
5942                         adapter->dev_id, sizeof(cp), &cp,
5943                         initialize_6lowpan_complete, adapter, NULL) > 0)
5944                 return true;
5945
5946         error("Failed to initialize BT 6Lowpan for index %u",
5947                 adapter->dev_id);
5948         return false;
5949 }
5950
5951 static DBusMessage *adapter_initialize_ipsp(DBusConnection *conn,
5952                                         DBusMessage *msg, void *data)
5953 {
5954         struct btd_adapter *adapter = data;
5955         dbus_bool_t err;
5956
5957         DBG("Initialize IPSP");
5958
5959         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5960                 return btd_error_not_ready(msg);
5961
5962         if (adapter->ipsp_intialized)
5963                 return btd_error_already_exists(msg);
5964
5965         /* Enable BT 6lowpan in kernel */
5966         err = initialize_6lowpan(adapter);
5967
5968         if (!err)
5969                 return btd_error_failed(msg, "Failed to initialize BT 6lowpan");
5970
5971         return dbus_message_new_method_return(msg);
5972 }
5973
5974 static DBusMessage *adapter_deinitialize_ipsp(DBusConnection *conn,
5975                                         DBusMessage *msg, void *data)
5976 {
5977         struct btd_adapter *adapter = data;
5978         dbus_bool_t err;
5979
5980         DBG("De-initialize IPSP");
5981
5982         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5983                 return btd_error_not_ready(msg);
5984
5985         if (!adapter->ipsp_intialized)
5986                 return btd_error_not_permitted(msg, "IPSP not initialized");
5987
5988         if (adapter_ipsp_connected(adapter))
5989                 return btd_error_not_permitted(msg, "IPSP Client device found connected");
5990
5991         /* Disable BT 6lowpan in kernel */
5992         err = deinitialize_6lowpan(adapter);
5993
5994         if (!err)
5995                 return btd_error_failed(msg, "Failed to deinitialize BT 6lowpan");
5996
5997         return dbus_message_new_method_return(msg);
5998 }
5999 #endif
6000
6001 static DBusMessage *remove_device(DBusConnection *conn,
6002                                         DBusMessage *msg, void *user_data)
6003 {
6004         struct btd_adapter *adapter = user_data;
6005         struct btd_device *device;
6006         const char *path;
6007         GSList *list;
6008
6009         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
6010                                                 DBUS_TYPE_INVALID) == FALSE)
6011                 return btd_error_invalid_args(msg);
6012
6013         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
6014         if (!list)
6015                 return btd_error_does_not_exist(msg);
6016
6017         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6018                 return btd_error_not_ready(msg);
6019
6020         device = list->data;
6021
6022         btd_device_set_temporary(device, true);
6023
6024         if (!btd_device_is_connected(device)) {
6025                 btd_adapter_remove_device(adapter, device);
6026                 return dbus_message_new_method_return(msg);
6027         }
6028
6029         device_request_disconnect(device, msg);
6030
6031         return NULL;
6032 }
6033
6034 static const GDBusMethodTable adapter_methods[] = {
6035         { GDBUS_METHOD("StartDiscovery", NULL, NULL, start_discovery) },
6036         { GDBUS_METHOD("SetDiscoveryFilter",
6037                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
6038                                 set_discovery_filter) },
6039         { GDBUS_METHOD("StopDiscovery", NULL, NULL, stop_discovery) },
6040 #ifdef __TIZEN_PATCH__
6041         { GDBUS_METHOD("StartCustomDiscovery",
6042                         GDBUS_ARGS({ "type", "s" }), NULL,
6043                         adapter_start_custom_discovery) },
6044         { GDBUS_METHOD("StartLEDiscovery", NULL, NULL,
6045                         adapter_start_le_discovery) },
6046         { GDBUS_ASYNC_METHOD("StopLEDiscovery", NULL, NULL,
6047                         adapter_stop_le_discovery) },
6048 #if 0 // Not used
6049         { GDBUS_METHOD("EnableSecureConnection",
6050                         GDBUS_ARGS({"enable", "b"}), NULL,
6051                         write_sec_conn_host_support)},
6052
6053         { GDBUS_METHOD("ReadSecureConnection", NULL,
6054                                         NULL, read_sec_conn_host_support)},
6055 #endif
6056
6057         { GDBUS_METHOD("SetAdvertising",
6058                         GDBUS_ARGS({ "enable", "b" },
6059                                 { "slot_id", "i" }), NULL,
6060                         adapter_set_advertising) },
6061         { GDBUS_METHOD("SetAdvertisingParameters",
6062                         GDBUS_ARGS({ "interval_min", "u" },
6063                                 { "interval_max", "u" },
6064                                 { "filter_policy", "u" },
6065                                 { "type", "u" },
6066                                 { "slot_id", "i" }), NULL,
6067                         adapter_set_advertising_params) },
6068         { GDBUS_METHOD("SetAdvertisingData",
6069                         GDBUS_ARGS({ "value", "ay" },
6070                                 { "slot_id", "i" }), NULL,
6071                         adapter_set_advertising_data) },
6072         { GDBUS_METHOD("SetScanParameters",
6073                         GDBUS_ARGS({ "type", "u" },
6074                                 { "interval", "u" },
6075                                 { "window", "u" }), NULL,
6076                         adapter_le_set_scan_params) },
6077         { GDBUS_ASYNC_METHOD("scan_filter_param_setup",
6078                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
6079                                 { "filt_index", "i" }, { "feat_seln", "i"},
6080                                 { "list_logic_type", "i" }, { "filt_logic_type", "i"},
6081                                 { "rssi_high_thres", "i" }, { "rssi_low_thres", "i"},
6082                                 { "dely_mode", "i" }, { "found_timeout", "i"},
6083                                 { "lost_timeout", "i" }, { "found_timeout_cnt", "i"}), NULL,
6084                         adapter_le_scan_filter_param_setup) },
6085         { GDBUS_ASYNC_METHOD("scan_filter_add_remove",
6086                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
6087                                 { "filt_type", "i" }, { "filt_index", "i"},
6088                                 { "company_id", "i" }, { "company_id_mask", "i"},
6089                                 { "p_uuid", "ay" }, { "p_uuid_mask", "ay" },
6090                                 { "string", "s" }, { "address_type", "u" },
6091                                 /*{ "data_len", "i" },*/ { "p_data", "ay" },
6092                                 /*{ "mask_len", "i" },*/ { "p_mask", "ay" }), NULL,
6093                         adapter_le_scan_filter_add_remove) },
6094         { GDBUS_ASYNC_METHOD("scan_filter_clear",
6095                         GDBUS_ARGS({ "client_if", "i" }, { "filt_index", "i" }), NULL,
6096                         adapter_le_scan_filter_clear) },
6097         { GDBUS_ASYNC_METHOD("scan_filter_enable",
6098                         GDBUS_ARGS({ "client_if", "i" }, { "enable", "b" }), NULL,
6099                         adapter_le_scan_filter_enable) },
6100         { GDBUS_METHOD("InitializeIpsp",
6101                         NULL, NULL,
6102                         adapter_initialize_ipsp) },
6103         { GDBUS_METHOD("DeinitializeIpsp",
6104                         NULL, NULL,
6105                         adapter_deinitialize_ipsp) },
6106         { GDBUS_METHOD("SetScanRespData",
6107                         GDBUS_ARGS({ "value", "ay" },
6108                                 { "slot_id", "i" }), NULL,
6109                         adapter_set_scan_rsp_data) },
6110         { GDBUS_METHOD("AddDeviceWhiteList",
6111                         GDBUS_ARGS({ "address", "s" },
6112                                 { "address_type", "u" }), NULL,
6113                         adapter_add_device_white_list) },
6114         { GDBUS_METHOD("RemoveDeviceWhiteList",
6115                         GDBUS_ARGS({ "address", "s" },
6116                                 { "address_type", "u" }), NULL,
6117                         adapter_remove_device_white_list) },
6118         { GDBUS_METHOD("ClearDeviceWhiteList",
6119                         NULL, NULL,
6120                         adapter_clear_device_white_list) },
6121         { GDBUS_METHOD("SetLePrivacy",
6122                         GDBUS_ARGS({ "enable", "b" }), NULL,
6123                         adapter_set_le_privacy) },
6124         { GDBUS_METHOD("SetLeStaticRandomAddress",
6125                         GDBUS_ARGS({ "enable", "b" }), NULL,
6126                         adapter_set_le_static_address) },
6127         { GDBUS_ASYNC_METHOD("EnableRssi",
6128                         GDBUS_ARGS({ "bt_address", "s" },
6129                                 { "link_type", "i" },
6130                                 { "low_th", "i" },
6131                                 { "in_range_th", "i" },
6132                                 { "high_th", "i"}),
6133                         NULL,
6134                         adapter_enable_rssi) },
6135         { GDBUS_ASYNC_METHOD("GetRssiStrength",
6136                         GDBUS_ARGS({ "bt_address", "s" }, { "link_type", "i" }),
6137                         NULL,
6138                         adapter_get_rssi) },
6139         { GDBUS_ASYNC_METHOD("UnpairDevice",
6140                         GDBUS_ARGS({ "device", "o" }), NULL, adapter_unpair_device) },
6141         { GDBUS_METHOD("FindDevice",
6142                         GDBUS_ARGS({ "address", "s" }),
6143                         GDBUS_ARGS({ "device", "o" }),
6144                         find_device) },
6145 #ifdef __TIZEN_PATCH__
6146 #ifdef __BROADCOM_PATCH__
6147         { GDBUS_METHOD("SetWbsParameters",
6148                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
6149                         NULL,
6150                         set_wbs_parameters) },
6151         { GDBUS_METHOD("SetNbParameters",
6152                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
6153                         NULL,
6154                         set_nb_parameters) },
6155 #endif
6156         { GDBUS_METHOD("SetManufacturerData",
6157                         GDBUS_ARGS({ "value", "ay" }), NULL,
6158                         adapter_set_manufacturer_data) },
6159 #endif
6160         { GDBUS_ASYNC_METHOD("CreateDevice",
6161                         GDBUS_ARGS({ "address", "s" }), NULL,
6162                         create_device) },
6163 #endif
6164         { GDBUS_ASYNC_METHOD("RemoveDevice",
6165                         GDBUS_ARGS({ "device", "o" }), NULL, remove_device) },
6166 #ifdef __TIZEN_PATCH__
6167         { GDBUS_ASYNC_METHOD("LEReadMaximumDataLength", NULL,
6168                         GDBUS_ARGS({"maxTxOctets", "q" }, { "maxTxTime", "q" },
6169                                 {"maxRxOctets", "q" }, { "maxRxTime", "q" }),
6170                         le_read_maximum_data_length)},
6171         { GDBUS_ASYNC_METHOD("LEWriteHostSuggestedDataLength",
6172                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }), NULL,
6173                         le_write_host_suggested_default_data_length)},
6174         { GDBUS_ASYNC_METHOD("LEReadHostSuggestedDataLength", NULL,
6175                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }),
6176                         le_read_host_suggested_default_data_length)},
6177 #endif
6178         { }
6179 };
6180
6181 #ifdef __TIZEN_PATCH__
6182 static const GDBusSignalTable adapter_signals[] = {
6183         { GDBUS_SIGNAL("AdvertisingEnabled",
6184                         GDBUS_ARGS({ "slot_id", "i" },
6185                                         { "enabled", "b"})) },
6186         { GDBUS_SIGNAL("RssiEnabled",
6187                         GDBUS_ARGS({"address","s"},
6188                                         { "link_type", "i" },
6189                                         { "enabled", "b"})) },
6190         { GDBUS_SIGNAL("RssiAlert",
6191                         GDBUS_ARGS({"address","s"},
6192                                         { "link_type", "i" },
6193                                         { "alert_type", "i" },
6194                                         { "rssi_dbm", "i"})) },
6195         { GDBUS_SIGNAL("RawRssi",
6196                         GDBUS_ARGS({"address","s"},
6197                                         { "link_type", "i" },
6198                                         { "rssi_dbm", "i"})) },
6199         { GDBUS_SIGNAL("HardwareError", NULL) },
6200         { GDBUS_SIGNAL("TxTimeoutError", NULL) },
6201         { }
6202 };
6203 #endif
6204
6205 static const GDBusPropertyTable adapter_properties[] = {
6206         { "Address", "s", property_get_address },
6207         { "Name", "s", property_get_name },
6208         { "Alias", "s", property_get_alias, property_set_alias },
6209         { "Class", "u", property_get_class },
6210         { "Powered", "b", property_get_powered, property_set_powered },
6211         { "Discoverable", "b", property_get_discoverable,
6212                                         property_set_discoverable },
6213         { "DiscoverableTimeout", "u", property_get_discoverable_timeout,
6214                                         property_set_discoverable_timeout },
6215         { "Pairable", "b", property_get_pairable, property_set_pairable },
6216         { "PairableTimeout", "u", property_get_pairable_timeout,
6217                                         property_set_pairable_timeout },
6218         { "Discovering", "b", property_get_discovering },
6219 #ifdef __TIZEN_PATCH__
6220         { "LEDiscovering", "b", property_get_le_discovering },
6221 #endif
6222         { "UUIDs", "as", property_get_uuids },
6223         { "Modalias", "s", property_get_modalias, NULL,
6224                                         property_exists_modalias },
6225 #ifdef __TIZEN_PATCH__
6226 #if 0 // Not used
6227         { "SecureConnection", "b", property_get_secure_connection },
6228 #endif
6229         { "Connectable", "b", property_get_connectable,
6230                                         property_set_connectable },
6231         { "Version", "s", property_get_version },
6232         { "SupportedLEFeatures", "as", property_get_supported_le_features},
6233         { "IpspInitStateChanged", "b", property_get_ipsp_init_state},
6234         { "LEAddress", "as", property_get_le_address },
6235 #endif
6236
6237         { }
6238 };
6239
6240 static int str2buf(const char *str, uint8_t *buf, size_t blen)
6241 {
6242         int i, dlen;
6243
6244         if (str == NULL)
6245                 return -EINVAL;
6246
6247         memset(buf, 0, blen);
6248
6249         dlen = MIN((strlen(str) / 2), blen);
6250
6251         for (i = 0; i < dlen; i++)
6252                 sscanf(str + (i * 2), "%02hhX", &buf[i]);
6253
6254         return 0;
6255 }
6256
6257 static struct link_key_info *get_key_info(GKeyFile *key_file, const char *peer)
6258 {
6259         struct link_key_info *info = NULL;
6260         char *str;
6261
6262         str = g_key_file_get_string(key_file, "LinkKey", "Key", NULL);
6263         if (!str || strlen(str) < 32)
6264                 goto failed;
6265
6266         info = g_new0(struct link_key_info, 1);
6267
6268         str2ba(peer, &info->bdaddr);
6269
6270         if (!strncmp(str, "0x", 2))
6271                 str2buf(&str[2], info->key, sizeof(info->key));
6272         else
6273                 str2buf(&str[0], info->key, sizeof(info->key));
6274
6275         info->type = g_key_file_get_integer(key_file, "LinkKey", "Type", NULL);
6276         info->pin_len = g_key_file_get_integer(key_file, "LinkKey", "PINLength",
6277                                                 NULL);
6278
6279 failed:
6280         g_free(str);
6281
6282         return info;
6283 }
6284
6285 static struct smp_ltk_info *get_ltk(GKeyFile *key_file, const char *peer,
6286                                         uint8_t peer_type, const char *group)
6287 {
6288         struct smp_ltk_info *ltk = NULL;
6289         GError *gerr = NULL;
6290         bool master;
6291         char *key;
6292         char *rand = NULL;
6293
6294         key = g_key_file_get_string(key_file, group, "Key", NULL);
6295         if (!key || strlen(key) < 32)
6296                 goto failed;
6297
6298         rand = g_key_file_get_string(key_file, group, "Rand", NULL);
6299         if (!rand)
6300                 goto failed;
6301
6302         ltk = g_new0(struct smp_ltk_info, 1);
6303
6304         /* Default to assuming a master key */
6305         ltk->master = true;
6306
6307         str2ba(peer, &ltk->bdaddr);
6308         ltk->bdaddr_type = peer_type;
6309
6310         /*
6311          * Long term keys should respond to an identity address which can
6312          * either be a public address or a random static address. Keys
6313          * stored for resolvable random and unresolvable random addresses
6314          * are ignored.
6315          *
6316          * This is an extra sanity check for older kernel versions or older
6317          * daemons that might have been instructed to store long term keys
6318          * for these temporary addresses.
6319          */
6320         if (ltk->bdaddr_type == BDADDR_LE_RANDOM &&
6321                                         (ltk->bdaddr.b[5] & 0xc0) != 0xc0) {
6322                 g_free(ltk);
6323                 ltk = NULL;
6324                 goto failed;
6325         }
6326
6327         if (!strncmp(key, "0x", 2))
6328                 str2buf(&key[2], ltk->val, sizeof(ltk->val));
6329         else
6330                 str2buf(&key[0], ltk->val, sizeof(ltk->val));
6331
6332         if (!strncmp(rand, "0x", 2)) {
6333                 uint64_t rand_le;
6334                 str2buf(&rand[2], (uint8_t *) &rand_le, sizeof(rand_le));
6335                 ltk->rand = le64_to_cpu(rand_le);
6336         } else {
6337                 sscanf(rand, "%" PRIu64, &ltk->rand);
6338         }
6339
6340         ltk->authenticated = g_key_file_get_integer(key_file, group,
6341                                                         "Authenticated", NULL);
6342         ltk->enc_size = g_key_file_get_integer(key_file, group, "EncSize",
6343                                                                         NULL);
6344         ltk->ediv = g_key_file_get_integer(key_file, group, "EDiv", NULL);
6345
6346         master = g_key_file_get_boolean(key_file, group, "Master", &gerr);
6347         if (gerr)
6348                 g_error_free(gerr);
6349         else
6350                 ltk->master = master;
6351
6352 failed:
6353         g_free(key);
6354         g_free(rand);
6355
6356         return ltk;
6357 }
6358
6359 static GSList *get_ltk_info(GKeyFile *key_file, const char *peer,
6360                                                         uint8_t bdaddr_type)
6361 {
6362         struct smp_ltk_info *ltk;
6363         GSList *l = NULL;
6364
6365         DBG("%s", peer);
6366
6367         ltk = get_ltk(key_file, peer, bdaddr_type, "LongTermKey");
6368         if (ltk)
6369                 l = g_slist_append(l, ltk);
6370
6371         ltk = get_ltk(key_file, peer, bdaddr_type, "SlaveLongTermKey");
6372         if (ltk) {
6373                 ltk->master = false;
6374                 l = g_slist_append(l, ltk);
6375         }
6376
6377         return l;
6378 }
6379
6380 static struct irk_info *get_irk_info(GKeyFile *key_file, const char *peer,
6381                                                         uint8_t bdaddr_type)
6382 {
6383         struct irk_info *irk;
6384         char *str;
6385
6386         str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
6387 #ifdef __TIZEN_PATCH__
6388         if (!str)
6389                 return NULL;
6390         if (strlen(str) < 32) {
6391                 g_free(str);
6392                 return NULL;
6393         }
6394 #else
6395         if (!str || strlen(str) < 32)
6396                 return NULL;
6397 #endif
6398         irk = g_new0(struct irk_info, 1);
6399
6400         str2ba(peer, &irk->bdaddr);
6401         irk->bdaddr_type = bdaddr_type;
6402
6403         if (!strncmp(str, "0x", 2))
6404                 str2buf(&str[2], irk->val, sizeof(irk->val));
6405         else
6406                 str2buf(&str[0], irk->val, sizeof(irk->val));
6407
6408         g_free(str);
6409
6410         return irk;
6411 }
6412
6413 static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
6414                                                         uint8_t bdaddr_type)
6415 {
6416         struct conn_param *param;
6417
6418         if (!g_key_file_has_group(key_file, "ConnectionParameters"))
6419                 return NULL;
6420
6421         param = g_new0(struct conn_param, 1);
6422
6423         param->min_interval = g_key_file_get_integer(key_file,
6424                                                         "ConnectionParameters",
6425                                                         "MinInterval", NULL);
6426         param->max_interval = g_key_file_get_integer(key_file,
6427                                                         "ConnectionParameters",
6428                                                         "MaxInterval", NULL);
6429         param->latency = g_key_file_get_integer(key_file,
6430                                                         "ConnectionParameters",
6431                                                         "Latency", NULL);
6432         param->timeout = g_key_file_get_integer(key_file,
6433                                                         "ConnectionParameters",
6434                                                         "Timeout", NULL);
6435         str2ba(peer, &param->bdaddr);
6436         param->bdaddr_type = bdaddr_type;
6437
6438         return param;
6439 }
6440
6441 static void load_link_keys_complete(uint8_t status, uint16_t length,
6442                                         const void *param, void *user_data)
6443 {
6444         struct btd_adapter *adapter = user_data;
6445
6446         if (status != MGMT_STATUS_SUCCESS) {
6447                 btd_error(adapter->dev_id,
6448                         "Failed to load link keys for hci%u: %s (0x%02x)",
6449                                 adapter->dev_id, mgmt_errstr(status), status);
6450                 return;
6451         }
6452
6453         DBG("link keys loaded for hci%u", adapter->dev_id);
6454 }
6455
6456 static void load_link_keys(struct btd_adapter *adapter, GSList *keys,
6457                                                         bool debug_keys)
6458 {
6459         struct mgmt_cp_load_link_keys *cp;
6460         struct mgmt_link_key_info *key;
6461         size_t key_count, cp_size;
6462         unsigned int id;
6463         GSList *l;
6464
6465         /*
6466          * If the controller does not support BR/EDR operation,
6467          * there is no point in trying to load the link keys into
6468          * the kernel.
6469          *
6470          * This is an optimization for Low Energy only controllers.
6471          */
6472         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
6473                 return;
6474
6475         key_count = g_slist_length(keys);
6476
6477         DBG("hci%u keys %zu debug_keys %d", adapter->dev_id, key_count,
6478                                                                 debug_keys);
6479
6480         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
6481
6482         cp = g_try_malloc0(cp_size);
6483         if (cp == NULL) {
6484                 btd_error(adapter->dev_id, "No memory for link keys for hci%u",
6485                                                         adapter->dev_id);
6486                 return;
6487         }
6488
6489         /*
6490          * Even if the list of stored keys is empty, it is important to
6491          * load an empty list into the kernel. That way it is ensured
6492          * that no old keys from a previous daemon are present.
6493          *
6494          * In addition it is also the only way to toggle the different
6495          * behavior for debug keys.
6496          */
6497         cp->debug_keys = debug_keys;
6498         cp->key_count = htobs(key_count);
6499
6500         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
6501                 struct link_key_info *info = l->data;
6502
6503                 bacpy(&key->addr.bdaddr, &info->bdaddr);
6504                 key->addr.type = BDADDR_BREDR;
6505                 key->type = info->type;
6506                 memcpy(key->val, info->key, 16);
6507                 key->pin_len = info->pin_len;
6508         }
6509
6510         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_LINK_KEYS,
6511                                 adapter->dev_id, cp_size, cp,
6512                                 load_link_keys_complete, adapter, NULL);
6513
6514         g_free(cp);
6515
6516         if (id == 0)
6517                 btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
6518                                                         adapter->dev_id);
6519 }
6520
6521 static gboolean load_ltks_timeout(gpointer user_data)
6522 {
6523         struct btd_adapter *adapter = user_data;
6524
6525         btd_error(adapter->dev_id, "Loading LTKs timed out for hci%u",
6526                                                         adapter->dev_id);
6527
6528         adapter->load_ltks_timeout = 0;
6529
6530         mgmt_cancel(adapter->mgmt, adapter->load_ltks_id);
6531         adapter->load_ltks_id = 0;
6532
6533         return FALSE;
6534 }
6535
6536 static void load_ltks_complete(uint8_t status, uint16_t length,
6537                                         const void *param, void *user_data)
6538 {
6539         struct btd_adapter *adapter = user_data;
6540
6541         if (status != MGMT_STATUS_SUCCESS) {
6542                 btd_error(adapter->dev_id,
6543                                 "Failed to load LTKs for hci%u: %s (0x%02x)",
6544                                 adapter->dev_id, mgmt_errstr(status), status);
6545         }
6546
6547         adapter->load_ltks_id = 0;
6548
6549         g_source_remove(adapter->load_ltks_timeout);
6550         adapter->load_ltks_timeout = 0;
6551
6552         DBG("LTKs loaded for hci%u", adapter->dev_id);
6553 }
6554
6555 static void load_ltks(struct btd_adapter *adapter, GSList *keys)
6556 {
6557         struct mgmt_cp_load_long_term_keys *cp;
6558         struct mgmt_ltk_info *key;
6559         size_t key_count, cp_size;
6560         GSList *l;
6561
6562         /*
6563          * If the controller does not support Low Energy operation,
6564          * there is no point in trying to load the long term keys
6565          * into the kernel.
6566          *
6567          * While there is no harm in loading keys into the kernel,
6568          * this is an optimization to avoid a confusing warning
6569          * message when the loading of the keys timed out due to
6570          * a kernel bug (see comment below).
6571          */
6572         if (!(adapter->supported_settings & MGMT_SETTING_LE))
6573                 return;
6574
6575         key_count = g_slist_length(keys);
6576
6577         DBG("hci%u keys %zu", adapter->dev_id, key_count);
6578
6579         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
6580
6581         cp = g_try_malloc0(cp_size);
6582         if (cp == NULL) {
6583                 btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
6584                                                         adapter->dev_id);
6585                 return;
6586         }
6587
6588         /*
6589          * Even if the list of stored keys is empty, it is important to
6590          * load an empty list into the kernel. That way it is ensured
6591          * that no old keys from a previous daemon are present.
6592          */
6593         cp->key_count = htobs(key_count);
6594
6595         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
6596                 struct smp_ltk_info *info = l->data;
6597
6598                 bacpy(&key->addr.bdaddr, &info->bdaddr);
6599                 key->addr.type = info->bdaddr_type;
6600                 memcpy(key->val, info->val, sizeof(info->val));
6601                 key->rand = cpu_to_le64(info->rand);
6602                 key->ediv = cpu_to_le16(info->ediv);
6603                 key->type = info->authenticated;
6604                 key->master = info->master;
6605                 key->enc_size = info->enc_size;
6606         }
6607
6608         adapter->load_ltks_id = mgmt_send(adapter->mgmt,
6609                                         MGMT_OP_LOAD_LONG_TERM_KEYS,
6610                                         adapter->dev_id, cp_size, cp,
6611                                         load_ltks_complete, adapter, NULL);
6612
6613         g_free(cp);
6614
6615         if (adapter->load_ltks_id == 0) {
6616                 btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
6617                                                         adapter->dev_id);
6618                 return;
6619         }
6620
6621         /*
6622          * This timeout handling is needed since the kernel is stupid
6623          * and forgets to send a command complete response. However in
6624          * case of failures it does send a command status.
6625          */
6626         adapter->load_ltks_timeout = g_timeout_add_seconds(2,
6627                                                 load_ltks_timeout, adapter);
6628 }
6629
6630 static void load_irks_complete(uint8_t status, uint16_t length,
6631                                         const void *param, void *user_data)
6632 {
6633         struct btd_adapter *adapter = user_data;
6634
6635         if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
6636                 btd_info(adapter->dev_id,
6637                         "Load IRKs failed: Kernel doesn't support LE Privacy");
6638                 return;
6639         }
6640
6641         if (status != MGMT_STATUS_SUCCESS) {
6642                 btd_error(adapter->dev_id,
6643                                 "Failed to load IRKs for hci%u: %s (0x%02x)",
6644                                 adapter->dev_id, mgmt_errstr(status), status);
6645                 return;
6646         }
6647
6648         DBG("IRKs loaded for hci%u", adapter->dev_id);
6649 }
6650
6651 #ifdef __TIZEN_PATCH__
6652 static void load_devices_rpa_res_support(struct btd_adapter *adapter)
6653 {
6654         GSList *l;
6655
6656         DBG("%s", adapter->path);
6657
6658         for (l = adapter->devices; l; l = l->next) {
6659                 struct btd_device *device = l->data;
6660
6661                 btd_adapter_set_dev_rpa_res_support(adapter, device);
6662         }
6663 }
6664 #endif
6665
6666 static void load_irks(struct btd_adapter *adapter, GSList *irks)
6667 {
6668         struct mgmt_cp_load_irks *cp;
6669         struct mgmt_irk_info *irk;
6670         size_t irk_count, cp_size;
6671         unsigned int id;
6672         GSList *l;
6673
6674         /*
6675          * If the controller does not support LE Privacy operation,
6676          * there is no support for loading identity resolving keys
6677          * into the kernel.
6678          */
6679         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
6680                 return;
6681
6682         irk_count = g_slist_length(irks);
6683
6684         DBG("hci%u irks %zu", adapter->dev_id, irk_count);
6685
6686         cp_size = sizeof(*cp) + (irk_count * sizeof(*irk));
6687
6688         cp = g_try_malloc0(cp_size);
6689         if (cp == NULL) {
6690                 btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
6691                                                         adapter->dev_id);
6692                 return;
6693         }
6694
6695         /*
6696          * Even if the list of stored keys is empty, it is important to
6697          * load an empty list into the kernel. That way we tell the
6698          * kernel that we are able to handle New IRK events.
6699          */
6700         cp->irk_count = htobs(irk_count);
6701
6702         for (l = irks, irk = cp->irks; l != NULL; l = g_slist_next(l), irk++) {
6703                 struct irk_info *info = l->data;
6704
6705                 bacpy(&irk->addr.bdaddr, &info->bdaddr);
6706                 irk->addr.type = info->bdaddr_type;
6707                 memcpy(irk->val, info->val, sizeof(irk->val));
6708         }
6709
6710         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_IRKS, adapter->dev_id,
6711                         cp_size, cp, load_irks_complete, adapter, NULL);
6712
6713         g_free(cp);
6714
6715         if (id == 0)
6716                 btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
6717                                                         adapter->dev_id);
6718 }
6719
6720 static void load_conn_params_complete(uint8_t status, uint16_t length,
6721                                         const void *param, void *user_data)
6722 {
6723         struct btd_adapter *adapter = user_data;
6724
6725         if (status != MGMT_STATUS_SUCCESS) {
6726                 btd_error(adapter->dev_id,
6727                         "hci%u Load Connection Parameters failed: %s (0x%02x)",
6728                                 adapter->dev_id, mgmt_errstr(status), status);
6729                 return;
6730         }
6731
6732         DBG("Connection Parameters loaded for hci%u", adapter->dev_id);
6733 }
6734
6735 static void load_conn_params(struct btd_adapter *adapter, GSList *params)
6736 {
6737         struct mgmt_cp_load_conn_param *cp;
6738         struct mgmt_conn_param *param;
6739         size_t param_count, cp_size;
6740         unsigned int id;
6741         GSList *l;
6742
6743         /*
6744          * If the controller does not support Low Energy operation,
6745          * there is no point in trying to load the connection
6746          * parameters into the kernel.
6747          */
6748         if (!(adapter->supported_settings & MGMT_SETTING_LE))
6749                 return;
6750
6751         param_count = g_slist_length(params);
6752
6753         DBG("hci%u conn params %zu", adapter->dev_id, param_count);
6754
6755         cp_size = sizeof(*cp) + (param_count * sizeof(*param));
6756
6757         cp = g_try_malloc0(cp_size);
6758         if (cp == NULL) {
6759                 btd_error(adapter->dev_id,
6760                         "Failed to allocate memory for connection parameters");
6761                 return;
6762         }
6763
6764         cp->param_count = htobs(param_count);
6765
6766         for (l = params, param = cp->params; l; l = g_slist_next(l), param++) {
6767                 struct conn_param *info = l->data;
6768
6769                 bacpy(&param->addr.bdaddr, &info->bdaddr);
6770                 param->addr.type = info->bdaddr_type;
6771                 param->min_interval = htobs(info->min_interval);
6772                 param->max_interval = htobs(info->max_interval);
6773                 param->latency = htobs(info->latency);
6774                 param->timeout = htobs(info->timeout);
6775         }
6776
6777         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_PARAM, adapter->dev_id,
6778                         cp_size, cp, load_conn_params_complete, adapter, NULL);
6779
6780         g_free(cp);
6781
6782         if (id == 0)
6783                 btd_error(adapter->dev_id, "Load connection parameters failed");
6784 }
6785
6786 static uint8_t get_le_addr_type(GKeyFile *keyfile)
6787 {
6788         uint8_t addr_type;
6789         char *type;
6790
6791         type = g_key_file_get_string(keyfile, "General", "AddressType", NULL);
6792         if (!type)
6793                 return BDADDR_LE_PUBLIC;
6794
6795         if (g_str_equal(type, "public"))
6796                 addr_type = BDADDR_LE_PUBLIC;
6797         else if (g_str_equal(type, "static"))
6798                 addr_type = BDADDR_LE_RANDOM;
6799         else
6800                 addr_type = BDADDR_LE_PUBLIC;
6801
6802         g_free(type);
6803
6804         return addr_type;
6805 }
6806
6807 static void probe_devices(void *user_data)
6808 {
6809         struct btd_device *device = user_data;
6810
6811         device_probe_profiles(device, btd_device_get_uuids(device));
6812 }
6813
6814 static void load_devices(struct btd_adapter *adapter)
6815 {
6816         char dirname[PATH_MAX];
6817         char srcaddr[18];
6818         GSList *keys = NULL;
6819         GSList *ltks = NULL;
6820         GSList *irks = NULL;
6821         GSList *params = NULL;
6822         GSList *added_devices = NULL;
6823         DIR *dir;
6824         struct dirent *entry;
6825
6826         ba2str(&adapter->bdaddr, srcaddr);
6827
6828         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", srcaddr);
6829
6830         dir = opendir(dirname);
6831         if (!dir) {
6832                 btd_error(adapter->dev_id,
6833                                 "Unable to open adapter storage directory: %s",
6834                                                                 dirname);
6835                 return;
6836         }
6837
6838         while ((entry = readdir(dir)) != NULL) {
6839                 struct btd_device *device;
6840                 char filename[PATH_MAX];
6841                 GKeyFile *key_file;
6842 #ifdef __TIZEN_PATCH__
6843                 struct link_key_info *key_info = NULL;
6844                 GSList *list, *ltk_info = NULL;
6845 #else
6846                 struct link_key_info *key_info;
6847                 GSList *list, *ltk_info;
6848 #endif
6849                 struct irk_info *irk_info;
6850                 struct conn_param *param;
6851                 uint8_t bdaddr_type;
6852
6853                 if (entry->d_type == DT_UNKNOWN)
6854                         entry->d_type = util_get_dt(dirname, entry->d_name);
6855
6856                 if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
6857                         continue;
6858
6859 #ifdef __TIZEN_PATCH__
6860 {
6861                 bdaddr_t bdaddr;
6862
6863                 str2ba(entry->d_name, &bdaddr);
6864
6865                 if (!bacmp(&bdaddr, BDADDR_ANY)) {
6866                         error("No Bluetooth address");
6867                         continue;
6868                 }
6869 }
6870 #endif
6871                 snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", srcaddr,
6872                                 entry->d_name);
6873
6874                 key_file = g_key_file_new();
6875                 g_key_file_load_from_file(key_file, filename, 0, NULL);
6876
6877                 key_info = get_key_info(key_file, entry->d_name);
6878                 if (key_info)
6879                         keys = g_slist_append(keys, key_info);
6880
6881                 bdaddr_type = get_le_addr_type(key_file);
6882
6883                 ltk_info = get_ltk_info(key_file, entry->d_name, bdaddr_type);
6884                 ltks = g_slist_concat(ltks, ltk_info);
6885
6886                 irk_info = get_irk_info(key_file, entry->d_name, bdaddr_type);
6887                 if (irk_info)
6888                         irks = g_slist_append(irks, irk_info);
6889
6890                 param = get_conn_param(key_file, entry->d_name, bdaddr_type);
6891                 if (param)
6892                         params = g_slist_append(params, param);
6893
6894                 list = g_slist_find_custom(adapter->devices, entry->d_name,
6895                                                         device_address_cmp);
6896                 if (list) {
6897                         device = list->data;
6898                         goto device_exist;
6899                 }
6900
6901                 device = device_create_from_storage(adapter, entry->d_name,
6902                                                         key_file);
6903                 if (!device)
6904                         goto free;
6905
6906 #ifdef __TIZEN_PATCH__
6907 {
6908                 char irk_addr[18];
6909
6910                 /* After load IRK information from file, store it into device->bdaddr
6911                     RPA is stored in device->rpa_addr */
6912                 ba2str(device_get_address(device), irk_addr);
6913
6914                 DBG("irk address: %s, rpa_exist %d", irk_addr, device_get_rpa_exist(device));
6915
6916                 if (device_get_rpa_exist(device) == true) {
6917                         if (key_info)
6918                                 str2ba(irk_addr, &key_info->bdaddr);
6919
6920                         if (ltk_info) {
6921                                 ltks = g_slist_remove(ltks, ltk_info);
6922                                 ltk_info = get_ltk_info(key_file, irk_addr, bdaddr_type);
6923                                 ltks = g_slist_concat(ltks, ltk_info);
6924                         }
6925
6926                         if (irk_info) {
6927                                 str2ba(irk_addr, &irk_info->bdaddr);
6928                                 device_set_irk_value(device, irk_info->val);
6929                         }
6930
6931                         if (param)
6932                                 str2ba(irk_addr, &param->bdaddr);
6933                 }
6934 }
6935 #endif
6936
6937                 btd_device_set_temporary(device, false);
6938                 adapter->devices = g_slist_append(adapter->devices, device);
6939
6940                 /* TODO: register services from pre-loaded list of primaries */
6941
6942                 added_devices = g_slist_append(added_devices, device);
6943
6944 device_exist:
6945                 if (key_info) {
6946                         device_set_paired(device, BDADDR_BREDR);
6947                         device_set_bonded(device, BDADDR_BREDR);
6948                 }
6949
6950                 if (ltk_info) {
6951                         device_set_paired(device, bdaddr_type);
6952                         device_set_bonded(device, bdaddr_type);
6953                 }
6954
6955 free:
6956                 g_key_file_free(key_file);
6957         }
6958
6959         closedir(dir);
6960
6961         load_link_keys(adapter, keys, main_opts.debug_keys);
6962         g_slist_free_full(keys, g_free);
6963
6964         load_ltks(adapter, ltks);
6965         g_slist_free_full(ltks, g_free);
6966         load_irks(adapter, irks);
6967         g_slist_free_full(irks, g_free);
6968         load_conn_params(adapter, params);
6969         g_slist_free_full(params, g_free);
6970
6971         g_slist_free_full(added_devices, probe_devices);
6972
6973 #ifdef __TIZEN_PATCH__
6974         load_devices_rpa_res_support(adapter);
6975 #endif
6976 }
6977
6978 int btd_adapter_block_address(struct btd_adapter *adapter,
6979                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
6980 {
6981         struct mgmt_cp_block_device cp;
6982         char addr[18];
6983
6984         ba2str(bdaddr, addr);
6985         DBG("hci%u %s", adapter->dev_id, addr);
6986
6987         memset(&cp, 0, sizeof(cp));
6988         bacpy(&cp.addr.bdaddr, bdaddr);
6989         cp.addr.type = bdaddr_type;
6990
6991         if (mgmt_send(adapter->mgmt, MGMT_OP_BLOCK_DEVICE,
6992                                 adapter->dev_id, sizeof(cp), &cp,
6993                                 NULL, NULL, NULL) > 0)
6994                 return 0;
6995
6996         return -EIO;
6997 }
6998
6999 int btd_adapter_unblock_address(struct btd_adapter *adapter,
7000                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
7001 {
7002         struct mgmt_cp_unblock_device cp;
7003         char addr[18];
7004
7005         ba2str(bdaddr, addr);
7006         DBG("hci%u %s", adapter->dev_id, addr);
7007
7008         memset(&cp, 0, sizeof(cp));
7009         bacpy(&cp.addr.bdaddr, bdaddr);
7010         cp.addr.type = bdaddr_type;
7011
7012         if (mgmt_send(adapter->mgmt, MGMT_OP_UNBLOCK_DEVICE,
7013                                 adapter->dev_id, sizeof(cp), &cp,
7014                                 NULL, NULL, NULL) > 0)
7015                 return 0;
7016
7017         return -EIO;
7018 }
7019
7020 static int clear_blocked(struct btd_adapter *adapter)
7021 {
7022         return btd_adapter_unblock_address(adapter, BDADDR_ANY, 0);
7023 }
7024
7025 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
7026 {
7027         struct btd_adapter_driver *driver = user_data;
7028         int err;
7029
7030         if (driver->probe == NULL)
7031                 return;
7032
7033         err = driver->probe(adapter);
7034         if (err < 0) {
7035                 btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
7036                                                         strerror(-err), -err);
7037                 return;
7038         }
7039
7040         adapter->drivers = g_slist_prepend(adapter->drivers, driver);
7041 }
7042
7043 static void load_drivers(struct btd_adapter *adapter)
7044 {
7045         GSList *l;
7046
7047         for (l = adapter_drivers; l; l = l->next)
7048                 probe_driver(adapter, l->data);
7049 }
7050
7051 static void probe_profile(struct btd_profile *profile, void *data)
7052 {
7053         struct btd_adapter *adapter = data;
7054         int err;
7055
7056         if (profile->adapter_probe == NULL)
7057                 return;
7058
7059         err = profile->adapter_probe(profile, adapter);
7060         if (err < 0) {
7061                 btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
7062                                                         strerror(-err), -err);
7063                 return;
7064         }
7065
7066         adapter->profiles = g_slist_prepend(adapter->profiles, profile);
7067 }
7068
7069 void adapter_add_profile(struct btd_adapter *adapter, gpointer p)
7070 {
7071         struct btd_profile *profile = p;
7072
7073         if (!adapter->initialized)
7074                 return;
7075
7076         probe_profile(profile, adapter);
7077
7078         g_slist_foreach(adapter->devices, device_probe_profile, profile);
7079 }
7080
7081 void adapter_remove_profile(struct btd_adapter *adapter, gpointer p)
7082 {
7083         struct btd_profile *profile = p;
7084
7085         if (!adapter->initialized)
7086                 return;
7087
7088         if (profile->device_remove)
7089                 g_slist_foreach(adapter->devices, device_remove_profile, p);
7090
7091         adapter->profiles = g_slist_remove(adapter->profiles, profile);
7092
7093         if (profile->adapter_remove)
7094                 profile->adapter_remove(profile, adapter);
7095 }
7096
7097 static void adapter_add_connection(struct btd_adapter *adapter,
7098                                                 struct btd_device *device,
7099                                                 uint8_t bdaddr_type)
7100 {
7101         device_add_connection(device, bdaddr_type);
7102
7103         if (g_slist_find(adapter->connections, device)) {
7104                 btd_error(adapter->dev_id,
7105                                 "Device is already marked as connected");
7106                 return;
7107         }
7108
7109         adapter->connections = g_slist_append(adapter->connections, device);
7110 }
7111
7112 static void get_connections_complete(uint8_t status, uint16_t length,
7113                                         const void *param, void *user_data)
7114 {
7115         struct btd_adapter *adapter = user_data;
7116         const struct mgmt_rp_get_connections *rp = param;
7117         uint16_t i, conn_count;
7118
7119         if (status != MGMT_STATUS_SUCCESS) {
7120                 btd_error(adapter->dev_id,
7121                                 "Failed to get connections: %s (0x%02x)",
7122                                                 mgmt_errstr(status), status);
7123                 return;
7124         }
7125
7126         if (length < sizeof(*rp)) {
7127                 btd_error(adapter->dev_id,
7128                                 "Wrong size of get connections response");
7129                 return;
7130         }
7131
7132         conn_count = btohs(rp->conn_count);
7133
7134         DBG("Connection count: %d", conn_count);
7135
7136         if (conn_count * sizeof(struct mgmt_addr_info) +
7137                                                 sizeof(*rp) != length) {
7138                 btd_error(adapter->dev_id,
7139                         "Incorrect packet size for get connections response");
7140                 return;
7141         }
7142
7143         for (i = 0; i < conn_count; i++) {
7144                 const struct mgmt_addr_info *addr = &rp->addr[i];
7145                 struct btd_device *device;
7146                 char address[18];
7147
7148                 ba2str(&addr->bdaddr, address);
7149                 DBG("Adding existing connection to %s", address);
7150
7151                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
7152                                                                 addr->type);
7153                 if (device)
7154                         adapter_add_connection(adapter, device, addr->type);
7155         }
7156 }
7157
7158 static void load_connections(struct btd_adapter *adapter)
7159 {
7160         DBG("sending get connections command for index %u", adapter->dev_id);
7161
7162         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_CONNECTIONS,
7163                                 adapter->dev_id, 0, NULL,
7164                                 get_connections_complete, adapter, NULL) > 0)
7165                 return;
7166
7167         btd_error(adapter->dev_id, "Failed to get connections for index %u",
7168                                                         adapter->dev_id);
7169 }
7170
7171 bool btd_adapter_get_pairable(struct btd_adapter *adapter)
7172 {
7173         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
7174                 return true;
7175
7176         return false;
7177 }
7178
7179 bool btd_adapter_get_powered(struct btd_adapter *adapter)
7180 {
7181         if (adapter->current_settings & MGMT_SETTING_POWERED)
7182                 return true;
7183
7184         return false;
7185 }
7186
7187 bool btd_adapter_get_connectable(struct btd_adapter *adapter)
7188 {
7189         if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
7190                 return true;
7191
7192         return false;
7193 }
7194
7195 struct btd_gatt_database *btd_adapter_get_database(struct btd_adapter *adapter)
7196 {
7197         if (!adapter)
7198                 return NULL;
7199
7200         return adapter->database;
7201 }
7202
7203 uint32_t btd_adapter_get_class(struct btd_adapter *adapter)
7204 {
7205         return adapter->dev_class;
7206 }
7207
7208 const char *btd_adapter_get_name(struct btd_adapter *adapter)
7209 {
7210         if (adapter->stored_alias)
7211                 return adapter->stored_alias;
7212
7213         if (adapter->system_name)
7214                 return adapter->system_name;
7215
7216         return NULL;
7217 }
7218
7219 int adapter_connect_list_add(struct btd_adapter *adapter,
7220                                         struct btd_device *device)
7221 {
7222         /*
7223          * If the adapter->connect_le device is getting added back to
7224          * the connect list it probably means that the connect attempt
7225          * failed and hence we should clear this pointer
7226          */
7227         if (device == adapter->connect_le)
7228                 adapter->connect_le = NULL;
7229
7230         /*
7231          * If kernel background scanning is supported then the
7232          * adapter_auto_connect_add() function is used to maintain what to
7233          * connect.
7234          */
7235         if (kernel_conn_control)
7236                 return 0;
7237
7238         if (g_slist_find(adapter->connect_list, device)) {
7239                 DBG("ignoring already added device %s",
7240                                                 device_get_path(device));
7241                 goto done;
7242         }
7243
7244         if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
7245                 btd_error(adapter->dev_id,
7246                         "Can't add %s to non-LE capable adapter connect list",
7247                                                 device_get_path(device));
7248                 return -ENOTSUP;
7249         }
7250
7251         adapter->connect_list = g_slist_append(adapter->connect_list, device);
7252         DBG("%s added to %s's connect_list", device_get_path(device),
7253                                                         adapter->system_name);
7254
7255 done:
7256         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7257                 return 0;
7258
7259         trigger_passive_scanning(adapter);
7260
7261         return 0;
7262 }
7263
7264 void adapter_connect_list_remove(struct btd_adapter *adapter,
7265                                         struct btd_device *device)
7266 {
7267         /*
7268          * If the adapter->connect_le device is being removed from the
7269          * connect list it means the connection was successful and hence
7270          * the pointer should be cleared
7271          */
7272         if (device == adapter->connect_le)
7273                 adapter->connect_le = NULL;
7274
7275         if (kernel_conn_control)
7276                 return;
7277
7278         if (!g_slist_find(adapter->connect_list, device)) {
7279                 DBG("device %s is not on the list, ignoring",
7280                                                 device_get_path(device));
7281                 return;
7282         }
7283
7284         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
7285         DBG("%s removed from %s's connect_list", device_get_path(device),
7286                                                         adapter->system_name);
7287
7288         if (!adapter->connect_list) {
7289                 stop_passive_scanning(adapter);
7290                 return;
7291         }
7292
7293         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7294                 return;
7295
7296         trigger_passive_scanning(adapter);
7297 }
7298
7299 static void add_whitelist_complete(uint8_t status, uint16_t length,
7300                                         const void *param, void *user_data)
7301 {
7302         const struct mgmt_rp_add_device *rp = param;
7303         struct btd_adapter *adapter = user_data;
7304         struct btd_device *dev;
7305         char addr[18];
7306
7307         if (length < sizeof(*rp)) {
7308                 btd_error(adapter->dev_id,
7309                                 "Too small Add Device complete event");
7310                 return;
7311         }
7312
7313         ba2str(&rp->addr.bdaddr, addr);
7314
7315         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
7316                                                         rp->addr.type);
7317         if (!dev) {
7318                 btd_error(adapter->dev_id,
7319                         "Add Device complete for unknown device %s", addr);
7320                 return;
7321         }
7322
7323         if (status != MGMT_STATUS_SUCCESS) {
7324                 btd_error(adapter->dev_id,
7325                                         "Failed to add device %s: %s (0x%02x)",
7326                                         addr, mgmt_errstr(status), status);
7327                 return;
7328         }
7329
7330         DBG("%s added to kernel whitelist", addr);
7331 }
7332
7333 void adapter_whitelist_add(struct btd_adapter *adapter, struct btd_device *dev)
7334 {
7335         struct mgmt_cp_add_device cp;
7336
7337         if (!kernel_conn_control)
7338                 return;
7339
7340         memset(&cp, 0, sizeof(cp));
7341         bacpy(&cp.addr.bdaddr, device_get_address(dev));
7342         cp.addr.type = BDADDR_BREDR;
7343         cp.action = 0x01;
7344
7345         mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
7346                                 adapter->dev_id, sizeof(cp), &cp,
7347                                 add_whitelist_complete, adapter, NULL);
7348 }
7349
7350 static void remove_whitelist_complete(uint8_t status, uint16_t length,
7351                                         const void *param, void *user_data)
7352 {
7353         const struct mgmt_rp_remove_device *rp = param;
7354         char addr[18];
7355
7356         if (length < sizeof(*rp)) {
7357                 error("Too small Remove Device complete event");
7358                 return;
7359         }
7360
7361         ba2str(&rp->addr.bdaddr, addr);
7362
7363         if (status != MGMT_STATUS_SUCCESS) {
7364                 error("Failed to remove device %s: %s (0x%02x)",
7365                                         addr, mgmt_errstr(status), status);
7366                 return;
7367         }
7368
7369         DBG("%s removed from kernel whitelist", addr);
7370 }
7371
7372 void adapter_whitelist_remove(struct btd_adapter *adapter, struct btd_device *dev)
7373 {
7374         struct mgmt_cp_remove_device cp;
7375
7376         if (!kernel_conn_control)
7377                 return;
7378
7379         memset(&cp, 0, sizeof(cp));
7380         bacpy(&cp.addr.bdaddr, device_get_address(dev));
7381         cp.addr.type = BDADDR_BREDR;
7382
7383         mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
7384                                 adapter->dev_id, sizeof(cp), &cp,
7385                                 remove_whitelist_complete, adapter, NULL);
7386 }
7387
7388 static void add_device_complete(uint8_t status, uint16_t length,
7389                                         const void *param, void *user_data)
7390 {
7391         const struct mgmt_rp_add_device *rp = param;
7392         struct btd_adapter *adapter = user_data;
7393         struct btd_device *dev;
7394         char addr[18];
7395
7396         if (length < sizeof(*rp)) {
7397                 btd_error(adapter->dev_id,
7398                                 "Too small Add Device complete event");
7399                 return;
7400         }
7401
7402         ba2str(&rp->addr.bdaddr, addr);
7403
7404         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
7405                                                         rp->addr.type);
7406         if (!dev) {
7407                 btd_error(adapter->dev_id,
7408                         "Add Device complete for unknown device %s", addr);
7409                 return;
7410         }
7411
7412         if (status != MGMT_STATUS_SUCCESS) {
7413                 btd_error(adapter->dev_id,
7414                         "Failed to add device %s (%u): %s (0x%02x)",
7415                         addr, rp->addr.type, mgmt_errstr(status), status);
7416                 adapter->connect_list = g_slist_remove(adapter->connect_list,
7417                                                                         dev);
7418                 return;
7419         }
7420
7421         DBG("%s (%u) added to kernel connect list", addr, rp->addr.type);
7422 }
7423
7424 void adapter_auto_connect_add(struct btd_adapter *adapter,
7425                                         struct btd_device *device)
7426 {
7427         struct mgmt_cp_add_device cp;
7428         const bdaddr_t *bdaddr;
7429         uint8_t bdaddr_type;
7430         unsigned int id;
7431
7432         if (!kernel_conn_control)
7433                 return;
7434
7435         if (g_slist_find(adapter->connect_list, device)) {
7436                 DBG("ignoring already added device %s",
7437                                                 device_get_path(device));
7438                 return;
7439         }
7440
7441         bdaddr = device_get_address(device);
7442         bdaddr_type = btd_device_get_bdaddr_type(device);
7443
7444         if (bdaddr_type == BDADDR_BREDR) {
7445                 DBG("auto-connection feature is not avaiable for BR/EDR");
7446                 return;
7447         }
7448
7449         memset(&cp, 0, sizeof(cp));
7450         bacpy(&cp.addr.bdaddr, bdaddr);
7451         cp.addr.type = bdaddr_type;
7452         cp.action = 0x02;
7453
7454         id = mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
7455                         adapter->dev_id, sizeof(cp), &cp, add_device_complete,
7456                         adapter, NULL);
7457         if (id == 0)
7458                 return;
7459
7460         adapter->connect_list = g_slist_append(adapter->connect_list, device);
7461 }
7462
7463 static void remove_device_complete(uint8_t status, uint16_t length,
7464                                         const void *param, void *user_data)
7465 {
7466         const struct mgmt_rp_remove_device *rp = param;
7467         char addr[18];
7468
7469         if (length < sizeof(*rp)) {
7470                 error("Too small Remove Device complete event");
7471                 return;
7472         }
7473
7474         ba2str(&rp->addr.bdaddr, addr);
7475
7476         if (status != MGMT_STATUS_SUCCESS) {
7477                 error("Failed to remove device %s (%u): %s (0x%02x)",
7478                         addr, rp->addr.type, mgmt_errstr(status), status);
7479                 return;
7480         }
7481
7482         DBG("%s (%u) removed from kernel connect list", addr, rp->addr.type);
7483 }
7484
7485 void adapter_auto_connect_remove(struct btd_adapter *adapter,
7486                                         struct btd_device *device)
7487 {
7488         struct mgmt_cp_remove_device cp;
7489         const bdaddr_t *bdaddr;
7490         uint8_t bdaddr_type;
7491         unsigned int id;
7492
7493         if (!kernel_conn_control)
7494                 return;
7495
7496         if (!g_slist_find(adapter->connect_list, device)) {
7497                 DBG("ignoring not added device %s", device_get_path(device));
7498                 return;
7499         }
7500
7501         bdaddr = device_get_address(device);
7502         bdaddr_type = btd_device_get_bdaddr_type(device);
7503
7504         if (bdaddr_type == BDADDR_BREDR) {
7505                 DBG("auto-connection feature is not avaiable for BR/EDR");
7506                 return;
7507         }
7508
7509         memset(&cp, 0, sizeof(cp));
7510         bacpy(&cp.addr.bdaddr, bdaddr);
7511         cp.addr.type = bdaddr_type;
7512
7513         id = mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
7514                         adapter->dev_id, sizeof(cp), &cp,
7515                         remove_device_complete, adapter, NULL);
7516         if (id == 0)
7517                 return;
7518
7519         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
7520 }
7521
7522 static void adapter_start(struct btd_adapter *adapter)
7523 {
7524 #if defined(__TIZEN_PATCH__) && !defined(__SPRD_PATCH__)
7525         if (adapter_le_read_ble_feature_info())
7526                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
7527                         ADAPTER_INTERFACE, "SupportedLEFeatures");
7528
7529         adapter_get_adv_tx_power(adapter);
7530
7531         /* By default enable offloading for testing, this should be modified */
7532         if (adapter_le_is_supported_offloading())
7533                 adapter_le_enable_offloading(TRUE);
7534 #endif
7535
7536 #ifndef __TIZEN_PATCH__
7537         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7538                                                 ADAPTER_INTERFACE, "Powered");
7539 #else
7540         g_dbus_emit_property_changed_full(dbus_conn, adapter->path,
7541                                                 ADAPTER_INTERFACE, "Powered", 1);
7542 #endif
7543
7544         DBG("adapter %s has been enabled", adapter->path);
7545
7546         trigger_passive_scanning(adapter);
7547 }
7548
7549 static void reply_pending_requests(struct btd_adapter *adapter)
7550 {
7551         GSList *l;
7552
7553         if (!adapter)
7554                 return;
7555
7556         /* pending bonding */
7557         for (l = adapter->devices; l; l = l->next) {
7558                 struct btd_device *device = l->data;
7559
7560                 if (device_is_bonding(device, NULL))
7561                         device_bonding_failed(device,
7562                                                 HCI_OE_USER_ENDED_CONNECTION);
7563         }
7564 }
7565
7566 static void remove_driver(gpointer data, gpointer user_data)
7567 {
7568         struct btd_adapter_driver *driver = data;
7569         struct btd_adapter *adapter = user_data;
7570
7571         if (driver->remove)
7572                 driver->remove(adapter);
7573 }
7574
7575 static void remove_profile(gpointer data, gpointer user_data)
7576 {
7577         struct btd_profile *profile = data;
7578         struct btd_adapter *adapter = user_data;
7579
7580         if (profile->adapter_remove)
7581                 profile->adapter_remove(profile, adapter);
7582 }
7583
7584 static void unload_drivers(struct btd_adapter *adapter)
7585 {
7586         g_slist_foreach(adapter->drivers, remove_driver, adapter);
7587         g_slist_free(adapter->drivers);
7588         adapter->drivers = NULL;
7589
7590         g_slist_foreach(adapter->profiles, remove_profile, adapter);
7591         g_slist_free(adapter->profiles);
7592         adapter->profiles = NULL;
7593 }
7594
7595 static void free_service_auth(gpointer data, gpointer user_data)
7596 {
7597         struct service_auth *auth = data;
7598
7599         g_free(auth);
7600 }
7601
7602 static void adapter_free(gpointer user_data)
7603 {
7604         struct btd_adapter *adapter = user_data;
7605
7606         DBG("%p", adapter);
7607
7608         if (adapter->load_ltks_timeout > 0)
7609                 g_source_remove(adapter->load_ltks_timeout);
7610
7611         if (adapter->confirm_name_timeout > 0)
7612                 g_source_remove(adapter->confirm_name_timeout);
7613
7614         if (adapter->pair_device_timeout > 0)
7615                 g_source_remove(adapter->pair_device_timeout);
7616
7617         if (adapter->auth_idle_id)
7618                 g_source_remove(adapter->auth_idle_id);
7619
7620         g_queue_foreach(adapter->auths, free_service_auth, NULL);
7621         g_queue_free(adapter->auths);
7622
7623         /*
7624          * Unregister all handlers for this specific index since
7625          * the adapter bound to them is no longer valid.
7626          *
7627          * This also avoids having multiple instances of the same
7628          * handler in case indexes got removed and re-added.
7629          */
7630         mgmt_unregister_index(adapter->mgmt, adapter->dev_id);
7631
7632         /*
7633          * Cancel all pending commands for this specific index
7634          * since the adapter bound to them is no longer valid.
7635          */
7636         mgmt_cancel_index(adapter->mgmt, adapter->dev_id);
7637
7638         mgmt_unref(adapter->mgmt);
7639
7640         sdp_list_free(adapter->services, NULL);
7641
7642         g_slist_free(adapter->connections);
7643
7644         g_free(adapter->path);
7645         g_free(adapter->name);
7646         g_free(adapter->short_name);
7647         g_free(adapter->system_name);
7648         g_free(adapter->stored_alias);
7649         g_free(adapter->current_alias);
7650         free(adapter->modalias);
7651         g_free(adapter);
7652 }
7653
7654 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
7655 {
7656         __sync_fetch_and_add(&adapter->ref_count, 1);
7657
7658         return adapter;
7659 }
7660
7661 void btd_adapter_unref(struct btd_adapter *adapter)
7662 {
7663         if (__sync_sub_and_fetch(&adapter->ref_count, 1))
7664                 return;
7665
7666         if (!adapter->path) {
7667                 DBG("Freeing adapter %u", adapter->dev_id);
7668
7669                 adapter_free(adapter);
7670                 return;
7671         }
7672
7673         DBG("Freeing adapter %s", adapter->path);
7674
7675         g_dbus_unregister_interface(dbus_conn, adapter->path,
7676                                                 ADAPTER_INTERFACE);
7677 }
7678
7679 static void convert_names_entry(char *key, char *value, void *user_data)
7680 {
7681         char *address = user_data;
7682         char *str = key;
7683         char filename[PATH_MAX];
7684         GKeyFile *key_file;
7685         char *data;
7686         gsize length = 0;
7687
7688         if (strchr(key, '#'))
7689                 str[17] = '\0';
7690
7691         if (bachk(str) != 0)
7692                 return;
7693
7694         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/cache/%s", address, str);
7695         create_file(filename, S_IRUSR | S_IWUSR);
7696
7697         key_file = g_key_file_new();
7698         g_key_file_load_from_file(key_file, filename, 0, NULL);
7699         g_key_file_set_string(key_file, "General", "Name", value);
7700
7701         data = g_key_file_to_data(key_file, &length, NULL);
7702         g_file_set_contents(filename, data, length, NULL);
7703         g_free(data);
7704
7705         g_key_file_free(key_file);
7706 }
7707
7708 struct device_converter {
7709         char *address;
7710         void (*cb)(GKeyFile *key_file, void *value);
7711         gboolean force;
7712 };
7713
7714 static void set_device_type(GKeyFile *key_file, char type)
7715 {
7716         char *techno;
7717         char *addr_type = NULL;
7718         char *str;
7719
7720         switch (type) {
7721         case BDADDR_BREDR:
7722                 techno = "BR/EDR";
7723                 break;
7724         case BDADDR_LE_PUBLIC:
7725                 techno = "LE";
7726                 addr_type = "public";
7727                 break;
7728         case BDADDR_LE_RANDOM:
7729                 techno = "LE";
7730                 addr_type = "static";
7731                 break;
7732         default:
7733                 return;
7734         }
7735
7736         str = g_key_file_get_string(key_file, "General",
7737                                         "SupportedTechnologies", NULL);
7738         if (!str)
7739                 g_key_file_set_string(key_file, "General",
7740                                         "SupportedTechnologies", techno);
7741         else if (!strstr(str, techno))
7742                 g_key_file_set_string(key_file, "General",
7743                                         "SupportedTechnologies", "BR/EDR;LE");
7744
7745         g_free(str);
7746
7747         if (addr_type)
7748                 g_key_file_set_string(key_file, "General", "AddressType",
7749                                         addr_type);
7750 }
7751
7752 static void convert_aliases_entry(GKeyFile *key_file, void *value)
7753 {
7754         g_key_file_set_string(key_file, "General", "Alias", value);
7755 }
7756
7757 static void convert_trusts_entry(GKeyFile *key_file, void *value)
7758 {
7759         g_key_file_set_boolean(key_file, "General", "Trusted", TRUE);
7760 }
7761
7762 static void convert_classes_entry(GKeyFile *key_file, void *value)
7763 {
7764         g_key_file_set_string(key_file, "General", "Class", value);
7765 }
7766
7767 static void convert_blocked_entry(GKeyFile *key_file, void *value)
7768 {
7769         g_key_file_set_boolean(key_file, "General", "Blocked", TRUE);
7770 }
7771
7772 static void convert_did_entry(GKeyFile *key_file, void *value)
7773 {
7774         char *vendor_str, *product_str, *version_str;
7775         uint16_t val;
7776
7777         vendor_str = strchr(value, ' ');
7778         if (!vendor_str)
7779                 return;
7780
7781         *(vendor_str++) = 0;
7782
7783         if (g_str_equal(value, "FFFF"))
7784                 return;
7785
7786         product_str = strchr(vendor_str, ' ');
7787         if (!product_str)
7788                 return;
7789
7790         *(product_str++) = 0;
7791
7792         version_str = strchr(product_str, ' ');
7793         if (!version_str)
7794                 return;
7795
7796         *(version_str++) = 0;
7797
7798         val = (uint16_t) strtol(value, NULL, 16);
7799         g_key_file_set_integer(key_file, "DeviceID", "Source", val);
7800
7801         val = (uint16_t) strtol(vendor_str, NULL, 16);
7802         g_key_file_set_integer(key_file, "DeviceID", "Vendor", val);
7803
7804         val = (uint16_t) strtol(product_str, NULL, 16);
7805         g_key_file_set_integer(key_file, "DeviceID", "Product", val);
7806
7807         val = (uint16_t) strtol(version_str, NULL, 16);
7808         g_key_file_set_integer(key_file, "DeviceID", "Version", val);
7809 }
7810
7811 static void convert_linkkey_entry(GKeyFile *key_file, void *value)
7812 {
7813         char *type_str, *length_str, *str;
7814         int val;
7815
7816         type_str = strchr(value, ' ');
7817         if (!type_str)
7818                 return;
7819
7820         *(type_str++) = 0;
7821
7822         length_str = strchr(type_str, ' ');
7823         if (!length_str)
7824                 return;
7825
7826         *(length_str++) = 0;
7827
7828         str = g_strconcat("0x", value, NULL);
7829         g_key_file_set_string(key_file, "LinkKey", "Key", str);
7830         g_free(str);
7831
7832         val = strtol(type_str, NULL, 16);
7833         g_key_file_set_integer(key_file, "LinkKey", "Type", val);
7834
7835         val = strtol(length_str, NULL, 16);
7836         g_key_file_set_integer(key_file, "LinkKey", "PINLength", val);
7837 }
7838
7839 static void convert_ltk_entry(GKeyFile *key_file, void *value)
7840 {
7841         char *auth_str, *rand_str, *str;
7842         int i, ret;
7843         unsigned char auth, master, enc_size;
7844         unsigned short ediv;
7845
7846         auth_str = strchr(value, ' ');
7847         if (!auth_str)
7848                 return;
7849
7850         *(auth_str++) = 0;
7851
7852         for (i = 0, rand_str = auth_str; i < 4; i++) {
7853                 rand_str = strchr(rand_str, ' ');
7854                 if (!rand_str || rand_str[1] == '\0')
7855                         return;
7856
7857                 rand_str++;
7858         }
7859
7860         ret = sscanf(auth_str, " %hhd %hhd %hhd %hd", &auth, &master,
7861                                                         &enc_size, &ediv);
7862         if (ret < 4)
7863                 return;
7864
7865         str = g_strconcat("0x", value, NULL);
7866         g_key_file_set_string(key_file, "LongTermKey", "Key", str);
7867         g_free(str);
7868
7869         g_key_file_set_integer(key_file, "LongTermKey", "Authenticated", auth);
7870         g_key_file_set_integer(key_file, "LongTermKey", "Master", master);
7871         g_key_file_set_integer(key_file, "LongTermKey", "EncSize", enc_size);
7872         g_key_file_set_integer(key_file, "LongTermKey", "EDiv", ediv);
7873
7874         str = g_strconcat("0x", rand_str, NULL);
7875         g_key_file_set_string(key_file, "LongTermKey", "Rand", str);
7876         g_free(str);
7877 }
7878
7879 static void convert_profiles_entry(GKeyFile *key_file, void *value)
7880 {
7881         g_strdelimit(value, " ", ';');
7882         g_key_file_set_string(key_file, "General", "Services", value);
7883 }
7884
7885 static void convert_appearances_entry(GKeyFile *key_file, void *value)
7886 {
7887         g_key_file_set_string(key_file, "General", "Appearance", value);
7888 }
7889
7890 static void convert_entry(char *key, char *value, void *user_data)
7891 {
7892         struct device_converter *converter = user_data;
7893         char type = BDADDR_BREDR;
7894         char filename[PATH_MAX];
7895         GKeyFile *key_file;
7896         char *data;
7897         gsize length = 0;
7898
7899         if (strchr(key, '#')) {
7900                 key[17] = '\0';
7901                 type = key[18] - '0';
7902         }
7903
7904         if (bachk(key) != 0)
7905                 return;
7906
7907         if (converter->force == FALSE) {
7908                 struct stat st;
7909                 int err;
7910
7911                 snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s",
7912                                 converter->address, key);
7913
7914                 err = stat(filename, &st);
7915                 if (err || !S_ISDIR(st.st_mode))
7916                         return;
7917         }
7918
7919         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
7920                         converter->address, key);
7921
7922         key_file = g_key_file_new();
7923         g_key_file_load_from_file(key_file, filename, 0, NULL);
7924
7925         set_device_type(key_file, type);
7926
7927         converter->cb(key_file, value);
7928
7929         data = g_key_file_to_data(key_file, &length, NULL);
7930         if (length > 0) {
7931                 create_file(filename, S_IRUSR | S_IWUSR);
7932                 g_file_set_contents(filename, data, length, NULL);
7933         }
7934
7935         g_free(data);
7936
7937         g_key_file_free(key_file);
7938 }
7939
7940 static void convert_file(char *file, char *address,
7941                                 void (*cb)(GKeyFile *key_file, void *value),
7942                                 gboolean force)
7943 {
7944         char filename[PATH_MAX];
7945         struct device_converter converter;
7946
7947         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", address, file);
7948
7949         converter.address = address;
7950         converter.cb = cb;
7951         converter.force = force;
7952
7953         textfile_foreach(filename, convert_entry, &converter);
7954 }
7955
7956 static gboolean record_has_uuid(const sdp_record_t *rec,
7957                                 const char *profile_uuid)
7958 {
7959         sdp_list_t *pat;
7960
7961         for (pat = rec->pattern; pat != NULL; pat = pat->next) {
7962                 char *uuid;
7963                 int ret;
7964
7965                 uuid = bt_uuid2string(pat->data);
7966                 if (!uuid)
7967                         continue;
7968
7969                 ret = strcasecmp(uuid, profile_uuid);
7970
7971                 free(uuid);
7972
7973                 if (ret == 0)
7974                         return TRUE;
7975         }
7976
7977         return FALSE;
7978 }
7979
7980 static void store_attribute_uuid(GKeyFile *key_file, uint16_t start,
7981                                         uint16_t end, char *att_uuid,
7982                                         uuid_t uuid)
7983 {
7984         char handle[6], uuid_str[33];
7985         int i;
7986
7987         switch (uuid.type) {
7988         case SDP_UUID16:
7989                 sprintf(uuid_str, "%4.4X", uuid.value.uuid16);
7990                 break;
7991         case SDP_UUID32:
7992                 sprintf(uuid_str, "%8.8X", uuid.value.uuid32);
7993                 break;
7994         case SDP_UUID128:
7995                 for (i = 0; i < 16; i++)
7996                         sprintf(uuid_str + (i * 2), "%2.2X",
7997                                         uuid.value.uuid128.data[i]);
7998                 break;
7999         default:
8000                 uuid_str[0] = '\0';
8001         }
8002
8003         sprintf(handle, "%hu", start);
8004         g_key_file_set_string(key_file, handle, "UUID", att_uuid);
8005         g_key_file_set_string(key_file, handle, "Value", uuid_str);
8006         g_key_file_set_integer(key_file, handle, "EndGroupHandle", end);
8007 }
8008
8009 static void store_sdp_record(char *local, char *peer, int handle, char *value)
8010 {
8011         char filename[PATH_MAX];
8012         GKeyFile *key_file;
8013         char handle_str[11];
8014         char *data;
8015         gsize length = 0;
8016
8017         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/cache/%s", local, peer);
8018
8019         key_file = g_key_file_new();
8020         g_key_file_load_from_file(key_file, filename, 0, NULL);
8021
8022         sprintf(handle_str, "0x%8.8X", handle);
8023         g_key_file_set_string(key_file, "ServiceRecords", handle_str, value);
8024
8025         data = g_key_file_to_data(key_file, &length, NULL);
8026         if (length > 0) {
8027                 create_file(filename, S_IRUSR | S_IWUSR);
8028                 g_file_set_contents(filename, data, length, NULL);
8029         }
8030
8031         g_free(data);
8032
8033         g_key_file_free(key_file);
8034 }
8035
8036 static void convert_sdp_entry(char *key, char *value, void *user_data)
8037 {
8038         char *src_addr = user_data;
8039         char dst_addr[18];
8040         char type = BDADDR_BREDR;
8041         int handle, ret;
8042         char filename[PATH_MAX];
8043         GKeyFile *key_file;
8044         struct stat st;
8045         sdp_record_t *rec;
8046         uuid_t uuid;
8047         char *att_uuid, *prim_uuid;
8048         uint16_t start = 0, end = 0, psm = 0;
8049         int err;
8050         char *data;
8051         gsize length = 0;
8052
8053         ret = sscanf(key, "%17s#%hhu#%08X", dst_addr, &type, &handle);
8054         if (ret < 3) {
8055                 ret = sscanf(key, "%17s#%08X", dst_addr, &handle);
8056                 if (ret < 2)
8057                         return;
8058         }
8059
8060         if (bachk(dst_addr) != 0)
8061                 return;
8062
8063         /* Check if the device directory has been created as records should
8064          * only be converted for known devices */
8065         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
8066
8067         err = stat(filename, &st);
8068         if (err || !S_ISDIR(st.st_mode))
8069                 return;
8070
8071         /* store device records in cache */
8072         store_sdp_record(src_addr, dst_addr, handle, value);
8073
8074         /* Retrieve device record and check if there is an
8075          * attribute entry in it */
8076         sdp_uuid16_create(&uuid, ATT_UUID);
8077         att_uuid = bt_uuid2string(&uuid);
8078
8079         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
8080         prim_uuid = bt_uuid2string(&uuid);
8081
8082         rec = record_from_string(value);
8083
8084         if (record_has_uuid(rec, att_uuid))
8085                 goto failed;
8086
8087         /* TODO: Do this through btd_gatt_database */
8088         if (!gatt_parse_record(rec, &uuid, &psm, &start, &end))
8089                 goto failed;
8090
8091         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/attributes", src_addr,
8092                                                                 dst_addr);
8093
8094         key_file = g_key_file_new();
8095         g_key_file_load_from_file(key_file, filename, 0, NULL);
8096
8097         store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
8098
8099         data = g_key_file_to_data(key_file, &length, NULL);
8100         if (length > 0) {
8101                 create_file(filename, S_IRUSR | S_IWUSR);
8102                 g_file_set_contents(filename, data, length, NULL);
8103         }
8104
8105         g_free(data);
8106         g_key_file_free(key_file);
8107
8108 failed:
8109         sdp_record_free(rec);
8110         free(prim_uuid);
8111         free(att_uuid);
8112 }
8113
8114 static void convert_primaries_entry(char *key, char *value, void *user_data)
8115 {
8116         char *address = user_data;
8117         int device_type = -1;
8118         uuid_t uuid;
8119         char **services, **service, *prim_uuid;
8120         char filename[PATH_MAX];
8121         GKeyFile *key_file;
8122         int ret;
8123         uint16_t start, end;
8124         char uuid_str[MAX_LEN_UUID_STR + 1];
8125         char *data;
8126         gsize length = 0;
8127
8128         if (strchr(key, '#')) {
8129                 key[17] = '\0';
8130                 device_type = key[18] - '0';
8131         }
8132
8133         if (bachk(key) != 0)
8134                 return;
8135
8136         services = g_strsplit(value, " ", 0);
8137         if (services == NULL)
8138                 return;
8139
8140         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
8141         prim_uuid = bt_uuid2string(&uuid);
8142
8143         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/attributes", address,
8144                                                                         key);
8145         key_file = g_key_file_new();
8146         g_key_file_load_from_file(key_file, filename, 0, NULL);
8147
8148         for (service = services; *service; service++) {
8149                 ret = sscanf(*service, "%04hX#%04hX#%s", &start, &end,
8150                                                                 uuid_str);
8151                 if (ret < 3)
8152                         continue;
8153
8154                 bt_string2uuid(&uuid, uuid_str);
8155                 sdp_uuid128_to_uuid(&uuid);
8156
8157                 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
8158         }
8159
8160         g_strfreev(services);
8161
8162         data = g_key_file_to_data(key_file, &length, NULL);
8163         if (length == 0)
8164                 goto end;
8165
8166         create_file(filename, S_IRUSR | S_IWUSR);
8167         g_file_set_contents(filename, data, length, NULL);
8168
8169         if (device_type < 0)
8170                 goto end;
8171
8172         g_free(data);
8173         g_key_file_free(key_file);
8174
8175         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", address, key);
8176
8177         key_file = g_key_file_new();
8178         g_key_file_load_from_file(key_file, filename, 0, NULL);
8179         set_device_type(key_file, device_type);
8180
8181         data = g_key_file_to_data(key_file, &length, NULL);
8182         if (length > 0) {
8183                 create_file(filename, S_IRUSR | S_IWUSR);
8184                 g_file_set_contents(filename, data, length, NULL);
8185         }
8186
8187 end:
8188         g_free(data);
8189         free(prim_uuid);
8190         g_key_file_free(key_file);
8191 }
8192
8193 static void convert_ccc_entry(char *key, char *value, void *user_data)
8194 {
8195         char *src_addr = user_data;
8196         char dst_addr[18];
8197         char type = BDADDR_BREDR;
8198         uint16_t handle;
8199         int ret, err;
8200         char filename[PATH_MAX];
8201         GKeyFile *key_file;
8202         struct stat st;
8203         char group[6];
8204         char *data;
8205         gsize length = 0;
8206
8207         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
8208         if (ret < 3)
8209                 return;
8210
8211         if (bachk(dst_addr) != 0)
8212                 return;
8213
8214         /* Check if the device directory has been created as records should
8215          * only be converted for known devices */
8216         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
8217
8218         err = stat(filename, &st);
8219         if (err || !S_ISDIR(st.st_mode))
8220                 return;
8221
8222         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/ccc", src_addr,
8223                                                                 dst_addr);
8224         key_file = g_key_file_new();
8225         g_key_file_load_from_file(key_file, filename, 0, NULL);
8226
8227         sprintf(group, "%hu", handle);
8228         g_key_file_set_string(key_file, group, "Value", value);
8229
8230         data = g_key_file_to_data(key_file, &length, NULL);
8231         if (length > 0) {
8232                 create_file(filename, S_IRUSR | S_IWUSR);
8233                 g_file_set_contents(filename, data, length, NULL);
8234         }
8235
8236         g_free(data);
8237         g_key_file_free(key_file);
8238 }
8239
8240 static void convert_gatt_entry(char *key, char *value, void *user_data)
8241 {
8242         char *src_addr = user_data;
8243         char dst_addr[18];
8244         char type = BDADDR_BREDR;
8245         uint16_t handle;
8246         int ret, err;
8247         char filename[PATH_MAX];
8248         GKeyFile *key_file;
8249         struct stat st;
8250         char group[6];
8251         char *data;
8252         gsize length = 0;
8253
8254         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
8255         if (ret < 3)
8256                 return;
8257
8258         if (bachk(dst_addr) != 0)
8259                 return;
8260
8261         /* Check if the device directory has been created as records should
8262          * only be converted for known devices */
8263         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
8264
8265         err = stat(filename, &st);
8266         if (err || !S_ISDIR(st.st_mode))
8267                 return;
8268
8269         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/gatt", src_addr,
8270                                                                 dst_addr);
8271         key_file = g_key_file_new();
8272         g_key_file_load_from_file(key_file, filename, 0, NULL);
8273
8274         sprintf(group, "%hu", handle);
8275         g_key_file_set_string(key_file, group, "Value", value);
8276
8277         data = g_key_file_to_data(key_file, &length, NULL);
8278         if (length > 0) {
8279                 create_file(filename, S_IRUSR | S_IWUSR);
8280                 g_file_set_contents(filename, data, length, NULL);
8281         }
8282
8283         g_free(data);
8284         g_key_file_free(key_file);
8285 }
8286
8287 static void convert_proximity_entry(char *key, char *value, void *user_data)
8288 {
8289         char *src_addr = user_data;
8290         char *alert;
8291         char filename[PATH_MAX];
8292         GKeyFile *key_file;
8293         struct stat st;
8294         int err;
8295         char *data;
8296         gsize length = 0;
8297
8298         if (!strchr(key, '#'))
8299                 return;
8300
8301         key[17] = '\0';
8302         alert = &key[18];
8303
8304         if (bachk(key) != 0)
8305                 return;
8306
8307         /* Check if the device directory has been created as records should
8308          * only be converted for known devices */
8309         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, key);
8310
8311         err = stat(filename, &st);
8312         if (err || !S_ISDIR(st.st_mode))
8313                 return;
8314
8315         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/proximity", src_addr,
8316                                                                         key);
8317         key_file = g_key_file_new();
8318         g_key_file_load_from_file(key_file, filename, 0, NULL);
8319
8320         g_key_file_set_string(key_file, alert, "Level", value);
8321
8322         data = g_key_file_to_data(key_file, &length, NULL);
8323         if (length > 0) {
8324                 create_file(filename, S_IRUSR | S_IWUSR);
8325                 g_file_set_contents(filename, data, length, NULL);
8326         }
8327
8328         g_free(data);
8329         g_key_file_free(key_file);
8330 }
8331
8332 static void convert_device_storage(struct btd_adapter *adapter)
8333 {
8334         char filename[PATH_MAX];
8335         char address[18];
8336
8337         ba2str(&adapter->bdaddr, address);
8338
8339         /* Convert device's name cache */
8340         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/names", address);
8341         textfile_foreach(filename, convert_names_entry, address);
8342
8343         /* Convert aliases */
8344         convert_file("aliases", address, convert_aliases_entry, TRUE);
8345
8346         /* Convert trusts */
8347         convert_file("trusts", address, convert_trusts_entry, TRUE);
8348
8349         /* Convert blocked */
8350         convert_file("blocked", address, convert_blocked_entry, TRUE);
8351
8352         /* Convert profiles */
8353         convert_file("profiles", address, convert_profiles_entry, TRUE);
8354
8355         /* Convert primaries */
8356         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/primaries", address);
8357         textfile_foreach(filename, convert_primaries_entry, address);
8358
8359         /* Convert linkkeys */
8360         convert_file("linkkeys", address, convert_linkkey_entry, TRUE);
8361
8362         /* Convert longtermkeys */
8363         convert_file("longtermkeys", address, convert_ltk_entry, TRUE);
8364
8365         /* Convert classes */
8366         convert_file("classes", address, convert_classes_entry, FALSE);
8367
8368         /* Convert device ids */
8369         convert_file("did", address, convert_did_entry, FALSE);
8370
8371         /* Convert sdp */
8372         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/sdp", address);
8373         textfile_foreach(filename, convert_sdp_entry, address);
8374
8375         /* Convert ccc */
8376         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/ccc", address);
8377         textfile_foreach(filename, convert_ccc_entry, address);
8378
8379         /* Convert appearances */
8380         convert_file("appearances", address, convert_appearances_entry, FALSE);
8381
8382         /* Convert gatt */
8383         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/gatt", address);
8384         textfile_foreach(filename, convert_gatt_entry, address);
8385
8386         /* Convert proximity */
8387         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/proximity", address);
8388         textfile_foreach(filename, convert_proximity_entry, address);
8389 }
8390
8391 static void convert_config(struct btd_adapter *adapter, const char *filename,
8392                                                         GKeyFile *key_file)
8393 {
8394         char address[18];
8395         char str[MAX_NAME_LENGTH + 1];
8396         char config_path[PATH_MAX];
8397         int timeout;
8398         uint8_t mode;
8399         char *data;
8400         gsize length = 0;
8401
8402         ba2str(&adapter->bdaddr, address);
8403         snprintf(config_path, PATH_MAX, STORAGEDIR "/%s/config", address);
8404
8405         if (read_pairable_timeout(address, &timeout) == 0)
8406                 g_key_file_set_integer(key_file, "General",
8407                                                 "PairableTimeout", timeout);
8408
8409         if (read_discoverable_timeout(address, &timeout) == 0)
8410                 g_key_file_set_integer(key_file, "General",
8411                                                 "DiscoverableTimeout", timeout);
8412
8413         if (read_on_mode(address, str, sizeof(str)) == 0) {
8414                 mode = get_mode(str);
8415                 g_key_file_set_boolean(key_file, "General", "Discoverable",
8416                                         mode == MODE_DISCOVERABLE);
8417         }
8418
8419         if (read_local_name(&adapter->bdaddr, str) == 0)
8420                 g_key_file_set_string(key_file, "General", "Alias", str);
8421
8422         create_file(filename, S_IRUSR | S_IWUSR);
8423
8424         data = g_key_file_to_data(key_file, &length, NULL);
8425         g_file_set_contents(filename, data, length, NULL);
8426         g_free(data);
8427 }
8428
8429 static void fix_storage(struct btd_adapter *adapter)
8430 {
8431         char filename[PATH_MAX];
8432         char address[18];
8433         char *converted;
8434
8435         ba2str(&adapter->bdaddr, address);
8436
8437         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/config", address);
8438         converted = textfile_get(filename, "converted");
8439         if (!converted)
8440                 return;
8441
8442         free(converted);
8443
8444         textfile_del(filename, "converted");
8445
8446         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/names", address);
8447         textfile_del(filename, "converted");
8448
8449         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/aliases", address);
8450         textfile_del(filename, "converted");
8451
8452         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/trusts", address);
8453         textfile_del(filename, "converted");
8454
8455         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/blocked", address);
8456         textfile_del(filename, "converted");
8457
8458         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/profiles", address);
8459         textfile_del(filename, "converted");
8460
8461         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/primaries", address);
8462         textfile_del(filename, "converted");
8463
8464         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/linkkeys", address);
8465         textfile_del(filename, "converted");
8466
8467         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/longtermkeys", address);
8468         textfile_del(filename, "converted");
8469
8470         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/classes", address);
8471         textfile_del(filename, "converted");
8472
8473         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/did", address);
8474         textfile_del(filename, "converted");
8475
8476         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/sdp", address);
8477         textfile_del(filename, "converted");
8478
8479         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/ccc", address);
8480         textfile_del(filename, "converted");
8481
8482         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/appearances", address);
8483         textfile_del(filename, "converted");
8484
8485         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/gatt", address);
8486         textfile_del(filename, "converted");
8487
8488         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/proximity", address);
8489         textfile_del(filename, "converted");
8490 }
8491
8492 static void load_config(struct btd_adapter *adapter)
8493 {
8494         GKeyFile *key_file;
8495         char filename[PATH_MAX];
8496         char address[18];
8497         struct stat st;
8498         GError *gerr = NULL;
8499 #ifdef __TIZEN_PATCH__
8500         char *str;
8501 #endif
8502
8503         ba2str(&adapter->bdaddr, address);
8504
8505         key_file = g_key_file_new();
8506
8507         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/settings", address);
8508
8509         if (stat(filename, &st) < 0) {
8510                 convert_config(adapter, filename, key_file);
8511                 convert_device_storage(adapter);
8512         }
8513
8514         g_key_file_load_from_file(key_file, filename, 0, NULL);
8515
8516         /* Get alias */
8517         adapter->stored_alias = g_key_file_get_string(key_file, "General",
8518                                                                 "Alias", NULL);
8519         if (!adapter->stored_alias) {
8520                 /* fallback */
8521                 adapter->stored_alias = g_key_file_get_string(key_file,
8522                                                 "General", "Name", NULL);
8523         }
8524
8525         /* Get pairable timeout */
8526         adapter->pairable_timeout = g_key_file_get_integer(key_file, "General",
8527                                                 "PairableTimeout", &gerr);
8528         if (gerr) {
8529                 adapter->pairable_timeout = main_opts.pairto;
8530                 g_error_free(gerr);
8531                 gerr = NULL;
8532         }
8533
8534         /* Get discoverable mode */
8535         adapter->stored_discoverable = g_key_file_get_boolean(key_file,
8536                                         "General", "Discoverable", &gerr);
8537         if (gerr) {
8538                 adapter->stored_discoverable = false;
8539                 g_error_free(gerr);
8540                 gerr = NULL;
8541         }
8542
8543         /* Get discoverable timeout */
8544         adapter->discoverable_timeout = g_key_file_get_integer(key_file,
8545                                 "General", "DiscoverableTimeout", &gerr);
8546         if (gerr) {
8547                 adapter->discoverable_timeout = main_opts.discovto;
8548                 g_error_free(gerr);
8549                 gerr = NULL;
8550         }
8551
8552 #ifdef __TIZEN_PATCH__
8553         /* Get Le Privacy feature support */
8554         adapter->le_privacy_enabled = main_opts.le_privacy;
8555         if (adapter->le_privacy_enabled) {
8556                 /* Get Local IRK */
8557                 str = g_key_file_get_string(key_file,
8558                                 "General", "LocalIrk", &gerr);
8559                 if (gerr || !str || strlen(str) != 34) {
8560                         memset(adapter->local_irk, 0, MGMT_IRK_SIZE);
8561                         g_error_free(gerr);
8562                         gerr = NULL;
8563                 } else
8564                         str2buf(&str[2], (uint8_t *)adapter->local_irk, MGMT_IRK_SIZE);
8565         }
8566 #endif
8567
8568         g_key_file_free(key_file);
8569 }
8570
8571 static struct btd_adapter *btd_adapter_new(uint16_t index)
8572 {
8573         struct btd_adapter *adapter;
8574 #ifdef __TIZEN_PATCH__
8575 #ifdef TIZEN_WEARABLE
8576         DBusConnection *conn = btd_get_dbus_connection();
8577         DBusMessage *msg = NULL;
8578         DBusMessage *reply = NULL;
8579         int charging_state = 0;
8580 #endif  /* TIZEN_WEARABLE */
8581 #endif
8582
8583         adapter = g_try_new0(struct btd_adapter, 1);
8584         if (!adapter)
8585                 return NULL;
8586
8587         adapter->dev_id = index;
8588         adapter->mgmt = mgmt_ref(mgmt_master);
8589         adapter->pincode_requested = false;
8590
8591         /*
8592          * Setup default configuration values. These are either adapter
8593          * defaults or from a system wide configuration file.
8594          *
8595          * Some value might be overwritten later on by adapter specific
8596          * configuration. This is to make sure that sane defaults are
8597          * always present.
8598          */
8599         adapter->system_name = g_strdup(main_opts.name);
8600         adapter->major_class = (main_opts.class & 0x001f00) >> 8;
8601         adapter->minor_class = (main_opts.class & 0x0000fc) >> 2;
8602         adapter->modalias = bt_modalias(main_opts.did_source,
8603                                                 main_opts.did_vendor,
8604                                                 main_opts.did_product,
8605                                                 main_opts.did_version);
8606         adapter->discoverable_timeout = main_opts.discovto;
8607         adapter->pairable_timeout = main_opts.pairto;
8608 #ifdef __TIZEN_PATCH__
8609         adapter->advertising = FALSE;
8610 #endif
8611
8612         DBG("System name: %s", adapter->system_name);
8613         DBG("Major class: %u", adapter->major_class);
8614         DBG("Minor class: %u", adapter->minor_class);
8615         DBG("Modalias: %s", adapter->modalias);
8616         DBG("Discoverable timeout: %u seconds", adapter->discoverable_timeout);
8617         DBG("Pairable timeout: %u seconds", adapter->pairable_timeout);
8618 #ifdef __TIZEN_PATCH__
8619         if (main_opts.le_privacy)
8620                 DBG("LE Privacy is enabled.");
8621         else
8622                 DBG("LE Privacy is disabled.");
8623
8624         adapter->central_rpa_res_support = 0x00;
8625 #endif
8626         adapter->auths = g_queue_new();
8627
8628 #ifdef __TIZEN_PATCH__
8629 #ifdef TIZEN_WEARABLE
8630         adapter->charging_watch = g_dbus_add_signal_watch(conn, DEVICED_DEST,
8631                         DEVICED_BATT_OBJECT_PATH,
8632                         DEVICED_BATT_INTERFACE, "ChargerType",
8633                         charging_state_changed, adapter, NULL);
8634         if (adapter->charging_watch == 0)
8635                 error("Cannot add signal watch for ChargerType");
8636
8637         msg = dbus_message_new_method_call(DEVICED_DEST,
8638                         DEVICED_BATT_OBJECT_PATH,
8639                         DEVICED_BATT_INTERFACE, "ChargerType");
8640         if (msg) {
8641                 reply = dbus_connection_send_with_reply_and_block(conn,
8642                                 msg, 1000, NULL);
8643                 if (reply) {
8644                         if (dbus_message_get_args(reply, NULL,
8645                                         DBUS_TYPE_INT32, &charging_state,
8646                                         DBUS_TYPE_INVALID) == TRUE) {
8647                                 set_charging_state(adapter, charging_state);
8648                         }
8649                         dbus_message_unref(reply);
8650                 } else {
8651                         error("Reply is NULL");
8652                 }
8653                 dbus_message_unref(msg);
8654         } else {
8655                 error("Unable to create dbus message for charging state");
8656         }
8657 #endif  /* TIZEN_WEARABLE */
8658 #endif
8659
8660         return btd_adapter_ref(adapter);
8661 }
8662
8663 static void adapter_remove(struct btd_adapter *adapter)
8664 {
8665         GSList *l;
8666 #ifndef __TIZEN_PATCH__
8667         struct gatt_db *db;
8668 #endif
8669
8670         DBG("Removing adapter %s", adapter->path);
8671
8672 #ifdef __TIZEN_PATCH__
8673 #ifdef TIZEN_WEARABLE
8674         if (adapter->charging_watch > 0) {
8675                 g_dbus_remove_watch(btd_get_dbus_connection(),
8676                                 adapter->charging_watch);
8677                 adapter->charging_watch = 0;
8678         }
8679
8680         if (adapter->charging_timeout) {
8681                 g_source_remove(adapter->charging_timeout);
8682                 adapter->charging_timeout = 0;
8683         }
8684 #endif  /* TIZEN_WEARABLE */
8685 #endif
8686
8687         if (adapter->discovery_idle_timeout > 0) {
8688                 g_source_remove(adapter->discovery_idle_timeout);
8689                 adapter->discovery_idle_timeout = 0;
8690         }
8691
8692         if (adapter->temp_devices_timeout > 0) {
8693                 g_source_remove(adapter->temp_devices_timeout);
8694                 adapter->temp_devices_timeout = 0;
8695         }
8696
8697         discovery_cleanup(adapter);
8698
8699         g_slist_free(adapter->connect_list);
8700         adapter->connect_list = NULL;
8701
8702         for (l = adapter->devices; l; l = l->next)
8703                 device_remove(l->data, FALSE);
8704
8705         g_slist_free(adapter->devices);
8706         adapter->devices = NULL;
8707
8708         unload_drivers(adapter);
8709
8710 #ifndef __TIZEN_PATCH__
8711         db = btd_gatt_database_get_db(adapter->database);
8712         gatt_db_unregister(db, adapter->db_id);
8713         adapter->db_id = 0;
8714
8715         btd_gatt_database_destroy(adapter->database);
8716         adapter->database = NULL;
8717 #else
8718         btd_adapter_gatt_server_stop(adapter);
8719 #endif
8720
8721         btd_advertising_manager_destroy(adapter->adv_manager);
8722         adapter->adv_manager = NULL;
8723
8724         g_slist_free(adapter->pin_callbacks);
8725         adapter->pin_callbacks = NULL;
8726
8727         g_slist_free(adapter->msd_callbacks);
8728         adapter->msd_callbacks = NULL;
8729 }
8730
8731 const char *adapter_get_path(struct btd_adapter *adapter)
8732 {
8733         if (!adapter)
8734                 return NULL;
8735
8736         return adapter->path;
8737 }
8738
8739 const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter)
8740 {
8741         return &adapter->bdaddr;
8742 }
8743
8744 static gboolean confirm_name_timeout(gpointer user_data)
8745 {
8746         struct btd_adapter *adapter = user_data;
8747
8748         btd_error(adapter->dev_id, "Confirm name timed out for hci%u",
8749                                                         adapter->dev_id);
8750
8751         adapter->confirm_name_timeout = 0;
8752
8753         mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
8754         adapter->confirm_name_id = 0;
8755
8756         return FALSE;
8757 }
8758
8759 static void confirm_name_complete(uint8_t status, uint16_t length,
8760                                         const void *param, void *user_data)
8761 {
8762         struct btd_adapter *adapter = user_data;
8763
8764         if (status != MGMT_STATUS_SUCCESS) {
8765                 btd_error(adapter->dev_id,
8766                                 "Failed to confirm name for hci%u: %s (0x%02x)",
8767                                 adapter->dev_id, mgmt_errstr(status), status);
8768         }
8769
8770         adapter->confirm_name_id = 0;
8771
8772         g_source_remove(adapter->confirm_name_timeout);
8773         adapter->confirm_name_timeout = 0;
8774
8775         DBG("Confirm name complete for hci%u", adapter->dev_id);
8776 }
8777
8778 static void confirm_name(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
8779                                         uint8_t bdaddr_type, bool name_known)
8780 {
8781         struct mgmt_cp_confirm_name cp;
8782         char addr[18];
8783
8784         ba2str(bdaddr, addr);
8785         DBG("hci%d bdaddr %s name_known %u", adapter->dev_id, addr,
8786                                                                 name_known);
8787
8788         /*
8789          * If the kernel does not answer the confirm name command with
8790          * a command complete or command status in time, this might
8791          * race against another device found event that also requires
8792          * to confirm the name. If there is a pending command, just
8793          * cancel it to be safe here.
8794          */
8795         if (adapter->confirm_name_id > 0) {
8796                 btd_warn(adapter->dev_id,
8797                                 "Found pending confirm name for hci%u",
8798                                                         adapter->dev_id);
8799                 mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
8800         }
8801
8802         if (adapter->confirm_name_timeout > 0) {
8803                 g_source_remove(adapter->confirm_name_timeout);
8804                 adapter->confirm_name_timeout = 0;
8805         }
8806
8807         memset(&cp, 0, sizeof(cp));
8808         bacpy(&cp.addr.bdaddr, bdaddr);
8809         cp.addr.type = bdaddr_type;
8810         cp.name_known = name_known;
8811
8812         adapter->confirm_name_id = mgmt_reply(adapter->mgmt,
8813                                         MGMT_OP_CONFIRM_NAME,
8814                                         adapter->dev_id, sizeof(cp), &cp,
8815                                         confirm_name_complete, adapter, NULL);
8816
8817         if (adapter->confirm_name_id == 0) {
8818                 btd_error(adapter->dev_id, "Failed to confirm name for hci%u",
8819                                                         adapter->dev_id);
8820                 return;
8821         }
8822
8823         /*
8824          * This timeout handling is needed since the kernel is stupid
8825          * and forgets to send a command complete response. However in
8826          * case of failures it does send a command status.
8827          */
8828         adapter->confirm_name_timeout = g_timeout_add_seconds(2,
8829                                                 confirm_name_timeout, adapter);
8830 }
8831
8832 static void adapter_msd_notify(struct btd_adapter *adapter,
8833                                                         struct btd_device *dev,
8834                                                         GSList *msd_list)
8835 {
8836         GSList *cb_l, *cb_next;
8837         GSList *msd_l, *msd_next;
8838
8839         for (cb_l = adapter->msd_callbacks; cb_l != NULL; cb_l = cb_next) {
8840                 btd_msd_cb_t cb = cb_l->data;
8841
8842                 cb_next = g_slist_next(cb_l);
8843
8844                 for (msd_l = msd_list; msd_l != NULL; msd_l = msd_next) {
8845                         const struct eir_msd *msd = msd_l->data;
8846
8847                         msd_next = g_slist_next(msd_l);
8848
8849                         cb(adapter, dev, msd->company, msd->data,
8850                                                                 msd->data_len);
8851                 }
8852         }
8853 }
8854
8855 static bool is_filter_match(GSList *discovery_filter, struct eir_data *eir_data,
8856                                                                 int8_t rssi)
8857 {
8858         GSList *l, *m;
8859         bool got_match = false;
8860
8861         for (l = discovery_filter; l != NULL && got_match != true;
8862                                                         l = g_slist_next(l)) {
8863                 struct watch_client *client = l->data;
8864                 struct discovery_filter *item = client->discovery_filter;
8865
8866                 /*
8867                  * If one of currently running scans is regular scan, then
8868                  * return all devices as matches
8869                  */
8870                 if (!item) {
8871                         got_match = true;
8872                         continue;
8873                 }
8874
8875                 /* if someone started discovery with empty uuids, he wants all
8876                  * devices in given proximity.
8877                  */
8878                 if (!item->uuids)
8879                         got_match = true;
8880                 else {
8881                         for (m = item->uuids; m != NULL && got_match != true;
8882                                                         m = g_slist_next(m)) {
8883                                 /* m->data contains string representation of
8884                                  * uuid.
8885                                  */
8886                                 if (g_slist_find_custom(eir_data->services,
8887                                                         m->data,
8888                                                         g_strcmp) != NULL)
8889                                         got_match = true;
8890                         }
8891                 }
8892
8893                 if (got_match) {
8894                         /* we have service match, check proximity */
8895                         if (item->rssi == DISTANCE_VAL_INVALID ||
8896                             item->rssi <= rssi ||
8897                             item->pathloss == DISTANCE_VAL_INVALID ||
8898                             (eir_data->tx_power != 127 &&
8899                              eir_data->tx_power - rssi <= item->pathloss))
8900                                 return true;
8901
8902                         got_match = false;
8903                 }
8904         }
8905
8906         return got_match;
8907 }
8908
8909 #ifdef __TIZEN_PATCH__
8910 static void update_found_devices(struct btd_adapter *adapter,
8911                                         const bdaddr_t *bdaddr,
8912                                         uint8_t bdaddr_type, int8_t rssi,
8913                                         bool confirm, bool legacy, uint8_t adv_type,
8914                                         const uint8_t *data, uint8_t data_len)
8915 #else
8916 static void update_found_devices(struct btd_adapter *adapter,
8917                                         const bdaddr_t *bdaddr,
8918                                         uint8_t bdaddr_type, int8_t rssi,
8919                                         bool confirm, bool legacy,
8920                                         bool not_connectable,
8921                                         const uint8_t *data, uint8_t data_len)
8922 #endif
8923 {
8924         struct btd_device *dev;
8925         struct eir_data eir_data;
8926         bool name_known, discoverable;
8927         char addr[18];
8928
8929         memset(&eir_data, 0, sizeof(eir_data));
8930         eir_parse(&eir_data, data, data_len);
8931
8932         if (bdaddr_type == BDADDR_BREDR)
8933                 discoverable = true;
8934         else
8935                 discoverable = eir_data.flags & (EIR_LIM_DISC | EIR_GEN_DISC);
8936
8937         ba2str(bdaddr, addr);
8938
8939         dev = btd_adapter_find_device(adapter, bdaddr, bdaddr_type);
8940         if (!dev) {
8941                 /*
8942                  * If no client has requested discovery or the device is
8943                  * not marked as discoverable, then do not create new
8944                  * device objects.
8945                  */
8946 #ifdef __TIZEN_PATCH__
8947                 /*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
8948                         adapter->le_discovery_list, discoverable);*/
8949                 if ((adapter->discovery_list == NULL &&
8950                                 adapter->le_discovery_list == NULL) || !discoverable) {
8951                                 DBG("discovery list is NULL");
8952                         eir_data_free(&eir_data);
8953                         return;
8954                 }
8955 #else
8956                 if (!adapter->discovery_list || !discoverable) {
8957                         eir_data_free(&eir_data);
8958                         return;
8959                 }
8960 #endif
8961
8962                 dev = adapter_create_device(adapter, bdaddr, bdaddr_type);
8963         }
8964
8965         if (!dev) {
8966                 btd_error(adapter->dev_id,
8967                         "Unable to create object for found device %s", addr);
8968                 eir_data_free(&eir_data);
8969                 return;
8970         }
8971
8972 #ifdef __TIZEN_PATCH__
8973         if(device_get_rpa_exist(dev) == true)
8974                 bdaddr_type = BDADDR_LE_RANDOM;
8975 #endif
8976
8977         device_update_last_seen(dev, bdaddr_type);
8978
8979         /*
8980          * FIXME: We need to check for non-zero flags first because
8981          * older kernels send separate adv_ind and scan_rsp. Newer
8982          * kernels send them merged, so once we know which mgmt version
8983          * supports this we can make the non-zero check conditional.
8984          */
8985         if (bdaddr_type != BDADDR_BREDR && eir_data.flags &&
8986                                         !(eir_data.flags & EIR_BREDR_UNSUP))
8987                 device_set_bredr_support(dev);
8988
8989         if (eir_data.name != NULL && eir_data.name_complete)
8990                 device_store_cached_name(dev, eir_data.name);
8991
8992         /*
8993          * If no client has requested discovery, then only update
8994          * already paired devices (skip temporary ones).
8995          */
8996 #ifdef __TIZEN_PATCH__
8997         if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
8998                         adapter->le_discovery_list == NULL) {
8999                 DBG("discovery list is NULL");
9000                 eir_data_free(&eir_data);
9001                 return;
9002         }
9003
9004         device_set_last_addr_type(dev, bdaddr_type);
9005         device_set_ipsp_connected(dev, FALSE);
9006 #else
9007         if (device_is_temporary(dev) && !adapter->discovery_list) {
9008                 eir_data_free(&eir_data);
9009                 return;
9010         }
9011 #endif
9012
9013 #ifdef __TIZEN_PATCH__
9014         if (bdaddr_type == BDADDR_BREDR) {
9015 #endif
9016         if (adapter->filtered_discovery &&
9017             !is_filter_match(adapter->discovery_list, &eir_data, rssi)) {
9018                 eir_data_free(&eir_data);
9019                 return;
9020         }
9021
9022         device_set_legacy(dev, legacy);
9023
9024         if (adapter->filtered_discovery)
9025                 device_set_rssi_with_delta(dev, rssi, 0);
9026         else
9027                 device_set_rssi(dev, rssi);
9028
9029         if (eir_data.tx_power != 127)
9030                 device_set_tx_power(dev, eir_data.tx_power);
9031 #ifdef __TIZEN_PATCH__
9032         }
9033 #endif
9034
9035         if (eir_data.appearance != 0)
9036                 device_set_appearance(dev, eir_data.appearance);
9037
9038         /* Report an unknown name to the kernel even if there is a short name
9039          * known, but still update the name with the known short name. */
9040 #ifdef __TIZEN_PATCH__
9041         if (eir_data.name_complete)
9042                 name_known = device_name_known(dev);
9043         else
9044                 name_known = false;
9045 #else
9046         name_known = device_name_known(dev);
9047 #endif
9048
9049         if (eir_data.name && (eir_data.name_complete || !name_known))
9050                 btd_device_device_set_name(dev, eir_data.name);
9051
9052         if (eir_data.class != 0)
9053                 device_set_class(dev, eir_data.class);
9054
9055         if (eir_data.did_source || eir_data.did_vendor ||
9056                         eir_data.did_product || eir_data.did_version)
9057                 btd_device_set_pnpid(dev, eir_data.did_source,
9058                                                         eir_data.did_vendor,
9059                                                         eir_data.did_product,
9060                                                         eir_data.did_version);
9061
9062         device_add_eir_uuids(dev, eir_data.services);
9063
9064 #ifdef __TIZEN_PATCH__
9065         if (eir_data.flags != 0)
9066                 device_set_remote_feature_flag(dev, eir_data.flags);
9067
9068         if (bdaddr_type == BDADDR_BREDR)
9069                 device_set_manufacturer_info(dev, &eir_data);
9070         else
9071                 device_set_adv_report_info(dev, (void*)data, data_len, adv_type, rssi);
9072 #endif
9073
9074         if (eir_data.msd_list) {
9075                 device_set_manufacturer_data(dev, eir_data.msd_list);
9076                 adapter_msd_notify(adapter, dev, eir_data.msd_list);
9077         }
9078
9079         if (eir_data.sd_list)
9080                 device_set_service_data(dev, eir_data.sd_list);
9081
9082         eir_data_free(&eir_data);
9083
9084         /*
9085          * Only if at least one client has requested discovery, maintain
9086          * list of found devices and name confirming for legacy devices.
9087          * Otherwise, this is an event from passive discovery and we
9088          * should check if the device needs connecting to.
9089          */
9090 #ifdef __TIZEN_PATCH__
9091         if (!adapter->discovery_list && !adapter->le_discovery_list)
9092 #else
9093         if (!adapter->discovery_list)
9094 #endif
9095                 goto connect_le;
9096
9097         if (g_slist_find(adapter->discovery_found, dev))
9098                 return;
9099
9100         if (confirm)
9101                 confirm_name(adapter, bdaddr, bdaddr_type, name_known);
9102
9103         adapter->discovery_found = g_slist_prepend(adapter->discovery_found,
9104                                                                         dev);
9105
9106         return;
9107
9108 connect_le:
9109 #ifndef __TIZEN_PATCH__
9110         /* Ignore non-connectable events */
9111         if (not_connectable)
9112                 return;
9113 #endif
9114
9115         /*
9116          * If we're in the process of stopping passive scanning and
9117          * connecting another (or maybe even the same) LE device just
9118          * ignore this one.
9119          */
9120         if (adapter->connect_le)
9121                 return;
9122
9123         /*
9124          * If kernel background scan is used then the kernel is
9125          * responsible for connecting.
9126          */
9127         if (kernel_conn_control)
9128                 return;
9129
9130         /*
9131          * If this is an LE device that's not connected and part of the
9132          * connect_list stop passive scanning so that a connection
9133          * attempt to it can be made
9134          */
9135         if (bdaddr_type != BDADDR_BREDR && !btd_device_is_connected(dev) &&
9136                                 g_slist_find(adapter->connect_list, dev)) {
9137                 adapter->connect_le = dev;
9138                 stop_passive_scanning(adapter);
9139         }
9140 }
9141
9142 static void device_found_callback(uint16_t index, uint16_t length,
9143                                         const void *param, void *user_data)
9144 {
9145         const struct mgmt_ev_device_found *ev = param;
9146         struct btd_adapter *adapter = user_data;
9147         const uint8_t *eir;
9148         uint16_t eir_len;
9149         uint32_t flags;
9150         bool confirm_name;
9151         bool legacy;
9152         char addr[18];
9153
9154         if (length < sizeof(*ev)) {
9155                 btd_error(adapter->dev_id,
9156                         "Too short device found event (%u bytes)", length);
9157                 return;
9158         }
9159
9160         eir_len = btohs(ev->eir_len);
9161         if (length != sizeof(*ev) + eir_len) {
9162                 btd_error(adapter->dev_id,
9163                                 "Device found event size mismatch (%u != %zu)",
9164                                         length, sizeof(*ev) + eir_len);
9165                 return;
9166         }
9167
9168         if (eir_len == 0)
9169                 eir = NULL;
9170         else
9171                 eir = ev->eir;
9172
9173         flags = btohl(ev->flags);
9174
9175         ba2str(&ev->addr.bdaddr, addr);
9176         DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
9177                         index, addr, ev->rssi, flags, eir_len);
9178
9179         confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
9180         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
9181
9182 #ifdef __TIZEN_PATCH__
9183         update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
9184                                         ev->rssi, confirm_name, legacy, 0,
9185                                         eir, eir_len);
9186 #else
9187         update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
9188                                         ev->rssi, confirm_name, legacy,
9189                                         flags & MGMT_DEV_FOUND_NOT_CONNECTABLE,
9190                                         eir, eir_len);
9191 #endif
9192 }
9193
9194 #ifdef __TIZEN_PATCH__
9195 static void le_device_found_callback(uint16_t index, uint16_t length,
9196                                         const void *param, void *user_data)
9197 {
9198         const struct mgmt_ev_le_device_found *ev = param;
9199         struct btd_adapter *adapter = user_data;
9200         const uint8_t *eir;
9201         uint16_t eir_len;
9202         uint32_t flags;
9203         bool confirm_name;
9204         bool legacy;
9205         char addr[18];
9206
9207         if (length < sizeof(*ev)) {
9208                 error("Too short device found event (%u bytes)", length);
9209                 return;
9210         }
9211
9212         eir_len = btohs(ev->eir_len);
9213         if (length != sizeof(*ev) + eir_len) {
9214                 error("Device found event size mismatch (%u != %zu)",
9215                                         length, sizeof(*ev) + eir_len);
9216                 return;
9217         }
9218
9219         if (eir_len == 0)
9220                 eir = NULL;
9221         else
9222                 eir = ev->eir;
9223
9224         flags = btohl(ev->flags);
9225
9226         ba2str(&ev->addr.bdaddr, addr);
9227         /*DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
9228                         index, addr, ev->rssi, flags, eir_len);*/
9229
9230         confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
9231         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
9232
9233         /*DBG("hci%u addr %s, addr_type %d rssi %d flags 0x%04x eir_len %u confirm_name %d legacy %d, adv_type %02x",
9234                         index, addr, ev->addr.type, ev->rssi, flags, eir_len, confirm_name, legacy, ev->adv_type);*/
9235
9236         update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
9237                                         ev->rssi, confirm_name, legacy, ev->adv_type,
9238                                         eir, eir_len);
9239 }
9240 #endif
9241
9242 struct agent *adapter_get_agent(struct btd_adapter *adapter)
9243 {
9244         return agent_get(NULL);
9245 }
9246
9247 static void adapter_remove_connection(struct btd_adapter *adapter,
9248                                                 struct btd_device *device,
9249                                                 uint8_t bdaddr_type)
9250 {
9251         DBG("");
9252
9253         if (!g_slist_find(adapter->connections, device)) {
9254                 btd_error(adapter->dev_id, "No matching connection for device");
9255                 return;
9256         }
9257
9258         device_remove_connection(device, bdaddr_type);
9259
9260 #ifdef __TIZEN_PATCH__
9261         if (device_is_authenticating(device, bdaddr_type))
9262 #else
9263         if (device_is_authenticating(device))
9264 #endif
9265                 device_cancel_authentication(device, TRUE);
9266
9267         /* If another bearer is still connected */
9268         if (btd_device_is_connected(device))
9269                 return;
9270
9271         adapter->connections = g_slist_remove(adapter->connections, device);
9272
9273         if (device_is_temporary(device) && !device_is_retrying(device)) {
9274                 const char *path = device_get_path(device);
9275
9276                 DBG("Removing temporary device %s", path);
9277 #ifdef __TIZEN_PATCH__
9278                 /* device_is_paired is added incase of tempoary bonded
9279                  * oop file transfer in that device is not bonded it's paired.
9280                  */
9281                 if (!(device_is_bonded(device, bdaddr_type) ||
9282                                 device_is_paired(device, bdaddr_type))) {
9283                         DBG("addr type %d, bonded", bdaddr_type);
9284                         return;
9285                 }
9286
9287                 btd_adapter_unpair_device(adapter, device);
9288 #else
9289                 btd_adapter_remove_device(adapter, device);
9290 #endif
9291         }
9292 }
9293
9294 static void adapter_stop(struct btd_adapter *adapter)
9295 {
9296         /* check pending requests */
9297         reply_pending_requests(adapter);
9298
9299         cancel_passive_scanning(adapter);
9300
9301         while (adapter->set_filter_list) {
9302                 struct watch_client *client;
9303
9304                 client = adapter->set_filter_list->data;
9305
9306                 /* g_dbus_remove_watch will remove the client from the
9307                  * adapter's list and free it using the discovery_destroy
9308                  * function.
9309                  */
9310                 g_dbus_remove_watch(dbus_conn, client->watch);
9311         }
9312
9313         while (adapter->discovery_list) {
9314                 struct watch_client *client;
9315
9316                 client = adapter->discovery_list->data;
9317
9318                 /* g_dbus_remove_watch will remove the client from the
9319                  * adapter's list and free it using the discovery_destroy
9320                  * function.
9321                  */
9322                 g_dbus_remove_watch(dbus_conn, client->watch);
9323         }
9324
9325         adapter->filtered_discovery = false;
9326         adapter->no_scan_restart_delay = false;
9327         g_free(adapter->current_discovery_filter);
9328         adapter->current_discovery_filter = NULL;
9329
9330         adapter->discovering = false;
9331
9332         while (adapter->connections) {
9333                 struct btd_device *device = adapter->connections->data;
9334                 uint8_t addr_type = btd_device_get_bdaddr_type(device);
9335
9336                 adapter_remove_connection(adapter, device, BDADDR_BREDR);
9337                 if (addr_type != BDADDR_BREDR)
9338                         adapter_remove_connection(adapter, device, addr_type);
9339         }
9340
9341         g_dbus_emit_property_changed(dbus_conn, adapter->path,
9342                                         ADAPTER_INTERFACE, "Discovering");
9343 #ifdef __TIZEN_PATCH__
9344         g_dbus_emit_property_changed(dbus_conn, adapter->path,
9345                                                 ADAPTER_INTERFACE, "LEDiscovering");
9346 #endif
9347
9348         if (adapter->dev_class) {
9349                 /* the kernel should reset the class of device when powering
9350                  * down, but it does not. So force it here ... */
9351                 adapter->dev_class = 0;
9352                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
9353                                                 ADAPTER_INTERFACE, "Class");
9354         }
9355
9356 #ifdef __TIZEN_PATCH__
9357         advertiser_cleanup(adapter);
9358 #endif
9359         g_dbus_emit_property_changed(dbus_conn, adapter->path,
9360                                                 ADAPTER_INTERFACE, "Powered");
9361
9362         DBG("adapter %s has been disabled", adapter->path);
9363 }
9364
9365 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
9366 {
9367         adapter_drivers = g_slist_append(adapter_drivers, driver);
9368
9369         if (driver->probe == NULL)
9370                 return 0;
9371
9372         adapter_foreach(probe_driver, driver);
9373
9374         return 0;
9375 }
9376
9377 static void unload_driver(struct btd_adapter *adapter, gpointer data)
9378 {
9379         struct btd_adapter_driver *driver = data;
9380
9381         if (driver->remove)
9382                 driver->remove(adapter);
9383
9384         adapter->drivers = g_slist_remove(adapter->drivers, data);
9385 }
9386
9387 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
9388 {
9389         adapter_drivers = g_slist_remove(adapter_drivers, driver);
9390
9391         adapter_foreach(unload_driver, driver);
9392 }
9393
9394 static void agent_auth_cb(struct agent *agent, DBusError *derr,
9395                                                         void *user_data)
9396 {
9397         struct btd_adapter *adapter = user_data;
9398         struct service_auth *auth = g_queue_pop_head(adapter->auths);
9399
9400         if (!auth) {
9401                 DBG("No pending authorization");
9402                 return;
9403         }
9404
9405         auth->cb(derr, auth->user_data);
9406
9407         if (auth->agent)
9408                 agent_unref(auth->agent);
9409
9410         g_free(auth);
9411
9412         /* Stop processing if queue is empty */
9413         if (g_queue_is_empty(adapter->auths)) {
9414                 if (adapter->auth_idle_id > 0)
9415                         g_source_remove(adapter->auth_idle_id);
9416                 return;
9417         }
9418
9419         if (adapter->auth_idle_id > 0)
9420                 return;
9421
9422         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
9423 }
9424
9425 static gboolean process_auth_queue(gpointer user_data)
9426 {
9427         struct btd_adapter *adapter = user_data;
9428         DBusError err;
9429
9430         adapter->auth_idle_id = 0;
9431
9432         dbus_error_init(&err);
9433         dbus_set_error_const(&err, ERROR_INTERFACE ".Rejected", NULL);
9434
9435         while (!g_queue_is_empty(adapter->auths)) {
9436                 struct service_auth *auth = adapter->auths->head->data;
9437                 struct btd_device *device = auth->device;
9438                 const char *dev_path;
9439
9440                 /* Wait services to be resolved before asking authorization */
9441                 if (auth->svc_id > 0) {
9442 #ifdef __TIZEN_PATCH__
9443                         DBG("Wait services to be resolved before asking authorization");
9444 #endif
9445                         return FALSE;
9446                 }
9447
9448 #ifndef __TIZEN_PATCH__
9449                 if (device_is_trusted(device) == TRUE) {
9450 #else
9451                 if (device_is_trusted(device) == TRUE ||
9452                                 device_is_profile_trusted(device, auth->uuid)) {
9453 #endif
9454                         auth->cb(NULL, auth->user_data);
9455                         goto next;
9456                 }
9457
9458 #ifdef __TIZEN_PATCH__
9459                 /* If Profile is Blocked, Simply reject Authorization*/
9460                 if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
9461                         auth->cb(&err, auth->user_data);
9462                         goto next;
9463                 }
9464 #endif
9465
9466                 /* If agent is set authorization is already ongoing */
9467                 if (auth->agent)
9468                         return FALSE;
9469
9470                 auth->agent = agent_get(NULL);
9471                 if (auth->agent == NULL) {
9472                         btd_warn(adapter->dev_id,
9473                                         "Authentication attempt without agent");
9474                         auth->cb(&err, auth->user_data);
9475                         goto next;
9476                 }
9477
9478                 dev_path = device_get_path(device);
9479
9480                 if (agent_authorize_service(auth->agent, dev_path, auth->uuid,
9481                                         agent_auth_cb, adapter, NULL) < 0) {
9482                         auth->cb(&err, auth->user_data);
9483                         goto next;
9484                 }
9485
9486                 break;
9487
9488 next:
9489                 if (auth->agent)
9490                         agent_unref(auth->agent);
9491
9492                 g_free(auth);
9493
9494                 g_queue_pop_head(adapter->auths);
9495         }
9496
9497         dbus_error_free(&err);
9498
9499         return FALSE;
9500 }
9501
9502 static void svc_complete(struct btd_device *dev, int err, void *user_data)
9503 {
9504         struct service_auth *auth = user_data;
9505         struct btd_adapter *adapter = auth->adapter;
9506
9507         auth->svc_id = 0;
9508
9509         if (adapter->auth_idle_id != 0)
9510                 return;
9511
9512         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
9513 }
9514
9515 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
9516                                         const char *uuid, service_auth_cb cb,
9517                                         void *user_data)
9518 {
9519         struct service_auth *auth;
9520         struct btd_device *device;
9521         static guint id = 0;
9522
9523         device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
9524         if (!device)
9525                 return 0;
9526
9527         if (device_is_disconnecting(device)) {
9528                 DBG("Authorization request while disconnecting");
9529                 return 0;
9530         }
9531
9532         /* Device connected? */
9533         if (!g_slist_find(adapter->connections, device))
9534                 btd_error(adapter->dev_id,
9535                         "Authorization request for non-connected device!?");
9536
9537         auth = g_try_new0(struct service_auth, 1);
9538         if (!auth)
9539                 return 0;
9540
9541         auth->cb = cb;
9542         auth->user_data = user_data;
9543         auth->uuid = uuid;
9544         auth->device = device;
9545         auth->adapter = adapter;
9546         auth->id = ++id;
9547         auth->svc_id = device_wait_for_svc_complete(device, svc_complete, auth);
9548
9549         g_queue_push_tail(adapter->auths, auth);
9550
9551         return auth->id;
9552 }
9553
9554 guint btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
9555                                         const char *uuid, service_auth_cb cb,
9556                                         void *user_data)
9557 {
9558         struct btd_adapter *adapter;
9559         GSList *l;
9560
9561         if (bacmp(src, BDADDR_ANY) != 0) {
9562                 adapter = adapter_find(src);
9563                 if (!adapter)
9564                         return 0;
9565
9566                 return adapter_authorize(adapter, dst, uuid, cb, user_data);
9567         }
9568
9569         for (l = adapters; l != NULL; l = g_slist_next(l)) {
9570                 guint id;
9571
9572                 adapter = l->data;
9573
9574                 id = adapter_authorize(adapter, dst, uuid, cb, user_data);
9575                 if (id != 0)
9576                         return id;
9577         }
9578
9579         return 0;
9580 }
9581
9582 static struct service_auth *find_authorization(guint id)
9583 {
9584         GSList *l;
9585         GList *l2;
9586
9587         for (l = adapters; l != NULL; l = g_slist_next(l)) {
9588                 struct btd_adapter *adapter = l->data;
9589
9590                 for (l2 = adapter->auths->head; l2 != NULL; l2 = l2->next) {
9591                         struct service_auth *auth = l2->data;
9592
9593                         if (auth->id == id)
9594                                 return auth;
9595                 }
9596         }
9597
9598         return NULL;
9599 }
9600
9601 int btd_cancel_authorization(guint id)
9602 {
9603         struct service_auth *auth;
9604
9605         auth = find_authorization(id);
9606         if (auth == NULL)
9607                 return -EPERM;
9608
9609         if (auth->svc_id > 0)
9610                 device_remove_svc_complete_callback(auth->device,
9611                                                                 auth->svc_id);
9612
9613         g_queue_remove(auth->adapter->auths, auth);
9614
9615         if (auth->agent) {
9616                 agent_cancel(auth->agent);
9617                 agent_unref(auth->agent);
9618         }
9619
9620         g_free(auth);
9621
9622         return 0;
9623 }
9624
9625 int btd_adapter_restore_powered(struct btd_adapter *adapter)
9626 {
9627         if (adapter->current_settings & MGMT_SETTING_POWERED)
9628                 return 0;
9629
9630         set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
9631
9632         return 0;
9633 }
9634
9635 void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
9636                                                         btd_adapter_pin_cb_t cb)
9637 {
9638         adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
9639 }
9640
9641 void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
9642                                                         btd_adapter_pin_cb_t cb)
9643 {
9644         adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
9645 }
9646
9647 void btd_adapter_unregister_msd_cb(struct btd_adapter *adapter,
9648                                                         btd_msd_cb_t cb)
9649 {
9650         adapter->msd_callbacks = g_slist_remove(adapter->msd_callbacks, cb);
9651 }
9652
9653 void btd_adapter_register_msd_cb(struct btd_adapter *adapter,
9654                                                         btd_msd_cb_t cb)
9655 {
9656         adapter->msd_callbacks = g_slist_prepend(adapter->msd_callbacks, cb);
9657 }
9658
9659 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
9660                                                         gboolean enable)
9661 {
9662         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
9663                 return -EINVAL;
9664
9665         set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, enable ? 0x01 : 0x00);
9666
9667         return 0;
9668 }
9669
9670 int btd_adapter_read_clock(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
9671                                 int which, int timeout, uint32_t *clock,
9672                                 uint16_t *accuracy)
9673 {
9674         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
9675                 return -EINVAL;
9676
9677         return -ENOSYS;
9678 }
9679
9680 int btd_adapter_remove_bonding(struct btd_adapter *adapter,
9681                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9682 {
9683         struct mgmt_cp_unpair_device cp;
9684
9685         memset(&cp, 0, sizeof(cp));
9686         bacpy(&cp.addr.bdaddr, bdaddr);
9687         cp.addr.type = bdaddr_type;
9688         cp.disconnect = 1;
9689
9690         if (mgmt_send(adapter->mgmt, MGMT_OP_UNPAIR_DEVICE,
9691                                 adapter->dev_id, sizeof(cp), &cp,
9692                                 NULL, NULL, NULL) > 0)
9693                 return 0;
9694
9695         return -EIO;
9696 }
9697
9698 static void pincode_reply_complete(uint8_t status, uint16_t length,
9699                                         const void *param, void *user_data)
9700 {
9701         struct btd_device *device = user_data;
9702
9703         /* If the MGMT_OP_PIN_CODE_REPLY command is acknowledged, move the
9704          * starting time to that point. This give a better sense of time
9705          * evaluating the pincode. */
9706         device_bonding_restart_timer(device);
9707 }
9708
9709 int btd_adapter_pincode_reply(struct btd_adapter *adapter,
9710                                         const bdaddr_t *bdaddr,
9711                                         const char *pin, size_t pin_len)
9712 {
9713         struct btd_device *device;
9714         unsigned int id;
9715         char addr[18];
9716
9717         ba2str(bdaddr, addr);
9718         DBG("hci%u addr %s pinlen %zu", adapter->dev_id, addr, pin_len);
9719
9720         if (pin == NULL) {
9721                 struct mgmt_cp_pin_code_neg_reply cp;
9722
9723                 memset(&cp, 0, sizeof(cp));
9724                 bacpy(&cp.addr.bdaddr, bdaddr);
9725                 cp.addr.type = BDADDR_BREDR;
9726
9727                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
9728                                         adapter->dev_id, sizeof(cp), &cp,
9729                                         NULL, NULL, NULL);
9730         } else {
9731                 struct mgmt_cp_pin_code_reply cp;
9732
9733                 if (pin_len > 16)
9734                         return -EINVAL;
9735
9736                 memset(&cp, 0, sizeof(cp));
9737                 bacpy(&cp.addr.bdaddr, bdaddr);
9738                 cp.addr.type = BDADDR_BREDR;
9739                 cp.pin_len = pin_len;
9740                 memcpy(cp.pin_code, pin, pin_len);
9741
9742                 /* Since a pincode was requested, update the starting time to
9743                  * the point where the pincode is provided. */
9744                 device = btd_adapter_find_device(adapter, bdaddr, BDADDR_BREDR);
9745                 device_bonding_restart_timer(device);
9746
9747                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_REPLY,
9748                                         adapter->dev_id, sizeof(cp), &cp,
9749                                         pincode_reply_complete, device, NULL);
9750         }
9751
9752         if (id == 0)
9753                 return -EIO;
9754
9755         return 0;
9756 }
9757
9758 int btd_adapter_confirm_reply(struct btd_adapter *adapter,
9759                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
9760                                 gboolean success)
9761 {
9762         struct mgmt_cp_user_confirm_reply cp;
9763         uint16_t opcode;
9764         char addr[18];
9765
9766         ba2str(bdaddr, addr);
9767         DBG("hci%u addr %s success %d", adapter->dev_id, addr, success);
9768
9769         if (success)
9770                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
9771         else
9772                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
9773
9774         memset(&cp, 0, sizeof(cp));
9775         bacpy(&cp.addr.bdaddr, bdaddr);
9776         cp.addr.type = bdaddr_type;
9777
9778         if (mgmt_reply(adapter->mgmt, opcode, adapter->dev_id, sizeof(cp), &cp,
9779                                                         NULL, NULL, NULL) > 0)
9780                 return 0;
9781
9782         return -EIO;
9783 }
9784
9785 static void user_confirm_request_callback(uint16_t index, uint16_t length,
9786                                         const void *param, void *user_data)
9787 {
9788         const struct mgmt_ev_user_confirm_request *ev = param;
9789         struct btd_adapter *adapter = user_data;
9790         struct btd_device *device;
9791         char addr[18];
9792         int err;
9793
9794         if (length < sizeof(*ev)) {
9795                 btd_error(adapter->dev_id,
9796                                 "Too small user confirm request event");
9797                 return;
9798         }
9799
9800         ba2str(&ev->addr.bdaddr, addr);
9801         DBG("hci%u %s confirm_hint %u", adapter->dev_id, addr,
9802                                                         ev->confirm_hint);
9803         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
9804                                                                 ev->addr.type);
9805         if (!device) {
9806                 btd_error(adapter->dev_id,
9807                                 "Unable to get device object for %s", addr);
9808                 return;
9809         }
9810
9811 #ifdef __TIZEN_PATCH__
9812         device_set_auth_addr_type(device, ev->addr.type);
9813 #endif
9814
9815         err = device_confirm_passkey(device, btohl(ev->value),
9816                                                         ev->confirm_hint);
9817         if (err < 0) {
9818                 btd_error(adapter->dev_id,
9819                                 "device_confirm_passkey: %s", strerror(-err));
9820                 btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
9821                                                         ev->addr.type, FALSE);
9822         }
9823 }
9824
9825 int btd_adapter_passkey_reply(struct btd_adapter *adapter,
9826                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
9827                                 uint32_t passkey)
9828 {
9829         unsigned int id;
9830         char addr[18];
9831
9832         ba2str(bdaddr, addr);
9833         DBG("hci%u addr %s passkey %06u", adapter->dev_id, addr, passkey);
9834
9835         if (passkey == INVALID_PASSKEY) {
9836                 struct mgmt_cp_user_passkey_neg_reply cp;
9837
9838                 memset(&cp, 0, sizeof(cp));
9839                 bacpy(&cp.addr.bdaddr, bdaddr);
9840                 cp.addr.type = bdaddr_type;
9841
9842                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
9843                                         adapter->dev_id, sizeof(cp), &cp,
9844                                         NULL, NULL, NULL);
9845         } else {
9846                 struct mgmt_cp_user_passkey_reply cp;
9847
9848                 memset(&cp, 0, sizeof(cp));
9849                 bacpy(&cp.addr.bdaddr, bdaddr);
9850                 cp.addr.type = bdaddr_type;
9851                 cp.passkey = htobl(passkey);
9852
9853                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_REPLY,
9854                                         adapter->dev_id, sizeof(cp), &cp,
9855                                         NULL, NULL, NULL);
9856         }
9857
9858         if (id == 0)
9859                 return -EIO;
9860
9861         return 0;
9862 }
9863
9864 static void user_passkey_request_callback(uint16_t index, uint16_t length,
9865                                         const void *param, void *user_data)
9866 {
9867         const struct mgmt_ev_user_passkey_request *ev = param;
9868         struct btd_adapter *adapter = user_data;
9869         struct btd_device *device;
9870         char addr[18];
9871         int err;
9872
9873         if (length < sizeof(*ev)) {
9874                 btd_error(adapter->dev_id, "Too small passkey request event");
9875                 return;
9876         }
9877
9878         ba2str(&ev->addr.bdaddr, addr);
9879         DBG("hci%u %s", index, addr);
9880
9881         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
9882                                                                 ev->addr.type);
9883         if (!device) {
9884                 btd_error(adapter->dev_id,
9885                                 "Unable to get device object for %s", addr);
9886                 return;
9887         }
9888
9889 #ifdef __TIZEN_PATCH__
9890         device_set_auth_addr_type(device, ev->addr.type);
9891 #endif
9892
9893         err = device_request_passkey(device);
9894         if (err < 0) {
9895                 btd_error(adapter->dev_id,
9896                                 "device_request_passkey: %s", strerror(-err));
9897                 btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
9898                                         ev->addr.type, INVALID_PASSKEY);
9899         }
9900 }
9901
9902 static void user_passkey_notify_callback(uint16_t index, uint16_t length,
9903                                         const void *param, void *user_data)
9904 {
9905         const struct mgmt_ev_passkey_notify *ev = param;
9906         struct btd_adapter *adapter = user_data;
9907         struct btd_device *device;
9908         uint32_t passkey;
9909         char addr[18];
9910         int err;
9911
9912         if (length < sizeof(*ev)) {
9913                 btd_error(adapter->dev_id, "Too small passkey notify event");
9914                 return;
9915         }
9916
9917         ba2str(&ev->addr.bdaddr, addr);
9918         DBG("hci%u %s", index, addr);
9919
9920         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
9921                                                                 ev->addr.type);
9922         if (!device) {
9923                 btd_error(adapter->dev_id,
9924                                 "Unable to get device object for %s", addr);
9925                 return;
9926         }
9927
9928         passkey = get_le32(&ev->passkey);
9929
9930         DBG("passkey %06u entered %u", passkey, ev->entered);
9931
9932         err = device_notify_passkey(device, passkey, ev->entered);
9933         if (err < 0)
9934                 btd_error(adapter->dev_id,
9935                                 "device_notify_passkey: %s", strerror(-err));
9936 }
9937
9938 #ifdef __TIZEN_PATCH__
9939 static void rssi_alert_callback(uint16_t index, uint16_t length,
9940                                         const void *param, void *user_data)
9941 {
9942         const struct mgmt_ev_vendor_specific_rssi_alert *ev = param;
9943         struct btd_adapter *adapter = user_data;
9944         char addr[18];
9945         char *bt_addr =  NULL;
9946         int link_type = -1;
9947         int alert_type = -1;
9948         int rssi_dbm = 0;
9949
9950         if (length < sizeof(*ev)) {
9951                 error("Too small rssi alert event");
9952                 return;
9953         }
9954
9955         ba2str(&ev->bdaddr, addr);
9956         DBG("hci%u %s %d", index, addr, ev->link_type);
9957         DBG("RSSI Alert Params [%d %d]", ev->alert_type, ev->rssi_dbm);
9958
9959         bt_addr = (char *)&addr;
9960         link_type = ev->link_type;
9961         alert_type = ev->alert_type;
9962         rssi_dbm = ev->rssi_dbm;
9963         g_dbus_emit_signal(dbus_conn, adapter->path,
9964                         ADAPTER_INTERFACE, "RssiAlert",
9965                         DBUS_TYPE_STRING, &bt_addr,
9966                         DBUS_TYPE_INT32, &link_type,
9967                         DBUS_TYPE_INT32, &alert_type,
9968                         DBUS_TYPE_INT32, &rssi_dbm,
9969                         DBUS_TYPE_INVALID);
9970 }
9971
9972 static void get_raw_rssi_callback(uint16_t index, uint16_t length,
9973                                         const void *param, void *user_data)
9974 {
9975         const struct mgmt_cc_rp_get_raw_rssi *ev = param;
9976         struct btd_adapter *adapter = user_data;
9977         char addr[18];
9978         char *bt_addr =  NULL;
9979         int link_type = -1;
9980         int rssi_dbm = 0;
9981
9982         if (length < sizeof(*ev)) {
9983                 error("Too small raw RSSI event");
9984                 return;
9985         }
9986
9987         ba2str(&ev->bt_address, addr);
9988         DBG("hci%u %s", index, addr);
9989         DBG("Raw RSSI Params [%d %d]", ev->link_type, ev->rssi_dbm);
9990
9991         bt_addr = (char *)&addr;
9992         link_type = ev->link_type;
9993         rssi_dbm = ev->rssi_dbm;
9994
9995         g_dbus_emit_signal(dbus_conn, adapter->path,
9996                         ADAPTER_INTERFACE, "RawRssi",
9997                         DBUS_TYPE_STRING, &bt_addr,
9998                         DBUS_TYPE_INT32, &link_type,
9999                         DBUS_TYPE_INT32, &rssi_dbm,
10000                         DBUS_TYPE_INVALID);
10001 }
10002
10003 static void rssi_enabled_callback(uint16_t index, uint16_t length,
10004                                         const void *param, void *user_data)
10005 {
10006         const struct mgmt_cc_rsp_enable_rssi *ev = param;
10007         struct btd_adapter *adapter = user_data;
10008         char addr[18];
10009         char *bt_addr =  NULL;
10010         int enabled = TRUE;
10011         int link_type = -1;
10012
10013         if (length < sizeof(*ev)) {
10014                 error("Too small rssi enabled event");
10015                 return;
10016         }
10017
10018         ba2str(&ev->bt_address, addr);
10019         DBG("hci%u %s %d", index, addr, ev->link_type);
10020         DBG("RSSI Enabled [%d %d]", ev->le_ext_opcode, ev->status);
10021
10022         bt_addr = (char *)&addr;
10023         link_type = ev->link_type;
10024
10025         g_dbus_emit_signal(dbus_conn, adapter->path,
10026                         ADAPTER_INTERFACE, "RssiEnabled",
10027                         DBUS_TYPE_STRING, &bt_addr,
10028                         DBUS_TYPE_INT32, &link_type,
10029                         DBUS_TYPE_BOOLEAN, &enabled,
10030                         DBUS_TYPE_INVALID);
10031 }
10032
10033 static void rssi_disabled_callback(uint16_t index, uint16_t length,
10034                                         const void *param, void *user_data)
10035 {
10036         const struct mgmt_cc_rp_disable_rssi *ev = param;
10037         struct btd_adapter *adapter = user_data;
10038         char addr[18];
10039         char *bt_addr =  NULL;
10040         int disabled = FALSE;
10041         int link_type = -1;
10042
10043         if (length < sizeof(*ev)) {
10044                 error("Too small RSSI disabled event");
10045                 return;
10046         }
10047
10048         ba2str(&ev->bt_address, addr);
10049         DBG("hci%u %s %d", index, addr, ev->link_type);
10050         DBG("RSSI Disabled Params [%d %d]", ev->le_ext_opcode, ev->status);
10051
10052         bt_addr = (char *)&addr;
10053         link_type = ev->link_type;
10054
10055         g_dbus_emit_signal(dbus_conn, adapter->path,
10056                         ADAPTER_INTERFACE, "RssiEnabled",
10057                         DBUS_TYPE_STRING, &bt_addr,
10058                         DBUS_TYPE_INT32, &link_type,
10059                         DBUS_TYPE_BOOLEAN, &disabled,
10060                         DBUS_TYPE_INVALID);
10061 }
10062
10063 void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver)
10064 {
10065         char *ver;
10066
10067         switch (hci_ver) {
10068         case 0:
10069                 ver = "Bluetooth 1.0b";
10070                 break;
10071         case 1:
10072                 ver = "Bluetooth 1.1";
10073                 break;
10074         case 2:
10075                 ver = "Bluetooth 1.2";
10076                 break;
10077         case 3:
10078                 ver = "Bluetooth 2.0 + EDR";
10079                 break;
10080         case 4:
10081                 ver = "Bluetooth 2.1 + EDR";
10082                 break;
10083         case 5:
10084                 ver = "Bluetooth 3.0 + HS";
10085                 break;
10086         case 6:
10087                 ver = "Bluetooth 4.0";
10088                 break;
10089         case 7:
10090                 ver = "Bluetooth 4.1";
10091                 break;
10092         default:
10093                 ver = "Unknown";
10094                 break;
10095         }
10096
10097         if (adapter->version)
10098                 g_free(adapter->version);
10099
10100         adapter->version = g_strdup(ver);
10101 }
10102
10103 #if 0 // Not used
10104 static void new_local_irk_callback(uint16_t index, uint16_t length,
10105                                         const void *param, void *user_data)
10106 {
10107         const struct mgmt_ev_new_local_irk *ev = param;
10108         struct btd_adapter *adapter = user_data;
10109
10110         if (length < sizeof(*ev)) {
10111                 error("Too small size of Local IRK generated");
10112                 return;
10113         }
10114
10115         DBG("Local IRK generated for hci%u", index);
10116
10117         memset(adapter->local_irk, 0, sizeof(adapter->local_irk));
10118         memcpy(adapter->local_irk, (char *)ev->irk, sizeof(adapter->local_irk));
10119         store_adapter_info(adapter);
10120 }
10121 #endif
10122
10123 static void hardware_error_callback(uint16_t index, uint16_t length,
10124                 const void *param, void *user_data)
10125 {
10126         const struct mgmt_ev_hardware_error *ev = param;
10127         struct btd_adapter *adapter = user_data;
10128
10129         if (length < sizeof(*ev)) {
10130                 error("Too small Hardware error event");
10131                 return;
10132         }
10133
10134         error("Hardware error occurred : %d", ev->error_code);
10135         g_dbus_emit_signal(dbus_conn, adapter->path,
10136                         ADAPTER_INTERFACE, "HardwareError",
10137                         DBUS_TYPE_INVALID);
10138 }
10139
10140 static void tx_timeout_error_callback(uint16_t index, uint16_t length,
10141                 const void *param, void *user_data)
10142 {
10143         struct btd_adapter *adapter = user_data;
10144
10145         error("Tx Timeout error occurred");
10146         g_dbus_emit_signal(dbus_conn, adapter->path,
10147                         ADAPTER_INTERFACE, "TxTimeoutError",
10148                         DBUS_TYPE_INVALID);
10149 }
10150
10151 static void device_name_update_callback(uint16_t index, uint16_t length,
10152                 const void *param, void *user_data)
10153 {
10154         const struct mgmt_ev_device_name_update *ev = param;
10155         struct btd_adapter *adapter = user_data;
10156         struct btd_device *device;
10157         char addr[18];
10158         const uint8_t *eir_name;
10159         struct eir_data eir_data;
10160
10161         if (length < sizeof(*ev)) {
10162                 error("Name update error event");
10163                 return;
10164         }
10165
10166         ba2str(&ev->addr.bdaddr, addr);
10167         DBG("hci%u %s", index, addr);
10168
10169         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
10170                                                                 ev->addr.type);
10171         if (!device) {
10172                 error("Unable to get device object for %s", addr);
10173                 return;
10174         }
10175
10176         if (ev->eir_len == 0)
10177                 return;
10178
10179         eir_name = ev->eir;
10180
10181         memset(&eir_data, 0, sizeof(eir_data));
10182         eir_parse(&eir_data, eir_name, ev->eir_len);
10183
10184         if (eir_data.name)
10185                 btd_device_device_set_name(device, eir_data.name);
10186
10187         eir_data_free(&eir_data);
10188 }
10189
10190 static void multi_adv_state_change_callback(uint16_t index, uint16_t length,
10191                                         const void *param, void *user_data)
10192 {
10193         const struct mgmt_ev_vendor_specific_multi_adv_state_changed *ev = param;
10194
10195         if (length < sizeof(*ev)) {
10196                 error("Too small adv state change event");
10197                 return;
10198         }
10199
10200         DBG("adv id %d, state change reason %d, connection_handle %x",
10201                 ev->adv_instance, ev->state_change_reason, ev->connection_handle);
10202
10203         if ((ev->adv_instance > 0 && ev->adv_instance < adapter_le_get_max_adv_instance()) &&
10204                         ev->state_change_reason == 0)
10205                 adapter_le_enable_multi_adv(TRUE, ev->adv_instance);
10206 }
10207
10208 static void bt_6lowpan_conn_state_change_callback(uint16_t index, uint16_t length,
10209                                         const void *param, void *user_data)
10210 {
10211         const struct mgmt_ev_6lowpan_conn_state_changed *ev = param;
10212         struct btd_adapter *adapter = user_data;
10213         struct btd_device *device;
10214         char addr[18];
10215         gboolean connected = 0;
10216
10217         if (length < sizeof(*ev)) {
10218                 btd_error(adapter->dev_id,
10219                         "Too small device connected event");
10220                 return;
10221         }
10222
10223         ba2str(&ev->addr.bdaddr, addr);
10224
10225         DBG("hci%u device %s", index, addr);
10226
10227         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
10228                                                                 ev->addr.type);
10229         if (!device) {
10230                 btd_error(adapter->dev_id,
10231                         "Unable to get device object for %s", addr);
10232                 return;
10233         }
10234
10235         if (ev->connected)
10236                 connected = TRUE;
10237         else
10238                 connected = FALSE;
10239
10240         device_set_ipsp_connected(device, connected);
10241 }
10242
10243 static void bt_le_data_length_changed_callback(uint16_t index, uint16_t length,
10244                                         const void *param, void *user_data)
10245 {
10246         const struct mgmt_ev_le_data_length_changed *ev = param;
10247         struct btd_adapter *adapter = user_data;
10248         struct btd_device *device;
10249         char addr[18];
10250
10251         if (length < sizeof(*ev)) {
10252                 btd_error(adapter->dev_id,
10253                         "Too small data length changed event");
10254                 return;
10255         }
10256
10257         ba2str(&ev->addr.bdaddr, addr);
10258
10259         DBG("hci%u device %s", index, addr);
10260
10261         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
10262                                                                 ev->addr.type);
10263         if (!device) {
10264                 btd_error(adapter->dev_id,
10265                         "Unable to get device object for %s", addr);
10266                 return;
10267         }
10268
10269         device_le_data_length_changed(device, ev->max_tx_octets, ev->max_tx_time,
10270                 ev->max_rx_octets, ev->max_rx_time);
10271 }
10272
10273 static void le_conn_update_completed_callback(uint16_t index, uint16_t length,
10274                                         const void *param, void *user_data)
10275 {
10276         const struct mgmt_ev_conn_updated *ev = param;
10277         struct btd_adapter *adapter = user_data;
10278         struct btd_device *device;
10279         char addr[18];
10280         GSList *list;
10281
10282         if (length < sizeof(*ev)) {
10283                 error("Too small le conn update completed event");
10284                 return;
10285         }
10286
10287         ba2str(&ev->addr.bdaddr, addr);
10288         list = g_slist_find_custom(adapter->devices, addr,
10289                                                         device_address_cmp);
10290         if (list) {
10291                 device = list->data;
10292                 if (device_get_conn_update_state(device))
10293                         device_set_conn_update_state(device, false);
10294         }
10295 }
10296 #endif
10297
10298 struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
10299                                                 struct btd_adapter *adapter)
10300 {
10301         struct btd_adapter_pin_cb_iter *iter =
10302                                 g_new0(struct btd_adapter_pin_cb_iter, 1);
10303
10304         iter->it = adapter->pin_callbacks;
10305         iter->attempt = 1;
10306
10307         return iter;
10308 }
10309
10310 void btd_adapter_pin_cb_iter_free(struct btd_adapter_pin_cb_iter *iter)
10311 {
10312         g_free(iter);
10313 }
10314
10315 bool btd_adapter_pin_cb_iter_end(struct btd_adapter_pin_cb_iter *iter)
10316 {
10317         return iter->it == NULL && iter->attempt == 0;
10318 }
10319
10320 static ssize_t btd_adapter_pin_cb_iter_next(
10321                                         struct btd_adapter_pin_cb_iter *iter,
10322                                         struct btd_adapter *adapter,
10323                                         struct btd_device *device,
10324                                         char *pin_buf, bool *display)
10325 {
10326         btd_adapter_pin_cb_t cb;
10327         ssize_t ret;
10328
10329         while (iter->it != NULL) {
10330                 cb = iter->it->data;
10331                 ret = cb(adapter, device, pin_buf, display, iter->attempt);
10332                 iter->attempt++;
10333                 if (ret > 0)
10334                         return ret;
10335                 iter->attempt = 1;
10336                 iter->it = g_slist_next(iter->it);
10337         }
10338         iter->attempt = 0;
10339
10340         return 0;
10341 }
10342
10343 static void pin_code_request_callback(uint16_t index, uint16_t length,
10344                                         const void *param, void *user_data)
10345 {
10346         const struct mgmt_ev_pin_code_request *ev = param;
10347         struct btd_adapter *adapter = user_data;
10348         struct btd_device *device;
10349         bool display = false;
10350         char pin[17];
10351         ssize_t pinlen;
10352         char addr[18];
10353         int err;
10354         struct btd_adapter_pin_cb_iter *iter;
10355
10356         if (length < sizeof(*ev)) {
10357                 btd_error(adapter->dev_id, "Too small PIN code request event");
10358                 return;
10359         }
10360
10361         ba2str(&ev->addr.bdaddr, addr);
10362
10363         DBG("hci%u %s", adapter->dev_id, addr);
10364
10365         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
10366                                                                 ev->addr.type);
10367         if (!device) {
10368                 btd_error(adapter->dev_id,
10369                                 "Unable to get device object for %s", addr);
10370                 return;
10371         }
10372
10373         /* Flag the request of a pincode to allow a bonding retry. */
10374         adapter->pincode_requested = true;
10375 #ifdef __TIZEN_PATCH__
10376         btd_device_set_legacy_pairing(device, true);
10377 #endif
10378
10379         memset(pin, 0, sizeof(pin));
10380
10381         iter = device_bonding_iter(device);
10382         if (iter == NULL)
10383                 pinlen = 0;
10384         else
10385                 pinlen = btd_adapter_pin_cb_iter_next(iter, adapter, device,
10386                                                                 pin, &display);
10387
10388         if (pinlen > 0 && (!ev->secure || pinlen == 16)) {
10389                 if (display && device_is_bonding(device, NULL)) {
10390                         err = device_notify_pincode(device, ev->secure, pin);
10391                         if (err < 0) {
10392                                 btd_error(adapter->dev_id,
10393                                                 "device_notify_pin: %s",
10394                                                         strerror(-err));
10395                                 btd_adapter_pincode_reply(adapter,
10396                                                         &ev->addr.bdaddr,
10397                                                         NULL, 0);
10398                         }
10399                 } else {
10400                         btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
10401                                                                 pin, pinlen);
10402                 }
10403                 return;
10404         }
10405
10406         err = device_request_pincode(device, ev->secure);
10407         if (err < 0) {
10408                 btd_error(adapter->dev_id, "device_request_pin: %s",
10409                                                         strerror(-err));
10410                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
10411         }
10412 }
10413
10414 int adapter_cancel_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
10415                                                         uint8_t addr_type)
10416 {
10417         struct mgmt_addr_info cp;
10418         char addr[18];
10419
10420         ba2str(bdaddr, addr);
10421         DBG("hci%u bdaddr %s type %u", adapter->dev_id, addr, addr_type);
10422
10423         memset(&cp, 0, sizeof(cp));
10424         bacpy(&cp.bdaddr, bdaddr);
10425         cp.type = addr_type;
10426
10427         if (mgmt_reply(adapter->mgmt, MGMT_OP_CANCEL_PAIR_DEVICE,
10428                                 adapter->dev_id, sizeof(cp), &cp,
10429                                 NULL, NULL, NULL) > 0)
10430                 return 0;
10431
10432         return -EIO;
10433 }
10434
10435 static void check_oob_bonding_complete(struct btd_adapter *adapter,
10436                                         const bdaddr_t *bdaddr, uint8_t status)
10437 {
10438         if (!adapter->oob_handler || !adapter->oob_handler->bonding_cb)
10439                 return;
10440
10441         if (bacmp(bdaddr, &adapter->oob_handler->remote_addr) != 0)
10442                 return;
10443
10444         adapter->oob_handler->bonding_cb(adapter, bdaddr, status,
10445                                         adapter->oob_handler->user_data);
10446
10447         g_free(adapter->oob_handler);
10448         adapter->oob_handler = NULL;
10449 }
10450
10451 static void bonding_complete(struct btd_adapter *adapter,
10452                                         const bdaddr_t *bdaddr,
10453                                         uint8_t addr_type, uint8_t status)
10454 {
10455         struct btd_device *device;
10456
10457         if (status == 0)
10458                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
10459         else
10460                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
10461
10462         if (device != NULL)
10463                 device_bonding_complete(device, addr_type, status);
10464
10465 #ifdef __TIZEN_PATCH__
10466         //resume_discovery(adapter);
10467         //resume_le_discovery(adapter);
10468 #else
10469         resume_discovery(adapter);
10470 #endif
10471         check_oob_bonding_complete(adapter, bdaddr, status);
10472 }
10473
10474 /* bonding_attempt_complete() handles the end of a "bonding attempt" checking if
10475  * it should begin a new attempt or complete the bonding.
10476  */
10477 static void bonding_attempt_complete(struct btd_adapter *adapter,
10478                                         const bdaddr_t *bdaddr,
10479                                         uint8_t addr_type, uint8_t status)
10480 {
10481         struct btd_device *device;
10482         char addr[18];
10483
10484         ba2str(bdaddr, addr);
10485         DBG("hci%u bdaddr %s type %u status 0x%x", adapter->dev_id, addr,
10486                                                         addr_type, status);
10487
10488         if (status == 0)
10489                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
10490         else
10491                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
10492
10493         if (status == MGMT_STATUS_AUTH_FAILED && adapter->pincode_requested) {
10494                 /* On faliure, issue a bonding_retry if possible. */
10495                 if (device != NULL) {
10496                         if (device_bonding_attempt_retry(device) == 0)
10497                                 return;
10498                 }
10499         }
10500
10501         /* Ignore disconnects during retry. */
10502         if (status == MGMT_STATUS_DISCONNECTED &&
10503                                         device && device_is_retrying(device))
10504                 return;
10505
10506         /* In any other case, finish the bonding. */
10507         bonding_complete(adapter, bdaddr, addr_type, status);
10508 }
10509
10510 struct pair_device_data {
10511         struct btd_adapter *adapter;
10512         bdaddr_t bdaddr;
10513         uint8_t addr_type;
10514 };
10515
10516 static void free_pair_device_data(void *user_data)
10517 {
10518         struct pair_device_data *data = user_data;
10519
10520         g_free(data);
10521 }
10522
10523 static gboolean pair_device_timeout(gpointer user_data)
10524 {
10525         struct pair_device_data *data = user_data;
10526         struct btd_adapter *adapter = data->adapter;
10527
10528         btd_error(adapter->dev_id, "Pair device timed out for hci%u",
10529                                                         adapter->dev_id);
10530
10531         adapter->pair_device_timeout = 0;
10532
10533         adapter_cancel_bonding(adapter, &data->bdaddr, data->addr_type);
10534
10535         return FALSE;
10536 }
10537
10538 static void pair_device_complete(uint8_t status, uint16_t length,
10539                                         const void *param, void *user_data)
10540 {
10541         const struct mgmt_rp_pair_device *rp = param;
10542         struct pair_device_data *data = user_data;
10543         struct btd_adapter *adapter = data->adapter;
10544
10545         DBG("%s (0x%02x)", mgmt_errstr(status), status);
10546
10547         adapter->pair_device_id = 0;
10548
10549         if (adapter->pair_device_timeout > 0) {
10550                 g_source_remove(adapter->pair_device_timeout);
10551                 adapter->pair_device_timeout = 0;
10552         }
10553
10554         /* Workaround for a kernel bug
10555          *
10556          * Broken kernels may reply to device pairing command with command
10557          * status instead of command complete event e.g. if adapter was not
10558          * powered.
10559          */
10560         if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
10561                 btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
10562                                                 mgmt_errstr(status), status);
10563
10564                 bonding_attempt_complete(adapter, &data->bdaddr,
10565                                                 data->addr_type, status);
10566                 return;
10567         }
10568
10569         if (length < sizeof(*rp)) {
10570                 btd_error(adapter->dev_id, "Too small pair device response");
10571                 return;
10572         }
10573
10574         bonding_attempt_complete(adapter, &rp->addr.bdaddr, rp->addr.type,
10575                                                                         status);
10576 }
10577
10578 int adapter_create_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
10579                                         uint8_t addr_type, uint8_t io_cap)
10580 {
10581         if (adapter->pair_device_id > 0) {
10582                 btd_error(adapter->dev_id,
10583                         "Unable pair since another pairing is in progress");
10584                 return -EBUSY;
10585         }
10586
10587 #ifndef __TIZEN_PATCH__
10588         suspend_discovery(adapter);
10589 #endif
10590         return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
10591 }
10592
10593 /* Starts a new bonding attempt in a fresh new bonding_req or a retried one. */
10594 int adapter_bonding_attempt(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
10595                                         uint8_t addr_type, uint8_t io_cap)
10596 {
10597         struct mgmt_cp_pair_device cp;
10598         char addr[18];
10599         struct pair_device_data *data;
10600         unsigned int id;
10601
10602         ba2str(bdaddr, addr);
10603         DBG("hci%u bdaddr %s type %d io_cap 0x%02x",
10604                                 adapter->dev_id, addr, addr_type, io_cap);
10605
10606         /* Reset the pincode_requested flag for a new bonding attempt. */
10607         adapter->pincode_requested = false;
10608
10609         memset(&cp, 0, sizeof(cp));
10610         bacpy(&cp.addr.bdaddr, bdaddr);
10611         cp.addr.type = addr_type;
10612         cp.io_cap = io_cap;
10613
10614         data = g_new0(struct pair_device_data, 1);
10615         data->adapter = adapter;
10616         bacpy(&data->bdaddr, bdaddr);
10617         data->addr_type = addr_type;
10618
10619         id = mgmt_send(adapter->mgmt, MGMT_OP_PAIR_DEVICE,
10620                                 adapter->dev_id, sizeof(cp), &cp,
10621                                 pair_device_complete, data,
10622                                 free_pair_device_data);
10623
10624         if (id == 0) {
10625                 btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
10626                                                         addr, adapter->dev_id);
10627                 free_pair_device_data(data);
10628                 return -EIO;
10629         }
10630
10631         adapter->pair_device_id = id;
10632
10633         /* Due to a bug in the kernel it is possible that a LE pairing
10634          * request never times out. Therefore, add a timer to clean up
10635          * if no response arrives
10636          */
10637         adapter->pair_device_timeout = g_timeout_add_seconds(BONDING_TIMEOUT,
10638                                                 pair_device_timeout, data);
10639
10640         return 0;
10641 }
10642
10643 static void disconnect_notify(struct btd_device *dev, uint8_t reason)
10644 {
10645         GSList *l;
10646
10647         for (l = disconnect_list; l; l = g_slist_next(l)) {
10648                 btd_disconnect_cb disconnect_cb = l->data;
10649                 disconnect_cb(dev, reason);
10650         }
10651 }
10652
10653 static void dev_disconnected(struct btd_adapter *adapter,
10654                                         const struct mgmt_addr_info *addr,
10655                                         uint8_t reason)
10656 {
10657         struct btd_device *device;
10658         char dst[18];
10659
10660         ba2str(&addr->bdaddr, dst);
10661
10662         DBG("Device %s disconnected, reason %u", dst, reason);
10663
10664         device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
10665
10666 #ifdef __TIZEN_PATCH__
10667         if (device) {
10668                 device_set_disconnect_reason(device, reason);
10669                 adapter_remove_connection(adapter, device, addr->type);
10670                 disconnect_notify(device, reason);
10671                 if (device_is_bonded(device, addr->type)) {
10672                         DBG("addr type %d, bonded", addr->type);
10673                         return;
10674                 }
10675         }
10676 #else
10677         if (device) {
10678                 adapter_remove_connection(adapter, device, addr->type);
10679                 disconnect_notify(device, reason);
10680         }
10681 #endif
10682
10683         bonding_attempt_complete(adapter, &addr->bdaddr, addr->type,
10684                                                 MGMT_STATUS_DISCONNECTED);
10685 }
10686
10687 void btd_add_disconnect_cb(btd_disconnect_cb func)
10688 {
10689         disconnect_list = g_slist_append(disconnect_list, func);
10690 }
10691
10692 void btd_remove_disconnect_cb(btd_disconnect_cb func)
10693 {
10694         disconnect_list = g_slist_remove(disconnect_list, func);
10695 }
10696
10697 static void disconnect_complete(uint8_t status, uint16_t length,
10698                                         const void *param, void *user_data)
10699 {
10700         const struct mgmt_rp_disconnect *rp = param;
10701         struct btd_adapter *adapter = user_data;
10702
10703         if (status == MGMT_STATUS_NOT_CONNECTED) {
10704                 btd_warn(adapter->dev_id,
10705                                 "Disconnecting failed: already disconnected");
10706         } else if (status != MGMT_STATUS_SUCCESS) {
10707                 btd_error(adapter->dev_id,
10708                                 "Failed to disconnect device: %s (0x%02x)",
10709                                                 mgmt_errstr(status), status);
10710                 return;
10711         }
10712
10713         if (length < sizeof(*rp)) {
10714                 btd_error(adapter->dev_id,
10715                                 "Too small device disconnect response");
10716                 return;
10717         }
10718
10719 #ifdef __TIZEN_PATCH__
10720         /* Use HCI error code instead of MGMT disconnection reason */
10721         dev_disconnected(adapter, &rp->addr, 0x16);
10722 #else
10723         dev_disconnected(adapter, &rp->addr, MGMT_DEV_DISCONN_LOCAL_HOST);
10724 #endif
10725 }
10726
10727 int btd_adapter_disconnect_device(struct btd_adapter *adapter,
10728                                                 const bdaddr_t *bdaddr,
10729                                                 uint8_t bdaddr_type)
10730
10731 {
10732         struct mgmt_cp_disconnect cp;
10733
10734         memset(&cp, 0, sizeof(cp));
10735         bacpy(&cp.addr.bdaddr, bdaddr);
10736         cp.addr.type = bdaddr_type;
10737
10738         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT,
10739                                 adapter->dev_id, sizeof(cp), &cp,
10740                                 disconnect_complete, adapter, NULL) > 0)
10741                 return 0;
10742
10743         return -EIO;
10744 }
10745
10746 static void auth_failed_callback(uint16_t index, uint16_t length,
10747                                         const void *param, void *user_data)
10748 {
10749         const struct mgmt_ev_auth_failed *ev = param;
10750         struct btd_adapter *adapter = user_data;
10751
10752         if (length < sizeof(*ev)) {
10753                 btd_error(adapter->dev_id, "Too small auth failed mgmt event");
10754                 return;
10755         }
10756
10757         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
10758                                                                 ev->status);
10759 }
10760
10761 static void store_link_key(struct btd_adapter *adapter,
10762                                 struct btd_device *device, const uint8_t *key,
10763                                 uint8_t type, uint8_t pin_length)
10764 {
10765         char adapter_addr[18];
10766         char device_addr[18];
10767         char filename[PATH_MAX];
10768         GKeyFile *key_file;
10769         gsize length = 0;
10770         char key_str[33];
10771         char *str;
10772         int i;
10773
10774         ba2str(btd_adapter_get_address(adapter), adapter_addr);
10775         ba2str(device_get_address(device), device_addr);
10776
10777 #ifdef __TIZEN_PATCH__
10778         if (device_get_rpa_exist(device) == true)
10779                 ba2str(device_get_rpa(device), device_addr);
10780 #endif
10781
10782         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", adapter_addr,
10783                                                                 device_addr);
10784         key_file = g_key_file_new();
10785         g_key_file_load_from_file(key_file, filename, 0, NULL);
10786
10787         for (i = 0; i < 16; i++)
10788                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
10789
10790         g_key_file_set_string(key_file, "LinkKey", "Key", key_str);
10791
10792         g_key_file_set_integer(key_file, "LinkKey", "Type", type);
10793         g_key_file_set_integer(key_file, "LinkKey", "PINLength", pin_length);
10794
10795         create_file(filename, S_IRUSR | S_IWUSR);
10796
10797         str = g_key_file_to_data(key_file, &length, NULL);
10798         g_file_set_contents(filename, str, length, NULL);
10799         g_free(str);
10800
10801         g_key_file_free(key_file);
10802 }
10803
10804 #ifdef __TIZEN_PATCH__
10805 static struct link_key_info *load_link_key(struct btd_adapter *adapter,
10806                                 const char *peer)
10807 {
10808         struct link_key_info *key_info;
10809         GKeyFile *key_file;
10810         char filename[PATH_MAX];
10811         char srcaddr[18];
10812
10813         ba2str(&adapter->bdaddr, srcaddr);
10814
10815         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", srcaddr, peer);
10816
10817         key_file = g_key_file_new();
10818         g_key_file_load_from_file(key_file, filename, 0, NULL);
10819
10820         key_info = get_key_info(key_file, peer);
10821
10822         return key_info;
10823 }
10824 #endif
10825
10826 static void new_link_key_callback(uint16_t index, uint16_t length,
10827                                         const void *param, void *user_data)
10828 {
10829         const struct mgmt_ev_new_link_key *ev = param;
10830         const struct mgmt_addr_info *addr = &ev->key.addr;
10831         struct btd_adapter *adapter = user_data;
10832         struct btd_device *device;
10833         char dst[18];
10834
10835         if (length < sizeof(*ev)) {
10836                 btd_error(adapter->dev_id, "Too small new link key event");
10837                 return;
10838         }
10839
10840         ba2str(&addr->bdaddr, dst);
10841
10842         DBG("hci%u new key for %s type %u pin_len %u store_hint %u",
10843                 adapter->dev_id, dst, ev->key.type, ev->key.pin_len,
10844                 ev->store_hint);
10845
10846         if (ev->key.pin_len > 16) {
10847                 btd_error(adapter->dev_id,
10848                                 "Invalid PIN length (%u) in new_key event",
10849                                                         ev->key.pin_len);
10850                 return;
10851         }
10852
10853         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
10854         if (!device) {
10855                 btd_error(adapter->dev_id,
10856                                 "Unable to get device object for %s", dst);
10857                 return;
10858         }
10859
10860         if (ev->store_hint) {
10861                 const struct mgmt_link_key_info *key = &ev->key;
10862
10863                 store_link_key(adapter, device, key->val, key->type,
10864                                                                 key->pin_len);
10865
10866                 device_set_bonded(device, BDADDR_BREDR);
10867 #if defined(__TIZEN_PATCH__) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
10868         } else {
10869                 DBG("store_hint %d", ev->store_hint);
10870                 btd_device_set_temporary(device, false);
10871         }
10872 #else
10873         }
10874 #endif
10875
10876         /* If BR/EDR linkkey exists in previous, update the linkkey into RPA based folder info */
10877 #ifdef __TIZEN_PATCH__
10878         if (device_get_rpa_exist(device) == true) {
10879                 struct link_key_info *key_info;
10880
10881                 key_info = load_link_key(adapter, dst);
10882                 if (key_info && key_info->type == 0x05) {
10883                         DBG("Replace linkkey!");
10884
10885                         /* #define HCI_LK_AUTH_COMBINATION_P192    0x05
10886                            Replace the linkkey as the orginal one
10887                         */
10888                         store_link_key(adapter, device, key_info->key,
10889                                                         key_info->type, key_info->pin_len);
10890
10891                         /* Delete irk based folder */
10892                         device_remove_stored_folder(device);
10893                 } else {
10894                         DBG("There is no original linkkey or type is not 0x05");
10895                 }
10896         }
10897 #endif
10898
10899         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
10900 }
10901
10902 static void store_longtermkey(const bdaddr_t *local, const bdaddr_t *peer,
10903                                 uint8_t bdaddr_type, const unsigned char *key,
10904                                 uint8_t master, uint8_t authenticated,
10905                                 uint8_t enc_size, uint16_t ediv,
10906                                 uint64_t rand)
10907 {
10908         const char *group = master ? "LongTermKey" : "SlaveLongTermKey";
10909         char adapter_addr[18];
10910         char device_addr[18];
10911         char filename[PATH_MAX];
10912         GKeyFile *key_file;
10913         char key_str[33];
10914         gsize length = 0;
10915         char *str;
10916         int i;
10917
10918         if (master != 0x00 && master != 0x01) {
10919                 error("Unsupported LTK type %u", master);
10920                 return;
10921         }
10922
10923         ba2str(local, adapter_addr);
10924         ba2str(peer, device_addr);
10925
10926         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", adapter_addr,
10927                                                                 device_addr);
10928         key_file = g_key_file_new();
10929         g_key_file_load_from_file(key_file, filename, 0, NULL);
10930
10931         /* Old files may contain this so remove it in case it exists */
10932         g_key_file_remove_key(key_file, "LongTermKey", "Master", NULL);
10933
10934         for (i = 0; i < 16; i++)
10935                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
10936
10937         g_key_file_set_string(key_file, group, "Key", key_str);
10938
10939         g_key_file_set_integer(key_file, group, "Authenticated",
10940                                                         authenticated);
10941         g_key_file_set_integer(key_file, group, "EncSize", enc_size);
10942
10943         g_key_file_set_integer(key_file, group, "EDiv", ediv);
10944         g_key_file_set_uint64(key_file, group, "Rand", rand);
10945
10946         create_file(filename, S_IRUSR | S_IWUSR);
10947
10948         str = g_key_file_to_data(key_file, &length, NULL);
10949         g_file_set_contents(filename, str, length, NULL);
10950         g_free(str);
10951
10952         g_key_file_free(key_file);
10953 }
10954
10955 static void new_long_term_key_callback(uint16_t index, uint16_t length,
10956                                         const void *param, void *user_data)
10957 {
10958         const struct mgmt_ev_new_long_term_key *ev = param;
10959         const struct mgmt_addr_info *addr = &ev->key.addr;
10960         struct btd_adapter *adapter = user_data;
10961         struct btd_device *device;
10962         bool persistent;
10963         char dst[18];
10964
10965         if (length < sizeof(*ev)) {
10966                 btd_error(adapter->dev_id, "Too small long term key event");
10967                 return;
10968         }
10969
10970         ba2str(&addr->bdaddr, dst);
10971
10972         DBG("hci%u new LTK for %s type %u enc_size %u",
10973                 adapter->dev_id, dst, ev->key.type, ev->key.enc_size);
10974
10975         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
10976         if (!device) {
10977                 btd_error(adapter->dev_id,
10978                                 "Unable to get device object for %s", dst);
10979                 return;
10980         }
10981
10982         /*
10983          * Some older kernel versions set store_hint for long term keys
10984          * from resolvable and unresolvable random addresses, but there
10985          * is no point in storing these. Next time around the device
10986          * address will be invalid.
10987          *
10988          * So only for identity addresses (public and static random) use
10989          * the store_hint as an indication if the long term key should
10990          * be persistently stored.
10991          *
10992          */
10993         if (addr->type == BDADDR_LE_RANDOM &&
10994                                 (addr->bdaddr.b[5] & 0xc0) != 0xc0)
10995                 persistent = false;
10996         else
10997                 persistent = !!ev->store_hint;
10998
10999         if (persistent) {
11000                 const struct mgmt_ltk_info *key = &ev->key;
11001                 const bdaddr_t *bdaddr = btd_adapter_get_address(adapter);
11002                 uint16_t ediv;
11003                 uint64_t rand;
11004
11005                 ediv = le16_to_cpu(key->ediv);
11006                 rand = le64_to_cpu(key->rand);
11007
11008 #ifdef __TIZEN_PATCH__
11009                 if (device_get_rpa_exist(device) == true) {
11010                                 store_longtermkey(bdaddr, device_get_rpa(device),
11011                                                         key->addr.type, key->val, key->master,
11012                                                         key->type, key->enc_size, ediv, rand);
11013                 } else {
11014                         store_longtermkey(bdaddr, &key->addr.bdaddr,
11015                                                 key->addr.type, key->val, key->master,
11016                                                 key->type, key->enc_size, ediv, rand);
11017                 }
11018 #else
11019                 store_longtermkey(bdaddr, &key->addr.bdaddr,
11020                                         key->addr.type, key->val, key->master,
11021                                         key->type, key->enc_size, ediv, rand);
11022 #endif
11023
11024                 device_set_bonded(device, addr->type);
11025         }
11026
11027         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
11028 }
11029
11030 static void store_csrk(const bdaddr_t *local, const bdaddr_t *peer,
11031                                 uint8_t bdaddr_type, const unsigned char *key,
11032                                 uint32_t counter, uint8_t type)
11033 {
11034         const char *group;
11035         char adapter_addr[18];
11036         char device_addr[18];
11037         char filename[PATH_MAX];
11038         GKeyFile *key_file;
11039         char key_str[33];
11040         gsize length = 0;
11041         gboolean auth;
11042         char *str;
11043         int i;
11044
11045         switch (type) {
11046         case 0x00:
11047                 group = "LocalSignatureKey";
11048                 auth = FALSE;
11049                 break;
11050         case 0x01:
11051                 group = "RemoteSignatureKey";
11052                 auth = FALSE;
11053                 break;
11054         case 0x02:
11055                 group = "LocalSignatureKey";
11056                 auth = TRUE;
11057                 break;
11058         case 0x03:
11059                 group = "RemoteSignatureKey";
11060                 auth = TRUE;
11061                 break;
11062         default:
11063                 warn("Unsupported CSRK type %u", type);
11064                 return;
11065         }
11066
11067         ba2str(local, adapter_addr);
11068         ba2str(peer, device_addr);
11069
11070         snprintf(filename, sizeof(filename), STORAGEDIR "/%s/%s/info",
11071                                                 adapter_addr, device_addr);
11072
11073         key_file = g_key_file_new();
11074         g_key_file_load_from_file(key_file, filename, 0, NULL);
11075
11076         for (i = 0; i < 16; i++)
11077                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
11078
11079         g_key_file_set_string(key_file, group, "Key", key_str);
11080         g_key_file_set_integer(key_file, group, "Counter", counter);
11081         g_key_file_set_boolean(key_file, group, "Authenticated", auth);
11082
11083         create_file(filename, S_IRUSR | S_IWUSR);
11084
11085         str = g_key_file_to_data(key_file, &length, NULL);
11086         g_file_set_contents(filename, str, length, NULL);
11087         g_free(str);
11088
11089         g_key_file_free(key_file);
11090 }
11091
11092 static void new_csrk_callback(uint16_t index, uint16_t length,
11093                                         const void *param, void *user_data)
11094 {
11095         const struct mgmt_ev_new_csrk *ev = param;
11096         const struct mgmt_addr_info *addr = &ev->key.addr;
11097         const struct mgmt_csrk_info *key = &ev->key;
11098         struct btd_adapter *adapter = user_data;
11099         const bdaddr_t *bdaddr = btd_adapter_get_address(adapter);
11100         struct btd_device *device;
11101         char dst[18];
11102
11103         if (length < sizeof(*ev)) {
11104                 btd_error(adapter->dev_id, "Too small CSRK event");
11105                 return;
11106         }
11107
11108         ba2str(&addr->bdaddr, dst);
11109
11110         DBG("hci%u new CSRK for %s type %u", adapter->dev_id, dst,
11111                                                                 ev->key.type);
11112
11113         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
11114         if (!device) {
11115                 btd_error(adapter->dev_id,
11116                                 "Unable to get device object for %s", dst);
11117                 return;
11118         }
11119
11120         if (!ev->store_hint)
11121                 return;
11122
11123         store_csrk(bdaddr, &key->addr.bdaddr, key->addr.type, key->val, 0,
11124                                                                 key->type);
11125
11126         btd_device_set_temporary(device, false);
11127 }
11128
11129 static void store_irk(struct btd_adapter *adapter, const bdaddr_t *peer,
11130                                 uint8_t bdaddr_type, const unsigned char *key)
11131 {
11132         char adapter_addr[18];
11133         char device_addr[18];
11134         char filename[PATH_MAX];
11135         GKeyFile *key_file;
11136         char *store_data;
11137         char str[33];
11138         size_t length = 0;
11139         int i;
11140
11141         ba2str(&adapter->bdaddr, adapter_addr);
11142         ba2str(peer, device_addr);
11143
11144         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", adapter_addr,
11145                                                                 device_addr);
11146         key_file = g_key_file_new();
11147         g_key_file_load_from_file(key_file, filename, 0, NULL);
11148
11149         for (i = 0; i < 16; i++)
11150                 sprintf(str + (i * 2), "%2.2X", key[i]);
11151
11152         g_key_file_set_string(key_file, "IdentityResolvingKey", "Key", str);
11153
11154         create_file(filename, S_IRUSR | S_IWUSR);
11155
11156         store_data = g_key_file_to_data(key_file, &length, NULL);
11157         g_file_set_contents(filename, store_data, length, NULL);
11158         g_free(store_data);
11159
11160         g_key_file_free(key_file);
11161 }
11162
11163 static void new_irk_callback(uint16_t index, uint16_t length,
11164                                         const void *param, void *user_data)
11165 {
11166         const struct mgmt_ev_new_irk *ev = param;
11167         const struct mgmt_addr_info *addr = &ev->key.addr;
11168         const struct mgmt_irk_info *irk = &ev->key;
11169         struct btd_adapter *adapter = user_data;
11170         struct btd_device *device, *duplicate;
11171         bool persistent;
11172         char dst[18], rpa[18];
11173
11174         if (length < sizeof(*ev)) {
11175                 btd_error(adapter->dev_id, "Too small New IRK event");
11176                 return;
11177         }
11178
11179         ba2str(&addr->bdaddr, dst);
11180         ba2str(&ev->rpa, rpa);
11181
11182         DBG("hci%u new IRK for %s RPA %s", adapter->dev_id, dst, rpa);
11183
11184         if (bacmp(&ev->rpa, BDADDR_ANY)) {
11185 #ifdef __TIZEN_PATCH__
11186                 /*
11187                  * With new RPA, existing device can be found only when bonding is
11188                  * initiated from local side using remote RPA; so first find the device
11189                  * with RPA. If device is not found then find the device with IDA.
11190                  */
11191
11192                 device = btd_adapter_find_device(adapter, &ev->rpa,
11193                                 BDADDR_LE_RANDOM);
11194                 if (device == NULL)
11195                         device = btd_adapter_find_device(adapter, &addr->bdaddr,
11196                                         addr->type);
11197                 if (device == NULL)
11198                         device = btd_adapter_get_device(adapter, &ev->rpa,
11199                                         BDADDR_LE_RANDOM);
11200 #else
11201
11202                 device = btd_adapter_get_device(adapter, &ev->rpa,
11203                                                                 BDADDR_LE_RANDOM);
11204 #endif
11205
11206                 duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
11207                                                                 addr->type);
11208                 if (duplicate == device)
11209                         duplicate = NULL;
11210         } else {
11211                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
11212                                                                 addr->type);
11213                 duplicate = NULL;
11214         }
11215
11216         if (!device) {
11217                 btd_error(adapter->dev_id,
11218                                 "Unable to get device object for %s", dst);
11219                 return;
11220         }
11221
11222 #ifdef __TIZEN_PATCH__
11223         if (bacmp(&ev->rpa, BDADDR_ANY) != 0) {
11224                 device_set_rpa(device, &ev->rpa);
11225
11226                 if (duplicate)
11227                         device_set_rpa(duplicate, &ev->rpa);
11228         }
11229 #endif
11230
11231         device_update_addr(device, &addr->bdaddr, addr->type);
11232
11233 #ifdef __TIZEN_PATCH__
11234         if (duplicate) {
11235                 device_merge_duplicate(device, duplicate);
11236                 device_set_irk_value(duplicate, irk->val);
11237
11238                 /* If BR/EDR linkkey exists in previous, update the linkkey into RPA based folder info */
11239                 if (device_get_rpa_exist(device) == true) {
11240                         struct link_key_info *key_info;
11241
11242                         key_info = load_link_key(adapter, dst);
11243                         if (key_info && key_info->type == 0x05) {
11244                                 DBG("Add linkkey of BR/EDR");
11245
11246                                 /* #define HCI_LK_AUTH_COMBINATION_P192    0x05  */
11247                                 store_link_key(adapter, device, key_info->key,
11248                                                                 key_info->type, key_info->pin_len);
11249
11250                                 /* Delete IDA based folder */
11251                                 device_remove_stored_folder(duplicate);
11252                         } else {
11253                                 DBG("There is no original linkkey or type is not 0x05");
11254                         }
11255                 }
11256         }
11257 #else
11258         if (duplicate)
11259                 device_merge_duplicate(device, duplicate);
11260 #endif
11261
11262         persistent = !!ev->store_hint;
11263         if (!persistent)
11264                 return;
11265
11266 #ifdef __TIZEN_PATCH__
11267         if (bacmp(&ev->rpa, BDADDR_ANY) != 0)
11268                 store_irk(adapter, device_get_rpa(device), addr->type, irk->val);
11269         else
11270                 store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
11271
11272         device_set_irk_value(device, irk->val);
11273 #else
11274         store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
11275 #endif
11276
11277         btd_device_set_temporary(device, false);
11278
11279 #ifdef __TIZEN_PATCH__
11280         btd_adapter_set_dev_rpa_res_support(adapter, device);
11281 #endif
11282 }
11283
11284 static void store_conn_param(struct btd_adapter *adapter, const bdaddr_t *peer,
11285                                 uint8_t bdaddr_type, uint16_t min_interval,
11286                                 uint16_t max_interval, uint16_t latency,
11287                                 uint16_t timeout)
11288 {
11289         char adapter_addr[18];
11290         char device_addr[18];
11291         char filename[PATH_MAX];
11292         GKeyFile *key_file;
11293         char *store_data;
11294         size_t length = 0;
11295
11296         ba2str(&adapter->bdaddr, adapter_addr);
11297         ba2str(peer, device_addr);
11298
11299         DBG("");
11300
11301         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", adapter_addr,
11302                                                                 device_addr);
11303         key_file = g_key_file_new();
11304         g_key_file_load_from_file(key_file, filename, 0, NULL);
11305
11306         g_key_file_set_integer(key_file, "ConnectionParameters",
11307                                                 "MinInterval", min_interval);
11308         g_key_file_set_integer(key_file, "ConnectionParameters",
11309                                                 "MaxInterval", max_interval);
11310         g_key_file_set_integer(key_file, "ConnectionParameters",
11311                                                 "Latency", latency);
11312         g_key_file_set_integer(key_file, "ConnectionParameters",
11313                                                 "Timeout", timeout);
11314
11315         create_file(filename, S_IRUSR | S_IWUSR);
11316
11317         store_data = g_key_file_to_data(key_file, &length, NULL);
11318         g_file_set_contents(filename, store_data, length, NULL);
11319         g_free(store_data);
11320
11321         g_key_file_free(key_file);
11322 }
11323
11324 static void new_conn_param(uint16_t index, uint16_t length,
11325                                         const void *param, void *user_data)
11326 {
11327         const struct mgmt_ev_new_conn_param *ev = param;
11328         struct btd_adapter *adapter = user_data;
11329         uint16_t min, max, latency, timeout;
11330         struct btd_device *dev;
11331         char dst[18];
11332
11333
11334         if (length < sizeof(*ev)) {
11335                 btd_error(adapter->dev_id,
11336                                 "Too small New Connection Parameter event");
11337                 return;
11338         }
11339
11340         ba2str(&ev->addr.bdaddr, dst);
11341
11342         min = btohs(ev->min_interval);
11343         max = btohs(ev->max_interval);
11344         latency = btohs(ev->latency);
11345         timeout = btohs(ev->timeout);
11346
11347         DBG("hci%u %s (%u) min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
11348                 adapter->dev_id, dst, ev->addr.type, min, max, latency, timeout);
11349
11350         dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
11351         if (!dev) {
11352                 btd_error(adapter->dev_id,
11353                                 "Unable to get device object for %s", dst);
11354                 return;
11355         }
11356
11357         if (!ev->store_hint)
11358                 return;
11359
11360         store_conn_param(adapter, &ev->addr.bdaddr, ev->addr.type,
11361                                         ev->min_interval, ev->max_interval,
11362                                         ev->latency, ev->timeout);
11363 }
11364
11365 int adapter_set_io_capability(struct btd_adapter *adapter, uint8_t io_cap)
11366 {
11367         struct mgmt_cp_set_io_capability cp;
11368
11369         memset(&cp, 0, sizeof(cp));
11370         cp.io_capability = io_cap;
11371
11372         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IO_CAPABILITY,
11373                                 adapter->dev_id, sizeof(cp), &cp,
11374                                 NULL, NULL, NULL) > 0)
11375                 return 0;
11376
11377         return -EIO;
11378 }
11379
11380 int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
11381                                         const bdaddr_t *bdaddr,
11382                                         uint8_t *hash, uint8_t *randomizer)
11383 {
11384         struct mgmt_cp_add_remote_oob_data cp;
11385         char addr[18];
11386
11387         ba2str(bdaddr, addr);
11388         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
11389
11390         memset(&cp, 0, sizeof(cp));
11391         bacpy(&cp.addr.bdaddr, bdaddr);
11392         memcpy(cp.hash192, hash, 16);
11393
11394         if (randomizer)
11395                 memcpy(cp.rand192, randomizer, 16);
11396
11397         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
11398                                 adapter->dev_id, sizeof(cp), &cp,
11399                                 NULL, NULL, NULL) > 0)
11400                 return 0;
11401
11402         return -EIO;
11403 }
11404
11405 int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
11406                                                         const bdaddr_t *bdaddr)
11407 {
11408         struct mgmt_cp_remove_remote_oob_data cp;
11409         char addr[18];
11410
11411         ba2str(bdaddr, addr);
11412         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
11413
11414         memset(&cp, 0, sizeof(cp));
11415         bacpy(&cp.addr.bdaddr, bdaddr);
11416
11417         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
11418                                 adapter->dev_id, sizeof(cp), &cp,
11419                                 NULL, NULL, NULL) > 0)
11420                 return 0;
11421
11422         return -EIO;
11423 }
11424
11425 bool btd_adapter_ssp_enabled(struct btd_adapter *adapter)
11426 {
11427         if (adapter->current_settings & MGMT_SETTING_SSP)
11428                 return true;
11429
11430         return false;
11431 }
11432
11433 void btd_adapter_set_oob_handler(struct btd_adapter *adapter,
11434                                                 struct oob_handler *handler)
11435 {
11436         adapter->oob_handler = handler;
11437 }
11438
11439 gboolean btd_adapter_check_oob_handler(struct btd_adapter *adapter)
11440 {
11441         return adapter->oob_handler != NULL;
11442 }
11443
11444 static void read_local_oob_data_complete(uint8_t status, uint16_t length,
11445                                         const void *param, void *user_data)
11446 {
11447         const struct mgmt_rp_read_local_oob_data *rp = param;
11448         struct btd_adapter *adapter = user_data;
11449         const uint8_t *hash, *randomizer;
11450
11451         if (status != MGMT_STATUS_SUCCESS) {
11452                 btd_error(adapter->dev_id,
11453                                 "Read local OOB data failed: %s (0x%02x)",
11454                                                 mgmt_errstr(status), status);
11455                 hash = NULL;
11456                 randomizer = NULL;
11457 #ifdef __TIZEN_PATCH__
11458         } else if (length < 32) {
11459 #else
11460         } else if (length < sizeof(*rp)) {
11461 #endif
11462                 btd_error(adapter->dev_id,
11463                                 "Too small read local OOB data response");
11464                 return;
11465         } else {
11466                 hash = rp->hash192;
11467                 randomizer = rp->rand192;
11468         }
11469
11470         if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
11471                 return;
11472
11473         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
11474                                         adapter->oob_handler->user_data);
11475
11476         g_free(adapter->oob_handler);
11477         adapter->oob_handler = NULL;
11478 }
11479
11480 int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
11481 {
11482         DBG("hci%u", adapter->dev_id);
11483
11484         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_DATA,
11485                         adapter->dev_id, 0, NULL, read_local_oob_data_complete,
11486                         adapter, NULL) > 0)
11487                 return 0;
11488
11489         return -EIO;
11490 }
11491
11492 void btd_adapter_for_each_device(struct btd_adapter *adapter,
11493                         void (*cb)(struct btd_device *device, void *data),
11494                         void *data)
11495 {
11496         g_slist_foreach(adapter->devices, (GFunc) cb, data);
11497 }
11498
11499 static int adapter_cmp(gconstpointer a, gconstpointer b)
11500 {
11501         struct btd_adapter *adapter = (struct btd_adapter *) a;
11502         const bdaddr_t *bdaddr = b;
11503
11504         return bacmp(&adapter->bdaddr, bdaddr);
11505 }
11506
11507 static int adapter_id_cmp(gconstpointer a, gconstpointer b)
11508 {
11509         struct btd_adapter *adapter = (struct btd_adapter *) a;
11510         uint16_t id = GPOINTER_TO_UINT(b);
11511
11512         return adapter->dev_id == id ? 0 : -1;
11513 }
11514
11515 struct btd_adapter *adapter_find(const bdaddr_t *sba)
11516 {
11517         GSList *match;
11518
11519         match = g_slist_find_custom(adapters, sba, adapter_cmp);
11520         if (!match)
11521                 return NULL;
11522
11523         return match->data;
11524 }
11525
11526 struct btd_adapter *adapter_find_by_id(int id)
11527 {
11528         GSList *match;
11529
11530         match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
11531                                                         adapter_id_cmp);
11532         if (!match)
11533                 return NULL;
11534
11535         return match->data;
11536 }
11537
11538 void adapter_foreach(adapter_cb func, gpointer user_data)
11539 {
11540         g_slist_foreach(adapters, (GFunc) func, user_data);
11541 }
11542
11543 static int set_did(struct btd_adapter *adapter, uint16_t vendor,
11544                         uint16_t product, uint16_t version, uint16_t source)
11545 {
11546         struct mgmt_cp_set_device_id cp;
11547
11548         DBG("hci%u source %x vendor %x product %x version %x",
11549                         adapter->dev_id, source, vendor, product, version);
11550
11551         memset(&cp, 0, sizeof(cp));
11552
11553         cp.source = htobs(source);
11554         cp.vendor = htobs(vendor);
11555         cp.product = htobs(product);
11556         cp.version = htobs(version);
11557
11558         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_ID,
11559                                 adapter->dev_id, sizeof(cp), &cp,
11560                                 NULL, NULL, NULL) > 0)
11561                 return 0;
11562
11563         return -EIO;
11564 }
11565
11566 static void services_modified(struct gatt_db_attribute *attrib, void *user_data)
11567 {
11568         struct btd_adapter *adapter = user_data;
11569
11570         g_dbus_emit_property_changed(dbus_conn, adapter->path,
11571                                                 ADAPTER_INTERFACE, "UUIDs");
11572 }
11573
11574 static int adapter_register(struct btd_adapter *adapter)
11575 {
11576         struct agent *agent;
11577         struct gatt_db *db;
11578
11579         if (powering_down)
11580                 return -EBUSY;
11581
11582         adapter->path = g_strdup_printf("/org/bluez/hci%d", adapter->dev_id);
11583
11584         if (!g_dbus_register_interface(dbus_conn,
11585                                         adapter->path, ADAPTER_INTERFACE,
11586 #ifdef __TIZEN_PATCH__
11587                                         adapter_methods, adapter_signals,
11588 #else
11589                                         adapter_methods, NULL,
11590 #endif
11591                                         adapter_properties, adapter,
11592                                         adapter_free)) {
11593                 btd_error(adapter->dev_id,
11594                                 "Adapter interface init failed on path %s",
11595                                                         adapter->path);
11596                 g_free(adapter->path);
11597                 adapter->path = NULL;
11598                 return -EINVAL;
11599         }
11600
11601         if (adapters == NULL)
11602                 adapter->is_default = true;
11603
11604         adapters = g_slist_append(adapters, adapter);
11605
11606         agent = agent_get(NULL);
11607         if (agent) {
11608                 uint8_t io_cap = agent_get_io_capability(agent);
11609                 adapter_set_io_capability(adapter, io_cap);
11610                 agent_unref(agent);
11611         }
11612
11613         adapter->database = btd_gatt_database_new(adapter);
11614         if (!adapter->database) {
11615                 btd_error(adapter->dev_id,
11616                                 "Failed to create GATT database for adapter");
11617                 adapters = g_slist_remove(adapters, adapter);
11618                 return -EINVAL;
11619         }
11620
11621         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
11622                 /* Don't start advertising managers on non-LE controllers. */
11623                 if (adapter->supported_settings & MGMT_SETTING_LE) {
11624                         adapter->adv_manager =
11625                                         btd_advertising_manager_new(adapter);
11626                 } else {
11627                         btd_info(adapter->dev_id,
11628                                 "LEAdvertisingManager skipped, LE unavailable");
11629                 }
11630         }
11631
11632         db = btd_gatt_database_get_db(adapter->database);
11633         adapter->db_id = gatt_db_register(db, services_modified,
11634                                                         services_modified,
11635                                                         adapter, NULL);
11636
11637         load_config(adapter);
11638         fix_storage(adapter);
11639         load_drivers(adapter);
11640         btd_profile_foreach(probe_profile, adapter);
11641         clear_blocked(adapter);
11642         load_devices(adapter);
11643
11644 #ifdef __TIZEN_PATCH__
11645         if (adapter->le_privacy_enabled &&
11646                 (adapter->supported_settings & MGMT_SETTING_PRIVACY))
11647                                 set_privacy(adapter, true);
11648         else
11649                 DBG("LE privacy feature not configured or supported");
11650 #endif
11651
11652         /* retrieve the active connections: address the scenario where
11653          * the are active connections before the daemon've started */
11654         if (adapter->current_settings & MGMT_SETTING_POWERED)
11655                 load_connections(adapter);
11656
11657         adapter->initialized = TRUE;
11658
11659         if (main_opts.did_source) {
11660                 /* DeviceID record is added by sdpd-server before any other
11661                  * record is registered. */
11662                 adapter_service_insert(adapter, sdp_record_find(0x10000));
11663                 set_did(adapter, main_opts.did_vendor, main_opts.did_product,
11664                                 main_opts.did_version, main_opts.did_source);
11665         }
11666
11667         DBG("Adapter %s registered", adapter->path);
11668
11669         return 0;
11670 }
11671
11672 static int adapter_unregister(struct btd_adapter *adapter)
11673 {
11674         DBG("Unregister path: %s", adapter->path);
11675
11676         adapters = g_slist_remove(adapters, adapter);
11677
11678         if (adapter->is_default && adapters != NULL) {
11679                 struct btd_adapter *new_default;
11680
11681                 new_default = adapter_find_by_id(hci_get_route(NULL));
11682                 if (new_default == NULL)
11683                         new_default = adapters->data;
11684
11685                 new_default->is_default = true;
11686         }
11687
11688         adapter_list = g_list_remove(adapter_list, adapter);
11689
11690         adapter_remove(adapter);
11691         btd_adapter_unref(adapter);
11692
11693         return 0;
11694 }
11695
11696 static void disconnected_callback(uint16_t index, uint16_t length,
11697                                         const void *param, void *user_data)
11698 {
11699         const struct mgmt_ev_device_disconnected *ev = param;
11700         struct btd_adapter *adapter = user_data;
11701         uint8_t reason;
11702
11703         if (length < sizeof(struct mgmt_addr_info)) {
11704                 btd_error(adapter->dev_id,
11705                                 "Too small device disconnected event");
11706                 return;
11707         }
11708
11709         if (length < sizeof(*ev))
11710                 reason = MGMT_DEV_DISCONN_UNKNOWN;
11711         else
11712                 reason = ev->reason;
11713
11714         dev_disconnected(adapter, &ev->addr, reason);
11715 }
11716
11717 static void connected_callback(uint16_t index, uint16_t length,
11718                                         const void *param, void *user_data)
11719 {
11720         const struct mgmt_ev_device_connected *ev = param;
11721         struct btd_adapter *adapter = user_data;
11722         struct btd_device *device;
11723         struct eir_data eir_data;
11724         uint16_t eir_len;
11725         char addr[18];
11726         bool name_known;
11727
11728         if (length < sizeof(*ev)) {
11729                 btd_error(adapter->dev_id, "Too small device connected event");
11730                 return;
11731         }
11732
11733         eir_len = btohs(ev->eir_len);
11734         if (length < sizeof(*ev) + eir_len) {
11735                 btd_error(adapter->dev_id, "Too small device connected event");
11736                 return;
11737         }
11738
11739         ba2str(&ev->addr.bdaddr, addr);
11740
11741         DBG("hci%u device %s connected eir_len %u", index, addr, eir_len);
11742
11743         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
11744                                                                 ev->addr.type);
11745         if (!device) {
11746                 btd_error(adapter->dev_id,
11747                                 "Unable to get device object for %s", addr);
11748                 return;
11749         }
11750
11751         memset(&eir_data, 0, sizeof(eir_data));
11752         if (eir_len > 0)
11753                 eir_parse(&eir_data, ev->eir, eir_len);
11754
11755         if (eir_data.class != 0)
11756                 device_set_class(device, eir_data.class);
11757
11758         adapter_add_connection(adapter, device, ev->addr.type);
11759
11760         name_known = device_name_known(device);
11761
11762         if (eir_data.name && (eir_data.name_complete || !name_known)) {
11763                 device_store_cached_name(device, eir_data.name);
11764                 btd_device_device_set_name(device, eir_data.name);
11765         }
11766
11767         if (eir_data.msd_list)
11768                 adapter_msd_notify(adapter, device, eir_data.msd_list);
11769
11770         eir_data_free(&eir_data);
11771 }
11772
11773 static void device_blocked_callback(uint16_t index, uint16_t length,
11774                                         const void *param, void *user_data)
11775 {
11776         const struct mgmt_ev_device_blocked *ev = param;
11777         struct btd_adapter *adapter = user_data;
11778         struct btd_device *device;
11779         char addr[18];
11780
11781         if (length < sizeof(*ev)) {
11782                 btd_error(adapter->dev_id, "Too small device blocked event");
11783                 return;
11784         }
11785
11786         ba2str(&ev->addr.bdaddr, addr);
11787         DBG("hci%u %s blocked", index, addr);
11788
11789         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
11790                                                                 ev->addr.type);
11791         if (device)
11792                 device_block(device, TRUE);
11793 }
11794
11795 static void device_unblocked_callback(uint16_t index, uint16_t length,
11796                                         const void *param, void *user_data)
11797 {
11798         const struct mgmt_ev_device_unblocked *ev = param;
11799         struct btd_adapter *adapter = user_data;
11800         struct btd_device *device;
11801         char addr[18];
11802
11803         if (length < sizeof(*ev)) {
11804                 btd_error(adapter->dev_id, "Too small device unblocked event");
11805                 return;
11806         }
11807
11808         ba2str(&ev->addr.bdaddr, addr);
11809         DBG("hci%u %s unblocked", index, addr);
11810
11811         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
11812                                                                 ev->addr.type);
11813         if (device)
11814                 device_unblock(device, FALSE, TRUE);
11815 }
11816
11817 static void conn_fail_notify(struct btd_device *dev, uint8_t status)
11818 {
11819         GSList *l;
11820
11821         for (l = conn_fail_list; l; l = g_slist_next(l)) {
11822                 btd_conn_fail_cb conn_fail_cb = l->data;
11823                 conn_fail_cb(dev, status);
11824         }
11825 }
11826
11827 void btd_add_conn_fail_cb(btd_conn_fail_cb func)
11828 {
11829         conn_fail_list = g_slist_append(conn_fail_list, func);
11830 }
11831
11832 void btd_remove_conn_fail_cb(btd_conn_fail_cb func)
11833 {
11834         conn_fail_list = g_slist_remove(conn_fail_list, func);
11835 }
11836
11837 static void connect_failed_callback(uint16_t index, uint16_t length,
11838                                         const void *param, void *user_data)
11839 {
11840         const struct mgmt_ev_connect_failed *ev = param;
11841         struct btd_adapter *adapter = user_data;
11842         struct btd_device *device;
11843         char addr[18];
11844
11845         if (length < sizeof(*ev)) {
11846                 btd_error(adapter->dev_id, "Too small connect failed event");
11847                 return;
11848         }
11849
11850         ba2str(&ev->addr.bdaddr, addr);
11851
11852         DBG("hci%u %s status %u", index, addr, ev->status);
11853
11854         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
11855                                                                 ev->addr.type);
11856         if (device) {
11857                 conn_fail_notify(device, ev->status);
11858
11859                 /* If the device is in a bonding process cancel any auth request
11860                  * sent to the agent before proceeding, but keep the bonding
11861                  * request structure. */
11862                 if (device_is_bonding(device, NULL))
11863                         device_cancel_authentication(device, FALSE);
11864         }
11865
11866         /* In the case of security mode 3 devices */
11867         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
11868                                                                 ev->status);
11869
11870         /* If the device is scheduled to retry the bonding wait until the retry
11871          * happens. In other case, proceed with cancel the bondig.
11872          */
11873         if (device && device_is_bonding(device, NULL)
11874                                         && !device_is_retrying(device)) {
11875                 device_cancel_authentication(device, TRUE);
11876                 device_bonding_failed(device, ev->status);
11877         }
11878
11879 #ifndef __TIZEN_PATCH__
11880         /* In the case the bonding was canceled or did exists, remove the device
11881          * when it is temporary. */
11882         if (device && !device_is_bonding(device, NULL)
11883                                                 && device_is_temporary(device))
11884                 btd_adapter_remove_device(adapter, device);
11885 #endif
11886 }
11887
11888 static void remove_keys(struct btd_adapter *adapter,
11889                                         struct btd_device *device, uint8_t type)
11890 {
11891         char adapter_addr[18];
11892         char device_addr[18];
11893         char filename[PATH_MAX];
11894         GKeyFile *key_file;
11895         gsize length = 0;
11896         char *str;
11897
11898         ba2str(btd_adapter_get_address(adapter), adapter_addr);
11899         ba2str(device_get_address(device), device_addr);
11900
11901 #ifdef __TIZEN_PATCH__
11902         if (device_get_rpa_exist(device) == true)
11903                 ba2str(device_get_rpa(device), device_addr);
11904 #endif
11905
11906         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", adapter_addr,
11907                                                                 device_addr);
11908         key_file = g_key_file_new();
11909         g_key_file_load_from_file(key_file, filename, 0, NULL);
11910
11911         if (type == BDADDR_BREDR) {
11912                 g_key_file_remove_group(key_file, "LinkKey", NULL);
11913         } else {
11914                 g_key_file_remove_group(key_file, "LongTermKey", NULL);
11915                 g_key_file_remove_group(key_file, "LocalSignatureKey", NULL);
11916                 g_key_file_remove_group(key_file, "RemoteSignatureKey", NULL);
11917                 g_key_file_remove_group(key_file, "IdentityResolvingKey", NULL);
11918         }
11919
11920         str = g_key_file_to_data(key_file, &length, NULL);
11921         g_file_set_contents(filename, str, length, NULL);
11922         g_free(str);
11923
11924         g_key_file_free(key_file);
11925 }
11926
11927 static void unpaired_callback(uint16_t index, uint16_t length,
11928                                         const void *param, void *user_data)
11929 {
11930         const struct mgmt_ev_device_unpaired *ev = param;
11931         struct btd_adapter *adapter = user_data;
11932         struct btd_device *device;
11933         char addr[18];
11934
11935         if (length < sizeof(*ev)) {
11936                 btd_error(adapter->dev_id, "Too small device unpaired event");
11937                 return;
11938         }
11939
11940         ba2str(&ev->addr.bdaddr, addr);
11941
11942         DBG("hci%u addr %s", index, addr);
11943
11944         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
11945                                                                 ev->addr.type);
11946         if (!device) {
11947                 btd_warn(adapter->dev_id,
11948                         "No device object for unpaired device %s", addr);
11949                 return;
11950         }
11951
11952         remove_keys(adapter, device, ev->addr.type);
11953         device_set_unpaired(device, ev->addr.type);
11954 }
11955
11956 #ifdef __TIZEN_PATCH__
11957 static void set_privacy_complete(uint8_t status, uint16_t length,
11958         const void *param, void *user_data)
11959 {
11960         struct btd_adapter *adapter = user_data;
11961
11962         if (status != MGMT_STATUS_SUCCESS)
11963                 error("Setting privacy failed for hci%u: %s (0x%02x)",
11964                         adapter->dev_id, mgmt_errstr(status), status);
11965         else
11966                 DBG("Privacy feature is set/unset successfully for hci%u",
11967                         adapter->dev_id);
11968 }
11969
11970 static bool set_privacy(struct btd_adapter *adapter, bool privacy)
11971 {
11972         struct mgmt_cp_set_privacy cp;
11973         static const char testblock[MGMT_IRK_SIZE];
11974
11975         memset(&cp, 0, sizeof(cp));
11976
11977         if (privacy) {
11978                 if (!memcmp(adapter->local_irk, testblock, MGMT_IRK_SIZE)) {
11979                         cp.privacy = GEN_IRK_THEN_ENABLE_PRIVACY;
11980                         memset(cp.irk, 0, MGMT_IRK_SIZE);
11981                 } else {
11982                         cp.privacy = ENABLE_PRIVACY;
11983                         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
11984                 }
11985         } else {
11986                 cp.privacy = DISABLE_PRIVACY;
11987                 memset(cp.irk, 0, MGMT_IRK_SIZE);
11988         }
11989         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
11990                         adapter->dev_id, sizeof(cp), &cp,
11991                         set_privacy_complete, adapter, NULL) > 0)
11992                 return true;
11993
11994         error("Failed to set privacy and load local irk for index %u",
11995                 adapter->dev_id);
11996
11997         return false;
11998 }
11999
12000 int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
12001                                                 const bdaddr_t *bdaddr,
12002                                                 uint8_t bdaddr_type)
12003
12004 {
12005         struct mgmt_cp_connect_6lowpan cp;
12006
12007         memset(&cp, 0, sizeof(cp));
12008         bacpy(&cp.addr.bdaddr, bdaddr);
12009         cp.addr.type = bdaddr_type;
12010
12011         if (mgmt_send(adapter->mgmt, MGMT_OP_CONNECT_6LOWPAN,
12012                                 adapter->dev_id, sizeof(cp), &cp,
12013                                 NULL, NULL, NULL) > 0)
12014                 return 0;
12015
12016         return -EIO;
12017 }
12018
12019 int btd_adapter_disconnect_ipsp(struct btd_adapter *adapter,
12020                                                 const bdaddr_t *bdaddr,
12021                                                 uint8_t bdaddr_type)
12022
12023 {
12024         struct mgmt_cp_disconnect_6lowpan cp;
12025
12026         memset(&cp, 0, sizeof(cp));
12027         bacpy(&cp.addr.bdaddr, bdaddr);
12028         cp.addr.type = bdaddr_type;
12029
12030         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT_6LOWPAN,
12031                                 adapter->dev_id, sizeof(cp), &cp,
12032                                 NULL, NULL, NULL) > 0)
12033                 return 0;
12034
12035         return -EIO;
12036 }
12037
12038 uint8_t btd_adapter_get_rpa_res_support_value(
12039                 struct btd_adapter *adapter)
12040 {
12041         return adapter->central_rpa_res_support;
12042 }
12043
12044 static void set_dev_rpa_res_support_complete(uint8_t status,
12045                                         uint16_t length, const void *param,
12046                                         void *user_data)
12047 {
12048         if (status != MGMT_STATUS_SUCCESS)
12049                 error("Failed to set RPA resolution support of device : %s (0x%02x)",
12050                                                 mgmt_errstr(status), status);
12051         else
12052                 DBG("Set RPA resolution support successful");
12053 }
12054
12055 int btd_adapter_set_dev_rpa_res_support(struct btd_adapter *adapter,
12056                                         struct btd_device *device)
12057
12058 {
12059         struct mgmt_cp_set_dev_rpa_res_support cp;
12060
12061         DBG("btd_adapter_set_dev_rpa_res_support called");
12062
12063         memset(&cp, 0, sizeof(cp));
12064
12065         bacpy(&cp.addr.bdaddr, device_get_address(device));
12066         cp.addr.type = btd_device_get_bdaddr_type(device);
12067         cp.res_support = device_get_rpa_res_char_value(device);
12068
12069         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_RPA_RES_SUPPORT,
12070                                 adapter->dev_id, sizeof(cp), &cp,
12071                                 set_dev_rpa_res_support_complete, NULL, NULL) > 0)
12072                 return 0;
12073
12074         return -EIO;
12075 }
12076 #endif
12077
12078 static void clear_devices_complete(uint8_t status, uint16_t length,
12079                                         const void *param, void *user_data)
12080 {
12081         if (status != MGMT_STATUS_SUCCESS) {
12082                 error("Failed to clear devices: %s (0x%02x)",
12083                                                 mgmt_errstr(status), status);
12084                 return;
12085         }
12086 }
12087
12088 static int clear_devices(struct btd_adapter *adapter)
12089 {
12090         struct mgmt_cp_remove_device cp;
12091
12092         if (!kernel_conn_control)
12093                 return 0;
12094
12095         memset(&cp, 0, sizeof(cp));
12096
12097         DBG("sending clear devices command for index %u", adapter->dev_id);
12098
12099         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
12100                                 adapter->dev_id, sizeof(cp), &cp,
12101                                 clear_devices_complete, adapter, NULL) > 0)
12102                 return 0;
12103
12104         btd_error(adapter->dev_id, "Failed to clear devices for index %u",
12105                                                         adapter->dev_id);
12106
12107         return -EIO;
12108 }
12109
12110 static void read_info_complete(uint8_t status, uint16_t length,
12111                                         const void *param, void *user_data)
12112 {
12113         struct btd_adapter *adapter = user_data;
12114         const struct mgmt_rp_read_info *rp = param;
12115         uint32_t missing_settings;
12116         int err;
12117
12118         DBG("index %u status 0x%02x", adapter->dev_id, status);
12119
12120         if (status != MGMT_STATUS_SUCCESS) {
12121                 btd_error(adapter->dev_id,
12122                                 "Failed to read info for index %u: %s (0x%02x)",
12123                                 adapter->dev_id, mgmt_errstr(status), status);
12124                 goto failed;
12125         }
12126
12127         if (length < sizeof(*rp)) {
12128                 btd_error(adapter->dev_id,
12129                                 "Too small read info complete response");
12130                 goto failed;
12131         }
12132
12133         if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
12134                 btd_error(adapter->dev_id, "No Bluetooth address for index %u",
12135                                                         adapter->dev_id);
12136                 goto failed;
12137         }
12138
12139         /*
12140          * Store controller information for device address, class of device,
12141          * device name, short name and settings.
12142          *
12143          * During the lifetime of the controller these will be updated by
12144          * events and the information is required to keep the current
12145          * state of the controller.
12146          */
12147         bacpy(&adapter->bdaddr, &rp->bdaddr);
12148         adapter->dev_class = rp->dev_class[0] | (rp->dev_class[1] << 8) |
12149                                                 (rp->dev_class[2] << 16);
12150         adapter->name = g_strdup((const char *) rp->name);
12151         adapter->short_name = g_strdup((const char *) rp->short_name);
12152
12153         adapter->supported_settings = btohl(rp->supported_settings);
12154         adapter->current_settings = btohl(rp->current_settings);
12155
12156 #ifdef __TIZEN_PATCH__
12157         adapter_check_version(adapter, rp->version);
12158 #endif
12159
12160         clear_uuids(adapter);
12161         clear_devices(adapter);
12162
12163         missing_settings = adapter->current_settings ^
12164                                                 adapter->supported_settings;
12165
12166         switch (main_opts.mode) {
12167         case BT_MODE_DUAL:
12168                 if (missing_settings & MGMT_SETTING_SSP)
12169                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
12170                 if (missing_settings & MGMT_SETTING_LE)
12171                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
12172                 if (missing_settings & MGMT_SETTING_BREDR)
12173                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
12174                 break;
12175         case BT_MODE_BREDR:
12176                 if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
12177                         btd_error(adapter->dev_id,
12178                                 "Ignoring adapter withouth BR/EDR support");
12179                         goto failed;
12180                 }
12181
12182                 if (missing_settings & MGMT_SETTING_SSP)
12183                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
12184                 if (missing_settings & MGMT_SETTING_BREDR)
12185                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
12186                 if (adapter->current_settings & MGMT_SETTING_LE)
12187                         set_mode(adapter, MGMT_OP_SET_LE, 0x00);
12188                 break;
12189         case BT_MODE_LE:
12190                 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
12191                         btd_error(adapter->dev_id,
12192                                 "Ignoring adapter withouth LE support");
12193                         goto failed;
12194                 }
12195
12196                 if (missing_settings & MGMT_SETTING_LE)
12197                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
12198                 if (adapter->current_settings & MGMT_SETTING_BREDR)
12199                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x00);
12200                 break;
12201         }
12202
12203         if (missing_settings & MGMT_SETTING_SECURE_CONN)
12204                 set_mode(adapter, MGMT_OP_SET_SECURE_CONN, 0x01);
12205
12206         if (main_opts.fast_conn &&
12207                         (missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
12208                 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
12209
12210 #ifdef __TIZEN_PATCH__
12211         /* Set the RPA resolution value to '1' if privacy is supported */
12212         if (adapter->le_privacy_enabled &&
12213                         adapter->supported_settings & MGMT_SETTING_PRIVACY)
12214                 adapter->central_rpa_res_support = 0x01;
12215 #endif
12216
12217         err = adapter_register(adapter);
12218         if (err < 0) {
12219                 btd_error(adapter->dev_id, "Unable to register new adapter");
12220                 goto failed;
12221         }
12222
12223         /*
12224          * Register all event notification handlers for controller.
12225          *
12226          * The handlers are registered after a succcesful read of the
12227          * controller info. From now on they can track updates and
12228          * notifications.
12229          */
12230         mgmt_register(adapter->mgmt, MGMT_EV_NEW_SETTINGS, adapter->dev_id,
12231                                         new_settings_callback, adapter, NULL);
12232
12233         mgmt_register(adapter->mgmt, MGMT_EV_CLASS_OF_DEV_CHANGED,
12234                                                 adapter->dev_id,
12235                                                 dev_class_changed_callback,
12236                                                 adapter, NULL);
12237         mgmt_register(adapter->mgmt, MGMT_EV_LOCAL_NAME_CHANGED,
12238                                                 adapter->dev_id,
12239                                                 local_name_changed_callback,
12240                                                 adapter, NULL);
12241
12242         mgmt_register(adapter->mgmt, MGMT_EV_DISCOVERING,
12243                                                 adapter->dev_id,
12244                                                 discovering_callback,
12245                                                 adapter, NULL);
12246
12247         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FOUND,
12248                                                 adapter->dev_id,
12249                                                 device_found_callback,
12250                                                 adapter, NULL);
12251
12252 #ifdef __TIZEN_PATCH__
12253         mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
12254                                                 adapter->dev_id,
12255                                                 le_device_found_callback,
12256                                                 adapter, NULL);
12257 #endif
12258
12259         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_DISCONNECTED,
12260                                                 adapter->dev_id,
12261                                                 disconnected_callback,
12262                                                 adapter, NULL);
12263
12264         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_CONNECTED,
12265                                                 adapter->dev_id,
12266                                                 connected_callback,
12267                                                 adapter, NULL);
12268
12269         mgmt_register(adapter->mgmt, MGMT_EV_CONNECT_FAILED,
12270                                                 adapter->dev_id,
12271                                                 connect_failed_callback,
12272                                                 adapter, NULL);
12273
12274         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNPAIRED,
12275                                                 adapter->dev_id,
12276                                                 unpaired_callback,
12277                                                 adapter, NULL);
12278
12279         mgmt_register(adapter->mgmt, MGMT_EV_AUTH_FAILED,
12280                                                 adapter->dev_id,
12281                                                 auth_failed_callback,
12282                                                 adapter, NULL);
12283
12284         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LINK_KEY,
12285                                                 adapter->dev_id,
12286                                                 new_link_key_callback,
12287                                                 adapter, NULL);
12288
12289         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LONG_TERM_KEY,
12290                                                 adapter->dev_id,
12291                                                 new_long_term_key_callback,
12292                                                 adapter, NULL);
12293
12294         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CSRK,
12295                                                 adapter->dev_id,
12296                                                 new_csrk_callback,
12297                                                 adapter, NULL);
12298
12299         mgmt_register(adapter->mgmt, MGMT_EV_NEW_IRK,
12300                                                 adapter->dev_id,
12301                                                 new_irk_callback,
12302                                                 adapter, NULL);
12303
12304         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CONN_PARAM,
12305                                                 adapter->dev_id,
12306                                                 new_conn_param,
12307                                                 adapter, NULL);
12308
12309         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
12310                                                 adapter->dev_id,
12311                                                 device_blocked_callback,
12312                                                 adapter, NULL);
12313         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNBLOCKED,
12314                                                 adapter->dev_id,
12315                                                 device_unblocked_callback,
12316                                                 adapter, NULL);
12317
12318         mgmt_register(adapter->mgmt, MGMT_EV_PIN_CODE_REQUEST,
12319                                                 adapter->dev_id,
12320                                                 pin_code_request_callback,
12321                                                 adapter, NULL);
12322
12323         mgmt_register(adapter->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
12324                                                 adapter->dev_id,
12325                                                 user_confirm_request_callback,
12326                                                 adapter, NULL);
12327
12328         mgmt_register(adapter->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
12329                                                 adapter->dev_id,
12330                                                 user_passkey_request_callback,
12331                                                 adapter, NULL);
12332
12333         mgmt_register(adapter->mgmt, MGMT_EV_PASSKEY_NOTIFY,
12334                                                 adapter->dev_id,
12335                                                 user_passkey_notify_callback,
12336                                                 adapter, NULL);
12337
12338 #ifdef __TIZEN_PATCH__
12339         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
12340                                                 adapter->dev_id,
12341                                                 rssi_alert_callback,
12342                                                 adapter, NULL);
12343
12344         mgmt_register(adapter->mgmt, MGMT_EV_RAW_RSSI,
12345                                                 adapter->dev_id,
12346                                                 get_raw_rssi_callback,
12347                                                 adapter, NULL);
12348
12349         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ENABLED,
12350                                                         adapter->dev_id,
12351                                                         rssi_enabled_callback,
12352                                                         adapter, NULL);
12353
12354         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_DISABLED,
12355                                                         adapter->dev_id,
12356                                                         rssi_disabled_callback,
12357                                                         adapter, NULL);
12358
12359 #if 0 // Not used
12360         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LOCAL_IRK,
12361                                                 adapter->dev_id,
12362                                                 new_local_irk_callback,
12363                                                 adapter, NULL);
12364 #endif
12365
12366         mgmt_register(adapter->mgmt, MGMT_EV_HARDWARE_ERROR,
12367                                                 adapter->dev_id,
12368                                                 hardware_error_callback,
12369                                                 adapter, NULL);
12370
12371         mgmt_register(adapter->mgmt, MGMT_EV_TX_TIMEOUT_ERROR,
12372                                                 adapter->dev_id,
12373                                                 tx_timeout_error_callback,
12374                                                 adapter, NULL);
12375
12376         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_NAME_UPDATE,
12377                                         adapter->dev_id,
12378                                         device_name_update_callback,
12379                                         adapter, NULL);
12380
12381         mgmt_register(adapter->mgmt, MGMT_EV_MULTI_ADV_STATE_CHANGED,
12382                                         adapter->dev_id,
12383                                         multi_adv_state_change_callback,
12384                                         adapter, NULL);
12385
12386         mgmt_register(adapter->mgmt, MGMT_EV_6LOWPAN_CONN_STATE_CHANGED,
12387                                                 adapter->dev_id,
12388                                                 bt_6lowpan_conn_state_change_callback,
12389                                                 adapter, NULL);
12390
12391         mgmt_register(adapter->mgmt, MGMT_EV_LE_DATA_LENGTH_CHANGED,
12392                                                 adapter->dev_id,
12393                                                 bt_le_data_length_changed_callback,
12394                                                 adapter, NULL);
12395
12396         mgmt_register(adapter->mgmt, MGMT_EV_CONN_UPDATED,
12397                                         adapter->dev_id,
12398                                         le_conn_update_completed_callback,
12399                                         adapter, NULL);
12400 #endif
12401
12402         set_dev_class(adapter);
12403
12404         set_name(adapter, btd_adapter_get_name(adapter));
12405
12406         if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
12407                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
12408
12409         if (!kernel_conn_control)
12410                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x01);
12411         else if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
12412                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
12413
12414         if (adapter->stored_discoverable && !adapter->discoverable_timeout)
12415                 set_discoverable(adapter, 0x01, 0);
12416
12417         if (adapter->current_settings & MGMT_SETTING_POWERED)
12418                 adapter_start(adapter);
12419 #ifdef __TIZEN_PATCH__
12420         else
12421                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
12422 #endif
12423
12424         return;
12425
12426 failed:
12427         /*
12428          * Remove adapter from list in case of a failure.
12429          *
12430          * Leaving an adapter structure around for a controller that can
12431          * not be initilized makes no sense at the moment.
12432          *
12433          * This is a simplification to avoid constant checks if the
12434          * adapter is ready to do anything.
12435          */
12436         adapter_list = g_list_remove(adapter_list, adapter);
12437
12438         btd_adapter_unref(adapter);
12439 }
12440
12441 static void index_added(uint16_t index, uint16_t length, const void *param,
12442                                                         void *user_data)
12443 {
12444         struct btd_adapter *adapter;
12445
12446         DBG("index %u", index);
12447
12448         adapter = btd_adapter_lookup(index);
12449         if (adapter) {
12450                 btd_warn(adapter->dev_id,
12451                         "Ignoring index added for an already existing adapter");
12452                 return;
12453         }
12454
12455         adapter = btd_adapter_new(index);
12456         if (!adapter) {
12457                 btd_error(adapter->dev_id,
12458                         "Unable to create new adapter for index %u", index);
12459                 return;
12460         }
12461
12462         /*
12463          * Protect against potential two executions of read controller info.
12464          *
12465          * In case the start of the daemon and the action of adding a new
12466          * controller coincide this function might be called twice.
12467          *
12468          * To avoid the double execution of reading the controller info,
12469          * add the adapter already to the list. If an adapter is already
12470          * present, the second notification will cause a warning. If the
12471          * command fails the adapter is removed from the list again.
12472          */
12473         adapter_list = g_list_append(adapter_list, adapter);
12474
12475         DBG("sending read info command for index %u", index);
12476
12477         if (mgmt_send(mgmt_master, MGMT_OP_READ_INFO, index, 0, NULL,
12478                                         read_info_complete, adapter, NULL) > 0)
12479                 return;
12480
12481         btd_error(adapter->dev_id,
12482                         "Failed to read controller info for index %u", index);
12483
12484         adapter_list = g_list_remove(adapter_list, adapter);
12485
12486         btd_adapter_unref(adapter);
12487 }
12488
12489 static void index_removed(uint16_t index, uint16_t length, const void *param,
12490                                                         void *user_data)
12491 {
12492         struct btd_adapter *adapter;
12493
12494         DBG("index %u", index);
12495
12496         adapter = btd_adapter_lookup(index);
12497         if (!adapter) {
12498                 warn("Ignoring index removal for a non-existent adapter");
12499                 return;
12500         }
12501
12502         adapter_unregister(adapter);
12503 }
12504
12505 static void read_index_list_complete(uint8_t status, uint16_t length,
12506                                         const void *param, void *user_data)
12507 {
12508         const struct mgmt_rp_read_index_list *rp = param;
12509         uint16_t num;
12510         int i;
12511
12512         if (status != MGMT_STATUS_SUCCESS) {
12513                 error("Failed to read index list: %s (0x%02x)",
12514                                                 mgmt_errstr(status), status);
12515                 return;
12516         }
12517
12518         if (length < sizeof(*rp)) {
12519                 error("Wrong size of read index list response");
12520                 return;
12521         }
12522
12523         num = btohs(rp->num_controllers);
12524
12525         DBG("Number of controllers: %d", num);
12526
12527         if (num * sizeof(uint16_t) + sizeof(*rp) != length) {
12528                 error("Incorrect packet size for index list response");
12529                 return;
12530         }
12531
12532         for (i = 0; i < num; i++) {
12533                 uint16_t index;
12534
12535                 index = btohs(rp->index[i]);
12536
12537                 DBG("Found index %u", index);
12538
12539                 /*
12540                  * Pretend to be index added event notification.
12541                  *
12542                  * It is safe to just trigger the procedure for index
12543                  * added notification. It does check against itself.
12544                  */
12545                 index_added(index, 0, NULL, NULL);
12546         }
12547 }
12548
12549 static void read_commands_complete(uint8_t status, uint16_t length,
12550                                         const void *param, void *user_data)
12551 {
12552         const struct mgmt_rp_read_commands *rp = param;
12553         uint16_t num_commands, num_events;
12554         const uint16_t *opcode;
12555         size_t expected_len;
12556         int i;
12557
12558         if (status != MGMT_STATUS_SUCCESS) {
12559                 error("Failed to read supported commands: %s (0x%02x)",
12560                                                 mgmt_errstr(status), status);
12561                 return;
12562         }
12563
12564         if (length < sizeof(*rp)) {
12565                 error("Wrong size of read commands response");
12566                 return;
12567         }
12568
12569         num_commands = btohs(rp->num_commands);
12570         num_events = btohs(rp->num_events);
12571
12572         DBG("Number of commands: %d", num_commands);
12573         DBG("Number of events: %d", num_events);
12574
12575         expected_len = sizeof(*rp) + num_commands * sizeof(uint16_t) +
12576                                                 num_events * sizeof(uint16_t);
12577
12578         if (length < expected_len) {
12579                 error("Too small reply for supported commands: (%u != %zu)",
12580                                                         length, expected_len);
12581                 return;
12582         }
12583
12584         opcode = rp->opcodes;
12585
12586         for (i = 0; i < num_commands; i++) {
12587                 uint16_t op = get_le16(opcode++);
12588
12589                 if (op == MGMT_OP_ADD_DEVICE) {
12590                         DBG("enabling kernel-side connection control");
12591                         kernel_conn_control = true;
12592                 }
12593         }
12594 }
12595
12596 static void read_version_complete(uint8_t status, uint16_t length,
12597                                         const void *param, void *user_data)
12598 {
12599         const struct mgmt_rp_read_version *rp = param;
12600
12601         if (status != MGMT_STATUS_SUCCESS) {
12602                 error("Failed to read version information: %s (0x%02x)",
12603                                                 mgmt_errstr(status), status);
12604                 return;
12605         }
12606
12607         if (length < sizeof(*rp)) {
12608                 error("Wrong size of read version response");
12609                 return;
12610         }
12611
12612         mgmt_version = rp->version;
12613         mgmt_revision = btohs(rp->revision);
12614
12615         info("Bluetooth management interface %u.%u initialized",
12616                                                 mgmt_version, mgmt_revision);
12617
12618         if (mgmt_version < 1) {
12619                 error("Version 1.0 or later of management interface required");
12620                 abort();
12621         }
12622
12623         DBG("sending read supported commands command");
12624
12625         /*
12626          * It is irrelevant if this command succeeds or fails. In case of
12627          * failure safe settings are assumed.
12628          */
12629         mgmt_send(mgmt_master, MGMT_OP_READ_COMMANDS,
12630                                 MGMT_INDEX_NONE, 0, NULL,
12631                                 read_commands_complete, NULL, NULL);
12632
12633         mgmt_register(mgmt_master, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
12634                                                 index_added, NULL, NULL);
12635         mgmt_register(mgmt_master, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
12636                                                 index_removed, NULL, NULL);
12637
12638         DBG("sending read index list command");
12639
12640         if (mgmt_send(mgmt_master, MGMT_OP_READ_INDEX_LIST,
12641                                 MGMT_INDEX_NONE, 0, NULL,
12642                                 read_index_list_complete, NULL, NULL) > 0)
12643                 return;
12644
12645         error("Failed to read controller index list");
12646 }
12647
12648 static void mgmt_debug(const char *str, void *user_data)
12649 {
12650         const char *prefix = user_data;
12651
12652         info("%s%s", prefix, str);
12653 }
12654
12655 int adapter_init(void)
12656 {
12657         dbus_conn = btd_get_dbus_connection();
12658
12659         mgmt_master = mgmt_new_default();
12660         if (!mgmt_master) {
12661                 error("Failed to access management interface");
12662                 return -EIO;
12663         }
12664
12665         if (getenv("MGMT_DEBUG"))
12666                 mgmt_set_debug(mgmt_master, mgmt_debug, "mgmt: ", NULL);
12667
12668         DBG("sending read version command");
12669
12670         if (mgmt_send(mgmt_master, MGMT_OP_READ_VERSION,
12671                                 MGMT_INDEX_NONE, 0, NULL,
12672                                 read_version_complete, NULL, NULL) > 0)
12673                 return 0;
12674
12675         error("Failed to read management version information");
12676
12677         return -EIO;
12678 }
12679
12680 void adapter_cleanup(void)
12681 {
12682         g_list_free(adapter_list);
12683
12684         while (adapters) {
12685                 struct btd_adapter *adapter = adapters->data;
12686
12687                 adapter_remove(adapter);
12688                 adapters = g_slist_remove(adapters, adapter);
12689                 btd_adapter_unref(adapter);
12690         }
12691
12692         /*
12693          * In case there is another reference active, clear out
12694          * registered handlers for index added and index removed.
12695          *
12696          * This is just an extra precaution to be safe, and in
12697          * reality should not make a difference.
12698          */
12699         mgmt_unregister_index(mgmt_master, MGMT_INDEX_NONE);
12700
12701         /*
12702          * In case there is another reference active, cancel
12703          * all pending global commands.
12704          *
12705          * This is just an extra precaution to avoid callbacks
12706          * that potentially then could leak memory or access
12707          * an invalid structure.
12708          */
12709         mgmt_cancel_index(mgmt_master, MGMT_INDEX_NONE);
12710
12711         mgmt_unref(mgmt_master);
12712         mgmt_master = NULL;
12713
12714         dbus_conn = NULL;
12715 }
12716
12717 void adapter_shutdown(void)
12718 {
12719         GList *list;
12720
12721         DBG("");
12722
12723         powering_down = true;
12724
12725         for (list = g_list_first(adapter_list); list;
12726                                                 list = g_list_next(list)) {
12727                 struct btd_adapter *adapter = list->data;
12728
12729                 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
12730                         continue;
12731
12732                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x00);
12733
12734                 adapter_remaining++;
12735         }
12736
12737         if (!adapter_remaining)
12738                 btd_exit();
12739 }
12740
12741 /*
12742  * Check if workaround for broken ATT server socket behavior is needed
12743  * where we need to connect an ATT client socket before pairing to get
12744  * early access to the ATT channel.
12745  */
12746 bool btd_le_connect_before_pairing(void)
12747 {
12748         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 4))
12749                 return true;
12750
12751         return false;
12752 }
12753
12754 #ifdef __TIZEN_PATCH__
12755 #if 0 // Not used
12756 static void read_rssi_complete(uint8_t status, uint16_t length,
12757                                         const void *param, void *user_data)
12758 {
12759         const struct mgmt_rp_read_rssi *rp = param;
12760         struct btd_device *device = user_data;
12761
12762         if (status != MGMT_STATUS_SUCCESS) {
12763                 error("read RSSI failed: %s (0x%02x)",
12764                                                 mgmt_errstr(status), status);
12765                 return;
12766         }
12767
12768         if (length < sizeof(*rp)) {
12769                 error("Too small read rssi response");
12770                 return;
12771         }
12772
12773         if (!rp->status) {
12774                 device_set_rssi(device, rp->rssi);
12775         }
12776         return;
12777 }
12778
12779 int btd_adapter_read_rssi(struct btd_adapter *adapter, bdaddr_t *bdaddr,
12780                                         struct btd_device *device)
12781 {
12782         struct mgmt_cp_read_rssi cp;
12783
12784         DBG("btd_adapter_read_rssi");
12785         memset(&cp, 0, sizeof(cp));
12786         bacpy(&cp.bdaddr, bdaddr);
12787
12788         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_RSSI,
12789                         adapter->dev_id, sizeof(cp), &cp,
12790                         read_rssi_complete, device, NULL) > 0)
12791                 return 0;
12792         return -EIO;
12793 }
12794
12795 int btd_adapter_l2cap_conn_param_update(struct btd_adapter *adapter,
12796                                 bdaddr_t *bdaddr, uint16_t interval_min,
12797                                 uint16_t interval_max, uint16_t latency,
12798                                 uint16_t supervision_time_out)
12799 {
12800         struct mgmt_cp_l2cap_conn_param_update cp;
12801
12802         memset(&cp, 0, sizeof(cp));
12803         if (bdaddr)
12804                 bacpy(&cp.bdaddr, bdaddr);
12805         else
12806                 return -EIO;
12807
12808         cp.interval_min = interval_min;
12809         cp.interval_max = interval_max;
12810         cp.latency = latency;
12811         cp.supervision_time_out = supervision_time_out;
12812         if (mgmt_send(adapter->mgmt, MGMT_OP_L2CAP_CONN_PARAM_UPDATE,
12813                         adapter->dev_id, sizeof(cp), &cp,
12814                         NULL, NULL, NULL) > 0)
12815                 return 0;
12816
12817         return -EIO;
12818 }
12819
12820 static void write_auth_payload_timeout_complete(uint8_t status, uint16_t length,
12821                                         const void *param, void *user_data)
12822 {
12823         const struct mgmt_rp_write_auth_payload_timeout *rp = param;
12824
12825         if (status != MGMT_STATUS_SUCCESS) {
12826                 error("Failed to write auth payload timeout: %s (0x%02x)",
12827                                                 mgmt_errstr(status), status);
12828                 return;
12829         }
12830
12831         if (length < sizeof(*rp)) {
12832                 error("Wrong size of write auth payload timeout parameter");
12833                 return;
12834         }
12835 }
12836
12837 int btd_adapter_write_auth_payload_timeout(struct btd_adapter *adapter,
12838                                 bdaddr_t *bdaddr, uint32_t payload_timeout,
12839                                 struct btd_device *device)
12840 {
12841         struct mgmt_cp_write_auth_payload_timeout cp;
12842         memset(&cp, 0, sizeof(cp));
12843         bacpy(&cp.bdaddr, bdaddr);
12844
12845         if (payload_timeout > 65536)
12846                 return -EIO;
12847         else
12848                 cp.auth_payload_timeout = payload_timeout;
12849
12850         if (mgmt_send(adapter->mgmt, MGMT_OP_WRITE_AUTH_PAYLOAD_TIMEOUT,
12851                         adapter->dev_id, sizeof(cp), &cp,
12852                         write_auth_payload_timeout_complete, device, NULL) > 0)
12853                         return 0;
12854         return -EIO;
12855 }
12856
12857 static void read_auth_payload_timeout_complete(uint8_t status, uint16_t length,
12858                                         const void *param, void *user_data)
12859 {
12860         const struct mgmt_rp_read_auth_payload_timeout *rp = param;
12861         struct btd_device *device = user_data;
12862         if (status != MGMT_STATUS_SUCCESS) {
12863                 error("read auth payload timeout failed: %s (0x%02x)",
12864                                                 mgmt_errstr(status), status);
12865                 return;
12866         }
12867
12868         if (length < sizeof(*rp)) {
12869                 error("Too small read payload response");
12870                 return;
12871         }
12872
12873         if (!rp->status) {
12874                 device_set_payload_timeout(device, rp->auth_payload_timeout);
12875         }
12876         return;
12877 }
12878
12879 int btd_adapter_read_auth_payload_timeout(struct btd_adapter *adapter,
12880                                 bdaddr_t *bdaddr, struct btd_device *device)
12881 {
12882         struct mgmt_cp_read_auth_payload_timeout cp;
12883         memset(&cp, 0, sizeof(cp));
12884         bacpy(&cp.bdaddr, bdaddr);
12885
12886         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_AUTH_PAYLOAD_TIMEOUT,
12887                         adapter->dev_id, sizeof(cp), &cp,
12888                         read_auth_payload_timeout_complete, device, NULL) > 0)
12889                         return 0;
12890         return -EIO;
12891 }
12892 #endif
12893
12894 int btd_adapter_le_conn_update(struct btd_adapter *adapter, bdaddr_t *bdaddr,
12895                                 uint16_t interval_min, uint16_t interval_max,
12896                                 uint16_t latency, uint16_t supervision_time_out)
12897 {
12898         struct mgmt_cp_le_conn_update cp;
12899
12900         memset(&cp, 0, sizeof(cp));
12901
12902         if (NULL != bdaddr)
12903                 bacpy(&cp.bdaddr, bdaddr);
12904         else
12905                 return -EIO;
12906
12907         cp.interval_min = interval_min;
12908         cp.interval_max = interval_max;
12909         cp.latency = latency;
12910         cp.supervision_time_out = supervision_time_out;
12911
12912         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_CONN_UPDATE,
12913                         adapter->dev_id, sizeof(cp), &cp,
12914                         NULL, NULL, NULL) > 0)
12915                 return 0;
12916
12917         return -EIO;
12918 }
12919
12920 GSList *btd_adapter_get_connections(struct btd_adapter *adapter)
12921 {
12922         /* Return the connected device list */
12923         return adapter->connections;
12924 }
12925 #endif /* __TIZEN_PATCH__ */