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