src/adapter.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *  BlueZ - Bluetooth protocol stack for Linux
   5  *
   6  *  Copyright (C) 2006-2010  Nokia Corporation
   7  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *
   9  *
  10  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 #include <config.h>
  14 #endif
  15
  16 #include <stdio.h>
  17 #include <inttypes.h>
  18 #include <errno.h>
  19 #include <unistd.h>
  20 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <sys/ioctl.h>
  23 #include <sys/file.h>
  24 #include <sys/stat.h>
  25 #include <dirent.h>
  26
  27 #include <glib.h>
  28 #include <dbus/dbus.h>
  29
  30 #include "bluetooth/bluetooth.h"
  31 #include "bluetooth/hci.h"
  32 #include "bluetooth/hci_lib.h"
  33 #include "bluetooth/sdp.h"
  34 #include "bluetooth/sdp_lib.h"
  35 #include "lib/uuid.h"
  36 #include "lib/mgmt.h"
  37
  38 #include "gdbus/gdbus.h"
  39
  40 #include "log.h"
  41 #include "textfile.h"
  42
  43 #include "src/shared/mgmt.h"
  44 #include "src/shared/util.h"
  45 #include "src/shared/queue.h"
  46 #include "src/shared/att.h"
  47 #include "src/shared/gatt-db.h"
  48 #include "src/shared/timeout.h"
  49
  50 #include "btio/btio.h"
  51 #include "btd.h"
  52 #include "sdpd.h"
  53 #include "adapter.h"
  54 #include "device.h"
  55 #include "profile.h"
  56 #include "dbus-common.h"
  57 #include "error.h"
  58 #include "uuid-helper.h"
  59 #include "agent.h"
  60 #include "storage.h"
  61 #include "attrib/gattrib.h"
  62 #include "attrib/att.h"
  63 #include "attrib/gatt.h"
  64 #include "attrib-server.h"
  65 #include "gatt-database.h"
  66 #include "advertising.h"
  67 #include "adv_monitor.h"
  68 #include "eir.h"
  69 #include "battery.h"
  70
  71 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
  72 #include <ctype.h>
  73 #include "adapter_le_vsc_features.h"
  74 #include "../profile.h"
  75 #endif
  76
  77 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
  78 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
  79 #define DEVICED_DEST                    "org.tizen.system.deviced"
  80 #define DEVICED_BATT_INTERFACE          "org.tizen.system.deviced.Battery"
  81 #define DEVICED_BATT_OBJECT_PATH        "/Org/Tizen/System/DeviceD/Battery"
  82 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
  83 #endif
  84
  85 #define MODE_OFF                0x00
  86 #define MODE_CONNECTABLE        0x01
  87 #define MODE_DISCOVERABLE       0x02
  88 #define MODE_UNKNOWN            0xff
  89
  90 #define CONN_SCAN_TIMEOUT (3)
  91 #define IDLE_DISCOV_TIMEOUT (5)
  92 #define TEMP_DEV_TIMEOUT (3 * 60)
  93 #define BONDING_TIMEOUT (2 * 60)
  94
  95 #define SCAN_TYPE_BREDR (1 << BDADDR_BREDR)
  96 #define SCAN_TYPE_LE ((1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM))
  97 #define SCAN_TYPE_DUAL (SCAN_TYPE_BREDR | SCAN_TYPE_LE)
  98 #define SETTING_PRIVACY_MASK (1<<13)
  99
 100 #define HCI_RSSI_INVALID        127
 101 #define DISTANCE_VAL_INVALID    0x7FFF
 102 #define PATHLOSS_MAX            137
 103
 104 /*
 105  * These are known security keys that have been compromised.
 106  * If this grows or there are needs to be platform specific, it is
 107  * conceivable that these could be read from a config file.
 108  */
 109 static const struct mgmt_blocked_key_info blocked_keys[] = {
 110         /* Google Titan Security Keys */
 111         { HCI_BLOCKED_KEY_TYPE_LTK,
 112                 {0xbf, 0x01, 0xfb, 0x9d, 0x4e, 0xf3, 0xbc, 0x36,
 113                  0xd8, 0x74, 0xf5, 0x39, 0x41, 0x38, 0x68, 0x4c}},
 114         { HCI_BLOCKED_KEY_TYPE_IRK,
 115                 {0xa5, 0x99, 0xba, 0xe4, 0xe1, 0x7c, 0xa6, 0x18,
 116                  0x22, 0x8e, 0x07, 0x56, 0xb4, 0xe8, 0x5f, 0x01}},
 117 };
 118
 119 struct mgmt_exp_uuid {
 120         uint8_t val[16];
 121         const char *str;
 122 };
 123
 124 /* d4992530-b9ec-469f-ab01-6c481c47da1c */
 125 static const struct mgmt_exp_uuid debug_uuid = {
 126         .val = { 0x1c, 0xda, 0x47, 0x1c, 0x48, 0x6c, 0x01, 0xab,
 127                 0x9f, 0x46, 0xec, 0xb9, 0x30, 0x25, 0x99, 0xd4 },
 128         .str = "d4992530-b9ec-469f-ab01-6c481c47da1c"
 129 };
 130
 131 /* 671b10b5-42c0-4696-9227-eb28d1b049d6 */
 132 static const struct mgmt_exp_uuid le_simult_central_peripheral_uuid = {
 133         .val = { 0xd6, 0x49, 0xb0, 0xd1, 0x28, 0xeb, 0x27, 0x92,
 134                 0x96, 0x46, 0xc0, 0x42, 0xb5, 0x10, 0x1b, 0x67 },
 135         .str = "671b10b5-42c0-4696-9227-eb28d1b049d6"
 136 };
 137
 138 /* 330859bc-7506-492d-9370-9a6f0614037f */
 139 static const struct mgmt_exp_uuid quality_report_uuid = {
 140         .val = { 0x7f, 0x03, 0x14, 0x06, 0x6f, 0x9a, 0x70, 0x93,
 141                 0x2d, 0x49, 0x06, 0x75, 0xbc, 0x59, 0x08, 0x33 },
 142         .str = "330859bc-7506-492d-9370-9a6f0614037f"
 143 };
 144
 145 /* 15c0a148-c273-11ea-b3de-0242ac130004 */
 146 static const struct mgmt_exp_uuid rpa_resolution_uuid = {
 147         .val = { 0x04, 0x00, 0x13, 0xac, 0x42, 0x02, 0xde, 0xb3,
 148                 0xea, 0x11, 0x73, 0xc2, 0x48, 0xa1, 0xc0, 0x15 },
 149         .str = "15c0a148-c273-11ea-b3de-0242ac130004"
 150 };
 151
 152 /* a6695ace-ee7f-4fb9-881a-5fac66c629af */
 153 static const struct mgmt_exp_uuid codec_offload_uuid = {
 154         .val = { 0xaf, 0x29, 0xc6, 0x66, 0xac, 0x5f, 0x1a, 0x88,
 155                 0xb9, 0x4f, 0x7f, 0xee, 0xce, 0x5a, 0x69, 0xa6 },
 156         .str = "a6695ace-ee7f-4fb9-881a-5fac66c629af"
 157 };
 158
 159 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 160 #define ADV_DATA_MAX_LENGTH 31
 161 #define SCAN_RESPONSE_DATA_LENGTH_MAX 31
 162 #define EIR_MANUFACTURER_DATA_LENGTH_MAX 100
 163
 164 #define LE_BEARER_POSTFIX       " LE"
 165 #define LE_BEARER_POSTFIX_LEN   3
 166 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
 167
 168
 169 static DBusConnection *dbus_conn = NULL;
 170
 171 static uint32_t kernel_features = 0;
 172
 173 static GList *adapter_list = NULL;
 174 static unsigned int adapter_remaining = 0;
 175 static bool powering_down = false;
 176
 177 static GSList *adapters = NULL;
 178
 179 static struct mgmt *mgmt_primary = NULL;
 180
 181 static uint8_t mgmt_version = 0;
 182 static uint8_t mgmt_revision = 0;
 183
 184 static GSList *adapter_drivers = NULL;
 185
 186 static GSList *disconnect_list = NULL;
 187 static GSList *conn_fail_list = NULL;
 188
 189 struct link_key_info {
 190         bdaddr_t bdaddr;
 191         unsigned char key[16];
 192         uint8_t type;
 193         uint8_t pin_len;
 194         bool is_blocked;
 195 };
 196
 197 struct smp_ltk_info {
 198         bdaddr_t bdaddr;
 199         uint8_t bdaddr_type;
 200         uint8_t authenticated;
 201         bool central;
 202         uint8_t enc_size;
 203         uint16_t ediv;
 204         uint64_t rand;
 205         uint8_t val[16];
 206         bool is_blocked;
 207 };
 208
 209 struct irk_info {
 210         bdaddr_t bdaddr;
 211         uint8_t bdaddr_type;
 212         uint8_t val[16];
 213         bool is_blocked;
 214 };
 215
 216 struct conn_param {
 217         bdaddr_t bdaddr;
 218         uint8_t  bdaddr_type;
 219         uint16_t min_interval;
 220         uint16_t max_interval;
 221         uint16_t latency;
 222         uint16_t timeout;
 223 };
 224
 225 struct discovery_filter {
 226         uint8_t type;
 227         char *pattern;
 228         uint16_t pathloss;
 229         int16_t rssi;
 230         GSList *uuids;
 231         bool duplicate;
 232         bool discoverable;
 233 };
 234
 235 struct discovery_client {
 236         struct btd_adapter *adapter;
 237         DBusMessage *msg;
 238         char *owner;
 239         guint watch;
 240         struct discovery_filter *discovery_filter;
 241 };
 242
 243 struct service_auth {
 244         guint id;
 245         unsigned int svc_id;
 246         service_auth_cb cb;
 247         void *user_data;
 248         const char *uuid;
 249         struct btd_device *device;
 250         struct btd_adapter *adapter;
 251         struct agent *agent;            /* NULL for queued auths */
 252 };
 253
 254 struct btd_adapter_pin_cb_iter {
 255         GSList *it;                     /* current callback function */
 256         unsigned int attempt;           /* numer of times it() was called */
 257         /* When the iterator reaches the end, it is NULL and attempt is 0 */
 258 };
 259
 260 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 261 struct adv_info {
 262         int slot_id;    /* Reservied slot id is 0 (Single adv) */
 263         bool status;            /* Advertising status */
 264 };
 265
 266 static GSList *read_requests = NULL;
 267
 268 struct le_data_length_read_request {
 269         struct btd_adapter *adapter;
 270         DBusMessage *msg;
 271 };
 272
 273 struct le_batching_request {
 274         struct btd_adapter *adapter;
 275         DBusMessage *msg;
 276 };
 277
 278 struct le_batching_set_param_request {
 279         struct btd_adapter *adapter;
 280         DBusMessage *msg;
 281         bdaddr_t bdaddr;
 282 };
 283 #endif
 284
 285 struct btd_adapter {
 286         int ref_count;
 287
 288         uint16_t dev_id;
 289         struct mgmt *mgmt;
 290
 291         bdaddr_t bdaddr;                /* controller Bluetooth address */
 292 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 293         bdaddr_t le_static_addr;
 294         bdaddr_t rpa;
 295 #endif
 296         uint8_t bdaddr_type;            /* address type */
 297         uint32_t dev_class;             /* controller class of device */
 298         char *name;                     /* controller device name */
 299         char *short_name;               /* controller short name */
 300         uint32_t supported_settings;    /* controller supported settings */
 301         uint32_t pending_settings;      /* pending controller settings */
 302         uint32_t current_settings;      /* current controller settings */
 303
 304         char *path;                     /* adapter object path */
 305         uint16_t manufacturer;          /* adapter manufacturer */
 306         uint8_t major_class;            /* configured major class */
 307         uint8_t minor_class;            /* configured minor class */
 308         char *system_name;              /* configured system name */
 309         char *modalias;                 /* device id (modalias) */
 310         bool stored_discoverable;       /* stored discoverable mode */
 311         uint32_t discoverable_timeout;  /* discoverable time(sec) */
 312         uint32_t pairable_timeout;      /* pairable time(sec) */
 313
 314         char *current_alias;            /* current adapter name alias */
 315         char *stored_alias;             /* stored adapter name alias */
 316 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 317         uint8_t *local_irk;     /* adapter local IRK */
 318         uint8_t disc_type;
 319         bool ipsp_intialized;           /* Ipsp Initialization state */
 320         struct le_data_length_read_handler *read_handler;
 321         struct le_data_length_read_default_data_length_handler *def_read_handler;
 322 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 323         guint charging_watch;
 324         guint charging_timeout;
 325         charging_state_e charging;
 326 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 327 #endif
 328
 329         bool discovering;               /* discovering property state */
 330         bool filtered_discovery;        /* we are doing filtered discovery */
 331         bool no_scan_restart_delay;     /* when this flag is set, restart scan
 332                                          * without delay */
 333         uint8_t discovery_type;         /* current active discovery type */
 334         uint8_t discovery_enable;       /* discovery enabled/disabled */
 335         bool discovery_suspended;       /* discovery has been suspended */
 336         bool discovery_discoverable;    /* discoverable while discovering */
 337         GSList *discovery_list;         /* list of discovery clients */
 338         GSList *set_filter_list;        /* list of clients that specified
 339                                          * filter, but don't scan yet
 340                                          */
 341         /* current discovery filter, if any */
 342         struct mgmt_cp_start_service_discovery *current_discovery_filter;
 343
 344         struct discovery_client *client;        /* active discovery client */
 345
 346         GSList *discovery_found;        /* list of found devices */
 347 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 348         guint le_discovery_idle_timeout;        /* timeout between le discovery runs */
 349 #endif
 350         unsigned int discovery_idle_timeout; /* timeout between discovery
 351                                                 * runs
 352                                                 */
 353         unsigned int passive_scan_timeout; /* timeout between passive scans */
 354
 355         unsigned int pairable_timeout_id;       /* pairable timeout id */
 356         guint auth_idle_id;             /* Pending authorization dequeue */
 357         GQueue *auths;                  /* Ongoing and pending auths */
 358         bool pincode_requested;         /* PIN requested during last bonding */
 359         GSList *connections;            /* Connected devices */
 360         GSList *devices;                /* Devices structure pointers */
 361         GSList *connect_list;           /* Devices to connect when found */
 362         struct btd_device *connect_le;  /* LE device waiting to be connected */
 363         sdp_list_t *services;           /* Services associated to adapter */
 364
 365         struct btd_gatt_database *database;
 366         struct btd_adv_manager *adv_manager;
 367
 368         struct btd_adv_monitor_manager *adv_monitor_manager;
 369
 370         struct btd_battery_provider_manager *battery_provider_manager;
 371         GHashTable *allowed_uuid_set;   /* Set of allowed service UUIDs */
 372
 373         gboolean initialized;
 374 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 375         GSList *adv_list;       /* List of advertising instance */
 376         bool advertising;               /* Advertising active */
 377         gchar *version;                 /* Bluetooth Version */
 378         uint8_t adv_tx_power;
 379         guint adv_restart_timeout;
 380         bool le_discovering;                    /* LE Discovery active */
 381         GSList *le_discovery_list;              /* list of LE discovery clients */
 382 #endif
 383
 384         GSList *pin_callbacks;
 385         GSList *msd_callbacks;
 386
 387         GSList *drivers;
 388         GSList *profiles;
 389
 390         struct oob_handler *oob_handler;
 391
 392         unsigned int load_ltks_id;
 393         unsigned int load_ltks_timeout;
 394
 395         unsigned int confirm_name_id;
 396         unsigned int confirm_name_timeout;
 397
 398         unsigned int pair_device_id;
 399         unsigned int pair_device_timeout;
 400
 401         unsigned int db_id;             /* Service event handler for GATT db */
 402 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 403         uint8_t central_rpa_res_support;
 404         bluetooth_a2dp_role_t a2dp_role;
 405 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
 406         bool scan_filter_support;               /* platform's scan filtering support */
 407         uint8_t scan_type;              /* scan type */
 408         GSList *scan_params;    /* scan filter parameters */
 409         GSList *addr_filters;   /* adress scan filters list */
 410         GSList *service_data_changed_filters;   /* service data changed scan filters list */
 411         GSList *service_uuid_filters;   /* service uuid scan filters list */
 412         GSList *solicit_data_filters;   /* solicitation data scan filters list */
 413         GSList *local_name_filters;     /* local name scan filters list */
 414         GSList *manufaturer_data_filters;       /* manufacturer data scan filters list */
 415         GSList *service_data_filters;   /* service data scan filters list */
 416 #endif
 417 #endif
 418         bool is_default;                /* true if adapter is default one */
 419
 420         struct queue *exps;
 421 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 422         bool le_2m_phy_supported;
 423         bool le_coded_phy_supported;
 424         guint le_batching_available_pkts;
 425 #endif
 426 };
 427
 428 typedef enum {
 429         ADAPTER_AUTHORIZE_DISCONNECTED = 0,
 430         ADAPTER_AUTHORIZE_CHECK_CONNECTED
 431 } adapter_authorize_type;
 432
 433 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 434 enum {
 435         DEINIT_6LOWPAN,
 436         INIT_6LOWPAN
 437 };
 438 #endif
 439
 440 static struct btd_adapter *btd_adapter_lookup(uint16_t index)
 441 {
 442         GList *list;
 443
 444         for (list = g_list_first(adapter_list); list;
 445                                                 list = g_list_next(list)) {
 446                 struct btd_adapter *adapter = list->data;
 447
 448                 if (adapter->dev_id == index)
 449                         return adapter;
 450         }
 451
 452         return NULL;
 453 }
 454
 455 struct btd_adapter *btd_adapter_get_default(void)
 456 {
 457         GList *list;
 458
 459         for (list = g_list_first(adapter_list); list;
 460                                                 list = g_list_next(list)) {
 461                 struct btd_adapter *adapter = list->data;
 462
 463                 if (adapter->is_default)
 464                         return adapter;
 465         }
 466
 467         return NULL;
 468 }
 469
 470 bool btd_adapter_is_default(struct btd_adapter *adapter)
 471 {
 472         if (!adapter)
 473                 return false;
 474
 475         return adapter->is_default;
 476 }
 477
 478 uint16_t btd_adapter_get_index(struct btd_adapter *adapter)
 479 {
 480         if (!adapter)
 481                 return MGMT_INDEX_NONE;
 482
 483         return adapter->dev_id;
 484 }
 485
 486 static gboolean process_auth_queue(gpointer user_data);
 487
 488 static void dev_class_changed_callback(uint16_t index, uint16_t length,
 489                                         const void *param, void *user_data)
 490 {
 491         struct btd_adapter *adapter = user_data;
 492         const struct mgmt_cod *rp = param;
 493         uint32_t dev_class;
 494
 495         if (length < sizeof(*rp)) {
 496                 btd_error(adapter->dev_id,
 497                         "Wrong size of class of device changed parameters");
 498                 return;
 499         }
 500
 501         dev_class = rp->val[0] | (rp->val[1] << 8) | (rp->val[2] << 16);
 502
 503         if (dev_class == adapter->dev_class)
 504                 return;
 505
 506         DBG("Class: 0x%06x", dev_class);
 507
 508         adapter->dev_class = dev_class;
 509
 510         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 511                                                 ADAPTER_INTERFACE, "Class");
 512 }
 513
 514 static void set_dev_class_complete(uint8_t status, uint16_t length,
 515                                         const void *param, void *user_data)
 516 {
 517         struct btd_adapter *adapter = user_data;
 518
 519         if (status != MGMT_STATUS_SUCCESS) {
 520                 btd_error(adapter->dev_id,
 521                                 "Failed to set device class: %s (0x%02x)",
 522                                                 mgmt_errstr(status), status);
 523                 return;
 524         }
 525
 526         /*
 527          * The parameters are identical and also the task that is
 528          * required in both cases. So it is safe to just call the
 529          * event handling functions here.
 530          */
 531         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
 532 }
 533
 534 static void set_dev_class(struct btd_adapter *adapter)
 535 {
 536         struct mgmt_cp_set_dev_class cp;
 537
 538         /*
 539          * If the controller does not support BR/EDR operation,
 540          * there is no point in trying to set a major and minor
 541          * class value.
 542          *
 543          * This is an optimization for Low Energy only controllers.
 544          */
 545         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
 546                 return;
 547
 548         memset(&cp, 0, sizeof(cp));
 549
 550         /*
 551          * Silly workaround for a really stupid kernel bug :(
 552          *
 553          * All current kernel versions assign the major and minor numbers
 554          * straight to dev_class[0] and dev_class[1] without considering
 555          * the proper bit shifting.
 556          *
 557          * To make this work, shift the value in userspace for now until
 558          * we get a fixed kernel version.
 559          */
 560         cp.major = adapter->major_class & 0x1f;
 561         cp.minor = adapter->minor_class << 2;
 562
 563         DBG("sending set device class command for index %u", adapter->dev_id);
 564
 565         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_CLASS,
 566                                 adapter->dev_id, sizeof(cp), &cp,
 567                                 set_dev_class_complete, adapter, NULL) > 0)
 568                 return;
 569
 570         btd_error(adapter->dev_id,
 571                 "Failed to set class of device for index %u", adapter->dev_id);
 572 }
 573
 574 void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
 575                                                         uint8_t minor)
 576 {
 577         if (adapter->major_class == major && adapter->minor_class == minor)
 578                 return;
 579
 580         DBG("class: major %u minor %u", major, minor);
 581
 582         adapter->major_class = major;
 583         adapter->minor_class = minor;
 584
 585         set_dev_class(adapter);
 586 }
 587
 588 static uint8_t get_mode(const char *mode)
 589 {
 590         if (strcasecmp("off", mode) == 0)
 591                 return MODE_OFF;
 592         else if (strcasecmp("connectable", mode) == 0)
 593                 return MODE_CONNECTABLE;
 594         else if (strcasecmp("discoverable", mode) == 0)
 595                 return MODE_DISCOVERABLE;
 596         else
 597                 return MODE_UNKNOWN;
 598 }
 599
 600 const char *btd_adapter_get_storage_dir(struct btd_adapter *adapter)
 601 {
 602         static char dir[25];
 603
 604         if (adapter->bdaddr_type == BDADDR_LE_RANDOM) {
 605                 strcpy(dir, "static-");
 606                 ba2str(&adapter->bdaddr, dir + 7);
 607         } else {
 608                 ba2str(&adapter->bdaddr, dir);
 609         }
 610
 611         return dir;
 612 }
 613
 614 uint8_t btd_adapter_get_address_type(struct btd_adapter *adapter)
 615 {
 616         return adapter->bdaddr_type;
 617 }
 618
 619 static void store_adapter_info(struct btd_adapter *adapter)
 620 {
 621         GKeyFile *key_file;
 622         GError *gerr = NULL;
 623         char filename[PATH_MAX];
 624         char *str;
 625         gsize length = 0;
 626         gboolean discoverable;
 627
 628         key_file = g_key_file_new();
 629
 630         if (adapter->pairable_timeout != btd_opts.pairto)
 631                 g_key_file_set_integer(key_file, "General", "PairableTimeout",
 632                                         adapter->pairable_timeout);
 633
 634         if ((adapter->current_settings & MGMT_SETTING_DISCOVERABLE) &&
 635                                                 !adapter->discoverable_timeout)
 636                 discoverable = TRUE;
 637         else
 638                 discoverable = FALSE;
 639
 640         g_key_file_set_boolean(key_file, "General", "Discoverable",
 641                                                         discoverable);
 642
 643         if (adapter->discoverable_timeout != btd_opts.discovto)
 644                 g_key_file_set_integer(key_file, "General",
 645                                         "DiscoverableTimeout",
 646                                         adapter->discoverable_timeout);
 647
 648         if (adapter->stored_alias)
 649                 g_key_file_set_string(key_file, "General", "Alias",
 650                                                         adapter->stored_alias);
 651 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 652         /* Store A2DP Role */
 653         if (adapter->a2dp_role == BLUETOOTH_A2DP_SINK_ROLE)
 654                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "sink");
 655         else
 656                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "source");
 657 #endif
 658
 659         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/settings",
 660                                                 btd_adapter_get_storage_dir(adapter));
 661
 662         create_file(filename, 0600);
 663
 664         str = g_key_file_to_data(key_file, &length, NULL);
 665         if (!g_file_set_contents(filename, str, length, &gerr)) {
 666                 error("Unable set contents for %s: (%s)", filename,
 667                                                                 gerr->message);
 668                 g_error_free(gerr);
 669         }
 670         g_free(str);
 671
 672         g_key_file_free(key_file);
 673 }
 674
 675 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 676 bluetooth_a2dp_role_t btd_adapter_get_a2dp_role(struct btd_adapter *adapter)
 677 {
 678         if (!adapter)
 679                 return BLUETOOTH_A2DP_SOURCE_ROLE;
 680
 681         return adapter->a2dp_role;
 682 }
 683
 684 void btd_adapter_set_a2dp_role(struct btd_adapter *adapter, bluetooth_a2dp_role_t role)
 685 {
 686         if (!adapter) {
 687                 DBG("Could not set a2dp role");
 688                 return;
 689         }
 690
 691         if (role == BLUETOOTH_A2DP_SOURCE_ROLE) {
 692                 DBG("Set audio source role");
 693                 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
 694         } else if (role == BLUETOOTH_A2DP_SINK_ROLE) {
 695                 DBG("Set audio sink role");
 696                 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
 697         }
 698
 699         store_adapter_info(adapter);
 700 }
 701
 702 void btd_adapter_emit_a2dp_role_changed(struct btd_adapter *adapter)
 703 {
 704         if (!adapter) {
 705                 DBG("Could not emit signal for a2dp role");
 706                 return;
 707         }
 708
 709         DBG("A2dp role: %u", adapter->a2dp_role);
 710
 711         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 712                         ADAPTER_INTERFACE, "A2dpRole");
 713 }
 714 #endif
 715
 716 static void trigger_pairable_timeout(struct btd_adapter *adapter);
 717 static void adapter_start(struct btd_adapter *adapter);
 718 static void adapter_stop(struct btd_adapter *adapter);
 719 static void trigger_passive_scanning(struct btd_adapter *adapter);
 720 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
 721                                                         uint8_t mode);
 722 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 723 static bool load_local_irk(struct btd_adapter *adapter);
 724 static bool set_local_irk(struct btd_adapter *adapter);
 725 static bool set_privacy(struct btd_adapter *adapter, bool privacy);
 726 #endif
 727
 728 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 729 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 730 static gboolean charging_state_timeout_cb(gpointer user_data)
 731 {
 732         struct btd_adapter *adapter = user_data;
 733         int bredr_pkt_type = ACL_PTYPE_MASK;
 734
 735         adapter->charging_timeout = 0;
 736
 737         DBG("Set all connections to BR/EDR type");
 738         g_slist_foreach(adapter->devices, device_change_pkt_type,
 739                         (gpointer)bredr_pkt_type);
 740
 741         return FALSE;
 742 }
 743
 744 static void set_charging_state(struct btd_adapter *adapter,
 745                 charging_state_e state)
 746 {
 747         int br_pkt_type = ACL_PTYPE_MASK |
 748                 HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
 749                 HCI_3DH1 | HCI_3DH3 | HCI_3DH5;
 750
 751         if (adapter->charging == state)
 752                 return;
 753
 754         DBG("old charging state : %d, new charging_state : %d",
 755                         adapter->charging, state);
 756
 757         /*
 758          * Only none / wire charging <-> wireless charging state change should
 759          * be handled.
 760          */
 761         if ((adapter->charging == NONE_CHARGING && state == WIRE_CHARGING) ||
 762             (adapter->charging == WIRE_CHARGING && state == NONE_CHARGING)) {
 763                 DBG("Just update charging state");
 764                 adapter->charging = state;
 765                 return;
 766         }
 767
 768         if (adapter->charging_timeout) {
 769                 g_source_remove(adapter->charging_timeout);
 770                 adapter->charging_timeout = 0;
 771         }
 772
 773         adapter->charging = state;
 774         if (adapter->charging == NONE_CHARGING ||
 775             adapter->charging == WIRE_CHARGING) {
 776                 DBG("Trigger timeout to set connection to BR/EDR type");
 777                 adapter->charging_timeout = g_timeout_add(2000,
 778                                 charging_state_timeout_cb, adapter);
 779         } else if (adapter->charging == WIRELESS_CHARGING) {
 780                 DBG("Set all connections to BR type");
 781                 g_slist_foreach(adapter->devices, device_change_pkt_type,
 782                                 (gpointer)br_pkt_type);
 783         }
 784
 785         return;
 786 }
 787
 788 static gboolean charging_state_changed(DBusConnection *connection,
 789                 DBusMessage *msg, void *user_data)
 790 {
 791         struct btd_adapter *adapter = user_data;
 792         int state = 0;
 793
 794         DBG("charging_state_changed");
 795
 796         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &state,
 797                                 DBUS_TYPE_INVALID))
 798                 return TRUE;
 799
 800         set_charging_state(adapter, state);
 801
 802         return TRUE;
 803 }
 804
 805 charging_state_e get_charging_state(struct btd_adapter *adapter)
 806 {
 807         DBG("charging_state: %d", adapter->charging);
 808         return adapter->charging;
 809 }
 810 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 811
 812 static int compare_slot(gconstpointer a, gconstpointer b)
 813 {
 814         const struct adv_info *adv = a;
 815         const int id = *(int*)b;
 816
 817         return (adv->slot_id == id ? 0 : -1);
 818 }
 819
 820 static struct adv_info *find_advertiser(struct btd_adapter *adapter,
 821                                 int slot_id)
 822 {
 823         GSList *list;
 824
 825         list = g_slist_find_custom(adapter->adv_list, &slot_id,
 826                                                         compare_slot);
 827         if (list)
 828                 return list->data;
 829
 830         return NULL;
 831 }
 832
 833 static struct adv_info *create_advertiser(struct btd_adapter *adapter,
 834                                         int slot_id)
 835 {
 836         struct adv_info *adv;
 837
 838         if (!adapter)
 839                 return NULL;
 840
 841         adv = find_advertiser(adapter, slot_id);
 842         if (adv != NULL) {
 843                 DBG("Aleady existed. solt_id [%d]", slot_id);
 844                 return adv;
 845         }
 846
 847         DBG("Create adv slot id : %d", slot_id);
 848
 849         adv = g_new0(struct adv_info, 1);
 850         if (adv == NULL)
 851                 return NULL;
 852
 853         adv->slot_id = slot_id;
 854
 855         adapter->adv_list = g_slist_append(adapter->adv_list, adv);
 856         return adv;
 857 }
 858
 859
 860 static void advertising_state_changed(struct btd_adapter *adapter,
 861                                         int slot_id, bool enabled)
 862 {
 863         struct adv_info *adv;
 864         int id = slot_id;
 865         int state = enabled;
 866
 867         if (!adapter)
 868                 return;
 869
 870         adv = find_advertiser(adapter, slot_id);
 871         if (!adv) {
 872                 DBG("Unable to find advertiser [%d]", slot_id);
 873                 return;
 874         }
 875
 876         adv->status = enabled;
 877         DBG("slot_id %d, status %d", adv->slot_id, adv->status);
 878
 879         g_dbus_emit_signal(dbus_conn, adapter->path,
 880                         ADAPTER_INTERFACE, "AdvertisingEnabled",
 881                         DBUS_TYPE_INT32, &id,
 882                         DBUS_TYPE_BOOLEAN, &state,
 883                         DBUS_TYPE_INVALID);
 884 }
 885
 886 static void clear_advertiser_cb(gpointer data, gpointer user_data)
 887 {
 888         struct adv_info *adv = data;
 889         struct btd_adapter *adapter = user_data;
 890
 891         if (adv->status)
 892                 advertising_state_changed(adapter, adv->slot_id, 0);
 893 }
 894
 895 static void advertiser_cleanup(struct btd_adapter *adapter)
 896 {
 897         if (!adapter->adv_list)
 898                 return;
 899
 900         g_slist_foreach(adapter->adv_list, clear_advertiser_cb, adapter);
 901         g_slist_free(adapter->adv_list);
 902         adapter->adv_list = NULL;
 903 }
 904
 905 static void update_advertiser_address(gpointer data, gpointer user_data)
 906 {
 907         struct adv_info *adv = data;
 908         struct btd_adapter *adapter = user_data;
 909
 910         if (adv->slot_id > 0 && adv->status == 1)
 911                 adapter_le_set_random_address(adapter, &adapter->rpa, adv->slot_id);
 912 }
 913
 914 static void rpa_changed_callback(uint16_t index, uint16_t length,
 915                                         const void *param, void *user_data)
 916 {
 917         const struct mgmt_ev_rpa_changed *ev = param;
 918         struct btd_adapter *adapter = user_data;
 919         char addr[18];
 920
 921         if (length < sizeof(*ev)) {
 922                 error("Too small rpa changed event");
 923                 return;
 924         }
 925
 926         ba2str(&ev->bdaddr, addr);
 927         DBG("RPA changed %s", addr);
 928         bacpy(&adapter->rpa, &ev->bdaddr);
 929
 930         if (!adapter->adv_list)
 931                 return;
 932
 933         g_slist_foreach(adapter->adv_list, update_advertiser_address, adapter);
 934 }
 935
 936 #endif
 937
 938 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 939 #define OCF_PAGE_SCAN_TIMEOUT                   0x0018
 940 #define OGF_PAGE_SCAN_TIMEOUT           0x03
 941
 942 typedef struct {
 943         uint16_t        timeout;        /* Value */
 944 } __attribute__ ((packed)) hci_page_scan_timeout;
 945 #define HCI_PAGE_SCAN_TIMEOUT_CP_SIZE 2
 946
 947 static gboolean send_sprd_page_scan_timeout(gint value)
 948 {
 949         int dd;
 950         hci_page_scan_timeout cp;
 951         DBG("+");
 952         dd = hci_open_dev(0);
 953         cp.timeout = value;
 954         if (hci_send_cmd(dd, OGF_PAGE_SCAN_TIMEOUT, OCF_PAGE_SCAN_TIMEOUT,
 955                                 HCI_PAGE_SCAN_TIMEOUT_CP_SIZE, &cp) < 0) {
 956                 DBG("Error: While setting Page Timeout value");
 957                 hci_close_dev(dd);
 958                 return FALSE;
 959         }
 960         DBG("Page Scan Timeout Value Patch %d", value);
 961
 962         hci_close_dev(dd);
 963
 964         return TRUE;
 965 }
 966 #endif
 967
 968 static void settings_changed(struct btd_adapter *adapter, uint32_t settings)
 969 {
 970         uint32_t changed_mask;
 971
 972         changed_mask = adapter->current_settings ^ settings;
 973
 974         adapter->current_settings = settings;
 975         adapter->pending_settings &= ~changed_mask;
 976
 977         DBG("Changed settings: 0x%08x", changed_mask);
 978         DBG("Pending settings: 0x%08x", adapter->pending_settings);
 979
 980         if (changed_mask & MGMT_SETTING_POWERED) {
 981                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 982                                         ADAPTER_INTERFACE, "Powered");
 983
 984                 if (adapter->current_settings & MGMT_SETTING_POWERED) {
 985                         adapter_start(adapter);
 986
 987 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 988                         if (TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN) {
 989                                 /* Approx 6.4 Seconds of timeout */
 990                                 /* This Added because Z3 device was not able to connect with
 991                                   * some device as it was getting Page Timeout
 992                                   * (LG HBS800, sony carkit) etc. So, Increasing Page timeout value
 993                                   * from 5.12 Sec (which is default) to ~6.4sec*/
 994                                 DBG("Setting value");
 995                                 send_sprd_page_scan_timeout(10240);
 996                         }
 997 #endif
 998                 } else {
 999                         adapter_stop(adapter);
1000
1001                         if (powering_down) {
1002                                 adapter_remaining--;
1003
1004                                 if (!adapter_remaining)
1005                                         btd_exit();
1006                         }
1007                 }
1008         }
1009
1010         if ((changed_mask & MGMT_SETTING_LE) &&
1011                                 btd_adapter_get_powered(adapter) &&
1012                                 (adapter->current_settings & MGMT_SETTING_LE))
1013                 trigger_passive_scanning(adapter);
1014
1015         if (changed_mask & MGMT_SETTING_DISCOVERABLE) {
1016                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1017                                         ADAPTER_INTERFACE, "Discoverable");
1018                 /* Only persist discoverable setting if it was not set
1019                  * temporarily by discovery.
1020                  */
1021                 if (!adapter->discovery_discoverable)
1022                         store_adapter_info(adapter);
1023                 btd_adv_manager_refresh(adapter->adv_manager);
1024         }
1025
1026         if (changed_mask & MGMT_SETTING_BONDABLE) {
1027                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1028                                         ADAPTER_INTERFACE, "Pairable");
1029
1030                 trigger_pairable_timeout(adapter);
1031         }
1032
1033 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1034         if (changed_mask & MGMT_SETTING_ADVERTISING) {
1035                 if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
1036                         (adapter->advertising)) {
1037                         return;
1038                 }
1039
1040                 adapter->advertising = adapter->current_settings & MGMT_SETTING_ADVERTISING;
1041                 advertising_state_changed(adapter, 0, adapter->advertising);
1042         }
1043
1044         if ((changed_mask & MGMT_SETTING_PRIVACY) &&
1045             !(adapter->current_settings & MGMT_SETTING_PRIVACY)) {
1046                 DBG("LE Privacy feature is disabled");
1047
1048                 /*
1049                  * Some Android devices don't consider the device as LE one,
1050                  * if the device doesn't distribute IRK when pairing.
1051                  * Because of this compatibility issue, set IRK
1052                  * even though privacy feature is disabled.
1053                  */
1054                 set_local_irk(adapter);
1055         }
1056 #endif
1057 }
1058
1059 static void new_settings_callback(uint16_t index, uint16_t length,
1060                                         const void *param, void *user_data)
1061 {
1062         struct btd_adapter *adapter = user_data;
1063         uint32_t settings;
1064
1065         if (length < sizeof(settings)) {
1066                 btd_error(adapter->dev_id,
1067                                 "Wrong size of new settings parameters");
1068                 return;
1069         }
1070
1071         settings = get_le32(param);
1072
1073         if (settings == adapter->current_settings)
1074                 return;
1075
1076         DBG("Settings: 0x%08x", settings);
1077
1078         settings_changed(adapter, settings);
1079 }
1080
1081 static void set_mode_complete(uint8_t status, uint16_t length,
1082                                         const void *param, void *user_data)
1083 {
1084         struct btd_adapter *adapter = user_data;
1085
1086         if (status != MGMT_STATUS_SUCCESS) {
1087                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
1088                                                 mgmt_errstr(status), status);
1089                 return;
1090         }
1091
1092         /*
1093          * The parameters are identical and also the task that is
1094          * required in both cases. So it is safe to just call the
1095          * event handling functions here.
1096          */
1097         new_settings_callback(adapter->dev_id, length, param, adapter);
1098 }
1099
1100 static void remove_temporary_devices(struct btd_adapter *adapter)
1101 {
1102         GSList *l, *next;
1103
1104         for (l = adapter->devices; l; l = next) {
1105                 struct btd_device *dev = l->data;
1106
1107                 next = g_slist_next(l);
1108                 if (device_is_temporary(dev))
1109                         btd_adapter_remove_device(adapter, dev);
1110         }
1111 }
1112
1113 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
1114                                                         uint8_t mode)
1115 {
1116         struct mgmt_mode cp;
1117         uint32_t setting = 0;
1118
1119         memset(&cp, 0, sizeof(cp));
1120         cp.val = mode;
1121
1122         switch (opcode) {
1123         case MGMT_OP_SET_POWERED:
1124                 setting = MGMT_SETTING_POWERED;
1125                 break;
1126         case MGMT_OP_SET_CONNECTABLE:
1127                 setting = MGMT_SETTING_CONNECTABLE;
1128                 break;
1129         case MGMT_OP_SET_FAST_CONNECTABLE:
1130                 setting = MGMT_SETTING_FAST_CONNECTABLE;
1131                 break;
1132         case MGMT_OP_SET_DISCOVERABLE:
1133                 setting = MGMT_SETTING_DISCOVERABLE;
1134                 break;
1135         case MGMT_OP_SET_BONDABLE:
1136                 setting = MGMT_SETTING_BONDABLE;
1137                 break;
1138         }
1139
1140         adapter->pending_settings |= setting;
1141
1142         DBG("sending set mode command for index %u", adapter->dev_id);
1143
1144         if (mgmt_send(adapter->mgmt, opcode,
1145                                 adapter->dev_id, sizeof(cp), &cp,
1146                                 set_mode_complete, adapter, NULL) > 0)
1147                 return true;
1148
1149         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1150                                                         adapter->dev_id);
1151
1152         return false;
1153 }
1154
1155 static bool set_discoverable(struct btd_adapter *adapter, uint8_t mode,
1156                                                         uint16_t timeout)
1157 {
1158         struct mgmt_cp_set_discoverable cp;
1159
1160         memset(&cp, 0, sizeof(cp));
1161         cp.val = mode;
1162         cp.timeout = htobs(timeout);
1163
1164         DBG("sending set mode command for index %u", adapter->dev_id);
1165
1166         if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
1167                 if (mode)
1168                         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, mode);
1169                 else
1170                         /* This also disables discoverable so we're done */
1171                         return set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
1172                                                                         mode);
1173         }
1174
1175         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DISCOVERABLE,
1176                                 adapter->dev_id, sizeof(cp), &cp,
1177                                 set_mode_complete, adapter, NULL) > 0)
1178                 return true;
1179
1180         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1181                                                         adapter->dev_id);
1182
1183         return false;
1184 }
1185
1186 static bool pairable_timeout_handler(gpointer user_data)
1187 {
1188         struct btd_adapter *adapter = user_data;
1189
1190         adapter->pairable_timeout_id = 0;
1191
1192         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
1193
1194         return FALSE;
1195 }
1196
1197 static void trigger_pairable_timeout(struct btd_adapter *adapter)
1198 {
1199         if (adapter->pairable_timeout_id > 0) {
1200                 timeout_remove(adapter->pairable_timeout_id);
1201                 adapter->pairable_timeout_id = 0;
1202         }
1203
1204         if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
1205                 return;
1206
1207         if (adapter->pairable_timeout > 0)
1208                 adapter->pairable_timeout_id =
1209                         timeout_add_seconds(adapter->pairable_timeout,
1210                                         pairable_timeout_handler, adapter,
1211                                         NULL);
1212 }
1213
1214 static void local_name_changed_callback(uint16_t index, uint16_t length,
1215                                         const void *param, void *user_data)
1216 {
1217         struct btd_adapter *adapter = user_data;
1218         const struct mgmt_cp_set_local_name *rp = param;
1219
1220         if (length < sizeof(*rp)) {
1221                 btd_error(adapter->dev_id,
1222                                 "Wrong size of local name changed parameters");
1223                 return;
1224         }
1225
1226         if (!g_strcmp0(adapter->short_name, (const char *) rp->short_name) &&
1227                         !g_strcmp0(adapter->name, (const char *) rp->name))
1228                 return;
1229
1230         DBG("Name: %s", rp->name);
1231         DBG("Short name: %s", rp->short_name);
1232
1233         g_free(adapter->name);
1234         adapter->name = g_strdup((const char *) rp->name);
1235
1236         g_free(adapter->short_name);
1237         adapter->short_name = g_strdup((const char *) rp->short_name);
1238
1239         /*
1240          * Changing the name (even manually via HCI) will update the
1241          * current alias property.
1242          *
1243          * In case the name is empty, use the short name.
1244          *
1245          * There is a difference between the stored alias (which is
1246          * configured by the user) and the current alias. The current
1247          * alias is temporary for the lifetime of the daemon.
1248          */
1249         if (adapter->name && adapter->name[0] != '\0') {
1250                 g_free(adapter->current_alias);
1251                 adapter->current_alias = g_strdup(adapter->name);
1252         } else {
1253                 g_free(adapter->current_alias);
1254                 adapter->current_alias = g_strdup(adapter->short_name);
1255         }
1256
1257         DBG("Current alias: %s", adapter->current_alias);
1258
1259         if (!adapter->current_alias)
1260                 return;
1261
1262         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1263                                                 ADAPTER_INTERFACE, "Alias");
1264
1265         attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
1266                                 (const uint8_t *) adapter->current_alias,
1267                                         strlen(adapter->current_alias));
1268 }
1269
1270 static void set_local_name_complete(uint8_t status, uint16_t length,
1271                                         const void *param, void *user_data)
1272 {
1273         struct btd_adapter *adapter = user_data;
1274
1275         if (status != MGMT_STATUS_SUCCESS) {
1276                 btd_error(adapter->dev_id,
1277                                 "Failed to set local name: %s (0x%02x)",
1278                                                 mgmt_errstr(status), status);
1279                 return;
1280         }
1281
1282         /*
1283          * The parameters are identical and also the task that is
1284          * required in both cases. So it is safe to just call the
1285          * event handling functions here.
1286          */
1287         local_name_changed_callback(adapter->dev_id, length, param, adapter);
1288 }
1289
1290 static int set_name(struct btd_adapter *adapter, const char *name)
1291 {
1292         struct mgmt_cp_set_local_name cp;
1293         char maxname[MAX_NAME_LENGTH];
1294
1295         memset(maxname, 0, sizeof(maxname));
1296         strncpy(maxname, name, MAX_NAME_LENGTH - 1);
1297
1298         if (!g_utf8_validate(maxname, -1, NULL)) {
1299                 btd_error(adapter->dev_id,
1300                         "Name change failed: supplied name isn't valid UTF-8");
1301                 return -EINVAL;
1302         }
1303
1304         memset(&cp, 0, sizeof(cp));
1305         strncpy((char *) cp.name, maxname, sizeof(cp.name) - 1);
1306
1307         DBG("sending set local name command for index %u", adapter->dev_id);
1308
1309         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LOCAL_NAME,
1310                                 adapter->dev_id, sizeof(cp), &cp,
1311                                 set_local_name_complete, adapter, NULL) > 0)
1312                 return 0;
1313
1314         btd_error(adapter->dev_id, "Failed to set local name for index %u",
1315                                                         adapter->dev_id);
1316
1317         return -EIO;
1318 }
1319
1320 int adapter_set_name(struct btd_adapter *adapter, const char *name)
1321 {
1322         if (g_strcmp0(adapter->system_name, name) == 0)
1323                 return 0;
1324
1325         DBG("name: %s", name);
1326
1327         g_free(adapter->system_name);
1328         adapter->system_name = g_strdup(name);
1329
1330         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1331                                                 ADAPTER_INTERFACE, "Name");
1332
1333         /* alias is preferred over system name */
1334         if (adapter->stored_alias)
1335                 return 0;
1336
1337         DBG("alias: %s", name);
1338
1339         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1340                                                 ADAPTER_INTERFACE, "Alias");
1341
1342         return set_name(adapter, name);
1343 }
1344
1345 struct btd_device *btd_adapter_find_device(struct btd_adapter *adapter,
1346                                                         const bdaddr_t *dst,
1347                                                         uint8_t bdaddr_type)
1348 {
1349         struct device_addr_type addr;
1350         struct btd_device *device;
1351         GSList *list;
1352
1353         if (!adapter)
1354                 return NULL;
1355
1356         bacpy(&addr.bdaddr, dst);
1357         addr.bdaddr_type = bdaddr_type;
1358
1359 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1360         list = g_slist_find_custom(adapter->devices, &addr,
1361                                                 device_addr_type_strict_cmp);
1362         if (list) {
1363                 device = list->data;
1364                 return device;
1365         }
1366 #endif
1367         list = g_slist_find_custom(adapter->devices, &addr,
1368                                                         device_addr_type_cmp);
1369         if (!list)
1370                 return NULL;
1371
1372         device = list->data;
1373
1374         /*
1375          * If we're looking up based on public address and the address
1376          * was not previously used over this bearer we may need to
1377          * update LE or BR/EDR support information.
1378          */
1379         if (bdaddr_type == BDADDR_BREDR)
1380                 device_set_bredr_support(device);
1381         else
1382                 device_set_le_support(device, bdaddr_type);
1383
1384         return device;
1385 }
1386
1387 static int device_path_cmp(gconstpointer a, gconstpointer b)
1388 {
1389         const struct btd_device *device = a;
1390         const char *path = b;
1391         const char *dev_path = device_get_path(device);
1392
1393         return strcasecmp(dev_path, path);
1394 }
1395
1396 struct btd_device *btd_adapter_find_device_by_path(struct btd_adapter *adapter,
1397                                                    const char *path)
1398 {
1399         GSList *list;
1400
1401         if (!adapter)
1402                 return NULL;
1403
1404         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
1405         if (!list)
1406                 return NULL;
1407
1408         return list->data;
1409 }
1410
1411 static void uuid_to_uuid128(uuid_t *uuid128, const uuid_t *uuid)
1412 {
1413         if (uuid->type == SDP_UUID16)
1414                 sdp_uuid16_to_uuid128(uuid128, uuid);
1415         else if (uuid->type == SDP_UUID32)
1416                 sdp_uuid32_to_uuid128(uuid128, uuid);
1417         else
1418                 memcpy(uuid128, uuid, sizeof(*uuid));
1419 }
1420
1421 static bool is_supported_uuid(const uuid_t *uuid)
1422 {
1423         uuid_t tmp;
1424
1425         /* mgmt versions from 1.3 onwards support all types of UUIDs */
1426         if (MGMT_VERSION(mgmt_version, mgmt_revision) >= MGMT_VERSION(1, 3))
1427                 return true;
1428
1429         uuid_to_uuid128(&tmp, uuid);
1430
1431         if (!sdp_uuid128_to_uuid(&tmp))
1432                 return false;
1433
1434         if (tmp.type != SDP_UUID16)
1435                 return false;
1436
1437         return true;
1438 }
1439
1440 static void add_uuid_complete(uint8_t status, uint16_t length,
1441                                         const void *param, void *user_data)
1442 {
1443         struct btd_adapter *adapter = user_data;
1444
1445         if (status != MGMT_STATUS_SUCCESS) {
1446                 btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
1447                                                 mgmt_errstr(status), status);
1448                 return;
1449         }
1450
1451         /*
1452          * The parameters are identical and also the task that is
1453          * required in both cases. So it is safe to just call the
1454          * event handling functions here.
1455          */
1456         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1457
1458         if (adapter->initialized)
1459                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1460                                                 ADAPTER_INTERFACE, "UUIDs");
1461 }
1462
1463 static int add_uuid(struct btd_adapter *adapter, uuid_t *uuid, uint8_t svc_hint)
1464 {
1465         struct mgmt_cp_add_uuid cp;
1466         uuid_t uuid128;
1467         uint128_t uint128;
1468
1469         if (!is_supported_uuid(uuid)) {
1470                 btd_warn(adapter->dev_id,
1471                                 "Ignoring unsupported UUID for addition");
1472                 return 0;
1473         }
1474
1475         uuid_to_uuid128(&uuid128, uuid);
1476
1477         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1478         htob128(&uint128, (uint128_t *) cp.uuid);
1479         cp.svc_hint = svc_hint;
1480
1481         DBG("sending add uuid command for index %u", adapter->dev_id);
1482
1483         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_UUID,
1484                                 adapter->dev_id, sizeof(cp), &cp,
1485                                 add_uuid_complete, adapter, NULL) > 0)
1486                 return 0;
1487
1488         btd_error(adapter->dev_id, "Failed to add UUID for index %u",
1489                                                         adapter->dev_id);
1490
1491         return -EIO;
1492 }
1493
1494 static void remove_uuid_complete(uint8_t status, uint16_t length,
1495                                         const void *param, void *user_data)
1496 {
1497         struct btd_adapter *adapter = user_data;
1498
1499         if (status != MGMT_STATUS_SUCCESS) {
1500                 btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
1501                                                 mgmt_errstr(status), status);
1502                 return;
1503         }
1504
1505         /*
1506          * The parameters are identical and also the task that is
1507          * required in both cases. So it is safe to just call the
1508          * event handling functions here.
1509          */
1510         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1511
1512         if (adapter->initialized)
1513                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1514                                                 ADAPTER_INTERFACE, "UUIDs");
1515 }
1516
1517 static int remove_uuid(struct btd_adapter *adapter, uuid_t *uuid)
1518 {
1519         struct mgmt_cp_remove_uuid cp;
1520         uuid_t uuid128;
1521         uint128_t uint128;
1522
1523         if (!is_supported_uuid(uuid)) {
1524                 btd_warn(adapter->dev_id,
1525                                 "Ignoring unsupported UUID for removal");
1526                 return 0;
1527         }
1528
1529         uuid_to_uuid128(&uuid128, uuid);
1530
1531         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1532         htob128(&uint128, (uint128_t *) cp.uuid);
1533
1534         DBG("sending remove uuid command for index %u", adapter->dev_id);
1535
1536         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1537                                 adapter->dev_id, sizeof(cp), &cp,
1538                                 remove_uuid_complete, adapter, NULL) > 0)
1539                 return 0;
1540
1541         btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
1542                                                         adapter->dev_id);
1543
1544         return -EIO;
1545 }
1546
1547 static void clear_uuids_complete(uint8_t status, uint16_t length,
1548                                         const void *param, void *user_data)
1549 {
1550         struct btd_adapter *adapter = user_data;
1551
1552         if (status != MGMT_STATUS_SUCCESS) {
1553                 btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
1554                                                 mgmt_errstr(status), status);
1555                 return;
1556         }
1557
1558         /*
1559          * The parameters are identical and also the task that is
1560          * required in both cases. So it is safe to just call the
1561          * event handling functions here.
1562          */
1563         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1564 }
1565
1566 static int clear_uuids(struct btd_adapter *adapter)
1567 {
1568         struct mgmt_cp_remove_uuid cp;
1569
1570         memset(&cp, 0, sizeof(cp));
1571
1572         DBG("sending clear uuids command for index %u", adapter->dev_id);
1573
1574         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1575                                 adapter->dev_id, sizeof(cp), &cp,
1576                                 clear_uuids_complete, adapter, NULL) > 0)
1577                 return 0;
1578
1579         btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
1580                                                         adapter->dev_id);
1581
1582         return -EIO;
1583 }
1584
1585 static uint8_t get_uuid_mask(uuid_t *uuid)
1586 {
1587         if (uuid->type != SDP_UUID16)
1588                 return 0;
1589
1590         switch (uuid->value.uuid16) {
1591         case DIALUP_NET_SVCLASS_ID:
1592         case CIP_SVCLASS_ID:
1593                 return 0x42;    /* Telephony & Networking */
1594         case IRMC_SYNC_SVCLASS_ID:
1595         case OBEX_OBJPUSH_SVCLASS_ID:
1596         case OBEX_FILETRANS_SVCLASS_ID:
1597         case IRMC_SYNC_CMD_SVCLASS_ID:
1598         case PBAP_PSE_SVCLASS_ID:
1599                 return 0x10;    /* Object Transfer */
1600         case HEADSET_SVCLASS_ID:
1601         case HANDSFREE_SVCLASS_ID:
1602                 return 0x20;    /* Audio */
1603         case CORDLESS_TELEPHONY_SVCLASS_ID:
1604         case INTERCOM_SVCLASS_ID:
1605         case FAX_SVCLASS_ID:
1606         case SAP_SVCLASS_ID:
1607         /*
1608          * Setting the telephony bit for the handsfree audio gateway
1609          * role is not required by the HFP specification, but the
1610          * Nokia 616 carkit is just plain broken! It will refuse
1611          * pairing without this bit set.
1612          */
1613         case HANDSFREE_AGW_SVCLASS_ID:
1614                 return 0x40;    /* Telephony */
1615         case AUDIO_SOURCE_SVCLASS_ID:
1616         case VIDEO_SOURCE_SVCLASS_ID:
1617                 return 0x08;    /* Capturing */
1618         case AUDIO_SINK_SVCLASS_ID:
1619         case VIDEO_SINK_SVCLASS_ID:
1620                 return 0x04;    /* Rendering */
1621         case PANU_SVCLASS_ID:
1622         case NAP_SVCLASS_ID:
1623         case GN_SVCLASS_ID:
1624                 return 0x02;    /* Networking */
1625         default:
1626                 return 0;
1627         }
1628 }
1629
1630 static int uuid_cmp(const void *a, const void *b)
1631 {
1632         const sdp_record_t *rec = a;
1633         const uuid_t *uuid = b;
1634
1635         return sdp_uuid_cmp(&rec->svclass, uuid);
1636 }
1637
1638 static void adapter_service_insert(struct btd_adapter *adapter, sdp_record_t *rec)
1639 {
1640         sdp_list_t *browse_list = NULL;
1641         uuid_t browse_uuid;
1642         gboolean new_uuid;
1643
1644         DBG("%s", adapter->path);
1645
1646 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1647         if (rec == NULL) {
1648                 DBG("record is NULL return");
1649                 return;
1650         }
1651 #endif
1652
1653         /* skip record without a browse group */
1654         if (sdp_get_browse_groups(rec, &browse_list) < 0) {
1655                 DBG("skipping record without browse group");
1656                 return;
1657         }
1658
1659         sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
1660
1661         /* skip record without public browse group */
1662         if (!sdp_list_find(browse_list, &browse_uuid, sdp_uuid_cmp))
1663                 goto done;
1664
1665         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1666                 new_uuid = TRUE;
1667         else
1668                 new_uuid = FALSE;
1669
1670         adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1671                                                                 record_sort);
1672
1673         if (new_uuid) {
1674                 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1675                 add_uuid(adapter, &rec->svclass, svc_hint);
1676         }
1677
1678 done:
1679         sdp_list_free(browse_list, free);
1680 }
1681
1682 int adapter_service_add(struct btd_adapter *adapter, sdp_record_t *rec)
1683 {
1684         int ret;
1685
1686         DBG("%s", adapter->path);
1687
1688         ret = add_record_to_server(&adapter->bdaddr, rec);
1689         if (ret < 0)
1690                 return ret;
1691
1692         adapter_service_insert(adapter, rec);
1693
1694         return 0;
1695 }
1696
1697 void adapter_service_remove(struct btd_adapter *adapter, uint32_t handle)
1698 {
1699         sdp_record_t *rec = sdp_record_find(handle);
1700
1701         DBG("%s", adapter->path);
1702
1703         if (!rec)
1704                 return;
1705
1706         adapter->services = sdp_list_remove(adapter->services, rec);
1707
1708         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1709                 remove_uuid(adapter, &rec->svclass);
1710
1711         remove_record_from_server(rec->handle);
1712 }
1713
1714 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1715 static void adapter_print_devices(struct btd_adapter *adapter)
1716 {
1717         GSList *dev;
1718
1719         dev = adapter->devices;
1720         for (; dev; dev = dev->next)
1721                 device_print_addr(dev->data);
1722 }
1723 #endif
1724
1725 static void adapter_add_device(struct btd_adapter *adapter,
1726                                                 struct btd_device *device);
1727
1728 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
1729                                                 const bdaddr_t *bdaddr,
1730                                                 uint8_t bdaddr_type)
1731 {
1732         struct btd_device *device;
1733
1734         device = device_create(adapter, bdaddr, bdaddr_type);
1735         if (!device)
1736                 return NULL;
1737
1738         adapter_add_device(adapter, device);
1739
1740 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1741         device_print_addr(device);
1742         DBG("devices list count : %d", g_slist_length(adapter->devices));
1743 #endif
1744
1745         return device;
1746 }
1747
1748 static void service_auth_cancel(struct service_auth *auth)
1749 {
1750         DBusError derr;
1751
1752         if (auth->svc_id > 0)
1753                 device_remove_svc_complete_callback(auth->device,
1754                                                                 auth->svc_id);
1755
1756         dbus_error_init(&derr);
1757         dbus_set_error_const(&derr, ERROR_INTERFACE ".Canceled", NULL);
1758
1759         auth->cb(&derr, auth->user_data);
1760
1761         dbus_error_free(&derr);
1762
1763         if (auth->agent != NULL) {
1764                 agent_cancel(auth->agent);
1765                 agent_unref(auth->agent);
1766         }
1767
1768         g_free(auth);
1769 }
1770
1771 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1772 void btd_adapter_unpair_device(struct btd_adapter *adapter,
1773                                 struct btd_device *dev)
1774 {
1775         DBG("+");
1776         GList *l;
1777
1778         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1779
1780 //      adapter->devices = g_slist_remove(adapter->devices, dev);
1781 //
1782 //      adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1783 //                                                                      dev);
1784
1785         adapter->connections = g_slist_remove(adapter->connections, dev);
1786
1787         if (adapter->connect_le == dev)
1788                 adapter->connect_le = NULL;
1789
1790         l = adapter->auths->head;
1791         while (l != NULL) {
1792                 struct service_auth *auth = l->data;
1793                 GList *next = g_list_next(l);
1794
1795                 if (auth->device != dev) {
1796                         l = next;
1797                         continue;
1798                 }
1799
1800                 g_queue_delete_link(adapter->auths, l);
1801                 l = next;
1802
1803                 service_auth_cancel(auth);
1804         }
1805
1806         device_unpair(dev, TRUE);
1807         DBG("-");
1808 }
1809 #endif
1810
1811 static void adapter_remove_device(struct btd_adapter *adapter,
1812                                                 struct btd_device *device);
1813
1814 void btd_adapter_remove_device(struct btd_adapter *adapter,
1815                                 struct btd_device *dev)
1816 {
1817         GList *l;
1818
1819         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1820
1821         adapter_remove_device(adapter, dev);
1822 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1823         btd_adv_monitor_device_remove(adapter->adv_monitor_manager, dev);
1824 #endif
1825         adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1826                                                                         dev);
1827
1828         adapter->connections = g_slist_remove(adapter->connections, dev);
1829
1830         if (adapter->connect_le == dev)
1831                 adapter->connect_le = NULL;
1832
1833         l = adapter->auths->head;
1834         while (l != NULL) {
1835                 struct service_auth *auth = l->data;
1836                 GList *next = g_list_next(l);
1837
1838                 if (auth->device != dev) {
1839                         l = next;
1840                         continue;
1841                 }
1842
1843                 g_queue_delete_link(adapter->auths, l);
1844                 l = next;
1845
1846                 service_auth_cancel(auth);
1847         }
1848
1849         device_remove(dev, TRUE);
1850 }
1851
1852 struct btd_device *btd_adapter_get_device(struct btd_adapter *adapter,
1853                                         const bdaddr_t *addr,
1854                                         uint8_t addr_type)
1855 {
1856         struct btd_device *device;
1857
1858         if (!adapter)
1859                 return NULL;
1860
1861 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1862         if (!bacmp(addr, BDADDR_ANY))
1863                 return NULL;
1864 #endif
1865
1866         device = btd_adapter_find_device(adapter, addr, addr_type);
1867         if (device)
1868                 return device;
1869
1870         return adapter_create_device(adapter, addr, addr_type);
1871 }
1872
1873 sdp_list_t *btd_adapter_get_services(struct btd_adapter *adapter)
1874 {
1875         return adapter->services;
1876 }
1877
1878 static void passive_scanning_complete(uint8_t status, uint16_t length,
1879                                         const void *param, void *user_data)
1880 {
1881         struct btd_adapter *adapter = user_data;
1882         const struct mgmt_cp_start_discovery *rp = param;
1883
1884         DBG("status 0x%02x", status);
1885
1886         if (length < sizeof(*rp)) {
1887                 btd_error(adapter->dev_id,
1888                         "Wrong size of start scanning return parameters");
1889                 return;
1890         }
1891
1892         if (status == MGMT_STATUS_SUCCESS) {
1893                 adapter->discovery_type = rp->type;
1894                 adapter->discovery_enable = 0x01;
1895         }
1896 }
1897
1898 static bool passive_scanning_timeout(gpointer user_data)
1899 {
1900         struct btd_adapter *adapter = user_data;
1901         struct mgmt_cp_start_discovery cp;
1902
1903         adapter->passive_scan_timeout = 0;
1904
1905         cp.type = SCAN_TYPE_LE;
1906 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1907         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
1908                                 adapter->dev_id, sizeof(cp), &cp,
1909                                 passive_scanning_complete, adapter, NULL);
1910 #else
1911         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
1912                                 adapter->dev_id, sizeof(cp), &cp,
1913                                 passive_scanning_complete, adapter, NULL);
1914 #endif
1915         return FALSE;
1916 }
1917
1918 static void trigger_passive_scanning(struct btd_adapter *adapter)
1919 {
1920         if (!(adapter->current_settings & MGMT_SETTING_LE))
1921                 return;
1922
1923         DBG("");
1924
1925         if (adapter->passive_scan_timeout > 0) {
1926                 timeout_remove(adapter->passive_scan_timeout);
1927                 adapter->passive_scan_timeout = 0;
1928         }
1929
1930         /*
1931          * When the kernel background scanning is available, there is
1932          * no need to start any discovery. The kernel will keep scanning
1933          * as long as devices are in its auto-connection list.
1934          */
1935         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
1936                 return;
1937
1938         /*
1939          * If any client is running a discovery right now, then do not
1940          * even try to start passive scanning.
1941          *
1942          * The discovery procedure is using interleaved scanning and
1943          * thus will discover Low Energy devices as well.
1944          */
1945 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1946         if (adapter->discovery_list || adapter->le_discovery_list)
1947                 return;
1948 #else
1949         if (adapter->discovery_list)
1950                 return;
1951 #endif
1952
1953         if (adapter->discovery_enable == 0x01)
1954                 return;
1955
1956         /*
1957          * In case the discovery is suspended (for example for an ongoing
1958          * pairing attempt), then also do not start passive scanning.
1959          */
1960         if (adapter->discovery_suspended)
1961                 return;
1962
1963         /*
1964          * If the list of connectable Low Energy devices is empty,
1965          * then do not start passive scanning.
1966          */
1967         if (!adapter->connect_list)
1968                 return;
1969
1970         adapter->passive_scan_timeout = timeout_add_seconds(CONN_SCAN_TIMEOUT,
1971                                         passive_scanning_timeout, adapter,
1972                                         NULL);
1973 }
1974
1975 static void stop_passive_scanning_complete(uint8_t status, uint16_t length,
1976                                         const void *param, void *user_data)
1977 {
1978         struct btd_adapter *adapter = user_data;
1979         struct btd_device *dev;
1980         int err;
1981
1982         DBG("status 0x%02x (%s)", status, mgmt_errstr(status));
1983
1984         dev = adapter->connect_le;
1985         adapter->connect_le = NULL;
1986
1987         /*
1988          * When the kernel background scanning is available, there is
1989          * no need to stop any discovery. The kernel will handle the
1990          * auto-connection by itself.
1991          */
1992         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
1993                 return;
1994
1995         /*
1996          * MGMT_STATUS_REJECTED may be returned from kernel because the passive
1997          * scan timer had expired in kernel and passive scan was disabled just
1998          * around the time we called stop_passive_scanning().
1999          */
2000         if (status != MGMT_STATUS_SUCCESS && status != MGMT_STATUS_REJECTED) {
2001                 btd_error(adapter->dev_id, "Stopping passive scanning failed: %s",
2002                                                         mgmt_errstr(status));
2003                 return;
2004         }
2005
2006         adapter->discovery_type = 0x00;
2007         adapter->discovery_enable = 0x00;
2008
2009         if (!dev) {
2010                 DBG("Device removed while stopping passive scanning");
2011                 trigger_passive_scanning(adapter);
2012                 return;
2013         }
2014
2015         err = device_connect_le(dev);
2016         if (err < 0) {
2017                 btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
2018                                                         strerror(-err), -err);
2019                 trigger_passive_scanning(adapter);
2020         }
2021 }
2022
2023 static void stop_passive_scanning(struct btd_adapter *adapter)
2024 {
2025         struct mgmt_cp_stop_discovery cp;
2026 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2027         struct mgmt_cp_stop_discovery le_cp;
2028 #endif
2029
2030         DBG("");
2031
2032         /* If there are any normal discovery clients passive scanning
2033          * wont be running */
2034 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2035         if (adapter->discovery_list || adapter->le_discovery_list)
2036                 return;
2037 #else
2038         if (adapter->discovery_list)
2039                 return;
2040 #endif
2041
2042         if (adapter->discovery_enable == 0x00)
2043                 return;
2044
2045 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2046         if ((adapter->discovery_type & 0x01) > 0) {
2047                 cp.type = 0x01;
2048                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2049                                 adapter->dev_id, sizeof(cp), &cp,
2050                                 stop_passive_scanning_complete, adapter, NULL);
2051         }
2052         if ((adapter->discovery_type & 0x06) > 0) {
2053                 le_cp.type = 0x06;
2054                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
2055                                 adapter->dev_id, sizeof(le_cp), &le_cp,
2056                                 stop_passive_scanning_complete, adapter, NULL);
2057         }
2058 #else
2059         cp.type = adapter->discovery_type;
2060
2061         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2062                         adapter->dev_id, sizeof(cp), &cp,
2063                         stop_passive_scanning_complete, adapter, NULL);
2064 #endif
2065 }
2066
2067 static void cancel_passive_scanning(struct btd_adapter *adapter)
2068 {
2069         if (!(adapter->current_settings & MGMT_SETTING_LE))
2070                 return;
2071
2072         DBG("");
2073
2074         if (adapter->passive_scan_timeout > 0) {
2075                 timeout_remove(adapter->passive_scan_timeout);
2076                 adapter->passive_scan_timeout = 0;
2077         }
2078 }
2079
2080 static uint8_t get_scan_type(struct btd_adapter *adapter)
2081 {
2082         uint8_t type;
2083
2084         if (adapter->current_settings & MGMT_SETTING_BREDR)
2085                 type = SCAN_TYPE_BREDR;
2086         else
2087                 type = 0;
2088
2089         if (adapter->current_settings & MGMT_SETTING_LE)
2090                 type |= SCAN_TYPE_LE;
2091
2092         return type;
2093 }
2094
2095 static void free_discovery_filter(struct discovery_filter *discovery_filter)
2096 {
2097         if (!discovery_filter)
2098                 return;
2099
2100         g_slist_free_full(discovery_filter->uuids, free);
2101         free(discovery_filter->pattern);
2102         g_free(discovery_filter);
2103 }
2104
2105 static void invalidate_rssi_and_tx_power(gpointer a)
2106 {
2107         struct btd_device *dev = a;
2108
2109         device_set_rssi(dev, 0);
2110         device_set_tx_power(dev, 127);
2111 }
2112
2113 static void discovery_cleanup(struct btd_adapter *adapter, int timeout)
2114 {
2115         GSList *l, *next;
2116
2117         adapter->discovery_type = 0x00;
2118
2119         if (adapter->discovery_idle_timeout > 0) {
2120                 timeout_remove(adapter->discovery_idle_timeout);
2121                 adapter->discovery_idle_timeout = 0;
2122         }
2123
2124         g_slist_free_full(adapter->discovery_found,
2125                                                 invalidate_rssi_and_tx_power);
2126         adapter->discovery_found = NULL;
2127
2128         if (!adapter->devices)
2129                 return;
2130
2131         for (l = adapter->devices; l != NULL; l = next) {
2132                 struct btd_device *dev = l->data;
2133
2134                 next = g_slist_next(l);
2135
2136 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2137         if (device_is_temporary(dev) && !device_is_connectable(dev)
2138                 && !btd_device_is_connected(dev))
2139 #else
2140         if (device_is_temporary(dev) && !device_is_connectable(dev))
2141 #endif
2142                 btd_adapter_remove_device(adapter, dev);
2143
2144         }
2145 }
2146
2147 static void discovery_free(void *user_data)
2148 {
2149         struct discovery_client *client = user_data;
2150         struct btd_adapter *adapter = client->adapter;
2151
2152 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2153         DBG("%p", client);
2154 #endif
2155         if (client->watch)
2156                 g_dbus_remove_watch(dbus_conn, client->watch);
2157
2158         if (client->discovery_filter) {
2159                 free_discovery_filter(client->discovery_filter);
2160                 client->discovery_filter = NULL;
2161         }
2162
2163         if (client->msg) {
2164                 if (client == adapter->client) {
2165                         g_dbus_send_message(dbus_conn,
2166                                                 btd_error_busy(client->msg));
2167                         adapter->client = NULL;
2168                 }
2169                 dbus_message_unref(client->msg);
2170         }
2171
2172         g_free(client->owner);
2173         g_free(client);
2174 }
2175
2176 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2177 static void discovery_remove(struct discovery_client *client, bool exit)
2178 #else
2179 static void discovery_remove(struct discovery_client *client)
2180 #endif
2181
2182 {
2183         struct btd_adapter *adapter = client->adapter;
2184
2185         DBG("owner %s", client->owner);
2186
2187         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2188                                                                 client);
2189
2190         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2191                                                                 client);
2192
2193 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2194         if (!exit && client->discovery_filter)
2195 #else
2196         if (adapter->client == client)
2197                 adapter->client = NULL;
2198
2199         if (client->watch && client->discovery_filter)
2200 #endif
2201                 adapter->set_filter_list = g_slist_prepend(
2202                                         adapter->set_filter_list, client);
2203         else
2204                 discovery_free(client);
2205
2206         /*
2207          * If there are other client discoveries in progress, then leave
2208          * it active. If not, then make sure to stop the restart timeout.
2209          */
2210         if (adapter->discovery_list)
2211                 return;
2212
2213         discovery_cleanup(adapter, TEMP_DEV_TIMEOUT);
2214 }
2215
2216 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay);
2217
2218 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2219 static void discovery_reply(struct discovery_client *client, uint8_t status)
2220 #else
2221 static struct discovery_client *discovery_complete(struct btd_adapter *adapter,
2222                                                 uint8_t status)
2223 #endif
2224 {
2225 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2226         struct discovery_client *client = adapter->client;
2227 #endif
2228         DBusMessage *reply;
2229 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2230
2231         if (!client)
2232                 return NULL;
2233
2234         adapter->client = NULL;
2235 #endif
2236
2237         if (!client->msg)
2238 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2239                 return;
2240 #else
2241                 return client;
2242 #endif
2243         if (!status) {
2244                 g_dbus_send_reply(dbus_conn, client->msg, DBUS_TYPE_INVALID);
2245         } else  {
2246                 reply = btd_error_busy(client->msg);
2247                 g_dbus_send_message(dbus_conn, reply);
2248         }
2249
2250         dbus_message_unref(client->msg);
2251         client->msg = NULL;
2252 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2253         return client;
2254 #endif
2255 }
2256
2257 static void start_discovery_complete(uint8_t status, uint16_t length,
2258                                         const void *param, void *user_data)
2259 {
2260         struct btd_adapter *adapter = user_data;
2261         struct discovery_client *client;
2262         const struct mgmt_cp_start_discovery *rp = param;
2263
2264         DBG("status 0x%02x", status);
2265
2266         /* Is there are no clients the discovery must have been stopped while
2267          * discovery command was pending.
2268          */
2269         if (!adapter->discovery_list) {
2270                 struct mgmt_cp_stop_discovery cp;
2271
2272                 if (status != MGMT_STATUS_SUCCESS)
2273                         return;
2274
2275                 /* Stop discovering as there are no clients left */
2276                 cp.type = rp->type;
2277                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2278                                         adapter->dev_id, sizeof(cp), &cp,
2279                                         NULL, NULL, NULL);
2280                 return;
2281         }
2282
2283         client = adapter->discovery_list->data;
2284
2285         if (length < sizeof(*rp)) {
2286                 btd_error(adapter->dev_id,
2287                         "Wrong size of start discovery return parameters");
2288                 if (client->msg)
2289                         goto fail;
2290                 return;
2291         }
2292
2293         if (status == MGMT_STATUS_SUCCESS) {
2294 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2295                 DBG("Return param discovery type 0x%02x", rp->type);
2296                 adapter->discovery_type |= rp->type;
2297 #else
2298                 adapter->discovery_type = rp->type;
2299 #endif
2300                 adapter->discovery_enable = 0x01;
2301
2302                 if (adapter->current_discovery_filter)
2303                         adapter->filtered_discovery = true;
2304                 else
2305                         adapter->filtered_discovery = false;
2306
2307 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2308                 discovery_reply(client, status);
2309 #else
2310                 discovery_complete(adapter, status);
2311 #endif
2312                 if (adapter->discovering)
2313                         return;
2314
2315                 adapter->discovering = true;
2316                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2317                                         ADAPTER_INTERFACE, "Discovering");
2318                 return;
2319 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2320         } else {
2321                 adapter->discovering = false;
2322                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2323                                         ADAPTER_INTERFACE, "Discovering");
2324 #endif
2325         }
2326
2327 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2328 fail:
2329         /* Reply with an error if the first discovery has failed */
2330         if (client->msg) {
2331                 discovery_reply(client, status);
2332                 discovery_remove(client, false);
2333 #else
2334         client = discovery_complete(adapter, status);
2335         if (client) {
2336                 discovery_remove(client);
2337 #endif
2338                 return;
2339         }
2340
2341         /*
2342          * In case the restart of the discovery failed, then just trigger
2343          * it for the next idle timeout again.
2344          */
2345 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2346         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
2347 #endif
2348 }
2349
2350 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2351 static void start_le_discovery_complete(uint8_t status, uint16_t length,
2352                                         const void *param, void *user_data)
2353 {
2354         struct btd_adapter *adapter = user_data;
2355         const struct mgmt_cp_start_discovery *rp = param;
2356
2357         if (!rp) {
2358                 error("Error ocurred in LEDiscovering, rp is NULL");
2359                 return;
2360         }
2361
2362         DBG("status 0x%02x", status);
2363         if (length < sizeof(*rp)) {
2364                 error("Wrong size of start discovery return parameters");
2365                 return;
2366         }
2367
2368         DBG("Discovery Type 0x%02x", rp->type);
2369         if (status == MGMT_STATUS_SUCCESS) {
2370                 adapter->discovery_type |= rp->type;
2371                 adapter->discovery_enable = 0x01;
2372
2373                 if (adapter->le_discovering)
2374                         return;
2375
2376                 adapter->le_discovering = true;
2377                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2378                                         ADAPTER_INTERFACE, "LEDiscovering");
2379
2380                 return;
2381         } else {
2382                 adapter->le_discovering = false;
2383                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2384                                         ADAPTER_INTERFACE, "LEDiscovering");
2385
2386         }
2387 }
2388 #endif
2389
2390 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2391 static gboolean start_le_discovery_timeout(gpointer user_data)
2392 {
2393         struct btd_adapter *adapter = user_data;
2394         uint8_t new_type;
2395
2396         DBG("");
2397
2398         adapter->le_discovery_idle_timeout = 0;
2399
2400         new_type = SCAN_TYPE_LE;
2401
2402         if (adapter->discovery_enable == 0x01) {
2403                 /*
2404                  * If there is an already running discovery and it has the
2405                  * same type, then just keep it.
2406                  */
2407
2408                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_LE) {
2409                         if (adapter->le_discovering)
2410                                 return FALSE;
2411
2412                         adapter->le_discovering = true;
2413                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2414                                         ADAPTER_INTERFACE, "LEDiscovering");
2415
2416                         return FALSE;
2417                 }
2418         }
2419
2420         struct mgmt_cp_start_discovery cp;
2421
2422         cp.type = new_type;
2423         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2424                         adapter->dev_id, sizeof(cp), &cp,
2425                         start_le_discovery_complete, adapter, NULL);
2426
2427         return FALSE;
2428 }
2429 #endif
2430
2431 static bool start_discovery_timeout(gpointer user_data)
2432 {
2433         struct btd_adapter *adapter = user_data;
2434 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2435         struct mgmt_cp_start_service_discovery *sd_cp;
2436 #endif
2437         uint8_t new_type;
2438
2439         DBG("");
2440
2441         adapter->discovery_idle_timeout = 0;
2442
2443 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2444         new_type = SCAN_TYPE_BREDR;
2445
2446         if (adapter->discovery_enable == 0x01) {
2447                 /*
2448                  * If there is an already running discovery and it has the
2449                  * same type, then just keep it.
2450                  */
2451                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_BREDR) {
2452                         if (adapter->discovering)
2453                                 return FALSE;
2454
2455                         adapter->discovering = true;
2456                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2457                                         ADAPTER_INTERFACE, "Discovering");
2458
2459                         return FALSE;
2460                 }
2461         }
2462
2463         struct mgmt_cp_start_discovery cp;
2464         cp.type = new_type;
2465         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2466                                         adapter->dev_id, sizeof(cp), &cp,
2467                                         start_discovery_complete, adapter,
2468                                         NULL);
2469
2470
2471 #else
2472         /* If we're doing filtered discovery, it must be quickly restarted */
2473         adapter->no_scan_restart_delay = !!adapter->current_discovery_filter;
2474
2475         DBG("adapter->current_discovery_filter == %d",
2476             !!adapter->current_discovery_filter);
2477
2478         new_type = get_scan_type(adapter);
2479
2480         if (adapter->discovery_enable == 0x01) {
2481                 struct mgmt_cp_stop_discovery cp;
2482
2483                 /*
2484                  * If we're asked to start regular discovery, and there is an
2485                  * already running regular discovery and it has the same type,
2486                  * then just keep it.
2487                  */
2488                 if (!adapter->current_discovery_filter &&
2489                     !adapter->filtered_discovery &&
2490                     adapter->discovery_type == new_type) {
2491                         if (adapter->discovering)
2492                                 return FALSE;
2493
2494                         adapter->discovering = true;
2495                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2496                                         ADAPTER_INTERFACE, "Discovering");
2497                         return FALSE;
2498                 }
2499
2500                 /*
2501                  * Otherwise the current discovery must be stopped. So
2502                  * queue up a stop discovery command.
2503                  *
2504                  * This can happen if a passive scanning for Low Energy
2505                  * devices is ongoing, or scan type is changed between
2506                  * regular and filtered, or filter was updated.
2507                  */
2508                 cp.type = adapter->discovery_type;
2509                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2510                                         adapter->dev_id, sizeof(cp), &cp,
2511                                         NULL, NULL, NULL);
2512
2513                 /* Don't even bother to try to quickly start discovery
2514                  * just after stopping it, it would fail with status
2515                  * MGMT_BUSY. Instead discovering_callback will take
2516                  * care of that.
2517                  */
2518                 return FALSE;
2519
2520         }
2521
2522         /* Regular discovery is required */
2523         if (!adapter->current_discovery_filter) {
2524                 struct mgmt_cp_start_discovery cp;
2525
2526                 cp.type = new_type;
2527                 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2528                                         adapter->dev_id, sizeof(cp), &cp,
2529                                         start_discovery_complete, adapter,
2530                                         NULL);
2531
2532                 return FALSE;
2533         }
2534
2535         /* Filtered discovery is required */
2536         sd_cp = adapter->current_discovery_filter;
2537
2538         DBG("sending MGMT_OP_START_SERVICE_DISCOVERY %d, %d, %d",
2539                                 sd_cp->rssi, sd_cp->type,
2540                                 btohs(sd_cp->uuid_count));
2541
2542         mgmt_send(adapter->mgmt, MGMT_OP_START_SERVICE_DISCOVERY,
2543                   adapter->dev_id, sizeof(*sd_cp) +
2544                   btohs(sd_cp->uuid_count) * 16,
2545                   sd_cp, start_discovery_complete, adapter, NULL);
2546
2547 #endif
2548
2549         return FALSE;
2550 }
2551
2552 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2553 static void trigger_start_le_discovery(struct btd_adapter *adapter, guint delay)
2554 {
2555
2556         DBG("");
2557
2558         cancel_passive_scanning(adapter);
2559
2560         if (adapter->le_discovery_idle_timeout > 0) {
2561                 g_source_remove(adapter->le_discovery_idle_timeout);
2562                 adapter->le_discovery_idle_timeout = 0;
2563         }
2564
2565         /*
2566          * If the controller got powered down in between, then ensure
2567          * that we do not keep trying to restart discovery.
2568          *
2569          * This is safe-guard and should actually never trigger.
2570          */
2571         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2572                 return;
2573
2574         adapter->le_discovery_idle_timeout = g_timeout_add_seconds(delay,
2575                                         start_le_discovery_timeout, adapter);
2576 }
2577 #endif
2578
2579 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
2580 {
2581
2582         DBG("");
2583
2584         cancel_passive_scanning(adapter);
2585
2586         if (adapter->discovery_idle_timeout > 0) {
2587                 timeout_remove(adapter->discovery_idle_timeout);
2588                 adapter->discovery_idle_timeout = 0;
2589         }
2590
2591         /*
2592          * If the controller got powered down in between, then ensure
2593          * that we do not keep trying to restart discovery.
2594          *
2595          * This is safe-guard and should actually never trigger.
2596          */
2597         if (!btd_adapter_get_powered(adapter))
2598                 return;
2599
2600         adapter->discovery_idle_timeout = timeout_add_seconds(delay,
2601                                         start_discovery_timeout, adapter, NULL);
2602 }
2603
2604 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2605 static void suspend_discovery_complete(uint8_t status, uint16_t length,
2606                                         const void *param, void *user_data)
2607 {
2608         struct btd_adapter *adapter = user_data;
2609
2610         DBG("status 0x%02x", status);
2611
2612         if (status == MGMT_STATUS_SUCCESS) {
2613                 adapter->discovery_type = 0x00;
2614                 adapter->discovery_enable = 0x00;
2615                 return;
2616         }
2617 }
2618
2619 static void suspend_discovery(struct btd_adapter *adapter)
2620 {
2621         struct mgmt_cp_stop_discovery cp;
2622
2623         DBG("");
2624
2625         adapter->discovery_suspended = true;
2626
2627         /*
2628          * If there are no clients discovering right now, then there is
2629          * also nothing to suspend.
2630          */
2631         if (!adapter->discovery_list)
2632                 return;
2633
2634         /*
2635          * In case of being inside the idle phase, make sure to remove
2636          * the timeout to not trigger a restart.
2637          *
2638          * The restart will be triggered when the discovery is resumed.
2639          */
2640         if (adapter->discovery_idle_timeout > 0) {
2641                 timeout_remove(adapter->discovery_idle_timeout);
2642                 adapter->discovery_idle_timeout = 0;
2643         }
2644
2645         if (adapter->discovery_enable == 0x00)
2646                 return;
2647
2648         cp.type = adapter->discovery_type;
2649
2650         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2651                                 adapter->dev_id, sizeof(cp), &cp,
2652                                 suspend_discovery_complete, adapter, NULL);
2653 }
2654
2655 static void resume_discovery(struct btd_adapter *adapter)
2656 {
2657         DBG("");
2658
2659         adapter->discovery_suspended = false;
2660
2661         /*
2662          * If there are no clients discovering right now, then there is
2663          * also nothing to resume.
2664          */
2665         if (!adapter->discovery_list)
2666                 return;
2667
2668         /*
2669          * Treat a suspended discovery session the same as extra long
2670          * idle time for a normal discovery. So just trigger the default
2671          * restart procedure.
2672          */
2673         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2674 }
2675 #endif
2676
2677 static void discovering_callback(uint16_t index, uint16_t length,
2678                                         const void *param, void *user_data)
2679 {
2680         const struct mgmt_ev_discovering *ev = param;
2681         struct btd_adapter *adapter = user_data;
2682
2683         if (length < sizeof(*ev)) {
2684                 btd_error(adapter->dev_id, "Too small discovering event");
2685                 return;
2686         }
2687
2688         DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
2689                                 ev->discovering, adapter->filtered_discovery);
2690
2691 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2692         DBG("info discov_type %d", adapter->discovery_type);
2693         if (ev->type == SCAN_TYPE_BREDR) {
2694                 if (ev->discovering == FALSE) {
2695                         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
2696                         adapter->discovering = false;
2697                 } else {
2698                         hci_set_bit(BDADDR_BREDR, &adapter->discovery_type);
2699                         adapter->discovering = true;
2700                 }
2701                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2702                                         ADAPTER_INTERFACE, "Discovering");
2703
2704         } else if (ev->type == SCAN_TYPE_LE) {
2705                 if (ev->discovering == FALSE) {
2706                         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2707                         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2708
2709                         if (adapter->le_discovering == true) {
2710                                 if (adapter->le_discovery_list) {
2711                                         struct discovery_client *client;
2712
2713                                         client = adapter->le_discovery_list->data;
2714                                         g_dbus_remove_watch(dbus_conn, client->watch);
2715                                 }
2716
2717                                 adapter->le_discovering = false;
2718                         }
2719                 } else {
2720                         hci_set_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2721                         hci_set_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2722                         adapter->le_discovering = true;
2723                 }
2724
2725                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2726                                         ADAPTER_INTERFACE, "LEDiscovering");
2727         }
2728 #else
2729         if (adapter->discovery_enable == ev->discovering)
2730                 return;
2731
2732         adapter->discovery_type = ev->type;
2733         adapter->discovery_enable = ev->discovering;
2734 #endif
2735
2736         /*
2737          * Check for existing discoveries triggered by client applications
2738          * and ignore all others.
2739          *
2740          * If there are no clients, then it is good idea to trigger a
2741          * passive scanning attempt.
2742          */
2743 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2744         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2745                 if (!adapter->connect_le)
2746                         trigger_passive_scanning(adapter);
2747                 return;
2748         }
2749 #else
2750         if (!adapter->discovery_list) {
2751                 if (!adapter->connect_le)
2752                         trigger_passive_scanning(adapter);
2753                 return;
2754         }
2755 #endif
2756
2757         if (adapter->discovery_suspended)
2758                 return;
2759
2760         switch (adapter->discovery_enable) {
2761         case 0x00:
2762                 if (adapter->no_scan_restart_delay)
2763                         trigger_start_discovery(adapter, 0);
2764                 else
2765                         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2766                 break;
2767
2768         case 0x01:
2769                 if (adapter->discovery_idle_timeout > 0) {
2770                         timeout_remove(adapter->discovery_idle_timeout);
2771                         adapter->discovery_idle_timeout = 0;
2772                 }
2773
2774                 break;
2775         }
2776 }
2777
2778 static bool set_discovery_discoverable(struct btd_adapter *adapter, bool enable)
2779 {
2780         if (adapter->discovery_discoverable == enable)
2781                 return true;
2782
2783         /* Reset discoverable filter if already set */
2784         if (enable && (adapter->current_settings & MGMT_OP_SET_DISCOVERABLE))
2785                 return true;
2786
2787         adapter->discovery_discoverable = enable;
2788
2789         return set_discoverable(adapter, enable, 0);
2790 }
2791
2792 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2793 static void stop_discovery_complete(uint8_t status, uint16_t length,
2794                                         const void *param, void *user_data)
2795 {
2796         struct discovery_client *client = user_data;
2797         struct btd_adapter *adapter = client->adapter;
2798         DBusMessage *reply;
2799
2800         DBG("status 0x%02x", status);
2801
2802         if (status != MGMT_STATUS_SUCCESS) {
2803                 if (client->msg) {
2804                         reply = btd_error_busy(client->msg);
2805                         g_dbus_send_message(dbus_conn, reply);
2806                 }
2807
2808                 goto done;
2809         }
2810
2811         if (client->msg) {
2812                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2813                 g_dbus_send_message(dbus_conn, reply);
2814         }
2815
2816         adapter->discovery_type &= (~0x01);
2817         DBG("Discovery Type 0x%02x", adapter->discovery_type);
2818
2819         adapter->filtered_discovery = false;
2820         adapter->no_scan_restart_delay = false;
2821         adapter->discovering = false;
2822         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2823                         ADAPTER_INTERFACE, "Discovering");
2824
2825         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2826                 adapter->discovery_enable = 0x00;
2827                 trigger_passive_scanning(adapter);
2828         }
2829
2830 done:
2831         discovery_remove(client, false);
2832 }
2833
2834 static void stop_le_discovery_complete(uint8_t status, uint16_t length,
2835                                         const void *param, void *user_data)
2836 {
2837         struct btd_adapter *adapter = user_data;
2838         struct discovery_client *client;
2839         DBusMessage *reply;
2840
2841         DBG("status 0x%02x", status);
2842
2843         /* Is there are no clients the discovery must have been stopped while
2844           * discovery command was pending.
2845           */
2846         if (!adapter->le_discovery_list)
2847                 return;
2848
2849         client = adapter->le_discovery_list->data;
2850
2851         if (status != MGMT_STATUS_SUCCESS) {
2852                 if (client->msg) {
2853                         reply = btd_error_busy(client->msg);
2854                         g_dbus_send_message(dbus_conn, reply);
2855                 }
2856
2857                 goto done;
2858         }
2859
2860         if (client->msg) {
2861                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2862                 g_dbus_send_message(dbus_conn, reply);
2863         }
2864
2865         adapter->discovery_type &= (~0x06);
2866         DBG("Discovery Type 0x%02x", adapter->discovery_type);
2867
2868         adapter->filtered_discovery = false;
2869         adapter->no_scan_restart_delay = false;
2870         adapter->le_discovering = false;
2871         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2872                         ADAPTER_INTERFACE, "LEDiscovering");
2873
2874         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2875                 adapter->discovery_enable = 0x00;
2876                 trigger_passive_scanning(adapter);
2877         }
2878
2879 done:
2880         /*
2881          * The destroy function will cleanup the client information and
2882          * also remove it from the list of discovery clients.
2883          */
2884         g_dbus_remove_watch(dbus_conn, client->watch);
2885 }
2886 #else
2887
2888 static void stop_discovery_complete(uint8_t status, uint16_t length,
2889                                         const void *param, void *user_data)
2890 {
2891         struct btd_adapter *adapter = user_data;
2892         struct discovery_client *client;
2893
2894         DBG("status 0x%02x", status);
2895
2896         client = discovery_complete(adapter, status);
2897         if (client)
2898                 discovery_remove(client);
2899
2900         if (status != MGMT_STATUS_SUCCESS)
2901                 return;
2902
2903         adapter->discovery_type = 0x00;
2904         adapter->discovery_enable = 0x00;
2905         adapter->filtered_discovery = false;
2906         adapter->no_scan_restart_delay = false;
2907         adapter->discovering = false;
2908         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2909                                         ADAPTER_INTERFACE, "Discovering");
2910
2911         trigger_passive_scanning(adapter);
2912 }
2913 #endif
2914
2915 static int compare_sender(gconstpointer a, gconstpointer b)
2916 {
2917         const struct discovery_client *client = a;
2918         const char *sender = b;
2919
2920         return g_strcmp0(client->owner, sender);
2921 }
2922
2923 static gint g_strcmp(gconstpointer a, gconstpointer b)
2924 {
2925         return strcmp(a, b);
2926 }
2927
2928 static void extract_unique_uuids(gpointer data, gpointer user_data)
2929 {
2930         char *uuid_str = data;
2931         GSList **uuids = user_data;
2932
2933         if (!g_slist_find_custom(*uuids, uuid_str, g_strcmp))
2934                 *uuids = g_slist_insert_sorted(*uuids, uuid_str, g_strcmp);
2935 }
2936
2937 /*
2938  * This method merges all adapter filters into rssi, transport and uuids.
2939  * Returns 1 if there was no filtered scan, 0 otherwise.
2940  */
2941 static int merge_discovery_filters(struct btd_adapter *adapter, int *rssi,
2942                                         uint8_t *transport, GSList **uuids)
2943 {
2944         GSList *l;
2945         bool empty_uuid = false;
2946         bool has_regular_discovery = false;
2947         bool has_filtered_discovery = false;
2948
2949         for (l = adapter->discovery_list; l != NULL; l = g_slist_next(l)) {
2950                 struct discovery_client *client = l->data;
2951                 struct discovery_filter *item = client->discovery_filter;
2952
2953                 if (!item) {
2954                         has_regular_discovery = true;
2955                         continue;
2956                 }
2957
2958                 has_filtered_discovery = true;
2959
2960                 *transport |= item->type;
2961
2962                 /*
2963                  * Rule for merging rssi and pathloss into rssi field of kernel
2964                  * filter is as follow:
2965                  * - if there's any client without proximity filter, then do no
2966                  *   proximity filtering,
2967                  * - if all clients specified RSSI, then use lowest value,
2968                  * - if any client specified pathloss, then kernel filter should
2969                  *   do no proximity, as kernel can't compute pathloss. We'll do
2970                  *   filtering on our own.
2971                  */
2972                 if (item->rssi == DISTANCE_VAL_INVALID)
2973                         *rssi = HCI_RSSI_INVALID;
2974                 else if (*rssi != HCI_RSSI_INVALID && *rssi >= item->rssi)
2975                         *rssi = item->rssi;
2976                 else if (item->pathloss != DISTANCE_VAL_INVALID)
2977                         *rssi = HCI_RSSI_INVALID;
2978
2979                 if (!g_slist_length(item->uuids))
2980                         empty_uuid = true;
2981
2982                 g_slist_foreach(item->uuids, extract_unique_uuids, uuids);
2983         }
2984
2985         /* If no proximity filtering is set, disable it */
2986         if (*rssi == DISTANCE_VAL_INVALID)
2987                 *rssi = HCI_RSSI_INVALID;
2988
2989         /*
2990          * Empty_uuid variable determines wether there was any filter with no
2991          * uuids. In this case someone might be looking for all devices in
2992          * certain proximity, and we need to have empty uuids in kernel filter.
2993          */
2994         if (empty_uuid) {
2995                 g_slist_free(*uuids);
2996                 *uuids = NULL;
2997         }
2998
2999         if (has_regular_discovery) {
3000                 if (!has_filtered_discovery)
3001                         return 1;
3002
3003                 /*
3004                  * It there is both regular and filtered scan running, then
3005                  * clear whole fitler to report all devices.
3006                  */
3007                 *transport = get_scan_type(adapter);
3008                 *rssi = HCI_RSSI_INVALID;
3009                 g_slist_free(*uuids);
3010                 *uuids = NULL;
3011         }
3012
3013         return 0;
3014 }
3015
3016 static void populate_mgmt_filter_uuids(uint8_t (*mgmt_uuids)[16], GSList *uuids)
3017 {
3018         GSList *l;
3019
3020         for (l = uuids; l != NULL; l = g_slist_next(l)) {
3021                 bt_uuid_t uuid, u128;
3022                 uint128_t uint128;
3023
3024                 bt_string_to_uuid(&uuid, l->data);
3025                 bt_uuid_to_uuid128(&uuid, &u128);
3026
3027                 ntoh128((uint128_t *) u128.value.u128.data, &uint128);
3028                 htob128(&uint128, (uint128_t *) mgmt_uuids);
3029
3030                 mgmt_uuids++;
3031         }
3032 }
3033
3034 /*
3035  * This method merges all adapter filters into one that will be send to kernel.
3036  * cp_ptr is set to null when regular non-filtered discovery is needed,
3037  * otherwise it's pointing to filter. Returns 0 on succes, -1 on error
3038  */
3039 static int discovery_filter_to_mgmt_cp(struct btd_adapter *adapter,
3040                        struct mgmt_cp_start_service_discovery **cp_ptr)
3041 {
3042         GSList *uuids = NULL;
3043         struct mgmt_cp_start_service_discovery *cp;
3044         int rssi = DISTANCE_VAL_INVALID;
3045         int uuid_count;
3046         uint8_t discovery_type = 0;
3047
3048         DBG("");
3049
3050         if (merge_discovery_filters(adapter, &rssi, &discovery_type, &uuids)) {
3051                 /* There are only regular scans, run just regular scan. */
3052                 *cp_ptr = NULL;
3053                 return 0;
3054         }
3055
3056         uuid_count = g_slist_length(uuids);
3057
3058         cp = g_try_malloc(sizeof(*cp) + 16*uuid_count);
3059         *cp_ptr = cp;
3060         if (!cp) {
3061                 g_slist_free(uuids);
3062                 return -1;
3063         }
3064
3065         cp->type = discovery_type;
3066         cp->rssi = rssi;
3067         cp->uuid_count = htobs(uuid_count);
3068         populate_mgmt_filter_uuids(cp->uuids, uuids);
3069
3070         g_slist_free(uuids);
3071         return 0;
3072 }
3073
3074 static bool filters_equal(struct mgmt_cp_start_service_discovery *a,
3075                    struct mgmt_cp_start_service_discovery *b) {
3076         if (!a && !b)
3077                 return true;
3078
3079         if ((!a && b) || (a && !b))
3080                 return false;
3081
3082         if (a->type != b->type)
3083                 return false;
3084
3085         if (a->rssi != b->rssi)
3086                 return false;
3087
3088         /*
3089          * When we create mgmt_cp_start_service_discovery structure inside
3090          * discovery_filter_to_mgmt_cp, we always keep uuids sorted, and
3091          * unique, so we're safe to compare uuid_count, and uuids like that.
3092          */
3093         if (a->uuid_count != b->uuid_count)
3094                 return false;
3095
3096         if (memcmp(a->uuids, b->uuids, 16 * a->uuid_count) != 0)
3097                 return false;
3098
3099         return true;
3100 }
3101
3102 static int update_discovery_filter(struct btd_adapter *adapter)
3103 {
3104         struct mgmt_cp_start_service_discovery *sd_cp;
3105
3106         DBG("");
3107
3108         if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
3109                 btd_error(adapter->dev_id,
3110                                 "discovery_filter_to_mgmt_cp returned error");
3111                 return -ENOMEM;
3112         }
3113
3114         /* Only attempt to overwrite current discoverable setting when not
3115          * discoverable.
3116          */
3117         if (!(adapter->current_settings & MGMT_OP_SET_DISCOVERABLE)) {
3118                 GSList *l;
3119
3120                 for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
3121                         struct discovery_client *client = l->data;
3122
3123                         if (!client->discovery_filter)
3124                                 continue;
3125
3126                         if (client->discovery_filter->discoverable) {
3127                                 set_discovery_discoverable(adapter, true);
3128                                 break;
3129                         }
3130                 }
3131         }
3132
3133         /*
3134          * If filters are equal, then don't update scan, except for when
3135          * starting discovery.
3136          */
3137         if (filters_equal(adapter->current_discovery_filter, sd_cp) &&
3138             adapter->discovering != 0) {
3139                 DBG("filters were equal, deciding to not restart the scan.");
3140                 g_free(sd_cp);
3141                 return 0;
3142         }
3143
3144         g_free(adapter->current_discovery_filter);
3145         adapter->current_discovery_filter = sd_cp;
3146
3147         trigger_start_discovery(adapter, 0);
3148
3149         return -EINPROGRESS;
3150 }
3151
3152 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3153 static int discovery_stop(struct discovery_client *client, bool exit)
3154 #else
3155 static int discovery_stop(struct discovery_client *client)
3156 #endif
3157 {
3158         struct btd_adapter *adapter = client->adapter;
3159         struct mgmt_cp_stop_discovery cp;
3160
3161         /* Check if there are more client discovering */
3162         if (g_slist_next(adapter->discovery_list)) {
3163 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3164                 discovery_remove(client, exit);
3165 #else
3166                 discovery_remove(client);
3167 #endif
3168                 update_discovery_filter(adapter);
3169                 return 0;
3170         }
3171
3172         set_discovery_discoverable(adapter, false);
3173
3174         /*
3175          * In the idle phase of a discovery, there is no need to stop it
3176          * and so it is enough to send out the signal and just return.
3177          */
3178         if (adapter->discovery_enable == 0x00) {
3179 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3180                 discovery_remove(client, exit);
3181 #else
3182                 discovery_remove(client);
3183 #endif
3184                 adapter->discovering = false;
3185                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3186                                 ADAPTER_INTERFACE, "Discovering");
3187
3188                 trigger_passive_scanning(adapter);
3189
3190                 return 0;
3191         }
3192 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3193         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3194 #endif
3195         cp.type = adapter->discovery_type;
3196 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
3197         adapter->client = client;
3198 #endif
3199 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3200         cp.type = 0x01;
3201 #endif
3202         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
3203                         adapter->dev_id, sizeof(cp), &cp,
3204 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3205                         stop_discovery_complete, client, NULL);
3206 #else
3207                         stop_discovery_complete, adapter, NULL);
3208 #endif
3209
3210         return -EINPROGRESS;
3211 }
3212
3213 static void discovery_destroy(void *user_data)
3214 {
3215         struct discovery_client *client = user_data;
3216         struct btd_adapter *adapter = client->adapter;
3217
3218         DBG("owner %s", client->owner);
3219
3220         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
3221                                                                 client);
3222
3223         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
3224                                                                 client);
3225
3226         if (client->discovery_filter) {
3227                 free_discovery_filter(client->discovery_filter);
3228                 client->discovery_filter = NULL;
3229         }
3230
3231         g_free(client->owner);
3232         g_free(client);
3233
3234         /*
3235          * If there are other client discoveries in progress, then leave
3236          * it active. If not, then make sure to stop the restart timeout.
3237          */
3238         if (adapter->discovery_list)
3239                 return;
3240
3241 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3242         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
3243 #else
3244         adapter->discovery_type = 0x00;
3245 #endif
3246
3247         discovery_cleanup(adapter, 0);
3248
3249 }
3250
3251 static void discovery_disconnect(DBusConnection *conn, void *user_data)
3252 {
3253         struct discovery_client *client = user_data;
3254
3255         DBG("owner %s", client->owner);
3256 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3257         discovery_stop(client, true);
3258 #else
3259         client->watch = 0;
3260
3261         discovery_stop(client);
3262 #endif
3263 }
3264
3265 /*
3266  * Returns true if client was already discovering, false otherwise. *client
3267  * will point to discovering client, or client that have pre-set his filter.
3268  */
3269 static bool get_discovery_client(struct btd_adapter *adapter,
3270                                                 const char *owner,
3271                                                 struct discovery_client **client)
3272 {
3273         GSList *list = g_slist_find_custom(adapter->discovery_list, owner,
3274                                                                 compare_sender);
3275         if (list) {
3276                 *client = list->data;
3277                 return true;
3278         }
3279
3280         list = g_slist_find_custom(adapter->set_filter_list, owner,
3281                                                                 compare_sender);
3282         if (list) {
3283                 *client = list->data;
3284                 return false;
3285         }
3286
3287         *client = NULL;
3288         return false;
3289 }
3290
3291 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3292 static void le_discovery_destroy(void *user_data)
3293 {
3294         struct discovery_client *client = user_data;
3295         struct btd_adapter *adapter = client->adapter;
3296
3297         DBG("owner %s", client->owner);
3298
3299         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3300                                                                 client);
3301
3302         g_free(client->owner);
3303         g_free(client);
3304
3305         /*
3306          * If there are other client discoveries in progress, then leave
3307          * it active. If not, then make sure to stop the restart timeout.
3308          */
3309         DBG("adapter->discovery_list[%p] adapter->le_discovery_list[%p]",
3310                         adapter->discovery_list, adapter->le_discovery_list);
3311         if (adapter->discovery_list || adapter->le_discovery_list)
3312                 return;
3313
3314         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
3315         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
3316
3317         DBG("Restart Timer... adapter->discovery_type[%d]", adapter->discovery_type);
3318         if (adapter->discovery_idle_timeout > 0) {
3319                 g_source_remove(adapter->discovery_idle_timeout);
3320                 adapter->discovery_idle_timeout = 0;
3321         }
3322
3323         discovery_cleanup(adapter, 0);
3324 }
3325
3326 static void le_discovery_disconnect(DBusConnection *conn, void *user_data)
3327 {
3328         struct discovery_client *client = user_data;
3329         struct btd_adapter *adapter = client->adapter;
3330         struct mgmt_cp_stop_le_discovery cp;
3331
3332         DBG("owner %s", client->owner);
3333
3334         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3335                                                                 client);
3336
3337         /*
3338          * There is no need for extra cleanup of the client since that
3339          * will be done by the destroy callback.
3340          *
3341          * However in case this is the last client, the discovery in
3342          * the kernel needs to be disabled.
3343          */
3344         if (adapter->le_discovery_list)
3345                 return;
3346
3347         /*
3348          * In the idle phase of a discovery, there is no need to stop it
3349          * and so it is enough to send out the signal and just return.
3350          */
3351         if (adapter->discovery_enable == 0x00) {
3352                 adapter->le_discovering = false;
3353                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3354                                         ADAPTER_INTERFACE, "LEDiscovering");
3355
3356                 if (adapter->discovering == false  && adapter->le_discovering == false) {
3357                         trigger_passive_scanning(adapter);
3358                         return;
3359                 }
3360         }
3361
3362         cp.type = 0x06;
3363
3364         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
3365                                 adapter->dev_id, sizeof(cp), &cp,
3366                                 stop_le_discovery_complete, adapter, NULL);
3367 }
3368
3369 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
3370 static void addr_filter_params_free(gpointer data)
3371 {
3372         adapter_le_address_filter_params_t *params = data;
3373
3374         g_free(params);
3375 }
3376
3377 static void uuid_filter_params_free(gpointer data)
3378 {
3379         adapter_le_uuid_params_t *params = data;
3380
3381         g_free((char *)params->uuid);
3382         g_free((char *)params->uuid_mask);
3383         g_free(params);
3384 }
3385
3386 static void manufacturer_filter_params_free(gpointer data)
3387 {
3388         adapter_le_manf_data_params_t *params = data;
3389
3390         g_free((char *)params->man_data);
3391         g_free((char *)params->man_data_mask);
3392         g_free(params);
3393 }
3394
3395 static void local_name_filter_params_free(gpointer data)
3396 {
3397         adapter_le_local_name_params_t *params = data;
3398
3399         g_free((char *)params->local_name);
3400         g_free(params);
3401 }
3402
3403 static void service_data_filter_params_free(gpointer data)
3404 {
3405         adapter_le_service_data_params_t *params = data;
3406
3407         g_free((char *)params->service_data);
3408         g_free((char *)params->service_data_mask);
3409         g_free(params);
3410 }
3411
3412 static void scan_filter_params_free(gpointer data)
3413 {
3414         adapter_le_scan_filter_param_t *params = data;
3415         g_free(params);
3416 }
3417
3418 int adapter_le_address_cmp(gconstpointer a, gconstpointer b)
3419 {
3420         const adapter_le_address_filter_params_t *params = a;
3421         const char *address = b;
3422         char addr[18];
3423
3424         ba2str(&params->broadcaster_addr, addr);
3425         return strcasecmp(addr, address);
3426 }
3427
3428 int adapter_le_uuid_cmp(gconstpointer a, gconstpointer b)
3429 {
3430         const adapter_le_uuid_params_t *params = a;
3431         const char *uuid = b;
3432
3433         return strcasecmp((const char *)params->uuid, uuid);
3434 }
3435
3436 int adapter_le_manufacturer_data_cmp(gconstpointer a, gconstpointer b)
3437 {
3438         const adapter_le_manf_data_params_t *params = a;
3439         const struct eir_msd *msd = b;
3440
3441         if (msd->company == params->company_id) {
3442                 /* if the advertisiement packet is an iBeacon */
3443                 if (msd->company == COMPANY_ID_APPLE)
3444                         return 0;
3445                 return strncasecmp((const char *)params->man_data,
3446                                                 (const char *)msd->data,
3447                                                 params->man_data_len);
3448         } else {
3449                 return -1;
3450         }
3451 }
3452
3453 int adapter_le_local_name_cmp(gconstpointer a, gconstpointer b)
3454 {
3455         const adapter_le_local_name_params_t *params = a;
3456         const char *name = b;
3457
3458         return strcasecmp(params->local_name, name);
3459 }
3460
3461 int adapter_le_service_data_cmp(gconstpointer a, gconstpointer b)
3462 {
3463         const adapter_le_service_data_params_t *params = a;
3464         const struct eir_sd *sd = b;
3465         /* Todo, the service data format for 16 bit, 32bit and
3466          * 128 bit uuids needs to addressed */
3467         return strncasecmp((const char *)(params->service_data),
3468                                         (const char *)sd->data,
3469                                         sd->data_len);
3470 }
3471
3472 int adapter_le_address_filter_index_cmp(gconstpointer a, gconstpointer b)
3473 {
3474         const adapter_le_address_filter_params_t *params = a;
3475         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3476
3477         return params->filter_index - filter_inex;
3478 }
3479
3480 int adapter_le_uuid_filter_index_cmp(gconstpointer a, gconstpointer b)
3481 {
3482         const adapter_le_uuid_params_t *params = a;
3483         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3484
3485         return params->filter_index - filter_inex;
3486 }
3487
3488 int adapter_le_manufacturer_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3489 {
3490         const adapter_le_manf_data_params_t *params = a;
3491         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3492
3493         return params->filter_index - filter_inex;
3494 }
3495
3496 int adapter_le_local_name_filter_index_cmp(gconstpointer a, gconstpointer b)
3497 {
3498         const adapter_le_local_name_params_t *params = a;
3499         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3500
3501         return params->filter_index - filter_inex;
3502 }
3503
3504 int adapter_le_service_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3505 {
3506         const adapter_le_service_data_params_t *params = a;
3507         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3508
3509         return params->filter_index - filter_inex;
3510 }
3511
3512 int adapter_le_scan_params_filter_index_cmp(gconstpointer a, gconstpointer b)
3513 {
3514         const adapter_le_scan_filter_param_t *params = a;
3515         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3516
3517         return params->index - filter_inex;
3518 }
3519
3520 static gboolean adapter_le_clear_platform_scan_filter_data(
3521                         struct btd_adapter *adapter, int filter_index)
3522 {
3523         DBG("");
3524         GSList *list;
3525         if (!adapter)
3526                 return FALSE;
3527
3528         list = g_slist_find_custom(adapter->addr_filters,
3529                 GINT_TO_POINTER(filter_index), adapter_le_address_filter_index_cmp);
3530         if (list && list->data) {
3531                 /* Delete info from the struct to list */
3532                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3533         }
3534         list = g_slist_find_custom(adapter->service_data_changed_filters,
3535                 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3536         if (list && list->data) {
3537                 /* Delete info from the struct to list */
3538                 adapter->service_data_changed_filters = g_slist_delete_link(adapter->service_data_changed_filters, list);
3539         }
3540
3541         list = g_slist_find_custom(adapter->service_uuid_filters,
3542                 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3543         if (list && list->data) {
3544                 /* Delete info from the struct to list */
3545                 adapter->service_uuid_filters = g_slist_delete_link(adapter->service_uuid_filters, list);
3546         }
3547
3548         list = g_slist_find_custom(adapter->solicit_data_filters,
3549                 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3550         if (list && list->data) {
3551                 /* Delete info from the struct to list */
3552                 adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3553         }
3554
3555         list = g_slist_find_custom(adapter->local_name_filters,
3556                 GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
3557         if (list && list->data) {
3558                 /* Delete info from the struct to list */
3559                 adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
3560         }
3561
3562         list = g_slist_find_custom(adapter->manufaturer_data_filters,
3563                 GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3564         if (list && list->data) {
3565                 /* Delete info from the struct to list */
3566                 adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3567         }
3568
3569         list = g_slist_find_custom(adapter->service_data_filters,
3570                 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3571         if (list && list->data) {
3572                 /* Delete info from the struct to list */
3573                 adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
3574         }
3575
3576         list = g_slist_find_custom(adapter->scan_params,
3577                 GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
3578         if (list && list->data) {
3579                 /* Delete info from the struct to list */
3580                 adapter->scan_params = g_slist_delete_link(adapter->scan_params, list);
3581         }
3582
3583         return TRUE;
3584 }
3585
3586 static gboolean adapter_le_enable_platform_scan_filtering(
3587                         struct btd_adapter *adapter, gboolean enable)
3588 {
3589         if (!adapter)
3590                 return FALSE;
3591
3592         DBG("Platform scan filtering enable[%d]", enable);
3593
3594         adapter->scan_filter_support = enable;
3595
3596         return TRUE;
3597 }
3598
3599
3600 static gboolean adapter_le_service_add_addr_scan_filter_data(struct btd_adapter *adapter,
3601                                                 int filter_index, gchar *string, int addr_type)
3602 {
3603         /* TYPE_DEVICE_ADDRESS */
3604         adapter_le_address_filter_params_t *params;
3605
3606         DBG("");
3607
3608         params = g_new0(adapter_le_address_filter_params_t, 1);
3609         if (!params)
3610                 return FALSE;
3611
3612         params->filter_index = filter_index;
3613         str2ba(string, &params->broadcaster_addr);
3614         params->bdaddr_type = addr_type;
3615
3616         /* Store the struct to list */
3617         adapter->addr_filters = g_slist_append(adapter->addr_filters, params);
3618         return TRUE;
3619 }
3620
3621 static const char *adapter_le_service_find_addr_scan_filter_data(
3622                                                 struct btd_adapter *adapter, gchar *string)
3623 {
3624         GSList *list;
3625         DBG("");
3626
3627         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3628         if (!list)
3629                 return NULL;
3630         else
3631                 return list->data;
3632
3633         return NULL;
3634 }
3635
3636 static gboolean adapter_le_service_delete_addr_scan_filter_data(struct btd_adapter *adapter,
3637                                                 int filter_index, gchar *string, int addr_type)
3638 {
3639         GSList *list;
3640         DBG("");
3641
3642         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3643         if (!list)
3644                 return FALSE;
3645         else
3646                 /* Delete info from the struct to list */
3647                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3648
3649         return TRUE;
3650 }
3651
3652 static gboolean adapter_le_service_clear_addr_scan_filter_data(struct btd_adapter *adapter)
3653 {
3654         DBG("");
3655
3656         g_slist_free_full(adapter->addr_filters, addr_filter_params_free);
3657         adapter->addr_filters = NULL;
3658
3659         return TRUE;
3660 }
3661
3662 static gboolean adapter_le_service_add_uuid_scan_filter_data(struct btd_adapter *adapter,
3663                                                         int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3664                                                         uint8_t *p_uuid_mask, int uuid_mask_len)
3665 {
3666
3667         adapter_le_uuid_params_t *params;
3668         bt_uuid_t uuid;
3669
3670         DBG("");
3671
3672         params = g_new0(adapter_le_uuid_params_t, 1);
3673         if (!params)
3674                 return FALSE;
3675
3676         if (uuid_mask_len == UUID_16_LEN) {
3677                 uint16_t *uuid16 = (void *)p_uuid;
3678                 sdp_uuid16_create((uuid_t *)&uuid, get_be16(uuid16));
3679         } else if (uuid_mask_len == UUID_32_LEN) {
3680                 uint32_t *uuid32 = (void *)p_uuid;
3681                 sdp_uuid32_create((uuid_t *)&uuid, get_be32(uuid32));
3682         } else {
3683                 sdp_uuid128_create((uuid_t *)&uuid, p_uuid);
3684         }
3685         params->filter_index = filter_index;
3686         params->uuid = (uint8_t *)bt_uuid2string((uuid_t *)&uuid);
3687         params->uuid_mask = g_new0(uint8_t, uuid_mask_len);
3688         memcpy(params->uuid_mask, p_uuid_mask, uuid_mask_len);
3689         params->uuid_len = uuid_mask_len;
3690
3691         /* Store the struct to list */
3692         adapter->solicit_data_filters = g_slist_append(adapter->solicit_data_filters, params);
3693
3694         return TRUE;
3695 }
3696
3697 static adapter_le_uuid_params_t *adapter_le_service_find_uuid_scan_filter_data(struct btd_adapter *adapter,
3698                                                         uint8_t *p_uuid)
3699 {
3700         GSList *list;
3701         DBG("");
3702
3703         list = g_slist_find_custom(adapter->solicit_data_filters, p_uuid, adapter_le_uuid_cmp);
3704         if (!list)
3705                 return NULL;
3706         else
3707                 /* Delete info from the struct to list */
3708                 return list->data;
3709
3710         return NULL;
3711 }
3712
3713 static gboolean adapter_le_service_delete_uuid_scan_filter_data(struct btd_adapter *adapter,
3714                                                         int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3715                                                         uint8_t *p_uuid_mask, int uuid_mask_len)
3716 {
3717         GSList *list;
3718         DBG("");
3719
3720         list = g_slist_find_custom(adapter->solicit_data_filters, GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3721         if (!list)
3722                 return FALSE;
3723         else {
3724                 adapter_le_uuid_params_t *params = list->data;
3725                 /* Delete info from the struct to list */
3726                 if (params && strcasecmp((const char *)params->uuid, (const char *)p_uuid)) {
3727                         adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3728                 }
3729         }
3730
3731         return TRUE;
3732 }
3733
3734 static gboolean adapter_le_service_clear_uuid_scan_filter_data(struct btd_adapter *adapter)
3735 {
3736         DBG("");
3737
3738         g_slist_free_full(adapter->solicit_data_filters, uuid_filter_params_free);
3739         adapter->solicit_data_filters = NULL;
3740
3741         return TRUE;
3742 }
3743
3744 static gboolean adapter_le_service_add_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3745                                                         int filter_index, int company_id, int company_id_mask,
3746                                                         uint8_t *p_data, uint8_t *p_mask, int data_len)
3747 {
3748
3749         adapter_le_manf_data_params_t *params;
3750
3751         DBG("");
3752
3753         params = g_new0(adapter_le_manf_data_params_t, 1);
3754         if (!params)
3755                 return FALSE;
3756
3757         params->filter_index = filter_index;
3758         params->company_id = company_id;
3759         params->company_id_mask = company_id_mask;
3760         params->man_data = g_new0(uint8_t, data_len);
3761         memcpy(params->man_data, p_data, data_len);
3762         params->man_data_mask = g_new0(uint8_t, data_len);
3763         memcpy(params->man_data_mask, p_mask, data_len);
3764         params->man_data_len = data_len;
3765
3766         /* Store the struct to list */
3767         adapter->manufaturer_data_filters = g_slist_append(adapter->manufaturer_data_filters, params);
3768
3769         return TRUE;
3770 }
3771
3772 static adapter_le_manf_data_params_t *adapter_le_service_find_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3773                                                         struct eir_msd *msd)
3774 {
3775         GSList *list;
3776         DBG("");
3777         list = g_slist_find_custom(adapter->manufaturer_data_filters, msd, adapter_le_manufacturer_data_cmp);
3778         if (!list)
3779                 return NULL;
3780         else
3781                 return list->data;
3782
3783         return NULL;
3784 }
3785
3786 static gboolean adapter_le_service_delete_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3787                                                         int filter_index, int company_id, int company_id_mask,
3788                                                         uint8_t *p_data, uint8_t *p_mask, int data_len)
3789 {
3790         GSList *list;
3791         DBG("");
3792         list = g_slist_find_custom(adapter->manufaturer_data_filters, GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3793         if (!list)
3794                 return FALSE;
3795         else {
3796                 adapter_le_manf_data_params_t *params = list->data;
3797                 /* Delete info from the struct to list */
3798                 if (params && strcasecmp((const char *)params->man_data, (const char *)p_data)) {
3799                         adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3800                 }
3801         }
3802
3803         return TRUE;
3804 }
3805
3806 static gboolean adapter_le_service_clear_manufacturer_scan_filter_data(struct btd_adapter *adapter)
3807 {
3808         DBG("");
3809
3810         g_slist_free_full(adapter->manufaturer_data_filters, manufacturer_filter_params_free);
3811         adapter->manufaturer_data_filters = NULL;
3812
3813         return TRUE;
3814 }
3815
3816 static gboolean adapter_le_service_add_local_name_scan_filter_data(struct btd_adapter *adapter,
3817                                                                                         int filter_index, gchar *name)
3818 {
3819
3820         adapter_le_local_name_params_t *params;
3821
3822         DBG("");
3823
3824         params = g_new0(adapter_le_local_name_params_t, 1);
3825         if (!params)
3826                 return FALSE;
3827
3828         params->filter_index = filter_index;
3829         params->local_name = g_strdup(name);
3830         params->name_len = strlen(name);
3831
3832         /* Store the struct to list */
3833         adapter->local_name_filters = g_slist_append(adapter->local_name_filters, params);
3834
3835         return TRUE;
3836 }
3837
3838 static adapter_le_local_name_params_t *adapter_le_service_find_local_name_scan_filter_data(
3839                                                                                                 struct btd_adapter *adapter,
3840                                                                                                 gchar *name)
3841 {
3842         GSList *list;
3843         DBG("");
3844         list = g_slist_find_custom(adapter->local_name_filters, name, adapter_le_local_name_cmp);
3845         if (!list)
3846                 return NULL;
3847         else
3848                 return list->data;
3849
3850         return NULL;
3851 }
3852
3853 static gboolean adapter_le_service_delete_local_name_scan_filter_data(struct btd_adapter *adapter,
3854                                                                                                 int filter_index, gchar *name)
3855 {
3856         GSList *list;
3857         DBG("");
3858         list = g_slist_find_custom(adapter->local_name_filters, GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
3859         if (!list)
3860                 return FALSE;
3861         else {
3862                 adapter_le_local_name_params_t *params = list->data;
3863                 /* Delete info from the struct to list */
3864                 if (params && strcasecmp((const char *)params->local_name, (const char *)name)) {
3865                         adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
3866                 }
3867         }
3868
3869         return TRUE;
3870 }
3871
3872 static gboolean adapter_le_service_clear_local_name_scan_filter_data(struct btd_adapter *adapter)
3873 {
3874         DBG("");
3875
3876         g_slist_free_full(adapter->local_name_filters, local_name_filter_params_free);
3877         adapter->local_name_filters = NULL;
3878
3879         return TRUE;
3880 }
3881
3882 static gboolean adapter_le_service_add_service_scan_filter_data(struct btd_adapter *adapter,
3883                                                         int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
3884 {
3885         adapter_le_service_data_params_t *params;
3886
3887         DBG("");
3888
3889         params = g_new0(adapter_le_service_data_params_t, 1);
3890         if (!params)
3891                 return FALSE;
3892
3893         params->filter_index = filter_index;
3894         params->service_data = g_new0(uint8_t, data_len);
3895         memcpy(params->service_data, p_data, data_len);
3896         params->service_data_mask = g_new0(uint8_t, data_len);
3897         memcpy(params->service_data_mask, p_mask, data_len);
3898         params->service_data_len = data_len;
3899
3900         /* Store the struct to list */
3901         adapter->service_data_filters = g_slist_append(adapter->service_data_filters, params);
3902
3903         return TRUE;
3904 }
3905
3906 static adapter_le_service_data_params_t* adapter_le_service_find_service_scan_filter_data(
3907                                                         struct btd_adapter *adapter, struct eir_sd *sd)
3908 {
3909         GSList *list;
3910         DBG("");
3911
3912         list = g_slist_find_custom(adapter->service_data_filters, sd, adapter_le_service_data_cmp);
3913         if (!list)
3914                 return NULL;
3915         else
3916                 return list->data;
3917
3918         return NULL;
3919 }
3920
3921 static gboolean adapter_le_service_delete_service_scan_filter_data(struct btd_adapter *adapter,
3922                                                         int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
3923 {
3924         GSList *list;
3925         DBG("");
3926
3927         list = g_slist_find_custom(adapter->service_data_filters, GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3928         if (!list)
3929                 return FALSE;
3930         else {
3931                 adapter_le_service_data_params_t *params = list->data;
3932                 /* Delete info from the struct to list */
3933                 if (params && strcasecmp((const char *)params->service_data, (const char *)p_data)) {
3934                         adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
3935                 }
3936         }
3937         return TRUE;
3938 }
3939
3940 static gboolean adapter_le_service_clear_service_scan_filter_data(struct btd_adapter *adapter)
3941 {
3942         DBG("");
3943
3944         g_slist_free_full(adapter->service_data_filters, service_data_filter_params_free);
3945         adapter->service_data_filters = NULL;
3946
3947         return TRUE;
3948 }
3949
3950 static gboolean adapter_le_service_add_scan_filter_params(struct btd_adapter *adapter,
3951                                                         adapter_le_scan_filter_param_t *params)
3952 {
3953         adapter_le_scan_filter_param_t *l_params;
3954
3955         DBG("");
3956
3957         l_params = g_new0(adapter_le_scan_filter_param_t, 1);
3958         if (!l_params)
3959                 return FALSE;
3960
3961         l_params->action = params->action;
3962         l_params->delivery_mode = params->delivery_mode;
3963         l_params->feature = params->feature;
3964         l_params->filter_logic_type = params->filter_logic_type;
3965         l_params->index = params->index;
3966         l_params->list_logic_type = params->list_logic_type;
3967         l_params->onfound_timeout = params->onfound_timeout;
3968         l_params->onfound_timeout_cnt = params->onfound_timeout_cnt;
3969         l_params->rssi_high_threshold = params->rssi_high_threshold;
3970         l_params->rssi_low_threshold = params->rssi_low_threshold;
3971
3972         /* Store the struct to list */
3973         adapter->scan_params = g_slist_append(adapter->scan_params, l_params);
3974
3975         return TRUE;
3976 }
3977
3978 static adapter_le_scan_filter_param_t *adapter_le_service_find_scan_filter_params(
3979                                                         struct btd_adapter *adapter, int filter_index)
3980 {
3981         GSList *list;
3982         DBG("");
3983
3984         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
3985         if (!list)
3986                 return NULL;
3987         else
3988                 return list->data;
3989
3990         return NULL;
3991 }
3992
3993 static gboolean adapter_le_service_delete_scan_filter_params(struct btd_adapter *adapter,
3994                                                         adapter_le_scan_filter_param_t *params)
3995 {
3996         GSList *list;
3997         DBG("");
3998
3999         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(params->index), adapter_le_scan_params_filter_index_cmp);
4000         if (!list)
4001                 return FALSE;
4002         else
4003                 adapter->scan_params = g_slist_remove(adapter->scan_params, list);
4004
4005         return TRUE;
4006 }
4007
4008 static gboolean adapter_le_service_clear_scan_filter_params(struct btd_adapter *adapter)
4009 {
4010         DBG("");
4011
4012         g_slist_free_full(adapter->scan_params, scan_filter_params_free);
4013         adapter->scan_params = NULL;
4014
4015         return TRUE;
4016 }
4017
4018 int adapter_byte_arr_cmp_with_mask(const char *data1, const char *data2,
4019         const char *mask, int data_len)
4020 {
4021         int i;
4022         char a, b;
4023         if (data1 == NULL || data2 == NULL || mask == NULL)
4024                 return -1;
4025         for (i = 0; i < data_len; i++) {
4026                 a = data1[i] & mask[i];
4027                 b = data2[i] & mask[i];
4028                 if (a != b)
4029                         return (int)(a - b);
4030         }
4031         return 0;
4032 }
4033
4034 static uint8_t validate_for_filter_policy(struct btd_adapter *adapter,
4035                                                                 const struct eir_data *eir, gchar *addr)
4036 {
4037         uint8_t allow_report = NONE_REPORT;
4038
4039         if (adapter->scan_filter_support == FALSE)
4040                 allow_report = SCAN_REPORT;
4041         else {
4042                 if (adapter_le_service_find_addr_scan_filter_data(adapter, addr))
4043                         allow_report = SCAN_REPORT;
4044                 if (eir->name) {
4045                         if(adapter_le_service_find_local_name_scan_filter_data(adapter, eir->name))
4046                                 allow_report = SCAN_REPORT;
4047                         }
4048                 if (eir->sd_list) {
4049                         GSList *list = NULL;
4050                         for (list = eir->sd_list; list != NULL; list = g_slist_next(list)) {
4051                                 struct eir_sd *sd = list->data;
4052                                 if (sd != NULL) {
4053                                         static adapter_le_uuid_params_t *uuid_data = NULL;
4054                                         static adapter_le_service_data_params_t *service_data = NULL;
4055                                         static adapter_le_scan_filter_param_t *scan_param_data = NULL;
4056                                         uuid_data = adapter_le_service_find_uuid_scan_filter_data(adapter, (uint8_t *)sd->uuid);
4057                                         service_data = adapter_le_service_find_service_scan_filter_data(adapter, sd);
4058                                         if (service_data != NULL) {
4059                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)service_data->service_data,
4060                                                 (const char *)sd->data, (const char *)service_data->service_data_mask,
4061                                                 service_data->service_data_len)) {
4062                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4063                                                                                 service_data->filter_index);
4064                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4065                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
4066                                                                 allow_report = SCAN_REPORT;
4067                                                 }
4068                                         }
4069                                         if (uuid_data != NULL) {
4070                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)uuid_data->uuid,
4071                                                 (const char *)sd->uuid, (const char *)uuid_data->uuid_mask,
4072                                                 uuid_data->uuid_len)) {
4073                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4074                                                                                                 uuid_data->filter_index);
4075                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4076                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
4077                                                                 allow_report = SCAN_REPORT;
4078                                                 }
4079                                         }
4080                                         if (allow_report)
4081                                                 break;
4082                                 }
4083                         }
4084                 }
4085                 if (eir->msd_list) {
4086                         GSList *list = NULL;
4087                         for (list = eir->msd_list; list != NULL; list = g_slist_next(list)) {
4088                                 struct eir_msd *msd = list->data;
4089                                 if (msd != NULL) {
4090                                         static adapter_le_manf_data_params_t *manuf_data;
4091                                         static adapter_le_scan_filter_param_t *scan_param_data = NULL;
4092                                         manuf_data = adapter_le_service_find_manufacturer_scan_filter_data(adapter,
4093                                                         msd);
4094                                         if (manuf_data != NULL) {
4095                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)msd->data,
4096                                                         (const char *)manuf_data->man_data, (const char *)manuf_data->man_data_mask,
4097                                                         manuf_data->man_data_len)) {
4098                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4099                                                                                                 manuf_data->filter_index);
4100                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4101                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
4102                                                                 allow_report = SCAN_REPORT;
4103                                                 }
4104                                                 if (msd->company == COMPANY_ID_APPLE)
4105                                                         allow_report = IBEACON_REPORT;
4106                                         }
4107                                 }
4108                         }
4109                 }
4110         }
4111         return allow_report;
4112 }
4113
4114 gboolean adapter_le_set_platform_scan_filter_params(struct btd_adapter *adapter,
4115                                         adapter_le_scan_filter_param_t *params)
4116 {
4117         gboolean ret = TRUE;
4118         DBG("adapter_le_scan_filter_param_t [%d]", params->index);
4119         adapter_le_scan_filter_action_type action_type = params->action;
4120
4121         if (action_type == ADD) {
4122                 ret = adapter_le_service_add_scan_filter_params(adapter, params);
4123         } else if (action_type == DELETE) {
4124                 ret = adapter_le_service_delete_scan_filter_params(adapter, params);
4125         } else if (action_type == CLEAR) {
4126                 ret = adapter_le_service_clear_scan_filter_params(adapter);
4127         } else {
4128                 DBG("filter_action error");
4129                 ret = FALSE;
4130         }
4131
4132         DBG("Scan Filter VSC :: Action [%x]",
4133                                         params->action);
4134         return ret;
4135 }
4136
4137 gboolean adapter_le_set_platform_scan_filter_data(struct btd_adapter *adapter,
4138                                                 int client_if, int action,
4139                                                 int filt_type, int filter_index,
4140                                                 int company_id,
4141                                                 int company_id_mask,
4142                                                 int uuid_len, uint8_t *p_uuid,
4143                                                 int uuid_mask_len, uint8_t *p_uuid_mask,
4144                                                 gchar *string, int addr_type,
4145                                                 int data_len, uint8_t *p_data,
4146                                                 int mask_len, uint8_t *p_mask)
4147 {
4148         gboolean ret = TRUE;
4149
4150         DBG("");
4151
4152         switch (filt_type) {
4153         case TYPE_DEVICE_ADDRESS: {
4154                 /* TYPE_DEVICE_ADDRESS */
4155                 adapter_le_scan_filter_action_type action_type = action;
4156
4157                 if (action_type == ADD) {
4158                         ret = adapter_le_service_add_addr_scan_filter_data(adapter,
4159                                                 filter_index, string, addr_type);
4160                 } else if (action_type == DELETE) {
4161                         ret = adapter_le_service_delete_addr_scan_filter_data(adapter,
4162                                                 filter_index, string, addr_type);
4163                 } else if (action_type == CLEAR) {
4164                         ret = adapter_le_service_clear_addr_scan_filter_data(adapter);
4165                 } else {
4166                         DBG("filter_action error");
4167                         ret = FALSE;
4168                 }
4169
4170                 break;
4171         }
4172
4173         case TYPE_SERVICE_UUID:
4174         case TYPE_SOLICIT_UUID: {
4175                 adapter_le_scan_filter_action_type action_type = action;
4176
4177                 gboolean is_solicited = (filt_type == TYPE_SOLICIT_UUID) ? TRUE : FALSE;
4178
4179                 if (uuid_len != UUID_16_LEN && uuid_len != UUID_32_LEN
4180                         && uuid_len != UUID_128_LEN) {
4181                         DBG("UUID length error");
4182                         return FALSE;
4183                 }
4184
4185                 if (uuid_len != uuid_mask_len) {
4186                         DBG("Both UUID and UUID_MASK length shoule be samed");
4187                         return FALSE;
4188                 }
4189
4190                 if (action_type == ADD) {
4191                         ret = adapter_le_service_add_uuid_scan_filter_data(adapter,
4192                                                 filter_index, is_solicited, p_uuid,
4193                                                 p_uuid_mask, uuid_len);
4194                 } else if (action_type == DELETE) {
4195                         ret = adapter_le_service_delete_uuid_scan_filter_data(adapter,
4196                                                 filter_index, is_solicited, p_uuid,
4197                                                 p_uuid_mask, uuid_len);
4198                 } else if (action_type == CLEAR) {
4199                         ret = adapter_le_service_clear_uuid_scan_filter_data(adapter);
4200                 } else {
4201                         DBG("filter_action error");
4202                         ret = FALSE;
4203                 }
4204
4205                 break;
4206         }
4207
4208         case TYPE_LOCAL_NAME: {
4209                 adapter_le_scan_filter_action_type action_type = action;
4210
4211                 if (action_type == ADD) {
4212                         ret = adapter_le_service_add_local_name_scan_filter_data(adapter,
4213                                                 filter_index, (gchar*)string);
4214                 } else if (action_type == DELETE) {
4215                         ret = adapter_le_service_delete_local_name_scan_filter_data(adapter,
4216                                                 filter_index, (gchar*)string);
4217                 } else if (action_type == CLEAR) {
4218                         ret = adapter_le_service_clear_local_name_scan_filter_data(adapter);
4219                 } else {
4220                         DBG("filter_action error");
4221                         ret = FALSE;
4222                 }
4223
4224                 break;
4225         }
4226
4227         case TYPE_MANUFACTURER_DATA: {
4228                 adapter_le_scan_filter_action_type action_type = action;
4229
4230                 if (data_len == 0 || (data_len != mask_len)) {
4231                         DBG("parameter length error");
4232                         return FALSE;
4233                 }
4234
4235                 if (action_type == ADD) {
4236                         ret = adapter_le_service_add_manufacturer_scan_filter_data(adapter,
4237                                                 filter_index,company_id, company_id_mask, p_data, p_mask, data_len);
4238                 } else if (action_type == DELETE) {
4239                         ret = adapter_le_service_delete_manufacturer_scan_filter_data(adapter,
4240                                                 filter_index, company_id, company_id_mask, p_data, p_mask, data_len);
4241                 } else if (action_type == CLEAR) {
4242                         ret = adapter_le_service_clear_manufacturer_scan_filter_data(adapter);
4243                 } else {
4244                         DBG("filter_action error");
4245                         ret = FALSE;
4246                 }
4247
4248                 break;
4249         }
4250
4251         case TYPE_SERVICE_DATA: {
4252                 adapter_le_scan_filter_action_type action_type = action;
4253
4254                 if (data_len == 0 || (data_len != mask_len)) {
4255                         DBG("parameter length error");
4256                         return FALSE;
4257                 }
4258
4259                 if (action_type == ADD) {
4260                         ret = adapter_le_service_add_service_scan_filter_data(adapter,
4261                                                 filter_index, p_data, p_mask, data_len);
4262                 } else if (action_type == DELETE) {
4263                         ret = adapter_le_service_delete_service_scan_filter_data(adapter,
4264                                                 filter_index, p_data, p_mask, data_len);
4265                 } else if (action_type == CLEAR) {
4266                         ret = adapter_le_service_clear_service_scan_filter_data(adapter);
4267                 } else {
4268                         DBG("filter_action error");
4269                         ret = FALSE;
4270                 }
4271
4272                 break;
4273         }
4274
4275         default:
4276                 DBG("filter_type error");
4277                 ret = FALSE;
4278         }
4279
4280         return ret;
4281 }
4282 #endif
4283
4284 static int set_adv_data_flag(uint8_t *adv_data, uint8_t *data, int data_len, void *user_data)
4285 {
4286         struct btd_adapter *adapter = user_data;
4287
4288         adv_data[0] = 2;
4289         adv_data[1] = EIR_FLAGS;
4290
4291         if (adapter->le_static_addr.b[5] != 0)
4292                 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER |
4293                                 EIR_SIM_HOST | EIR_BREDR_UNSUP;
4294         else
4295                 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER | EIR_SIM_HOST;
4296
4297         memcpy(adv_data + 3, data, data_len);
4298         return data_len + 3;
4299 }
4300
4301 static int set_adv_data_device_name(uint8_t *adv_data, int adv_len, char *name)
4302 {
4303         int ad_type;
4304         int ad_len;
4305         int i, j;
4306         int name_len;
4307         uint8_t *data = NULL;
4308
4309         if (!name)
4310                 return adv_len;
4311
4312         data = g_memdup(adv_data, adv_len);
4313         if (!data)
4314                 return adv_len;
4315
4316         name_len = strlen(name);
4317
4318         for (i = 0; i <adv_len ; i++) {
4319                 ad_len = data[i];
4320                 ad_type = data[i + 1];
4321
4322                 if (ad_type == EIR_NAME_COMPLETE) {
4323                         /* Move to last position and update local name */
4324                         for (j = i; j < adv_len - 2; j++)
4325                                 adv_data[j] = data[j + 2];
4326
4327                         adv_data[j] = name_len + 1;
4328                         if (name_len > ADV_DATA_MAX_LENGTH - adv_len) {
4329                                 adv_data[j] = ADV_DATA_MAX_LENGTH - adv_len + 1;
4330                                 adv_data[j + 1] = EIR_NAME_SHORT;
4331                                 memcpy(adv_data + j + 2, name, ADV_DATA_MAX_LENGTH - adv_len);
4332                                 g_free(data);
4333                                 return ADV_DATA_MAX_LENGTH;
4334                         } else {
4335                                 adv_data[j + 1] = EIR_NAME_COMPLETE;
4336                                 memcpy(adv_data + j + 2, name, name_len);
4337                                 g_free(data);
4338                                 return adv_len + name_len;
4339                         }
4340
4341                 } else {
4342                         memcpy(adv_data + i, &data[i], ad_len + 1);
4343                         i = i + data[i];
4344                 }
4345         }
4346
4347         g_free(data);
4348         return adv_len;
4349 }
4350
4351 static int set_adv_data_tx_power(uint8_t *adv_data, int adv_len, int8_t tx_power)
4352 {
4353         int ad_type;
4354         int ad_len;
4355         int i, j;
4356         uint8_t *data = NULL;
4357
4358         data = g_memdup(adv_data, adv_len);
4359         if (!data)
4360                 return adv_len;
4361
4362         for (i = 0; i <adv_len ; i++) {
4363                 ad_len = data[i];
4364                 ad_type = data[i + 1];
4365
4366                 if (ad_type == EIR_TX_POWER) {
4367                         adv_data[i] = 2;
4368                         adv_data[i + 1] = EIR_TX_POWER;
4369                         adv_data[i + 2] = tx_power;
4370
4371                         for(j = i + 2; j < adv_len; j++)
4372                                 adv_data[j + 1] = data[j];
4373
4374                         g_free(data);
4375                         return adv_len + 1;
4376                 } else {
4377                         memcpy(adv_data + i, &data[i], ad_len + 1);
4378                         i = i + data[i];
4379                 }
4380         }
4381
4382         g_free(data);
4383         return adv_len;
4384 }
4385
4386
4387 static int adapter_le_set_missed_adv_data(uint8_t *p_data, uint8_t data_len,
4388                 gboolean is_scan_rsp, char *adapter_name, int8_t tx_power, uint8_t **adv_data, int *adv_len,
4389                 void *user_data)
4390 {
4391         uint8_t *data;
4392         int len;
4393
4394         data = g_malloc0(ADV_DATA_MAX_LENGTH);
4395         memcpy(data, p_data, data_len);
4396         len = data_len;
4397
4398         /* In case multi advertising, need to update the below AD type
4399                 since it handled into kernel */
4400         if (!is_scan_rsp) {
4401                 len = set_adv_data_flag(data, p_data, data_len, user_data);
4402         }
4403
4404         len = set_adv_data_tx_power(data, len, tx_power);
4405
4406         len = set_adv_data_device_name(data, len, adapter_name);
4407
4408         *adv_data = data;
4409         *adv_len = len;
4410         return 0;
4411 }
4412
4413 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
4414 static DBusMessage *adapter_get_psm_l2cap_le(DBusConnection *conn,
4415                                                 DBusMessage *msg, void *user_data)
4416 {
4417         return get_psm_l2cap_le(conn, msg);
4418 }
4419
4420 static DBusMessage *adapter_listen_l2cap_le_socket(DBusConnection *conn,
4421                                                 DBusMessage *msg, void *user_data)
4422 {
4423         return listen_l2cap_le_socket(conn, msg, user_data);
4424 }
4425
4426 static DBusMessage *adapter_remove_l2cap_le_socket(DBusConnection *conn,
4427                                                 DBusMessage *msg, void *user_data)
4428 {
4429         return remove_l2cap_le_socket(conn, msg);
4430 }
4431
4432 #endif
4433
4434 static DBusMessage *adapter_start_custom_discovery(DBusConnection *conn,
4435                                         DBusMessage *msg, void *user_data)
4436 {
4437         struct btd_adapter *adapter = user_data;
4438         const char *sender = dbus_message_get_sender(msg);
4439         struct discovery_client *client;
4440         GSList *list;
4441         const gchar *disc_type;
4442
4443         DBG("sender %s", sender);
4444
4445         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4446                 return btd_error_not_ready(msg);
4447
4448         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &disc_type,
4449                                                         DBUS_TYPE_INVALID)) {
4450                 return btd_error_invalid_args(msg);
4451         }
4452
4453         DBG("discovery type = %s", disc_type);
4454
4455         /*Valid strings: "BREDR", "LE", "LE_BREDR" */
4456         if (g_strcmp0(disc_type, "BREDR") == 0)
4457                 adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
4458         else if (g_strcmp0(disc_type, "LE") == 0)
4459                 adapter->disc_type =  BT_DISC_TYPE_LE_ONLY;
4460         else if (g_strcmp0(disc_type, "LE_BREDR") == 0)
4461                 adapter->disc_type =  BT_DISC_TYPE_LE_BREDR;
4462         else
4463                 return btd_error_invalid_args(msg);
4464
4465         /*
4466          * Every client can only start one discovery, if the client
4467          * already started a discovery then return an error.
4468          */
4469         list = g_slist_find_custom(adapter->discovery_list, sender,
4470                                                 compare_sender);
4471         if (list)
4472                 return btd_error_busy(msg);
4473
4474         client = g_new0(struct discovery_client, 1);
4475
4476         client->adapter = adapter;
4477         client->owner = g_strdup(sender);
4478         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4479                                                 discovery_disconnect, client,
4480                                                 discovery_destroy);
4481
4482         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
4483                                                                 client);
4484
4485         /*
4486          * Just trigger the discovery here. In case an already running
4487          * discovery in idle phase exists, it will be restarted right
4488          * away.
4489          */
4490         trigger_start_discovery(adapter, 0);
4491
4492         return dbus_message_new_method_return(msg);
4493 }
4494
4495 static DBusMessage *adapter_start_le_discovery(DBusConnection *conn,
4496                                         DBusMessage *msg, void *user_data)
4497 {
4498         struct btd_adapter *adapter = user_data;
4499         const char *sender = dbus_message_get_sender(msg);
4500         struct discovery_client *client;
4501         GSList *list;
4502
4503         DBG("sender %s", sender);
4504
4505         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4506                 return btd_error_not_ready(msg);
4507
4508         /*
4509          * Every client can only start one discovery, if the client
4510          * already started a discovery then return an error.
4511          */
4512
4513         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4514         DBG("adapter->disc_type[%d]", adapter->disc_type);
4515         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4516
4517         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4518                                                 compare_sender);
4519         if (list)
4520                 return btd_error_busy(msg);
4521
4522         client = g_new0(struct discovery_client, 1);
4523
4524         client->adapter = adapter;
4525         client->owner = g_strdup(sender);
4526         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4527                                                 le_discovery_disconnect, client,
4528                                                 le_discovery_destroy);
4529
4530         adapter->le_discovery_list = g_slist_prepend(adapter->le_discovery_list,
4531                                                                 client);
4532
4533         /*
4534          * Just trigger the discovery here. In case an already running
4535          * discovery in idle phase exists, it will be restarted right
4536          * away.
4537          */
4538         trigger_start_le_discovery(adapter, 0);
4539
4540         return dbus_message_new_method_return(msg);
4541 }
4542
4543 static DBusMessage *adapter_stop_le_discovery(DBusConnection *conn,
4544                                         DBusMessage *msg, void *user_data)
4545 {
4546         struct btd_adapter *adapter = user_data;
4547         const char *sender = dbus_message_get_sender(msg);
4548         struct mgmt_cp_stop_le_discovery cp;
4549         struct discovery_client *client;
4550         GSList *list;
4551
4552         DBG("sender %s", sender);
4553
4554         if (adapter->le_discovery_idle_timeout > 0) {
4555                 DBG("Remove LE scan trigger");
4556                 g_source_remove(adapter->le_discovery_idle_timeout);
4557                 adapter->le_discovery_idle_timeout = 0;
4558         }
4559
4560         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4561                 return btd_error_not_ready(msg);
4562
4563         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4564                                                 compare_sender);
4565         if (!list)
4566                 return btd_error_failed(msg, "No discovery started");
4567
4568         client = list->data;
4569
4570         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4571         DBG("adapter->disc_type[%d]", adapter->disc_type);
4572         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4573
4574         cp.type = adapter->discovery_type;
4575         DBG("cp.type %d", cp.type);
4576
4577         /*
4578          * As long as other discovery clients are still active, just
4579          * clenup client info and return success.
4580          */
4581         DBG("adapter->le_discovery_list %p", adapter->le_discovery_list);
4582         if (g_slist_next(adapter->le_discovery_list)) {
4583                 /*
4584                  * The destroy function will cleanup the client information and
4585                  * also remove it from the list of discovery clients.
4586                  */
4587                 g_dbus_remove_watch(dbus_conn, client->watch);
4588                 return dbus_message_new_method_return(msg);
4589         }
4590
4591         /*
4592          * In the idle phase of a discovery, there is no need to stop it
4593          * and so it is enough to send out the signal and just return.
4594          */
4595         DBG("cp.type %d", cp.type);
4596         DBG("adapter->discovery_enable %d", adapter->discovery_enable);
4597         if (adapter->discovery_enable == 0x00) {
4598                 adapter->le_discovering = false;
4599                 g_dbus_remove_watch(dbus_conn, client->watch);
4600                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
4601                                         ADAPTER_INTERFACE, "LEDiscovering");
4602
4603                 trigger_passive_scanning(adapter);
4604                 return dbus_message_new_method_return(msg);
4605         }
4606
4607         DBG("adapter->discovery_type %d", adapter->discovery_type);
4608         cp.type = 0x06;
4609         DBG("cp.type %d", cp.type);
4610         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
4611                                 adapter->dev_id, sizeof(cp), &cp,
4612                                 stop_le_discovery_complete, adapter, NULL);
4613
4614         client->msg = dbus_message_ref(msg);
4615         return NULL;
4616 }
4617
4618 static DBusMessage *adapter_set_advertising(DBusConnection *conn,
4619                                                 DBusMessage *msg, void *data)
4620 {
4621         struct btd_adapter *adapter = data;
4622         dbus_bool_t err;
4623         dbus_bool_t enable = FALSE;
4624         dbus_int32_t slot_id;
4625
4626         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4627                 return btd_error_not_ready(msg);
4628
4629         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &enable,
4630                                                 DBUS_TYPE_INT32, &slot_id,
4631                                                 DBUS_TYPE_INVALID))
4632                 return btd_error_invalid_args(msg);
4633
4634         if (adapter->adv_restart_timeout > 0)
4635                 return btd_error_in_progress(msg);
4636
4637         DBG("%s advertising slot_id %d", enable ? "Enable" : "Disable", slot_id);
4638
4639         if (adapter_le_is_supported_multi_advertising() && slot_id > 0)
4640                 err = adapter_le_enable_multi_adv(adapter, enable, slot_id);
4641         else
4642                 err = set_mode(adapter, MGMT_OP_SET_ADVERTISING, enable);
4643
4644         if (!err)
4645                 return btd_error_failed(msg, "Set Advertising failed");
4646
4647         if (enable)
4648                 create_advertiser(adapter, slot_id);
4649
4650         if (err && slot_id > 0)
4651                 advertising_state_changed(adapter, slot_id, enable);
4652
4653         return dbus_message_new_method_return(msg);
4654 }
4655
4656 static DBusMessage *adapter_set_advertising_params(DBusConnection *conn,
4657                                                 DBusMessage *msg, void *data)
4658 {
4659         struct btd_adapter *adapter = data;
4660         struct mgmt_cp_set_advertising_params cp;
4661         dbus_uint32_t interval_min;
4662         dbus_uint32_t interval_max;
4663         dbus_uint32_t filter_policy;
4664         dbus_uint32_t type;
4665         dbus_int32_t tx_power_level;
4666         dbus_int32_t slot_id;
4667         gboolean ret;
4668
4669         DBG("Set customised advertising parameters");
4670
4671         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4672                 return btd_error_not_ready(msg);
4673
4674         if (!dbus_message_get_args(msg, NULL,
4675                                 DBUS_TYPE_UINT32, &interval_min,
4676                                 DBUS_TYPE_UINT32, &interval_max,
4677                                 DBUS_TYPE_UINT32, &filter_policy,
4678                                 DBUS_TYPE_UINT32, &type,
4679                                 DBUS_TYPE_INT32, &tx_power_level,
4680                                 DBUS_TYPE_INT32, &slot_id,
4681                                 DBUS_TYPE_INVALID))
4682                 return btd_error_invalid_args(msg);
4683
4684         memset(&cp, 0, sizeof(cp));
4685
4686         DBG("advertising interval min %x, max %x, filter %x type %x, tx power %d",
4687                                 interval_min, interval_max, filter_policy, type, tx_power_level);
4688
4689         if (filter_policy > 0x03)
4690                 return btd_error_invalid_args(msg);
4691
4692         if (type > 0x04)
4693                 return btd_error_invalid_args(msg);
4694
4695         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4696                 adapter_le_adv_inst_info_t *p_inst;
4697                 adapter_le_adv_param_t *p_params;
4698
4699                 p_inst = g_malloc0(sizeof(adapter_le_adv_inst_info_t));
4700                 p_params = g_malloc0(sizeof(adapter_le_adv_param_t));
4701                 p_inst->inst_id = slot_id;
4702                 p_params->adv_int_min = interval_min;
4703                 p_params->adv_int_max = interval_max;
4704                 p_params->adv_type = type;
4705                 p_params->channel_map = 0x07;   /* fixed channel :: will be used all */
4706                 p_params->adv_filter_policy = filter_policy;
4707                 p_params->tx_power = tx_power_level;
4708
4709                 if (adapter->current_settings & MGMT_SETTING_PRIVACY) {
4710                         p_inst->bdaddr_type = 0x01;
4711                         bacpy(&p_inst->bdaddr, &adapter->rpa);
4712                 } else if (adapter->le_static_addr.b[5] != 0) {
4713                         p_inst->bdaddr_type = 0x01;
4714                         bacpy(&p_inst->bdaddr, &adapter->le_static_addr);
4715                 } else {
4716                         p_inst->bdaddr_type = 0x00;
4717                         bacpy(&p_inst->bdaddr, &adapter->bdaddr);
4718                 }
4719
4720                 ret = adapter_le_set_multi_adv_params(p_inst, p_params);
4721
4722                 g_free(p_inst);
4723                 g_free(p_params);
4724
4725                 if (ret)
4726                         return dbus_message_new_method_return(msg);
4727                 else
4728                         return btd_error_failed(msg, "set advertising param failed");
4729         } else {
4730                 cp.interval_max = interval_max;
4731                 cp.interval_min = interval_min;
4732                 cp.filter_policy = filter_policy;
4733                 cp.type = type;
4734
4735                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_PARAMS,
4736                                         adapter->dev_id, sizeof(cp), &cp,
4737                                         NULL, NULL, NULL) > 0)
4738                         return dbus_message_new_method_return(msg);
4739
4740                 return btd_error_failed(msg, "set advertising param failed");
4741         }
4742 }
4743
4744 static DBusMessage *adapter_set_advertising_data(DBusConnection *conn,
4745                                                 DBusMessage *msg, void *data)
4746 {
4747         struct btd_adapter *adapter = data;
4748         struct mgmt_cp_set_advertising_data cp;
4749         uint8_t *value;
4750         int32_t len = 0;
4751         dbus_int32_t slot_id;
4752         uint8_t *adv_data = NULL;
4753         int adv_len = 0;
4754         char *adapter_name = adapter->name;
4755         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
4756
4757         DBG("Set advertising data");
4758
4759         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4760                 return btd_error_not_ready(msg);
4761
4762         if (!dbus_message_get_args(msg, NULL,
4763                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4764                         DBUS_TYPE_INT32, &slot_id,
4765                         DBUS_TYPE_INVALID))
4766                 return btd_error_invalid_args(msg);
4767
4768         if (len > ADV_DATA_MAX_LENGTH - 3)
4769                 return btd_error_invalid_args(msg);
4770
4771         if (adapter->le_static_addr.b[5] != 0) {
4772                 char *ptr = NULL;
4773
4774                 g_strlcpy(le_name, adapter_name,
4775                                 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
4776                 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
4777                         *ptr = '\0';
4778
4779                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
4780                 adapter_name = le_name;
4781         }
4782
4783         adapter_le_set_missed_adv_data(value, len, FALSE,
4784                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
4785
4786         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4787                 if (adapter_le_set_multi_adv_data(slot_id, FALSE, adv_len, adv_data)) {
4788                         g_free(adv_data);
4789                         return dbus_message_new_method_return(msg);
4790                 } else {
4791                         g_free(adv_data);
4792                         return btd_error_failed(msg, "set advertising data failed");
4793                 }
4794         } else {
4795                 memcpy(&cp, adv_data, adv_len);
4796
4797                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_DATA,
4798                                                 adapter->dev_id, adv_len,
4799                                                 &cp, NULL, NULL, NULL) > 0) {
4800                         g_free(adv_data);
4801                         return dbus_message_new_method_return(msg);
4802                 }
4803
4804                 g_free(adv_data);
4805                 return btd_error_failed(msg, "set advertising data failed");
4806         }
4807 }
4808
4809 static DBusMessage *adapter_le_scan_filter_param_setup(DBusConnection *conn,
4810                                                 DBusMessage *msg, void *data)
4811 {
4812         struct btd_adapter *adapter = data;
4813 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4814         dbus_bool_t ctlr_filter_support = TRUE;
4815 #endif
4816         dbus_int32_t client_if, action, filt_index;
4817         dbus_int32_t feat_seln, list_logic_type, filt_logic_type;
4818         dbus_int32_t rssi_high_thres, rssi_low_thres, dely_mode;
4819         dbus_int32_t found_timeout, lost_timeout, found_timeout_cnt;
4820         adapter_le_scan_filter_param_t params;
4821         gboolean err;
4822
4823         DBG("adapter_le_scan_filter_param_setup");
4824
4825         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4826                 return btd_error_not_ready(msg);
4827
4828         if (adapter_le_get_scan_filter_size() == 0)
4829 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4830                 return btd_error_not_supported(msg);
4831 #else
4832                 ctlr_filter_support = FALSE;
4833 #endif
4834
4835         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4836                                                 DBUS_TYPE_INT32, &action,
4837                                                 DBUS_TYPE_INT32, &filt_index,
4838                                                 DBUS_TYPE_INT32, &feat_seln,
4839                                                 DBUS_TYPE_INT32, &list_logic_type,
4840                                                 DBUS_TYPE_INT32, &filt_logic_type,
4841                                                 DBUS_TYPE_INT32, &rssi_high_thres,
4842                                                 DBUS_TYPE_INT32, &rssi_low_thres,
4843                                                 DBUS_TYPE_INT32, &dely_mode,
4844                                                 DBUS_TYPE_INT32, &found_timeout,
4845                                                 DBUS_TYPE_INT32, &lost_timeout,
4846                                                 DBUS_TYPE_INT32, &found_timeout_cnt,
4847                                                 DBUS_TYPE_INVALID))
4848                 return btd_error_invalid_args(msg);
4849
4850         memset(&params, 0, sizeof(params));
4851
4852         params.action = action;
4853         params.index = filt_index;
4854         params.feature = feat_seln;
4855         params.filter_logic_type = filt_logic_type;
4856         params.list_logic_type = list_logic_type;
4857         params.delivery_mode = dely_mode;
4858         params.rssi_high_threshold = rssi_high_thres;
4859
4860         if (params.delivery_mode == ON_FOUND) {
4861                 params.rssi_low_threshold = rssi_low_thres;
4862                 params.onfound_timeout = found_timeout;
4863                 params.onfound_timeout_cnt = found_timeout_cnt;
4864                 params.onlost_timeout = lost_timeout;
4865         }
4866
4867 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4868         if (ctlr_filter_support)
4869 #endif
4870         err = adapter_le_set_scan_filter_params(&params);
4871 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4872         else
4873                 err = adapter_le_set_platform_scan_filter_params(adapter, &params);
4874 #endif
4875
4876         if (!err)
4877                 return btd_error_failed(msg, "Failed to scan filter param setup");
4878
4879         return dbus_message_new_method_return(msg);
4880 }
4881
4882 static DBusMessage *adapter_le_scan_filter_add_remove(DBusConnection *conn,
4883                                                 DBusMessage *msg, void *data)
4884 {
4885         struct btd_adapter *adapter = data;
4886         struct btd_device *dev = NULL;
4887         dbus_int32_t client_if, action, filt_type, filt_index;
4888         dbus_int32_t company_id, company_id_mask;
4889         gchar *str = NULL;
4890         dbus_uint32_t address_type = 0;
4891         uint8_t addr_type = 0;
4892         GSList *list;
4893         char string[30];
4894         uint8_t *p_uuid, *p_uuid_mask, *p_data, *p_mask;
4895         int32_t uuid_len = 0, uuid_mask_len = 0, data_len = 0, mask_len = 0;
4896         gboolean err;
4897 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4898         dbus_bool_t ctlr_filter_support = TRUE;
4899 #endif
4900
4901         DBG("adapter_le_scan_filter_add_remove");
4902
4903         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4904                 return btd_error_not_ready(msg);
4905
4906         /* if controller does not support vendor specific scan filtering feature
4907          * then add the filter into platform supported scan filters.
4908          */
4909         if (adapter_le_get_scan_filter_size() == 0) {
4910 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4911                 return btd_error_not_supported(msg);
4912 #else
4913                 ctlr_filter_support = FALSE;
4914 #endif
4915         }
4916
4917         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4918                                                 DBUS_TYPE_INT32, &action,
4919                                                 DBUS_TYPE_INT32, &filt_type,
4920                                                 DBUS_TYPE_INT32, &filt_index,
4921                                                 DBUS_TYPE_INT32, &company_id,
4922                                                 DBUS_TYPE_INT32, &company_id_mask,
4923                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid, &uuid_len,
4924                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid_mask, &uuid_mask_len,
4925                                                 DBUS_TYPE_STRING, &str,
4926                                                 DBUS_TYPE_UINT32, &address_type,
4927                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_data, &data_len,
4928                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_mask, &mask_len,
4929                                                 DBUS_TYPE_INVALID))
4930                 return btd_error_invalid_args(msg);
4931
4932         if (filt_type == TYPE_DEVICE_ADDRESS) {
4933                 list = g_slist_find_custom(adapter->devices, str, device_rpa_cmp);
4934                 if (!list)
4935                         list = g_slist_find_custom(adapter->devices, str,
4936                                                                 device_address_cmp);
4937                 if (list)
4938                         dev = list->data;
4939                 if (dev && device_get_rpa_exist(dev) == true) {
4940                         ba2str(device_get_address(dev), string);
4941                         if (btd_device_get_bdaddr_type(dev) == BDADDR_LE_PUBLIC)
4942                                 addr_type = 0x00;
4943                         else
4944                                 addr_type = 0x01;
4945                 } else {
4946                         strncpy(string, str, sizeof(string) - 1);
4947                         addr_type = 0x00;
4948                 }
4949
4950                 DBG("addr %s, type %d", string, addr_type);
4951         } else {
4952                 strncpy(string, str, sizeof(string) - 1 );
4953         }
4954
4955 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4956         if (ctlr_filter_support)
4957 #endif
4958         err = adapter_le_set_scan_filter_data(client_if, action, filt_type,
4959                         filt_index, company_id, company_id_mask,
4960                         uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
4961                         string, addr_type, data_len, p_data, mask_len, p_mask);
4962 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4963         else
4964                 err = adapter_le_set_platform_scan_filter_data(adapter, client_if, action, filt_type,
4965                                 filt_index, company_id, company_id_mask,
4966                                 uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
4967                                 string, addr_type, data_len, p_data, mask_len, p_mask);
4968 #endif
4969         if (!err)
4970                 return btd_error_failed(msg, "Failed to add/remove filter");
4971
4972         return dbus_message_new_method_return(msg);
4973 }
4974
4975 static DBusMessage *adapter_le_scan_filter_clear(DBusConnection *conn,
4976                                                 DBusMessage *msg, void *data)
4977 {
4978         struct btd_adapter *adapter = data;
4979         dbus_int32_t client_if = 0;
4980         dbus_int32_t filt_index = 0;
4981         gboolean err;
4982 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4983         dbus_bool_t ctlr_filter_support = TRUE;
4984 #endif
4985
4986         DBG("adapter_le_scan_filter_clear");
4987
4988         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4989                 return btd_error_not_ready(msg);
4990
4991         if (adapter_le_get_scan_filter_size() == 0)
4992 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4993                 return btd_error_not_supported(msg);
4994 #else
4995                 ctlr_filter_support = FALSE;
4996 #endif
4997
4998         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4999                                                 DBUS_TYPE_INT32, &filt_index,
5000                                                 DBUS_TYPE_INVALID))
5001                 return btd_error_invalid_args(msg);
5002
5003 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5004         if (ctlr_filter_support)
5005 #endif
5006         err = adapter_le_clear_scan_filter_data(client_if, filt_index);
5007 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5008         else
5009                 err = adapter_le_clear_platform_scan_filter_data(adapter, filt_index);
5010 #endif
5011
5012         if (!err)
5013                 return btd_error_failed(msg, "Failed to clear filter");
5014
5015         return dbus_message_new_method_return(msg);
5016 }
5017
5018
5019 static DBusMessage *adapter_le_scan_filter_enable(DBusConnection *conn,
5020                                                 DBusMessage *msg, void *data)
5021 {
5022         struct btd_adapter *adapter = data;
5023         dbus_bool_t enable = FALSE;
5024         dbus_int32_t client_if = 0;
5025         gboolean err;
5026 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5027         dbus_bool_t ctlr_filter_support = TRUE;
5028 #endif
5029
5030         DBG("adapter_le_scan_filter_enable");
5031
5032         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5033                 return btd_error_not_ready(msg);
5034
5035 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5036         /* if controller does not support vendor specific scan filtering feature
5037          * then enable platform supported scan filtering functionalites.
5038          */
5039 #endif
5040         if (adapter_le_get_scan_filter_size() == 0)
5041 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5042                 return btd_error_not_supported(msg);
5043 #else
5044                 ctlr_filter_support = FALSE;
5045 #endif
5046
5047         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5048                                                 DBUS_TYPE_BOOLEAN, &enable,
5049                                                 DBUS_TYPE_INVALID))
5050                 return btd_error_invalid_args(msg);
5051
5052 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5053         if (ctlr_filter_support)
5054 #endif
5055         err = adapter_le_enable_scan_filtering(enable);
5056 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5057         else
5058                 err = adapter_le_enable_platform_scan_filtering(adapter, enable);
5059 #endif
5060
5061         if (!err)
5062                 return btd_error_failed(msg, "Failed to enable scan filtering");
5063
5064         return dbus_message_new_method_return(msg);
5065 }
5066
5067 static DBusMessage *adapter_le_set_scan_params(DBusConnection *conn,
5068                                                 DBusMessage *msg, void *data)
5069 {
5070         struct btd_adapter *adapter = data;
5071         struct mgmt_cp_le_set_scan_params cp;
5072         uint32_t type;
5073         uint32_t interval;
5074         uint32_t window;
5075
5076         DBG("Set scan parameters");
5077
5078         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5079                 return btd_error_not_ready(msg);
5080
5081         if (!dbus_message_get_args(msg, NULL,
5082                                 DBUS_TYPE_UINT32, &type,
5083                                 DBUS_TYPE_UINT32, &interval,
5084                                 DBUS_TYPE_UINT32, &window,
5085                                 DBUS_TYPE_INVALID))
5086                 return btd_error_invalid_args(msg);
5087
5088         DBG("scan type %x, interval %x, window %x",
5089                                 type, interval, window);
5090         memset(&cp, 0, sizeof(cp));
5091
5092         cp.type = type;
5093         cp.interval = interval;
5094         cp.window = window;
5095         adapter->scan_type = type;
5096
5097         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_SCAN_PARAMS,
5098                                         adapter->dev_id, sizeof(cp), &cp,
5099                                         NULL, NULL, NULL) > 0)
5100                 return dbus_message_new_method_return(msg);
5101
5102         return btd_error_failed(msg, "set scan parameters failed");
5103 }
5104
5105 static DBusMessage *adapter_set_scan_rsp_data(DBusConnection *conn,
5106                                                 DBusMessage *msg, void *data)
5107 {
5108         struct btd_adapter *adapter = data;
5109         struct mgmt_cp_set_scan_rsp_data cp;
5110         uint8_t *value;
5111         int32_t len = 0;
5112         dbus_int32_t slot_id;
5113         uint8_t *adv_data = NULL;
5114         int adv_len = 0;
5115
5116         char *adapter_name = adapter->name;
5117         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
5118
5119         DBG("Set scan response data");
5120
5121         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5122                 return btd_error_not_ready(msg);
5123
5124         if (!dbus_message_get_args(msg, NULL,
5125                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
5126                         DBUS_TYPE_INT32, &slot_id,
5127                         DBUS_TYPE_INVALID))
5128                 return btd_error_invalid_args(msg);
5129
5130         if (len > SCAN_RESPONSE_DATA_LENGTH_MAX)
5131                 return btd_error_invalid_args(msg);
5132
5133         if (adapter->le_static_addr.b[5] != 0) {
5134                 char *ptr = NULL;
5135
5136                 g_strlcpy(le_name, adapter_name,
5137                                 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
5138                 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
5139                         *ptr = '\0';
5140
5141                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
5142                 adapter_name = le_name;
5143         }
5144
5145         adapter_le_set_missed_adv_data(value, len, TRUE,
5146                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
5147
5148         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
5149                 if (adapter_le_set_multi_adv_data(slot_id, TRUE, adv_len, (uint8_t *)adv_data)) {
5150                         g_free(adv_data);
5151                         return dbus_message_new_method_return(msg);
5152                 } else {
5153                         g_free(adv_data);
5154                         return btd_error_failed(msg, "set advertising data failed");
5155                 }
5156         } else {
5157                 memcpy(&cp, adv_data, adv_len);
5158
5159                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_SCAN_RSP_DATA,
5160                                                 adapter->dev_id, adv_len, &cp,
5161                                                 NULL, NULL, NULL) > 0) {
5162                         g_free(adv_data);
5163                         return dbus_message_new_method_return(msg);
5164                 }
5165
5166                 g_free(adv_data);
5167                 return btd_error_failed(msg, "set scan reponse data failed");
5168         }
5169 }
5170
5171 static DBusMessage *adapter_add_device_white_list(DBusConnection *conn,
5172                                         DBusMessage *msg, void *data)
5173 {
5174         struct btd_adapter *adapter = data;
5175         struct mgmt_cp_add_dev_white_list cp;
5176         const gchar *address;
5177         bdaddr_t bdaddr;
5178         dbus_uint32_t address_type;
5179         struct btd_device *dev;
5180
5181         DBG("Add device whie list");
5182         if (dbus_message_get_args(msg, NULL,
5183                                         DBUS_TYPE_STRING, &address,
5184                                         DBUS_TYPE_UINT32, &address_type,
5185                                         DBUS_TYPE_INVALID) == FALSE)
5186                 return btd_error_invalid_args(msg);
5187
5188         if (bachk(address) < 0)
5189                 return btd_error_invalid_args(msg);
5190
5191         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5192                 return btd_error_not_ready(msg);
5193
5194         DBG("addr %s, type %d", address, address_type);
5195         str2ba(address, &bdaddr);
5196
5197         dev = btd_adapter_find_device(adapter, &bdaddr,
5198                         address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5199         if (dev && device_get_rpa_exist(dev) == true) {
5200                 if (adapter_le_is_supported_offloading() == FALSE) {
5201                         error("Spec based command is not supported yet");
5202                         return btd_error_not_supported(msg);
5203                 }
5204
5205                 /* Add IRK value to list */
5206                 if (adapter_le_add_irk_to_list(device_get_irk_value(dev),
5207                                         device_get_address(dev),
5208                                         btd_device_get_bdaddr_type(dev))) {
5209                         return dbus_message_new_method_return(msg);
5210                 } else {
5211                         return btd_error_failed(msg, "Add LE IRK to list failed");
5212                 }
5213         }
5214
5215         memset(&cp, 0, sizeof(cp));
5216
5217         cp.bdaddr_type = address_type;
5218         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5219
5220         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEV_WHITE_LIST,
5221                                         adapter->dev_id, sizeof(cp), &cp,
5222                                         NULL, NULL, NULL) > 0)
5223                 return dbus_message_new_method_return(msg);
5224
5225         return btd_error_failed(msg, "add device white list failed");
5226 }
5227
5228 static DBusMessage *adapter_remove_device_white_list(DBusConnection *conn,
5229                                         DBusMessage *msg, void *data)
5230 {
5231         struct btd_adapter *adapter = data;
5232         struct mgmt_cp_remove_dev_white_list cp;
5233         const gchar *address;
5234         bdaddr_t bdaddr;
5235         dbus_uint32_t address_type;
5236         struct btd_device *dev;
5237
5238         DBG("Remove device whie list");
5239
5240         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5241                 return btd_error_not_ready(msg);
5242
5243         if (dbus_message_get_args(msg, NULL,
5244                                         DBUS_TYPE_STRING, &address,
5245                                         DBUS_TYPE_UINT32, &address_type,
5246                                         DBUS_TYPE_INVALID) == FALSE)
5247                 return btd_error_invalid_args(msg);
5248
5249         if (bachk(address) < 0)
5250                 return btd_error_invalid_args(msg);
5251
5252         DBG("addr %s, type %d", address, address_type);
5253         str2ba(address, &bdaddr);
5254
5255         dev = btd_adapter_find_device(adapter, &bdaddr,
5256                         address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5257         if (dev && device_get_rpa_exist(dev) == true) {
5258                 if (adapter_le_is_supported_offloading() == FALSE) {
5259                         error("Spec based command is not supported yet");
5260                         return btd_error_not_supported(msg);
5261                 }
5262
5263                 /* Remove IRK value to list */
5264                 if (adapter_le_remove_irk_to_list(device_get_address(dev),
5265                                         btd_device_get_bdaddr_type(dev))) {
5266                         return dbus_message_new_method_return(msg);
5267                 } else {
5268                         return btd_error_failed(msg, "Remove IRK is failed");
5269                 }
5270         }
5271
5272         memset(&cp, 0, sizeof(cp));
5273
5274         cp.bdaddr_type = address_type;
5275         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5276
5277         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEV_FROM_WHITE_LIST,
5278                                         adapter->dev_id, sizeof(cp), &cp,
5279                                         NULL, NULL, NULL) > 0)
5280                 return dbus_message_new_method_return(msg);
5281
5282         return btd_error_failed(msg, "remove device white list failed");
5283 }
5284
5285 static DBusMessage *adapter_clear_device_white_list(DBusConnection *conn,
5286                                         DBusMessage *msg, void *data)
5287 {
5288         struct btd_adapter *adapter = data;
5289
5290         DBG("Clear device whie list");
5291
5292         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5293                 return btd_error_not_ready(msg);
5294
5295         if (mgmt_send(adapter->mgmt, MGMT_OP_CLEAR_DEV_WHITE_LIST,
5296                                         adapter->dev_id, 0, NULL,
5297                                         NULL, NULL, NULL) > 0)
5298                 return dbus_message_new_method_return(msg);
5299
5300         return btd_error_failed(msg, "clear white list failed");
5301 }
5302
5303 static DBusMessage *adapter_set_le_privacy(DBusConnection *conn,
5304                                         DBusMessage *msg, void *data)
5305 {
5306         struct btd_adapter *adapter = data;
5307         dbus_bool_t err;
5308         dbus_bool_t enable_privacy = FALSE;
5309
5310         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
5311                 return btd_error_not_supported(msg);
5312
5313         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
5314                                 &enable_privacy, DBUS_TYPE_INVALID))
5315                 return btd_error_invalid_args(msg);
5316
5317         if (enable_privacy) {
5318                 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
5319                         return btd_error_already_exists(msg);
5320         } else {
5321                 if (!(adapter->current_settings & MGMT_SETTING_PRIVACY))
5322                         return btd_error_already_exists(msg);
5323         }
5324
5325         err = set_privacy(adapter, enable_privacy);
5326
5327         if (!err) {
5328                 return btd_error_failed(msg, "Set Le Privacy failed");
5329         } else {
5330                 if (enable_privacy)
5331                         adapter->current_settings = adapter->current_settings | MGMT_SETTING_PRIVACY;
5332                 else
5333                         adapter->current_settings = adapter->current_settings & ~(SETTING_PRIVACY_MASK);
5334         }
5335
5336         return dbus_message_new_method_return(msg);
5337 }
5338
5339 static void init_le_static_address(struct btd_adapter *adapter)
5340 {
5341         int fd;
5342         int ret;
5343         char address[18];
5344         char dirname[PATH_MAX];
5345         int i;
5346         bdaddr_t le_static_addr;
5347
5348         le_static_addr.b[5] = adapter->bdaddr.b[5] | 0xc0;
5349         for (i = 0; i < 5; i++) {
5350                 le_static_addr.b[i] =
5351                         (adapter->bdaddr.b[i] & 0x7f) << 1 |
5352                         (adapter->bdaddr.b[i] & 0x80) >> 7;
5353         }
5354
5355         /*
5356          * < How to get Public address from above static address >
5357          *
5358          * for (i = 0; i < 5; i++) {
5359          *      bredr_addr.b[i] =
5360          *              (adapter->le_static_addr.b[i] & 0xfe) >> 1 |
5361          *              (adapter->le_static_addr.b[i] & 0x01) << 7;
5362          * }
5363          * bredr_addr.b[5] = {the value from advertising data}
5364          */
5365
5366         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5367         fd = open(dirname, O_WRONLY | O_CREAT, 0644);
5368
5369         if (fd >= 0) {
5370                 ba2str(&le_static_addr, address);
5371                 DBG("LE static random : %s", address);
5372                 ret = write(fd, address, strlen(address));
5373                 if (ret < 0) {
5374                         error("Cannot save LE address : %s",
5375                                         strerror(errno));
5376                 }
5377
5378                 ret = fdatasync(fd);
5379                 if (ret < 0)
5380                         error("sync failed : %s", strerror(errno));
5381
5382                 close(fd);
5383         } else {
5384                 error("Cannot save LE address");
5385         }
5386 }
5387
5388 static void set_le_static_address(struct btd_adapter *adapter)
5389 {
5390         int fd;
5391         int ret;
5392         char address[18];
5393         char dirname[PATH_MAX];
5394
5395         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5396         if (access(dirname, F_OK) < 0)
5397                 init_le_static_address(adapter);
5398
5399         fd = open(dirname, O_RDONLY);
5400         if (fd >= 0) {
5401                 ret = read(fd, address, sizeof(address));
5402                 if (ret >= 17) {
5403                         /* xx:xx:xx:xx:xx:xx */
5404                         address[17] = '\0';
5405                         DBG("LE static random : %s", address);
5406                         str2ba(address, &adapter->le_static_addr);
5407                         adapter->le_static_addr.b[5] |= 0xc0;
5408                 } else
5409                         error("Invalid LE address");
5410                 close(fd);
5411         } else {
5412                 error("Cannot get LE address");
5413         }
5414
5415         return;
5416 }
5417
5418 static void set_le_static_address_complete(uint8_t status, uint16_t length,
5419                                         const void *param, void *user_data)
5420 {
5421         struct btd_adapter *adapter = user_data;
5422
5423         DBG("index %u status 0x%02x", adapter->dev_id, status);
5424
5425         if (status != MGMT_STATUS_SUCCESS) {
5426                 error("Failed to set static address for index %u: %s (0x%02x)",
5427                                 adapter->dev_id, mgmt_errstr(status), status);
5428                 if (adapter->le_static_addr.b[5] != 0)
5429                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5430                 else
5431                         set_le_static_address(adapter);
5432                 return;
5433         }
5434
5435         return;
5436 }
5437
5438 static DBusMessage *adapter_set_le_static_address(DBusConnection *conn,
5439                                         DBusMessage *msg, void *data)
5440 {
5441         struct btd_adapter *adapter = data;
5442         dbus_bool_t is_enable = FALSE;
5443         struct mgmt_cp_set_static_address cp;
5444
5445         if (!(adapter->supported_settings & MGMT_OP_SET_STATIC_ADDRESS)) {
5446                 error("LE static address is not supported");
5447                 return btd_error_not_supported(msg);
5448         }
5449
5450         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &is_enable,
5451                                 DBUS_TYPE_INVALID)) {
5452                 error("Invalid arguments");
5453                 return btd_error_invalid_args(msg);
5454         }
5455
5456         memset(&cp, 0x00, sizeof(cp));
5457         if (is_enable)  {
5458                 if (adapter->le_static_addr.b[5] != 0) {
5459                         DBG("LE static address is already configured");
5460                         return dbus_message_new_method_return(msg);
5461                 }
5462                 set_le_static_address(adapter);
5463                 bacpy(&cp.bdaddr, &adapter->le_static_addr);
5464         } else {
5465                 if (adapter->le_static_addr.b[5] == 0) {
5466                         DBG("LE static address is not configured");
5467                         return dbus_message_new_method_return(msg);
5468                 }
5469                 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5470         }
5471         DBG("Set static random address : %d", is_enable);
5472
5473         if (mgmt_send(mgmt_primary, MGMT_OP_SET_STATIC_ADDRESS, adapter->dev_id,
5474                         sizeof(cp), &cp,
5475                         set_le_static_address_complete, adapter, NULL) <= 0) {
5476                 error("Failed to set static address : %d", is_enable);
5477                 if (is_enable)
5478                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5479                 else
5480                         set_le_static_address(adapter);
5481                 return btd_error_failed(msg, "Unable to set static address");
5482         }
5483
5484         return dbus_message_new_method_return(msg);
5485 }
5486
5487 static DBusMessage *adapter_enable_rssi(DBusConnection *conn,
5488                                                 DBusMessage *msg, void *data)
5489 {
5490         struct btd_adapter *adapter = data;
5491         struct mgmt_cp_set_enable_rssi cp;
5492         struct mgmt_cp_disable_rssi cp_dis;
5493         bdaddr_t bt_addr = { { 0, } };
5494         const gchar *address = NULL;
5495
5496         const char *sender = dbus_message_get_sender(msg);
5497         dbus_int32_t link_type;
5498         dbus_int32_t low_threshold;
5499         dbus_int32_t in_range_threshold;
5500         dbus_int32_t high_threshold;
5501
5502         DBG("Enable RSSI called");
5503         DBG("sender %s", sender);
5504         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5505                 return btd_error_not_ready(msg);
5506
5507         if (!dbus_message_get_args(msg, NULL,
5508                                 DBUS_TYPE_STRING, &address,
5509                                 DBUS_TYPE_INT32, &link_type,
5510                                 DBUS_TYPE_INT32, &low_threshold,
5511                                 DBUS_TYPE_INT32, &in_range_threshold,
5512                                 DBUS_TYPE_INT32, &high_threshold,
5513                                 DBUS_TYPE_INVALID))
5514                 return btd_error_invalid_args(msg);
5515
5516         DBG("Enable RSSI: [%s %d %d %d %d]", address, link_type,
5517                         low_threshold, in_range_threshold, high_threshold);
5518
5519         DBG("BT address [%s]", address);
5520         memset(&bt_addr, 0, sizeof(bdaddr_t));
5521         str2ba(address, &bt_addr);
5522         memset(&cp, 0, sizeof(struct mgmt_cp_set_enable_rssi));
5523         memset(&cp_dis, 0, sizeof(struct mgmt_cp_disable_rssi));
5524
5525         if (bachk(address) < 0)
5526                 return btd_error_invalid_args(msg);
5527
5528 //      if (!btd_adapter_find_device(adapter, address))
5529 //              return btd_error_not_found(msg);
5530
5531         if (low_threshold == 0 && in_range_threshold == 0 && high_threshold == 0) {
5532                 cp_dis.bdaddr = bt_addr;
5533                 cp_dis.link_type = link_type;
5534                 DBG("Disable Request");
5535                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_DISABLE,
5536                                         adapter->dev_id, sizeof(cp_dis), &cp_dis,
5537                                         NULL, NULL, NULL) > 0)
5538                                         return dbus_message_new_method_return(msg);
5539         } else {
5540                 cp.low_th = low_threshold;
5541                 cp.in_range_th = in_range_threshold;
5542                 cp.high_th = high_threshold;
5543                 cp.bdaddr = bt_addr;
5544                 cp.link_type = link_type;
5545                 DBG("Enable Request");
5546                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_ENABLE,
5547                                         adapter->dev_id, sizeof(cp), &cp,
5548                                         NULL, NULL, NULL) > 0)
5549                         return dbus_message_new_method_return(msg);
5550         }
5551         return btd_error_failed(msg, "Enable/Disable RSSI Failed");
5552 }
5553
5554 static DBusMessage *adapter_get_rssi(DBusConnection *conn,
5555                                                 DBusMessage *msg, void *data)
5556 {
5557         struct btd_adapter *adapter = data;
5558         struct mgmt_cp_get_raw_rssi cp;
5559         bdaddr_t bt_addr;
5560         const gchar *address = NULL;
5561         dbus_int32_t link_type;
5562         const char *sender = dbus_message_get_sender(msg);
5563
5564         DBG("Get RSSI called");
5565         DBG("sender %s", sender);
5566         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5567                 return btd_error_not_ready(msg);
5568
5569         if (!dbus_message_get_args(msg, NULL,
5570                                 DBUS_TYPE_STRING, &address,
5571                                 DBUS_TYPE_INT32, &link_type,
5572                                 DBUS_TYPE_INVALID))
5573                 return btd_error_invalid_args(msg);
5574
5575         DBG("BT address [%s] link type [%d]", address, link_type);
5576         memset(&bt_addr, 0, sizeof(bdaddr_t));
5577         str2ba(address, &bt_addr);
5578         memset(&cp, 0, sizeof(struct mgmt_cp_get_raw_rssi));
5579
5580         if (bachk(address) < 0)
5581                 return btd_error_invalid_args(msg);
5582
5583 //      if (!btd_adapter_find_device(adapter, address))
5584 //              return btd_error_not_found(msg);
5585
5586         memcpy(&(cp.bt_address), &bt_addr, sizeof(bdaddr_t));
5587         cp.link_type = link_type;
5588         DBG("RAW RSSI Request");
5589         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_RAW_RSSI,
5590                                         adapter->dev_id, sizeof(cp), &cp,
5591                                         NULL, NULL, NULL) > 0)
5592                         return dbus_message_new_method_return(msg);
5593
5594         return btd_error_failed(msg, "Get Raw RSSI Failed");
5595 }
5596
5597 #if !defined(__SPRD_PATCH__)
5598 static void get_adv_tx_power_complete(uint8_t status, uint16_t length,
5599                                         const void *param, void *user_data)
5600 {
5601         struct btd_adapter *adapter = user_data;
5602         const struct mgmt_rp_get_adv_tx_power *rp = param;
5603
5604         if (!rp) {
5605                 error("Error ocurred in Getting adv tx power, rp is NULL");
5606                 return;
5607         }
5608
5609         if (status != MGMT_STATUS_SUCCESS) {
5610                 error("Failed to get adv tx power: %s (0x%02x)",
5611                                                 mgmt_errstr(status), status);
5612                 return;
5613         }
5614
5615         if (length < sizeof(*rp)) {
5616                 error("Wrong size of get adv tx power");
5617                 return;
5618         }
5619
5620         adapter->adv_tx_power = rp->adv_tx_power;
5621         return;
5622 }
5623
5624 static  void adapter_get_adv_tx_power(void *data)
5625 {
5626         struct btd_adapter *adapter = data;
5627
5628         mgmt_send(adapter->mgmt, MGMT_OP_GET_ADV_TX_POWER,
5629                                         adapter->dev_id, 0, NULL,
5630                                         get_adv_tx_power_complete, adapter, NULL);
5631         return;
5632 }
5633 #endif
5634
5635 static DBusMessage *set_wbs_parameters(DBusConnection *conn,
5636                                 DBusMessage *msg, void *data)
5637 {
5638         struct btd_adapter *adapter = data;
5639         const gchar *role = NULL;
5640         const gchar *address = NULL;
5641         struct mgmt_cp_set_voice_setting cp;
5642         bdaddr_t bt_addr = { { 0, } };
5643
5644         DBG("+");
5645
5646         if (!dbus_message_get_args(msg, NULL,
5647                                 DBUS_TYPE_STRING, &role,
5648                                 DBUS_TYPE_STRING, &address,
5649                                 DBUS_TYPE_INVALID)) {
5650                 return btd_error_invalid_args(msg);
5651         }
5652
5653         DBG("Role = %s", role);
5654         DBG("Address = %s", address);
5655
5656         memset(&cp, 0, sizeof(cp));
5657
5658         cp.voice_setting = BT_VOICE_TRANSPARENT | BT_VOICE_CVSD_16BIT;
5659
5660         if (g_strcmp0(role, "Handsfree") == 0)
5661                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5662         else if (g_strcmp0(role, "Gateway") == 0)
5663                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5664
5665         str2ba(address, &bt_addr);
5666         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5667
5668         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5669                                 adapter->dev_id, sizeof(cp), &cp,
5670                                 NULL, NULL, NULL) == 0)
5671                 error("mgmt_send failed for voice setting");
5672
5673         DBG("-");
5674         return dbus_message_new_method_return(msg);
5675 }
5676
5677 static DBusMessage *set_nb_parameters(DBusConnection *conn,
5678                                 DBusMessage *msg, void *data)
5679 {
5680         struct btd_adapter *adapter = data;
5681         const gchar *role;
5682         const gchar *address = NULL;
5683         struct mgmt_cp_set_voice_setting cp;
5684         bdaddr_t bt_addr = { { 0, } };
5685
5686         DBG("+");
5687
5688         if (!dbus_message_get_args(msg, NULL,
5689                                 DBUS_TYPE_STRING, &role,
5690                                 DBUS_TYPE_STRING, &address,
5691                                 DBUS_TYPE_INVALID)) {
5692                 return btd_error_invalid_args(msg);
5693         }
5694
5695         DBG("Role = %s", role);
5696         DBG("Address = %s", address);
5697
5698         memset(&cp, 0, sizeof(cp));
5699
5700         cp.voice_setting = BT_VOICE_CVSD_16BIT;
5701
5702         if (g_strcmp0(role, "Handsfree") == 0)
5703                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5704         else if (g_strcmp0(role, "Gateway") == 0)
5705                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5706
5707         str2ba(address, &bt_addr);
5708         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5709
5710         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5711                                 adapter->dev_id, sizeof(cp), &cp,
5712                                 NULL, NULL, NULL) == 0)
5713                 error("mgmt_send failed for voice setting");
5714
5715         DBG("-");
5716
5717         return dbus_message_new_method_return(msg);
5718 }
5719
5720 void btd_adapter_set_read_le_data_length_handler(
5721                         struct btd_adapter *adapter,
5722                         struct le_data_length_read_handler *handler)
5723 {
5724         adapter->read_handler = handler;
5725 }
5726
5727 static void le_read_maximum_data_length_return_param_complete(
5728                         uint8_t status, uint16_t length,
5729                         const void *param, void *user_data)
5730 {
5731         struct btd_adapter *adapter = user_data;
5732         const struct mgmt_rp_le_read_maximum_data_length *rp = param;
5733         uint16_t max_tx_octects = 0;
5734         uint16_t max_tx_time = 0;
5735         uint16_t max_rx_octects = 0;
5736         uint16_t max_rx_time = 0;
5737         int err = 0;
5738
5739         if (!rp) {
5740                 error("Error ocurred in Reading maximum data length, rp is NULL");
5741                 err = -EIO;
5742                 goto done;
5743         }
5744
5745         if (status != MGMT_STATUS_SUCCESS) {
5746                 error("le read maximum data length failed: %s (0x%02x)",
5747                         mgmt_errstr(status), status);
5748                 err = -EIO;
5749                 goto done;
5750         }
5751
5752         if (length < sizeof(*rp)) {
5753                 error("Too small le read maximum data length response");
5754                 err = -EIO;
5755                 goto done;
5756         } else {
5757                 max_tx_octects = rp->max_tx_octets;
5758                 max_tx_time =rp->max_tx_time;
5759                 max_rx_octects = rp->max_rx_octets;
5760                 max_rx_time = rp->max_rx_time;
5761         }
5762
5763 done:
5764         if (!adapter->read_handler ||
5765                 !adapter->read_handler->read_callback) {
5766                 g_free(adapter->read_handler);
5767                 return;
5768         }
5769
5770         adapter->read_handler->read_callback(adapter, err,
5771                         max_tx_octects, max_tx_time,
5772                         max_rx_octects, max_rx_time,
5773                         adapter->read_handler->user_data);
5774
5775         g_free(adapter->read_handler);
5776         adapter->read_handler = NULL;
5777 }
5778
5779 int btd_adapter_le_read_maximum_data_length(
5780         struct btd_adapter *adapter)
5781 {
5782         if (mgmt_send(adapter->mgmt,
5783                          MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
5784                          adapter->dev_id, 0, NULL,
5785                          le_read_maximum_data_length_return_param_complete,
5786                          adapter, NULL) > 0)
5787                 return 0;
5788
5789         return -EIO;
5790 }
5791
5792 static gint read_request_cmp(gconstpointer a, gconstpointer b)
5793 {
5794         const struct le_data_length_read_request *data = a;
5795         const struct btd_adapter *adapter = b;
5796
5797         return data->adapter !=  adapter;
5798 }
5799
5800 static struct le_data_length_read_request *find_read_le_data_length_request(
5801         struct btd_adapter *adapter)
5802 {
5803         GSList *match;
5804
5805         match = g_slist_find_custom(read_requests, adapter, read_request_cmp);
5806
5807         if (match)
5808                 return match->data;
5809
5810         return NULL;
5811 }
5812
5813 static void le_read_data_length_complete(
5814                         struct btd_adapter *adapter,
5815                         int err,
5816                         uint16_t max_tx_octects, uint16_t max_tx_time,
5817                         uint16_t max_rx_octects, uint16_t max_rx_time,
5818                         void *user_data)
5819 {
5820         DBusMessage *reply;
5821         struct le_data_length_read_request *read_request;
5822
5823         read_request = find_read_le_data_length_request(adapter);
5824
5825         if (!read_request)
5826                 return;
5827
5828         if (err) {
5829                 DBG("Failed to read max data length. errno[%d]", err);
5830                 reply = btd_error_failed(read_request->msg,
5831                                         "Failed to read max data length");
5832         } else {
5833                 reply = g_dbus_create_reply(read_request->msg,
5834                                         DBUS_TYPE_UINT16, &max_tx_octects,
5835                                         DBUS_TYPE_UINT16, &max_tx_time,
5836                                         DBUS_TYPE_UINT16, &max_rx_octects,
5837                                         DBUS_TYPE_UINT16, &max_rx_time,
5838                                         DBUS_TYPE_INVALID);
5839
5840                 if (!reply) {
5841                         reply = btd_error_failed(read_request->msg,
5842                                                 "Failed to create reply.");
5843                 }
5844         }
5845
5846         read_requests = g_slist_remove(read_requests, read_request);
5847         dbus_message_unref(read_request->msg);
5848         g_free(read_request);
5849
5850         if (!g_dbus_send_message(dbus_conn, reply))
5851                 error("D-Bus send failed");
5852 }
5853
5854 static DBusMessage *le_read_maximum_data_length(
5855                         DBusConnection *conn, DBusMessage *msg,
5856                         void *user_data)
5857 {
5858         struct btd_adapter *adapter = user_data;
5859         struct le_data_length_read_request *read_request;
5860         struct le_data_length_read_handler *handler;
5861
5862         if (find_read_le_data_length_request(adapter))
5863                 return btd_error_in_progress(msg);
5864
5865         if (btd_adapter_le_read_maximum_data_length(adapter))
5866                 return btd_error_failed(msg, "Unable to read maximum le data length");
5867
5868         read_request = g_new(struct le_data_length_read_request, 1);
5869
5870         read_request->msg = dbus_message_ref(msg);
5871         read_request->adapter = adapter;
5872
5873         read_requests = g_slist_append(read_requests, read_request);
5874
5875         handler = g_new0(struct le_data_length_read_handler, 1);
5876
5877         handler->read_callback =
5878                 (read_max_data_length_cb_t)le_read_data_length_complete;
5879
5880         btd_adapter_set_read_le_data_length_handler(
5881                         read_request->adapter, handler);
5882
5883         return NULL;
5884
5885 }
5886
5887 void le_write_host_suggested_data_length_return_param_complete(
5888                         uint8_t status, uint16_t length,
5889                         const void *param, void *user_data)
5890 {
5891         if (status != MGMT_STATUS_SUCCESS) {
5892                 error("le write host suggested data length failed: %s (0x%02x)",
5893                         mgmt_errstr(status), status);
5894         }
5895
5896         return;
5897 }
5898
5899 static DBusMessage *le_write_host_suggested_default_data_length(
5900                         DBusConnection *conn, DBusMessage *msg,
5901                         void *user_data)
5902 {
5903         struct btd_adapter *adapter = user_data;
5904         struct mgmt_cp_le_write_host_suggested_data_length cp;
5905         dbus_uint16_t def_tx_Octets;
5906         dbus_uint16_t def_tx_time;
5907
5908         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5909                 return btd_error_not_ready(msg);
5910
5911         if (!dbus_message_get_args(msg, NULL,
5912                                         DBUS_TYPE_UINT16, &def_tx_Octets,
5913                                         DBUS_TYPE_UINT16, &def_tx_time,
5914                                         DBUS_TYPE_INVALID))
5915                 return btd_error_invalid_args(msg);
5916
5917         memset(&cp, 0, sizeof(cp));
5918         cp.def_tx_octets = def_tx_Octets;
5919         cp.def_tx_time = def_tx_time;
5920
5921         if (mgmt_send(adapter->mgmt,
5922                          MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
5923                          adapter->dev_id, sizeof(cp), &cp,
5924                          le_write_host_suggested_data_length_return_param_complete,
5925                          adapter, NULL) > 0)
5926                 return dbus_message_new_method_return(msg);
5927
5928         return btd_error_failed(msg, "Unable to write host suggested le data length values");
5929 }
5930
5931 static void le_read_suggested_default_data_length_return_param_complete(
5932                         uint8_t status, uint16_t length,
5933                         const void *param, void *user_data)
5934 {
5935         struct btd_adapter *adapter = user_data;
5936         const struct mgmt_rp_le_read_host_suggested_data_length *rp = param;
5937         uint16_t def_tx_octects, def_tx_time;
5938
5939         if (!rp) {
5940                 error("Error ocurred in Reading suggested data length, rp is NULL");
5941                 if (adapter->def_read_handler)
5942                         g_free(adapter->def_read_handler->user_data);
5943
5944                 g_free(adapter->def_read_handler);
5945                 return;
5946         }
5947
5948         if (status != MGMT_STATUS_SUCCESS) {
5949                 error("Read host suggested def le data length values failed: %s (0x%02x)",
5950                         mgmt_errstr(status), status);
5951                 def_tx_octects = 0;
5952                 def_tx_time =0;
5953
5954                 if (adapter->def_read_handler)
5955                         g_free(adapter->def_read_handler->user_data);
5956
5957                 g_free(adapter->def_read_handler);
5958                 return;
5959         }
5960
5961         if (length < sizeof(*rp)) {
5962                 goto done;
5963         } else {
5964                 def_tx_octects = rp->def_tx_octets;
5965                 def_tx_time =rp->def_tx_time;
5966                 DBG("retrieving host suggested data length values %d %d", def_tx_octects, def_tx_time);
5967         }
5968
5969         if (!adapter->def_read_handler)
5970                 return;
5971
5972         if(!adapter->def_read_handler->read_callback) {
5973                 goto done;
5974         }
5975
5976         adapter->def_read_handler->read_callback(adapter,
5977                         def_tx_octects, def_tx_time,
5978                         adapter->def_read_handler->user_data);
5979 done:
5980         if (adapter->def_read_handler)
5981                 g_free(adapter->def_read_handler->user_data);
5982
5983         g_free(adapter->def_read_handler);
5984         adapter->def_read_handler = NULL;
5985 }
5986
5987 int btd_adapter_le_read_suggested_default_data_length(
5988         struct btd_adapter *adapter)
5989 {
5990         if (mgmt_send(adapter->mgmt,
5991                          MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
5992                          adapter->dev_id, 0, NULL,
5993                          le_read_suggested_default_data_length_return_param_complete,
5994                          adapter, NULL) > 0) {
5995                 return 0;
5996         }
5997
5998         return -EIO;
5999 }
6000
6001 static void le_read_host_suggested_default_length_complete(
6002                         struct btd_adapter *adapter,
6003                         uint16_t def_tx_octects, uint16_t def_tx_time,
6004                         void *user_data)
6005 {
6006         DBusMessage *reply;
6007         struct le_data_length_read_request *read_request;
6008
6009         read_request = find_read_le_data_length_request(adapter);
6010         if (!read_request)
6011                 return;
6012
6013         reply = g_dbus_create_reply(read_request->msg,
6014                         DBUS_TYPE_UINT16, &def_tx_octects,
6015                         DBUS_TYPE_UINT16, &def_tx_time,
6016                         DBUS_TYPE_INVALID);
6017
6018         if (!reply) {
6019                 btd_error_failed(read_request->msg,
6020                         "Failed to read host suggested def data length values");
6021                 return;
6022         }
6023
6024         read_requests = g_slist_remove(read_requests, read_request);
6025         dbus_message_unref(read_request->msg);
6026         g_free(read_request);
6027
6028         if (!g_dbus_send_message(dbus_conn, reply))
6029                 error("D-Bus send failed");
6030 }
6031
6032 static DBusMessage *le_read_host_suggested_default_data_length(
6033                         DBusConnection *conn, DBusMessage *msg,
6034                         void *user_data)
6035 {
6036         struct btd_adapter *adapter = user_data;
6037         struct le_data_length_read_request *read_request;
6038         struct le_data_length_read_default_data_length_handler *handler;
6039
6040         if (find_read_le_data_length_request(adapter))
6041                 return btd_error_in_progress(msg);
6042
6043         if (btd_adapter_le_read_suggested_default_data_length(adapter))
6044                 return btd_error_failed(msg, "Unable to read host suggested def data length");
6045
6046         read_request = g_new(struct le_data_length_read_request, 1);
6047
6048         read_request->msg = dbus_message_ref(msg);
6049         read_request->adapter = adapter;
6050
6051         read_requests = g_slist_append(read_requests, read_request);
6052
6053         handler = g_new0(struct le_data_length_read_default_data_length_handler, 1);
6054
6055         handler->read_callback =
6056                 (read_host_suggested_default_data_length_cb_t)le_read_host_suggested_default_length_complete;
6057
6058         read_request->adapter->def_read_handler = handler;
6059
6060         return NULL;
6061 }
6062
6063 static void get_le_batching_available_pkts_complete(
6064                         uint8_t status, uint16_t length,
6065                         const void *param, void *user_data)
6066 {
6067         const struct mgmt_rp_get_le_batching_buffer *rp = param;
6068         struct le_batching_request *request =
6069                 (struct le_batching_request*)user_data;
6070         DBusMessage *reply;
6071
6072         if (status != MGMT_STATUS_SUCCESS) {
6073                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6074                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6075                         reply = btd_error_not_supported(request->msg);
6076                 else
6077                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6078                 goto done;
6079         }
6080
6081         if (length < sizeof(*rp)) {
6082                 reply = btd_error_failed(request->msg,
6083                         "Wrong size of get le batching buffer");
6084                 goto done;
6085         }
6086
6087         DBG("LE Batching buffer: [%u]", rp->buffer);
6088         request->adapter->le_batching_available_pkts = rp->buffer;
6089         reply = g_dbus_create_reply(request->msg,
6090                                 DBUS_TYPE_UINT32, &rp->buffer,
6091                                 DBUS_TYPE_INVALID);
6092         if (!reply)
6093                 reply = btd_error_failed(request->msg,
6094                                         "Failed to create reply.");
6095
6096 done:
6097         if (!g_dbus_send_message(dbus_conn, reply))
6098                 error("D-Bus send failed");
6099
6100         dbus_message_unref(request->msg);
6101         g_free(request);
6102 }
6103
6104 static DBusMessage *adapter_get_le_batching_available_pkts(DBusConnection *conn,
6105                                                 DBusMessage *msg, void *data)
6106 {
6107         struct btd_adapter *adapter = data;
6108         struct le_batching_request *request;
6109         DBusMessage *reply;
6110         dbus_uint32_t val;
6111
6112         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6113                 return btd_error_not_ready(msg);
6114
6115         if (adapter->le_batching_available_pkts < 0)
6116                 return btd_error_not_supported(msg);
6117
6118         if (adapter->le_batching_available_pkts > 0) {
6119                 reply = dbus_message_new_method_return(msg);
6120                 if (!reply)
6121                         return NULL;
6122
6123                 val = adapter->le_batching_available_pkts;
6124                 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &val,
6125                                                                 DBUS_TYPE_INVALID);
6126                 DBG("LE Batching buffer: [%u]", val);
6127                 return reply;
6128         }
6129
6130         request = g_new(struct le_batching_request, 1);
6131
6132         request->msg = dbus_message_ref(msg);
6133         request->adapter = adapter;
6134
6135         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_LE_BATCHING_BUFFER,
6136                                 adapter->dev_id, 0, NULL,
6137                                 get_le_batching_available_pkts_complete, request, NULL) == 0) {
6138                 dbus_message_unref(request->msg);
6139                 g_free(request);
6140                 return btd_error_failed(msg, "Unable to get le batching buffer");
6141         }
6142
6143         return NULL;
6144 }
6145
6146 static void set_le_batching_enable_complete(
6147                         uint8_t status, uint16_t length,
6148                         const void *param, void *user_data)
6149 {
6150         const struct mgmt_rp_set_le_batching_enable *rp = param;
6151         struct le_batching_request *request =
6152                 (struct le_batching_request*)user_data;
6153         DBusMessage *reply;
6154
6155         DBG("");
6156         if (status != MGMT_STATUS_SUCCESS) {
6157                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6158                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6159                         reply = btd_error_not_supported(request->msg);
6160                 else
6161                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6162                 goto done;
6163         }
6164
6165         if (length < sizeof(*rp)) {
6166                 reply = btd_error_failed(request->msg,
6167                         "Wrong size of set le batching enable");
6168                 goto done;
6169         }
6170
6171         reply = g_dbus_create_reply(request->msg,
6172                                 DBUS_TYPE_INVALID);
6173         if (!reply)
6174                 reply = btd_error_failed(request->msg,
6175                                         "Failed to create reply.");
6176
6177 done:
6178         if (!g_dbus_send_message(dbus_conn, reply))
6179                 error("D-Bus send failed");
6180
6181         dbus_message_unref(request->msg);
6182         g_free(request);
6183 }
6184
6185 static void set_le_batching_param_complete(
6186                         uint8_t status, uint16_t length,
6187                         const void *param, void *user_data)
6188 {
6189         const struct mgmt_rp_set_le_batching_param *rp = param;
6190         struct mgmt_cp_set_le_batching_enable cp;
6191         struct le_batching_set_param_request *request =
6192                 (struct le_batching_set_param_request*)user_data;
6193         DBusMessage *reply;
6194
6195         if (status != MGMT_STATUS_SUCCESS) {
6196                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6197                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6198                         reply = btd_error_not_supported(request->msg);
6199                 else
6200                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6201                 goto done;
6202         }
6203
6204         if (length < sizeof(*rp)) {
6205                 reply = btd_error_failed(request->msg,
6206                         "Wrong size of set le batching param");
6207                 goto done;
6208         }
6209
6210         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6211         cp.bdaddr = request->bdaddr;
6212         cp.enable = 1;
6213         if (mgmt_send(request->adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6214                         request->adapter->dev_id, sizeof(cp), &cp,
6215                         set_le_batching_enable_complete, request, NULL) == 0) {
6216                 reply = btd_error_failed(request->msg, "Unable to set le batching enable");
6217                 goto done;
6218         }
6219
6220         return;
6221 done:
6222         if (!g_dbus_send_message(dbus_conn, reply))
6223                 error("D-Bus send failed");
6224
6225         dbus_message_unref(request->msg);
6226         g_free(request);
6227 }
6228
6229 static DBusMessage *adapter_enable_le_batching(DBusConnection *conn,
6230                                                 DBusMessage *msg, void *data)
6231 {
6232         struct btd_adapter *adapter = data;
6233         struct mgmt_cp_set_le_batching_param cp;
6234         struct le_batching_set_param_request *request;
6235         bdaddr_t bt_addr = { { 0, } };
6236         const gchar *address = NULL;
6237         dbus_int32_t packet_threshold;
6238         dbus_int32_t timeout;
6239
6240         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6241                 return btd_error_not_ready(msg);
6242
6243         if (!dbus_message_get_args(msg, NULL,
6244                                 DBUS_TYPE_STRING, &address,
6245                                 DBUS_TYPE_INT32, &packet_threshold,
6246                                 DBUS_TYPE_INT32, &timeout,
6247                                 DBUS_TYPE_INVALID))
6248                 return btd_error_invalid_args(msg);
6249
6250         if (packet_threshold < 0 || packet_threshold > 0x7fff ||
6251                 timeout < 0 || timeout > 0x7fff)
6252                 return btd_error_invalid_args(msg);
6253
6254         DBG("Set LE batching param: [%s %d %d]", address,
6255                         packet_threshold, timeout);
6256
6257         memset(&bt_addr, 0, sizeof(bdaddr_t));
6258         str2ba(address, &bt_addr);
6259         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_param));
6260
6261         if (bachk(address) < 0)
6262                 return btd_error_invalid_args(msg);
6263
6264         cp.bdaddr = bt_addr;
6265         cp.pkt_th = packet_threshold;
6266         /* 1sec = 100 */
6267         cp.timeout = timeout * 100;
6268
6269         request = g_new(struct le_batching_set_param_request, 1);
6270         request->msg = dbus_message_ref(msg);
6271         request->adapter = adapter;
6272         request->bdaddr = bt_addr;
6273         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_PARAM,
6274                         adapter->dev_id, sizeof(cp), &cp,
6275                         set_le_batching_param_complete, request, NULL) == 0) {
6276                 dbus_message_unref(request->msg);
6277                 g_free(request);
6278                 return btd_error_failed(msg, "Unable to set le batching param");
6279         }
6280
6281         return NULL;
6282 }
6283
6284 static DBusMessage *adapter_disable_le_batching(DBusConnection *conn,
6285                                                 DBusMessage *msg, void *data)
6286 {
6287         struct btd_adapter *adapter = data;
6288         struct le_batching_request *request;
6289         struct mgmt_cp_set_le_batching_enable cp;
6290         bdaddr_t bt_addr = { { 0, } };
6291         const gchar *address = NULL;
6292
6293         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6294                 return btd_error_not_ready(msg);
6295
6296         if (!dbus_message_get_args(msg, NULL,
6297                                 DBUS_TYPE_STRING, &address,
6298                                 DBUS_TYPE_INVALID))
6299                 return btd_error_invalid_args(msg);
6300
6301         DBG("Disable LE Batching: [%s]", address);
6302
6303         memset(&bt_addr, 0, sizeof(bdaddr_t));
6304         str2ba(address, &bt_addr);
6305         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6306
6307         if (bachk(address) < 0)
6308                 return btd_error_invalid_args(msg);
6309
6310         cp.bdaddr = bt_addr;
6311         cp.enable = 0;
6312
6313         request = g_new(struct le_batching_request, 1);
6314         request->msg = dbus_message_ref(msg);
6315         request->adapter = adapter;
6316         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6317                         adapter->dev_id, sizeof(cp), &cp,
6318                         set_le_batching_enable_complete, request, NULL) == 0) {
6319                 dbus_message_unref(request->msg);
6320                 g_free(request);
6321                 return btd_error_failed(msg, "Unable to set le batching enable");
6322         }
6323
6324         return NULL;
6325 }
6326
6327 void le_set_data_length_return_param_complete(
6328                         uint8_t status, uint16_t length,
6329                         const void *param, void *user_data)
6330 {
6331         if (status != MGMT_STATUS_SUCCESS) {
6332                 error("le_set_data_length failed: %s (0x%02x)",
6333                         mgmt_errstr(status), status);
6334         }
6335
6336         return;
6337 }
6338
6339 int btd_adapter_le_set_data_length(struct btd_adapter *adapter, bdaddr_t *bdaddr,
6340                                 uint16_t max_tx_octets, uint16_t max_tx_time)
6341 {
6342         struct mgmt_cp_le_set_data_length cp;
6343
6344         memset(&cp, 0, sizeof(cp));
6345
6346         bacpy(&cp.bdaddr, bdaddr);
6347
6348         cp.max_tx_octets = max_tx_octets;
6349         cp.max_tx_time = max_tx_time;
6350
6351         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_DATA_LENGTH,
6352                         adapter->dev_id, sizeof(cp), &cp,
6353                         le_set_data_length_return_param_complete,
6354                         adapter, NULL) > 0)
6355                 return 0;
6356
6357         return -EIO;
6358 }
6359
6360 static DBusMessage *adapter_set_manufacturer_data(DBusConnection *conn,
6361                                                 DBusMessage *msg, void *data)
6362 {
6363         struct btd_adapter *adapter = data;
6364         struct mgmt_cp_set_manufacturer_data cp;
6365         uint8_t *value;
6366         int32_t len = 0;
6367
6368         DBG("Set manufacturer data");
6369
6370         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6371                 return btd_error_not_ready(msg);
6372
6373         if (!dbus_message_get_args(msg, NULL,
6374                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
6375                         DBUS_TYPE_INVALID))
6376                 return btd_error_invalid_args(msg);
6377
6378         if (len > EIR_MANUFACTURER_DATA_LENGTH_MAX)
6379                 return btd_error_invalid_args(msg);
6380
6381         memcpy(&cp, value, len);
6382
6383         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_MANUFACTURER_DATA,
6384                                         adapter->dev_id, EIR_MANUFACTURER_DATA_LENGTH_MAX,
6385                                         &cp, NULL, NULL, NULL) > 0)
6386                 return dbus_message_new_method_return(msg);
6387
6388         return btd_error_failed(msg, "Set manufacturer data failed");
6389 }
6390
6391 static DBusMessage *adapter_get_energy_info(DBusConnection *conn,
6392                                                 DBusMessage *msg, void *user_data)
6393 {
6394         DBusMessage *reply;
6395         uint32_t tx_time = 0;
6396         uint32_t rx_time = 0;
6397         uint32_t idle_time = 0;
6398         uint32_t energy_used = 0;
6399
6400         if (adapter_le_get_energy_info(&tx_time, &rx_time,
6401                                         &idle_time, &energy_used) == FALSE) {
6402                 error("Fail to send vcs for getting energy info");
6403                 reply = btd_error_not_supported(msg);
6404                 goto done;
6405         }
6406
6407         reply = g_dbus_create_reply(msg,
6408                                 DBUS_TYPE_UINT32, &tx_time,
6409                                 DBUS_TYPE_UINT32, &rx_time,
6410                                 DBUS_TYPE_UINT32, &idle_time,
6411                                 DBUS_TYPE_UINT32, &energy_used,
6412                                 DBUS_TYPE_INVALID);
6413
6414         if (!reply)
6415                 reply = btd_error_failed(msg,
6416                                         "Failed to create reply.");
6417
6418 done:
6419         return reply;
6420 }
6421
6422
6423 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
6424
6425 static DBusMessage *start_discovery(DBusConnection *conn,
6426                                         DBusMessage *msg, void *user_data)
6427 {
6428         struct btd_adapter *adapter = user_data;
6429         const char *sender = dbus_message_get_sender(msg);
6430         struct discovery_client *client;
6431         bool is_discovering;
6432         int err;
6433
6434         DBG("sender %s", sender);
6435
6436         if (!btd_adapter_get_powered(adapter))
6437                 return btd_error_not_ready(msg);
6438
6439         is_discovering = get_discovery_client(adapter, sender, &client);
6440
6441         /*
6442          * Every client can only start one discovery, if the client
6443          * already started a discovery then return an error.
6444          */
6445         if (is_discovering)
6446                 return btd_error_busy(msg);
6447
6448         /*
6449          * If there was pre-set filter, just reconnect it to discovery_list,
6450          * and trigger scan.
6451          */
6452         if (client) {
6453                 if (client->msg)
6454                         return btd_error_busy(msg);
6455
6456                 adapter->set_filter_list = g_slist_remove(
6457                                              adapter->set_filter_list, client);
6458                 adapter->discovery_list = g_slist_prepend(
6459                                               adapter->discovery_list, client);
6460
6461                 goto done;
6462         }
6463
6464         client = g_new0(struct discovery_client, 1);
6465
6466         client->adapter = adapter;
6467         client->owner = g_strdup(sender);
6468         client->discovery_filter = NULL;
6469         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6470                                                 discovery_disconnect, client,
6471                                                 NULL);
6472         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
6473                                                                 client);
6474
6475 done:
6476         /*
6477          * Just trigger the discovery here. In case an already running
6478          * discovery in idle phase exists, it will be restarted right
6479          * away.
6480          */
6481         err = update_discovery_filter(adapter);
6482         if (!err)
6483                 return dbus_message_new_method_return(msg);
6484
6485         /* If the discovery has to be started wait it complete to reply */
6486         if (err == -EINPROGRESS) {
6487                 client->msg = dbus_message_ref(msg);
6488 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
6489                 adapter->client = client;
6490 #endif
6491                 return NULL;
6492
6493         }
6494
6495         return btd_error_failed(msg, strerror(-err));
6496 }
6497
6498 static bool parse_uuids(DBusMessageIter *value, struct discovery_filter *filter)
6499 {
6500         DBusMessageIter arriter;
6501
6502         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_ARRAY)
6503                 return false;
6504
6505         dbus_message_iter_recurse(value, &arriter);
6506         while (dbus_message_iter_get_arg_type(&arriter) != DBUS_TYPE_INVALID) {
6507                 bt_uuid_t uuid, u128;
6508                 char uuidstr[MAX_LEN_UUID_STR + 1];
6509                 char *uuid_param;
6510
6511                 if (dbus_message_iter_get_arg_type(&arriter) !=
6512                                                 DBUS_TYPE_STRING)
6513                         return false;
6514
6515                 dbus_message_iter_get_basic(&arriter, &uuid_param);
6516
6517                 if (bt_string_to_uuid(&uuid, uuid_param))
6518                         return false;
6519
6520                 bt_uuid_to_uuid128(&uuid, &u128);
6521                 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
6522
6523                 filter->uuids = g_slist_prepend(filter->uuids, g_strdup(uuidstr));
6524
6525                 dbus_message_iter_next(&arriter);
6526         }
6527
6528         return true;
6529 }
6530
6531 static bool parse_rssi(DBusMessageIter *value, struct discovery_filter *filter)
6532 {
6533         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_INT16)
6534                 return false;
6535
6536         dbus_message_iter_get_basic(value, &filter->rssi);
6537         /* -127 <= RSSI <= +20 (spec V4.2 [Vol 2, Part E] 7.7.65.2) */
6538         if (filter->rssi > 20 || filter->rssi < -127)
6539                 return false;
6540
6541         return true;
6542 }
6543
6544 static bool parse_pathloss(DBusMessageIter *value,
6545                                 struct discovery_filter *filter)
6546 {
6547         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT16)
6548                 return false;
6549
6550         dbus_message_iter_get_basic(value, &filter->pathloss);
6551         /* pathloss filter must be smaller that PATHLOSS_MAX */
6552         if (filter->pathloss > PATHLOSS_MAX)
6553                 return false;
6554
6555         return true;
6556 }
6557
6558 static bool parse_transport(DBusMessageIter *value,
6559                                         struct discovery_filter *filter)
6560 {
6561         char *transport_str;
6562
6563         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6564                 return false;
6565
6566         dbus_message_iter_get_basic(value, &transport_str);
6567
6568         if (!strcmp(transport_str, "bredr"))
6569                 filter->type = SCAN_TYPE_BREDR;
6570         else if (!strcmp(transport_str, "le"))
6571                 filter->type = SCAN_TYPE_LE;
6572         else if (strcmp(transport_str, "auto"))
6573                 return false;
6574
6575         return true;
6576 }
6577
6578 static bool parse_duplicate_data(DBusMessageIter *value,
6579                                         struct discovery_filter *filter)
6580 {
6581         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6582                 return false;
6583
6584         dbus_message_iter_get_basic(value, &filter->duplicate);
6585
6586         return true;
6587 }
6588
6589 static bool parse_discoverable(DBusMessageIter *value,
6590                                         struct discovery_filter *filter)
6591 {
6592         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6593                 return false;
6594
6595         dbus_message_iter_get_basic(value, &filter->discoverable);
6596
6597         return true;
6598 }
6599
6600 static bool parse_pattern(DBusMessageIter *value,
6601                                         struct discovery_filter *filter)
6602 {
6603         const char *pattern;
6604
6605         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6606                 return false;
6607
6608         dbus_message_iter_get_basic(value, &pattern);
6609
6610         free(filter->pattern);
6611         filter->pattern = strdup(pattern);
6612
6613         return true;
6614 }
6615
6616 struct filter_parser {
6617         const char *name;
6618         bool (*func)(DBusMessageIter *iter, struct discovery_filter *filter);
6619 } parsers[] = {
6620         { "UUIDs", parse_uuids },
6621         { "RSSI", parse_rssi },
6622         { "Pathloss", parse_pathloss },
6623         { "Transport", parse_transport },
6624         { "DuplicateData", parse_duplicate_data },
6625         { "Discoverable", parse_discoverable },
6626         { "Pattern", parse_pattern },
6627         { }
6628 };
6629
6630 static bool parse_discovery_filter_entry(char *key, DBusMessageIter *value,
6631                                                 struct discovery_filter *filter)
6632 {
6633         struct filter_parser *parser;
6634
6635         for (parser = parsers; parser && parser->name; parser++) {
6636                 if (!strcmp(parser->name, key))
6637                         return parser->func(value, filter);
6638         }
6639
6640         DBG("Unknown key parameter: %s!\n", key);
6641         return false;
6642 }
6643
6644 /*
6645  * This method is responsible for parsing parameters to SetDiscoveryFilter. If
6646  * filter in msg was empty, sets *filter to NULL. If whole parsing was
6647  * successful, sets *filter to proper value.
6648  * Returns false on any error, and true on success.
6649  */
6650 static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
6651                                         struct discovery_filter **filter,
6652                                         DBusMessage *msg)
6653 {
6654         DBusMessageIter iter, subiter, dictiter, variantiter;
6655         bool is_empty = true;
6656
6657         *filter = g_try_malloc(sizeof(**filter));
6658         if (!*filter)
6659                 return false;
6660
6661         (*filter)->uuids = NULL;
6662         (*filter)->pathloss = DISTANCE_VAL_INVALID;
6663         (*filter)->rssi = DISTANCE_VAL_INVALID;
6664         (*filter)->type = get_scan_type(adapter);
6665         (*filter)->duplicate = false;
6666         (*filter)->discoverable = false;
6667         (*filter)->pattern = NULL;
6668
6669         dbus_message_iter_init(msg, &iter);
6670         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
6671             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
6672                 goto invalid_args;
6673
6674         dbus_message_iter_recurse(&iter, &subiter);
6675         do {
6676                 int type = dbus_message_iter_get_arg_type(&subiter);
6677                 char *key;
6678
6679                 if (type == DBUS_TYPE_INVALID)
6680                         break;
6681
6682                 is_empty = false;
6683                 dbus_message_iter_recurse(&subiter, &dictiter);
6684
6685                 dbus_message_iter_get_basic(&dictiter, &key);
6686                 if (!dbus_message_iter_next(&dictiter))
6687                         goto invalid_args;
6688
6689                 if (dbus_message_iter_get_arg_type(&dictiter) !=
6690                                                              DBUS_TYPE_VARIANT)
6691                         goto invalid_args;
6692
6693                 dbus_message_iter_recurse(&dictiter, &variantiter);
6694
6695                 if (!parse_discovery_filter_entry(key, &variantiter, *filter))
6696                         goto invalid_args;
6697
6698                 dbus_message_iter_next(&subiter);
6699         } while (true);
6700
6701         if (is_empty) {
6702                 g_free(*filter);
6703                 *filter = NULL;
6704                 return true;
6705         }
6706
6707         /* only pathlos or rssi can be set, never both */
6708         if ((*filter)->pathloss != DISTANCE_VAL_INVALID &&
6709             (*filter)->rssi != DISTANCE_VAL_INVALID)
6710                 goto invalid_args;
6711
6712         DBG("filtered discovery params: transport: %d rssi: %d pathloss: %d "
6713                 " duplicate data: %s discoverable %s pattern %s",
6714                 (*filter)->type, (*filter)->rssi, (*filter)->pathloss,
6715                 (*filter)->duplicate ? "true" : "false",
6716                 (*filter)->discoverable ? "true" : "false",
6717                 (*filter)->pattern);
6718
6719         return true;
6720
6721 invalid_args:
6722         g_slist_free_full((*filter)->uuids, g_free);
6723         g_free(*filter);
6724         *filter = NULL;
6725         return false;
6726 }
6727
6728 static DBusMessage *set_discovery_filter(DBusConnection *conn,
6729                                         DBusMessage *msg, void *user_data)
6730 {
6731         struct btd_adapter *adapter = user_data;
6732         struct discovery_client *client;
6733         struct discovery_filter *discovery_filter;
6734         const char *sender = dbus_message_get_sender(msg);
6735         bool is_discovering;
6736
6737         DBG("sender %s", sender);
6738
6739         if (!btd_adapter_get_powered(adapter))
6740                 return btd_error_not_ready(msg);
6741
6742         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 8))
6743                 return btd_error_not_supported(msg);
6744
6745         /* parse parameters */
6746         if (!parse_discovery_filter_dict(adapter, &discovery_filter, msg))
6747                 return btd_error_invalid_args(msg);
6748
6749         is_discovering = get_discovery_client(adapter, sender, &client);
6750
6751         if (client) {
6752                 free_discovery_filter(client->discovery_filter);
6753                 client->discovery_filter = discovery_filter;
6754
6755                 if (is_discovering)
6756                         update_discovery_filter(adapter);
6757
6758                 if (discovery_filter || is_discovering)
6759                         return dbus_message_new_method_return(msg);
6760
6761                 /* Removing pre-set filter */
6762                 adapter->set_filter_list = g_slist_remove(
6763                                               adapter->set_filter_list,
6764                                               client);
6765                 discovery_free(client);
6766                 DBG("successfully cleared pre-set filter");
6767         } else if (discovery_filter) {
6768                 /* Client pre-setting his filter for first time */
6769                 client = g_new0(struct discovery_client, 1);
6770                 client->adapter = adapter;
6771                 client->owner = g_strdup(sender);
6772                 client->discovery_filter = discovery_filter;
6773                 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6774                                                 discovery_disconnect, client,
6775                                                 NULL);
6776                 adapter->set_filter_list = g_slist_prepend(
6777                                              adapter->set_filter_list, client);
6778
6779                 DBG("successfully pre-set filter");
6780         }
6781
6782         return dbus_message_new_method_return(msg);
6783 }
6784
6785 static DBusMessage *stop_discovery(DBusConnection *conn,
6786                                         DBusMessage *msg, void *user_data)
6787 {
6788         struct btd_adapter *adapter = user_data;
6789         const char *sender = dbus_message_get_sender(msg);
6790         struct discovery_client *client;
6791         GSList *list;
6792         int err;
6793
6794         DBG("sender %s", sender);
6795
6796         if (!btd_adapter_get_powered(adapter))
6797                 return btd_error_not_ready(msg);
6798
6799         list = g_slist_find_custom(adapter->discovery_list, sender,
6800                         compare_sender);
6801         if (!list)
6802                 return btd_error_failed(msg, "No discovery started");
6803
6804         client = list->data;
6805
6806         if (client->msg)
6807                 return btd_error_busy(msg);
6808
6809 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
6810         err = discovery_stop(client, false);
6811 #else
6812         err = discovery_stop(client);
6813 #endif
6814         switch (err) {
6815                 case 0:
6816                         return dbus_message_new_method_return(msg);
6817                 case -EINPROGRESS:
6818                         client->msg = dbus_message_ref(msg);
6819 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
6820                         adapter->client = client;
6821 #endif
6822                         return NULL;
6823                 default:
6824                         return btd_error_failed(msg, strerror(-err));
6825         }
6826 }
6827
6828 static gboolean property_get_address(const GDBusPropertyTable *property,
6829                                         DBusMessageIter *iter, void *user_data)
6830 {
6831         struct btd_adapter *adapter = user_data;
6832         char addr[18];
6833         const char *str = addr;
6834
6835         ba2str(&adapter->bdaddr, addr);
6836
6837         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6838
6839         return TRUE;
6840 }
6841
6842 static gboolean property_get_address_type(const GDBusPropertyTable *property,
6843                                         DBusMessageIter *iter, void *user_data)
6844 {
6845         struct btd_adapter *adapter = user_data;
6846         const char *str;
6847
6848         if ((adapter->current_settings & MGMT_SETTING_LE) &&
6849                                 (adapter->bdaddr_type == BDADDR_LE_RANDOM))
6850                 str = "random";
6851         else
6852                 str = "public";
6853
6854         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6855
6856         return TRUE;
6857 }
6858
6859 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
6860 static gboolean property_get_le_address(const GDBusPropertyTable *property,
6861                                         DBusMessageIter *iter, void *user_data)
6862 {
6863         struct btd_adapter *adapter = user_data;
6864         DBusMessageIter entry;
6865         char addr[18];
6866         const char *str = addr;
6867         char *type = NULL;
6868
6869         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
6870                                         DBUS_TYPE_STRING_AS_STRING, &entry);
6871
6872         if (adapter->le_static_addr.b[5] != 0) {
6873                 ba2str(&adapter->le_static_addr, addr);
6874                 type = g_strdup_printf("%d", BDADDR_LE_RANDOM);
6875         } else {
6876                 ba2str(&adapter->bdaddr, addr);
6877                 type = g_strdup_printf("%d", BDADDR_LE_PUBLIC);
6878         }
6879
6880         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &type);
6881         g_free((void *)type);
6882
6883         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
6884
6885         dbus_message_iter_close_container(iter, &entry);
6886
6887         return TRUE;
6888 }
6889 #endif
6890
6891 static gboolean property_get_name(const GDBusPropertyTable *property,
6892                                         DBusMessageIter *iter, void *user_data)
6893 {
6894         struct btd_adapter *adapter = user_data;
6895         const char *str = adapter->system_name ? : "";
6896
6897         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6898
6899         return TRUE;
6900 }
6901
6902 static gboolean property_get_alias(const GDBusPropertyTable *property,
6903                                         DBusMessageIter *iter, void *user_data)
6904 {
6905         struct btd_adapter *adapter = user_data;
6906         const char *str;
6907
6908         if (adapter->current_alias)
6909                 str = adapter->current_alias;
6910         else if (adapter->stored_alias)
6911                 str = adapter->stored_alias;
6912         else
6913                 str = adapter->system_name ? : "";
6914
6915         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6916
6917         return TRUE;
6918 }
6919
6920 static void property_set_alias(const GDBusPropertyTable *property,
6921                                 DBusMessageIter *iter,
6922                                 GDBusPendingPropertySet id, void *user_data)
6923 {
6924         struct btd_adapter *adapter = user_data;
6925         const char *name;
6926         int ret;
6927
6928         dbus_message_iter_get_basic(iter, &name);
6929
6930         if (g_str_equal(name, "")  == TRUE) {
6931                 if (adapter->stored_alias == NULL) {
6932                         /* no alias set, nothing to restore */
6933                         g_dbus_pending_property_success(id);
6934                         return;
6935                 }
6936
6937                 /* restore to system name */
6938                 ret = set_name(adapter, adapter->system_name);
6939         } else {
6940                 if (g_strcmp0(adapter->stored_alias, name) == 0) {
6941                         /* alias already set, nothing to do */
6942                         g_dbus_pending_property_success(id);
6943                         return;
6944                 }
6945
6946                 /* set to alias */
6947                 ret = set_name(adapter, name);
6948         }
6949
6950         if (ret >= 0) {
6951                 g_free(adapter->stored_alias);
6952
6953                 if (g_str_equal(name, "")  == TRUE)
6954                         adapter->stored_alias = NULL;
6955                 else
6956                         adapter->stored_alias = g_strdup(name);
6957
6958                 store_adapter_info(adapter);
6959
6960                 g_dbus_pending_property_success(id);
6961                 return;
6962         }
6963
6964         if (ret == -EINVAL)
6965                 g_dbus_pending_property_error(id,
6966                                         ERROR_INTERFACE ".InvalidArguments",
6967                                         "Invalid arguments in method call");
6968         else
6969                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
6970                                                         strerror(-ret));
6971 }
6972
6973 static gboolean property_get_class(const GDBusPropertyTable *property,
6974                                         DBusMessageIter *iter, void *user_data)
6975 {
6976         struct btd_adapter *adapter = user_data;
6977         dbus_uint32_t val = adapter->dev_class;
6978
6979         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
6980
6981         return TRUE;
6982 }
6983
6984 static gboolean property_get_a2dp_role(const GDBusPropertyTable *property,
6985                                         DBusMessageIter *iter, void *user_data)
6986 {
6987         struct btd_adapter *adapter = user_data;
6988         dbus_uint32_t val = adapter->a2dp_role;
6989
6990         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
6991
6992         return TRUE;
6993 }
6994
6995 static gboolean property_get_mode(struct btd_adapter *adapter,
6996                                 uint32_t setting, DBusMessageIter *iter)
6997 {
6998         dbus_bool_t enable;
6999
7000         enable = (adapter->current_settings & setting) ? TRUE : FALSE;
7001
7002         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
7003
7004         return TRUE;
7005 }
7006
7007 struct property_set_data {
7008         struct btd_adapter *adapter;
7009         GDBusPendingPropertySet id;
7010 };
7011
7012 static void property_set_mode_complete(uint8_t status, uint16_t length,
7013                                         const void *param, void *user_data)
7014 {
7015         struct property_set_data *data = user_data;
7016         struct btd_adapter *adapter = data->adapter;
7017
7018         DBG("%s (0x%02x)", mgmt_errstr(status), status);
7019
7020         if (status != MGMT_STATUS_SUCCESS) {
7021                 const char *dbus_err;
7022
7023                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
7024                                                 mgmt_errstr(status), status);
7025
7026                 if (status == MGMT_STATUS_RFKILLED)
7027                         dbus_err = ERROR_INTERFACE ".Blocked";
7028                 else
7029                         dbus_err = ERROR_INTERFACE ".Failed";
7030
7031                 g_dbus_pending_property_error(data->id, dbus_err,
7032                                                         mgmt_errstr(status));
7033                 return;
7034         }
7035
7036         g_dbus_pending_property_success(data->id);
7037
7038         /*
7039          * The parameters are identical and also the task that is
7040          * required in both cases. So it is safe to just call the
7041          * event handling functions here.
7042          */
7043         new_settings_callback(adapter->dev_id, length, param, adapter);
7044 }
7045
7046 static void clear_discoverable(struct btd_adapter *adapter)
7047 {
7048         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
7049                 return;
7050
7051         if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
7052                 return;
7053
7054         /* If no timeout is set do nothing as both connectable and discoverable
7055          * flags are persistent on power toggle.
7056          */
7057         if (!adapter->discoverable_timeout)
7058                 return;
7059
7060         /* If timeout was set kernel clears discoverable on its own when
7061          * powering off controller. This would leave connectable flag set
7062          * after power on.
7063          *
7064          * With kernel control clearing connectable clear also discoverable
7065          * flag so we need to clear connectable.
7066          */
7067         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
7068 }
7069
7070 static void property_set_mode(struct btd_adapter *adapter, uint32_t setting,
7071                                                 DBusMessageIter *value,
7072                                                 GDBusPendingPropertySet id)
7073 {
7074         struct property_set_data *data;
7075         struct mgmt_cp_set_discoverable cp;
7076         void *param;
7077         dbus_bool_t enable, current_enable;
7078         uint16_t opcode, len;
7079         uint8_t mode;
7080
7081         dbus_message_iter_get_basic(value, &enable);
7082
7083         if (adapter->pending_settings & setting) {
7084                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Busy",
7085                                                 NULL);
7086                 return;
7087         }
7088
7089         if (adapter->current_settings & setting)
7090                 current_enable = TRUE;
7091         else
7092                 current_enable = FALSE;
7093
7094         if (enable == current_enable) {
7095                 g_dbus_pending_property_success(id);
7096                 return;
7097         }
7098
7099         mode = (enable == TRUE) ? 0x01 : 0x00;
7100
7101         adapter->pending_settings |= setting;
7102
7103         switch (setting) {
7104         case MGMT_SETTING_POWERED:
7105                 opcode = MGMT_OP_SET_POWERED;
7106                 param = &mode;
7107                 len = sizeof(mode);
7108
7109                 if (!mode) {
7110                         btd_adv_monitor_power_down(
7111                                                 adapter->adv_monitor_manager);
7112                         clear_discoverable(adapter);
7113                         remove_temporary_devices(adapter);
7114                 }
7115
7116                 break;
7117         case MGMT_SETTING_DISCOVERABLE:
7118 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7119                 if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
7120                         if (mode) {
7121                                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
7122                                                                         mode);
7123                         } else {
7124                                 opcode = MGMT_OP_SET_CONNECTABLE;
7125                                 param = &mode;
7126                                 len = sizeof(mode);
7127                                 break;
7128                         }
7129                 }
7130 #endif
7131
7132                 memset(&cp, 0, sizeof(cp));
7133                 cp.val = mode;
7134                 if (cp.val)
7135                         cp.timeout = htobs(adapter->discoverable_timeout);
7136
7137                 opcode = MGMT_OP_SET_DISCOVERABLE;
7138                 param = &cp;
7139                 len = sizeof(cp);
7140                 break;
7141         case MGMT_SETTING_BONDABLE:
7142                 opcode = MGMT_OP_SET_BONDABLE;
7143                 param = &mode;
7144                 len = sizeof(mode);
7145                 break;
7146 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7147         case MGMT_SETTING_CONNECTABLE:
7148                 opcode = MGMT_OP_SET_CONNECTABLE;
7149                 param = &mode;
7150                 len = sizeof(mode);
7151                 break;
7152 #endif
7153         default:
7154                 goto failed;
7155         }
7156
7157         DBG("sending %s command for index %u", mgmt_opstr(opcode),
7158                                                         adapter->dev_id);
7159
7160         data = g_try_new0(struct property_set_data, 1);
7161         if (!data)
7162                 goto failed;
7163
7164         data->adapter = adapter;
7165         data->id = id;
7166
7167 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7168         /*
7169          * Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
7170          */
7171         if (mgmt_send_nowait(adapter->mgmt, opcode, adapter->dev_id, len, param,
7172                                 property_set_mode_complete, data, g_free) > 0)
7173 #else
7174         if (mgmt_send(adapter->mgmt, opcode, adapter->dev_id, len, param,
7175                         property_set_mode_complete, data, g_free) > 0)
7176 #endif
7177                 return;
7178
7179         g_free(data);
7180
7181 failed:
7182         btd_error(adapter->dev_id, "Failed to set mode for index %u",
7183                                                         adapter->dev_id);
7184
7185         g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
7186 }
7187
7188 static gboolean property_get_powered(const GDBusPropertyTable *property,
7189                                         DBusMessageIter *iter, void *user_data)
7190 {
7191         struct btd_adapter *adapter = user_data;
7192
7193         return property_get_mode(adapter, MGMT_SETTING_POWERED, iter);
7194 }
7195
7196 static void property_set_powered(const GDBusPropertyTable *property,
7197                                 DBusMessageIter *iter,
7198                                 GDBusPendingPropertySet id, void *user_data)
7199 {
7200         struct btd_adapter *adapter = user_data;
7201
7202         if (powering_down) {
7203                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7204                                                         "Powering down");
7205                 return;
7206         }
7207
7208         property_set_mode(adapter, MGMT_SETTING_POWERED, iter, id);
7209 }
7210
7211 static gboolean property_get_discoverable(const GDBusPropertyTable *property,
7212                                         DBusMessageIter *iter, void *user_data)
7213 {
7214         struct btd_adapter *adapter = user_data;
7215
7216         return property_get_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter);
7217 }
7218
7219 static void property_set_discoverable(const GDBusPropertyTable *property,
7220                                 DBusMessageIter *iter,
7221                                 GDBusPendingPropertySet id, void *user_data)
7222 {
7223         struct btd_adapter *adapter = user_data;
7224
7225         if (adapter->discoverable_timeout > 0 &&
7226                         !btd_adapter_get_powered(adapter)) {
7227                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7228                                                                 "Not Powered");
7229                 return;
7230         }
7231
7232         /* Reset discovery_discoverable as Discoverable takes precedence */
7233         adapter->discovery_discoverable = false;
7234
7235         property_set_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter, id);
7236 }
7237
7238 static gboolean property_get_discoverable_timeout(
7239                                         const GDBusPropertyTable *property,
7240                                         DBusMessageIter *iter, void *user_data)
7241 {
7242         struct btd_adapter *adapter = user_data;
7243         dbus_uint32_t value = adapter->discoverable_timeout;
7244
7245         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7246
7247         return TRUE;
7248 }
7249
7250 static void property_set_discoverable_timeout(
7251                                 const GDBusPropertyTable *property,
7252                                 DBusMessageIter *iter,
7253                                 GDBusPendingPropertySet id, void *user_data)
7254 {
7255         struct btd_adapter *adapter = user_data;
7256         bool enabled;
7257         dbus_uint32_t value;
7258
7259         dbus_message_iter_get_basic(iter, &value);
7260
7261         adapter->discoverable_timeout = value;
7262
7263         g_dbus_pending_property_success(id);
7264
7265         store_adapter_info(adapter);
7266
7267         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7268                                 ADAPTER_INTERFACE, "DiscoverableTimeout");
7269
7270         if (adapter->pending_settings & MGMT_SETTING_DISCOVERABLE) {
7271                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7272                         enabled = false;
7273                 else
7274                         enabled = true;
7275         } else {
7276                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7277                         enabled = true;
7278                 else
7279                         enabled = false;
7280         }
7281
7282         if (enabled)
7283                 set_discoverable(adapter, 0x01, adapter->discoverable_timeout);
7284 }
7285
7286 static gboolean property_get_pairable(const GDBusPropertyTable *property,
7287                                         DBusMessageIter *iter, void *user_data)
7288 {
7289         struct btd_adapter *adapter = user_data;
7290
7291         return property_get_mode(adapter, MGMT_SETTING_BONDABLE, iter);
7292 }
7293
7294 static void property_set_pairable(const GDBusPropertyTable *property,
7295                                 DBusMessageIter *iter,
7296                                 GDBusPendingPropertySet id, void *user_data)
7297 {
7298         struct btd_adapter *adapter = user_data;
7299
7300         property_set_mode(adapter, MGMT_SETTING_BONDABLE, iter, id);
7301 }
7302
7303 static gboolean property_get_pairable_timeout(
7304                                         const GDBusPropertyTable *property,
7305                                         DBusMessageIter *iter, void *user_data)
7306 {
7307         struct btd_adapter *adapter = user_data;
7308         dbus_uint32_t value = adapter->pairable_timeout;
7309
7310         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7311
7312         return TRUE;
7313 }
7314
7315 static void property_set_pairable_timeout(const GDBusPropertyTable *property,
7316                                 DBusMessageIter *iter,
7317                                 GDBusPendingPropertySet id, void *user_data)
7318 {
7319         struct btd_adapter *adapter = user_data;
7320         dbus_uint32_t value;
7321
7322         dbus_message_iter_get_basic(iter, &value);
7323
7324         adapter->pairable_timeout = value;
7325
7326         g_dbus_pending_property_success(id);
7327
7328         store_adapter_info(adapter);
7329
7330         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7331                                         ADAPTER_INTERFACE, "PairableTimeout");
7332
7333         trigger_pairable_timeout(adapter);
7334 }
7335
7336 static gboolean property_get_discovering(const GDBusPropertyTable *property,
7337                                         DBusMessageIter *iter, void *user_data)
7338 {
7339         struct btd_adapter *adapter = user_data;
7340         dbus_bool_t discovering = adapter->discovering;
7341
7342         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7343
7344         return TRUE;
7345 }
7346
7347 static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
7348 {
7349         GHashTable *uuids = user_data;
7350         bt_uuid_t uuid, u128;
7351         char uuidstr[MAX_LEN_UUID_STR + 1];
7352
7353         if (!gatt_db_service_get_active(attrib))
7354                 return;
7355
7356         if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
7357                 return;
7358
7359         bt_uuid_to_uuid128(&uuid, &u128);
7360         bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
7361
7362         g_hash_table_add(uuids, strdup(uuidstr));
7363 }
7364
7365 static void iter_append_uuid(gpointer key, gpointer value, gpointer user_data)
7366 {
7367         DBusMessageIter *iter = user_data;
7368         const char *uuid = key;
7369
7370         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
7371 }
7372
7373 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7374 static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
7375                                         DBusMessageIter *iter, void *user_data)
7376 {
7377         struct btd_adapter *adapter = user_data;
7378         dbus_bool_t discovering = adapter->le_discovering;
7379
7380         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7381
7382         return TRUE;
7383 }
7384
7385 static gboolean property_get_connectable(const GDBusPropertyTable *property,
7386                                         DBusMessageIter *iter, void *user_data)
7387 {
7388         struct btd_adapter *adapter = user_data;
7389
7390         return property_get_mode(adapter, MGMT_SETTING_CONNECTABLE, iter);
7391 }
7392
7393 static void property_set_connectable(const GDBusPropertyTable *property,
7394                                 DBusMessageIter *iter,
7395                                 GDBusPendingPropertySet id, void *user_data)
7396 {
7397         struct btd_adapter *adapter = user_data;
7398
7399         property_set_mode(adapter, MGMT_SETTING_CONNECTABLE, iter, id);
7400 }
7401
7402 static gboolean property_get_version(const GDBusPropertyTable *property,
7403                                         DBusMessageIter *iter, void *user_data)
7404 {
7405         struct btd_adapter *adapter = user_data;
7406         const char *str = adapter->version ? : "";
7407
7408         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7409
7410         return TRUE;
7411 }
7412
7413 static gboolean property_get_supported_le_features(
7414                                         const GDBusPropertyTable *property,
7415                                         DBusMessageIter *iter, void *user_data)
7416 {
7417         const char *str, *val;
7418         int value;
7419         DBusMessageIter entry;
7420         struct btd_adapter *adapter = user_data;
7421
7422         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7423                         DBUS_TYPE_STRING_AS_STRING, &entry);
7424
7425         value = adapter_le_get_max_adv_instance();
7426         if (value > 0) {
7427                 str = g_strdup("adv_inst_max");
7428                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7429
7430                 val = g_strdup_printf("%d", value);
7431                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7432
7433                 g_free((void *)str);
7434                 g_free((void *)val);
7435         }
7436
7437         value = adapter_le_is_supported_offloading();
7438         if (value > 0) {
7439                 str = g_strdup("rpa_offloading");
7440                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7441
7442                 val = g_strdup_printf("%d", value);
7443                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7444
7445                 g_free((void *)str);
7446                 g_free((void *)val);
7447         }
7448
7449         value = adapter_le_get_scan_filter_size();
7450 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
7451         if (value <= 0)
7452                 value = SCAN_FILTER_SLOTS_MAX;
7453 #endif
7454         if (value > 0) {
7455                 str = g_strdup("max_filter");
7456                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7457
7458                 val = g_strdup_printf("%d", value);
7459                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7460
7461                 g_free((void *)str);
7462                 g_free((void *)val);
7463         }
7464
7465         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
7466                 /* 2M PHY Support */
7467                 str = g_strdup("2m_phy");
7468                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7469
7470                 if (adapter->le_2m_phy_supported)
7471                         val = g_strdup("true");
7472                 else
7473                         val = g_strdup("false");
7474
7475                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7476
7477                 g_free((void *)str);
7478                 g_free((void *)val);
7479
7480                 /* CODED PHY Support */
7481                 str = g_strdup("coded_phy");
7482                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7483
7484                 if (adapter->le_coded_phy_supported)
7485                         val = g_strdup("true");
7486                 else
7487                         val = g_strdup("false");
7488
7489                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7490
7491                 g_free((void *)str);
7492                 g_free((void *)val);
7493         }
7494
7495         dbus_message_iter_close_container(iter, &entry);
7496
7497         return TRUE;
7498 }
7499
7500 static gboolean property_get_ipsp_init_state(
7501                                         const GDBusPropertyTable *property,
7502                                         DBusMessageIter *iter, void *data)
7503 {
7504         struct btd_adapter *adapter = data;
7505         dbus_bool_t ipsp_initialized;
7506
7507         if (adapter->ipsp_intialized)
7508                 ipsp_initialized = TRUE;
7509         else
7510                 ipsp_initialized = FALSE;
7511
7512         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
7513                                         &ipsp_initialized);
7514
7515         return TRUE;
7516 }
7517 #endif
7518
7519 static gboolean property_get_uuids(const GDBusPropertyTable *property,
7520                                         DBusMessageIter *iter, void *user_data)
7521 {
7522         struct btd_adapter *adapter = user_data;
7523         DBusMessageIter entry;
7524         sdp_list_t *l;
7525         struct gatt_db *db;
7526         GHashTable *uuids;
7527
7528         uuids = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
7529         if (!uuids)
7530                 return FALSE;
7531
7532         /* SDP records */
7533         for (l = adapter->services; l != NULL; l = l->next) {
7534                 sdp_record_t *rec = l->data;
7535                 char *uuid;
7536
7537                 uuid = bt_uuid2string(&rec->svclass);
7538                 if (uuid == NULL)
7539                         continue;
7540
7541                 g_hash_table_add(uuids, uuid);
7542         }
7543
7544         /* GATT services */
7545         db = btd_gatt_database_get_db(adapter->database);
7546         if (db)
7547                 gatt_db_foreach_service(db, NULL, add_gatt_uuid, uuids);
7548
7549         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7550                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7551         g_hash_table_foreach(uuids, iter_append_uuid, &entry);
7552         dbus_message_iter_close_container(iter, &entry);
7553
7554         g_hash_table_destroy(uuids);
7555
7556         return TRUE;
7557 }
7558
7559 static gboolean property_exists_modalias(const GDBusPropertyTable *property,
7560                                                         void *user_data)
7561 {
7562         struct btd_adapter *adapter = user_data;
7563
7564         return adapter->modalias ? TRUE : FALSE;
7565 }
7566
7567 static gboolean property_get_modalias(const GDBusPropertyTable *property,
7568                                         DBusMessageIter *iter, void *user_data)
7569 {
7570         struct btd_adapter *adapter = user_data;
7571         const char *str = adapter->modalias ? : "";
7572
7573         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7574
7575         return TRUE;
7576 }
7577
7578 static gboolean property_get_roles(const GDBusPropertyTable *property,
7579                                         DBusMessageIter *iter, void *user_data)
7580 {
7581         struct btd_adapter *adapter = user_data;
7582         DBusMessageIter entry;
7583
7584         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7585                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7586
7587         if (adapter->supported_settings & MGMT_SETTING_LE) {
7588                 const char *str = "central";
7589                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7590         }
7591
7592         if (adapter->supported_settings & MGMT_SETTING_ADVERTISING) {
7593                 const char *str = "peripheral";
7594                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7595         }
7596
7597         if (queue_find(adapter->exps, NULL,
7598                                 le_simult_central_peripheral_uuid.val)) {
7599                 const char *str = "central-peripheral";
7600                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7601         }
7602
7603         dbus_message_iter_close_container(iter, &entry);
7604
7605         return TRUE;
7606 }
7607
7608 static void property_append_experimental(void *data, void *user_data)
7609 {
7610         uint8_t *feature = data;
7611         DBusMessageIter *iter = user_data;
7612         uint128_t value;
7613         bt_uuid_t uuid;
7614         char str[MAX_LEN_UUID_STR + 1];
7615         char *ptr;
7616
7617         bswap_128(feature, &value);
7618         bt_uuid128_create(&uuid, value);
7619         bt_uuid_to_string(&uuid, str, sizeof(str));
7620
7621         ptr = str;
7622
7623         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &ptr);
7624 }
7625
7626 static gboolean property_get_experimental(const GDBusPropertyTable *property,
7627                                         DBusMessageIter *iter, void *user_data)
7628 {
7629         struct btd_adapter *adapter = user_data;
7630         DBusMessageIter entry;
7631
7632         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7633                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7634
7635         queue_foreach(adapter->exps, property_append_experimental, &entry);
7636
7637         dbus_message_iter_close_container(iter, &entry);
7638
7639         return TRUE;
7640 }
7641
7642 static gboolean property_experimental_exits(const GDBusPropertyTable *property,
7643                                                                 void *data)
7644 {
7645         struct btd_adapter *adapter = data;
7646
7647         return !queue_isempty(adapter->exps);
7648 }
7649
7650 static DBusMessage *remove_device(DBusConnection *conn,
7651                                         DBusMessage *msg, void *user_data)
7652 {
7653         struct btd_adapter *adapter = user_data;
7654         struct btd_device *device;
7655         const char *path;
7656         GSList *list;
7657
7658         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
7659                                                 DBUS_TYPE_INVALID) == FALSE)
7660                 return btd_error_invalid_args(msg);
7661
7662         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7663         if (!list)
7664                 return btd_error_does_not_exist(msg);
7665
7666         if (!btd_adapter_get_powered(adapter))
7667                 return btd_error_not_ready(msg);
7668
7669         device = list->data;
7670
7671         btd_device_set_temporary(device, true);
7672
7673         if (!btd_device_is_connected(device)) {
7674                 btd_adapter_remove_device(adapter, device);
7675                 return dbus_message_new_method_return(msg);
7676         }
7677
7678         device_request_disconnect(device, msg);
7679
7680         return NULL;
7681 }
7682
7683 static DBusMessage *get_discovery_filters(DBusConnection *conn,
7684                                         DBusMessage *msg, void *user_data)
7685 {
7686         DBusMessage *reply;
7687         DBusMessageIter iter, array;
7688         struct filter_parser *parser;
7689
7690         reply = dbus_message_new_method_return(msg);
7691
7692         dbus_message_iter_init_append(reply, &iter);
7693
7694         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
7695                                         DBUS_TYPE_STRING_AS_STRING, &array);
7696
7697         for (parser = parsers; parser && parser->name; parser++) {
7698                 dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
7699                                                         &parser->name);
7700         }
7701
7702         dbus_message_iter_close_container(&iter, &array);
7703
7704         return reply;
7705 }
7706
7707 struct device_connect_data {
7708         struct btd_adapter *adapter;
7709         bdaddr_t dst;
7710         uint8_t dst_type;
7711         DBusMessage *msg;
7712 };
7713
7714 static void device_browse_cb(struct btd_device *dev, int err, void *user_data)
7715 {
7716         DBG("err %d (%s)", err, strerror(-err));
7717
7718         if (!err)
7719                 btd_device_connect_services(dev, NULL);
7720 }
7721
7722 static void device_connect_cb(GIOChannel *io, GError *gerr, gpointer user_data)
7723 {
7724         struct device_connect_data *data = user_data;
7725         struct btd_adapter *adapter = data->adapter;
7726         struct btd_device *device;
7727         const char *path;
7728
7729         DBG("%s", gerr ? gerr->message : "");
7730
7731         if (gerr)
7732                 goto failed;
7733
7734         /* object might already exist due to mgmt socket event */
7735         device = btd_adapter_get_device(adapter, &data->dst, data->dst_type);
7736         if (!device)
7737                 goto failed;
7738
7739         path = device_get_path(device);
7740
7741         g_dbus_send_reply(dbus_conn, data->msg, DBUS_TYPE_OBJECT_PATH, &path,
7742                                                         DBUS_TYPE_INVALID);
7743
7744         /* continue with service discovery and connection */
7745         btd_device_set_temporary(device, false);
7746         device_update_last_seen(device, data->dst_type);
7747
7748         if (data->dst_type != BDADDR_BREDR){
7749                 g_io_channel_set_close_on_unref(io, FALSE);
7750                 device_attach_att(device, io);
7751         }
7752
7753         device_discover_services(device);
7754         device_wait_for_svc_complete(device, device_browse_cb, NULL);
7755
7756         g_io_channel_unref(io);
7757         dbus_message_unref(data->msg);
7758         free(data);
7759         return;
7760
7761 failed:
7762         g_dbus_send_error(dbus_conn, data->msg, "org.bluez.Failed", NULL);
7763         g_io_channel_unref(io);
7764         dbus_message_unref(data->msg);
7765         free(data);
7766 }
7767
7768 static void device_connect(struct btd_adapter *adapter, const bdaddr_t *dst,
7769                                         uint8_t dst_type, DBusMessage *msg)
7770 {
7771         struct device_connect_data *data;
7772         GIOChannel *io;
7773
7774         data = new0(struct device_connect_data, 1);
7775         data->adapter = adapter;
7776         bacpy(&data->dst, dst);
7777         data->dst_type = dst_type;
7778         data->msg = dbus_message_ref(msg);
7779
7780         if (dst_type == BDADDR_BREDR)
7781                 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
7782                                 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
7783                                 BT_IO_OPT_SOURCE_TYPE, BDADDR_BREDR,
7784                                 BT_IO_OPT_DEST_BDADDR, dst,
7785                                 BT_IO_OPT_DEST_TYPE, BDADDR_BREDR,
7786                                 BT_IO_OPT_PSM, SDP_PSM,
7787                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
7788                                 BT_IO_OPT_INVALID);
7789         else
7790                 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
7791                                 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
7792                                 BT_IO_OPT_SOURCE_TYPE, adapter->bdaddr_type,
7793                                 BT_IO_OPT_DEST_BDADDR, dst,
7794                                 BT_IO_OPT_DEST_TYPE, dst_type,
7795                                 BT_IO_OPT_CID, ATT_CID,
7796                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
7797                                 BT_IO_OPT_INVALID);
7798
7799         if (!io) {
7800                 g_dbus_send_message(dbus_conn,
7801                                 btd_error_failed(msg, "Connect failed"));
7802                 dbus_message_unref(data->msg);
7803                 free(data);
7804         }
7805 }
7806
7807 static DBusMessage *connect_device(DBusConnection *conn,
7808                                         DBusMessage *msg, void *user_data)
7809 {
7810         struct btd_adapter *adapter = user_data;
7811         DBusMessageIter iter, subiter, dictiter, value;
7812         uint8_t addr_type = BDADDR_BREDR;
7813         bdaddr_t addr = *BDADDR_ANY;
7814
7815         DBG("sender %s", dbus_message_get_sender(msg));
7816
7817         if (!btd_adapter_get_powered(adapter))
7818                 return btd_error_not_ready(msg);
7819
7820         dbus_message_iter_init(msg, &iter);
7821         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
7822             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
7823                 return btd_error_invalid_args(msg);
7824
7825         dbus_message_iter_recurse(&iter, &subiter);
7826         while (true) {
7827                 int type = dbus_message_iter_get_arg_type(&subiter);
7828                 char *key;
7829                 char *str;
7830
7831                 if (type == DBUS_TYPE_INVALID)
7832                         break;
7833
7834                 dbus_message_iter_recurse(&subiter, &dictiter);
7835
7836                 dbus_message_iter_get_basic(&dictiter, &key);
7837                 if (!dbus_message_iter_next(&dictiter))
7838                         return btd_error_invalid_args(msg);
7839
7840                 if (dbus_message_iter_get_arg_type(&dictiter) !=
7841                                                         DBUS_TYPE_VARIANT)
7842                         return btd_error_invalid_args(msg);
7843
7844                 dbus_message_iter_recurse(&dictiter, &value);
7845
7846                 if (!strcmp(key, "Address")) {
7847                         if (dbus_message_iter_get_arg_type(&value) !=
7848                                                         DBUS_TYPE_STRING)
7849                                 return btd_error_invalid_args(msg);
7850
7851                         dbus_message_iter_get_basic(&value, &str);
7852
7853                         if (str2ba(str, &addr) < 0 )
7854                                 return btd_error_invalid_args(msg);
7855                 } else if (!strcmp(key, "AddressType")) {
7856                         if (dbus_message_iter_get_arg_type(&value) !=
7857                                                         DBUS_TYPE_STRING)
7858                                 return btd_error_invalid_args(msg);
7859
7860                         dbus_message_iter_get_basic(&value, &str);
7861
7862
7863                         if (!strcmp(str, "public"))
7864                                 addr_type = BDADDR_LE_PUBLIC;
7865                         else if (!strcmp(str, "random"))
7866                                 addr_type = BDADDR_LE_RANDOM;
7867                         else
7868                                 return btd_error_invalid_args(msg);
7869                 } else {
7870                         return btd_error_invalid_args(msg);
7871                 }
7872
7873                 dbus_message_iter_next(&subiter);
7874         }
7875
7876         if (!bacmp(&addr, BDADDR_ANY))
7877                 return btd_error_invalid_args(msg);
7878
7879         if (btd_adapter_find_device(adapter, &addr, addr_type))
7880                 return btd_error_already_exists(msg);
7881
7882         device_connect(adapter, &addr, addr_type, msg);
7883         return NULL;
7884 }
7885
7886 static void update_device_allowed_services(void *data, void *user_data)
7887 {
7888         struct btd_device *device = data;
7889
7890         btd_device_update_allowed_services(device);
7891 }
7892
7893 static void add_uuid_to_uuid_set(void *data, void *user_data)
7894 {
7895         bt_uuid_t *uuid = data;
7896         GHashTable *uuid_set = user_data;
7897
7898         if (!uuid) {
7899                 error("Found NULL in UUID allowed list");
7900                 return;
7901         }
7902
7903         g_hash_table_add(uuid_set, uuid);
7904 }
7905
7906 static guint bt_uuid_hash(gconstpointer key)
7907 {
7908         const bt_uuid_t *uuid = key;
7909         bt_uuid_t uuid_128;
7910         uint64_t *val;
7911
7912         if (!uuid)
7913                 return 0;
7914
7915         bt_uuid_to_uuid128(uuid, &uuid_128);
7916         val = (uint64_t *)&uuid_128.value.u128;
7917
7918         return g_int64_hash(val) ^ g_int64_hash(val+1);
7919 }
7920
7921 static gboolean bt_uuid_equal(gconstpointer v1, gconstpointer v2)
7922 {
7923         const bt_uuid_t *uuid1 = v1;
7924         const bt_uuid_t *uuid2 = v2;
7925
7926         if (!uuid1 || !uuid2)
7927                 return !uuid1 && !uuid2;
7928
7929         return bt_uuid_cmp(uuid1, uuid2) == 0;
7930 }
7931
7932 bool btd_adapter_set_allowed_uuids(struct btd_adapter *adapter,
7933                                                         struct queue *uuids)
7934 {
7935         if (!adapter)
7936                 return false;
7937
7938         if (adapter->allowed_uuid_set)
7939                 g_hash_table_destroy(adapter->allowed_uuid_set);
7940
7941         adapter->allowed_uuid_set = g_hash_table_new(bt_uuid_hash,
7942                                                                 bt_uuid_equal);
7943         if (!adapter->allowed_uuid_set) {
7944                 btd_error(adapter->dev_id,
7945                                         "Failed to allocate allowed_uuid_set");
7946                 return false;
7947         }
7948
7949         queue_foreach(uuids, add_uuid_to_uuid_set, adapter->allowed_uuid_set);
7950         g_slist_foreach(adapter->devices, update_device_allowed_services, NULL);
7951
7952         return true;
7953 }
7954
7955 bool btd_adapter_is_uuid_allowed(struct btd_adapter *adapter,
7956                                                         const char *uuid_str)
7957 {
7958         bt_uuid_t uuid;
7959
7960         if (!adapter || !adapter->allowed_uuid_set)
7961                 return true;
7962
7963         if (bt_string_to_uuid(&uuid, uuid_str)) {
7964                 btd_error(adapter->dev_id,
7965                                 "Failed to parse UUID string '%s'", uuid_str);
7966                 return false;
7967         }
7968
7969         return !g_hash_table_size(adapter->allowed_uuid_set) ||
7970                 g_hash_table_contains(adapter->allowed_uuid_set, &uuid);
7971 }
7972
7973 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7974 static DBusMessage *adapter_unpair_device(DBusConnection *conn,
7975                                         DBusMessage *msg, void *user_data)
7976 {
7977         DBG("+");
7978         struct btd_adapter *adapter = user_data;
7979         struct btd_device *device;
7980         const char *path;
7981         GSList *list;
7982
7983         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
7984                                                 DBUS_TYPE_INVALID) == FALSE)
7985                 return btd_error_invalid_args(msg);
7986
7987         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7988         if (!list)
7989                 return btd_error_does_not_exist(msg);
7990
7991         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7992                 return btd_error_not_ready(msg);
7993
7994         device = list->data;
7995
7996         btd_device_set_temporary(device, TRUE);
7997
7998         if (!btd_device_is_connected(device)) {
7999                 btd_adapter_unpair_device(adapter, device);
8000                 return dbus_message_new_method_return(msg);
8001         }
8002
8003         device_request_disconnect(device, msg);
8004
8005         DBG("-");
8006         return NULL;
8007 }
8008
8009 static DBusMessage *create_device(DBusConnection *conn,
8010                                         DBusMessage *msg, void *data)
8011 {
8012         struct btd_adapter *adapter = data;
8013         const gchar *address;
8014         bdaddr_t addr;
8015         DBG("+");
8016
8017         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8018                                                 DBUS_TYPE_INVALID) == FALSE)
8019                 return btd_error_invalid_args(msg);
8020
8021         if (bachk(address) < 0)
8022                 return btd_error_invalid_args(msg);
8023
8024         DBG("%s", address);
8025
8026         str2ba(address, &addr);
8027         btd_adapter_get_device(adapter, &addr, BDADDR_BREDR);
8028
8029         DBG("-");
8030         return dbus_message_new_method_return(msg);
8031 }
8032
8033 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
8034                                         void *data)
8035 {
8036         struct btd_adapter *adapter = data;
8037         struct btd_device *device;
8038         DBusMessage *reply;
8039         const gchar *address;
8040         GSList *l;
8041         const gchar *dev_path;
8042
8043         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8044                                 DBUS_TYPE_INVALID))
8045                 return btd_error_invalid_args(msg);
8046
8047         l = g_slist_find_custom(adapter->devices, address, device_rpa_cmp);
8048         if (!l)
8049                 l = g_slist_find_custom(adapter->devices, address,
8050                                                         device_address_cmp);
8051         if (!l)
8052                 return btd_error_does_not_exist(msg);
8053
8054         device = l->data;
8055
8056         reply = dbus_message_new_method_return(msg);
8057         if (!reply)
8058                 return NULL;
8059
8060         dev_path = device_get_path(device);
8061
8062         dbus_message_append_args(reply,
8063                         DBUS_TYPE_OBJECT_PATH, &dev_path,
8064                         DBUS_TYPE_INVALID);
8065
8066         return reply;
8067 }
8068
8069 static gboolean adapter_ipsp_connected(struct btd_adapter *adapter)
8070 {
8071         GSList *l, *next;
8072
8073         DBG("%s", adapter->path);
8074
8075         for (l = adapter->connections; l != NULL; l = next) {
8076                 struct btd_device *dev = l->data;
8077
8078                 next = g_slist_next(l);
8079
8080                 if (device_is_ipsp_connected(dev))
8081                         return TRUE;
8082         }
8083
8084         return FALSE;
8085 }
8086
8087 static void adapter_set_ipsp_init_state(struct btd_adapter *adapter, gboolean initialized)
8088 {
8089         if (adapter->ipsp_intialized == initialized)
8090                 return;
8091
8092         adapter->ipsp_intialized = initialized;
8093
8094         g_dbus_emit_property_changed(dbus_conn, adapter->path,
8095                                                 ADAPTER_INTERFACE, "IpspInitStateChanged");
8096 }
8097
8098 static void deinitialize_6lowpan_complete(uint8_t status, uint16_t length,
8099         const void *param, void *user_data)
8100 {
8101         struct btd_adapter *adapter = user_data;
8102         bool initialized = FALSE;
8103
8104         if (status != MGMT_STATUS_SUCCESS)
8105                 error("De-Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
8106                         adapter->dev_id, mgmt_errstr(status), status);
8107         else {
8108                 adapter_set_ipsp_init_state(adapter, initialized);
8109                 DBG("De-Initialize BT 6lowpan successfully for hci%u",
8110                         adapter->dev_id);
8111         }
8112 }
8113
8114 static bool deinitialize_6lowpan(struct btd_adapter *adapter)
8115 {
8116         struct mgmt_cp_enable_6lowpan cp;
8117
8118         memset(&cp, 0, sizeof(cp));
8119
8120         cp.enable_6lowpan = DEINIT_6LOWPAN;
8121         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
8122                         adapter->dev_id, sizeof(cp), &cp,
8123                         deinitialize_6lowpan_complete, adapter, NULL) > 0)
8124                 return true;
8125
8126         error("Failed to de-initialize BT 6Lowpan for index %u",
8127                 adapter->dev_id);
8128         return false;
8129 }
8130
8131 static void initialize_6lowpan_complete(uint8_t status, uint16_t length,
8132         const void *param, void *user_data)
8133 {
8134         struct btd_adapter *adapter = user_data;
8135         bool initialized = TRUE;
8136
8137         if (status != MGMT_STATUS_SUCCESS)
8138                 error("Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
8139                         adapter->dev_id, mgmt_errstr(status), status);
8140         else {
8141                 adapter_set_ipsp_init_state(adapter, initialized);
8142                 DBG("Initialize BT 6lowpan successfully for hci%u",
8143                         adapter->dev_id);
8144         }
8145 }
8146
8147 static bool initialize_6lowpan(struct btd_adapter *adapter)
8148 {
8149         struct mgmt_cp_enable_6lowpan cp;
8150
8151         memset(&cp, 0, sizeof(cp));
8152
8153         cp.enable_6lowpan = INIT_6LOWPAN;
8154         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
8155                         adapter->dev_id, sizeof(cp), &cp,
8156                         initialize_6lowpan_complete, adapter, NULL) > 0)
8157                 return true;
8158
8159         error("Failed to initialize BT 6Lowpan for index %u",
8160                 adapter->dev_id);
8161         return false;
8162 }
8163
8164 static DBusMessage *adapter_initialize_ipsp(DBusConnection *conn,
8165                                         DBusMessage *msg, void *data)
8166 {
8167         struct btd_adapter *adapter = data;
8168         dbus_bool_t err;
8169
8170         DBG("Initialize IPSP");
8171
8172         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8173                 return btd_error_not_ready(msg);
8174
8175         if (adapter->ipsp_intialized)
8176                 return btd_error_already_exists(msg);
8177
8178         /* Enable BT 6lowpan in kernel */
8179         err = initialize_6lowpan(adapter);
8180
8181         if (!err)
8182                 return btd_error_failed(msg, "Failed to initialize BT 6lowpan");
8183
8184         return dbus_message_new_method_return(msg);
8185 }
8186
8187 static DBusMessage *adapter_deinitialize_ipsp(DBusConnection *conn,
8188                                         DBusMessage *msg, void *data)
8189 {
8190         struct btd_adapter *adapter = data;
8191         dbus_bool_t err;
8192
8193         DBG("De-initialize IPSP");
8194
8195         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8196                 return btd_error_not_ready(msg);
8197
8198         if (!adapter->ipsp_intialized)
8199                 return btd_error_not_permitted(msg, "IPSP not initialized");
8200
8201         if (adapter_ipsp_connected(adapter))
8202                 return btd_error_not_permitted(msg, "IPSP Client device found connected");
8203
8204         /* Disable BT 6lowpan in kernel */
8205         err = deinitialize_6lowpan(adapter);
8206
8207         if (!err)
8208                 return btd_error_failed(msg, "Failed to deinitialize BT 6lowpan");
8209
8210         return dbus_message_new_method_return(msg);
8211 }
8212 #endif
8213
8214 static const GDBusMethodTable adapter_methods[] = {
8215         { GDBUS_ASYNC_METHOD("StartDiscovery", NULL, NULL, start_discovery) },
8216         { GDBUS_METHOD("SetDiscoveryFilter",
8217                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8218                                 set_discovery_filter) },
8219         { GDBUS_ASYNC_METHOD("StopDiscovery", NULL, NULL, stop_discovery) },
8220 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8221         { GDBUS_METHOD("GetPSML2capLE",
8222                         GDBUS_ARGS({ "path", "o"}),
8223                         GDBUS_ARGS({ "psm", "i" }),
8224                         adapter_get_psm_l2cap_le) },
8225         { GDBUS_METHOD("ListenL2capLESocket",
8226                         GDBUS_ARGS({ "path", "o"}, { "psm", "i" }, { "options", "a{sv}" }),
8227                         NULL, adapter_listen_l2cap_le_socket) },
8228         { GDBUS_METHOD("RemoveL2capLESocket", GDBUS_ARGS({ "path", "o" }),
8229                         NULL, adapter_remove_l2cap_le_socket) },
8230         { GDBUS_METHOD("StartCustomDiscovery",
8231                         GDBUS_ARGS({ "type", "s" }), NULL,
8232                         adapter_start_custom_discovery) },
8233         { GDBUS_METHOD("StartLEDiscovery", NULL, NULL,
8234                         adapter_start_le_discovery) },
8235         { GDBUS_ASYNC_METHOD("StopLEDiscovery", NULL, NULL,
8236                         adapter_stop_le_discovery) },
8237         { GDBUS_METHOD("SetAdvertising",
8238                         GDBUS_ARGS({ "enable", "b" },
8239                                 { "slot_id", "i" }), NULL,
8240                         adapter_set_advertising) },
8241         { GDBUS_METHOD("SetAdvertisingParameters",
8242                         GDBUS_ARGS({ "interval_min", "u" },
8243                                 { "interval_max", "u" },
8244                                 { "filter_policy", "u" },
8245                                 { "type", "u" },
8246                                 { "tx_power_level", "i" },
8247                                 { "slot_id", "i" }), NULL,
8248                         adapter_set_advertising_params) },
8249         { GDBUS_METHOD("SetAdvertisingData",
8250                         GDBUS_ARGS({ "value", "ay" },
8251                                 { "slot_id", "i" }), NULL,
8252                         adapter_set_advertising_data) },
8253         { GDBUS_METHOD("SetScanParameters",
8254                         GDBUS_ARGS({ "type", "u" },
8255                                 { "interval", "u" },
8256                                 { "window", "u" }), NULL,
8257                         adapter_le_set_scan_params) },
8258         { GDBUS_ASYNC_METHOD("scan_filter_param_setup",
8259                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
8260                                 { "filt_index", "i" }, { "feat_seln", "i"},
8261                                 { "list_logic_type", "i" }, { "filt_logic_type", "i"},
8262                                 { "rssi_high_thres", "i" }, { "rssi_low_thres", "i"},
8263                                 { "dely_mode", "i" }, { "found_timeout", "i"},
8264                                 { "lost_timeout", "i" }, { "found_timeout_cnt", "i"}), NULL,
8265                         adapter_le_scan_filter_param_setup) },
8266         { GDBUS_ASYNC_METHOD("scan_filter_add_remove",
8267                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
8268                                 { "filt_type", "i" }, { "filt_index", "i"},
8269                                 { "company_id", "i" }, { "company_id_mask", "i"},
8270                                 { "p_uuid", "ay" }, { "p_uuid_mask", "ay" },
8271                                 { "string", "s" }, { "address_type", "u" },
8272                                 /*{ "data_len", "i" },*/ { "p_data", "ay" },
8273                                 /*{ "mask_len", "i" },*/ { "p_mask", "ay" }), NULL,
8274                         adapter_le_scan_filter_add_remove) },
8275         { GDBUS_ASYNC_METHOD("scan_filter_clear",
8276                         GDBUS_ARGS({ "client_if", "i" }, { "filt_index", "i" }), NULL,
8277                         adapter_le_scan_filter_clear) },
8278         { GDBUS_ASYNC_METHOD("scan_filter_enable",
8279                         GDBUS_ARGS({ "client_if", "i" }, { "enable", "b" }), NULL,
8280                         adapter_le_scan_filter_enable) },
8281         { GDBUS_METHOD("InitializeIpsp",
8282                         NULL, NULL,
8283                         adapter_initialize_ipsp) },
8284         { GDBUS_METHOD("DeinitializeIpsp",
8285                         NULL, NULL,
8286                         adapter_deinitialize_ipsp) },
8287         { GDBUS_METHOD("SetScanRespData",
8288                         GDBUS_ARGS({ "value", "ay" },
8289                                 { "slot_id", "i" }), NULL,
8290                         adapter_set_scan_rsp_data) },
8291         { GDBUS_METHOD("AddDeviceWhiteList",
8292                         GDBUS_ARGS({ "address", "s" },
8293                                 { "address_type", "u" }), NULL,
8294                         adapter_add_device_white_list) },
8295         { GDBUS_METHOD("RemoveDeviceWhiteList",
8296                         GDBUS_ARGS({ "address", "s" },
8297                                 { "address_type", "u" }), NULL,
8298                         adapter_remove_device_white_list) },
8299         { GDBUS_METHOD("ClearDeviceWhiteList",
8300                         NULL, NULL,
8301                         adapter_clear_device_white_list) },
8302         { GDBUS_METHOD("SetLePrivacy",
8303                         GDBUS_ARGS({ "enable", "b" }), NULL,
8304                         adapter_set_le_privacy) },
8305         { GDBUS_METHOD("SetLeStaticRandomAddress",
8306                         GDBUS_ARGS({ "enable", "b" }), NULL,
8307                         adapter_set_le_static_address) },
8308         { GDBUS_ASYNC_METHOD("EnableRssi",
8309                         GDBUS_ARGS({ "bt_address", "s" },
8310                                 { "link_type", "i" },
8311                                 { "low_th", "i" },
8312                                 { "in_range_th", "i" },
8313                                 { "high_th", "i"}),
8314                         NULL,
8315                         adapter_enable_rssi) },
8316         { GDBUS_ASYNC_METHOD("GetRssiStrength",
8317                         GDBUS_ARGS({ "bt_address", "s" }, { "link_type", "i" }),
8318                         NULL,
8319                         adapter_get_rssi) },
8320         { GDBUS_ASYNC_METHOD("UnpairDevice",
8321                         GDBUS_ARGS({ "device", "o" }), NULL, adapter_unpair_device) },
8322         { GDBUS_METHOD("FindDevice",
8323                         GDBUS_ARGS({ "address", "s" }),
8324                         GDBUS_ARGS({ "device", "o" }),
8325                         find_device) },
8326         { GDBUS_METHOD("SetWbsParameters",
8327                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8328                         NULL,
8329                         set_wbs_parameters) },
8330         { GDBUS_METHOD("SetNbParameters",
8331                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8332                         NULL,
8333                         set_nb_parameters) },
8334         { GDBUS_METHOD("SetManufacturerData",
8335                         GDBUS_ARGS({ "value", "ay" }), NULL,
8336                         adapter_set_manufacturer_data) },
8337         { GDBUS_ASYNC_METHOD("CreateDevice",
8338                         GDBUS_ARGS({ "address", "s" }), NULL,
8339                         create_device) },
8340         { GDBUS_METHOD("GetEnergyInfo",
8341                         NULL,
8342                         GDBUS_ARGS({ "tx_time", "u" },
8343                                 { "rx_time", "u" },
8344                                 { "idle_time", "u" },
8345                                 { "energy_used", "u" }),
8346                         adapter_get_energy_info) },
8347 #endif
8348         { GDBUS_ASYNC_METHOD("RemoveDevice",
8349                         GDBUS_ARGS({ "device", "o" }), NULL, remove_device) },
8350 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8351         { GDBUS_ASYNC_METHOD("LEReadMaximumDataLength", NULL,
8352                         GDBUS_ARGS({"maxTxOctets", "q" }, { "maxTxTime", "q" },
8353                                 {"maxRxOctets", "q" }, { "maxRxTime", "q" }),
8354                         le_read_maximum_data_length)},
8355         { GDBUS_ASYNC_METHOD("LEWriteHostSuggestedDataLength",
8356                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }), NULL,
8357                         le_write_host_suggested_default_data_length)},
8358         { GDBUS_ASYNC_METHOD("LEReadHostSuggestedDataLength", NULL,
8359                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }),
8360                         le_read_host_suggested_default_data_length)},
8361         { GDBUS_ASYNC_METHOD("GetLeBatchingAvailablePkts",
8362                         NULL,
8363                         GDBUS_ARGS({ "AvailablePkts", "u" }),
8364                         adapter_get_le_batching_available_pkts) },
8365         { GDBUS_ASYNC_METHOD("EnableLeBatching",
8366                         GDBUS_ARGS({ "bt_address", "s" },
8367                                 { "packet_threshold", "i" },
8368                                 { "timeout", "i"}),
8369                         NULL,
8370                         adapter_enable_le_batching) },
8371         { GDBUS_ASYNC_METHOD("DisableLeBatching",
8372                         GDBUS_ARGS({ "bt_address", "s" }),
8373                         NULL,
8374                         adapter_disable_le_batching) },
8375 #endif
8376         { GDBUS_METHOD("GetDiscoveryFilters", NULL,
8377                         GDBUS_ARGS({ "filters", "as" }),
8378                         get_discovery_filters) },
8379         { GDBUS_EXPERIMENTAL_ASYNC_METHOD("ConnectDevice",
8380                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8381                                 connect_device) },
8382         { }
8383 };
8384
8385 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8386 static const GDBusSignalTable adapter_signals[] = {
8387         { GDBUS_SIGNAL("AdvertisingEnabled",
8388                         GDBUS_ARGS({ "slot_id", "i" },
8389                                         { "enabled", "b"})) },
8390         { GDBUS_SIGNAL("RssiEnabled",
8391                         GDBUS_ARGS({"address","s"},
8392                                         { "link_type", "i" },
8393                                         { "enabled", "b"})) },
8394         { GDBUS_SIGNAL("RssiAlert",
8395                         GDBUS_ARGS({"address","s"},
8396                                         { "link_type", "i" },
8397                                         { "alert_type", "i" },
8398                                         { "rssi_dbm", "i"})) },
8399         { GDBUS_SIGNAL("RawRssi",
8400                         GDBUS_ARGS({"address","s"},
8401                                         { "link_type", "i" },
8402                                         { "rssi_dbm", "i"})) },
8403         { GDBUS_SIGNAL("HardwareError", NULL) },
8404         { GDBUS_SIGNAL("TxTimeoutError", NULL) },
8405         { }
8406 };
8407 #endif
8408
8409 static const GDBusPropertyTable adapter_properties[] = {
8410         { "Address", "s", property_get_address },
8411         { "AddressType", "s", property_get_address_type },
8412         { "Name", "s", property_get_name },
8413         { "Alias", "s", property_get_alias, property_set_alias },
8414         { "Class", "u", property_get_class },
8415         { "Powered", "b", property_get_powered, property_set_powered },
8416         { "Discoverable", "b", property_get_discoverable,
8417                                         property_set_discoverable },
8418         { "DiscoverableTimeout", "u", property_get_discoverable_timeout,
8419                                         property_set_discoverable_timeout },
8420         { "Pairable", "b", property_get_pairable, property_set_pairable },
8421         { "PairableTimeout", "u", property_get_pairable_timeout,
8422                                         property_set_pairable_timeout },
8423         { "Discovering", "b", property_get_discovering },
8424 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8425         { "LEDiscovering", "b", property_get_le_discovering },
8426 #endif
8427         { "UUIDs", "as", property_get_uuids },
8428         { "Modalias", "s", property_get_modalias, NULL,
8429                                         property_exists_modalias },
8430         { "Roles", "as", property_get_roles },
8431         { "ExperimentalFeatures", "as", property_get_experimental, NULL,
8432                                         property_experimental_exits },
8433 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8434         { "Connectable", "b", property_get_connectable,
8435                                         property_set_connectable },
8436         { "Version", "s", property_get_version },
8437         { "SupportedLEFeatures", "as", property_get_supported_le_features},
8438         { "IpspInitStateChanged", "b", property_get_ipsp_init_state},
8439         { "LEAddress", "as", property_get_le_address },
8440         { "A2dpRole", "u", property_get_a2dp_role },
8441 #endif
8442
8443         { }
8444 };
8445
8446 static int str2buf(const char *str, uint8_t *buf, size_t blen)
8447 {
8448         int i, dlen;
8449
8450         if (str == NULL)
8451                 return -EINVAL;
8452
8453         memset(buf, 0, blen);
8454
8455         dlen = MIN((strlen(str) / 2), blen);
8456
8457         for (i = 0; i < dlen; i++)
8458                 sscanf(str + (i * 2), "%02hhX", &buf[i]);
8459
8460         return 0;
8461 }
8462
8463 static bool is_blocked_key(uint8_t key_type, uint8_t *key_value)
8464 {
8465         uint32_t i = 0;
8466
8467         for (i = 0; i < ARRAY_SIZE(blocked_keys); ++i) {
8468                 if (key_type == blocked_keys[i].type &&
8469                                 !memcmp(blocked_keys[i].val, key_value,
8470                                                 sizeof(blocked_keys[i].val)))
8471                         return true;
8472         }
8473
8474         return false;
8475 }
8476
8477 static struct link_key_info *get_key_info(GKeyFile *key_file, const char *peer)
8478 {
8479         struct link_key_info *info = NULL;
8480         char *str;
8481
8482         str = g_key_file_get_string(key_file, "LinkKey", "Key", NULL);
8483         if (!str || strlen(str) < 32)
8484                 goto failed;
8485
8486         info = g_new0(struct link_key_info, 1);
8487
8488         str2ba(peer, &info->bdaddr);
8489
8490         if (!strncmp(str, "0x", 2))
8491                 str2buf(&str[2], info->key, sizeof(info->key));
8492         else
8493                 str2buf(&str[0], info->key, sizeof(info->key));
8494
8495         info->type = g_key_file_get_integer(key_file, "LinkKey", "Type", NULL);
8496         info->pin_len = g_key_file_get_integer(key_file, "LinkKey", "PINLength",
8497                                                 NULL);
8498
8499         info->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8500                                                                 info->key);
8501
8502 failed:
8503         g_free(str);
8504
8505         return info;
8506 }
8507
8508 static struct smp_ltk_info *get_ltk(GKeyFile *key_file, const char *peer,
8509                                         uint8_t peer_type, const char *group)
8510 {
8511         struct smp_ltk_info *ltk = NULL;
8512         char *key;
8513         char *rand = NULL;
8514
8515         key = g_key_file_get_string(key_file, group, "Key", NULL);
8516         if (!key || strlen(key) < 32)
8517                 goto failed;
8518
8519         rand = g_key_file_get_string(key_file, group, "Rand", NULL);
8520         if (!rand)
8521                 goto failed;
8522
8523         ltk = g_new0(struct smp_ltk_info, 1);
8524
8525         /* Default to assuming a central key */
8526         ltk->central = true;
8527
8528         str2ba(peer, &ltk->bdaddr);
8529         ltk->bdaddr_type = peer_type;
8530
8531         /*
8532          * Long term keys should respond to an identity address which can
8533          * either be a public address or a random static address. Keys
8534          * stored for resolvable random and unresolvable random addresses
8535          * are ignored.
8536          *
8537          * This is an extra sanity check for older kernel versions or older
8538          * daemons that might have been instructed to store long term keys
8539          * for these temporary addresses.
8540          */
8541         if (ltk->bdaddr_type == BDADDR_LE_RANDOM &&
8542                                         (ltk->bdaddr.b[5] & 0xc0) != 0xc0) {
8543                 g_free(ltk);
8544                 ltk = NULL;
8545                 goto failed;
8546         }
8547
8548         if (!strncmp(key, "0x", 2))
8549                 str2buf(&key[2], ltk->val, sizeof(ltk->val));
8550         else
8551                 str2buf(&key[0], ltk->val, sizeof(ltk->val));
8552
8553         if (!strncmp(rand, "0x", 2)) {
8554                 uint64_t rand_le;
8555                 str2buf(&rand[2], (uint8_t *) &rand_le, sizeof(rand_le));
8556                 ltk->rand = le64_to_cpu(rand_le);
8557         } else {
8558                 sscanf(rand, "%" PRIu64, &ltk->rand);
8559         }
8560
8561         ltk->authenticated = g_key_file_get_integer(key_file, group,
8562                                                         "Authenticated", NULL);
8563         ltk->enc_size = g_key_file_get_integer(key_file, group, "EncSize",
8564                                                                         NULL);
8565         ltk->ediv = g_key_file_get_integer(key_file, group, "EDiv", NULL);
8566
8567         ltk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LTK,
8568                                                                 ltk->val);
8569
8570 failed:
8571         g_free(key);
8572         g_free(rand);
8573
8574         return ltk;
8575 }
8576
8577 static struct smp_ltk_info *get_ltk_info(GKeyFile *key_file, const char *peer,
8578                                                         uint8_t bdaddr_type)
8579 {
8580         DBG("%s", peer);
8581
8582         return get_ltk(key_file, peer, bdaddr_type, "LongTermKey");
8583 }
8584
8585 static struct smp_ltk_info *get_peripheral_ltk_info(GKeyFile *key_file,
8586                                                         const char *peer,
8587                                                         uint8_t bdaddr_type)
8588 {
8589         struct smp_ltk_info *ltk;
8590
8591         DBG("%s", peer);
8592
8593         /* Peripheral* is the proper term, but for now read both entries
8594          * so it won't break when user up/downgrades. Remove the other
8595          * term after a few releases.
8596          */
8597         ltk = get_ltk(key_file, peer, bdaddr_type, "PeripheralLongTermKey");
8598         if (!ltk)
8599                 ltk = get_ltk(key_file, peer, bdaddr_type, "SlaveLongTermKey");
8600
8601         if (ltk)
8602                 ltk->central = false;
8603
8604         return ltk;
8605 }
8606
8607 static struct irk_info *get_irk_info(GKeyFile *key_file, const char *peer,
8608                                                         uint8_t bdaddr_type)
8609 {
8610         struct irk_info *irk = NULL;
8611         char *str;
8612
8613         str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
8614 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8615         if (!str)
8616                 return NULL;
8617         if (strlen(str) < 32) {
8618                 g_free(str);
8619                 return NULL;
8620         }
8621 #else
8622         if (!str || strlen(str) < 32)
8623                 goto failed;
8624 #endif
8625
8626         irk = g_new0(struct irk_info, 1);
8627
8628         str2ba(peer, &irk->bdaddr);
8629         irk->bdaddr_type = bdaddr_type;
8630
8631         if (!strncmp(str, "0x", 2))
8632                 str2buf(&str[2], irk->val, sizeof(irk->val));
8633         else
8634                 str2buf(&str[0], irk->val, sizeof(irk->val));
8635
8636         irk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8637                                                                 irk->val);
8638
8639 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
8640 failed:
8641 #endif
8642         g_free(str);
8643
8644         return irk;
8645 }
8646
8647 static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
8648                                                         uint8_t bdaddr_type)
8649 {
8650         struct conn_param *param;
8651
8652         if (!g_key_file_has_group(key_file, "ConnectionParameters"))
8653                 return NULL;
8654
8655         param = g_new0(struct conn_param, 1);
8656
8657         param->min_interval = g_key_file_get_integer(key_file,
8658                                                         "ConnectionParameters",
8659                                                         "MinInterval", NULL);
8660         param->max_interval = g_key_file_get_integer(key_file,
8661                                                         "ConnectionParameters",
8662                                                         "MaxInterval", NULL);
8663         param->latency = g_key_file_get_integer(key_file,
8664                                                         "ConnectionParameters",
8665                                                         "Latency", NULL);
8666         param->timeout = g_key_file_get_integer(key_file,
8667                                                         "ConnectionParameters",
8668                                                         "Timeout", NULL);
8669         str2ba(peer, &param->bdaddr);
8670         param->bdaddr_type = bdaddr_type;
8671
8672         return param;
8673 }
8674
8675 #if 0
8676 static int generate_and_write_irk(uint8_t *irk, GKeyFile *key_file,
8677                                                         const char *filename)
8678 {
8679         struct bt_crypto *crypto;
8680         char str_irk_out[33];
8681         gsize length = 0;
8682         GError *gerr = NULL;
8683         char *str;
8684         int i;
8685
8686         crypto = bt_crypto_new();
8687         if (!crypto) {
8688                 error("Failed to open crypto");
8689                 return -1;
8690         }
8691
8692         if (!bt_crypto_random_bytes(crypto, irk, 16)) {
8693                 error("Failed to generate IRK");
8694                 bt_crypto_unref(crypto);
8695                 return -1;
8696         }
8697
8698         bt_crypto_unref(crypto);
8699
8700         for (i = 0; i < 16; i++)
8701                 sprintf(str_irk_out + (i * 2), "%02x", irk[i]);
8702
8703         str_irk_out[32] = '\0';
8704         info("Generated IRK successfully");
8705
8706         g_key_file_set_string(key_file, "General", "IdentityResolvingKey",
8707                                                                 str_irk_out);
8708         str = g_key_file_to_data(key_file, &length, NULL);
8709         if (!g_file_set_contents(filename, str, length, &gerr)) {
8710                 error("Unable set contents for %s: (%s)", filename,
8711                                                                 gerr->message);
8712                 g_error_free(gerr);
8713         }
8714         g_free(str);
8715         DBG("Generated IRK written to file");
8716         return 0;
8717 }
8718
8719 static int load_irk(struct btd_adapter *adapter, uint8_t *irk)
8720 {
8721         char filename[PATH_MAX];
8722         GKeyFile *key_file;
8723         GError *gerr = NULL;
8724         char *str_irk;
8725         int ret;
8726
8727         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/identity",
8728                                         btd_adapter_get_storage_dir(adapter));
8729
8730         key_file = g_key_file_new();
8731         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
8732                 error("Unable to load key file from %s: (%s)", filename,
8733                                                                 gerr->message);
8734                 g_error_free(gerr);
8735         }
8736
8737         str_irk = g_key_file_get_string(key_file, "General",
8738                                                 "IdentityResolvingKey", NULL);
8739         if (!str_irk) {
8740                 info("No IRK stored");
8741                 ret = generate_and_write_irk(irk, key_file, filename);
8742                 g_key_file_free(key_file);
8743                 return ret;
8744         }
8745
8746         g_key_file_free(key_file);
8747
8748         if (strlen(str_irk) != 32 || str2buf(str_irk, irk, 16)) {
8749                 /* TODO re-create new IRK here? */
8750                 error("Invalid IRK format, disabling privacy");
8751                 g_free(str_irk);
8752                 return -1;
8753         }
8754
8755         g_free(str_irk);
8756         DBG("Successfully read IRK from file");
8757         return 0;
8758 }
8759
8760 static void set_privacy_complete(uint8_t status, uint16_t length,
8761                                         const void *param, void *user_data)
8762 {
8763         struct btd_adapter *adapter = user_data;
8764
8765         if (status != MGMT_STATUS_SUCCESS) {
8766                 btd_error(adapter->dev_id, "Failed to set privacy: %s (0x%02x)",
8767                                                 mgmt_errstr(status), status);
8768                 return;
8769         }
8770
8771         DBG("Successfuly set privacy for index %u", adapter->dev_id);
8772 }
8773
8774 static int set_privacy(struct btd_adapter *adapter, uint8_t privacy)
8775 {
8776         struct mgmt_cp_set_privacy cp;
8777
8778         memset(&cp, 0, sizeof(cp));
8779
8780         if (privacy) {
8781                 uint8_t irk[16];
8782
8783                 if (load_irk(adapter, irk) == 0) {
8784                         cp.privacy = privacy;
8785                         memcpy(cp.irk, irk, 16);
8786                 }
8787         }
8788
8789         DBG("sending set privacy command for index %u", adapter->dev_id);
8790         DBG("setting privacy mode 0x%02x for index %u", cp.privacy,
8791                                                         adapter->dev_id);
8792
8793         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
8794                                 adapter->dev_id, sizeof(cp), &cp,
8795                                 set_privacy_complete, adapter, NULL) > 0)
8796                 return 0;
8797
8798         btd_error(adapter->dev_id, "Failed to set privacy for index %u",
8799                                                         adapter->dev_id);
8800
8801         return -1;
8802 }
8803 #endif
8804
8805 static void load_link_keys_complete(uint8_t status, uint16_t length,
8806                                         const void *param, void *user_data)
8807 {
8808         struct btd_adapter *adapter = user_data;
8809
8810         if (status != MGMT_STATUS_SUCCESS) {
8811                 btd_error(adapter->dev_id,
8812                         "Failed to load link keys for hci%u: %s (0x%02x)",
8813                                 adapter->dev_id, mgmt_errstr(status), status);
8814                 return;
8815         }
8816
8817         DBG("link keys loaded for hci%u", adapter->dev_id);
8818 }
8819
8820 static void load_link_keys(struct btd_adapter *adapter, GSList *keys,
8821                                                         bool debug_keys)
8822 {
8823         struct mgmt_cp_load_link_keys *cp;
8824         struct mgmt_link_key_info *key;
8825         size_t key_count, cp_size;
8826         unsigned int id;
8827         GSList *l;
8828
8829         /*
8830          * If the controller does not support BR/EDR operation,
8831          * there is no point in trying to load the link keys into
8832          * the kernel.
8833          *
8834          * This is an optimization for Low Energy only controllers.
8835          */
8836         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
8837                 return;
8838
8839         key_count = g_slist_length(keys);
8840
8841         DBG("hci%u keys %zu debug_keys %d", adapter->dev_id, key_count,
8842                                                                 debug_keys);
8843
8844         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
8845
8846         cp = g_try_malloc0(cp_size);
8847         if (cp == NULL) {
8848                 btd_error(adapter->dev_id, "No memory for link keys for hci%u",
8849                                                         adapter->dev_id);
8850                 return;
8851         }
8852
8853         /*
8854          * Even if the list of stored keys is empty, it is important to
8855          * load an empty list into the kernel. That way it is ensured
8856          * that no old keys from a previous daemon are present.
8857          *
8858          * In addition it is also the only way to toggle the different
8859          * behavior for debug keys.
8860          */
8861         cp->debug_keys = debug_keys;
8862         cp->key_count = htobs(key_count);
8863
8864         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
8865                 struct link_key_info *info = l->data;
8866
8867                 bacpy(&key->addr.bdaddr, &info->bdaddr);
8868                 key->addr.type = BDADDR_BREDR;
8869                 key->type = info->type;
8870                 memcpy(key->val, info->key, 16);
8871                 key->pin_len = info->pin_len;
8872         }
8873
8874         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_LINK_KEYS,
8875                                 adapter->dev_id, cp_size, cp,
8876                                 load_link_keys_complete, adapter, NULL);
8877
8878         g_free(cp);
8879
8880         if (id == 0)
8881                 btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
8882                                                         adapter->dev_id);
8883 }
8884
8885 static bool load_ltks_timeout(gpointer user_data)
8886 {
8887         struct btd_adapter *adapter = user_data;
8888
8889         btd_error(adapter->dev_id, "Loading LTKs timed out for hci%u",
8890                                                         adapter->dev_id);
8891
8892         adapter->load_ltks_timeout = 0;
8893
8894         mgmt_cancel(adapter->mgmt, adapter->load_ltks_id);
8895         adapter->load_ltks_id = 0;
8896
8897         return FALSE;
8898 }
8899
8900 static void load_ltks_complete(uint8_t status, uint16_t length,
8901                                         const void *param, void *user_data)
8902 {
8903         struct btd_adapter *adapter = user_data;
8904
8905         if (status != MGMT_STATUS_SUCCESS) {
8906                 btd_error(adapter->dev_id,
8907                                 "Failed to load LTKs for hci%u: %s (0x%02x)",
8908                                 adapter->dev_id, mgmt_errstr(status), status);
8909         }
8910
8911         adapter->load_ltks_id = 0;
8912
8913         timeout_remove(adapter->load_ltks_timeout);
8914         adapter->load_ltks_timeout = 0;
8915
8916         DBG("LTKs loaded for hci%u", adapter->dev_id);
8917 }
8918
8919 static void load_ltks(struct btd_adapter *adapter, GSList *keys)
8920 {
8921         struct mgmt_cp_load_long_term_keys *cp;
8922         struct mgmt_ltk_info *key;
8923         size_t key_count, max_key_count, cp_size;
8924         GSList *l;
8925         uint16_t mtu;
8926
8927         /*
8928          * If the controller does not support Low Energy operation,
8929          * there is no point in trying to load the long term keys
8930          * into the kernel.
8931          *
8932          * While there is no harm in loading keys into the kernel,
8933          * this is an optimization to avoid a confusing warning
8934          * message when the loading of the keys timed out due to
8935          * a kernel bug (see comment below).
8936          */
8937         if (!(adapter->supported_settings & MGMT_SETTING_LE))
8938                 return;
8939
8940         key_count = g_slist_length(keys);
8941         mtu = mgmt_get_mtu(adapter->mgmt);
8942         max_key_count = (mtu - sizeof(*cp)) / sizeof(*key);
8943         key_count = MIN(max_key_count, key_count);
8944
8945         DBG("hci%u keys %zu", adapter->dev_id, key_count);
8946
8947         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
8948
8949         cp = g_try_malloc0(cp_size);
8950         if (cp == NULL) {
8951                 btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
8952                                                         adapter->dev_id);
8953                 return;
8954         }
8955
8956         /*
8957          * Even if the list of stored keys is empty, it is important to
8958          * load an empty list into the kernel. That way it is ensured
8959          * that no old keys from a previous daemon are present.
8960          */
8961         cp->key_count = htobs(key_count);
8962
8963         for (l = keys, key = cp->keys; l && key_count;
8964                         l = g_slist_next(l), key++, key_count--) {
8965                 struct smp_ltk_info *info = l->data;
8966                 struct btd_device *dev;
8967
8968                 bacpy(&key->addr.bdaddr, &info->bdaddr);
8969                 key->addr.type = info->bdaddr_type;
8970                 memcpy(key->val, info->val, sizeof(info->val));
8971                 key->rand = cpu_to_le64(info->rand);
8972                 key->ediv = cpu_to_le16(info->ediv);
8973                 key->type = info->authenticated;
8974                 key->central = info->central;
8975                 key->enc_size = info->enc_size;
8976
8977                 /* Mark device as paired as their LTKs can be loaded. */
8978                 dev = btd_adapter_find_device(adapter, &info->bdaddr,
8979                                                         info->bdaddr_type);
8980                 if (dev) {
8981                         device_set_paired(dev, info->bdaddr_type);
8982                         device_set_bonded(dev, info->bdaddr_type);
8983                         device_set_ltk_enc_size(dev, info->enc_size);
8984                         device_set_ltk_enc_size(dev, info->enc_size);
8985                 }
8986         }
8987
8988         adapter->load_ltks_id = mgmt_send(adapter->mgmt,
8989                                         MGMT_OP_LOAD_LONG_TERM_KEYS,
8990                                         adapter->dev_id, cp_size, cp,
8991                                         load_ltks_complete, adapter, NULL);
8992
8993         g_free(cp);
8994
8995         if (adapter->load_ltks_id == 0) {
8996                 btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
8997                                                         adapter->dev_id);
8998                 return;
8999         }
9000
9001         /*
9002          * This timeout handling is needed since the kernel is stupid
9003          * and forgets to send a command complete response. However in
9004          * case of failures it does send a command status.
9005          */
9006         adapter->load_ltks_timeout = timeout_add_seconds(2,
9007                                                 load_ltks_timeout, adapter,
9008                                                 NULL);
9009 }
9010
9011 static void load_irks_complete(uint8_t status, uint16_t length,
9012                                         const void *param, void *user_data)
9013 {
9014         struct btd_adapter *adapter = user_data;
9015
9016         if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
9017                 btd_info(adapter->dev_id,
9018                         "Load IRKs failed: Kernel doesn't support LE Privacy");
9019                 return;
9020         }
9021
9022         if (status != MGMT_STATUS_SUCCESS) {
9023                 btd_error(adapter->dev_id,
9024                                 "Failed to load IRKs for hci%u: %s (0x%02x)",
9025                                 adapter->dev_id, mgmt_errstr(status), status);
9026                 return;
9027         }
9028
9029         DBG("IRKs loaded for hci%u", adapter->dev_id);
9030 }
9031
9032 static void load_irks(struct btd_adapter *adapter, GSList *irks)
9033 {
9034         struct mgmt_cp_load_irks *cp;
9035         struct mgmt_irk_info *irk;
9036         size_t irk_count, cp_size;
9037         unsigned int id;
9038         GSList *l;
9039
9040         /*
9041          * If the controller does not support LE Privacy operation,
9042          * there is no support for loading identity resolving keys
9043          * into the kernel.
9044          */
9045         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
9046                 return;
9047
9048         irk_count = g_slist_length(irks);
9049
9050         DBG("hci%u irks %zu", adapter->dev_id, irk_count);
9051
9052         cp_size = sizeof(*cp) + (irk_count * sizeof(*irk));
9053
9054         cp = g_try_malloc0(cp_size);
9055         if (cp == NULL) {
9056                 btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
9057                                                         adapter->dev_id);
9058                 return;
9059         }
9060
9061         /*
9062          * Even if the list of stored keys is empty, it is important to
9063          * load an empty list into the kernel. That way we tell the
9064          * kernel that we are able to handle New IRK events.
9065          */
9066         cp->irk_count = htobs(irk_count);
9067
9068         for (l = irks, irk = cp->irks; l != NULL; l = g_slist_next(l), irk++) {
9069                 struct irk_info *info = l->data;
9070
9071                 bacpy(&irk->addr.bdaddr, &info->bdaddr);
9072                 irk->addr.type = info->bdaddr_type;
9073                 memcpy(irk->val, info->val, sizeof(irk->val));
9074         }
9075
9076         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_IRKS, adapter->dev_id,
9077                         cp_size, cp, load_irks_complete, adapter, NULL);
9078
9079         g_free(cp);
9080
9081         if (id == 0)
9082                 btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
9083                                                         adapter->dev_id);
9084 }
9085
9086 static void load_conn_params_complete(uint8_t status, uint16_t length,
9087                                         const void *param, void *user_data)
9088 {
9089         struct btd_adapter *adapter = user_data;
9090
9091         if (status != MGMT_STATUS_SUCCESS) {
9092                 btd_error(adapter->dev_id,
9093                         "hci%u Load Connection Parameters failed: %s (0x%02x)",
9094                                 adapter->dev_id, mgmt_errstr(status), status);
9095                 return;
9096         }
9097
9098         DBG("Connection Parameters loaded for hci%u", adapter->dev_id);
9099 }
9100
9101 static void load_conn_params(struct btd_adapter *adapter, GSList *params)
9102 {
9103         struct mgmt_cp_load_conn_param *cp;
9104         struct mgmt_conn_param *param;
9105         size_t param_count, cp_size;
9106         unsigned int id;
9107         GSList *l;
9108
9109         /*
9110          * If the controller does not support Low Energy operation,
9111          * there is no point in trying to load the connection
9112          * parameters into the kernel.
9113          */
9114         if (!(adapter->supported_settings & MGMT_SETTING_LE))
9115                 return;
9116
9117         param_count = g_slist_length(params);
9118
9119         DBG("hci%u conn params %zu", adapter->dev_id, param_count);
9120
9121         cp_size = sizeof(*cp) + (param_count * sizeof(*param));
9122
9123         cp = g_try_malloc0(cp_size);
9124         if (cp == NULL) {
9125                 btd_error(adapter->dev_id,
9126                         "Failed to allocate memory for connection parameters");
9127                 return;
9128         }
9129
9130         cp->param_count = htobs(param_count);
9131
9132         for (l = params, param = cp->params; l; l = g_slist_next(l), param++) {
9133                 struct conn_param *info = l->data;
9134
9135                 bacpy(&param->addr.bdaddr, &info->bdaddr);
9136                 param->addr.type = info->bdaddr_type;
9137                 param->min_interval = htobs(info->min_interval);
9138                 param->max_interval = htobs(info->max_interval);
9139                 param->latency = htobs(info->latency);
9140                 param->timeout = htobs(info->timeout);
9141         }
9142
9143         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_PARAM, adapter->dev_id,
9144                         cp_size, cp, load_conn_params_complete, adapter, NULL);
9145
9146         g_free(cp);
9147
9148         if (id == 0)
9149                 btd_error(adapter->dev_id, "Load connection parameters failed");
9150 }
9151
9152 static uint8_t get_le_addr_type(GKeyFile *keyfile)
9153 {
9154         uint8_t addr_type;
9155         char *type;
9156
9157         type = g_key_file_get_string(keyfile, "General", "AddressType", NULL);
9158         if (!type)
9159                 return BDADDR_LE_PUBLIC;
9160
9161         if (g_str_equal(type, "public"))
9162                 addr_type = BDADDR_LE_PUBLIC;
9163         else if (g_str_equal(type, "static"))
9164                 addr_type = BDADDR_LE_RANDOM;
9165         else
9166                 addr_type = BDADDR_LE_PUBLIC;
9167
9168         g_free(type);
9169
9170         return addr_type;
9171 }
9172
9173 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9174 static uint8_t get_addr_type(GKeyFile *keyfile)
9175 {
9176         char **techno, **t;
9177         char *str;
9178         uint8_t bdaddr_type = BDADDR_BREDR;
9179         bool le = false;
9180
9181         /* Load device technology */
9182         techno = g_key_file_get_string_list(keyfile, "General",
9183                                         "SupportedTechnologies", NULL, NULL);
9184         if (!techno)
9185                 return 0xff;
9186
9187         for (t = techno; *t; t++) {
9188                 if (g_str_equal(*t, "LE"))
9189                         le = true;
9190         }
9191
9192         if (!le) {
9193                 bdaddr_type = BDADDR_BREDR;
9194         } else {
9195                 str = g_key_file_get_string(keyfile, "General",
9196                                                 "AddressType", NULL);
9197
9198                 if (str && g_str_equal(str, "public"))
9199                         bdaddr_type = BDADDR_LE_PUBLIC;
9200                 else if (str && g_str_equal(str, "static"))
9201                         bdaddr_type = BDADDR_LE_RANDOM;
9202                 else
9203                         error("Unknown LE device technology");
9204
9205                 g_free(str);
9206         }
9207
9208         g_strfreev(techno);
9209
9210         return bdaddr_type;
9211 }
9212 #endif
9213
9214 static void probe_devices(void *user_data)
9215 {
9216         struct btd_device *device = user_data;
9217
9218         device_probe_profiles(device, btd_device_get_uuids(device));
9219         device_resolved_drivers(device_get_adapter(device), device);
9220 }
9221
9222 static bool load_bredr_defaults(struct btd_adapter *adapter,
9223                                 struct mgmt_tlv_list *list,
9224                                 struct btd_br_defaults *defaults)
9225 {
9226         if (btd_opts.mode == BT_MODE_LE)
9227                 return true;
9228
9229         if (defaults->page_scan_type != 0xFFFF) {
9230                 if (!mgmt_tlv_add_fixed(list, 0x0000,
9231                                         &defaults->page_scan_type))
9232                         return false;
9233         }
9234
9235         if (defaults->page_scan_interval) {
9236                 if (!mgmt_tlv_add_fixed(list, 0x0001,
9237                                         &defaults->page_scan_interval))
9238                         return false;
9239         }
9240
9241         if (defaults->page_scan_win) {
9242                 if (!mgmt_tlv_add_fixed(list, 0x0002,
9243                                         &defaults->page_scan_win))
9244                         return false;
9245         }
9246
9247         if (defaults->scan_type != 0xFFFF) {
9248                 if (!mgmt_tlv_add_fixed(list, 0x0003,
9249                                         &defaults->scan_type))
9250                         return false;
9251         }
9252
9253         if (defaults->scan_interval) {
9254                 if (!mgmt_tlv_add_fixed(list, 0x0004,
9255                                         &defaults->scan_interval))
9256                         return false;
9257         }
9258
9259         if (defaults->scan_win) {
9260                 if (!mgmt_tlv_add_fixed(list, 0x0005,
9261                                         &defaults->scan_win))
9262                         return false;
9263         }
9264
9265         if (defaults->link_supervision_timeout) {
9266                 if (!mgmt_tlv_add_fixed(list, 0x0006,
9267                                         &defaults->link_supervision_timeout))
9268                         return false;
9269         }
9270
9271         if (defaults->page_timeout) {
9272                 if (!mgmt_tlv_add_fixed(list, 0x0007,
9273                                         &defaults->page_timeout))
9274                         return false;
9275         }
9276
9277         if (defaults->min_sniff_interval) {
9278                 if (!mgmt_tlv_add_fixed(list, 0x0008,
9279                                         &defaults->min_sniff_interval))
9280                         return false;
9281         }
9282
9283         if (defaults->max_sniff_interval) {
9284                 if (!mgmt_tlv_add_fixed(list, 0x0009,
9285                                         &defaults->max_sniff_interval))
9286                         return false;
9287         }
9288
9289         return true;
9290 }
9291
9292 static bool load_le_defaults(struct btd_adapter *adapter,
9293                                 struct mgmt_tlv_list *list,
9294                                 struct btd_le_defaults *defaults)
9295 {
9296         if (btd_opts.mode == BT_MODE_BREDR)
9297                 return true;
9298
9299         if (defaults->min_adv_interval) {
9300                 if (!mgmt_tlv_add_fixed(list, 0x000a,
9301                                         &defaults->min_adv_interval))
9302                         return false;
9303         }
9304
9305         if (defaults->max_adv_interval) {
9306                 if (!mgmt_tlv_add_fixed(list, 0x000b,
9307                                         &defaults->max_adv_interval))
9308                         return false;
9309         }
9310
9311         if (defaults->adv_rotation_interval) {
9312                 if (!mgmt_tlv_add_fixed(list, 0x000c,
9313                                         &defaults->adv_rotation_interval))
9314                         return false;
9315         }
9316
9317         if (defaults->scan_interval_autoconnect) {
9318                 if (!mgmt_tlv_add_fixed(list, 0x000d,
9319                                         &defaults->scan_interval_autoconnect))
9320                         return false;
9321         }
9322
9323         if (defaults->scan_win_autoconnect) {
9324                 if (!mgmt_tlv_add_fixed(list, 0x000e,
9325                                         &defaults->scan_win_autoconnect))
9326                         return false;
9327         }
9328
9329         if (defaults->scan_interval_suspend) {
9330                 if (!mgmt_tlv_add_fixed(list, 0x000f,
9331                                         &defaults->scan_interval_suspend))
9332                         return false;
9333         }
9334
9335         if (defaults->scan_win_suspend) {
9336                 if (!mgmt_tlv_add_fixed(list, 0x0010,
9337                                         &defaults->scan_win_suspend))
9338                         return false;
9339         }
9340
9341         if (defaults->scan_interval_discovery) {
9342                 if (!mgmt_tlv_add_fixed(list, 0x0011,
9343                                         &defaults->scan_interval_discovery))
9344                         return false;
9345         }
9346
9347         if (defaults->scan_win_discovery) {
9348                 if (!mgmt_tlv_add_fixed(list, 0x0012,
9349                                         &defaults->scan_win_discovery))
9350                         return false;
9351         }
9352
9353         if (defaults->scan_interval_adv_monitor) {
9354                 if (!mgmt_tlv_add_fixed(list, 0x0013,
9355                                         &defaults->scan_interval_adv_monitor))
9356                         return false;
9357         }
9358
9359         if (defaults->scan_win_adv_monitor) {
9360                 if (!mgmt_tlv_add_fixed(list, 0x0014,
9361                                         &defaults->scan_win_adv_monitor))
9362                         return false;
9363         }
9364
9365         if (defaults->scan_interval_connect) {
9366                 if (!mgmt_tlv_add_fixed(list, 0x0015,
9367                                         &defaults->scan_interval_connect))
9368                         return false;
9369         }
9370
9371         if (defaults->scan_win_connect) {
9372                 if (!mgmt_tlv_add_fixed(list, 0x0016,
9373                                         &defaults->scan_win_connect))
9374                         return false;
9375         }
9376
9377         if (defaults->min_conn_interval) {
9378                 if (!mgmt_tlv_add_fixed(list, 0x0017,
9379                                         &defaults->min_conn_interval))
9380                         return false;
9381         }
9382
9383         if (defaults->max_conn_interval) {
9384                 if (!mgmt_tlv_add_fixed(list, 0x0018,
9385                                         &defaults->max_conn_interval))
9386                         return false;
9387         }
9388
9389         if (defaults->conn_latency) {
9390                 if (!mgmt_tlv_add_fixed(list, 0x0019,
9391                                         &defaults->conn_latency))
9392                         return false;
9393         }
9394
9395         if (defaults->conn_lsto) {
9396                 if (!mgmt_tlv_add_fixed(list, 0x001a,
9397                                         &defaults->conn_lsto))
9398                         return false;
9399         }
9400
9401         if (defaults->autoconnect_timeout) {
9402                 if (!mgmt_tlv_add_fixed(list, 0x001b,
9403                                         &defaults->autoconnect_timeout))
9404                         return false;
9405         }
9406
9407         if (defaults->advmon_allowlist_scan_duration) {
9408                 if (!mgmt_tlv_add_fixed(list, 0x001d,
9409                                 &defaults->advmon_allowlist_scan_duration))
9410                         return false;
9411         }
9412
9413         if (defaults->advmon_no_filter_scan_duration) {
9414                 if (!mgmt_tlv_add_fixed(list, 0x001e,
9415                                 &defaults->advmon_no_filter_scan_duration))
9416                         return false;
9417         }
9418
9419         if (defaults->enable_advmon_interleave_scan != 0xFF) {
9420                 if (!mgmt_tlv_add_fixed(list, 0x001f,
9421                                 &defaults->enable_advmon_interleave_scan))
9422                         return false;
9423         }
9424
9425         return true;
9426 }
9427
9428 static void load_defaults(struct btd_adapter *adapter)
9429 {
9430         struct mgmt_tlv_list *list;
9431         unsigned int err = 0;
9432
9433         if (!btd_opts.defaults.num_entries ||
9434             !btd_has_kernel_features(KERNEL_SET_SYSTEM_CONFIG))
9435                 return;
9436
9437         list = mgmt_tlv_list_new();
9438
9439         if (!load_bredr_defaults(adapter, list, &btd_opts.defaults.br))
9440                 goto done;
9441
9442         if (!load_le_defaults(adapter, list, &btd_opts.defaults.le))
9443                 goto done;
9444
9445         err = mgmt_send_tlv(adapter->mgmt, MGMT_OP_SET_DEF_SYSTEM_CONFIG,
9446                         adapter->dev_id, list, NULL, NULL, NULL);
9447
9448 done:
9449         if (!err)
9450                 btd_error(adapter->dev_id,
9451                                 "Failed to set default system config for hci%u",
9452                                 adapter->dev_id);
9453
9454         mgmt_tlv_list_free(list);
9455 }
9456
9457 static void load_devices(struct btd_adapter *adapter)
9458 {
9459         char dirname[PATH_MAX];
9460         GSList *keys = NULL;
9461         GSList *ltks = NULL;
9462         GSList *irks = NULL;
9463         GSList *params = NULL;
9464         GSList *added_devices = NULL;
9465         GError *gerr = NULL;
9466         DIR *dir;
9467         struct dirent *entry;
9468
9469         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s",
9470                                         btd_adapter_get_storage_dir(adapter));
9471
9472         dir = opendir(dirname);
9473         if (!dir) {
9474                 btd_error(adapter->dev_id,
9475                                 "Unable to open adapter storage directory: %s",
9476                                                                 dirname);
9477                 return;
9478         }
9479
9480         while ((entry = readdir(dir)) != NULL) {
9481                 struct btd_device *device;
9482                 char filename[PATH_MAX];
9483                 GKeyFile *key_file;
9484 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9485                 struct link_key_info *key_info = NULL;
9486                 struct smp_ltk_info *ltk_info = NULL;
9487                 struct smp_ltk_info *peripheral_ltk_info;
9488                 GSList *list = NULL;
9489                 struct device_addr_type addr;
9490 #else
9491                 struct link_key_info *key_info;
9492                 struct smp_ltk_info *ltk_info;
9493                 struct smp_ltk_info *peripheral_ltk_info;
9494                 GSList *list;
9495 #endif
9496                 struct irk_info *irk_info;
9497                 struct conn_param *param;
9498                 uint8_t bdaddr_type;
9499
9500                 if (entry->d_type == DT_UNKNOWN)
9501                         entry->d_type = util_get_dt(dirname, entry->d_name);
9502
9503                 if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
9504                         continue;
9505
9506 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9507 {
9508                 bdaddr_t bdaddr;
9509
9510                 str2ba(entry->d_name, &bdaddr);
9511
9512                 if (!bacmp(&bdaddr, BDADDR_ANY)) {
9513                         error("No Bluetooth address");
9514                         continue;
9515                 }
9516 }
9517 #endif
9518                 snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
9519                                         btd_adapter_get_storage_dir(adapter),
9520                                         entry->d_name);
9521
9522                 key_file = g_key_file_new();
9523                 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
9524                         error("Unable to load key file from %s: (%s)", filename,
9525                                                                 gerr->message);
9526                         g_error_free(gerr);
9527                 }
9528
9529                 key_info = get_key_info(key_file, entry->d_name);
9530
9531                 bdaddr_type = get_le_addr_type(key_file);
9532
9533                 ltk_info = get_ltk_info(key_file, entry->d_name, bdaddr_type);
9534
9535                 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9536                                                 entry->d_name, bdaddr_type);
9537
9538                 irk_info = get_irk_info(key_file, entry->d_name, bdaddr_type);
9539
9540                 // If any key for the device is blocked, we discard all.
9541                 if ((key_info && key_info->is_blocked) ||
9542                                 (ltk_info && ltk_info->is_blocked) ||
9543                                 (peripheral_ltk_info &&
9544                                         peripheral_ltk_info->is_blocked) ||
9545                                 (irk_info && irk_info->is_blocked)) {
9546
9547                         if (key_info) {
9548                                 g_free(key_info);
9549                                 key_info = NULL;
9550                         }
9551
9552                         if (ltk_info) {
9553                                 g_free(ltk_info);
9554                                 ltk_info = NULL;
9555                         }
9556
9557                         if (peripheral_ltk_info) {
9558                                 g_free(peripheral_ltk_info);
9559                                 peripheral_ltk_info = NULL;
9560                         }
9561
9562                         if (irk_info) {
9563                                 g_free(irk_info);
9564                                 irk_info = NULL;
9565                         }
9566
9567                         goto free;
9568                 }
9569
9570                 if (key_info)
9571                         keys = g_slist_append(keys, key_info);
9572
9573                 if (ltk_info)
9574                         ltks = g_slist_append(ltks, ltk_info);
9575
9576                 if (peripheral_ltk_info)
9577                         ltks = g_slist_append(ltks, peripheral_ltk_info);
9578
9579                 if (irk_info)
9580                         irks = g_slist_append(irks, irk_info);
9581
9582                 param = get_conn_param(key_file, entry->d_name, bdaddr_type);
9583                 if (param)
9584                         params = g_slist_append(params, param);
9585
9586 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9587                 str2ba(entry->d_name, &addr.bdaddr);
9588                 addr.bdaddr_type = get_addr_type(key_file);
9589                 if (addr.bdaddr_type == 0xff) {
9590                         error("No SupportedTechnologies. Skipping");
9591                         goto free;
9592                 }
9593
9594                 list = g_slist_find_custom(adapter->devices, &addr,
9595                                                 device_addr_type_strict_cmp);
9596 #else
9597                 list = g_slist_find_custom(adapter->devices, entry->d_name,
9598                                                         device_address_cmp);
9599 #endif
9600                 if (list) {
9601 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9602                         DBG("Skip already loaded device [%s] [%d]",
9603                                         entry->d_name, addr.bdaddr_type);
9604 #endif
9605                         device = list->data;
9606                         goto device_exist;
9607                 }
9608
9609                 device = device_create_from_storage(adapter, entry->d_name,
9610                                                         key_file);
9611                 if (!device)
9612                         goto free;
9613
9614 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9615 {
9616                 char idaddr[18];
9617
9618                 /*
9619                  * After loading IRK information from file,
9620                  * store it into device->bdaddr.
9621                  * RPA is stored in device->rpa_addr
9622                  */
9623                 ba2str(device_get_address(device), idaddr);
9624
9625                 DBG("irk address: %s, rpa_exist %d",
9626                                 idaddr, device_get_rpa_exist(device));
9627
9628                 if (device_get_rpa_exist(device) == true) {
9629                         if (key_info)
9630                                 str2ba(idaddr, &key_info->bdaddr);
9631
9632                         if (ltk_info) {
9633                                 ltks = g_slist_remove(ltks, ltk_info);
9634                                 ltk_info = get_ltk_info(key_file,
9635                                                 idaddr, bdaddr_type);
9636                                 if (ltk_info)
9637                                         ltks = g_slist_append(ltks, ltk_info);
9638                         }
9639
9640                         if (peripheral_ltk_info) {
9641                                 ltks = g_slist_remove(ltks, peripheral_ltk_info);
9642                                 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9643                                                 idaddr, bdaddr_type);
9644                                 if (peripheral_ltk_info)
9645                                         ltks = g_slist_append(ltks, peripheral_ltk_info);
9646                         }
9647
9648                         if (irk_info) {
9649                                 str2ba(idaddr, &irk_info->bdaddr);
9650                                 device_set_irk_value(device, irk_info->val);
9651                         }
9652
9653                         if (param)
9654                                 str2ba(idaddr, &param->bdaddr);
9655                 }
9656 }
9657 #endif
9658
9659                 btd_device_set_temporary(device, false);
9660                 adapter_add_device(adapter, device);
9661
9662                 /* TODO: register services from pre-loaded list of primaries */
9663
9664                 added_devices = g_slist_append(added_devices, device);
9665
9666 device_exist:
9667                 if (key_info) {
9668                         device_set_paired(device, BDADDR_BREDR);
9669                         device_set_bonded(device, BDADDR_BREDR);
9670                 }
9671
9672 free:
9673                 g_key_file_free(key_file);
9674         }
9675
9676         closedir(dir);
9677
9678         load_link_keys(adapter, keys, btd_opts.debug_keys);
9679         g_slist_free_full(keys, g_free);
9680
9681         load_ltks(adapter, ltks);
9682         g_slist_free_full(ltks, g_free);
9683         load_irks(adapter, irks);
9684         g_slist_free_full(irks, g_free);
9685         load_conn_params(adapter, params);
9686         g_slist_free_full(params, g_free);
9687
9688         g_slist_free_full(added_devices, probe_devices);
9689 }
9690
9691 int btd_adapter_block_address(struct btd_adapter *adapter,
9692                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9693 {
9694         struct mgmt_cp_block_device cp;
9695         char addr[18];
9696
9697         ba2str(bdaddr, addr);
9698         DBG("hci%u %s", adapter->dev_id, addr);
9699
9700         memset(&cp, 0, sizeof(cp));
9701         bacpy(&cp.addr.bdaddr, bdaddr);
9702         cp.addr.type = bdaddr_type;
9703
9704         if (mgmt_send(adapter->mgmt, MGMT_OP_BLOCK_DEVICE,
9705                                 adapter->dev_id, sizeof(cp), &cp,
9706                                 NULL, NULL, NULL) > 0)
9707                 return 0;
9708
9709         return -EIO;
9710 }
9711
9712 int btd_adapter_unblock_address(struct btd_adapter *adapter,
9713                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9714 {
9715         struct mgmt_cp_unblock_device cp;
9716         char addr[18];
9717
9718         ba2str(bdaddr, addr);
9719         DBG("hci%u %s", adapter->dev_id, addr);
9720
9721         memset(&cp, 0, sizeof(cp));
9722         bacpy(&cp.addr.bdaddr, bdaddr);
9723         cp.addr.type = bdaddr_type;
9724
9725         if (mgmt_send(adapter->mgmt, MGMT_OP_UNBLOCK_DEVICE,
9726                                 adapter->dev_id, sizeof(cp), &cp,
9727                                 NULL, NULL, NULL) > 0)
9728                 return 0;
9729
9730         return -EIO;
9731 }
9732
9733 static int clear_blocked(struct btd_adapter *adapter)
9734 {
9735         return btd_adapter_unblock_address(adapter, BDADDR_ANY, 0);
9736 }
9737
9738 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
9739 {
9740         struct btd_adapter_driver *driver = user_data;
9741         int err;
9742
9743         if (driver->probe == NULL)
9744                 return;
9745
9746         err = driver->probe(adapter);
9747         if (err < 0) {
9748                 btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
9749                                                         strerror(-err), -err);
9750                 return;
9751         }
9752
9753         adapter->drivers = g_slist_prepend(adapter->drivers, driver);
9754 }
9755
9756 static void load_drivers(struct btd_adapter *adapter)
9757 {
9758         GSList *l;
9759
9760         for (l = adapter_drivers; l; l = l->next)
9761                 probe_driver(adapter, l->data);
9762 }
9763
9764 static void probe_profile(struct btd_profile *profile, void *data)
9765 {
9766         struct btd_adapter *adapter = data;
9767         int err;
9768
9769         if (profile->adapter_probe == NULL)
9770                 return;
9771
9772         err = profile->adapter_probe(profile, adapter);
9773         if (err < 0) {
9774                 btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
9775                                                         strerror(-err), -err);
9776                 return;
9777         }
9778
9779         adapter->profiles = g_slist_prepend(adapter->profiles, profile);
9780 }
9781
9782 void adapter_add_profile(struct btd_adapter *adapter, gpointer p)
9783 {
9784         struct btd_profile *profile = p;
9785
9786         if (!adapter->initialized)
9787                 return;
9788
9789         probe_profile(profile, adapter);
9790
9791         g_slist_foreach(adapter->devices, device_probe_profile, profile);
9792 }
9793
9794 void adapter_remove_profile(struct btd_adapter *adapter, gpointer p)
9795 {
9796         struct btd_profile *profile = p;
9797
9798         if (!adapter->initialized)
9799                 return;
9800
9801         if (profile->device_remove)
9802                 g_slist_foreach(adapter->devices, device_remove_profile, p);
9803
9804         adapter->profiles = g_slist_remove(adapter->profiles, profile);
9805
9806         if (profile->adapter_remove)
9807                 profile->adapter_remove(profile, adapter);
9808 }
9809
9810 static void device_added_drivers(struct btd_adapter *adapter,
9811                                                 struct btd_device *device)
9812 {
9813         struct btd_adapter_driver *driver;
9814         GSList *l;
9815
9816         for (l = adapter_drivers; l; l = l->next) {
9817                 driver = l->data;
9818
9819                 if (driver->device_added)
9820                         driver->device_added(adapter, device);
9821         }
9822 }
9823
9824 static void device_removed_drivers(struct btd_adapter *adapter,
9825                                                 struct btd_device *device)
9826 {
9827         struct btd_adapter_driver *driver;
9828         GSList *l;
9829
9830         for (l = adapter_drivers; l; l = l->next) {
9831                 driver = l->data;
9832
9833                 if (driver->device_removed)
9834                         driver->device_removed(adapter, device);
9835         }
9836 }
9837
9838 void device_resolved_drivers(struct btd_adapter *adapter,
9839                                                 struct btd_device *device)
9840 {
9841         struct btd_adapter_driver *driver;
9842         GSList *l;
9843
9844         for (l = adapter_drivers; l; l = l->next) {
9845                 driver = l->data;
9846
9847                 if (driver->device_resolved)
9848                         driver->device_resolved(adapter, device);
9849         }
9850 }
9851
9852 static void adapter_add_device(struct btd_adapter *adapter,
9853                                                 struct btd_device *device)
9854 {
9855         adapter->devices = g_slist_append(adapter->devices, device);
9856         device_added_drivers(adapter, device);
9857 }
9858
9859 static void adapter_remove_device(struct btd_adapter *adapter,
9860                                                 struct btd_device *device)
9861 {
9862         adapter->devices = g_slist_remove(adapter->devices, device);
9863         device_removed_drivers(adapter, device);
9864 }
9865
9866 static void adapter_add_connection(struct btd_adapter *adapter,
9867                                                 struct btd_device *device,
9868                                                 uint8_t bdaddr_type)
9869 {
9870         device_add_connection(device, bdaddr_type);
9871
9872         if (g_slist_find(adapter->connections, device)) {
9873                 btd_error(adapter->dev_id,
9874                                 "Device is already marked as connected");
9875                 return;
9876         }
9877
9878         adapter->connections = g_slist_append(adapter->connections, device);
9879 }
9880
9881 static void get_connections_complete(uint8_t status, uint16_t length,
9882                                         const void *param, void *user_data)
9883 {
9884         struct btd_adapter *adapter = user_data;
9885         const struct mgmt_rp_get_connections *rp = param;
9886         uint16_t i, conn_count;
9887
9888         if (status != MGMT_STATUS_SUCCESS) {
9889                 btd_error(adapter->dev_id,
9890                                 "Failed to get connections: %s (0x%02x)",
9891                                                 mgmt_errstr(status), status);
9892                 return;
9893         }
9894
9895         if (length < sizeof(*rp)) {
9896                 btd_error(adapter->dev_id,
9897                                 "Wrong size of get connections response");
9898                 return;
9899         }
9900
9901         conn_count = btohs(rp->conn_count);
9902
9903         DBG("Connection count: %d", conn_count);
9904
9905         if (conn_count * sizeof(struct mgmt_addr_info) +
9906                                                 sizeof(*rp) != length) {
9907                 btd_error(adapter->dev_id,
9908                         "Incorrect packet size for get connections response");
9909                 return;
9910         }
9911
9912         for (i = 0; i < conn_count; i++) {
9913                 const struct mgmt_addr_info *addr = &rp->addr[i];
9914                 struct btd_device *device;
9915                 char address[18];
9916
9917                 ba2str(&addr->bdaddr, address);
9918                 DBG("Adding existing connection to %s", address);
9919
9920                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
9921                                                                 addr->type);
9922                 if (device)
9923                         adapter_add_connection(adapter, device, addr->type);
9924         }
9925 }
9926
9927 static void load_connections(struct btd_adapter *adapter)
9928 {
9929         DBG("sending get connections command for index %u", adapter->dev_id);
9930
9931         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_CONNECTIONS,
9932                                 adapter->dev_id, 0, NULL,
9933                                 get_connections_complete, adapter, NULL) > 0)
9934                 return;
9935
9936         btd_error(adapter->dev_id, "Failed to get connections for index %u",
9937                                                         adapter->dev_id);
9938 }
9939
9940 bool btd_adapter_get_pairable(struct btd_adapter *adapter)
9941 {
9942         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
9943                 return true;
9944
9945         return false;
9946 }
9947
9948 bool btd_adapter_get_powered(struct btd_adapter *adapter)
9949 {
9950         if ((adapter->current_settings & MGMT_SETTING_POWERED) &&
9951                         !(adapter->pending_settings & MGMT_SETTING_POWERED))
9952                 return true;
9953
9954         return false;
9955 }
9956
9957 bool btd_adapter_get_connectable(struct btd_adapter *adapter)
9958 {
9959         if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
9960                 return true;
9961
9962         return false;
9963 }
9964
9965 bool btd_adapter_get_discoverable(struct btd_adapter *adapter)
9966 {
9967         if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
9968                 return true;
9969
9970         return false;
9971 }
9972
9973 bool btd_adapter_get_bredr(struct btd_adapter *adapter)
9974 {
9975         if (adapter->current_settings & MGMT_SETTING_BREDR)
9976                 return true;
9977
9978         return false;
9979 }
9980
9981 struct btd_gatt_database *btd_adapter_get_database(struct btd_adapter *adapter)
9982 {
9983         if (!adapter)
9984                 return NULL;
9985
9986         return adapter->database;
9987 }
9988
9989 uint32_t btd_adapter_get_class(struct btd_adapter *adapter)
9990 {
9991         return adapter->dev_class;
9992 }
9993
9994 const char *btd_adapter_get_name(struct btd_adapter *adapter)
9995 {
9996         if (adapter->stored_alias)
9997                 return adapter->stored_alias;
9998
9999         if (adapter->system_name)
10000                 return adapter->system_name;
10001
10002         return NULL;
10003 }
10004
10005 int adapter_connect_list_add(struct btd_adapter *adapter,
10006                                         struct btd_device *device)
10007 {
10008         /*
10009          * If the adapter->connect_le device is getting added back to
10010          * the connect list it probably means that the connect attempt
10011          * failed and hence we should clear this pointer
10012          */
10013         if (device == adapter->connect_le)
10014                 adapter->connect_le = NULL;
10015
10016         /*
10017          * If kernel background scanning is supported then the
10018          * adapter_auto_connect_add() function is used to maintain what to
10019          * connect.
10020          */
10021         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10022                 return 0;
10023
10024         if (g_slist_find(adapter->connect_list, device)) {
10025                 DBG("ignoring already added device %s",
10026                                                 device_get_path(device));
10027                 goto done;
10028         }
10029
10030         if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
10031                 btd_error(adapter->dev_id,
10032                         "Can't add %s to non-LE capable adapter connect list",
10033                                                 device_get_path(device));
10034                 return -ENOTSUP;
10035         }
10036
10037         adapter->connect_list = g_slist_append(adapter->connect_list, device);
10038         DBG("%s added to %s's connect_list", device_get_path(device),
10039                                                         adapter->system_name);
10040
10041 done:
10042         if (!btd_adapter_get_powered(adapter))
10043                 return 0;
10044
10045         trigger_passive_scanning(adapter);
10046
10047         return 0;
10048 }
10049
10050 void adapter_connect_list_remove(struct btd_adapter *adapter,
10051                                         struct btd_device *device)
10052 {
10053         /*
10054          * If the adapter->connect_le device is being removed from the
10055          * connect list it means the connection was successful and hence
10056          * the pointer should be cleared
10057          */
10058         if (device == adapter->connect_le)
10059                 adapter->connect_le = NULL;
10060
10061         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10062                 return;
10063
10064         if (!g_slist_find(adapter->connect_list, device)) {
10065                 DBG("device %s is not on the list, ignoring",
10066                                                 device_get_path(device));
10067                 return;
10068         }
10069
10070         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10071         DBG("%s removed from %s's connect_list", device_get_path(device),
10072                                                         adapter->system_name);
10073
10074         if (!adapter->connect_list) {
10075                 stop_passive_scanning(adapter);
10076                 return;
10077         }
10078
10079         if (!btd_adapter_get_powered(adapter))
10080                 return;
10081
10082         trigger_passive_scanning(adapter);
10083 }
10084
10085 static void add_accept_list_complete(uint8_t status, uint16_t length,
10086                                         const void *param, void *user_data)
10087 {
10088         const struct mgmt_rp_add_device *rp = param;
10089         struct btd_adapter *adapter = user_data;
10090         struct btd_device *dev;
10091         char addr[18];
10092
10093         if (length < sizeof(*rp)) {
10094                 btd_error(adapter->dev_id,
10095                                 "Too small Add Device complete event");
10096                 return;
10097         }
10098
10099         ba2str(&rp->addr.bdaddr, addr);
10100
10101         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10102                                                         rp->addr.type);
10103         if (!dev) {
10104                 btd_error(adapter->dev_id,
10105                         "Add Device complete for unknown device %s", addr);
10106                 return;
10107         }
10108
10109         if (status != MGMT_STATUS_SUCCESS) {
10110                 btd_error(adapter->dev_id,
10111                                         "Failed to add device %s: %s (0x%02x)",
10112                                         addr, mgmt_errstr(status), status);
10113                 return;
10114         }
10115
10116         DBG("%s added to kernel accept list", addr);
10117 }
10118
10119 void adapter_accept_list_add(struct btd_adapter *adapter,
10120                                                         struct btd_device *dev)
10121 {
10122         struct mgmt_cp_add_device cp;
10123
10124         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10125                 return;
10126
10127         memset(&cp, 0, sizeof(cp));
10128         bacpy(&cp.addr.bdaddr, device_get_address(dev));
10129         cp.addr.type = BDADDR_BREDR;
10130         cp.action = 0x01;
10131
10132         mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10133                                 adapter->dev_id, sizeof(cp), &cp,
10134                                 add_accept_list_complete, adapter, NULL);
10135 }
10136
10137 static void remove_accept_list_complete(uint8_t status, uint16_t length,
10138                                         const void *param, void *user_data)
10139 {
10140         const struct mgmt_rp_remove_device *rp = param;
10141         char addr[18];
10142
10143         if (length < sizeof(*rp)) {
10144                 error("Too small Remove Device complete event");
10145                 return;
10146         }
10147
10148         ba2str(&rp->addr.bdaddr, addr);
10149
10150         if (status != MGMT_STATUS_SUCCESS) {
10151                 error("Failed to remove device %s: %s (0x%02x)",
10152                                         addr, mgmt_errstr(status), status);
10153                 return;
10154         }
10155
10156         DBG("%s removed from kernel accept list", addr);
10157 }
10158
10159 void adapter_accept_list_remove(struct btd_adapter *adapter,
10160                                                         struct btd_device *dev)
10161 {
10162         struct mgmt_cp_remove_device cp;
10163
10164         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10165                 return;
10166
10167         memset(&cp, 0, sizeof(cp));
10168         bacpy(&cp.addr.bdaddr, device_get_address(dev));
10169         cp.addr.type = BDADDR_BREDR;
10170
10171         mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10172                                 adapter->dev_id, sizeof(cp), &cp,
10173                                 remove_accept_list_complete, adapter, NULL);
10174 }
10175
10176 static void set_device_privacy_complete(uint8_t status, uint16_t length,
10177                                          const void *param, void *user_data)
10178 {
10179         const struct mgmt_rp_set_device_flags *rp = param;
10180
10181         if (status != MGMT_STATUS_SUCCESS) {
10182                 error("Set device flags return status: %s",
10183                                         mgmt_errstr(status));
10184                 return;
10185         }
10186
10187         if (length < sizeof(*rp)) {
10188                 error("Too small Set Device Flags complete event: %d", length);
10189                 return;
10190         }
10191 }
10192
10193 static void add_device_complete(uint8_t status, uint16_t length,
10194                                         const void *param, void *user_data)
10195 {
10196         const struct mgmt_rp_add_device *rp = param;
10197         struct btd_adapter *adapter = user_data;
10198         struct btd_device *dev;
10199         char addr[18];
10200
10201         if (length < sizeof(*rp)) {
10202                 btd_error(adapter->dev_id,
10203                                 "Too small Add Device complete event");
10204                 return;
10205         }
10206
10207         ba2str(&rp->addr.bdaddr, addr);
10208
10209         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10210                                                         rp->addr.type);
10211         if (!dev) {
10212                 btd_error(adapter->dev_id,
10213                         "Add Device complete for unknown device %s", addr);
10214                 return;
10215         }
10216
10217         if (status != MGMT_STATUS_SUCCESS) {
10218                 btd_error(adapter->dev_id,
10219                         "Failed to add device %s (%u): %s (0x%02x)",
10220                         addr, rp->addr.type, mgmt_errstr(status), status);
10221                 adapter->connect_list = g_slist_remove(adapter->connect_list,
10222                                                                         dev);
10223                 return;
10224         }
10225
10226         DBG("%s (%u) added to kernel connect list", addr, rp->addr.type);
10227
10228         if (btd_opts.device_privacy) {
10229                 uint32_t flags = btd_device_get_current_flags(dev);
10230
10231                 /* Set Device Privacy Mode has not set the flag yet. */
10232                 if (!(flags & DEVICE_FLAG_DEVICE_PRIVACY)) {
10233                         adapter_set_device_flags(adapter, dev, flags |
10234                                                 DEVICE_FLAG_DEVICE_PRIVACY,
10235                                                 set_device_privacy_complete,
10236                                                 NULL);
10237                 }
10238         }
10239 }
10240
10241 void adapter_auto_connect_add(struct btd_adapter *adapter,
10242                                         struct btd_device *device)
10243 {
10244         struct mgmt_cp_add_device cp;
10245         const bdaddr_t *bdaddr;
10246         uint8_t bdaddr_type;
10247         unsigned int id;
10248
10249         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10250                 return;
10251
10252         if (g_slist_find(adapter->connect_list, device)) {
10253                 DBG("ignoring already added device %s",
10254                                                 device_get_path(device));
10255                 return;
10256         }
10257
10258         bdaddr = device_get_address(device);
10259         bdaddr_type = btd_device_get_bdaddr_type(device);
10260
10261         if (bdaddr_type == BDADDR_BREDR) {
10262                 DBG("auto-connection feature is not avaiable for BR/EDR");
10263                 return;
10264         }
10265
10266         memset(&cp, 0, sizeof(cp));
10267         bacpy(&cp.addr.bdaddr, bdaddr);
10268         cp.addr.type = bdaddr_type;
10269         cp.action = 0x02;
10270
10271         id = mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10272                         adapter->dev_id, sizeof(cp), &cp, add_device_complete,
10273                         adapter, NULL);
10274         if (id == 0)
10275                 return;
10276
10277         adapter->connect_list = g_slist_append(adapter->connect_list, device);
10278 }
10279
10280 void adapter_set_device_flags(struct btd_adapter *adapter,
10281                                 struct btd_device *device, uint32_t flags,
10282                                 mgmt_request_func_t func, void *user_data)
10283 {
10284         struct mgmt_cp_set_device_flags cp;
10285         const bdaddr_t *bdaddr;
10286         uint8_t bdaddr_type;
10287
10288         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10289                 return;
10290
10291         bdaddr = device_get_address(device);
10292         bdaddr_type = btd_device_get_bdaddr_type(device);
10293
10294         memset(&cp, 0, sizeof(cp));
10295         bacpy(&cp.addr.bdaddr, bdaddr);
10296         cp.addr.type = bdaddr_type;
10297         cp.current_flags = cpu_to_le32(flags);
10298
10299         mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_FLAGS, adapter->dev_id,
10300                   sizeof(cp), &cp, func, user_data, NULL);
10301 }
10302
10303 static void device_flags_changed_callback(uint16_t index, uint16_t length,
10304                                           const void *param, void *user_data)
10305 {
10306         const struct mgmt_ev_device_flags_changed *ev = param;
10307         struct btd_adapter *adapter = user_data;
10308         struct btd_device *dev;
10309         char addr[18];
10310
10311         if (length < sizeof(*ev)) {
10312                 btd_error(adapter->dev_id,
10313                           "Too small Device Flags Changed event: %d",
10314                           length);
10315                 return;
10316         }
10317
10318         ba2str(&ev->addr.bdaddr, addr);
10319
10320         dev = btd_adapter_find_device(adapter, &ev->addr.bdaddr, ev->addr.type);
10321         if (!dev) {
10322                 btd_error(adapter->dev_id,
10323                         "Device Flags Changed for unknown device %s", addr);
10324                 return;
10325         }
10326
10327         btd_device_flags_changed(dev, ev->supported_flags, ev->current_flags);
10328 }
10329
10330
10331 static void remove_device_complete(uint8_t status, uint16_t length,
10332                                         const void *param, void *user_data)
10333 {
10334         const struct mgmt_rp_remove_device *rp = param;
10335         char addr[18];
10336
10337         if (length < sizeof(*rp)) {
10338                 error("Too small Remove Device complete event");
10339                 return;
10340         }
10341
10342         ba2str(&rp->addr.bdaddr, addr);
10343
10344         if (status != MGMT_STATUS_SUCCESS) {
10345                 error("Failed to remove device %s (%u): %s (0x%02x)",
10346                         addr, rp->addr.type, mgmt_errstr(status), status);
10347                 return;
10348         }
10349
10350         DBG("%s (%u) removed from kernel connect list", addr, rp->addr.type);
10351 }
10352
10353 void adapter_auto_connect_remove(struct btd_adapter *adapter,
10354                                         struct btd_device *device)
10355 {
10356         struct mgmt_cp_remove_device cp;
10357         const bdaddr_t *bdaddr;
10358         uint8_t bdaddr_type;
10359         unsigned int id;
10360
10361         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10362                 return;
10363
10364         if (!g_slist_find(adapter->connect_list, device)) {
10365                 DBG("ignoring not added device %s", device_get_path(device));
10366                 return;
10367         }
10368
10369         bdaddr = device_get_address(device);
10370         bdaddr_type = btd_device_get_bdaddr_type(device);
10371
10372         if (bdaddr_type == BDADDR_BREDR) {
10373                 DBG("auto-connection feature is not avaiable for BR/EDR");
10374                 return;
10375         }
10376
10377         memset(&cp, 0, sizeof(cp));
10378         bacpy(&cp.addr.bdaddr, bdaddr);
10379         cp.addr.type = bdaddr_type;
10380
10381         id = mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10382                         adapter->dev_id, sizeof(cp), &cp,
10383                         remove_device_complete, adapter, NULL);
10384         if (id == 0)
10385                 return;
10386
10387         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10388 }
10389
10390 #if defined (TIZEN_FEATURE_BLUEZ_MODIFY)
10391 static void get_phy_configuration_resp(uint8_t status, uint16_t len, const void *param,
10392                                                         void *user_data)
10393 {
10394         uint32_t supported_phys;
10395         uint32_t configurable_phys;
10396         uint32_t selected_phys;
10397
10398         const struct mgmt_rp_get_phy_confguration *rp = param;
10399         struct btd_adapter *adapter = user_data;
10400
10401         if (status != MGMT_STATUS_SUCCESS) {
10402                 error("Get PHY Configuration failed with status 0x%02x (%s)",
10403                                 status, mgmt_errstr(status));
10404                 return;
10405         }
10406
10407         if (len < sizeof(*rp)) {
10408                 error("Too small get-phy reply (%u bytes)", len);
10409                 return;
10410         }
10411
10412         supported_phys = get_le32(&rp->supported_phys);
10413         configurable_phys = get_le32(&rp-> configurable_phys);
10414         selected_phys = get_le16(&rp->selected_phys);
10415
10416         DBG("Supported phys: [0x%x]", supported_phys);
10417         DBG("Configurable phys: [0x%x]", configurable_phys);
10418         DBG("Selected phys: [0x%x]", selected_phys);
10419
10420         if (adapter->supported_settings & MGMT_SETTING_LE) {
10421                 if ((supported_phys & MGMT_PHY_LE_2M_TX) &&
10422                                 (supported_phys & MGMT_PHY_LE_2M_RX)) {
10423                         DBG("Adapter supports LE 2M PHY");
10424                         adapter->le_2m_phy_supported = TRUE;
10425                 } else
10426                         DBG("Adapter does not support LE 2M PHY");
10427
10428                 if ((supported_phys & MGMT_PHY_LE_CODED_TX) &&
10429                                 (supported_phys & MGMT_PHY_LE_CODED_RX)) {
10430                         adapter->le_coded_phy_supported = TRUE;
10431                         DBG("Adapter supports LE CODED PHY");
10432                 } else
10433                         DBG("Adapter does not support LE CODED PHY");
10434         }
10435
10436         /* Emit Property Changed Signal */
10437          g_dbus_emit_property_changed(dbus_conn, adapter->path,
10438                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10439
10440 }
10441 #endif
10442
10443 static void adapter_start(struct btd_adapter *adapter)
10444 {
10445
10446 #if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__SPRD_PATCH__)
10447         if (adapter_le_read_ble_feature_info())
10448                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10449                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10450 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
10451         else
10452                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10453                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10454 #endif
10455
10456         adapter_get_adv_tx_power(adapter);
10457
10458         /* By default enable offloading for testing, this should be modified */
10459         if (adapter_le_is_supported_offloading())
10460                 adapter_le_enable_offloading(TRUE);
10461 #endif
10462
10463 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
10464         g_dbus_emit_property_changed(dbus_conn, adapter->path,
10465                                                 ADAPTER_INTERFACE, "Powered");
10466 #else
10467         g_dbus_emit_property_changed_full(dbus_conn, adapter->path,
10468                                                 ADAPTER_INTERFACE, "Powered", 1);
10469 #endif
10470
10471         DBG("adapter %s has been enabled", adapter->path);
10472
10473         trigger_passive_scanning(adapter);
10474 }
10475
10476 static void reply_pending_requests(struct btd_adapter *adapter)
10477 {
10478         GSList *l;
10479
10480         if (!adapter)
10481                 return;
10482
10483         /* pending bonding */
10484         for (l = adapter->devices; l; l = l->next) {
10485                 struct btd_device *device = l->data;
10486
10487                 if (device_is_bonding(device, NULL))
10488                         device_bonding_failed(device,
10489                                                 HCI_OE_USER_ENDED_CONNECTION);
10490         }
10491 }
10492
10493 static void remove_driver(gpointer data, gpointer user_data)
10494 {
10495         struct btd_adapter_driver *driver = data;
10496         struct btd_adapter *adapter = user_data;
10497
10498         if (driver->remove)
10499                 driver->remove(adapter);
10500 }
10501
10502 static void remove_profile(gpointer data, gpointer user_data)
10503 {
10504         struct btd_profile *profile = data;
10505         struct btd_adapter *adapter = user_data;
10506
10507         if (profile->adapter_remove)
10508                 profile->adapter_remove(profile, adapter);
10509 }
10510
10511 static void unload_drivers(struct btd_adapter *adapter)
10512 {
10513         g_slist_foreach(adapter->drivers, remove_driver, adapter);
10514         g_slist_free(adapter->drivers);
10515         adapter->drivers = NULL;
10516
10517         g_slist_foreach(adapter->profiles, remove_profile, adapter);
10518         g_slist_free(adapter->profiles);
10519         adapter->profiles = NULL;
10520 }
10521
10522 static void free_service_auth(gpointer data, gpointer user_data)
10523 {
10524         struct service_auth *auth = data;
10525
10526         g_free(auth);
10527 }
10528
10529 static void remove_discovery_list(struct btd_adapter *adapter)
10530 {
10531         g_slist_free_full(adapter->set_filter_list, discovery_free);
10532         adapter->set_filter_list = NULL;
10533
10534         g_slist_free_full(adapter->discovery_list, discovery_free);
10535         adapter->discovery_list = NULL;
10536 }
10537
10538 static void adapter_free(gpointer user_data)
10539 {
10540         struct btd_adapter *adapter = user_data;
10541
10542         DBG("%p", adapter);
10543
10544         /* Make sure the adapter's discovery list is cleaned up before freeing
10545          * the adapter.
10546          */
10547         remove_discovery_list(adapter);
10548
10549         if (adapter->pairable_timeout_id > 0) {
10550                 timeout_remove(adapter->pairable_timeout_id);
10551                 adapter->pairable_timeout_id = 0;
10552         }
10553
10554         if (adapter->passive_scan_timeout > 0) {
10555                 timeout_remove(adapter->passive_scan_timeout);
10556                 adapter->passive_scan_timeout = 0;
10557         }
10558
10559         if (adapter->load_ltks_timeout > 0)
10560                 timeout_remove(adapter->load_ltks_timeout);
10561
10562         if (adapter->confirm_name_timeout > 0)
10563                 timeout_remove(adapter->confirm_name_timeout);
10564
10565         if (adapter->pair_device_timeout > 0)
10566                 timeout_remove(adapter->pair_device_timeout);
10567
10568         if (adapter->auth_idle_id)
10569                 timeout_remove(adapter->auth_idle_id);
10570
10571         g_queue_foreach(adapter->auths, free_service_auth, NULL);
10572         g_queue_free(adapter->auths);
10573         queue_destroy(adapter->exps, NULL);
10574
10575         /*
10576          * Unregister all handlers for this specific index since
10577          * the adapter bound to them is no longer valid.
10578          *
10579          * This also avoids having multiple instances of the same
10580          * handler in case indexes got removed and re-added.
10581          */
10582         mgmt_unregister_index(adapter->mgmt, adapter->dev_id);
10583
10584         /*
10585          * Cancel all pending commands for this specific index
10586          * since the adapter bound to them is no longer valid.
10587          */
10588         mgmt_cancel_index(adapter->mgmt, adapter->dev_id);
10589
10590         mgmt_unref(adapter->mgmt);
10591
10592         sdp_list_free(adapter->services, NULL);
10593
10594         g_slist_free(adapter->connections);
10595
10596         g_free(adapter->path);
10597         g_free(adapter->name);
10598         g_free(adapter->short_name);
10599         g_free(adapter->system_name);
10600         g_free(adapter->stored_alias);
10601         g_free(adapter->current_alias);
10602         free(adapter->modalias);
10603
10604         if (adapter->allowed_uuid_set)
10605                 g_hash_table_destroy(adapter->allowed_uuid_set);
10606
10607         g_free(adapter);
10608 }
10609
10610 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
10611 {
10612         __sync_fetch_and_add(&adapter->ref_count, 1);
10613
10614         return adapter;
10615 }
10616
10617 void btd_adapter_unref(struct btd_adapter *adapter)
10618 {
10619         if (__sync_sub_and_fetch(&adapter->ref_count, 1))
10620                 return;
10621
10622         if (!adapter->path) {
10623                 DBG("Freeing adapter %u", adapter->dev_id);
10624
10625                 adapter_free(adapter);
10626                 return;
10627         }
10628
10629         DBG("Freeing adapter %s", adapter->path);
10630
10631         g_dbus_unregister_interface(dbus_conn, adapter->path,
10632                                                 ADAPTER_INTERFACE);
10633 }
10634
10635 static void convert_names_entry(char *key, char *value, void *user_data)
10636 {
10637         char *address = user_data;
10638         char *str = key;
10639         char filename[PATH_MAX];
10640         GKeyFile *key_file;
10641         GError *gerr = NULL;
10642         char *data;
10643         gsize length = 0;
10644
10645         if (strchr(key, '#'))
10646                 str[17] = '\0';
10647
10648         if (bachk(str) != 0)
10649                 return;
10650
10651         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/cache/%s", address, str);
10652         create_file(filename, 0600);
10653
10654         key_file = g_key_file_new();
10655         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
10656                 error("Unable to load key file from %s: (%s)", filename,
10657                                                                 gerr->message);
10658                 g_error_free(gerr);
10659         }
10660         g_key_file_set_string(key_file, "General", "Name", value);
10661
10662         data = g_key_file_to_data(key_file, &length, NULL);
10663         if (!g_file_set_contents(filename, data, length, &gerr)) {
10664                 error("Unable set contents for %s: (%s)", filename,
10665                                                                 gerr->message);
10666                 g_error_free(gerr);
10667         }
10668         g_free(data);
10669
10670         g_key_file_free(key_file);
10671 }
10672
10673 struct device_converter {
10674         char *address;
10675         void (*cb)(GKeyFile *key_file, void *value);
10676         gboolean force;
10677 };
10678
10679 static void set_device_type(GKeyFile *key_file, char type)
10680 {
10681         char *techno;
10682         char *addr_type = NULL;
10683         char *str;
10684
10685         switch (type) {
10686         case BDADDR_BREDR:
10687                 techno = "BR/EDR";
10688                 break;
10689         case BDADDR_LE_PUBLIC:
10690                 techno = "LE";
10691                 addr_type = "public";
10692                 break;
10693         case BDADDR_LE_RANDOM:
10694                 techno = "LE";
10695                 addr_type = "static";
10696                 break;
10697         default:
10698                 return;
10699         }
10700
10701         str = g_key_file_get_string(key_file, "General",
10702                                         "SupportedTechnologies", NULL);
10703         if (!str)
10704                 g_key_file_set_string(key_file, "General",
10705                                         "SupportedTechnologies", techno);
10706         else if (!strstr(str, techno))
10707                 g_key_file_set_string(key_file, "General",
10708                                         "SupportedTechnologies", "BR/EDR;LE");
10709
10710         g_free(str);
10711
10712         if (addr_type)
10713                 g_key_file_set_string(key_file, "General", "AddressType",
10714                                         addr_type);
10715 }
10716
10717 static void convert_aliases_entry(GKeyFile *key_file, void *value)
10718 {
10719         g_key_file_set_string(key_file, "General", "Alias", value);
10720 }
10721
10722 static void convert_trusts_entry(GKeyFile *key_file, void *value)
10723 {
10724         g_key_file_set_boolean(key_file, "General", "Trusted", TRUE);
10725 }
10726
10727 static void convert_classes_entry(GKeyFile *key_file, void *value)
10728 {
10729         g_key_file_set_string(key_file, "General", "Class", value);
10730 }
10731
10732 static void convert_blocked_entry(GKeyFile *key_file, void *value)
10733 {
10734         g_key_file_set_boolean(key_file, "General", "Blocked", TRUE);
10735 }
10736
10737 static void convert_did_entry(GKeyFile *key_file, void *value)
10738 {
10739         char *vendor_str, *product_str, *version_str;
10740         uint16_t val;
10741
10742         vendor_str = strchr(value, ' ');
10743         if (!vendor_str)
10744                 return;
10745
10746         *(vendor_str++) = 0;
10747
10748         if (g_str_equal(value, "FFFF"))
10749                 return;
10750
10751         product_str = strchr(vendor_str, ' ');
10752         if (!product_str)
10753                 return;
10754
10755         *(product_str++) = 0;
10756
10757         version_str = strchr(product_str, ' ');
10758         if (!version_str)
10759                 return;
10760
10761         *(version_str++) = 0;
10762
10763         val = (uint16_t) strtol(value, NULL, 16);
10764         g_key_file_set_integer(key_file, "DeviceID", "Source", val);
10765
10766         val = (uint16_t) strtol(vendor_str, NULL, 16);
10767         g_key_file_set_integer(key_file, "DeviceID", "Vendor", val);
10768
10769         val = (uint16_t) strtol(product_str, NULL, 16);
10770         g_key_file_set_integer(key_file, "DeviceID", "Product", val);
10771
10772         val = (uint16_t) strtol(version_str, NULL, 16);
10773         g_key_file_set_integer(key_file, "DeviceID", "Version", val);
10774 }
10775
10776 static void convert_linkkey_entry(GKeyFile *key_file, void *value)
10777 {
10778         char *type_str, *length_str, *str;
10779         int val;
10780
10781         type_str = strchr(value, ' ');
10782         if (!type_str)
10783                 return;
10784
10785         *(type_str++) = 0;
10786
10787         length_str = strchr(type_str, ' ');
10788         if (!length_str)
10789                 return;
10790
10791         *(length_str++) = 0;
10792
10793         str = g_strconcat("0x", value, NULL);
10794         g_key_file_set_string(key_file, "LinkKey", "Key", str);
10795         g_free(str);
10796
10797         val = strtol(type_str, NULL, 16);
10798         g_key_file_set_integer(key_file, "LinkKey", "Type", val);
10799
10800         val = strtol(length_str, NULL, 16);
10801         g_key_file_set_integer(key_file, "LinkKey", "PINLength", val);
10802 }
10803
10804 static void convert_ltk_entry(GKeyFile *key_file, void *value)
10805 {
10806         char *auth_str, *rand_str, *str;
10807         int i, ret;
10808         unsigned char auth, central, enc_size;
10809         unsigned short ediv;
10810
10811         auth_str = strchr(value, ' ');
10812         if (!auth_str)
10813                 return;
10814
10815         *(auth_str++) = 0;
10816
10817         for (i = 0, rand_str = auth_str; i < 4; i++) {
10818                 rand_str = strchr(rand_str, ' ');
10819                 if (!rand_str || rand_str[1] == '\0')
10820                         return;
10821
10822                 rand_str++;
10823         }
10824
10825         ret = sscanf(auth_str, " %hhd %hhd %hhd %hd", &auth, &central,
10826                                                         &enc_size, &ediv);
10827         if (ret < 4)
10828                 return;
10829
10830         str = g_strconcat("0x", value, NULL);
10831         g_key_file_set_string(key_file, "LongTermKey", "Key", str);
10832         g_free(str);
10833
10834         g_key_file_set_integer(key_file, "LongTermKey", "Authenticated", auth);
10835         g_key_file_set_integer(key_file, "LongTermKey", "EncSize", enc_size);
10836         g_key_file_set_integer(key_file, "LongTermKey", "EDiv", ediv);
10837
10838         str = g_strconcat("0x", rand_str, NULL);
10839         g_key_file_set_string(key_file, "LongTermKey", "Rand", str);
10840         g_free(str);
10841 }
10842
10843 static void convert_profiles_entry(GKeyFile *key_file, void *value)
10844 {
10845         g_strdelimit(value, " ", ';');
10846         g_key_file_set_string(key_file, "General", "Services", value);
10847 }
10848
10849 static void convert_appearances_entry(GKeyFile *key_file, void *value)
10850 {
10851         g_key_file_set_string(key_file, "General", "Appearance", value);
10852 }
10853
10854 static void convert_entry(char *key, char *value, void *user_data)
10855 {
10856         struct device_converter *converter = user_data;
10857         char type = BDADDR_BREDR;
10858         char filename[PATH_MAX];
10859         GKeyFile *key_file;
10860         GError *gerr = NULL;
10861         char *data;
10862         gsize length = 0;
10863
10864         if (strchr(key, '#')) {
10865                 key[17] = '\0';
10866                 type = key[18] - '0';
10867         }
10868
10869         if (bachk(key) != 0)
10870                 return;
10871
10872         if (converter->force == FALSE) {
10873                 struct stat st;
10874                 int err;
10875
10876                 snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s",
10877                                 converter->address, key);
10878
10879                 err = stat(filename, &st);
10880                 if (err || !S_ISDIR(st.st_mode))
10881                         return;
10882         }
10883
10884         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
10885                         converter->address, key);
10886
10887         key_file = g_key_file_new();
10888         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
10889                 error("Unable to load key file from %s: (%s)", filename,
10890                                                                 gerr->message);
10891                 g_error_free(gerr);
10892         }
10893
10894         set_device_type(key_file, type);
10895
10896         converter->cb(key_file, value);
10897
10898         data = g_key_file_to_data(key_file, &length, NULL);
10899         if (length > 0) {
10900                 create_file(filename, 0600);
10901                 if (!g_file_set_contents(filename, data, length, &gerr)) {
10902                         error("Unable set contents for %s: (%s)", filename,
10903                                                                 gerr->message);
10904                         g_error_free(gerr);
10905                 }
10906         }
10907
10908         g_free(data);
10909
10910         g_key_file_free(key_file);
10911 }
10912
10913 static void convert_file(char *file, char *address,
10914                                 void (*cb)(GKeyFile *key_file, void *value),
10915                                 gboolean force)
10916 {
10917         char filename[PATH_MAX];
10918         struct device_converter converter;
10919
10920         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", address, file);
10921
10922         converter.address = address;
10923         converter.cb = cb;
10924         converter.force = force;
10925
10926         textfile_foreach(filename, convert_entry, &converter);
10927 }
10928
10929 static gboolean record_has_uuid(const sdp_record_t *rec,
10930                                 const char *profile_uuid)
10931 {
10932         sdp_list_t *pat;
10933
10934         for (pat = rec->pattern; pat != NULL; pat = pat->next) {
10935                 char *uuid;
10936                 int ret;
10937
10938                 uuid = bt_uuid2string(pat->data);
10939                 if (!uuid)
10940                         continue;
10941
10942                 ret = strcasecmp(uuid, profile_uuid);
10943
10944                 free(uuid);
10945
10946                 if (ret == 0)
10947                         return TRUE;
10948         }
10949
10950         return FALSE;
10951 }
10952
10953 static void store_attribute_uuid(GKeyFile *key_file, uint16_t start,
10954                                         uint16_t end, char *att_uuid,
10955                                         uuid_t uuid)
10956 {
10957         char handle[6], uuid_str[33];
10958         int i;
10959
10960         switch (uuid.type) {
10961         case SDP_UUID16:
10962                 sprintf(uuid_str, "%4.4X", uuid.value.uuid16);
10963                 break;
10964         case SDP_UUID32:
10965                 sprintf(uuid_str, "%8.8X", uuid.value.uuid32);
10966                 break;
10967         case SDP_UUID128:
10968                 for (i = 0; i < 16; i++)
10969                         sprintf(uuid_str + (i * 2), "%2.2X",
10970                                         uuid.value.uuid128.data[i]);
10971                 break;
10972         default:
10973                 uuid_str[0] = '\0';
10974         }
10975
10976         sprintf(handle, "%hu", start);
10977         g_key_file_set_string(key_file, handle, "UUID", att_uuid);
10978         g_key_file_set_string(key_file, handle, "Value", uuid_str);
10979         g_key_file_set_integer(key_file, handle, "EndGroupHandle", end);
10980 }
10981
10982 static void store_sdp_record(char *local, char *peer, int handle, char *value)
10983 {
10984         char filename[PATH_MAX];
10985         GKeyFile *key_file;
10986         GError *gerr = NULL;
10987         char handle_str[11];
10988         char *data;
10989         gsize length = 0;
10990
10991         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/cache/%s", local, peer);
10992
10993         key_file = g_key_file_new();
10994         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
10995                 error("Unable to load key file from %s: (%s)", filename,
10996                                                                 gerr->message);
10997                 g_error_free(gerr);
10998         }
10999
11000         sprintf(handle_str, "0x%8.8X", handle);
11001         g_key_file_set_string(key_file, "ServiceRecords", handle_str, value);
11002
11003         data = g_key_file_to_data(key_file, &length, NULL);
11004         if (length > 0) {
11005                 create_file(filename, 0600);
11006                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11007                         error("Unable set contents for %s: (%s)", filename,
11008                                                                 gerr->message);
11009                         g_error_free(gerr);
11010                 }
11011         }
11012
11013         g_free(data);
11014
11015         g_key_file_free(key_file);
11016 }
11017
11018 static void convert_sdp_entry(char *key, char *value, void *user_data)
11019 {
11020         char *src_addr = user_data;
11021         char dst_addr[18];
11022         char type = BDADDR_BREDR;
11023         int handle, ret;
11024         char filename[PATH_MAX];
11025         GKeyFile *key_file;
11026         GError *gerr = NULL;
11027         struct stat st;
11028         sdp_record_t *rec;
11029         uuid_t uuid;
11030         char *att_uuid, *prim_uuid;
11031         uint16_t start = 0, end = 0, psm = 0;
11032         int err;
11033         char *data;
11034         gsize length = 0;
11035
11036         ret = sscanf(key, "%17s#%hhu#%08X", dst_addr, &type, &handle);
11037         if (ret < 3) {
11038                 ret = sscanf(key, "%17s#%08X", dst_addr, &handle);
11039                 if (ret < 2)
11040                         return;
11041         }
11042
11043         if (bachk(dst_addr) != 0)
11044                 return;
11045
11046         /* Check if the device directory has been created as records should
11047          * only be converted for known devices */
11048         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
11049
11050         err = stat(filename, &st);
11051         if (err || !S_ISDIR(st.st_mode))
11052                 return;
11053
11054         /* store device records in cache */
11055         store_sdp_record(src_addr, dst_addr, handle, value);
11056
11057         /* Retrieve device record and check if there is an
11058          * attribute entry in it */
11059         sdp_uuid16_create(&uuid, ATT_UUID);
11060         att_uuid = bt_uuid2string(&uuid);
11061
11062         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11063         prim_uuid = bt_uuid2string(&uuid);
11064
11065         rec = record_from_string(value);
11066
11067         if (record_has_uuid(rec, att_uuid))
11068                 goto failed;
11069
11070         /* TODO: Do this through btd_gatt_database */
11071         if (!gatt_parse_record(rec, &uuid, &psm, &start, &end))
11072                 goto failed;
11073
11074         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/attributes", src_addr,
11075                                                                 dst_addr);
11076
11077         key_file = g_key_file_new();
11078         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11079                 error("Unable to load key file from %s: (%s)", filename,
11080                                                                 gerr->message);
11081                 g_error_free(gerr);
11082         }
11083
11084         store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11085
11086         data = g_key_file_to_data(key_file, &length, NULL);
11087         if (length > 0) {
11088                 create_file(filename, 0600);
11089                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11090                         error("Unable set contents for %s: (%s)", filename,
11091                                                                 gerr->message);
11092                         g_error_free(gerr);
11093                 }
11094         }
11095
11096         g_free(data);
11097         g_key_file_free(key_file);
11098
11099 failed:
11100         sdp_record_free(rec);
11101         free(prim_uuid);
11102         free(att_uuid);
11103 }
11104
11105 static void convert_primaries_entry(char *key, char *value, void *user_data)
11106 {
11107         char *address = user_data;
11108         int device_type = -1;
11109         uuid_t uuid;
11110         char **services, **service, *prim_uuid;
11111         char filename[PATH_MAX];
11112         GKeyFile *key_file;
11113         GError *gerr = NULL;
11114         int ret;
11115         uint16_t start, end;
11116         char uuid_str[MAX_LEN_UUID_STR + 1];
11117         char *data;
11118         gsize length = 0;
11119
11120         if (strchr(key, '#')) {
11121                 key[17] = '\0';
11122                 device_type = key[18] - '0';
11123         }
11124
11125         if (bachk(key) != 0)
11126                 return;
11127
11128         services = g_strsplit(value, " ", 0);
11129         if (services == NULL)
11130                 return;
11131
11132         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11133         prim_uuid = bt_uuid2string(&uuid);
11134
11135         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/attributes", address,
11136                                                                         key);
11137         key_file = g_key_file_new();
11138         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11139                 error("Unable to load key file from %s: (%s)", filename,
11140                                                                 gerr->message);
11141                 g_error_free(gerr);
11142         }
11143
11144         for (service = services; *service; service++) {
11145                 ret = sscanf(*service, "%04hX#%04hX#%s", &start, &end,
11146                                                                 uuid_str);
11147                 if (ret < 3)
11148                         continue;
11149
11150                 bt_string2uuid(&uuid, uuid_str);
11151                 sdp_uuid128_to_uuid(&uuid);
11152
11153                 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11154         }
11155
11156         g_strfreev(services);
11157
11158         data = g_key_file_to_data(key_file, &length, NULL);
11159         if (length == 0)
11160                 goto end;
11161
11162         create_file(filename, 0600);
11163         if (!g_file_set_contents(filename, data, length, &gerr)) {
11164                 error("Unable set contents for %s: (%s)", filename,
11165                                                                 gerr->message);
11166                 g_error_free(gerr);
11167         }
11168
11169         if (device_type < 0)
11170                 goto end;
11171
11172         g_free(data);
11173         g_key_file_free(key_file);
11174
11175         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", address, key);
11176
11177         key_file = g_key_file_new();
11178         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11179                 error("Unable to load key file from %s: (%s)", filename,
11180                                                                 gerr->message);
11181                 g_error_free(gerr);
11182         }
11183         set_device_type(key_file, device_type);
11184
11185         data = g_key_file_to_data(key_file, &length, NULL);
11186         if (length > 0) {
11187                 create_file(filename, 0600);
11188                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11189                         error("Unable set contents for %s: (%s)", filename,
11190                                                                 gerr->message);
11191                         g_error_free(gerr);
11192                 }
11193         }
11194
11195 end:
11196         g_free(data);
11197         free(prim_uuid);
11198         g_key_file_free(key_file);
11199 }
11200
11201 static void convert_ccc_entry(char *key, char *value, void *user_data)
11202 {
11203         char *src_addr = user_data;
11204         char dst_addr[18];
11205         char type = BDADDR_BREDR;
11206         uint16_t handle;
11207         int ret, err;
11208         char filename[PATH_MAX];
11209         GKeyFile *key_file;
11210         GError *gerr = NULL;
11211         struct stat st;
11212         char group[6];
11213         char *data;
11214         gsize length = 0;
11215
11216         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11217         if (ret < 3)
11218                 return;
11219
11220         if (bachk(dst_addr) != 0)
11221                 return;
11222
11223         /* Check if the device directory has been created as records should
11224          * only be converted for known devices */
11225         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
11226
11227         err = stat(filename, &st);
11228         if (err || !S_ISDIR(st.st_mode))
11229                 return;
11230
11231         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/ccc", src_addr,
11232                                                                 dst_addr);
11233         key_file = g_key_file_new();
11234         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11235                 error("Unable to load key file from %s: (%s)", filename,
11236                                                                 gerr->message);
11237                 g_error_free(gerr);
11238         }
11239
11240         sprintf(group, "%hu", handle);
11241         g_key_file_set_string(key_file, group, "Value", value);
11242
11243         data = g_key_file_to_data(key_file, &length, NULL);
11244         if (length > 0) {
11245                 create_file(filename, 0600);
11246                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11247                         error("Unable set contents for %s: (%s)", filename,
11248                                                                 gerr->message);
11249                         g_error_free(gerr);
11250                 }
11251         }
11252
11253         g_free(data);
11254         g_key_file_free(key_file);
11255 }
11256
11257 static void convert_gatt_entry(char *key, char *value, void *user_data)
11258 {
11259         char *src_addr = user_data;
11260         char dst_addr[18];
11261         char type = BDADDR_BREDR;
11262         uint16_t handle;
11263         int ret, err;
11264         char filename[PATH_MAX];
11265         GKeyFile *key_file;
11266         GError *gerr = NULL;
11267         struct stat st;
11268         char group[6];
11269         char *data;
11270         gsize length = 0;
11271
11272         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11273         if (ret < 3)
11274                 return;
11275
11276         if (bachk(dst_addr) != 0)
11277                 return;
11278
11279         /* Check if the device directory has been created as records should
11280          * only be converted for known devices */
11281         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
11282
11283         err = stat(filename, &st);
11284         if (err || !S_ISDIR(st.st_mode))
11285                 return;
11286
11287         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/gatt", src_addr,
11288                                                                 dst_addr);
11289         key_file = g_key_file_new();
11290         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11291                 error("Unable to load key file from %s: (%s)", filename,
11292                                                                 gerr->message);
11293                 g_error_free(gerr);
11294         }
11295
11296         sprintf(group, "%hu", handle);
11297         g_key_file_set_string(key_file, group, "Value", value);
11298
11299         data = g_key_file_to_data(key_file, &length, NULL);
11300         if (length > 0) {
11301                 create_file(filename, 0600);
11302                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11303                         error("Unable set contents for %s: (%s)", filename,
11304                                                                 gerr->message);
11305                         g_error_free(gerr);
11306                 }
11307         }
11308
11309         g_free(data);
11310         g_key_file_free(key_file);
11311 }
11312
11313 static void convert_proximity_entry(char *key, char *value, void *user_data)
11314 {
11315         char *src_addr = user_data;
11316         char *alert;
11317         char filename[PATH_MAX];
11318         GKeyFile *key_file;
11319         GError *gerr = NULL;
11320         struct stat st;
11321         int err;
11322         char *data;
11323         gsize length = 0;
11324
11325         if (!strchr(key, '#'))
11326                 return;
11327
11328         key[17] = '\0';
11329         alert = &key[18];
11330
11331         if (bachk(key) != 0)
11332                 return;
11333
11334         /* Check if the device directory has been created as records should
11335          * only be converted for known devices */
11336         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, key);
11337
11338         err = stat(filename, &st);
11339         if (err || !S_ISDIR(st.st_mode))
11340                 return;
11341
11342         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/proximity", src_addr,
11343                                                                         key);
11344         key_file = g_key_file_new();
11345         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11346                 error("Unable to load key file from %s: (%s)", filename,
11347                                                                 gerr->message);
11348                 g_error_free(gerr);
11349         }
11350
11351         g_key_file_set_string(key_file, alert, "Level", value);
11352
11353         data = g_key_file_to_data(key_file, &length, NULL);
11354         if (length > 0) {
11355                 create_file(filename, 0600);
11356                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11357                         error("Unable set contents for %s: (%s)", filename,
11358                                                                 gerr->message);
11359                         g_error_free(gerr);
11360                 }
11361         }
11362
11363         g_free(data);
11364         g_key_file_free(key_file);
11365 }
11366
11367 static void convert_device_storage(struct btd_adapter *adapter)
11368 {
11369         char filename[PATH_MAX];
11370         char address[18];
11371
11372         ba2str(&adapter->bdaddr, address);
11373
11374         /* Convert device's name cache */
11375         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/names", address);
11376         textfile_foreach(filename, convert_names_entry, address);
11377
11378         /* Convert aliases */
11379         convert_file("aliases", address, convert_aliases_entry, TRUE);
11380
11381         /* Convert trusts */
11382         convert_file("trusts", address, convert_trusts_entry, TRUE);
11383
11384         /* Convert blocked */
11385         convert_file("blocked", address, convert_blocked_entry, TRUE);
11386
11387         /* Convert profiles */
11388         convert_file("profiles", address, convert_profiles_entry, TRUE);
11389
11390         /* Convert primaries */
11391         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/primaries", address);
11392         textfile_foreach(filename, convert_primaries_entry, address);
11393
11394         /* Convert linkkeys */
11395         convert_file("linkkeys", address, convert_linkkey_entry, TRUE);
11396
11397         /* Convert longtermkeys */
11398         convert_file("longtermkeys", address, convert_ltk_entry, TRUE);
11399
11400         /* Convert classes */
11401         convert_file("classes", address, convert_classes_entry, FALSE);
11402
11403         /* Convert device ids */
11404         convert_file("did", address, convert_did_entry, FALSE);
11405
11406         /* Convert sdp */
11407         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/sdp", address);
11408         textfile_foreach(filename, convert_sdp_entry, address);
11409
11410         /* Convert ccc */
11411         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/ccc", address);
11412         textfile_foreach(filename, convert_ccc_entry, address);
11413
11414         /* Convert appearances */
11415         convert_file("appearances", address, convert_appearances_entry, FALSE);
11416
11417         /* Convert gatt */
11418         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/gatt", address);
11419         textfile_foreach(filename, convert_gatt_entry, address);
11420
11421         /* Convert proximity */
11422         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/proximity", address);
11423         textfile_foreach(filename, convert_proximity_entry, address);
11424 }
11425
11426 static void convert_config(struct btd_adapter *adapter, const char *filename,
11427                                                         GKeyFile *key_file)
11428 {
11429         char address[18];
11430         char str[MAX_NAME_LENGTH + 1];
11431         char config_path[PATH_MAX];
11432         int timeout;
11433         uint8_t mode;
11434         char *data;
11435         gsize length = 0;
11436         GError *gerr = NULL;
11437
11438         ba2str(&adapter->bdaddr, address);
11439         snprintf(config_path, PATH_MAX, STORAGEDIR "/%s/config", address);
11440
11441         if (read_pairable_timeout(address, &timeout) == 0)
11442                 g_key_file_set_integer(key_file, "General",
11443                                                 "PairableTimeout", timeout);
11444
11445         if (read_discoverable_timeout(address, &timeout) == 0)
11446                 g_key_file_set_integer(key_file, "General",
11447                                                 "DiscoverableTimeout", timeout);
11448
11449         if (read_on_mode(address, str, sizeof(str)) == 0) {
11450                 mode = get_mode(str);
11451                 g_key_file_set_boolean(key_file, "General", "Discoverable",
11452                                         mode == MODE_DISCOVERABLE);
11453         }
11454
11455         if (read_local_name(&adapter->bdaddr, str) == 0)
11456                 g_key_file_set_string(key_file, "General", "Alias", str);
11457
11458         create_file(filename, 0600);
11459
11460         data = g_key_file_to_data(key_file, &length, NULL);
11461         if (!g_file_set_contents(filename, data, length, &gerr)) {
11462                 error("Unable set contents for %s: (%s)", filename,
11463                                                                 gerr->message);
11464                 g_error_free(gerr);
11465         }
11466         g_free(data);
11467 }
11468
11469 static void fix_storage(struct btd_adapter *adapter)
11470 {
11471         char filename[PATH_MAX];
11472         char address[18];
11473         char *converted;
11474
11475         ba2str(&adapter->bdaddr, address);
11476
11477         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/config", address);
11478         converted = textfile_get(filename, "converted");
11479         if (!converted)
11480                 return;
11481
11482         free(converted);
11483
11484         textfile_del(filename, "converted");
11485
11486         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/names", address);
11487         textfile_del(filename, "converted");
11488
11489         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/aliases", address);
11490         textfile_del(filename, "converted");
11491
11492         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/trusts", address);
11493         textfile_del(filename, "converted");
11494
11495         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/blocked", address);
11496         textfile_del(filename, "converted");
11497
11498         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/profiles", address);
11499         textfile_del(filename, "converted");
11500
11501         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/primaries", address);
11502         textfile_del(filename, "converted");
11503
11504         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/linkkeys", address);
11505         textfile_del(filename, "converted");
11506
11507         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/longtermkeys", address);
11508         textfile_del(filename, "converted");
11509
11510         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/classes", address);
11511         textfile_del(filename, "converted");
11512
11513         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/did", address);
11514         textfile_del(filename, "converted");
11515
11516         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/sdp", address);
11517         textfile_del(filename, "converted");
11518
11519         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/ccc", address);
11520         textfile_del(filename, "converted");
11521
11522         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/appearances", address);
11523         textfile_del(filename, "converted");
11524
11525         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/gatt", address);
11526         textfile_del(filename, "converted");
11527
11528         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/proximity", address);
11529         textfile_del(filename, "converted");
11530 }
11531
11532 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11533 static bool is_tempfile(const char *filename)
11534 {
11535         char *p;
11536         int i;
11537
11538         /* tempfile has ^[A-Z0-9]{6}$ suffix (e.g. "settings.1LS4BZ") */
11539         p = strrchr(filename, '.');
11540         if (p == NULL)
11541                 return false;
11542
11543         if (strlen(++p) != 6)
11544                 return false;
11545
11546         for (i = 0; i < 6; i++) {
11547                 if (isdigit(p[i]) || isupper(p[i]))
11548                         continue;
11549                 else
11550                         return false;
11551         }
11552         return true;
11553 }
11554
11555 static void delete_tempfiles(const char *dirname)
11556 {
11557         DIR *dir;
11558         struct dirent *entry;
11559         char filename[PATH_MAX];
11560
11561         dir = opendir(dirname);
11562         if (dir == NULL)
11563                 return;
11564
11565         while ((entry = readdir(dir)) != NULL) {
11566                 if (g_str_equal(entry->d_name, ".") || g_str_equal(entry->d_name, ".."))
11567                         continue;
11568
11569                 if (entry->d_type == DT_UNKNOWN)
11570                         entry->d_type = util_get_dt(dirname, entry->d_name);
11571
11572                 snprintf(filename, PATH_MAX, "%s/%s", dirname, entry->d_name);
11573
11574                 if (entry->d_type == DT_DIR) {
11575                         delete_tempfiles(filename);
11576                 } else if (entry->d_type == DT_REG && is_tempfile(entry->d_name)) {
11577                         unlink(filename);
11578                 }
11579         }
11580         closedir(dir);
11581 }
11582 #endif
11583
11584 static void load_config(struct btd_adapter *adapter)
11585 {
11586         GKeyFile *key_file;
11587         char filename[PATH_MAX];
11588         struct stat st;
11589         GError *gerr = NULL;
11590 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11591         char *str;
11592 #endif
11593
11594         key_file = g_key_file_new();
11595
11596         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/settings",
11597                                         btd_adapter_get_storage_dir(adapter));
11598
11599         if (stat(filename, &st) < 0) {
11600                 convert_config(adapter, filename, key_file);
11601                 convert_device_storage(adapter);
11602         }
11603
11604         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11605                 error("Unable to load key file from %s: (%s)", filename,
11606                                                                 gerr->message);
11607                 g_error_free(gerr);
11608         }
11609
11610         /* Get alias */
11611         adapter->stored_alias = g_key_file_get_string(key_file, "General",
11612                                                                 "Alias", NULL);
11613         if (!adapter->stored_alias) {
11614                 /* fallback */
11615                 adapter->stored_alias = g_key_file_get_string(key_file,
11616                                                 "General", "Name", NULL);
11617         }
11618
11619         /* Get pairable timeout */
11620         adapter->pairable_timeout = g_key_file_get_integer(key_file, "General",
11621                                                 "PairableTimeout", &gerr);
11622         if (gerr) {
11623                 adapter->pairable_timeout = btd_opts.pairto;
11624                 g_error_free(gerr);
11625                 gerr = NULL;
11626         }
11627
11628         /* Get discoverable mode */
11629         adapter->stored_discoverable = g_key_file_get_boolean(key_file,
11630                                         "General", "Discoverable", &gerr);
11631         if (gerr) {
11632                 adapter->stored_discoverable = false;
11633                 g_error_free(gerr);
11634                 gerr = NULL;
11635         }
11636
11637         /* Get discoverable timeout */
11638         adapter->discoverable_timeout = g_key_file_get_integer(key_file,
11639                                 "General", "DiscoverableTimeout", &gerr);
11640         if (gerr) {
11641                 adapter->discoverable_timeout = btd_opts.discovto;
11642                 g_error_free(gerr);
11643                 gerr = NULL;
11644         }
11645
11646 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11647         /* Get A2DP Role */
11648         str = g_key_file_get_string(key_file, "General", "DefaultA2DPRole", &gerr);
11649         if (gerr || !str) {
11650                 if (btd_opts.default_a2dp_role_sink) {
11651                         DBG("Default A2DP role is sink");
11652                         adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
11653                 } else {
11654                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11655                 }
11656                 g_error_free(gerr);
11657                 gerr = NULL;
11658         } else {
11659                 if (g_strcmp0(str, "sink") == 0)
11660                         adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
11661                 else if (g_strcmp0(str, "source") == 0)
11662                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11663                 g_free(str);
11664         }
11665 #endif
11666
11667         g_key_file_free(key_file);
11668 }
11669
11670 static struct btd_adapter *btd_adapter_new(uint16_t index)
11671 {
11672         struct btd_adapter *adapter;
11673 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11674 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11675         DBusConnection *conn = btd_get_dbus_connection();
11676         DBusMessage *msg = NULL;
11677         DBusMessage *reply = NULL;
11678         int charging_state = 0;
11679 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11680 #endif
11681
11682         adapter = g_try_new0(struct btd_adapter, 1);
11683         if (!adapter)
11684                 return NULL;
11685
11686         adapter->dev_id = index;
11687         adapter->mgmt = mgmt_ref(mgmt_primary);
11688         adapter->pincode_requested = false;
11689
11690         /*
11691          * Setup default configuration values. These are either adapter
11692          * defaults or from a system wide configuration file.
11693          *
11694          * Some value might be overwritten later on by adapter specific
11695          * configuration. This is to make sure that sane defaults are
11696          * always present.
11697          */
11698         adapter->system_name = g_strdup(btd_opts.name);
11699         adapter->major_class = (btd_opts.class & 0x001f00) >> 8;
11700         adapter->minor_class = (btd_opts.class & 0x0000fc) >> 2;
11701         adapter->modalias = bt_modalias(btd_opts.did_source,
11702                                                 btd_opts.did_vendor,
11703                                                 btd_opts.did_product,
11704                                                 btd_opts.did_version);
11705         adapter->discoverable_timeout = btd_opts.discovto;
11706         adapter->pairable_timeout = btd_opts.pairto;
11707 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11708         adapter->advertising = FALSE;
11709 #endif
11710
11711         DBG("System name: %s", adapter->system_name);
11712         DBG("Major class: %u", adapter->major_class);
11713         DBG("Minor class: %u", adapter->minor_class);
11714         DBG("Modalias: %s", adapter->modalias);
11715         DBG("Discoverable timeout: %u seconds", adapter->discoverable_timeout);
11716         DBG("Pairable timeout: %u seconds", adapter->pairable_timeout);
11717         adapter->auths = g_queue_new();
11718         adapter->exps = queue_new();
11719
11720 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11721 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11722         adapter->charging_watch = g_dbus_add_signal_watch(conn, DEVICED_DEST,
11723                         DEVICED_BATT_OBJECT_PATH,
11724                         DEVICED_BATT_INTERFACE, "ChargerType",
11725                         charging_state_changed, adapter, NULL);
11726         if (adapter->charging_watch == 0)
11727                 error("Cannot add signal watch for ChargerType");
11728
11729         msg = dbus_message_new_method_call(DEVICED_DEST,
11730                         DEVICED_BATT_OBJECT_PATH,
11731                         DEVICED_BATT_INTERFACE, "ChargerType");
11732         if (msg) {
11733                 reply = dbus_connection_send_with_reply_and_block(conn,
11734                                 msg, 1000, NULL);
11735                 if (reply) {
11736                         if (dbus_message_get_args(reply, NULL,
11737                                         DBUS_TYPE_INT32, &charging_state,
11738                                         DBUS_TYPE_INVALID) == TRUE) {
11739                                 set_charging_state(adapter, charging_state);
11740                         }
11741                         dbus_message_unref(reply);
11742                 } else {
11743                         error("Reply is NULL");
11744                 }
11745                 dbus_message_unref(msg);
11746         } else {
11747                 error("Unable to create dbus message for charging state");
11748         }
11749 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11750 #endif
11751
11752         return btd_adapter_ref(adapter);
11753 }
11754
11755 static void adapter_remove(struct btd_adapter *adapter)
11756 {
11757         GSList *l;
11758 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11759         struct gatt_db *db;
11760 #endif
11761
11762         DBG("Removing adapter %s", adapter->path);
11763
11764 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11765 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11766         if (adapter->charging_watch > 0) {
11767                 g_dbus_remove_watch(btd_get_dbus_connection(),
11768                                 adapter->charging_watch);
11769                 adapter->charging_watch = 0;
11770         }
11771
11772         if (adapter->charging_timeout) {
11773                 g_source_remove(adapter->charging_timeout);
11774                 adapter->charging_timeout = 0;
11775         }
11776 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11777 #endif
11778
11779         if (adapter->discovery_idle_timeout > 0) {
11780                 g_source_remove(adapter->discovery_idle_timeout);
11781                 adapter->discovery_idle_timeout = 0;
11782         }
11783
11784         discovery_cleanup(adapter, 0);
11785
11786         g_slist_free(adapter->connect_list);
11787         adapter->connect_list = NULL;
11788
11789         for (l = adapter->devices; l; l = l->next) {
11790                 device_removed_drivers(adapter, l->data);
11791                 device_remove(l->data, FALSE);
11792         }
11793
11794         g_slist_free(adapter->devices);
11795         adapter->devices = NULL;
11796
11797         discovery_cleanup(adapter, 0);
11798
11799         unload_drivers(adapter);
11800
11801 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11802         db = btd_gatt_database_get_db(adapter->database);
11803         gatt_db_unregister(db, adapter->db_id);
11804         adapter->db_id = 0;
11805
11806         btd_gatt_database_destroy(adapter->database);
11807         adapter->database = NULL;
11808 #else
11809         btd_adapter_gatt_server_stop(adapter);
11810 #endif
11811         btd_adv_manager_destroy(adapter->adv_manager);
11812         adapter->adv_manager = NULL;
11813
11814         btd_adv_monitor_manager_destroy(adapter->adv_monitor_manager);
11815         adapter->adv_monitor_manager = NULL;
11816
11817         btd_battery_provider_manager_destroy(adapter->battery_provider_manager);
11818         adapter->battery_provider_manager = NULL;
11819
11820         g_slist_free(adapter->pin_callbacks);
11821         adapter->pin_callbacks = NULL;
11822
11823         g_slist_free(adapter->msd_callbacks);
11824         adapter->msd_callbacks = NULL;
11825 }
11826
11827 const char *adapter_get_path(struct btd_adapter *adapter)
11828 {
11829         if (!adapter)
11830                 return NULL;
11831
11832         return adapter->path;
11833 }
11834
11835 const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter)
11836 {
11837         return &adapter->bdaddr;
11838 }
11839
11840 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11841 const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter)
11842 {
11843         if (adapter->current_settings & MGMT_SETTING_PRIVACY)
11844                 return &adapter->rpa;
11845         else if (adapter->le_static_addr.b[5] != 0)
11846                 return &adapter->le_static_addr;
11847         else
11848                 return &adapter->bdaddr;
11849 }
11850
11851 uint8_t btd_adapter_get_le_address_type(struct btd_adapter * adapter)
11852 {
11853         if (adapter->current_settings & MGMT_SETTING_PRIVACY ||
11854                                 adapter->le_static_addr.b[5] != 0)
11855                         return BDADDR_LE_RANDOM;
11856                 else
11857                         return BDADDR_LE_PUBLIC;
11858 }
11859 #endif
11860
11861 static bool confirm_name_timeout(gpointer user_data)
11862 {
11863         struct btd_adapter *adapter = user_data;
11864
11865         btd_error(adapter->dev_id, "Confirm name timed out for hci%u",
11866                                                         adapter->dev_id);
11867
11868         adapter->confirm_name_timeout = 0;
11869
11870         mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
11871         adapter->confirm_name_id = 0;
11872
11873         return FALSE;
11874 }
11875
11876 static void confirm_name_complete(uint8_t status, uint16_t length,
11877                                         const void *param, void *user_data)
11878 {
11879         struct btd_adapter *adapter = user_data;
11880
11881         if (status != MGMT_STATUS_SUCCESS) {
11882                 btd_error(adapter->dev_id,
11883                                 "Failed to confirm name for hci%u: %s (0x%02x)",
11884                                 adapter->dev_id, mgmt_errstr(status), status);
11885         }
11886
11887         adapter->confirm_name_id = 0;
11888
11889         timeout_remove(adapter->confirm_name_timeout);
11890         adapter->confirm_name_timeout = 0;
11891
11892         DBG("Confirm name complete for hci%u", adapter->dev_id);
11893 }
11894
11895 static void confirm_name(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
11896                                         uint8_t bdaddr_type, bool name_known)
11897 {
11898         struct mgmt_cp_confirm_name cp;
11899         char addr[18];
11900
11901         ba2str(bdaddr, addr);
11902         DBG("hci%d bdaddr %s name_known %u", adapter->dev_id, addr,
11903                                                                 name_known);
11904
11905         /*
11906          * If the kernel does not answer the confirm name command with
11907          * a command complete or command status in time, this might
11908          * race against another device found event that also requires
11909          * to confirm the name. If there is a pending command, just
11910          * cancel it to be safe here.
11911          */
11912         if (adapter->confirm_name_id > 0) {
11913                 btd_warn(adapter->dev_id,
11914                                 "Found pending confirm name for hci%u",
11915                                                         adapter->dev_id);
11916                 mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
11917         }
11918
11919         if (adapter->confirm_name_timeout > 0) {
11920                 timeout_remove(adapter->confirm_name_timeout);
11921                 adapter->confirm_name_timeout = 0;
11922         }
11923
11924         memset(&cp, 0, sizeof(cp));
11925         bacpy(&cp.addr.bdaddr, bdaddr);
11926         cp.addr.type = bdaddr_type;
11927         cp.name_known = name_known;
11928
11929         adapter->confirm_name_id = mgmt_reply(adapter->mgmt,
11930                                         MGMT_OP_CONFIRM_NAME,
11931                                         adapter->dev_id, sizeof(cp), &cp,
11932                                         confirm_name_complete, adapter, NULL);
11933
11934         if (adapter->confirm_name_id == 0) {
11935                 btd_error(adapter->dev_id, "Failed to confirm name for hci%u",
11936                                                         adapter->dev_id);
11937                 return;
11938         }
11939
11940         /*
11941          * This timeout handling is needed since the kernel is stupid
11942          * and forgets to send a command complete response. However in
11943          * case of failures it does send a command status.
11944          */
11945         adapter->confirm_name_timeout = timeout_add_seconds(2,
11946                                                 confirm_name_timeout, adapter,
11947                                                 NULL);
11948 }
11949
11950 static void adapter_msd_notify(struct btd_adapter *adapter,
11951                                                         struct btd_device *dev,
11952                                                         GSList *msd_list)
11953 {
11954         GSList *cb_l, *cb_next;
11955         GSList *msd_l, *msd_next;
11956
11957         for (cb_l = adapter->msd_callbacks; cb_l != NULL; cb_l = cb_next) {
11958                 btd_msd_cb_t cb = cb_l->data;
11959
11960                 cb_next = g_slist_next(cb_l);
11961
11962                 for (msd_l = msd_list; msd_l != NULL; msd_l = msd_next) {
11963                         const struct eir_msd *msd = msd_l->data;
11964
11965                         msd_next = g_slist_next(msd_l);
11966
11967                         cb(adapter, dev, msd->company, msd->data,
11968                                                                 msd->data_len);
11969                 }
11970         }
11971 }
11972
11973 static bool is_filter_match(GSList *discovery_filter, struct eir_data *eir_data,
11974                                                                 int8_t rssi)
11975 {
11976         GSList *l, *m;
11977         bool got_match = false;
11978
11979         for (l = discovery_filter; l != NULL && got_match != true;
11980                                                         l = g_slist_next(l)) {
11981                 struct discovery_client *client = l->data;
11982                 struct discovery_filter *item = client->discovery_filter;
11983
11984                 /*
11985                  * If one of currently running scans is regular scan, then
11986                  * return all devices as matches
11987                  */
11988                 if (!item) {
11989                         got_match = true;
11990                         continue;
11991                 }
11992
11993                 /* if someone started discovery with empty uuids, he wants all
11994                  * devices in given proximity.
11995                  */
11996                 if (!item->uuids)
11997                         got_match = true;
11998                 else {
11999                         for (m = item->uuids; m != NULL && got_match != true;
12000                                                         m = g_slist_next(m)) {
12001                                 /* m->data contains string representation of
12002                                  * uuid.
12003                                  */
12004                                 if (g_slist_find_custom(eir_data->services,
12005                                                         m->data,
12006                                                         g_strcmp) != NULL)
12007                                         got_match = true;
12008                         }
12009                 }
12010
12011                 if (got_match) {
12012                         /* we have service match, check proximity */
12013                         if (item->rssi == DISTANCE_VAL_INVALID ||
12014                             item->rssi <= rssi ||
12015                             item->pathloss == DISTANCE_VAL_INVALID ||
12016                             (eir_data->tx_power != 127 &&
12017                              eir_data->tx_power - rssi <= item->pathloss))
12018                                 return true;
12019
12020                         got_match = false;
12021                 }
12022         }
12023
12024         return got_match;
12025 }
12026
12027 static void filter_duplicate_data(void *data, void *user_data)
12028 {
12029         struct discovery_client *client = data;
12030         bool *duplicate = user_data;
12031
12032         if (*duplicate || !client->discovery_filter)
12033                 return;
12034
12035         *duplicate = client->discovery_filter->duplicate;
12036 }
12037
12038 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12039 static bool device_is_discoverable(struct btd_adapter *adapter,
12040                                         struct eir_data *eir, const char *addr,
12041                                         uint8_t bdaddr_type)
12042 {
12043         GSList *l;
12044         bool discoverable;
12045
12046         if (bdaddr_type == BDADDR_BREDR || adapter->filtered_discovery)
12047                 discoverable = true;
12048         else
12049                 discoverable = eir->flags & (EIR_LIM_DISC | EIR_GEN_DISC);
12050
12051         /*
12052          * Mark as not discoverable if no client has requested discovery and
12053          * report has not set any discoverable flags.
12054          */
12055         if (!adapter->discovery_list && !discoverable)
12056                 return false;
12057
12058         /* Do a prefix match for both address and name if pattern is set */
12059         for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
12060                 struct dicovery_client *client = l->data;
12061                 struct discovery_filter *filter = client->discovery_filter;
12062                 size_t pattern_len;
12063
12064                 if (!filter || !filter->pattern)
12065                         continue;
12066
12067                 /* Reset discoverable if a client has a pattern filter */
12068                 discoverable = false;
12069
12070                 pattern_len = strlen(filter->pattern);
12071                 if (!pattern_len)
12072                         return true;
12073
12074                 if (!strncmp(filter->pattern, addr, pattern_len))
12075                         return true;
12076
12077                 if (eir->name && !strncmp(filter->pattern, eir->name,
12078                                                         pattern_len))
12079                         return true;
12080         }
12081
12082         return discoverable;
12083 }
12084 #endif
12085
12086 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12087 void btd_adapter_update_found_device(struct btd_adapter *adapter,
12088                                         const bdaddr_t *bdaddr,
12089                                         uint8_t bdaddr_type, int8_t rssi,
12090                                         bool confirm, bool legacy, uint8_t adv_type,
12091                                         bool name_resolve_failed,
12092                                         const uint8_t *data, uint8_t data_len,
12093                                         bool monitoring)
12094 #else
12095 void btd_adapter_update_found_device(struct btd_adapter *adapter,
12096                                         const bdaddr_t *bdaddr,
12097                                         uint8_t bdaddr_type, int8_t rssi,
12098                                         bool confirm, bool legacy,
12099                                         bool not_connectable,
12100                                         bool name_resolve_failed,
12101                                         const uint8_t *data, uint8_t data_len,
12102                                         bool monitoring)
12103 #endif
12104 {
12105         struct btd_device *dev;
12106 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12107         struct bt_ad *ad = NULL;
12108 #endif
12109         struct eir_data eir_data;
12110 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12111         bool name_known, discoverable;
12112 #else
12113         bool name_known;
12114 #endif
12115 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12116         uint8_t allow_report;
12117 #endif
12118         char addr[18];
12119         bool duplicate = false;
12120 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12121         struct queue *matched_monitors = NULL;
12122
12123         if (!btd_adv_monitor_offload_supported(adapter->adv_monitor_manager)) {
12124                 if (bdaddr_type != BDADDR_BREDR)
12125                         ad = bt_ad_new_with_data(data_len, data);
12126
12127                 /* During the background scanning, update the device only when
12128                 * the data match at least one Adv monitor
12129                 */
12130                 if (ad) {
12131                         matched_monitors = btd_adv_monitor_content_filter(
12132                                                 adapter->adv_monitor_manager,
12133                                                 ad);
12134                         bt_ad_unref(ad);
12135                         ad = NULL;
12136                         monitoring = matched_monitors ? true : false;
12137                 }
12138         }
12139
12140         if (!adapter->discovering && !monitoring)
12141                 return;
12142 #endif
12143         memset(&eir_data, 0, sizeof(eir_data));
12144         eir_parse(&eir_data, data, data_len);
12145         ba2str(bdaddr, addr);
12146 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12147         discoverable = device_is_discoverable(adapter, &eir_data, addr,
12148                                                         bdaddr_type);
12149
12150 #endif
12151
12152 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12153         /* Check if the any filter policy */
12154         allow_report = validate_for_filter_policy(adapter, &eir_data, addr);
12155         if (allow_report == NONE_REPORT &&
12156                 ((adapter->scan_type == LE_ACTIVE_SCAN && adv_type == ADV_TYPE_SCAN_RESPONSE) ||
12157                 adapter->scan_type == LE_PASSIVE_SCAN)) {
12158                 eir_data_free(&eir_data);
12159                 return;
12160         }
12161 #endif
12162         dev = btd_adapter_find_device(adapter, bdaddr, bdaddr_type);
12163         if (!dev) {
12164                 /*
12165                  * If no client has requested discovery or the device is
12166                  * not marked as discoverable, then do not create new
12167                  * device objects.
12168                  */
12169 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12170                 /*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
12171                         adapter->le_discovery_list, discoverable);*/
12172                 if ((adapter->discovery_list == NULL &&
12173                                 adapter->le_discovery_list == NULL)) {
12174                         DBG("discovery list is NULL");
12175                         eir_data_free(&eir_data);
12176                         return;
12177                 }
12178 #else
12179                 if (!adapter->discovery_list || !discoverable && !matched_monitors) {
12180                         eir_data_free(&eir_data);
12181                         return;
12182                 }
12183 #endif
12184
12185                 dev = adapter_create_device(adapter, bdaddr, bdaddr_type);
12186         }
12187
12188         if (!dev) {
12189                 btd_error(adapter->dev_id,
12190                         "Unable to create object for found device %s", addr);
12191                 eir_data_free(&eir_data);
12192                 return;
12193         }
12194
12195 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12196         if (device_get_rpa_exist(dev) == true)
12197                 bdaddr_type = BDADDR_LE_RANDOM;
12198 #endif
12199
12200         device_update_last_seen(dev, bdaddr_type);
12201
12202         /*
12203          * FIXME: We need to check for non-zero flags first because
12204          * older kernels send separate adv_ind and scan_rsp. Newer
12205          * kernels send them merged, so once we know which mgmt version
12206          * supports this we can make the non-zero check conditional.
12207          */
12208 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12209         if (bdaddr_type == BDADDR_LE_PUBLIC && eir_data.flags &&
12210                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
12211                 device_set_bredr_support(dev);
12212                 /* Update last seen for BR/EDR in case its flag is set */
12213                 device_update_last_seen(dev, BDADDR_BREDR);
12214         }
12215 #else
12216         if (bdaddr_type != BDADDR_BREDR && eir_data.flags &&
12217                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
12218                 device_set_bredr_support(dev);
12219                 /* Update last seen for BR/EDR in case its flag is set */
12220                 device_update_last_seen(dev, BDADDR_BREDR);
12221         }
12222 #endif
12223
12224         if (eir_data.name != NULL && eir_data.name_complete)
12225                 device_store_cached_name(dev, eir_data.name);
12226
12227         /*
12228          * Only skip devices that are not connected, are temporary, and there
12229          * is no active discovery session ongoing and no matched Adv monitors
12230          */
12231 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12232         if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
12233                         adapter->le_discovery_list == NULL) {
12234                 DBG("discovery list is NULL");
12235                 eir_data_free(&eir_data);
12236                 return;
12237         }
12238
12239         device_set_last_addr_type(dev, bdaddr_type);
12240         device_set_ipsp_connected(dev, FALSE, NULL);
12241 #else
12242         if (!btd_device_is_connected(dev) &&
12243                 (device_is_temporary(dev) && !adapter->discovery_list) &&
12244                 !monitoring) {
12245                 eir_data_free(&eir_data);
12246                 return;
12247         }
12248 #endif
12249
12250 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12251         if (bdaddr_type == BDADDR_BREDR) {
12252         if (adapter->filtered_discovery &&
12253             !is_filter_match(adapter->discovery_list, &eir_data, rssi)) {
12254 #else
12255         /* If there is no matched Adv monitors, don't continue if not
12256          * discoverable or if active discovery filter don't match.
12257          */
12258         if (!monitoring && (!discoverable ||
12259                 (adapter->filtered_discovery && !is_filter_match(
12260                                 adapter->discovery_list, &eir_data, rssi)))) {
12261 #endif
12262                 eir_data_free(&eir_data);
12263                 return;
12264         }
12265
12266         device_set_legacy(dev, legacy);
12267
12268         if (name_resolve_failed)
12269                 device_name_resolve_fail(dev);
12270
12271         if (adapter->filtered_discovery)
12272                 device_set_rssi_with_delta(dev, rssi, 0);
12273         else
12274                 device_set_rssi(dev, rssi);
12275
12276         if (eir_data.tx_power != 127)
12277                 device_set_tx_power(dev, eir_data.tx_power);
12278 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12279         }
12280 #endif
12281
12282         if (eir_data.appearance != 0)
12283                 device_set_appearance(dev, eir_data.appearance);
12284
12285         /* Report an unknown name to the kernel even if there is a short name
12286          * known, but still update the name with the known short name. */
12287 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12288         if (eir_data.name_complete)
12289                 name_known = device_name_known(dev);
12290         else
12291                 name_known = false;
12292 #else
12293         name_known = device_name_known(dev);
12294 #endif
12295
12296         if (eir_data.name && (eir_data.name_complete || !name_known))
12297                 btd_device_device_set_name(dev, eir_data.name);
12298
12299         if (eir_data.class != 0)
12300                 device_set_class(dev, eir_data.class);
12301
12302         if (eir_data.did_source || eir_data.did_vendor ||
12303                         eir_data.did_product || eir_data.did_version)
12304                 btd_device_set_pnpid(dev, eir_data.did_source,
12305                                                         eir_data.did_vendor,
12306                                                         eir_data.did_product,
12307                                                         eir_data.did_version);
12308
12309         device_add_eir_uuids(dev, eir_data.services);
12310
12311         if (adapter->discovery_list)
12312                 g_slist_foreach(adapter->discovery_list, filter_duplicate_data,
12313                                                                 &duplicate);
12314 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12315         if (eir_data.flags != 0)
12316                 device_set_remote_feature_flag(dev, eir_data.flags);
12317
12318         if (bdaddr_type == BDADDR_BREDR)
12319                 device_set_manufacturer_info(dev, &eir_data);
12320         else {
12321                 /* if the application has registered for iBeacon report,
12322                  * then send ibeacon report along with advertisement report */
12323                 device_set_adv_report_info(dev, (void*)data, data_len, adv_type, rssi);
12324         }
12325 #endif
12326
12327         if (eir_data.msd_list) {
12328                 device_set_manufacturer_data(dev, eir_data.msd_list, duplicate);
12329                 adapter_msd_notify(adapter, dev, eir_data.msd_list);
12330         }
12331
12332         if (eir_data.sd_list)
12333                 device_set_service_data(dev, eir_data.sd_list, duplicate);
12334
12335         if (eir_data.data_list)
12336                 device_set_data(dev, eir_data.data_list, duplicate);
12337
12338 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12339         if (bdaddr_type != BDADDR_BREDR && adv_type != ADV_TYPE_SCAN_RESPONSE) {
12340                 device_set_flags(dev, eir_data.flags);
12341                 device_set_le_connectable(dev, adv_type);
12342         }
12343 #else
12344         if (bdaddr_type != BDADDR_BREDR)
12345                 device_set_flags(dev, eir_data.flags);
12346 #endif
12347
12348         eir_data_free(&eir_data);
12349
12350 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12351         /* After the device is updated, notify the matched Adv monitors */
12352         if (matched_monitors) {
12353                 btd_adv_monitor_notify_monitors(adapter->adv_monitor_manager,
12354                                                 dev, rssi, matched_monitors);
12355                 queue_destroy(matched_monitors, NULL);
12356                 matched_monitors = NULL;
12357         }
12358 #endif
12359         /*
12360          * Only if at least one client has requested discovery, maintain
12361          * list of found devices and name confirming for legacy devices.
12362          * Otherwise, this is an event from passive discovery and we
12363          * should check if the device needs connecting to.
12364          */
12365 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12366         if (!adapter->discovery_list && !adapter->le_discovery_list)
12367 #else
12368         if (!adapter->discovery_list)
12369 #endif
12370                 goto connect_le;
12371
12372         if (g_slist_find(adapter->discovery_found, dev))
12373                 return;
12374
12375         /* If name is unknown but it's not allowed to resolve, don't send
12376          * MGMT_OP_CONFIRM_NAME.
12377          */
12378         if (confirm && (name_known || device_is_name_resolve_allowed(dev)))
12379                 confirm_name(adapter, bdaddr, bdaddr_type, name_known);
12380
12381         adapter->discovery_found = g_slist_prepend(adapter->discovery_found,
12382                                                                         dev);
12383
12384         return;
12385
12386 connect_le:
12387 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12388         /* Ignore non-connectable events */
12389         if (not_connectable)
12390                 return;
12391 #endif
12392
12393         /*
12394          * If we're in the process of stopping passive scanning and
12395          * connecting another (or maybe even the same) LE device just
12396          * ignore this one.
12397          */
12398         if (adapter->connect_le)
12399                 return;
12400
12401         /*
12402          * If kernel background scan is used then the kernel is
12403          * responsible for connecting.
12404          */
12405         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
12406                 return;
12407
12408         /*
12409          * If this is an LE device that's not connected and part of the
12410          * connect_list stop passive scanning so that a connection
12411          * attempt to it can be made
12412          */
12413         if (bdaddr_type != BDADDR_BREDR && !btd_device_is_connected(dev) &&
12414                                 g_slist_find(adapter->connect_list, dev)) {
12415                 adapter->connect_le = dev;
12416                 stop_passive_scanning(adapter);
12417         }
12418 }
12419
12420 static void device_found_callback(uint16_t index, uint16_t length,
12421                                         const void *param, void *user_data)
12422 {
12423         const struct mgmt_ev_device_found *ev = param;
12424         struct btd_adapter *adapter = user_data;
12425         const uint8_t *eir;
12426         uint16_t eir_len;
12427         uint32_t flags;
12428         bool confirm_name;
12429         bool legacy;
12430 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12431         bool not_connectable;
12432 #endif
12433         bool name_resolve_failed;
12434         char addr[18];
12435         if (length < sizeof(*ev)) {
12436                 btd_error(adapter->dev_id,
12437                         "Too short device found event (%u bytes)", length);
12438                 return;
12439         }
12440
12441         eir_len = btohs(ev->eir_len);
12442         if (length != sizeof(*ev) + eir_len) {
12443                 btd_error(adapter->dev_id,
12444                                 "Device found event size mismatch (%u != %zu)",
12445                                         length, sizeof(*ev) + eir_len);
12446                 return;
12447         }
12448
12449         if (eir_len == 0)
12450                 eir = NULL;
12451         else
12452                 eir = ev->eir;
12453
12454         flags = btohl(ev->flags);
12455
12456         ba2str(&ev->addr.bdaddr, addr);
12457         DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12458                         index, addr, ev->rssi, flags, eir_len);
12459
12460         confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
12461         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
12462 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12463         not_connectable = (flags & MGMT_DEV_FOUND_NOT_CONNECTABLE);
12464 #endif
12465         name_resolve_failed = (flags & MGMT_DEV_FOUND_NAME_REQUEST_FAILED);
12466 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12467         btd_adapter_update_found_device(adapter, &ev->addr.bdaddr, ev->addr.type,
12468                                         ev->rssi, confirm_name, legacy, 0,
12469                                         name_resolve_failed,
12470                                         eir, eir_len, false);
12471 #else
12472         btd_adapter_update_found_device(adapter, &ev->addr.bdaddr, ev->addr.type,
12473                                         ev->rssi, confirm_name, legacy,
12474                                         not_connectable, name_resolve_failed,
12475                                         eir, eir_len, false);
12476 #endif
12477 }
12478
12479 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12480 static void le_device_found_callback(uint16_t index, uint16_t length,
12481                                         const void *param, void *user_data)
12482 {
12483         const struct mgmt_ev_le_device_found *ev = param;
12484         struct btd_adapter *adapter = user_data;
12485         const uint8_t *eir;
12486         uint16_t eir_len;
12487         uint32_t flags;
12488         bool confirm_name;
12489         bool legacy;
12490         char addr[18];
12491         bool name_resolve_failed;
12492
12493         if (length < sizeof(*ev)) {
12494                 error("Too short device found event (%u bytes)", length);
12495                 return;
12496         }
12497
12498         eir_len = btohs(ev->eir_len);
12499         if (length != sizeof(*ev) + eir_len) {
12500                 error("Device found event size mismatch (%u != %zu)",
12501                                         length, sizeof(*ev) + eir_len);
12502                 return;
12503         }
12504
12505         if (eir_len == 0)
12506                 eir = NULL;
12507         else
12508                 eir = ev->eir;
12509
12510         flags = btohl(ev->flags);
12511
12512         ba2str(&ev->addr.bdaddr, addr);
12513         /*DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12514                         index, addr, ev->rssi, flags, eir_len);*/
12515
12516         confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
12517         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
12518
12519         /*DBG("hci%u addr %s, addr_type %d rssi %d flags 0x%04x eir_len %u confirm_name %d legacy %d, adv_type %02x",
12520                         index, addr, ev->addr.type, ev->rssi, flags, eir_len, confirm_name, legacy, ev->adv_type);*/
12521         name_resolve_failed = (flags & MGMT_DEV_FOUND_NAME_REQUEST_FAILED);
12522         btd_adapter_update_found_device(adapter, &ev->addr.bdaddr, ev->addr.type,
12523                                         ev->rssi, confirm_name, legacy, ev->adv_type,
12524                                         name_resolve_failed, eir, eir_len, false);
12525 }
12526 #endif
12527
12528 struct agent *adapter_get_agent(struct btd_adapter *adapter)
12529 {
12530         return agent_get(NULL);
12531 }
12532
12533 static void adapter_remove_connection(struct btd_adapter *adapter,
12534                                                 struct btd_device *device,
12535                                                 uint8_t bdaddr_type)
12536 {
12537         DBG("");
12538
12539         if (!g_slist_find(adapter->connections, device)) {
12540                 btd_error(adapter->dev_id, "No matching connection for device");
12541                 return;
12542         }
12543
12544         device_remove_connection(device, bdaddr_type);
12545
12546 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12547         if (device_is_authenticating(device, bdaddr_type))
12548 #else
12549         if (device_is_authenticating(device))
12550 #endif
12551                 device_cancel_authentication(device, TRUE);
12552
12553         /* If another bearer is still connected */
12554         if (btd_device_is_connected(device))
12555                 return;
12556
12557         adapter->connections = g_slist_remove(adapter->connections, device);
12558 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12559         DBG("isPaired %d, isBonded %d", device_is_paired(device, bdaddr_type),
12560                         device_is_bonded(device, bdaddr_type));
12561         if ((device_is_temporary(device) && !device_is_retrying(device)) ||
12562                         (!device_is_bonded(device, bdaddr_type))) {
12563
12564                 const char *path = device_get_path(device);
12565
12566                 DBG("Removing temporary device %s", path);
12567
12568                 /* device_is_paired is added incase of tempoary bonded
12569                  * oop file transfer in that device is not bonded it's paired.
12570                  */
12571                 if (!(device_is_bonded(device, bdaddr_type) ||
12572                                 device_is_paired(device, bdaddr_type))) {
12573                         DBG("addr type %d, bonded", bdaddr_type);
12574                         return;
12575                 }
12576
12577                 btd_adapter_unpair_device(adapter, device);
12578 #endif
12579         }
12580 }
12581
12582 static void adapter_stop(struct btd_adapter *adapter)
12583 {
12584         /* check pending requests */
12585         reply_pending_requests(adapter);
12586
12587         cancel_passive_scanning(adapter);
12588
12589         remove_discovery_list(adapter);
12590
12591         discovery_cleanup(adapter, 0);
12592
12593         adapter->filtered_discovery = false;
12594         adapter->no_scan_restart_delay = false;
12595         g_free(adapter->current_discovery_filter);
12596         adapter->current_discovery_filter = NULL;
12597
12598         set_discovery_discoverable(adapter, false);
12599         adapter->discovering = false;
12600
12601         while (adapter->connections) {
12602                 struct btd_device *device = adapter->connections->data;
12603                 uint8_t addr_type = btd_device_get_bdaddr_type(device);
12604
12605                 adapter_remove_connection(adapter, device, BDADDR_BREDR);
12606                 if (addr_type != BDADDR_BREDR)
12607                         adapter_remove_connection(adapter, device, addr_type);
12608         }
12609
12610         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12611                                         ADAPTER_INTERFACE, "Discovering");
12612 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12613         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12614                                                 ADAPTER_INTERFACE, "LEDiscovering");
12615 #endif
12616
12617         if (adapter->dev_class) {
12618                 /* the kernel should reset the class of device when powering
12619                  * down, but it does not. So force it here ... */
12620                 adapter->dev_class = 0;
12621                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12622                                                 ADAPTER_INTERFACE, "Class");
12623         }
12624
12625 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12626         advertiser_cleanup(adapter);
12627 #endif
12628         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12629                                                 ADAPTER_INTERFACE, "Powered");
12630
12631         DBG("adapter %s has been disabled", adapter->path);
12632 }
12633
12634 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
12635 {
12636         adapter_drivers = g_slist_append(adapter_drivers, driver);
12637
12638         if (driver->probe == NULL)
12639                 return 0;
12640
12641         adapter_foreach(probe_driver, driver);
12642
12643         return 0;
12644 }
12645
12646 static void unload_driver(struct btd_adapter *adapter, gpointer data)
12647 {
12648         struct btd_adapter_driver *driver = data;
12649
12650         if (driver->remove)
12651                 driver->remove(adapter);
12652
12653         adapter->drivers = g_slist_remove(adapter->drivers, data);
12654 }
12655
12656 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
12657 {
12658         adapter_drivers = g_slist_remove(adapter_drivers, driver);
12659
12660         adapter_foreach(unload_driver, driver);
12661 }
12662
12663 static void agent_auth_cb(struct agent *agent, DBusError *derr,
12664                                                         void *user_data)
12665 {
12666         struct btd_adapter *adapter = user_data;
12667         struct service_auth *auth = g_queue_pop_head(adapter->auths);
12668
12669         if (!auth) {
12670                 DBG("No pending authorization");
12671                 return;
12672         }
12673
12674         auth->cb(derr, auth->user_data);
12675
12676         if (auth->agent)
12677                 agent_unref(auth->agent);
12678
12679         g_free(auth);
12680
12681         /* Stop processing if queue is empty */
12682         if (g_queue_is_empty(adapter->auths)) {
12683                 if (adapter->auth_idle_id > 0)
12684                         g_source_remove(adapter->auth_idle_id);
12685                 return;
12686         }
12687
12688         if (adapter->auth_idle_id > 0)
12689                 return;
12690
12691         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12692 }
12693
12694 static gboolean process_auth_queue(gpointer user_data)
12695 {
12696         struct btd_adapter *adapter = user_data;
12697         DBusError err;
12698
12699         adapter->auth_idle_id = 0;
12700
12701         dbus_error_init(&err);
12702         dbus_set_error_const(&err, ERROR_INTERFACE ".Rejected", NULL);
12703
12704         while (!g_queue_is_empty(adapter->auths)) {
12705                 struct service_auth *auth = adapter->auths->head->data;
12706                 struct btd_device *device = auth->device;
12707
12708                 /* Wait services to be resolved before asking authorization */
12709                 if (auth->svc_id > 0) {
12710 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12711                         DBG("Wait services to be resolved before asking authorization");
12712 #endif
12713                         return FALSE;
12714                 }
12715                 if (!btd_adapter_is_uuid_allowed(adapter, auth->uuid)) {
12716                         auth->cb(&err, auth->user_data);
12717                         goto next;
12718                 }
12719
12720 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12721                 if (device_is_trusted(device) == TRUE) {
12722 #else
12723                 if (device_is_trusted(device) == TRUE
12724                                 || device_is_profile_trusted(device, auth->uuid)
12725                                 || btd_opts.pin_code) {
12726                         /* In headless device(pin_code is existing),
12727                            no need to request to agent */
12728 #endif
12729                         auth->cb(NULL, auth->user_data);
12730                         goto next;
12731                 }
12732
12733 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12734                 /* If Profile is Blocked, Simply reject Authorization*/
12735                 if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
12736                         auth->cb(&err, auth->user_data);
12737                         goto next;
12738                 }
12739 #endif
12740
12741                 /* If agent is set authorization is already ongoing */
12742                 if (auth->agent)
12743                         return FALSE;
12744
12745                 auth->agent = agent_get(NULL);
12746                 if (auth->agent == NULL) {
12747                         btd_warn(adapter->dev_id,
12748                                         "Authentication attempt without agent");
12749                         auth->cb(&err, auth->user_data);
12750                         goto next;
12751                 }
12752
12753                 if (agent_authorize_service(auth->agent, device, auth->uuid,
12754                                         agent_auth_cb, adapter, NULL) < 0) {
12755                         auth->cb(&err, auth->user_data);
12756                         goto next;
12757                 }
12758
12759                 break;
12760
12761 next:
12762                 if (auth->agent)
12763                         agent_unref(auth->agent);
12764
12765                 g_free(auth);
12766
12767                 g_queue_pop_head(adapter->auths);
12768         }
12769
12770         dbus_error_free(&err);
12771
12772         return FALSE;
12773 }
12774
12775 static void svc_complete(struct btd_device *dev, int err, void *user_data)
12776 {
12777         struct service_auth *auth = user_data;
12778         struct btd_adapter *adapter = auth->adapter;
12779
12780         auth->svc_id = 0;
12781
12782         if (adapter->auth_idle_id != 0)
12783                 return;
12784
12785         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12786 }
12787
12788 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
12789                                         const char *uuid,
12790                                         adapter_authorize_type check_for_connection,
12791                                         service_auth_cb cb, void *user_data)
12792 {
12793         struct service_auth *auth;
12794         struct btd_device *device;
12795         static guint id = 0;
12796
12797 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12798         if (!strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
12799                 device = btd_adapter_find_device(adapter, dst, BDADDR_LE_PUBLIC);
12800         else
12801                 device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
12802 #else
12803         device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
12804 #endif
12805
12806         if (!device)
12807                 return 0;
12808
12809         if (device_is_disconnecting(device)) {
12810                 DBG("Authorization request while disconnecting");
12811                 return 0;
12812         }
12813
12814         /* Device connected? */
12815         if (check_for_connection && !g_slist_find(adapter->connections, device))
12816                 btd_error(adapter->dev_id,
12817                         "Authorization request for non-connected device!?");
12818
12819         auth = g_try_new0(struct service_auth, 1);
12820         if (!auth)
12821                 return 0;
12822
12823         auth->cb = cb;
12824         auth->user_data = user_data;
12825         auth->uuid = uuid;
12826         auth->device = device;
12827         auth->adapter = adapter;
12828         auth->id = ++id;
12829 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12830         if (check_for_connection &&
12831                 strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
12832 #else
12833         if (check_for_connection)
12834 #endif
12835                 auth->svc_id = device_wait_for_svc_complete(device, svc_complete, auth);
12836         else {
12837                 if (adapter->auth_idle_id == 0)
12838                         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12839         }
12840
12841         g_queue_push_tail(adapter->auths, auth);
12842
12843         return auth->id;
12844 }
12845
12846 guint btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
12847                                         const char *uuid, service_auth_cb cb,
12848                                         void *user_data)
12849 {
12850         struct btd_adapter *adapter;
12851         GSList *l;
12852
12853         if (bacmp(src, BDADDR_ANY) != 0) {
12854                 adapter = adapter_find(src);
12855                 if (!adapter)
12856                         return 0;
12857
12858                 return adapter_authorize(adapter, dst, uuid,
12859                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
12860         }
12861
12862         for (l = adapters; l != NULL; l = g_slist_next(l)) {
12863                 guint id;
12864
12865                 adapter = l->data;
12866
12867                 id = adapter_authorize(adapter, dst, uuid,
12868                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
12869                 if (id != 0)
12870                         return id;
12871         }
12872
12873         return 0;
12874 }
12875
12876 guint btd_request_authorization_cable_configured(const bdaddr_t *src, const bdaddr_t *dst,
12877                                                 const char *uuid, service_auth_cb cb,
12878                                                 void *user_data)
12879 {
12880         struct btd_adapter *adapter;
12881
12882         if (bacmp(src, BDADDR_ANY) == 0)
12883                 return 0;
12884
12885         adapter = adapter_find(src);
12886         if (!adapter)
12887                 return 0;
12888
12889         return adapter_authorize(adapter, dst, uuid,
12890                         ADAPTER_AUTHORIZE_DISCONNECTED, cb, user_data);
12891 }
12892
12893 static struct service_auth *find_authorization(guint id)
12894 {
12895         GSList *l;
12896         GList *l2;
12897
12898         for (l = adapters; l != NULL; l = g_slist_next(l)) {
12899                 struct btd_adapter *adapter = l->data;
12900
12901                 for (l2 = adapter->auths->head; l2 != NULL; l2 = l2->next) {
12902                         struct service_auth *auth = l2->data;
12903
12904                         if (auth->id == id)
12905                                 return auth;
12906                 }
12907         }
12908
12909         return NULL;
12910 }
12911
12912 int btd_cancel_authorization(guint id)
12913 {
12914         struct service_auth *auth;
12915
12916         auth = find_authorization(id);
12917         if (auth == NULL)
12918                 return -EPERM;
12919
12920         if (auth->svc_id > 0)
12921                 device_remove_svc_complete_callback(auth->device,
12922                                                                 auth->svc_id);
12923
12924         g_queue_remove(auth->adapter->auths, auth);
12925
12926         if (auth->agent) {
12927                 agent_cancel(auth->agent);
12928                 agent_unref(auth->agent);
12929         }
12930
12931         g_free(auth);
12932
12933         return 0;
12934 }
12935
12936 int btd_adapter_restore_powered(struct btd_adapter *adapter)
12937 {
12938         if (btd_adapter_get_powered(adapter))
12939                 return 0;
12940
12941         set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
12942
12943         return 0;
12944 }
12945
12946 void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
12947                                                         btd_adapter_pin_cb_t cb)
12948 {
12949         adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
12950 }
12951
12952 void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
12953                                                         btd_adapter_pin_cb_t cb)
12954 {
12955         adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
12956 }
12957
12958 void btd_adapter_unregister_msd_cb(struct btd_adapter *adapter,
12959                                                         btd_msd_cb_t cb)
12960 {
12961         adapter->msd_callbacks = g_slist_remove(adapter->msd_callbacks, cb);
12962 }
12963
12964 void btd_adapter_register_msd_cb(struct btd_adapter *adapter,
12965                                                         btd_msd_cb_t cb)
12966 {
12967         adapter->msd_callbacks = g_slist_prepend(adapter->msd_callbacks, cb);
12968 }
12969
12970 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
12971                                                         gboolean enable)
12972 {
12973         if (!btd_adapter_get_powered(adapter))
12974                 return -EINVAL;
12975
12976         set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, enable ? 0x01 : 0x00);
12977
12978         return 0;
12979 }
12980
12981 int btd_adapter_read_clock(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12982                                 int which, int timeout, uint32_t *clock,
12983                                 uint16_t *accuracy)
12984 {
12985         if (!btd_adapter_get_powered(adapter))
12986                 return -EINVAL;
12987
12988         return -ENOSYS;
12989 }
12990
12991 int btd_adapter_remove_bonding(struct btd_adapter *adapter,
12992                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
12993 {
12994         struct mgmt_cp_unpair_device cp;
12995
12996         memset(&cp, 0, sizeof(cp));
12997         bacpy(&cp.addr.bdaddr, bdaddr);
12998         cp.addr.type = bdaddr_type;
12999         cp.disconnect = 1;
13000
13001         if (mgmt_send(adapter->mgmt, MGMT_OP_UNPAIR_DEVICE,
13002                                 adapter->dev_id, sizeof(cp), &cp,
13003                                 NULL, NULL, NULL) > 0)
13004                 return 0;
13005
13006         return -EIO;
13007 }
13008
13009 static void pincode_reply_complete(uint8_t status, uint16_t length,
13010                                         const void *param, void *user_data)
13011 {
13012         struct btd_device *device = user_data;
13013
13014         /* If the MGMT_OP_PIN_CODE_REPLY command is acknowledged, move the
13015          * starting time to that point. This give a better sense of time
13016          * evaluating the pincode. */
13017         device_bonding_restart_timer(device);
13018 }
13019
13020 int btd_adapter_pincode_reply(struct btd_adapter *adapter,
13021                                         const bdaddr_t *bdaddr,
13022                                         const char *pin, size_t pin_len)
13023 {
13024         struct btd_device *device;
13025         unsigned int id;
13026         char addr[18];
13027
13028         ba2str(bdaddr, addr);
13029         DBG("hci%u addr %s pinlen %zu", adapter->dev_id, addr, pin_len);
13030
13031         if (pin == NULL) {
13032                 struct mgmt_cp_pin_code_neg_reply cp;
13033
13034                 memset(&cp, 0, sizeof(cp));
13035                 bacpy(&cp.addr.bdaddr, bdaddr);
13036                 cp.addr.type = BDADDR_BREDR;
13037
13038                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
13039                                         adapter->dev_id, sizeof(cp), &cp,
13040                                         NULL, NULL, NULL);
13041         } else {
13042                 struct mgmt_cp_pin_code_reply cp;
13043
13044                 if (pin_len > 16)
13045                         return -EINVAL;
13046
13047                 memset(&cp, 0, sizeof(cp));
13048                 bacpy(&cp.addr.bdaddr, bdaddr);
13049                 cp.addr.type = BDADDR_BREDR;
13050                 cp.pin_len = pin_len;
13051                 memcpy(cp.pin_code, pin, pin_len);
13052
13053                 /* Since a pincode was requested, update the starting time to
13054                  * the point where the pincode is provided. */
13055                 device = btd_adapter_find_device(adapter, bdaddr, BDADDR_BREDR);
13056                 device_bonding_restart_timer(device);
13057
13058                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_REPLY,
13059                                         adapter->dev_id, sizeof(cp), &cp,
13060                                         pincode_reply_complete, device, NULL);
13061         }
13062
13063         if (id == 0)
13064                 return -EIO;
13065
13066         return 0;
13067 }
13068
13069 int btd_adapter_confirm_reply(struct btd_adapter *adapter,
13070                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13071                                 gboolean success)
13072 {
13073         struct mgmt_cp_user_confirm_reply cp;
13074         uint16_t opcode;
13075         char addr[18];
13076
13077         ba2str(bdaddr, addr);
13078         DBG("hci%u addr %s success %d", adapter->dev_id, addr, success);
13079
13080         if (success)
13081                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
13082         else
13083                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
13084
13085         memset(&cp, 0, sizeof(cp));
13086         bacpy(&cp.addr.bdaddr, bdaddr);
13087         cp.addr.type = bdaddr_type;
13088
13089         if (mgmt_reply(adapter->mgmt, opcode, adapter->dev_id, sizeof(cp), &cp,
13090                                                         NULL, NULL, NULL) > 0)
13091                 return 0;
13092
13093         return -EIO;
13094 }
13095
13096 static void user_confirm_request_callback(uint16_t index, uint16_t length,
13097                                         const void *param, void *user_data)
13098 {
13099         const struct mgmt_ev_user_confirm_request *ev = param;
13100         struct btd_adapter *adapter = user_data;
13101         struct btd_device *device;
13102         char addr[18];
13103         int err;
13104
13105         if (length < sizeof(*ev)) {
13106                 btd_error(adapter->dev_id,
13107                                 "Too small user confirm request event");
13108                 return;
13109         }
13110
13111         ba2str(&ev->addr.bdaddr, addr);
13112         DBG("hci%u %s confirm_hint %u", adapter->dev_id, addr,
13113                                                         ev->confirm_hint);
13114         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13115                                                                 ev->addr.type);
13116         if (!device) {
13117                 btd_error(adapter->dev_id,
13118                                 "Unable to get device object for %s", addr);
13119                 return;
13120         }
13121
13122 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13123         device_set_auth_addr_type(device, ev->addr.type);
13124 #endif
13125         err = device_confirm_passkey(device, ev->addr.type, btohl(ev->value),
13126                                                         ev->confirm_hint);
13127         if (err < 0) {
13128                 btd_error(adapter->dev_id,
13129                                 "device_confirm_passkey: %s", strerror(-err));
13130                 btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
13131                                                         ev->addr.type, FALSE);
13132         }
13133 }
13134
13135 int btd_adapter_passkey_reply(struct btd_adapter *adapter,
13136                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13137                                 uint32_t passkey)
13138 {
13139         unsigned int id;
13140         char addr[18];
13141
13142         ba2str(bdaddr, addr);
13143         DBG("hci%u addr %s passkey %06u", adapter->dev_id, addr, passkey);
13144
13145         if (passkey == INVALID_PASSKEY) {
13146                 struct mgmt_cp_user_passkey_neg_reply cp;
13147
13148                 memset(&cp, 0, sizeof(cp));
13149                 bacpy(&cp.addr.bdaddr, bdaddr);
13150                 cp.addr.type = bdaddr_type;
13151
13152                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
13153                                         adapter->dev_id, sizeof(cp), &cp,
13154                                         NULL, NULL, NULL);
13155         } else {
13156                 struct mgmt_cp_user_passkey_reply cp;
13157
13158                 memset(&cp, 0, sizeof(cp));
13159                 bacpy(&cp.addr.bdaddr, bdaddr);
13160                 cp.addr.type = bdaddr_type;
13161                 cp.passkey = htobl(passkey);
13162
13163                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_REPLY,
13164                                         adapter->dev_id, sizeof(cp), &cp,
13165                                         NULL, NULL, NULL);
13166         }
13167
13168         if (id == 0)
13169                 return -EIO;
13170
13171         return 0;
13172 }
13173
13174 static void user_passkey_request_callback(uint16_t index, uint16_t length,
13175                                         const void *param, void *user_data)
13176 {
13177         const struct mgmt_ev_user_passkey_request *ev = param;
13178         struct btd_adapter *adapter = user_data;
13179         struct btd_device *device;
13180         char addr[18];
13181         int err;
13182
13183         if (length < sizeof(*ev)) {
13184                 btd_error(adapter->dev_id, "Too small passkey request event");
13185                 return;
13186         }
13187
13188         ba2str(&ev->addr.bdaddr, addr);
13189         DBG("hci%u %s", index, addr);
13190
13191         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13192                                                                 ev->addr.type);
13193         if (!device) {
13194                 btd_error(adapter->dev_id,
13195                                 "Unable to get device object for %s", addr);
13196                 return;
13197         }
13198
13199 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13200         device_set_auth_addr_type(device, ev->addr.type);
13201 #endif
13202         err = device_request_passkey(device, ev->addr.type);
13203         if (err < 0) {
13204                 btd_error(adapter->dev_id,
13205                                 "device_request_passkey: %s", strerror(-err));
13206                 btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
13207                                         ev->addr.type, INVALID_PASSKEY);
13208         }
13209 }
13210
13211 static void user_passkey_notify_callback(uint16_t index, uint16_t length,
13212                                         const void *param, void *user_data)
13213 {
13214         const struct mgmt_ev_passkey_notify *ev = param;
13215         struct btd_adapter *adapter = user_data;
13216         struct btd_device *device;
13217         uint32_t passkey;
13218         char addr[18];
13219         int err;
13220
13221         if (length < sizeof(*ev)) {
13222                 btd_error(adapter->dev_id, "Too small passkey notify event");
13223                 return;
13224         }
13225
13226         ba2str(&ev->addr.bdaddr, addr);
13227         DBG("hci%u %s", index, addr);
13228
13229         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13230                                                                 ev->addr.type);
13231         if (!device) {
13232                 btd_error(adapter->dev_id,
13233                                 "Unable to get device object for %s", addr);
13234                 return;
13235         }
13236
13237         passkey = get_le32(&ev->passkey);
13238
13239         DBG("passkey %06u entered %u", passkey, ev->entered);
13240
13241         err = device_notify_passkey(device, ev->addr.type, passkey,
13242                                                                 ev->entered);
13243         if (err < 0)
13244                 btd_error(adapter->dev_id,
13245                                 "device_notify_passkey: %s", strerror(-err));
13246 }
13247
13248 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13249 static void rssi_alert_callback(uint16_t index, uint16_t length,
13250                                         const void *param, void *user_data)
13251 {
13252         const struct mgmt_ev_vendor_specific_rssi_alert *ev = param;
13253         struct btd_adapter *adapter = user_data;
13254         char addr[18];
13255         char *bt_addr =  NULL;
13256         int link_type = -1;
13257         int alert_type = -1;
13258         int rssi_dbm = 0;
13259
13260         if (length < sizeof(*ev)) {
13261                 error("Too small rssi alert event");
13262                 return;
13263         }
13264
13265         ba2str(&ev->bdaddr, addr);
13266         DBG("hci%u %s %d", index, addr, ev->link_type);
13267         DBG("RSSI Alert Params [%d %d]", ev->alert_type, ev->rssi_dbm);
13268
13269         bt_addr = (char *)&addr;
13270         link_type = ev->link_type;
13271         alert_type = ev->alert_type;
13272         rssi_dbm = ev->rssi_dbm;
13273         g_dbus_emit_signal(dbus_conn, adapter->path,
13274                         ADAPTER_INTERFACE, "RssiAlert",
13275                         DBUS_TYPE_STRING, &bt_addr,
13276                         DBUS_TYPE_INT32, &link_type,
13277                         DBUS_TYPE_INT32, &alert_type,
13278                         DBUS_TYPE_INT32, &rssi_dbm,
13279                         DBUS_TYPE_INVALID);
13280 }
13281
13282 static void get_raw_rssi_callback(uint16_t index, uint16_t length,
13283                                         const void *param, void *user_data)
13284 {
13285         const struct mgmt_cc_rp_get_raw_rssi *ev = param;
13286         struct btd_adapter *adapter = user_data;
13287         char addr[18];
13288         char *bt_addr =  NULL;
13289         int link_type = -1;
13290         int rssi_dbm = 0;
13291
13292         if (length < sizeof(*ev)) {
13293                 error("Too small raw RSSI event");
13294                 return;
13295         }
13296
13297         ba2str(&ev->bt_address, addr);
13298         DBG("hci%u %s", index, addr);
13299         DBG("Raw RSSI Params [%d %d]", ev->link_type, ev->rssi_dbm);
13300
13301         bt_addr = (char *)&addr;
13302         link_type = ev->link_type;
13303         rssi_dbm = ev->rssi_dbm;
13304
13305         g_dbus_emit_signal(dbus_conn, adapter->path,
13306                         ADAPTER_INTERFACE, "RawRssi",
13307                         DBUS_TYPE_STRING, &bt_addr,
13308                         DBUS_TYPE_INT32, &link_type,
13309                         DBUS_TYPE_INT32, &rssi_dbm,
13310                         DBUS_TYPE_INVALID);
13311 }
13312
13313 static void rssi_enabled_callback(uint16_t index, uint16_t length,
13314                                         const void *param, void *user_data)
13315 {
13316         const struct mgmt_cc_rsp_enable_rssi *ev = param;
13317         struct btd_adapter *adapter = user_data;
13318         char addr[18];
13319         char *bt_addr =  NULL;
13320         int enabled = TRUE;
13321         int link_type = -1;
13322
13323         if (length < sizeof(*ev)) {
13324                 error("Too small rssi enabled event");
13325                 return;
13326         }
13327
13328         ba2str(&ev->bt_address, addr);
13329         DBG("hci%u %s %d", index, addr, ev->link_type);
13330         DBG("RSSI Enabled [%d %d]", ev->le_ext_opcode, ev->status);
13331
13332         bt_addr = (char *)&addr;
13333         link_type = ev->link_type;
13334
13335         g_dbus_emit_signal(dbus_conn, adapter->path,
13336                         ADAPTER_INTERFACE, "RssiEnabled",
13337                         DBUS_TYPE_STRING, &bt_addr,
13338                         DBUS_TYPE_INT32, &link_type,
13339                         DBUS_TYPE_BOOLEAN, &enabled,
13340                         DBUS_TYPE_INVALID);
13341 }
13342
13343 static void rssi_disabled_callback(uint16_t index, uint16_t length,
13344                                         const void *param, void *user_data)
13345 {
13346         const struct mgmt_cc_rp_disable_rssi *ev = param;
13347         struct btd_adapter *adapter = user_data;
13348         char addr[18];
13349         char *bt_addr =  NULL;
13350         int disabled = FALSE;
13351         int link_type = -1;
13352
13353         if (length < sizeof(*ev)) {
13354                 error("Too small RSSI disabled event");
13355                 return;
13356         }
13357
13358         ba2str(&ev->bt_address, addr);
13359         DBG("hci%u %s %d", index, addr, ev->link_type);
13360         DBG("RSSI Disabled Params [%d %d]", ev->le_ext_opcode, ev->status);
13361
13362         bt_addr = (char *)&addr;
13363         link_type = ev->link_type;
13364
13365         g_dbus_emit_signal(dbus_conn, adapter->path,
13366                         ADAPTER_INTERFACE, "RssiEnabled",
13367                         DBUS_TYPE_STRING, &bt_addr,
13368                         DBUS_TYPE_INT32, &link_type,
13369                         DBUS_TYPE_BOOLEAN, &disabled,
13370                         DBUS_TYPE_INVALID);
13371 }
13372
13373 void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver)
13374 {
13375         char *ver;
13376
13377         switch (hci_ver) {
13378         case 0:
13379                 ver = "Bluetooth 1.0b";
13380                 break;
13381         case 1:
13382                 ver = "Bluetooth 1.1";
13383                 break;
13384         case 2:
13385                 ver = "Bluetooth 1.2";
13386                 break;
13387         case 3:
13388                 ver = "Bluetooth 2.0 + EDR";
13389                 break;
13390         case 4:
13391                 ver = "Bluetooth 2.1 + EDR";
13392                 break;
13393         case 5:
13394                 ver = "Bluetooth 3.0 + HS";
13395                 break;
13396         case 6:
13397                 ver = "Bluetooth 4.0";
13398                 break;
13399         case 7:
13400                 ver = "Bluetooth 4.1";
13401                 break;
13402         default:
13403                 ver = "Unknown";
13404                 break;
13405         }
13406
13407         if (adapter->version)
13408                 g_free(adapter->version);
13409
13410         adapter->version = g_strdup(ver);
13411 }
13412
13413 static void hardware_error_callback(uint16_t index, uint16_t length,
13414                 const void *param, void *user_data)
13415 {
13416         const struct mgmt_ev_hardware_error *ev = param;
13417         struct btd_adapter *adapter = user_data;
13418
13419         if (length < sizeof(*ev)) {
13420                 error("Too small Hardware error event");
13421                 return;
13422         }
13423
13424         error("Hardware error occurred : %d", ev->error_code);
13425         g_dbus_emit_signal(dbus_conn, adapter->path,
13426                         ADAPTER_INTERFACE, "HardwareError",
13427                         DBUS_TYPE_INVALID);
13428 }
13429
13430 static void tx_timeout_error_callback(uint16_t index, uint16_t length,
13431                 const void *param, void *user_data)
13432 {
13433         struct btd_adapter *adapter = user_data;
13434
13435         error("Tx Timeout error occurred");
13436         g_dbus_emit_signal(dbus_conn, adapter->path,
13437                         ADAPTER_INTERFACE, "TxTimeoutError",
13438                         DBUS_TYPE_INVALID);
13439 }
13440
13441 static void device_name_update_callback(uint16_t index, uint16_t length,
13442                 const void *param, void *user_data)
13443 {
13444         const struct mgmt_ev_device_name_update *ev = param;
13445         struct btd_adapter *adapter = user_data;
13446         struct btd_device *device;
13447         char addr[18];
13448         const uint8_t *eir_name;
13449         struct eir_data eir_data;
13450
13451         if (length < sizeof(*ev)) {
13452                 error("Name update error event");
13453                 return;
13454         }
13455
13456         ba2str(&ev->addr.bdaddr, addr);
13457         DBG("hci%u %s", index, addr);
13458
13459         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13460                                                                 ev->addr.type);
13461         if (!device) {
13462                 error("Unable to get device object for %s", addr);
13463                 return;
13464         }
13465
13466         if (ev->eir_len == 0)
13467                 return;
13468
13469         eir_name = ev->eir;
13470
13471         memset(&eir_data, 0, sizeof(eir_data));
13472         eir_parse(&eir_data, eir_name, ev->eir_len);
13473
13474         if (eir_data.name)
13475                 btd_device_device_set_name(device, eir_data.name);
13476
13477         eir_data_free(&eir_data);
13478 }
13479
13480 struct multi_adv_data {
13481         struct btd_adapter *adapter;
13482         uint8_t slot_id;
13483 };
13484
13485 static gboolean multi_adv_start_timeout_cb(gpointer user_data)
13486 {
13487         struct multi_adv_data *data = user_data;
13488         struct btd_adapter *adapter = data->adapter;
13489         dbus_bool_t err;
13490
13491         adapter->adv_restart_timeout = 0;
13492
13493         err = adapter_le_enable_multi_adv(adapter, TRUE, data->slot_id);
13494         if (!err)
13495                 advertising_state_changed(adapter, data->slot_id, FALSE);
13496
13497         g_free(data);
13498         return FALSE;
13499 }
13500
13501 static void multi_adv_state_change_callback(uint16_t index, uint16_t length,
13502                                         const void *param, void *user_data)
13503 {
13504         const struct mgmt_ev_vendor_specific_multi_adv_state_changed *ev = param;
13505         struct btd_adapter *adapter = user_data;
13506         struct multi_adv_data *data;
13507
13508         if (length < sizeof(*ev)) {
13509                 error("Too small adv state change event");
13510                 return;
13511         }
13512
13513         DBG("adv id %d, state change reason %d, connection_handle %x",
13514                 ev->adv_instance, ev->state_change_reason, ev->connection_handle);
13515
13516         if ((ev->adv_instance > 0 && ev->adv_instance < adapter_le_get_max_adv_instance()) &&
13517                         ev->state_change_reason == 0) {
13518                 /* advertising is stopped by controller, it should be enabled again.
13519                 * If fails, state should be changed to FALSE */
13520                 data = g_new0(struct multi_adv_data, 1);
13521                 data->adapter = adapter;
13522                 data->slot_id = ev->adv_instance;
13523
13524                 adapter->adv_restart_timeout =
13525                         g_timeout_add(300, multi_adv_start_timeout_cb, data);
13526         }
13527 }
13528
13529 static void le_conn_update_completed_callback(uint16_t index, uint16_t length,
13530                                         const void *param, void *user_data)
13531 {
13532         const struct mgmt_ev_conn_updated *ev = param;
13533         struct btd_adapter *adapter = user_data;
13534         struct btd_device *device;
13535         char addr[18];
13536         GSList *list = NULL;
13537
13538         if (length < sizeof(*ev)) {
13539                 error("Too small le conn update completed event");
13540                 return;
13541         }
13542
13543         ba2str(&ev->addr.bdaddr, addr);
13544         if (ev->addr.type == BDADDR_LE_PUBLIC) {
13545                 /* Private Random Address */
13546                 list = g_slist_find_custom(adapter->devices, addr,
13547                                                 device_rpa_ida_cmp);
13548                 /* LE Public */
13549                 if (!list)
13550                         list = g_slist_find_custom(adapter->devices, addr,
13551                                                         device_address_cmp);
13552         } else if (ev->addr.type == BDADDR_LE_RANDOM) {
13553                 /* LE Static Random address */
13554                 list = g_slist_find_custom(adapter->devices, addr,
13555                                                         device_address_cmp);
13556         }
13557
13558         if (list) {
13559                 device = list->data;
13560                 device_print_addr(device);
13561
13562                 if (device_get_conn_update_state(device))
13563                         device_set_conn_update_state(device, false);
13564         }
13565 }
13566
13567 static void bt_6lowpan_conn_state_change_callback(uint16_t index, uint16_t length,
13568                                         const void *param, void *user_data)
13569 {
13570         const struct mgmt_ev_6lowpan_conn_state_changed *ev = param;
13571         struct btd_adapter *adapter = user_data;
13572         struct btd_device *device;
13573         char addr[18];
13574         gboolean connected = 0;
13575
13576         if (length < sizeof(*ev)) {
13577                 btd_error(adapter->dev_id,
13578                         "Too small device connected event");
13579                 return;
13580         }
13581
13582         ba2str(&ev->addr.bdaddr, addr);
13583
13584         DBG("hci%u device %s", index, addr);
13585
13586         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13587                                                                 ev->addr.type);
13588         if (!device) {
13589                 btd_error(adapter->dev_id,
13590                         "Unable to get device object for %s", addr);
13591                 return;
13592         }
13593
13594         if (ev->connected)
13595                 connected = TRUE;
13596         else
13597                 connected = FALSE;
13598
13599         device_set_ipsp_connected(device, connected, ev->ifname);
13600 }
13601
13602 static void bt_le_data_length_changed_callback(uint16_t index, uint16_t length,
13603                                         const void *param, void *user_data)
13604 {
13605         const struct mgmt_ev_le_data_length_changed *ev = param;
13606         struct btd_adapter *adapter = user_data;
13607         struct btd_device *device;
13608         char addr[18];
13609
13610         if (length < sizeof(*ev)) {
13611                 btd_error(adapter->dev_id,
13612                         "Too small data length changed event");
13613                 return;
13614         }
13615
13616         ba2str(&ev->addr.bdaddr, addr);
13617
13618         DBG("hci%u device %s", index, addr);
13619
13620         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13621                                                                 ev->addr.type);
13622         if (!device) {
13623                 btd_error(adapter->dev_id,
13624                         "Unable to get device object for %s", addr);
13625                 return;
13626         }
13627
13628         device_le_data_length_changed(device, ev->max_tx_octets, ev->max_tx_time,
13629                 ev->max_rx_octets, ev->max_rx_time);
13630 }
13631
13632 #endif
13633
13634 struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
13635                                                 struct btd_adapter *adapter)
13636 {
13637         struct btd_adapter_pin_cb_iter *iter =
13638                                 g_new0(struct btd_adapter_pin_cb_iter, 1);
13639
13640         iter->it = adapter->pin_callbacks;
13641         iter->attempt = 1;
13642
13643         return iter;
13644 }
13645
13646 void btd_adapter_pin_cb_iter_free(struct btd_adapter_pin_cb_iter *iter)
13647 {
13648         g_free(iter);
13649 }
13650
13651 bool btd_adapter_pin_cb_iter_end(struct btd_adapter_pin_cb_iter *iter)
13652 {
13653         return iter->it == NULL && iter->attempt == 0;
13654 }
13655
13656 static ssize_t btd_adapter_pin_cb_iter_next(
13657                                         struct btd_adapter_pin_cb_iter *iter,
13658                                         struct btd_adapter *adapter,
13659                                         struct btd_device *device,
13660                                         char *pin_buf, bool *display)
13661 {
13662         btd_adapter_pin_cb_t cb;
13663         ssize_t ret;
13664
13665         while (iter->it != NULL) {
13666                 cb = iter->it->data;
13667                 ret = cb(adapter, device, pin_buf, display, iter->attempt);
13668                 iter->attempt++;
13669                 if (ret > 0)
13670                         return ret;
13671                 iter->attempt = 1;
13672                 iter->it = g_slist_next(iter->it);
13673         }
13674         iter->attempt = 0;
13675
13676         return 0;
13677 }
13678
13679 static void pin_code_request_callback(uint16_t index, uint16_t length,
13680                                         const void *param, void *user_data)
13681 {
13682         const struct mgmt_ev_pin_code_request *ev = param;
13683         struct btd_adapter *adapter = user_data;
13684         struct btd_device *device;
13685         bool display = false;
13686         char pin[17];
13687         ssize_t pinlen;
13688         char addr[18];
13689         int err;
13690         struct btd_adapter_pin_cb_iter *iter;
13691
13692         if (length < sizeof(*ev)) {
13693                 btd_error(adapter->dev_id, "Too small PIN code request event");
13694                 return;
13695         }
13696
13697         ba2str(&ev->addr.bdaddr, addr);
13698
13699         DBG("hci%u %s", adapter->dev_id, addr);
13700
13701         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13702                                                                 ev->addr.type);
13703         if (!device) {
13704                 btd_error(adapter->dev_id,
13705                                 "Unable to get device object for %s", addr);
13706                 return;
13707         }
13708
13709         /* Flag the request of a pincode to allow a bonding retry. */
13710         adapter->pincode_requested = true;
13711 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13712         btd_device_set_legacy_pairing(device, true);
13713 #endif
13714
13715         memset(pin, 0, sizeof(pin));
13716
13717         iter = device_bonding_iter(device);
13718         if (iter == NULL)
13719                 pinlen = 0;
13720         else
13721                 pinlen = btd_adapter_pin_cb_iter_next(iter, adapter, device,
13722                                                                 pin, &display);
13723
13724         if (pinlen > 0 && (!ev->secure || pinlen == 16)) {
13725                 if (display && device_is_bonding(device, NULL)) {
13726                         err = device_notify_pincode(device, ev->secure, pin);
13727                         if (err < 0) {
13728                                 btd_error(adapter->dev_id,
13729                                                 "device_notify_pin: %s",
13730                                                         strerror(-err));
13731                                 btd_adapter_pincode_reply(adapter,
13732                                                         &ev->addr.bdaddr,
13733                                                         NULL, 0);
13734                         }
13735                 } else {
13736                         btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
13737                                                                 pin, pinlen);
13738                 }
13739                 return;
13740         }
13741
13742 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13743         if (btd_opts.pin_code) {
13744                 /* Because we can't receive user input on headless device,
13745                    no need to request pincode. Use the 'PinCode' in headless conf file */
13746                 DBG("Use configured PinCode in headless device");
13747                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
13748                                 btd_opts.pin_code, strlen(btd_opts.pin_code));
13749                 return;
13750         }
13751 #endif
13752
13753         err = device_request_pincode(device, ev->secure);
13754         if (err < 0) {
13755                 btd_error(adapter->dev_id, "device_request_pin: %s",
13756                                                         strerror(-err));
13757                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
13758         }
13759 }
13760
13761 int adapter_cancel_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13762                                                         uint8_t addr_type)
13763 {
13764         struct mgmt_addr_info cp;
13765         char addr[18];
13766
13767         ba2str(bdaddr, addr);
13768         DBG("hci%u bdaddr %s type %u", adapter->dev_id, addr, addr_type);
13769
13770         memset(&cp, 0, sizeof(cp));
13771         bacpy(&cp.bdaddr, bdaddr);
13772         cp.type = addr_type;
13773
13774         if (mgmt_reply(adapter->mgmt, MGMT_OP_CANCEL_PAIR_DEVICE,
13775                                 adapter->dev_id, sizeof(cp), &cp,
13776                                 NULL, NULL, NULL) > 0)
13777                 return 0;
13778
13779         return -EIO;
13780 }
13781
13782 static void check_oob_bonding_complete(struct btd_adapter *adapter,
13783                                         const bdaddr_t *bdaddr, uint8_t status)
13784 {
13785         if (!adapter->oob_handler || !adapter->oob_handler->bonding_cb)
13786                 return;
13787
13788         if (bacmp(bdaddr, &adapter->oob_handler->remote_addr) != 0)
13789                 return;
13790
13791         adapter->oob_handler->bonding_cb(adapter, bdaddr, status,
13792                                         adapter->oob_handler->user_data);
13793
13794         g_free(adapter->oob_handler);
13795         adapter->oob_handler = NULL;
13796 }
13797
13798 static void bonding_complete(struct btd_adapter *adapter,
13799                                         const bdaddr_t *bdaddr,
13800                                         uint8_t addr_type, uint8_t status)
13801 {
13802         struct btd_device *device;
13803
13804         if (status == 0)
13805                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
13806         else
13807                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
13808
13809         if (device != NULL)
13810                 device_bonding_complete(device, addr_type, status);
13811
13812 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
13813         resume_discovery(adapter);
13814 #endif
13815         check_oob_bonding_complete(adapter, bdaddr, status);
13816 }
13817
13818 /* bonding_attempt_complete() handles the end of a "bonding attempt" checking if
13819  * it should begin a new attempt or complete the bonding.
13820  */
13821 static void bonding_attempt_complete(struct btd_adapter *adapter,
13822                                         const bdaddr_t *bdaddr,
13823                                         uint8_t addr_type, uint8_t status)
13824 {
13825         struct btd_device *device;
13826         char addr[18];
13827
13828         ba2str(bdaddr, addr);
13829         DBG("hci%u bdaddr %s type %u status 0x%x", adapter->dev_id, addr,
13830                                                         addr_type, status);
13831
13832         if (status == 0)
13833                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
13834         else
13835                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
13836
13837         if (status == MGMT_STATUS_AUTH_FAILED && adapter->pincode_requested) {
13838                 /* On faliure, issue a bonding_retry if possible. */
13839                 if (device != NULL) {
13840                         if (device_bonding_attempt_retry(device) == 0)
13841                                 return;
13842                 }
13843         }
13844
13845         /* Ignore disconnects during retry. */
13846         if (status == MGMT_STATUS_DISCONNECTED &&
13847                                         device && device_is_retrying(device))
13848                 return;
13849
13850         /* In any other case, finish the bonding. */
13851         bonding_complete(adapter, bdaddr, addr_type, status);
13852 }
13853
13854 struct pair_device_data {
13855         struct btd_adapter *adapter;
13856         bdaddr_t bdaddr;
13857         uint8_t addr_type;
13858 };
13859
13860 static void free_pair_device_data(void *user_data)
13861 {
13862         struct pair_device_data *data = user_data;
13863
13864         g_free(data);
13865 }
13866
13867 static bool pair_device_timeout(gpointer user_data)
13868 {
13869         struct pair_device_data *data = user_data;
13870         struct btd_adapter *adapter = data->adapter;
13871
13872         btd_error(adapter->dev_id, "Pair device timed out for hci%u",
13873                                                         adapter->dev_id);
13874
13875         adapter->pair_device_timeout = 0;
13876
13877         adapter_cancel_bonding(adapter, &data->bdaddr, data->addr_type);
13878
13879         return FALSE;
13880 }
13881
13882 static void pair_device_complete(uint8_t status, uint16_t length,
13883                                         const void *param, void *user_data)
13884 {
13885         const struct mgmt_rp_pair_device *rp = param;
13886         struct pair_device_data *data = user_data;
13887         struct btd_adapter *adapter = data->adapter;
13888
13889         DBG("%s (0x%02x)", mgmt_errstr(status), status);
13890
13891         adapter->pair_device_id = 0;
13892
13893         if (adapter->pair_device_timeout > 0) {
13894                 timeout_remove(adapter->pair_device_timeout);
13895                 adapter->pair_device_timeout = 0;
13896         }
13897
13898         /* Workaround for a kernel bug
13899          *
13900          * Broken kernels may reply to device pairing command with command
13901          * status instead of command complete event e.g. if adapter was not
13902          * powered.
13903          */
13904         if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
13905                 btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
13906                                                 mgmt_errstr(status), status);
13907
13908                 bonding_attempt_complete(adapter, &data->bdaddr,
13909                                                 data->addr_type, status);
13910                 return;
13911         }
13912
13913         if (length < sizeof(*rp)) {
13914                 btd_error(adapter->dev_id, "Too small pair device response");
13915                 return;
13916         }
13917
13918         bonding_attempt_complete(adapter, &rp->addr.bdaddr, rp->addr.type,
13919                                                                         status);
13920 }
13921
13922 int adapter_create_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13923                                         uint8_t addr_type, uint8_t io_cap)
13924 {
13925         if (adapter->pair_device_id > 0) {
13926                 btd_error(adapter->dev_id,
13927                         "Unable pair since another pairing is in progress");
13928                 return -EBUSY;
13929         }
13930
13931 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
13932         suspend_discovery(adapter);
13933 #endif
13934         return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
13935 }
13936
13937 /* Starts a new bonding attempt in a fresh new bonding_req or a retried one. */
13938 int adapter_bonding_attempt(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13939                                         uint8_t addr_type, uint8_t io_cap)
13940 {
13941         struct mgmt_cp_pair_device cp;
13942         char addr[18];
13943         struct pair_device_data *data;
13944         unsigned int id;
13945
13946         ba2str(bdaddr, addr);
13947         DBG("hci%u bdaddr %s type %d io_cap 0x%02x",
13948                                 adapter->dev_id, addr, addr_type, io_cap);
13949
13950         /* Reset the pincode_requested flag for a new bonding attempt. */
13951         adapter->pincode_requested = false;
13952
13953         memset(&cp, 0, sizeof(cp));
13954         bacpy(&cp.addr.bdaddr, bdaddr);
13955         cp.addr.type = addr_type;
13956         cp.io_cap = io_cap;
13957
13958         data = g_new0(struct pair_device_data, 1);
13959         data->adapter = adapter;
13960         bacpy(&data->bdaddr, bdaddr);
13961         data->addr_type = addr_type;
13962
13963         id = mgmt_send(adapter->mgmt, MGMT_OP_PAIR_DEVICE,
13964                                 adapter->dev_id, sizeof(cp), &cp,
13965                                 pair_device_complete, data,
13966                                 free_pair_device_data);
13967
13968         if (id == 0) {
13969                 btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
13970                                                         addr, adapter->dev_id);
13971                 free_pair_device_data(data);
13972                 return -EIO;
13973         }
13974
13975         adapter->pair_device_id = id;
13976
13977         /* Due to a bug in the kernel it is possible that a LE pairing
13978          * request never times out. Therefore, add a timer to clean up
13979          * if no response arrives
13980          */
13981         adapter->pair_device_timeout = timeout_add_seconds(BONDING_TIMEOUT,
13982                                                 pair_device_timeout, data,
13983                                                 NULL);
13984
13985         return 0;
13986 }
13987
13988 static void disconnect_notify(struct btd_device *dev, uint8_t reason)
13989 {
13990         GSList *l;
13991
13992         for (l = disconnect_list; l; l = g_slist_next(l)) {
13993                 btd_disconnect_cb disconnect_cb = l->data;
13994                 disconnect_cb(dev, reason);
13995         }
13996 }
13997
13998 static void dev_disconnected(struct btd_adapter *adapter,
13999                                         const struct mgmt_addr_info *addr,
14000                                         uint8_t reason)
14001 {
14002         struct btd_device *device;
14003         char dst[18];
14004 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14005         struct device_addr_type t_addr;
14006 #endif
14007
14008         ba2str(&addr->bdaddr, dst);
14009
14010         DBG("Device %s disconnected, reason %u", dst, reason);
14011
14012         device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
14013
14014 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14015         if (device) {
14016                 device_get_tizen_addr(device, addr->type, &t_addr);
14017
14018                 device_set_disconnect_reason(device, reason);
14019                 adapter_remove_connection(adapter, device, t_addr.bdaddr_type);
14020                 disconnect_notify(device, reason);
14021                 if (device_is_bonded(device, t_addr.bdaddr_type)) {
14022                         DBG("addr type %d, bonded", t_addr.bdaddr_type);
14023                         return;
14024                 }
14025
14026                 bonding_attempt_complete(adapter, &t_addr.bdaddr,
14027                                 t_addr.bdaddr_type, MGMT_STATUS_DISCONNECTED);
14028                 return;
14029         }
14030 #else
14031         if (device) {
14032                 adapter_remove_connection(adapter, device, addr->type);
14033                 disconnect_notify(device, reason);
14034         }
14035 #endif
14036
14037         bonding_attempt_complete(adapter, &addr->bdaddr, addr->type,
14038                                                 MGMT_STATUS_DISCONNECTED);
14039 }
14040
14041 void btd_add_disconnect_cb(btd_disconnect_cb func)
14042 {
14043         disconnect_list = g_slist_append(disconnect_list, func);
14044 }
14045
14046 void btd_remove_disconnect_cb(btd_disconnect_cb func)
14047 {
14048         disconnect_list = g_slist_remove(disconnect_list, func);
14049 }
14050
14051 static void disconnect_complete(uint8_t status, uint16_t length,
14052                                         const void *param, void *user_data)
14053 {
14054         const struct mgmt_rp_disconnect *rp = param;
14055         struct btd_adapter *adapter = user_data;
14056
14057         if (status == MGMT_STATUS_NOT_CONNECTED) {
14058                 btd_warn(adapter->dev_id,
14059                                 "Disconnecting failed: already disconnected");
14060         } else if (status != MGMT_STATUS_SUCCESS) {
14061                 btd_error(adapter->dev_id,
14062                                 "Failed to disconnect device: %s (0x%02x)",
14063                                                 mgmt_errstr(status), status);
14064                 return;
14065         }
14066
14067         if (length < sizeof(*rp)) {
14068                 btd_error(adapter->dev_id,
14069                                 "Too small device disconnect response");
14070                 return;
14071         }
14072
14073 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14074         /* Use HCI error code instead of MGMT disconnection reason */
14075         dev_disconnected(adapter, &rp->addr, 0x16);
14076 #else
14077         dev_disconnected(adapter, &rp->addr, MGMT_DEV_DISCONN_LOCAL_HOST);
14078 #endif
14079 }
14080
14081 int btd_adapter_disconnect_device(struct btd_adapter *adapter,
14082                                                 const bdaddr_t *bdaddr,
14083                                                 uint8_t bdaddr_type)
14084
14085 {
14086         struct mgmt_cp_disconnect cp;
14087
14088         memset(&cp, 0, sizeof(cp));
14089         bacpy(&cp.addr.bdaddr, bdaddr);
14090         cp.addr.type = bdaddr_type;
14091
14092         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT,
14093                                 adapter->dev_id, sizeof(cp), &cp,
14094                                 disconnect_complete, adapter, NULL) > 0)
14095                 return 0;
14096
14097         return -EIO;
14098 }
14099
14100 static void auth_failed_callback(uint16_t index, uint16_t length,
14101                                         const void *param, void *user_data)
14102 {
14103         const struct mgmt_ev_auth_failed *ev = param;
14104         struct btd_adapter *adapter = user_data;
14105
14106         if (length < sizeof(*ev)) {
14107                 btd_error(adapter->dev_id, "Too small auth failed mgmt event");
14108                 return;
14109         }
14110
14111         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
14112                                                                 ev->status);
14113 }
14114
14115 static void store_link_key(struct btd_adapter *adapter,
14116                                 struct btd_device *device, const uint8_t *key,
14117                                 uint8_t type, uint8_t pin_length)
14118 {
14119         char device_addr[18];
14120         char filename[PATH_MAX];
14121         GKeyFile *key_file;
14122         GError *gerr = NULL;
14123         gsize length = 0;
14124         char key_str[33];
14125         char *str;
14126         int i;
14127
14128         ba2str(device_get_address(device), device_addr);
14129
14130         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
14131                         btd_adapter_get_storage_dir(adapter), device_addr);
14132         create_file(filename, 0600);
14133
14134         key_file = g_key_file_new();
14135         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14136                 error("Unable to load key file from %s: (%s)", filename,
14137                                                                 gerr->message);
14138                 g_error_free(gerr);
14139                 g_key_file_free(key_file);
14140                 return;
14141         }
14142
14143         for (i = 0; i < 16; i++)
14144                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14145
14146         g_key_file_set_string(key_file, "LinkKey", "Key", key_str);
14147
14148         g_key_file_set_integer(key_file, "LinkKey", "Type", type);
14149         g_key_file_set_integer(key_file, "LinkKey", "PINLength", pin_length);
14150
14151         create_file(filename, 0600);
14152
14153         str = g_key_file_to_data(key_file, &length, NULL);
14154         if (!g_file_set_contents(filename, str, length, &gerr)) {
14155                 error("Unable set contents for %s: (%s)", filename,
14156                                                                 gerr->message);
14157                 g_error_free(gerr);
14158         }
14159         g_free(str);
14160
14161         g_key_file_free(key_file);
14162 }
14163
14164 static void new_link_key_callback(uint16_t index, uint16_t length,
14165                                         const void *param, void *user_data)
14166 {
14167         const struct mgmt_ev_new_link_key *ev = param;
14168         const struct mgmt_addr_info *addr = &ev->key.addr;
14169         struct btd_adapter *adapter = user_data;
14170         struct btd_device *device;
14171         char dst[18];
14172
14173         if (length < sizeof(*ev)) {
14174                 btd_error(adapter->dev_id, "Too small new link key event");
14175                 return;
14176         }
14177
14178         ba2str(&addr->bdaddr, dst);
14179
14180         DBG("hci%u new key for %s type %u pin_len %u store_hint %u",
14181                 adapter->dev_id, dst, ev->key.type, ev->key.pin_len,
14182                 ev->store_hint);
14183
14184         if (ev->key.pin_len > 16) {
14185                 btd_error(adapter->dev_id,
14186                                 "Invalid PIN length (%u) in new_key event",
14187                                                         ev->key.pin_len);
14188                 return;
14189         }
14190
14191         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14192         if (!device) {
14193                 btd_error(adapter->dev_id,
14194                                 "Unable to get device object for %s", dst);
14195                 return;
14196         }
14197
14198         if (ev->store_hint) {
14199                 const struct mgmt_link_key_info *key = &ev->key;
14200
14201                 store_link_key(adapter, device, key->val, key->type,
14202                                                                 key->pin_len);
14203
14204                 device_set_bonded(device, BDADDR_BREDR);
14205 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14206         } else {
14207                 if (btd_adapter_get_a2dp_role(adapter) == BLUETOOTH_A2DP_SINK_ROLE) {
14208                         DBG("store_hint %d", ev->store_hint);
14209                         btd_device_set_temporary(device, false);
14210                 }
14211         }
14212 #else
14213         }
14214 #endif
14215
14216         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14217 }
14218
14219 static void store_ltk_group(struct btd_adapter *adapter, const bdaddr_t *peer,
14220                                 uint8_t bdaddr_type, const unsigned char *key,
14221                                 const char *group, uint8_t authenticated,
14222                                 uint8_t enc_size, uint16_t ediv,
14223                                 uint64_t rand)
14224 {
14225         char device_addr[18];
14226         char filename[PATH_MAX];
14227         GKeyFile *key_file;
14228         GError *gerr = NULL;
14229         char key_str[33];
14230         gsize length = 0;
14231         char *str;
14232         int i;
14233
14234         ba2str(peer, device_addr);
14235
14236         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
14237                         btd_adapter_get_storage_dir(adapter), device_addr);
14238         key_file = g_key_file_new();
14239         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14240                 error("Unable to load key file from %s: (%s)", filename,
14241                                                                 gerr->message);
14242                 g_error_free(gerr);
14243         }
14244
14245         for (i = 0; i < 16; i++)
14246                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14247
14248         g_key_file_set_string(key_file, group, "Key", key_str);
14249
14250         g_key_file_set_integer(key_file, group, "Authenticated",
14251                         authenticated);
14252         g_key_file_set_integer(key_file, group, "EncSize", enc_size);
14253
14254         g_key_file_set_integer(key_file, group, "EDiv", ediv);
14255         g_key_file_set_uint64(key_file, group, "Rand", rand);
14256
14257         create_file(filename, 0600);
14258
14259         str = g_key_file_to_data(key_file, &length, NULL);
14260         if (!g_file_set_contents(filename, str, length, &gerr)) {
14261                 error("Unable set contents for %s: (%s)", filename,
14262                                                                 gerr->message);
14263                 g_error_free(gerr);
14264         }
14265         g_free(str);
14266
14267         g_key_file_free(key_file);
14268 }
14269
14270 static void store_longtermkey(struct btd_adapter *adapter, const bdaddr_t *peer,
14271                                 uint8_t bdaddr_type, const unsigned char *key,
14272                                 uint8_t central, uint8_t authenticated,
14273                                 uint8_t enc_size, uint16_t ediv,
14274                                 uint64_t rand)
14275 {
14276         if (central != 0x00 && central != 0x01) {
14277                 error("Unsupported LTK type %u", central);
14278                 return;
14279         }
14280
14281         if (central) {
14282                 store_ltk_group(adapter, peer, bdaddr_type, key, "LongTermKey",
14283                                 authenticated, enc_size, ediv, rand);
14284         } else {
14285                 /* Peripheral* is the proper term, but for now keep duplicates
14286                  * so it won't break when user up/downgrades. Remove the other
14287                  * term after a few releases.
14288                  */
14289                 store_ltk_group(adapter, peer, bdaddr_type, key,
14290                                 "PeripheralLongTermKey", authenticated,
14291                                 enc_size, ediv, rand);
14292                 store_ltk_group(adapter, peer, bdaddr_type, key,
14293                                 "SlaveLongTermKey", authenticated,
14294                                 enc_size, ediv, rand);
14295         }
14296 }
14297
14298 static void new_long_term_key_callback(uint16_t index, uint16_t length,
14299                                         const void *param, void *user_data)
14300 {
14301         const struct mgmt_ev_new_long_term_key *ev = param;
14302         const struct mgmt_addr_info *addr = &ev->key.addr;
14303         struct btd_adapter *adapter = user_data;
14304         struct btd_device *device;
14305         bool persistent;
14306         char dst[18];
14307 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14308         struct device_addr_type t_addr;
14309 #endif
14310
14311         if (length < sizeof(*ev)) {
14312                 btd_error(adapter->dev_id, "Too small long term key event");
14313                 return;
14314         }
14315
14316         ba2str(&addr->bdaddr, dst);
14317
14318         DBG("hci%u new LTK for %s type %u enc_size %u",
14319                 adapter->dev_id, dst, ev->key.type, ev->key.enc_size);
14320
14321         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14322         if (!device) {
14323                 btd_error(adapter->dev_id,
14324                                 "Unable to get device object for %s", dst);
14325                 return;
14326         }
14327
14328         /*
14329          * Some older kernel versions set store_hint for long term keys
14330          * from resolvable and unresolvable random addresses, but there
14331          * is no point in storing these. Next time around the device
14332          * address will be invalid.
14333          *
14334          * So only for identity addresses (public and static random) use
14335          * the store_hint as an indication if the long term key should
14336          * be persistently stored.
14337          *
14338          */
14339         if (addr->type == BDADDR_LE_RANDOM &&
14340                                 (addr->bdaddr.b[5] & 0xc0) != 0xc0)
14341                 persistent = false;
14342         else
14343                 persistent = !!ev->store_hint;
14344
14345         if (persistent) {
14346                 const struct mgmt_ltk_info *key = &ev->key;
14347                 uint16_t ediv;
14348                 uint64_t rand;
14349
14350                 ediv = le16_to_cpu(key->ediv);
14351                 rand = le64_to_cpu(key->rand);
14352
14353 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14354                 device_get_tizen_addr(device, addr->type, &t_addr);
14355                 store_longtermkey(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14356                                         key->val, key->central, key->type,
14357                                         key->enc_size, ediv, rand);
14358 #else
14359                 store_longtermkey(adapter, &key->addr.bdaddr,
14360                                         key->addr.type, key->val, key->central,
14361                                         key->type, key->enc_size, ediv, rand);
14362 #endif
14363
14364                 device_set_bonded(device, addr->type);
14365         }
14366
14367         device_set_ltk_enc_size(device, ev->key.enc_size);
14368
14369         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14370 }
14371
14372 static void store_csrk(struct btd_adapter *adapter, const bdaddr_t *peer,
14373                                 uint8_t bdaddr_type, const unsigned char *key,
14374                                 uint32_t counter, uint8_t type)
14375 {
14376         const char *group;
14377         char device_addr[18];
14378         char filename[PATH_MAX];
14379         GKeyFile *key_file;
14380         GError *gerr = NULL;
14381         char key_str[33];
14382         gsize length = 0;
14383         gboolean auth;
14384         char *str;
14385         int i;
14386
14387         switch (type) {
14388         case 0x00:
14389                 group = "LocalSignatureKey";
14390                 auth = FALSE;
14391                 break;
14392         case 0x01:
14393                 group = "RemoteSignatureKey";
14394                 auth = FALSE;
14395                 break;
14396         case 0x02:
14397                 group = "LocalSignatureKey";
14398                 auth = TRUE;
14399                 break;
14400         case 0x03:
14401                 group = "RemoteSignatureKey";
14402                 auth = TRUE;
14403                 break;
14404         default:
14405                 warn("Unsupported CSRK type %u", type);
14406                 return;
14407         }
14408
14409         ba2str(peer, device_addr);
14410
14411         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
14412                         btd_adapter_get_storage_dir(adapter), device_addr);
14413
14414         key_file = g_key_file_new();
14415         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14416                 error("Unable to load key file from %s: (%s)", filename,
14417                                                                 gerr->message);
14418                 g_error_free(gerr);
14419         }
14420
14421         for (i = 0; i < 16; i++)
14422                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14423
14424         g_key_file_set_string(key_file, group, "Key", key_str);
14425         g_key_file_set_integer(key_file, group, "Counter", counter);
14426         g_key_file_set_boolean(key_file, group, "Authenticated", auth);
14427
14428         create_file(filename, 0600);
14429
14430         str = g_key_file_to_data(key_file, &length, NULL);
14431         if (!g_file_set_contents(filename, str, length, &gerr)) {
14432                 error("Unable set contents for %s: (%s)", filename,
14433                                                                 gerr->message);
14434                 g_error_free(gerr);
14435         }
14436         g_free(str);
14437
14438         g_key_file_free(key_file);
14439 }
14440
14441 static void new_csrk_callback(uint16_t index, uint16_t length,
14442                                         const void *param, void *user_data)
14443 {
14444         const struct mgmt_ev_new_csrk *ev = param;
14445         const struct mgmt_addr_info *addr = &ev->key.addr;
14446         const struct mgmt_csrk_info *key = &ev->key;
14447         struct btd_adapter *adapter = user_data;
14448         struct btd_device *device;
14449         char dst[18];
14450 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14451         struct device_addr_type t_addr;
14452 #endif
14453
14454         if (length < sizeof(*ev)) {
14455                 btd_error(adapter->dev_id, "Too small CSRK event");
14456                 return;
14457         }
14458
14459         ba2str(&addr->bdaddr, dst);
14460
14461         DBG("hci%u new CSRK for %s type %u", adapter->dev_id, dst,
14462                                                                 ev->key.type);
14463
14464         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14465         if (!device) {
14466                 btd_error(adapter->dev_id,
14467                                 "Unable to get device object for %s", dst);
14468                 return;
14469         }
14470
14471         if (!ev->store_hint)
14472                 return;
14473
14474 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14475         device_get_tizen_addr(device, addr->type, &t_addr);
14476         store_csrk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, key->val, 0,
14477                                                                 key->type);
14478 #else
14479         store_csrk(adapter, &key->addr.bdaddr, key->addr.type, key->val, 0,
14480                                                                 key->type);
14481 #endif
14482
14483         btd_device_set_temporary(device, false);
14484 }
14485
14486 static void store_irk(struct btd_adapter *adapter, const bdaddr_t *peer,
14487                                 uint8_t bdaddr_type, const unsigned char *key)
14488 {
14489         char device_addr[18];
14490         char filename[PATH_MAX];
14491         GKeyFile *key_file;
14492         GError *gerr = NULL;
14493         char *store_data;
14494         char str[33];
14495         size_t length = 0;
14496         int i;
14497
14498         ba2str(peer, device_addr);
14499
14500         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
14501                         btd_adapter_get_storage_dir(adapter), device_addr);
14502         key_file = g_key_file_new();
14503         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14504                 error("Unable to load key file from %s: (%s)", filename,
14505                                                                 gerr->message);
14506                 g_error_free(gerr);
14507         }
14508
14509         for (i = 0; i < 16; i++)
14510                 sprintf(str + (i * 2), "%2.2X", key[i]);
14511
14512         g_key_file_set_string(key_file, "IdentityResolvingKey", "Key", str);
14513
14514         store_data = g_key_file_to_data(key_file, &length, NULL);
14515         if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14516                 error("Unable set contents for %s: (%s)", filename,
14517                                                                 gerr->message);
14518                 g_error_free(gerr);
14519         }
14520         g_free(store_data);
14521
14522         g_key_file_free(key_file);
14523 }
14524
14525 static void new_irk_callback(uint16_t index, uint16_t length,
14526                                         const void *param, void *user_data)
14527 {
14528         const struct mgmt_ev_new_irk *ev = param;
14529         const struct mgmt_addr_info *addr = &ev->key.addr;
14530         const struct mgmt_irk_info *irk = &ev->key;
14531         struct btd_adapter *adapter = user_data;
14532         struct btd_device *device, *duplicate;
14533         bool persistent;
14534         char dst[18], rpa[18];
14535 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14536         struct device_addr_type t_addr;
14537 #endif
14538
14539         if (length < sizeof(*ev)) {
14540                 btd_error(adapter->dev_id, "Too small New IRK event");
14541                 return;
14542         }
14543
14544         ba2str(&addr->bdaddr, dst);
14545         ba2str(&ev->rpa, rpa);
14546
14547         DBG("hci%u new IRK for %s RPA %s", adapter->dev_id, dst, rpa);
14548
14549         if (bacmp(&ev->rpa, BDADDR_ANY)) {
14550                 device = btd_adapter_get_device(adapter, &ev->rpa,
14551                                 BDADDR_LE_RANDOM);
14552 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14553                 device = btd_adapter_get_device(adapter, &ev->rpa,
14554                                                         BDADDR_LE_RANDOM);
14555                 duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
14556                                                                 addr->type);
14557                 if (duplicate == device)
14558                         duplicate = NULL;
14559 #else
14560                 device_set_rpa(device, &ev->rpa);
14561                 duplicate = NULL;
14562 #endif
14563         } else {
14564                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
14565                                                                 addr->type);
14566                 duplicate = NULL;
14567         }
14568
14569         if (!device) {
14570                 btd_error(adapter->dev_id,
14571                                 "Unable to get device object for %s", dst);
14572                 return;
14573         }
14574
14575         device_update_addr(device, &addr->bdaddr, addr->type);
14576
14577         if (duplicate)
14578                 device_merge_duplicate(device, duplicate);
14579
14580 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14581         device_set_irk_value(device, irk->val);
14582 #endif
14583
14584         persistent = !!ev->store_hint;
14585         if (!persistent)
14586                 return;
14587
14588 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14589         device_get_tizen_addr(device, addr->type, &t_addr);
14590         store_irk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, irk->val);
14591 #else
14592         store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
14593 #endif
14594
14595         btd_device_set_temporary(device, false);
14596 }
14597
14598 static void store_conn_param(struct btd_adapter *adapter, const bdaddr_t *peer,
14599                                 uint8_t bdaddr_type, uint16_t min_interval,
14600                                 uint16_t max_interval, uint16_t latency,
14601                                 uint16_t timeout)
14602 {
14603         char device_addr[18];
14604         char filename[PATH_MAX];
14605         GKeyFile *key_file;
14606         GError *gerr = NULL;
14607         char *store_data;
14608         size_t length = 0;
14609
14610         ba2str(peer, device_addr);
14611
14612         DBG("");
14613
14614         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
14615                         btd_adapter_get_storage_dir(adapter), device_addr);
14616         key_file = g_key_file_new();
14617         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14618                 error("Unable to load key file from %s: (%s)", filename,
14619                                                                 gerr->message);
14620                 g_error_free(gerr);
14621         }
14622
14623         g_key_file_set_integer(key_file, "ConnectionParameters",
14624                                                 "MinInterval", min_interval);
14625         g_key_file_set_integer(key_file, "ConnectionParameters",
14626                                                 "MaxInterval", max_interval);
14627         g_key_file_set_integer(key_file, "ConnectionParameters",
14628                                                 "Latency", latency);
14629         g_key_file_set_integer(key_file, "ConnectionParameters",
14630                                                 "Timeout", timeout);
14631
14632         create_file(filename, 0600);
14633
14634         store_data = g_key_file_to_data(key_file, &length, NULL);
14635         if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14636                 error("Unable set contents for %s: (%s)", filename,
14637                                                                 gerr->message);
14638                 g_error_free(gerr);
14639         }
14640         g_free(store_data);
14641
14642         g_key_file_free(key_file);
14643 }
14644
14645 static void new_conn_param(uint16_t index, uint16_t length,
14646                                         const void *param, void *user_data)
14647 {
14648         const struct mgmt_ev_new_conn_param *ev = param;
14649         struct btd_adapter *adapter = user_data;
14650         uint16_t min, max, latency, timeout;
14651         struct btd_device *dev;
14652         char dst[18];
14653 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14654         struct device_addr_type t_addr;
14655 #endif
14656
14657         if (length < sizeof(*ev)) {
14658                 btd_error(adapter->dev_id,
14659                                 "Too small New Connection Parameter event");
14660                 return;
14661         }
14662
14663         ba2str(&ev->addr.bdaddr, dst);
14664
14665         min = btohs(ev->min_interval);
14666         max = btohs(ev->max_interval);
14667         latency = btohs(ev->latency);
14668         timeout = btohs(ev->timeout);
14669
14670         DBG("hci%u %s (%u) min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
14671                 adapter->dev_id, dst, ev->addr.type, min, max, latency, timeout);
14672
14673         dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
14674         if (!dev) {
14675                 btd_error(adapter->dev_id,
14676                                 "Unable to get device object for %s", dst);
14677                 return;
14678         }
14679
14680         if (!ev->store_hint)
14681                 return;
14682
14683 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14684         device_get_tizen_addr(dev, ev->addr.type, &t_addr);
14685         store_conn_param(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14686                                         ev->min_interval, ev->max_interval,
14687                                         ev->latency, ev->timeout);
14688 #else
14689         store_conn_param(adapter, &ev->addr.bdaddr, ev->addr.type,
14690                                         ev->min_interval, ev->max_interval,
14691                                         ev->latency, ev->timeout);
14692 #endif
14693 }
14694
14695 int adapter_set_io_capability(struct btd_adapter *adapter, uint8_t io_cap)
14696 {
14697         struct mgmt_cp_set_io_capability cp;
14698
14699         if (!btd_opts.pairable) {
14700                 if (io_cap == IO_CAPABILITY_INVALID) {
14701                         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
14702                                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
14703
14704                         return 0;
14705                 }
14706
14707                 if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
14708                         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
14709         } else if (io_cap == IO_CAPABILITY_INVALID)
14710                 io_cap = IO_CAPABILITY_NOINPUTNOOUTPUT;
14711
14712         memset(&cp, 0, sizeof(cp));
14713         cp.io_capability = io_cap;
14714
14715         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IO_CAPABILITY,
14716                                 adapter->dev_id, sizeof(cp), &cp,
14717                                 NULL, NULL, NULL) > 0)
14718                 return 0;
14719
14720         return -EIO;
14721 }
14722
14723 int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
14724                                         const bdaddr_t *bdaddr,
14725                                         uint8_t *hash, uint8_t *randomizer)
14726 {
14727         struct mgmt_cp_add_remote_oob_data cp;
14728         char addr[18];
14729
14730         ba2str(bdaddr, addr);
14731         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14732
14733         memset(&cp, 0, sizeof(cp));
14734         bacpy(&cp.addr.bdaddr, bdaddr);
14735         memcpy(cp.hash192, hash, 16);
14736
14737         if (randomizer)
14738                 memcpy(cp.rand192, randomizer, 16);
14739
14740         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14741                                 adapter->dev_id, sizeof(cp), &cp,
14742                                 NULL, NULL, NULL) > 0)
14743                 return 0;
14744
14745         return -EIO;
14746 }
14747
14748 int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
14749                                                         const bdaddr_t *bdaddr)
14750 {
14751         struct mgmt_cp_remove_remote_oob_data cp;
14752         char addr[18];
14753
14754         ba2str(bdaddr, addr);
14755         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14756
14757         memset(&cp, 0, sizeof(cp));
14758         bacpy(&cp.addr.bdaddr, bdaddr);
14759
14760         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
14761                                 adapter->dev_id, sizeof(cp), &cp,
14762                                 NULL, NULL, NULL) > 0)
14763                 return 0;
14764
14765         return -EIO;
14766 }
14767
14768 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14769 int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
14770                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
14771                                 uint8_t *hash192, uint8_t *randomizer192,
14772                                 uint8_t *hash256, uint8_t *randomizer256)
14773 {
14774         struct mgmt_cp_add_remote_oob_data cp;
14775         char addr[18];
14776
14777         ba2str(bdaddr, addr);
14778         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
14779
14780         memset(&cp, 0, sizeof(cp));
14781         bacpy(&cp.addr.bdaddr, bdaddr);
14782         cp.addr.type = bdaddr_type;
14783
14784         if (hash192 && randomizer192) {
14785                 memcpy(cp.hash192, hash192, 16);
14786                 memcpy(cp.rand192, randomizer192, 16);
14787         }
14788
14789         if (hash256 && randomizer256) {
14790                 memcpy(cp.hash256, hash256, 16);
14791                 memcpy(cp.rand256, randomizer256, 16);
14792         }
14793
14794         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14795                                 adapter->dev_id, sizeof(cp), &cp,
14796                                 NULL, NULL, NULL) > 0)
14797                 return 0;
14798
14799         return -EIO;
14800 }
14801
14802 int btd_adapter_remove_remote_oob_ext_data(struct btd_adapter *adapter,
14803                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
14804 {
14805         struct mgmt_cp_remove_remote_oob_data cp;
14806         char addr[18];
14807
14808         ba2str(bdaddr, addr);
14809         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
14810
14811         memset(&cp, 0, sizeof(cp));
14812         bacpy(&cp.addr.bdaddr, bdaddr);
14813         cp.addr.type = bdaddr_type;
14814
14815         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
14816                                 adapter->dev_id, sizeof(cp), &cp,
14817                                 NULL, NULL, NULL) > 0)
14818                 return 0;
14819
14820         return -EIO;
14821 }
14822 #endif
14823
14824 bool btd_adapter_ssp_enabled(struct btd_adapter *adapter)
14825 {
14826         if (adapter->current_settings & MGMT_SETTING_SSP)
14827                 return true;
14828
14829         return false;
14830 }
14831
14832 void btd_adapter_set_oob_handler(struct btd_adapter *adapter,
14833                                                 struct oob_handler *handler)
14834 {
14835         adapter->oob_handler = handler;
14836 }
14837
14838 gboolean btd_adapter_check_oob_handler(struct btd_adapter *adapter)
14839 {
14840         return adapter->oob_handler != NULL;
14841 }
14842
14843 static void read_local_oob_data_complete(uint8_t status, uint16_t length,
14844                                         const void *param, void *user_data)
14845 {
14846         const struct mgmt_rp_read_local_oob_data *rp = param;
14847         struct btd_adapter *adapter = user_data;
14848         const uint8_t *hash, *randomizer;
14849 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14850         const uint8_t *hash256 = NULL;
14851         const uint8_t *randomizer256 = NULL;
14852 #endif
14853
14854         if (status != MGMT_STATUS_SUCCESS) {
14855                 btd_error(adapter->dev_id,
14856                                 "Read local OOB data failed: %s (0x%02x)",
14857                                                 mgmt_errstr(status), status);
14858                 hash = NULL;
14859                 randomizer = NULL;
14860 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14861         } else if (length < 32) {
14862 #else
14863         } else if (length < sizeof(*rp)) {
14864 #endif
14865                 btd_error(adapter->dev_id,
14866                                 "Too small read local OOB data response");
14867                 return;
14868         } else {
14869                 hash = rp->hash192;
14870                 randomizer = rp->rand192;
14871 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14872                 if (length > 32) {
14873                         hash256 = rp->hash256;
14874                         randomizer256 = rp->rand256;
14875                 }
14876 #endif
14877         }
14878
14879         if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
14880                 return;
14881
14882 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14883         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
14884                                         hash256, randomizer256,
14885                                         adapter->oob_handler->user_data);
14886 #else
14887         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
14888                                         adapter->oob_handler->user_data);
14889 #endif
14890
14891         g_free(adapter->oob_handler);
14892         adapter->oob_handler = NULL;
14893 }
14894
14895 int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
14896 {
14897         DBG("hci%u", adapter->dev_id);
14898
14899         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_DATA,
14900                         adapter->dev_id, 0, NULL, read_local_oob_data_complete,
14901                         adapter, NULL) > 0)
14902                 return 0;
14903
14904         return -EIO;
14905 }
14906
14907 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14908 static void le_read_local_oob_data_complete(uint8_t status, uint16_t length,
14909                                         const void *param, void *user_data)
14910 {
14911         const struct mgmt_rp_read_local_oob_ext_data *rp = param;
14912         struct btd_adapter *adapter = user_data;
14913
14914         if (status != MGMT_STATUS_SUCCESS) {
14915                 btd_error(adapter->dev_id, "LE Read local OOB data failed: %s (0x%02x)",
14916                                                 mgmt_errstr(status), status);
14917         } else if (length < sizeof(struct mgmt_rp_read_local_oob_ext_data)) {
14918                 btd_error(adapter->dev_id,
14919                                 "Too small read local OOB ext data response");
14920                 return;
14921         }
14922
14923         if (!adapter->oob_handler || !adapter->oob_handler->le_read_local_cb) {
14924                 btd_error(adapter->dev_id, "oob_handler is not valid : %p",
14925                                 adapter->oob_handler);
14926                 return;
14927         }
14928
14929         adapter->oob_handler->le_read_local_cb(adapter, rp->eir_len, rp->eir,
14930                         adapter->oob_handler->user_data);
14931
14932         g_free(adapter->oob_handler);
14933         adapter->oob_handler = NULL;
14934 }
14935
14936 int btd_adapter_le_read_local_oob_data(struct btd_adapter *adapter)
14937 {
14938         struct mgmt_cp_read_local_oob_ext_data cp;
14939
14940         DBG("hci%u", adapter->dev_id);
14941
14942         memset(&cp, 0, sizeof(cp));
14943         cp.type = (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
14944
14945         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
14946                         adapter->dev_id, sizeof(cp), &cp, le_read_local_oob_data_complete,
14947                         adapter, NULL) > 0)
14948                 return 0;
14949
14950         return -EIO;
14951 }
14952 #endif
14953
14954 void btd_adapter_for_each_device(struct btd_adapter *adapter,
14955                         void (*cb)(struct btd_device *device, void *data),
14956                         void *data)
14957 {
14958         g_slist_foreach(adapter->devices, (GFunc) cb, data);
14959 }
14960
14961 static int adapter_cmp(gconstpointer a, gconstpointer b)
14962 {
14963         struct btd_adapter *adapter = (struct btd_adapter *) a;
14964         const bdaddr_t *bdaddr = b;
14965
14966         return bacmp(&adapter->bdaddr, bdaddr);
14967 }
14968
14969 static int adapter_id_cmp(gconstpointer a, gconstpointer b)
14970 {
14971         struct btd_adapter *adapter = (struct btd_adapter *) a;
14972         uint16_t id = GPOINTER_TO_UINT(b);
14973
14974         return adapter->dev_id == id ? 0 : -1;
14975 }
14976
14977 struct btd_adapter *adapter_find(const bdaddr_t *sba)
14978 {
14979         GSList *match;
14980
14981         match = g_slist_find_custom(adapters, sba, adapter_cmp);
14982         if (!match)
14983                 return NULL;
14984
14985         return match->data;
14986 }
14987
14988 struct btd_adapter *adapter_find_by_id(int id)
14989 {
14990         GSList *match;
14991
14992         match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
14993                                                         adapter_id_cmp);
14994         if (!match)
14995                 return NULL;
14996
14997         return match->data;
14998 }
14999
15000 void adapter_foreach(adapter_cb func, gpointer user_data)
15001 {
15002         g_slist_foreach(adapters, (GFunc) func, user_data);
15003 }
15004
15005 static int set_did(struct btd_adapter *adapter, uint16_t vendor,
15006                         uint16_t product, uint16_t version, uint16_t source)
15007 {
15008         struct mgmt_cp_set_device_id cp;
15009
15010         DBG("hci%u source %x vendor %x product %x version %x",
15011                         adapter->dev_id, source, vendor, product, version);
15012
15013         memset(&cp, 0, sizeof(cp));
15014
15015         cp.source = htobs(source);
15016         cp.vendor = htobs(vendor);
15017         cp.product = htobs(product);
15018         cp.version = htobs(version);
15019
15020         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_ID,
15021                                 adapter->dev_id, sizeof(cp), &cp,
15022                                 NULL, NULL, NULL) > 0)
15023                 return 0;
15024
15025         return -EIO;
15026 }
15027
15028 static void services_modified(struct gatt_db_attribute *attrib, void *user_data)
15029 {
15030         struct btd_adapter *adapter = user_data;
15031
15032         g_dbus_emit_property_changed(dbus_conn, adapter->path,
15033                                                 ADAPTER_INTERFACE, "UUIDs");
15034 }
15035
15036 static int adapter_register(struct btd_adapter *adapter)
15037 {
15038         struct agent *agent;
15039         struct gatt_db *db;
15040 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15041         char address[18] = { 0 };
15042         char filename[PATH_MAX] = { 0 };
15043 #endif
15044
15045         if (powering_down)
15046                 return -EBUSY;
15047
15048         adapter->path = g_strdup_printf("/org/bluez/hci%d", adapter->dev_id);
15049
15050         if (!g_dbus_register_interface(dbus_conn,
15051                                         adapter->path, ADAPTER_INTERFACE,
15052 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15053                                         adapter_methods, adapter_signals,
15054 #else
15055                                         adapter_methods, NULL,
15056 #endif
15057                                         adapter_properties, adapter,
15058                                         adapter_free)) {
15059                 btd_error(adapter->dev_id,
15060                                 "Adapter interface init failed on path %s",
15061                                                         adapter->path);
15062                 g_free(adapter->path);
15063                 adapter->path = NULL;
15064                 return -EINVAL;
15065         }
15066
15067         if (adapters == NULL)
15068                 adapter->is_default = true;
15069
15070         adapters = g_slist_append(adapters, adapter);
15071
15072         agent = agent_get(NULL);
15073         if (agent) {
15074                 uint8_t io_cap = agent_get_io_capability(agent);
15075                 adapter_set_io_capability(adapter, io_cap);
15076                 agent_unref(agent);
15077         }
15078
15079         /* Don't start GATT database and advertising managers on
15080          * non-LE controllers.
15081          */
15082         if (!(adapter->supported_settings & MGMT_SETTING_LE) ||
15083                                         btd_opts.mode == BT_MODE_BREDR)
15084                 goto load;
15085
15086         adapter->database = btd_gatt_database_new(adapter);
15087         if (!adapter->database) {
15088                 btd_error(adapter->dev_id,
15089                                 "Failed to create GATT database for adapter");
15090                 adapters = g_slist_remove(adapters, adapter);
15091                 return -EINVAL;
15092         }
15093
15094         adapter->adv_manager = btd_adv_manager_new(adapter, adapter->mgmt);
15095
15096         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15097                 if (adapter->supported_settings & MGMT_SETTING_LE) {
15098                         adapter->adv_monitor_manager =
15099                                 btd_adv_monitor_manager_create(adapter,
15100                                                                 adapter->mgmt);
15101                         if (!adapter->adv_monitor_manager) {
15102                                 btd_error(adapter->dev_id,
15103                                                 "Failed to create Adv Monitor "
15104                                                 "Manager for adapter");
15105                                 return -EINVAL;
15106                         }
15107                 } else {
15108                         btd_info(adapter->dev_id, "Adv Monitor Manager "
15109                                         "skipped, LE unavailable");
15110                 }
15111         }
15112
15113         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15114                 adapter->battery_provider_manager =
15115                 btd_battery_provider_manager_create(adapter);
15116         }
15117
15118         db = btd_gatt_database_get_db(adapter->database);
15119         adapter->db_id = gatt_db_register(db, services_modified,
15120                                                         services_modified,
15121                                                         adapter, NULL);
15122
15123 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15124         ba2str(&adapter->bdaddr, address);
15125         snprintf(filename, PATH_MAX, STORAGEDIR "/%s", address);
15126         delete_tempfiles(filename);
15127 #endif
15128
15129 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15130         adapter_print_devices(adapter);
15131
15132         if (load_local_irk(adapter)) {
15133                 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
15134                         btd_opts.le_privacy = false;
15135
15136                 /*
15137                  * Some Android devices don't consider the device as LE one,
15138                  * if the device doesn't distribute IRK when pairing.
15139                  * Because of this compatibility issue, set IRK
15140                  * even though privacy feature is disabled.
15141                  */
15142                 set_local_irk(adapter);
15143
15144                 if (btd_opts.le_privacy) {
15145                         DBG("Enable LE Privacy feature");
15146                         set_privacy(adapter, true);
15147                 } else {
15148                         DBG("Disable LE Privacy feature");
15149                 }
15150         }
15151 #endif
15152
15153 load:
15154         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FLAGS_CHANGED,
15155                                                 adapter->dev_id,
15156                                                 device_flags_changed_callback,
15157                                                 adapter, NULL);
15158
15159         load_config(adapter);
15160         fix_storage(adapter);
15161         load_drivers(adapter);
15162         btd_profile_foreach(probe_profile, adapter);
15163         clear_blocked(adapter);
15164         load_defaults(adapter);
15165         load_devices(adapter);
15166
15167         /* restore Service Changed CCC value for bonded devices */
15168         btd_gatt_database_restore_svc_chng_ccc(adapter->database);
15169
15170         /* retrieve the active connections: address the scenario where
15171          * the are active connections before the daemon've started */
15172         if (btd_adapter_get_powered(adapter))
15173                 load_connections(adapter);
15174
15175         adapter->initialized = TRUE;
15176
15177         if (btd_opts.did_source) {
15178                 /* DeviceID record is added by sdpd-server before any other
15179                  * record is registered. */
15180                 adapter_service_insert(adapter, sdp_record_find(0x10000));
15181                 set_did(adapter, btd_opts.did_vendor, btd_opts.did_product,
15182                                 btd_opts.did_version, btd_opts.did_source);
15183         }
15184
15185         DBG("Adapter %s registered", adapter->path);
15186
15187         return 0;
15188 }
15189
15190 static int adapter_unregister(struct btd_adapter *adapter)
15191 {
15192         DBG("Unregister path: %s", adapter->path);
15193
15194         adapters = g_slist_remove(adapters, adapter);
15195
15196         if (adapter->is_default && adapters != NULL) {
15197                 struct btd_adapter *new_default;
15198
15199                 new_default = adapter_find_by_id(hci_get_route(NULL));
15200                 if (new_default == NULL)
15201                         new_default = adapters->data;
15202
15203                 new_default->is_default = true;
15204         }
15205
15206         adapter_list = g_list_remove(adapter_list, adapter);
15207
15208         adapter_remove(adapter);
15209         btd_adapter_unref(adapter);
15210
15211         return 0;
15212 }
15213
15214 static void disconnected_callback(uint16_t index, uint16_t length,
15215                                         const void *param, void *user_data)
15216 {
15217         const struct mgmt_ev_device_disconnected *ev = param;
15218         struct btd_adapter *adapter = user_data;
15219         uint8_t reason;
15220
15221         if (length < sizeof(struct mgmt_addr_info)) {
15222                 btd_error(adapter->dev_id,
15223                                 "Too small device disconnected event");
15224                 return;
15225         }
15226
15227         if (length < sizeof(*ev))
15228                 reason = MGMT_DEV_DISCONN_UNKNOWN;
15229         else
15230                 reason = ev->reason;
15231
15232         dev_disconnected(adapter, &ev->addr, reason);
15233 }
15234
15235 static void connected_callback(uint16_t index, uint16_t length,
15236                                         const void *param, void *user_data)
15237 {
15238         const struct mgmt_ev_device_connected *ev = param;
15239         struct btd_adapter *adapter = user_data;
15240         struct btd_device *device;
15241         struct eir_data eir_data;
15242         uint16_t eir_len;
15243         char addr[18];
15244         bool name_known;
15245
15246         if (length < sizeof(*ev)) {
15247                 btd_error(adapter->dev_id, "Too small device connected event");
15248                 return;
15249         }
15250
15251         eir_len = btohs(ev->eir_len);
15252         if (length < sizeof(*ev) + eir_len) {
15253                 btd_error(adapter->dev_id, "Too small device connected event");
15254                 return;
15255         }
15256
15257         ba2str(&ev->addr.bdaddr, addr);
15258
15259         DBG("hci%u device %s connected eir_len %u", index, addr, eir_len);
15260
15261         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
15262                                                                 ev->addr.type);
15263         if (!device) {
15264                 btd_error(adapter->dev_id,
15265                                 "Unable to get device object for %s", addr);
15266                 return;
15267         }
15268
15269         memset(&eir_data, 0, sizeof(eir_data));
15270         if (eir_len > 0)
15271                 eir_parse(&eir_data, ev->eir, eir_len);
15272
15273         if (eir_data.class != 0)
15274                 device_set_class(device, eir_data.class);
15275
15276         adapter_add_connection(adapter, device, ev->addr.type);
15277
15278         name_known = device_name_known(device);
15279
15280         if (eir_data.name && (eir_data.name_complete || !name_known)) {
15281                 device_store_cached_name(device, eir_data.name);
15282                 btd_device_device_set_name(device, eir_data.name);
15283         }
15284
15285         if (eir_data.msd_list)
15286                 adapter_msd_notify(adapter, device, eir_data.msd_list);
15287
15288         eir_data_free(&eir_data);
15289 }
15290
15291 static void controller_resume_notify(struct btd_adapter *adapter)
15292 {
15293         GSList *l;
15294
15295         for (l = adapter->drivers; l; l = g_slist_next(l)) {
15296                 struct btd_adapter_driver *driver = l->data;
15297                 if (driver->resume)
15298                         driver->resume(adapter);
15299         }
15300 }
15301
15302 static void controller_resume_callback(uint16_t index, uint16_t length,
15303                                        const void *param, void *user_data)
15304 {
15305         const struct mgmt_ev_controller_resume *ev = param;
15306         struct btd_adapter *adapter = user_data;
15307
15308         if (length < sizeof(*ev)) {
15309                 btd_error(adapter->dev_id, "Too small device resume event");
15310                 return;
15311         }
15312
15313         info("Controller resume with wake event 0x%x", ev->wake_reason);
15314
15315         controller_resume_notify(adapter);
15316 }
15317
15318 static void device_blocked_callback(uint16_t index, uint16_t length,
15319                                         const void *param, void *user_data)
15320 {
15321         const struct mgmt_ev_device_blocked *ev = param;
15322         struct btd_adapter *adapter = user_data;
15323         struct btd_device *device;
15324         char addr[18];
15325
15326         if (length < sizeof(*ev)) {
15327                 btd_error(adapter->dev_id, "Too small device blocked event");
15328                 return;
15329         }
15330
15331         ba2str(&ev->addr.bdaddr, addr);
15332         DBG("hci%u %s blocked", index, addr);
15333
15334         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15335                                                                 ev->addr.type);
15336         if (device)
15337                 device_block(device, TRUE);
15338 }
15339
15340 static void device_unblocked_callback(uint16_t index, uint16_t length,
15341                                         const void *param, void *user_data)
15342 {
15343         const struct mgmt_ev_device_unblocked *ev = param;
15344         struct btd_adapter *adapter = user_data;
15345         struct btd_device *device;
15346         char addr[18];
15347
15348         if (length < sizeof(*ev)) {
15349                 btd_error(adapter->dev_id, "Too small device unblocked event");
15350                 return;
15351         }
15352
15353         ba2str(&ev->addr.bdaddr, addr);
15354         DBG("hci%u %s unblocked", index, addr);
15355
15356         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15357                                                                 ev->addr.type);
15358         if (device)
15359                 device_unblock(device, FALSE, TRUE);
15360 }
15361
15362 static void conn_fail_notify(struct btd_device *dev, uint8_t status)
15363 {
15364         GSList *l;
15365
15366         for (l = conn_fail_list; l; l = g_slist_next(l)) {
15367                 btd_conn_fail_cb conn_fail_cb = l->data;
15368                 conn_fail_cb(dev, status);
15369         }
15370 }
15371
15372 void btd_add_conn_fail_cb(btd_conn_fail_cb func)
15373 {
15374         conn_fail_list = g_slist_append(conn_fail_list, func);
15375 }
15376
15377 void btd_remove_conn_fail_cb(btd_conn_fail_cb func)
15378 {
15379         conn_fail_list = g_slist_remove(conn_fail_list, func);
15380 }
15381
15382 static void connect_failed_callback(uint16_t index, uint16_t length,
15383                                         const void *param, void *user_data)
15384 {
15385         const struct mgmt_ev_connect_failed *ev = param;
15386         struct btd_adapter *adapter = user_data;
15387         struct btd_device *device;
15388         char addr[18];
15389
15390         if (length < sizeof(*ev)) {
15391                 btd_error(adapter->dev_id, "Too small connect failed event");
15392                 return;
15393         }
15394
15395         ba2str(&ev->addr.bdaddr, addr);
15396
15397         DBG("hci%u %s status %u", index, addr, ev->status);
15398
15399         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15400                                                                 ev->addr.type);
15401         if (device) {
15402                 conn_fail_notify(device, ev->status);
15403
15404                 /* If the device is in a bonding process cancel any auth request
15405                  * sent to the agent before proceeding, but keep the bonding
15406                  * request structure. */
15407                 if (device_is_bonding(device, NULL))
15408                         device_cancel_authentication(device, FALSE);
15409         }
15410
15411         /* In the case of security mode 3 devices */
15412         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
15413                                                                 ev->status);
15414
15415         /* If the device is scheduled to retry the bonding wait until the retry
15416          * happens. In other case, proceed with cancel the bondig.
15417          */
15418         if (device && device_is_bonding(device, NULL)
15419                                         && !device_is_retrying(device)) {
15420                 device_cancel_authentication(device, TRUE);
15421                 device_bonding_failed(device, ev->status);
15422         }
15423
15424 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
15425         /* In the case the bonding was canceled or did exists, remove the device
15426          * when it is temporary. */
15427         if (device && !device_is_bonding(device, NULL)
15428                                                 && device_is_temporary(device))
15429                 btd_adapter_remove_device(adapter, device);
15430 #endif
15431 }
15432
15433 static void remove_keys(struct btd_adapter *adapter,
15434                                         struct btd_device *device, uint8_t type)
15435 {
15436         char device_addr[18];
15437         char filename[PATH_MAX];
15438         GKeyFile *key_file;
15439         GError *gerr = NULL;
15440         gsize length = 0;
15441         char *str;
15442
15443         ba2str(device_get_address(device), device_addr);
15444
15445 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15446         if (device_get_rpa_exist(device) == true)
15447                 ba2str(device_get_rpa(device), device_addr);
15448 #endif
15449
15450         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
15451                         btd_adapter_get_storage_dir(adapter), device_addr);
15452         key_file = g_key_file_new();
15453         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
15454                 error("Unable to load key file from %s: (%s)", filename,
15455                                                                 gerr->message);
15456                 g_error_free(gerr);
15457         }
15458
15459         if (type == BDADDR_BREDR) {
15460                 g_key_file_remove_group(key_file, "LinkKey", NULL);
15461         } else {
15462                 g_key_file_remove_group(key_file, "LongTermKey", NULL);
15463                 g_key_file_remove_group(key_file, "LocalSignatureKey", NULL);
15464                 g_key_file_remove_group(key_file, "RemoteSignatureKey", NULL);
15465                 g_key_file_remove_group(key_file, "IdentityResolvingKey", NULL);
15466         }
15467
15468         str = g_key_file_to_data(key_file, &length, NULL);
15469         if (!g_file_set_contents(filename, str, length, &gerr)) {
15470                 error("Unable set contents for %s: (%s)", filename,
15471                                                                 gerr->message);
15472                 g_error_free(gerr);
15473         }
15474         g_free(str);
15475
15476         g_key_file_free(key_file);
15477 }
15478
15479 static void unpaired_callback(uint16_t index, uint16_t length,
15480                                         const void *param, void *user_data)
15481 {
15482         const struct mgmt_ev_device_unpaired *ev = param;
15483         struct btd_adapter *adapter = user_data;
15484         struct btd_device *device;
15485         char addr[18];
15486
15487         if (length < sizeof(*ev)) {
15488                 btd_error(adapter->dev_id, "Too small device unpaired event");
15489                 return;
15490         }
15491
15492         ba2str(&ev->addr.bdaddr, addr);
15493
15494         DBG("hci%u addr %s", index, addr);
15495
15496         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15497                                                                 ev->addr.type);
15498         if (!device) {
15499                 btd_warn(adapter->dev_id,
15500                         "No device object for unpaired device %s", addr);
15501                 return;
15502         }
15503
15504         remove_keys(adapter, device, ev->addr.type);
15505         device_set_unpaired(device, ev->addr.type);
15506 }
15507
15508 static void clear_devices_complete(uint8_t status, uint16_t length,
15509                                         const void *param, void *user_data)
15510 {
15511         if (status != MGMT_STATUS_SUCCESS) {
15512                 error("Failed to clear devices: %s (0x%02x)",
15513                                                 mgmt_errstr(status), status);
15514                 return;
15515         }
15516 }
15517
15518 static int clear_devices(struct btd_adapter *adapter)
15519 {
15520         struct mgmt_cp_remove_device cp;
15521
15522         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
15523                 return 0;
15524
15525         memset(&cp, 0, sizeof(cp));
15526
15527         DBG("sending clear devices command for index %u", adapter->dev_id);
15528
15529         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
15530                                 adapter->dev_id, sizeof(cp), &cp,
15531                                 clear_devices_complete, adapter, NULL) > 0)
15532                 return 0;
15533
15534         btd_error(adapter->dev_id, "Failed to clear devices for index %u",
15535                                                         adapter->dev_id);
15536
15537         return -EIO;
15538 }
15539
15540 static bool get_static_addr(struct btd_adapter *adapter)
15541 {
15542         struct bt_crypto *crypto;
15543         GKeyFile *file;
15544         GError *gerr = NULL;
15545         char **addrs;
15546         char mfg[7];
15547         char *str;
15548         bool ret;
15549         gsize len, i;
15550
15551         snprintf(mfg, sizeof(mfg), "0x%04x", adapter->manufacturer);
15552
15553         file = g_key_file_new();
15554         if (!g_key_file_load_from_file(file, STORAGEDIR "/addresses", 0,
15555                                                                 &gerr)) {
15556                 error("Unable to load key file from %s: (%s)",
15557                                         STORAGEDIR "/addresses", gerr->message);
15558                 g_error_free(gerr);
15559         }
15560         addrs = g_key_file_get_string_list(file, "Static", mfg, &len, NULL);
15561         if (addrs) {
15562                 for (i = 0; i < len; i++) {
15563                         bdaddr_t addr;
15564
15565                         str2ba(addrs[i], &addr);
15566                         if (adapter_find(&addr))
15567                                 continue;
15568
15569                         /* Usable address found in list */
15570                         bacpy(&adapter->bdaddr, &addr);
15571                         adapter->bdaddr_type = BDADDR_LE_RANDOM;
15572                         ret = true;
15573                         goto done;
15574                 }
15575
15576                 len++;
15577                 addrs = g_renew(char *, addrs, len + 1);
15578         } else {
15579                 len = 1;
15580                 addrs = g_new(char *, len + 1);
15581         }
15582
15583         /* Initialize slot for new address */
15584         addrs[len - 1] = g_malloc(18);
15585         addrs[len] = NULL;
15586
15587         crypto = bt_crypto_new();
15588         if (!crypto) {
15589                 error("Failed to open crypto");
15590                 ret = false;
15591                 goto done;
15592         }
15593
15594         ret = bt_crypto_random_bytes(crypto, &adapter->bdaddr,
15595                                                 sizeof(adapter->bdaddr));
15596         if (!ret) {
15597                 error("Failed to generate static address");
15598                 bt_crypto_unref(crypto);
15599                 goto done;
15600         }
15601
15602         bt_crypto_unref(crypto);
15603
15604         adapter->bdaddr.b[5] |= 0xc0;
15605         adapter->bdaddr_type = BDADDR_LE_RANDOM;
15606
15607         ba2str(&adapter->bdaddr, addrs[len - 1]);
15608
15609         g_key_file_set_string_list(file, "Static", mfg,
15610                                                 (const char **)addrs, len);
15611
15612         str = g_key_file_to_data(file, &len, NULL);
15613         if (!g_file_set_contents(STORAGEDIR "/addresses", str, len, &gerr)) {
15614                 error("Unable set contents for %s: (%s)",
15615                                         STORAGEDIR "/addresses", gerr->message);
15616                 g_error_free(gerr);
15617         }
15618         g_free(str);
15619
15620         ret = true;
15621
15622 done:
15623         g_key_file_free(file);
15624         g_strfreev(addrs);
15625
15626         return ret;
15627 }
15628
15629 static bool set_static_addr(struct btd_adapter *adapter)
15630 {
15631         struct mgmt_cp_set_static_address cp;
15632
15633         /* dual-mode adapters must have a public address */
15634         if (adapter->supported_settings & MGMT_SETTING_BREDR)
15635                 return false;
15636
15637         if (!(adapter->supported_settings & MGMT_SETTING_LE))
15638                 return false;
15639
15640         DBG("Setting static address");
15641
15642         if (!get_static_addr(adapter))
15643                 return false;
15644
15645         bacpy(&cp.bdaddr, &adapter->bdaddr);
15646         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STATIC_ADDRESS,
15647                                 adapter->dev_id, sizeof(cp), &cp,
15648                                 NULL, NULL, NULL) > 0) {
15649                 return true;
15650         }
15651
15652         return false;
15653 }
15654
15655 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15656 static uint8_t *generate_irk(void)
15657 {
15658         int fd;
15659         uint8_t *irk;
15660
15661         DBG("Generate IRK");
15662
15663         fd = open("/dev/urandom", O_RDONLY);
15664         if (fd < 0)
15665                 return NULL;
15666
15667         irk = g_malloc0(MGMT_IRK_SIZE);
15668         if (read(fd, irk, MGMT_IRK_SIZE) != MGMT_IRK_SIZE) {
15669                 error("Cannot read random bytes");
15670                 g_free(irk);
15671                 close(fd);
15672                 return NULL;
15673         }
15674         close(fd);
15675
15676         return irk;
15677 }
15678
15679 #define LOCAL_IRK_DIRNAME       "/csa/bluetooth"
15680 #define LOCAL_IRK_FILENAME      ".local_irk"
15681
15682 static bool store_local_irk(struct btd_adapter *adapter)
15683 {
15684         int fd;
15685         int ret;
15686
15687         if (adapter->local_irk == NULL) {
15688                 error("Local IRK is not proper");
15689                 return false;
15690         }
15691
15692         if (access(LOCAL_IRK_DIRNAME, F_OK) < 0) {
15693                 if (mkdir(LOCAL_IRK_DIRNAME, 0755) < 0) {
15694                         error("Cannot create a directory for local IRK : %s",
15695                                         strerror(errno));
15696                         return false;
15697                 }
15698         }
15699
15700         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME,
15701                         O_WRONLY | O_CREAT | O_TRUNC, 0644);
15702         if (fd < 0) {
15703                 error("Cannot open a file for local IRK : %s", strerror(errno));
15704                 return false;
15705         }
15706
15707         ret = write(fd, adapter->local_irk, MGMT_IRK_SIZE);
15708         if (ret != MGMT_IRK_SIZE) {
15709                 error("Cannot write local IRK [%d] : %s", ret, strerror(errno));
15710
15711                 close(fd);
15712                 unlink(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME);
15713                 return false;
15714         }
15715
15716         ret = fdatasync(fd);
15717         if (ret < 0)
15718                 error("sync failed : %s", strerror(errno));
15719
15720         close(fd);
15721         return true;
15722 }
15723
15724 static bool load_local_irk(struct btd_adapter *adapter)
15725 {
15726         int fd;
15727         int ret;
15728
15729         if (access(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, F_OK) < 0) {
15730                 adapter->local_irk = generate_irk();
15731                 if (store_local_irk(adapter) == false) {
15732                         error("Cannot store Local IRK");
15733                         g_free(adapter->local_irk);
15734                         return false;
15735                 }
15736
15737                 return true;
15738         }
15739
15740         if (adapter->local_irk) {
15741                 DBG("Local IRK is already loaded");
15742                 return true;
15743         }
15744
15745         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, O_RDONLY);
15746         if (fd < 0) {
15747                 error("Cannot open local IRK file : %s", strerror(errno));
15748                 return false;
15749         }
15750
15751         adapter->local_irk = g_malloc0(MGMT_IRK_SIZE);
15752
15753         ret = read(fd, adapter->local_irk, MGMT_IRK_SIZE);
15754         if (ret != MGMT_IRK_SIZE) {
15755                 error("Cannot read local IRK [%d] : %s", ret, strerror(errno));
15756                 g_free(adapter->local_irk);
15757                 close(fd);
15758                 return false;
15759         }
15760
15761         close(fd);
15762         return true;
15763 }
15764
15765 static void set_privacy_complete(uint8_t status, uint16_t length,
15766         const void *param, void *user_data)
15767 {
15768         struct btd_adapter *adapter = user_data;
15769
15770         if (status != MGMT_STATUS_SUCCESS)
15771                 error("Setting privacy failed for hci%u: %s (0x%02x)",
15772                         adapter->dev_id, mgmt_errstr(status), status);
15773         else
15774                 DBG("Privacy feature is set/unset successfully for hci%u",
15775                         adapter->dev_id);
15776 }
15777
15778 static bool set_privacy(struct btd_adapter *adapter, bool privacy)
15779 {
15780         struct mgmt_cp_set_privacy cp;
15781
15782         if (!adapter->local_irk) {
15783                 error("Local IRK is not available");
15784                 return false;
15785         }
15786
15787         memset(&cp, 0, sizeof(cp));
15788         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
15789
15790         if (privacy)
15791                 cp.privacy = 0x01;
15792
15793         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
15794                                 adapter->dev_id, sizeof(cp), &cp,
15795                                 set_privacy_complete, adapter, NULL) > 0)
15796                 return true;
15797
15798         error("Failed to set privacy and load local irk for index %u",
15799                         adapter->dev_id);
15800         return false;
15801 }
15802
15803 static void set_irk_complete(uint8_t status, uint16_t length,
15804                 const void *param, void *user_data)
15805 {
15806         struct btd_adapter *adapter = user_data;
15807
15808         if (status != MGMT_STATUS_SUCCESS)
15809                 error("Setting IRK is failed for hci%u: %s (0x%02x)",
15810                         adapter->dev_id, mgmt_errstr(status), status);
15811         else
15812                 DBG("Setting IRK is succeed for hci%u", adapter->dev_id);
15813 }
15814
15815 static bool set_local_irk(struct btd_adapter *adapter)
15816 {
15817         struct mgmt_cp_set_irk cp;
15818
15819         if (!adapter->local_irk) {
15820                 error("Local IRK is not available");
15821                 return false;
15822         }
15823
15824         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
15825
15826         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IRK,
15827                                 adapter->dev_id, sizeof(cp), &cp,
15828                                 set_irk_complete, adapter, NULL) > 0)
15829                 return true;
15830
15831         error("Failed to set irk %u", adapter->dev_id);
15832         return false;
15833 }
15834
15835 int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
15836                                                 const bdaddr_t *bdaddr,
15837                                                 uint8_t bdaddr_type)
15838
15839 {
15840         struct mgmt_cp_connect_6lowpan cp;
15841
15842         memset(&cp, 0, sizeof(cp));
15843         bacpy(&cp.addr.bdaddr, bdaddr);
15844         cp.addr.type = bdaddr_type;
15845
15846         if (mgmt_send(adapter->mgmt, MGMT_OP_CONNECT_6LOWPAN,
15847                                 adapter->dev_id, sizeof(cp), &cp,
15848                                 NULL, NULL, NULL) > 0)
15849                 return 0;
15850
15851         return -EIO;
15852 }
15853
15854 int btd_adapter_disconnect_ipsp(struct btd_adapter *adapter,
15855                                                 const bdaddr_t *bdaddr,
15856                                                 uint8_t bdaddr_type)
15857
15858 {
15859         struct mgmt_cp_disconnect_6lowpan cp;
15860
15861         memset(&cp, 0, sizeof(cp));
15862         bacpy(&cp.addr.bdaddr, bdaddr);
15863         cp.addr.type = bdaddr_type;
15864
15865         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT_6LOWPAN,
15866                                 adapter->dev_id, sizeof(cp), &cp,
15867                                 NULL, NULL, NULL) > 0)
15868                 return 0;
15869
15870         return -EIO;
15871 }
15872
15873 uint8_t btd_adapter_get_rpa_res_support_value(
15874                 struct btd_adapter *adapter)
15875 {
15876         return adapter->central_rpa_res_support;
15877 }
15878
15879 static void set_dev_rpa_res_support_complete(uint8_t status,
15880                                         uint16_t length, const void *param,
15881                                         void *user_data)
15882 {
15883         if (status != MGMT_STATUS_SUCCESS)
15884                 error("Failed to set RPA resolution support of device : %s (0x%02x)",
15885                                                 mgmt_errstr(status), status);
15886         else
15887                 DBG("Set RPA resolution support successful");
15888 }
15889
15890 int btd_adapter_set_dev_rpa_res_support(struct btd_adapter *adapter,
15891                                         struct btd_device *device)
15892
15893 {
15894         struct mgmt_cp_set_dev_rpa_res_support cp;
15895
15896         DBG("btd_adapter_set_dev_rpa_res_support called");
15897
15898         memset(&cp, 0, sizeof(cp));
15899
15900         bacpy(&cp.addr.bdaddr, device_get_address(device));
15901         cp.addr.type = btd_device_get_bdaddr_type(device);
15902         cp.res_support = device_get_rpa_res_char_value(device);
15903
15904         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_RPA_RES_SUPPORT,
15905                                 adapter->dev_id, sizeof(cp), &cp,
15906                                 set_dev_rpa_res_support_complete, NULL, NULL) > 0)
15907                 return 0;
15908
15909         return -EIO;
15910 }
15911 #endif
15912
15913 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15914 static gboolean adapter_start_idle_cb(gpointer user_data)
15915 {
15916         struct btd_adapter *adapter = (struct btd_adapter*)user_data;
15917
15918         adapter_start(adapter);
15919
15920         return FALSE;
15921 }
15922 #endif
15923
15924 static void set_blocked_keys_complete(uint8_t status, uint16_t length,
15925                                         const void *param, void *user_data)
15926 {
15927         struct btd_adapter *adapter = user_data;
15928
15929         if (status != MGMT_STATUS_SUCCESS) {
15930                 btd_error(adapter->dev_id,
15931                                 "Failed to set blocked keys: %s (0x%02x)",
15932                                 mgmt_errstr(status), status);
15933                 return;
15934         }
15935
15936         DBG("Successfully set blocked keys for index %u", adapter->dev_id);
15937 }
15938
15939 static bool set_blocked_keys(struct btd_adapter *adapter)
15940 {
15941         uint8_t buffer[sizeof(struct mgmt_cp_set_blocked_keys) +
15942                                         sizeof(blocked_keys)] = { 0 };
15943         struct mgmt_cp_set_blocked_keys *cp =
15944                                 (struct mgmt_cp_set_blocked_keys *)buffer;
15945         int i;
15946
15947         cp->key_count = ARRAY_SIZE(blocked_keys);
15948         for (i = 0; i < cp->key_count; ++i) {
15949                 cp->keys[i].type = blocked_keys[i].type;
15950                 memcpy(cp->keys[i].val, blocked_keys[i].val,
15951                                                 sizeof(cp->keys[i].val));
15952         }
15953
15954         return mgmt_send(mgmt_primary, MGMT_OP_SET_BLOCKED_KEYS,
15955                                                 adapter->dev_id,
15956                                                 sizeof(buffer), buffer,
15957                                                 set_blocked_keys_complete,
15958                                                 adapter, NULL);
15959 }
15960
15961 #define EXP_FEAT(_uuid, _func) \
15962 { \
15963         .uuid = _uuid, \
15964         .func = _func, \
15965 }
15966
15967 static void set_exp_debug_complete(uint8_t status, uint16_t len,
15968                                         const void *param, void *user_data)
15969 {
15970         struct btd_adapter *adapter = user_data;
15971         uint8_t action = btd_opts.experimental ? 0x01 : 0x00;
15972
15973         if (status != 0) {
15974                 error("Set Experimental Debug failed with status 0x%02x (%s)",
15975                                                 status, mgmt_errstr(status));
15976                 return;
15977         }
15978
15979         DBG("Experimental Debug successfully set");
15980
15981         if (action)
15982                 queue_push_tail(adapter->exps, (void *)debug_uuid.val);
15983 }
15984
15985 static void exp_debug_func(struct btd_adapter *adapter, uint8_t action)
15986 {
15987         struct mgmt_cp_set_exp_feature cp;
15988
15989         memset(&cp, 0, sizeof(cp));
15990         memcpy(cp.uuid, debug_uuid.val, 16);
15991         cp.action = action;
15992
15993         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
15994                         adapter->dev_id, sizeof(cp), &cp,
15995                         set_exp_debug_complete, adapter, NULL) > 0)
15996                 return;
15997
15998         btd_error(adapter->dev_id, "Failed to set exp debug");
15999 }
16000
16001 static void le_simult_central_peripheral_func(struct btd_adapter *adapter,
16002                                                         uint8_t action)
16003 {
16004         if (action)
16005                 queue_push_tail(adapter->exps,
16006                                 (void *)le_simult_central_peripheral_uuid.val);
16007 }
16008
16009 static void quality_report_func(struct btd_adapter *adapter, uint8_t action)
16010 {
16011         if (action)
16012                 queue_push_tail(adapter->exps, (void *)quality_report_uuid.val);
16013 }
16014
16015 static void set_rpa_resolution_complete(uint8_t status, uint16_t len,
16016                                         const void *param, void *user_data)
16017 {
16018         struct btd_adapter *adapter = user_data;
16019         uint8_t action = btd_opts.experimental ? 0x01 : 0x00;
16020
16021         if (status != 0) {
16022                 error("Set RPA Resolution failed with status 0x%02x (%s)",
16023                                                 status, mgmt_errstr(status));
16024                 return;
16025         }
16026
16027         DBG("RPA Resolution successfully set");
16028
16029         if (action)
16030                 queue_push_tail(adapter->exps, (void *)rpa_resolution_uuid.val);
16031 }
16032
16033 static void rpa_resolution_func(struct btd_adapter *adapter, uint8_t action)
16034 {
16035         struct mgmt_cp_set_exp_feature cp;
16036
16037         memset(&cp, 0, sizeof(cp));
16038         memcpy(cp.uuid, rpa_resolution_uuid.val, 16);
16039         cp.action = action;
16040
16041         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16042                         adapter->dev_id, sizeof(cp), &cp,
16043                         set_rpa_resolution_complete, adapter, NULL) > 0)
16044                 return;
16045
16046         btd_error(adapter->dev_id, "Failed to set RPA Resolution");
16047 }
16048
16049 static void codec_offload_complete(uint8_t status, uint16_t len,
16050                                         const void *param, void *user_data)
16051 {
16052         struct btd_adapter *adapter = user_data;
16053         uint8_t action = btd_opts.experimental ? 0x01 : 0x00;
16054
16055         if (status != 0) {
16056                 error("Set Codec Offload failed with status 0x%02x (%s)",
16057                                                 status, mgmt_errstr(status));
16058                 return;
16059         }
16060
16061         DBG("Codec Offload successfully set");
16062
16063         if (action)
16064                 queue_push_tail(adapter->exps, (void *)codec_offload_uuid.val);
16065 }
16066
16067 static void codec_offload_func(struct btd_adapter *adapter, uint8_t action)
16068 {
16069         struct mgmt_cp_set_exp_feature cp;
16070
16071         memset(&cp, 0, sizeof(cp));
16072         memcpy(cp.uuid, codec_offload_uuid.val, 16);
16073         cp.action = action;
16074
16075         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_EXP_FEATURE,
16076                         adapter->dev_id, sizeof(cp), &cp,
16077                         codec_offload_complete, adapter, NULL) > 0)
16078                 return;
16079
16080         btd_error(adapter->dev_id, "Failed to set Codec Offload");
16081 }
16082
16083 static const struct exp_feat {
16084         const struct mgmt_exp_uuid *uuid;
16085         void (*func)(struct btd_adapter *adapter, uint8_t action);
16086 } exp_table[] = {
16087         EXP_FEAT(&debug_uuid, exp_debug_func),
16088         EXP_FEAT(&le_simult_central_peripheral_uuid,
16089                  le_simult_central_peripheral_func),
16090         EXP_FEAT(&quality_report_uuid, quality_report_func),
16091         EXP_FEAT(&rpa_resolution_uuid, rpa_resolution_func),
16092         EXP_FEAT(&codec_offload_uuid, codec_offload_func),
16093 };
16094
16095 static void read_exp_features_complete(uint8_t status, uint16_t length,
16096                                         const void *param, void *user_data)
16097 {
16098         struct btd_adapter *adapter = user_data;
16099         const struct mgmt_rp_read_exp_features_info *rp = param;
16100         size_t feature_count = 0;
16101         size_t i = 0;
16102
16103         DBG("index %u status 0x%02x", adapter->dev_id, status);
16104
16105         if (status != MGMT_STATUS_SUCCESS) {
16106                 btd_error(adapter->dev_id,
16107                                 "Failed to read exp features info: %s (0x%02x)",
16108                                 mgmt_errstr(status), status);
16109                 return;
16110         }
16111
16112         if (length < sizeof(*rp)) {
16113                 btd_error(adapter->dev_id, "Response too small");
16114                 return;
16115         }
16116
16117         feature_count = le16_to_cpu(rp->feature_count);
16118
16119         if (length < sizeof(*rp) + (sizeof(*rp->features) * feature_count)) {
16120                 btd_error(adapter->dev_id, "Response too small");
16121                 return;
16122         }
16123
16124         for (i = 0; i < feature_count; ++i) {
16125                 size_t j;
16126                 for (j = 0; j < ARRAY_SIZE(exp_table); j++) {
16127                         const struct exp_feat *feat = &exp_table[j];
16128                         uint8_t action;
16129
16130                         if (memcmp(rp->features[i].uuid, feat->uuid->val,
16131                                         sizeof(rp->features[i].uuid)))
16132                                 continue;
16133
16134                         action = btd_experimental_enabled(feat->uuid->str);
16135
16136                         DBG("%s flags %u action %u", feat->uuid->str,
16137                                 rp->features[i].flags, action);
16138
16139                         /* If already set don't attempt to set it again */
16140                         if (action == (rp->features[i].flags & BIT(0))) {
16141                                 if (action)
16142                                         queue_push_tail(adapter->exps,
16143                                                 (void *)feat->uuid->val);
16144                                 continue;
16145                         }
16146
16147                         if (feat->func)
16148                                 feat->func(adapter, action);
16149                 }
16150         }
16151 }
16152
16153 static void read_exp_features(struct btd_adapter *adapter)
16154 {
16155         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_EXP_FEATURES_INFO,
16156                         adapter->dev_id, 0, NULL, read_exp_features_complete,
16157                         adapter, NULL) > 0)
16158                 return;
16159
16160         btd_error(adapter->dev_id, "Failed to read exp features info");
16161 }
16162
16163 static void read_info_complete(uint8_t status, uint16_t length,
16164                                         const void *param, void *user_data)
16165 {
16166         struct btd_adapter *adapter = user_data;
16167         const struct mgmt_rp_read_info *rp = param;
16168         uint32_t missing_settings;
16169         int err;
16170
16171         DBG("index %u status 0x%02x", adapter->dev_id, status);
16172
16173         if (status != MGMT_STATUS_SUCCESS) {
16174                 btd_error(adapter->dev_id,
16175                                 "Failed to read info for index %u: %s (0x%02x)",
16176                                 adapter->dev_id, mgmt_errstr(status), status);
16177                 goto failed;
16178         }
16179
16180         if (length < sizeof(*rp)) {
16181                 btd_error(adapter->dev_id,
16182                                 "Too small read info complete response");
16183                 goto failed;
16184         }
16185
16186         /*
16187          * Store controller information for class of device, device
16188          * name, short name and settings.
16189          *
16190          * During the lifetime of the controller these will be updated by
16191          * events and the information is required to keep the current
16192          * state of the controller.
16193          */
16194         adapter->dev_class = rp->dev_class[0] | (rp->dev_class[1] << 8) |
16195                                                 (rp->dev_class[2] << 16);
16196         adapter->name = g_strdup((const char *) rp->name);
16197         adapter->short_name = g_strdup((const char *) rp->short_name);
16198
16199         adapter->manufacturer = btohs(rp->manufacturer);
16200
16201         adapter->supported_settings = btohl(rp->supported_settings);
16202         adapter->current_settings = btohl(rp->current_settings);
16203
16204 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16205         adapter_check_version(adapter, rp->version);
16206 #endif
16207         clear_uuids(adapter);
16208         clear_devices(adapter);
16209
16210         if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
16211                 if (!set_static_addr(adapter)) {
16212                         btd_error(adapter->dev_id,
16213                                         "No Bluetooth address for index %u",
16214                                         adapter->dev_id);
16215                         goto failed;
16216                 }
16217         } else {
16218                 bacpy(&adapter->bdaddr, &rp->bdaddr);
16219                 if (!(adapter->supported_settings & MGMT_SETTING_LE))
16220                         adapter->bdaddr_type = BDADDR_BREDR;
16221                 else
16222                         adapter->bdaddr_type = BDADDR_LE_PUBLIC;
16223         }
16224
16225         missing_settings = adapter->current_settings ^
16226                                                 adapter->supported_settings;
16227
16228 /* If adapter supports PHY CONFIGURATION SETTING, then read PHY configuration and save them */
16229 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16230         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
16231                 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_PHY_CONFIGURATION, adapter->dev_id, 0, NULL,
16232                                         get_phy_configuration_resp, adapter, NULL) == 0)
16233                         error("Unable to send %s cmd",
16234                                         mgmt_opstr(MGMT_OP_GET_PHY_CONFIGURATION));
16235         }
16236 #endif
16237         switch (btd_opts.mode) {
16238         case BT_MODE_DUAL:
16239                 if (missing_settings & MGMT_SETTING_SSP) {
16240 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16241                         if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16242                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16243                         else
16244 #endif
16245                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16246                 }
16247                 if (missing_settings & MGMT_SETTING_LE)
16248                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16249                 if (missing_settings & MGMT_SETTING_BREDR)
16250                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16251                 break;
16252         case BT_MODE_BREDR:
16253                 if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
16254                         btd_error(adapter->dev_id,
16255                                 "Ignoring adapter withouth BR/EDR support");
16256                         goto failed;
16257                 }
16258
16259 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16260                 if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16261                         set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16262                 else
16263                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16264 #else
16265                 if (missing_settings & MGMT_SETTING_SSP)
16266                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16267 #endif
16268                 if (missing_settings & MGMT_SETTING_BREDR)
16269                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16270                 if (adapter->current_settings & MGMT_SETTING_LE)
16271                         set_mode(adapter, MGMT_OP_SET_LE, 0x00);
16272                 break;
16273         case BT_MODE_LE:
16274                 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
16275                         btd_error(adapter->dev_id,
16276                                 "Ignoring adapter withouth LE support");
16277                         goto failed;
16278                 }
16279
16280                 if (missing_settings & MGMT_SETTING_LE)
16281                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16282                 if (adapter->current_settings & MGMT_SETTING_BREDR)
16283                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x00);
16284                 break;
16285         }
16286
16287         if (missing_settings & MGMT_SETTING_SECURE_CONN)
16288                 set_mode(adapter, MGMT_OP_SET_SECURE_CONN, 0x01);
16289
16290         if (adapter->supported_settings & MGMT_SETTING_PRIVACY)
16291                 set_privacy(adapter, btd_opts.privacy);
16292
16293         if (btd_opts.fast_conn &&
16294                         (missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
16295                 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
16296
16297 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16298         /* Set the RPA resolution value to '1' if privacy is supported */
16299         if (btd_opts.le_privacy &&
16300                         adapter->supported_settings & MGMT_SETTING_PRIVACY)
16301                 adapter->central_rpa_res_support = 0x01;
16302 #endif
16303
16304         err = adapter_register(adapter);
16305         if (err < 0) {
16306                 btd_error(adapter->dev_id, "Unable to register new adapter");
16307                 goto failed;
16308         }
16309
16310         /*
16311          * Register all event notification handlers for controller.
16312          *
16313          * The handlers are registered after a succcesful read of the
16314          * controller info. From now on they can track updates and
16315          * notifications.
16316          */
16317         mgmt_register(adapter->mgmt, MGMT_EV_NEW_SETTINGS, adapter->dev_id,
16318                                         new_settings_callback, adapter, NULL);
16319
16320         mgmt_register(adapter->mgmt, MGMT_EV_CLASS_OF_DEV_CHANGED,
16321                                                 adapter->dev_id,
16322                                                 dev_class_changed_callback,
16323                                                 adapter, NULL);
16324         mgmt_register(adapter->mgmt, MGMT_EV_LOCAL_NAME_CHANGED,
16325                                                 adapter->dev_id,
16326                                                 local_name_changed_callback,
16327                                                 adapter, NULL);
16328
16329         mgmt_register(adapter->mgmt, MGMT_EV_DISCOVERING,
16330                                                 adapter->dev_id,
16331                                                 discovering_callback,
16332                                                 adapter, NULL);
16333
16334         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FOUND,
16335                                                 adapter->dev_id,
16336                                                 device_found_callback,
16337                                                 adapter, NULL);
16338
16339 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16340         mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
16341                                                 adapter->dev_id,
16342                                                 le_device_found_callback,
16343                                                 adapter, NULL);
16344 #endif
16345
16346         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_DISCONNECTED,
16347                                                 adapter->dev_id,
16348                                                 disconnected_callback,
16349                                                 adapter, NULL);
16350
16351         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_CONNECTED,
16352                                                 adapter->dev_id,
16353                                                 connected_callback,
16354                                                 adapter, NULL);
16355
16356         mgmt_register(adapter->mgmt, MGMT_EV_CONNECT_FAILED,
16357                                                 adapter->dev_id,
16358                                                 connect_failed_callback,
16359                                                 adapter, NULL);
16360
16361         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNPAIRED,
16362                                                 adapter->dev_id,
16363                                                 unpaired_callback,
16364                                                 adapter, NULL);
16365
16366         mgmt_register(adapter->mgmt, MGMT_EV_AUTH_FAILED,
16367                                                 adapter->dev_id,
16368                                                 auth_failed_callback,
16369                                                 adapter, NULL);
16370
16371         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LINK_KEY,
16372                                                 adapter->dev_id,
16373                                                 new_link_key_callback,
16374                                                 adapter, NULL);
16375
16376         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LONG_TERM_KEY,
16377                                                 adapter->dev_id,
16378                                                 new_long_term_key_callback,
16379                                                 adapter, NULL);
16380
16381         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CSRK,
16382                                                 adapter->dev_id,
16383                                                 new_csrk_callback,
16384                                                 adapter, NULL);
16385
16386         mgmt_register(adapter->mgmt, MGMT_EV_NEW_IRK,
16387                                                 adapter->dev_id,
16388                                                 new_irk_callback,
16389                                                 adapter, NULL);
16390
16391         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CONN_PARAM,
16392                                                 adapter->dev_id,
16393                                                 new_conn_param,
16394                                                 adapter, NULL);
16395
16396         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
16397                                                 adapter->dev_id,
16398                                                 device_blocked_callback,
16399                                                 adapter, NULL);
16400         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNBLOCKED,
16401                                                 adapter->dev_id,
16402                                                 device_unblocked_callback,
16403                                                 adapter, NULL);
16404
16405         mgmt_register(adapter->mgmt, MGMT_EV_PIN_CODE_REQUEST,
16406                                                 adapter->dev_id,
16407                                                 pin_code_request_callback,
16408                                                 adapter, NULL);
16409
16410         mgmt_register(adapter->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
16411                                                 adapter->dev_id,
16412                                                 user_confirm_request_callback,
16413                                                 adapter, NULL);
16414
16415         mgmt_register(adapter->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
16416                                                 adapter->dev_id,
16417                                                 user_passkey_request_callback,
16418                                                 adapter, NULL);
16419
16420         mgmt_register(adapter->mgmt, MGMT_EV_PASSKEY_NOTIFY,
16421                                                 adapter->dev_id,
16422                                                 user_passkey_notify_callback,
16423                                                 adapter, NULL);
16424
16425         mgmt_register(adapter->mgmt, MGMT_EV_CONTROLLER_RESUME,
16426                                                 adapter->dev_id,
16427                                                 controller_resume_callback,
16428                                                 adapter, NULL);
16429
16430 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16431         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
16432                                                 adapter->dev_id,
16433                                                 rssi_alert_callback,
16434                                                 adapter, NULL);
16435
16436         mgmt_register(adapter->mgmt, MGMT_EV_RAW_RSSI,
16437                                                 adapter->dev_id,
16438                                                 get_raw_rssi_callback,
16439                                                 adapter, NULL);
16440
16441         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ENABLED,
16442                                                         adapter->dev_id,
16443                                                         rssi_enabled_callback,
16444                                                         adapter, NULL);
16445
16446         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_DISABLED,
16447                                                         adapter->dev_id,
16448                                                         rssi_disabled_callback,
16449                                                         adapter, NULL);
16450
16451         mgmt_register(adapter->mgmt, MGMT_EV_HARDWARE_ERROR,
16452                                                 adapter->dev_id,
16453                                                 hardware_error_callback,
16454                                                 adapter, NULL);
16455
16456         mgmt_register(adapter->mgmt, MGMT_EV_TX_TIMEOUT_ERROR,
16457                                                 adapter->dev_id,
16458                                                 tx_timeout_error_callback,
16459                                                 adapter, NULL);
16460
16461         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_NAME_UPDATE,
16462                                         adapter->dev_id,
16463                                         device_name_update_callback,
16464                                         adapter, NULL);
16465
16466         mgmt_register(adapter->mgmt, MGMT_EV_MULTI_ADV_STATE_CHANGED,
16467                                         adapter->dev_id,
16468                                         multi_adv_state_change_callback,
16469                                         adapter, NULL);
16470
16471         mgmt_register(adapter->mgmt, MGMT_EV_6LOWPAN_CONN_STATE_CHANGED,
16472                                                 adapter->dev_id,
16473                                                 bt_6lowpan_conn_state_change_callback,
16474                                                 adapter, NULL);
16475
16476         mgmt_register(adapter->mgmt, MGMT_EV_LE_DATA_LENGTH_CHANGED,
16477                                                 adapter->dev_id,
16478                                                 bt_le_data_length_changed_callback,
16479                                                 adapter, NULL);
16480
16481         mgmt_register(adapter->mgmt, MGMT_EV_CONN_UPDATED,
16482                                         adapter->dev_id,
16483                                         le_conn_update_completed_callback,
16484                                         adapter, NULL);
16485
16486         mgmt_register(adapter->mgmt, MGMT_EV_RPA_CHANGED,
16487                                         adapter->dev_id,
16488                                         rpa_changed_callback,
16489                                         adapter, NULL);
16490 #endif
16491
16492         set_dev_class(adapter);
16493
16494         set_name(adapter, btd_adapter_get_name(adapter));
16495
16496         if (btd_has_kernel_features(KERNEL_BLOCKED_KEYS_SUPPORTED) &&
16497                         !set_blocked_keys(adapter)) {
16498                 btd_error(adapter->dev_id,
16499                                 "Failed to set blocked keys for index %u",
16500                                 adapter->dev_id);
16501                 goto failed;
16502         }
16503
16504         if (btd_opts.pairable &&
16505                         !(adapter->current_settings & MGMT_SETTING_BONDABLE))
16506                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
16507
16508         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
16509                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x01);
16510         else if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
16511                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
16512
16513         if (adapter->stored_discoverable && !adapter->discoverable_timeout)
16514                 set_discoverable(adapter, 0x01, 0);
16515
16516         if (btd_adapter_get_powered(adapter))
16517 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16518                 g_idle_add(adapter_start_idle_cb, adapter);
16519 #else
16520                 adapter_start(adapter);
16521 #endif
16522 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16523         else
16524                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
16525 #endif
16526
16527 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16528         init_le_static_address(adapter);
16529 #endif
16530
16531         return;
16532
16533 failed:
16534         /*
16535          * Remove adapter from list in case of a failure.
16536          *
16537          * Leaving an adapter structure around for a controller that can
16538          * not be initilized makes no sense at the moment.
16539          *
16540          * This is a simplification to avoid constant checks if the
16541          * adapter is ready to do anything.
16542          */
16543         adapter_list = g_list_remove(adapter_list, adapter);
16544
16545         btd_adapter_unref(adapter);
16546 }
16547
16548 static void reset_adv_monitors_complete(uint8_t status, uint16_t length,
16549                                         const void *param, void *user_data)
16550 {
16551         const struct mgmt_rp_remove_adv_monitor *rp = param;
16552
16553         if (status != MGMT_STATUS_SUCCESS) {
16554                 error("Failed to reset Adv Monitors: %s (0x%02x)",
16555                         mgmt_errstr(status), status);
16556                 return;
16557         }
16558
16559         if (length < sizeof(*rp)) {
16560                 error("Wrong size of remove Adv Monitor response for reset "
16561                         "all Adv Monitors");
16562                 return;
16563         }
16564
16565         DBG("Removed all Adv Monitors");
16566 }
16567
16568 static void reset_adv_monitors(uint16_t index)
16569 {
16570         struct mgmt_cp_remove_adv_monitor cp;
16571
16572         DBG("sending remove Adv Monitor command with handle 0");
16573
16574         /* Handle 0 indicates to remove all */
16575         cp.monitor_handle = 0;
16576         if (mgmt_send(mgmt_primary, MGMT_OP_REMOVE_ADV_MONITOR, index,
16577                         sizeof(cp), &cp, reset_adv_monitors_complete, NULL,
16578                         NULL) > 0) {
16579                 return;
16580         }
16581
16582         error("Failed to reset Adv Monitors");
16583 }
16584
16585 static void index_added(uint16_t index, uint16_t length, const void *param,
16586                                                         void *user_data)
16587 {
16588         struct btd_adapter *adapter;
16589
16590         DBG("index %u", index);
16591
16592         adapter = btd_adapter_lookup(index);
16593         if (adapter) {
16594                 btd_warn(adapter->dev_id,
16595                         "Ignoring index added for an already existing adapter");
16596                 return;
16597         }
16598
16599         reset_adv_monitors(index);
16600
16601         adapter = btd_adapter_new(index);
16602         if (!adapter) {
16603                 btd_error(index,
16604                         "Unable to create new adapter for index %u", index);
16605                 return;
16606         }
16607
16608         if (btd_has_kernel_features(KERNEL_EXP_FEATURES))
16609                 read_exp_features(adapter);
16610
16611         /*
16612          * Protect against potential two executions of read controller info.
16613          *
16614          * In case the start of the daemon and the action of adding a new
16615          * controller coincide this function might be called twice.
16616          *
16617          * To avoid the double execution of reading the controller info,
16618          * add the adapter already to the list. If an adapter is already
16619          * present, the second notification will cause a warning. If the
16620          * command fails the adapter is removed from the list again.
16621          */
16622         adapter_list = g_list_append(adapter_list, adapter);
16623
16624         DBG("sending read info command for index %u", index);
16625
16626         if (mgmt_send(mgmt_primary, MGMT_OP_READ_INFO, index, 0, NULL,
16627                                         read_info_complete, adapter, NULL) > 0)
16628                 return;
16629
16630         btd_error(adapter->dev_id,
16631                         "Failed to read controller info for index %u", index);
16632
16633         adapter_list = g_list_remove(adapter_list, adapter);
16634
16635         btd_adapter_unref(adapter);
16636 }
16637
16638 static void index_removed(uint16_t index, uint16_t length, const void *param,
16639                                                         void *user_data)
16640 {
16641         struct btd_adapter *adapter;
16642
16643         DBG("index %u", index);
16644
16645         adapter = btd_adapter_lookup(index);
16646         if (!adapter) {
16647                 warn("Ignoring index removal for a non-existent adapter");
16648                 return;
16649         }
16650
16651         adapter_unregister(adapter);
16652 }
16653
16654 static void read_index_list_complete(uint8_t status, uint16_t length,
16655                                         const void *param, void *user_data)
16656 {
16657         const struct mgmt_rp_read_index_list *rp = param;
16658         uint16_t num;
16659         int i;
16660
16661         if (status != MGMT_STATUS_SUCCESS) {
16662                 error("Failed to read index list: %s (0x%02x)",
16663                                                 mgmt_errstr(status), status);
16664                 return;
16665         }
16666
16667         if (length < sizeof(*rp)) {
16668                 error("Wrong size of read index list response");
16669                 return;
16670         }
16671
16672         num = btohs(rp->num_controllers);
16673
16674         DBG("Number of controllers: %d", num);
16675
16676         if (num * sizeof(uint16_t) + sizeof(*rp) != length) {
16677                 error("Incorrect packet size for index list response");
16678                 return;
16679         }
16680
16681         for (i = 0; i < num; i++) {
16682                 uint16_t index;
16683
16684                 index = btohs(rp->index[i]);
16685
16686                 DBG("Found index %u", index);
16687
16688                 /*
16689                  * Pretend to be index added event notification.
16690                  *
16691                  * It is safe to just trigger the procedure for index
16692                  * added notification. It does check against itself.
16693                  */
16694                 index_added(index, 0, NULL, NULL);
16695         }
16696 }
16697
16698 static void read_commands_complete(uint8_t status, uint16_t length,
16699                                         const void *param, void *user_data)
16700 {
16701         const struct mgmt_rp_read_commands *rp = param;
16702         uint16_t num_commands, num_events;
16703         size_t expected_len;
16704         int i;
16705
16706         if (status != MGMT_STATUS_SUCCESS) {
16707                 error("Failed to read supported commands: %s (0x%02x)",
16708                                                 mgmt_errstr(status), status);
16709                 return;
16710         }
16711
16712         if (length < sizeof(*rp)) {
16713                 error("Wrong size of read commands response");
16714                 return;
16715         }
16716
16717         num_commands = btohs(rp->num_commands);
16718         num_events = btohs(rp->num_events);
16719
16720         DBG("Number of commands: %d", num_commands);
16721         DBG("Number of events: %d", num_events);
16722
16723         expected_len = sizeof(*rp) + num_commands * sizeof(uint16_t) +
16724                                                 num_events * sizeof(uint16_t);
16725
16726         if (length < expected_len) {
16727                 error("Too small reply for supported commands: (%u != %zu)",
16728                                                         length, expected_len);
16729                 return;
16730         }
16731
16732         for (i = 0; i < num_commands; i++) {
16733                 uint16_t op = get_le16(rp->opcodes + i);
16734
16735                 switch (op) {
16736                 case MGMT_OP_ADD_DEVICE:
16737                         DBG("enabling kernel-side connection control");
16738                         kernel_features |= KERNEL_CONN_CONTROL;
16739                         break;
16740                 case MGMT_OP_SET_BLOCKED_KEYS:
16741                         DBG("kernel supports the set_blocked_keys op");
16742                         kernel_features |= KERNEL_BLOCKED_KEYS_SUPPORTED;
16743                         break;
16744                 case MGMT_OP_SET_DEF_SYSTEM_CONFIG:
16745                         DBG("kernel supports set system confic");
16746                         kernel_features |= KERNEL_SET_SYSTEM_CONFIG;
16747                         break;
16748                 case MGMT_OP_READ_EXP_FEATURES_INFO:
16749                         DBG("kernel supports exp features");
16750                         kernel_features |= KERNEL_EXP_FEATURES;
16751                         break;
16752                 case MGMT_OP_ADD_EXT_ADV_PARAMS:
16753                         DBG("kernel supports ext adv commands");
16754                         kernel_features |= KERNEL_HAS_EXT_ADV_ADD_CMDS;
16755                         break;
16756                 case MGMT_OP_READ_CONTROLLER_CAP:
16757                         DBG("kernel supports controller cap command");
16758                         kernel_features |= KERNEL_HAS_CONTROLLER_CAP_CMD;
16759                         break;
16760                 default:
16761                         break;
16762                 }
16763         }
16764
16765         for (i = 0; i < num_events; i++) {
16766                 uint16_t ev = get_le16(rp->opcodes + num_commands + i);
16767
16768                 switch(ev) {
16769                 case MGMT_EV_CONTROLLER_RESUME:
16770                         DBG("kernel supports suspend/resume events");
16771                         kernel_features |= KERNEL_HAS_RESUME_EVT;
16772                         break;
16773                 }
16774         }
16775 }
16776
16777 static void read_version_complete(uint8_t status, uint16_t length,
16778                                         const void *param, void *user_data)
16779 {
16780         const struct mgmt_rp_read_version *rp = param;
16781
16782         if (status != MGMT_STATUS_SUCCESS) {
16783                 error("Failed to read version information: %s (0x%02x)",
16784                                                 mgmt_errstr(status), status);
16785                 return;
16786         }
16787
16788         if (length < sizeof(*rp)) {
16789                 error("Wrong size of read version response");
16790                 return;
16791         }
16792
16793         mgmt_version = rp->version;
16794         mgmt_revision = btohs(rp->revision);
16795
16796         info("Bluetooth management interface %u.%u initialized",
16797                                                 mgmt_version, mgmt_revision);
16798
16799         if (mgmt_version < 1) {
16800                 error("Version 1.0 or later of management interface required");
16801                 abort();
16802         }
16803
16804         DBG("sending read supported commands command");
16805
16806         /*
16807          * It is irrelevant if this command succeeds or fails. In case of
16808          * failure safe settings are assumed.
16809          */
16810         mgmt_send(mgmt_primary, MGMT_OP_READ_COMMANDS,
16811                                 MGMT_INDEX_NONE, 0, NULL,
16812                                 read_commands_complete, NULL, NULL);
16813
16814         mgmt_register(mgmt_primary, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
16815                                                 index_added, NULL, NULL);
16816         mgmt_register(mgmt_primary, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
16817                                                 index_removed, NULL, NULL);
16818
16819         DBG("sending read index list command");
16820
16821         if (mgmt_send(mgmt_primary, MGMT_OP_READ_INDEX_LIST,
16822                                 MGMT_INDEX_NONE, 0, NULL,
16823                                 read_index_list_complete, NULL, NULL) > 0)
16824                 return;
16825
16826         error("Failed to read controller index list");
16827 }
16828
16829 static void mgmt_debug(const char *str, void *user_data)
16830 {
16831         const char *prefix = user_data;
16832
16833         info("%s%s", prefix, str);
16834 }
16835
16836 int adapter_init(void)
16837 {
16838         dbus_conn = btd_get_dbus_connection();
16839
16840         mgmt_primary = mgmt_new_default();
16841         if (!mgmt_primary) {
16842                 error("Failed to access management interface");
16843                 return -EIO;
16844         }
16845
16846         if (getenv("MGMT_DEBUG"))
16847                 mgmt_set_debug(mgmt_primary, mgmt_debug, "mgmt: ", NULL);
16848
16849         DBG("sending read version command");
16850
16851         if (mgmt_send(mgmt_primary, MGMT_OP_READ_VERSION,
16852                                 MGMT_INDEX_NONE, 0, NULL,
16853                                 read_version_complete, NULL, NULL) > 0)
16854                 return 0;
16855
16856         error("Failed to read management version information");
16857
16858         return -EIO;
16859 }
16860
16861 void adapter_cleanup(void)
16862 {
16863         g_list_free(adapter_list);
16864
16865         while (adapters) {
16866                 struct btd_adapter *adapter = adapters->data;
16867
16868                 adapter_remove(adapter);
16869                 adapters = g_slist_remove(adapters, adapter);
16870                 btd_adapter_unref(adapter);
16871         }
16872
16873         /*
16874          * In case there is another reference active, clear out
16875          * registered handlers for index added and index removed.
16876          *
16877          * This is just an extra precaution to be safe, and in
16878          * reality should not make a difference.
16879          */
16880         mgmt_unregister_index(mgmt_primary, MGMT_INDEX_NONE);
16881
16882         /*
16883          * In case there is another reference active, cancel
16884          * all pending global commands.
16885          *
16886          * This is just an extra precaution to avoid callbacks
16887          * that potentially then could leak memory or access
16888          * an invalid structure.
16889          */
16890         mgmt_cancel_index(mgmt_primary, MGMT_INDEX_NONE);
16891
16892         mgmt_unref(mgmt_primary);
16893         mgmt_primary = NULL;
16894
16895         dbus_conn = NULL;
16896 }
16897
16898 void adapter_shutdown(void)
16899 {
16900         GList *list;
16901
16902         DBG("");
16903
16904         powering_down = true;
16905
16906         for (list = g_list_first(adapter_list); list;
16907                                                 list = g_list_next(list)) {
16908                 struct btd_adapter *adapter = list->data;
16909
16910                 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
16911                         continue;
16912
16913                 clear_discoverable(adapter);
16914                 remove_temporary_devices(adapter);
16915                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x00);
16916
16917                 adapter_remaining++;
16918         }
16919
16920         if (!adapter_remaining)
16921                 btd_exit();
16922 }
16923
16924 /*
16925  * Check if workaround for broken ATT server socket behavior is needed
16926  * where we need to connect an ATT client socket before pairing to get
16927  * early access to the ATT channel.
16928  */
16929 bool btd_le_connect_before_pairing(void)
16930 {
16931         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 4))
16932                 return true;
16933
16934         return false;
16935 }
16936
16937 bool btd_has_kernel_features(uint32_t features)
16938 {
16939         return !!(kernel_features & features);
16940 }
16941 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16942 int btd_adapter_set_streaming_mode(struct btd_adapter *adapter,
16943                                    const bdaddr_t *bdaddr, gboolean enable)
16944 {
16945         struct mgmt_cp_set_streaming_mode cp;
16946         char addr[18];
16947
16948         ba2str(bdaddr, addr);
16949         DBG("hci%u device %s", adapter->dev_id, addr);
16950
16951         memset(&cp, 0, sizeof(cp));
16952
16953         cp.streaming_mode = enable ? 1 : 0;
16954         bacpy(&cp.bdaddr, bdaddr);
16955
16956         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STREAMING_MODE,
16957                                         adapter->dev_id, sizeof(cp), &cp,
16958                                         NULL, NULL, NULL) > 0)
16959                 return 0;
16960
16961         return -EIO;
16962 }
16963
16964 void adapter_send_event(const char *event)
16965 {
16966         struct btd_adapter *adapter = btd_adapter_get_default();
16967         if (adapter == NULL) {
16968                 error("adapter is NULL");
16969                 return;
16970         }
16971
16972         g_dbus_emit_signal(dbus_conn, adapter->path,
16973                         ADAPTER_INTERFACE, event,
16974                         DBUS_TYPE_INVALID);
16975 }
16976
16977 #endif