src/adapter.c

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