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