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 /* 6fbaf188-05e0-496a-9885-d6ddfdb4e03e */
 160 static const struct mgmt_exp_uuid iso_socket_uuid = {
 161         .val = { 0x3e, 0xe0, 0xb4, 0xfd, 0xdd, 0xd6, 0x85, 0x98,
 162                 0x6a, 0x49, 0xe0, 0x05, 0x88, 0xf1, 0xba, 0x6f },
 163         .str = "6fbaf188-05e0-496a-9885-d6ddfdb4e03e"
 164 };
 165
 166 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 167 #define ADV_DATA_MAX_LENGTH 31
 168 #define SCAN_RESPONSE_DATA_LENGTH_MAX 31
 169 #define EIR_MANUFACTURER_DATA_LENGTH_MAX 100
 170
 171 #define LE_BEARER_POSTFIX       " LE"
 172 #define LE_BEARER_POSTFIX_LEN   3
 173 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
 174
 175
 176 static DBusConnection *dbus_conn = NULL;
 177
 178 static uint32_t kernel_features = 0;
 179
 180 static GList *adapter_list = NULL;
 181 static unsigned int adapter_remaining = 0;
 182 static bool powering_down = false;
 183
 184 static GSList *adapters = NULL;
 185
 186 static struct mgmt *mgmt_primary = NULL;
 187
 188 static uint8_t mgmt_version = 0;
 189 static uint8_t mgmt_revision = 0;
 190
 191 static GSList *adapter_drivers = NULL;
 192
 193 static GSList *disconnect_list = NULL;
 194 static GSList *conn_fail_list = NULL;
 195
 196 struct link_key_info {
 197         bdaddr_t bdaddr;
 198         unsigned char key[16];
 199         uint8_t type;
 200         uint8_t pin_len;
 201         bool is_blocked;
 202 };
 203
 204 struct smp_ltk_info {
 205         bdaddr_t bdaddr;
 206         uint8_t bdaddr_type;
 207         uint8_t authenticated;
 208         bool central;
 209         uint8_t enc_size;
 210         uint16_t ediv;
 211         uint64_t rand;
 212         uint8_t val[16];
 213         bool is_blocked;
 214 };
 215
 216 struct irk_info {
 217         bdaddr_t bdaddr;
 218         uint8_t bdaddr_type;
 219         uint8_t val[16];
 220         bool is_blocked;
 221 };
 222
 223 struct conn_param {
 224         bdaddr_t bdaddr;
 225         uint8_t  bdaddr_type;
 226         uint16_t min_interval;
 227         uint16_t max_interval;
 228         uint16_t latency;
 229         uint16_t timeout;
 230 };
 231
 232 struct discovery_filter {
 233         uint8_t type;
 234         char *pattern;
 235         uint16_t pathloss;
 236         int16_t rssi;
 237         GSList *uuids;
 238         bool duplicate;
 239         bool discoverable;
 240 };
 241
 242 struct discovery_client {
 243         struct btd_adapter *adapter;
 244         DBusMessage *msg;
 245         char *owner;
 246         guint watch;
 247         struct discovery_filter *discovery_filter;
 248 };
 249
 250 struct service_auth {
 251         guint id;
 252         unsigned int svc_id;
 253         service_auth_cb cb;
 254         void *user_data;
 255         const char *uuid;
 256         struct btd_device *device;
 257         struct btd_adapter *adapter;
 258         struct agent *agent;            /* NULL for queued auths */
 259 };
 260
 261 struct btd_adapter_pin_cb_iter {
 262         GSList *it;                     /* current callback function */
 263         unsigned int attempt;           /* numer of times it() was called */
 264         /* When the iterator reaches the end, it is NULL and attempt is 0 */
 265 };
 266
 267 struct exp_pending {
 268         struct btd_adapter *adapter;
 269         unsigned int id;
 270 };
 271
 272 enum {
 273         ADAPTER_POWER_STATE_OFF,
 274         ADAPTER_POWER_STATE_ON,
 275         ADAPTER_POWER_STATE_ON_DISABLING,
 276         ADAPTER_POWER_STATE_OFF_ENABLING,
 277         ADAPTER_POWER_STATE_OFF_BLOCKED,
 278 };
 279
 280 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 281 struct adv_info {
 282         int slot_id;    /* Reservied slot id is 0 (Single adv) */
 283         bool status;            /* Advertising status */
 284 };
 285
 286 static GSList *read_requests = NULL;
 287
 288 struct le_data_length_read_request {
 289         struct btd_adapter *adapter;
 290         DBusMessage *msg;
 291 };
 292
 293 struct le_batching_request {
 294         struct btd_adapter *adapter;
 295         DBusMessage *msg;
 296 };
 297
 298 struct le_batching_set_param_request {
 299         struct btd_adapter *adapter;
 300         DBusMessage *msg;
 301         bdaddr_t bdaddr;
 302 };
 303 #endif
 304
 305 struct btd_adapter {
 306         int ref_count;
 307
 308         uint16_t dev_id;
 309         struct mgmt *mgmt;
 310
 311         bdaddr_t bdaddr;                /* controller Bluetooth address */
 312 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 313         bdaddr_t le_static_addr;
 314         bdaddr_t rpa;
 315 #endif
 316         uint8_t bdaddr_type;            /* address type */
 317         uint32_t dev_class;             /* controller class of device */
 318         char *name;                     /* controller device name */
 319         char *short_name;               /* controller short name */
 320         uint32_t supported_settings;    /* controller supported settings */
 321         uint32_t pending_settings;      /* pending controller settings */
 322         uint32_t power_state;           /* the power state */
 323         uint32_t current_settings;      /* current controller settings */
 324
 325         char *path;                     /* adapter object path */
 326         uint16_t manufacturer;          /* adapter manufacturer */
 327         uint8_t major_class;            /* configured major class */
 328         uint8_t minor_class;            /* configured minor class */
 329         char *system_name;              /* configured system name */
 330         char *modalias;                 /* device id (modalias) */
 331         bool stored_discoverable;       /* stored discoverable mode */
 332         uint32_t discoverable_timeout;  /* discoverable time(sec) */
 333         uint32_t pairable_timeout;      /* pairable time(sec) */
 334
 335         char *current_alias;            /* current adapter name alias */
 336         char *stored_alias;             /* stored adapter name alias */
 337 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 338         uint8_t *local_irk;     /* adapter local IRK */
 339         uint8_t disc_type;
 340         bool ipsp_intialized;           /* Ipsp Initialization state */
 341         struct le_data_length_read_handler *read_handler;
 342         struct le_data_length_read_default_data_length_handler *def_read_handler;
 343 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 344         guint charging_watch;
 345         guint charging_timeout;
 346         charging_state_e charging;
 347 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 348 #endif
 349
 350         bool discovering;               /* discovering property state */
 351         bool filtered_discovery;        /* we are doing filtered discovery */
 352         bool no_scan_restart_delay;     /* when this flag is set, restart scan
 353                                          * without delay */
 354         uint8_t discovery_type;         /* current active discovery type */
 355         uint8_t discovery_enable;       /* discovery enabled/disabled */
 356         bool discovery_suspended;       /* discovery has been suspended */
 357         bool discovery_discoverable;    /* discoverable while discovering */
 358         GSList *discovery_list;         /* list of discovery clients */
 359         GSList *set_filter_list;        /* list of clients that specified
 360                                          * filter, but don't scan yet
 361                                          */
 362         /* current discovery filter, if any */
 363         struct mgmt_cp_start_service_discovery *current_discovery_filter;
 364
 365         struct discovery_client *client;        /* active discovery client */
 366
 367         GSList *discovery_found;        /* list of found devices */
 368 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 369         guint le_discovery_idle_timeout;        /* timeout between le discovery runs */
 370 #endif
 371         unsigned int discovery_idle_timeout; /* timeout between discovery
 372                                                 * runs
 373                                                 */
 374         unsigned int passive_scan_timeout; /* timeout between passive scans */
 375
 376         unsigned int pairable_timeout_id;       /* pairable timeout id */
 377         guint auth_idle_id;             /* Pending authorization dequeue */
 378         GQueue *auths;                  /* Ongoing and pending auths */
 379         bool pincode_requested;         /* PIN requested during last bonding */
 380         GSList *connections;            /* Connected devices */
 381         GSList *devices;                /* Devices structure pointers */
 382         GSList *connect_list;           /* Devices to connect when found */
 383         struct btd_device *connect_le;  /* LE device waiting to be connected */
 384         sdp_list_t *services;           /* Services associated to adapter */
 385
 386         struct btd_gatt_database *database;
 387         struct btd_adv_manager *adv_manager;
 388
 389         struct btd_adv_monitor_manager *adv_monitor_manager;
 390
 391         struct btd_battery_provider_manager *battery_provider_manager;
 392         GHashTable *allowed_uuid_set;   /* Set of allowed service UUIDs */
 393
 394         gboolean initialized;
 395 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 396         GSList *adv_list;       /* List of advertising instance */
 397         bool advertising;               /* Advertising active */
 398         gchar *version;                 /* Bluetooth Version */
 399         uint8_t adv_tx_power;
 400         uint8_t adv_restart_instance;
 401         guint adv_restart_timeout;
 402         bool le_discovering;                    /* LE Discovery active */
 403         GSList *le_discovery_list;              /* list of LE discovery clients */
 404 #endif
 405
 406         GSList *pin_callbacks;
 407         GSList *msd_callbacks;
 408
 409         GSList *drivers;
 410         GSList *profiles;
 411
 412         struct oob_handler *oob_handler;
 413
 414         unsigned int db_id;             /* Service event handler for GATT db */
 415 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 416         uint8_t central_rpa_res_support;
 417         bluetooth_a2dp_role_t a2dp_role;
 418 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
 419         bool scan_filter_support;               /* platform's scan filtering support */
 420         uint8_t scan_type;              /* scan type */
 421         GSList *scan_params;    /* scan filter parameters */
 422         GSList *addr_filters;   /* adress scan filters list */
 423         GSList *service_data_changed_filters;   /* service data changed scan filters list */
 424         GSList *service_uuid_filters;   /* service uuid scan filters list */
 425         GSList *solicit_data_filters;   /* solicitation data scan filters list */
 426         GSList *local_name_filters;     /* local name scan filters list */
 427         GSList *manufaturer_data_filters;       /* manufacturer data scan filters list */
 428         GSList *service_data_filters;   /* service data scan filters list */
 429 #endif
 430 #endif
 431         bool is_default;                /* true if adapter is default one */
 432
 433         struct queue *exp_pending;
 434         struct queue *exps;
 435 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 436         bool le_2m_phy_supported;
 437         bool le_coded_phy_supported;
 438         guint le_batching_available_pkts;
 439 #endif
 440 };
 441
 442 static char *adapter_power_state_str(uint32_t power_state)
 443 {
 444         switch (power_state) {
 445         case ADAPTER_POWER_STATE_OFF:
 446                 return "off";
 447         case ADAPTER_POWER_STATE_ON:
 448                 return "on";
 449         case ADAPTER_POWER_STATE_ON_DISABLING:
 450                 return "on-disabling";
 451         case ADAPTER_POWER_STATE_OFF_ENABLING:
 452                 return "off-enabling";
 453         case ADAPTER_POWER_STATE_OFF_BLOCKED:
 454                 return "off-blocked";
 455         }
 456          DBG("Invalid power state %d", power_state);
 457         return "";
 458 }
 459
 460 typedef enum {
 461         ADAPTER_AUTHORIZE_DISCONNECTED = 0,
 462         ADAPTER_AUTHORIZE_CHECK_CONNECTED
 463 } adapter_authorize_type;
 464
 465 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 466 enum {
 467         DEINIT_6LOWPAN,
 468         INIT_6LOWPAN
 469 };
 470 #endif
 471
 472 static struct btd_adapter *btd_adapter_lookup(uint16_t index)
 473 {
 474         GList *list;
 475
 476         for (list = g_list_first(adapter_list); list;
 477                                                 list = g_list_next(list)) {
 478                 struct btd_adapter *adapter = list->data;
 479
 480                 if (adapter->dev_id == index)
 481                         return adapter;
 482         }
 483
 484         return NULL;
 485 }
 486
 487 struct btd_adapter *btd_adapter_get_default(void)
 488 {
 489         GList *list;
 490
 491         for (list = g_list_first(adapter_list); list;
 492                                                 list = g_list_next(list)) {
 493                 struct btd_adapter *adapter = list->data;
 494
 495                 if (adapter->is_default)
 496                         return adapter;
 497         }
 498
 499         return NULL;
 500 }
 501
 502 bool btd_adapter_is_default(struct btd_adapter *adapter)
 503 {
 504         if (!adapter)
 505                 return false;
 506
 507         return adapter->is_default;
 508 }
 509
 510 uint16_t btd_adapter_get_index(struct btd_adapter *adapter)
 511 {
 512         if (!adapter)
 513                 return MGMT_INDEX_NONE;
 514
 515         return adapter->dev_id;
 516 }
 517
 518 static gboolean process_auth_queue(gpointer user_data);
 519
 520 static void dev_class_changed_callback(uint16_t index, uint16_t length,
 521                                         const void *param, void *user_data)
 522 {
 523         struct btd_adapter *adapter = user_data;
 524         const struct mgmt_cod *rp = param;
 525         uint32_t dev_class;
 526
 527         if (length < sizeof(*rp)) {
 528                 btd_error(adapter->dev_id,
 529                         "Wrong size of class of device changed parameters");
 530                 return;
 531         }
 532
 533         dev_class = rp->val[0] | (rp->val[1] << 8) | (rp->val[2] << 16);
 534
 535         if (dev_class == adapter->dev_class)
 536                 return;
 537
 538         DBG("Class: 0x%06x", dev_class);
 539
 540         adapter->dev_class = dev_class;
 541
 542         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 543                                                 ADAPTER_INTERFACE, "Class");
 544 }
 545
 546 static void set_dev_class_complete(uint8_t status, uint16_t length,
 547                                         const void *param, void *user_data)
 548 {
 549         struct btd_adapter *adapter = user_data;
 550
 551         if (status != MGMT_STATUS_SUCCESS) {
 552                 btd_error(adapter->dev_id,
 553                                 "Failed to set device class: %s (0x%02x)",
 554                                                 mgmt_errstr(status), status);
 555                 return;
 556         }
 557
 558         /*
 559          * The parameters are identical and also the task that is
 560          * required in both cases. So it is safe to just call the
 561          * event handling functions here.
 562          */
 563         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
 564 }
 565
 566 static void set_dev_class(struct btd_adapter *adapter)
 567 {
 568         struct mgmt_cp_set_dev_class cp;
 569
 570         /*
 571          * If the controller does not support BR/EDR operation,
 572          * there is no point in trying to set a major and minor
 573          * class value.
 574          *
 575          * This is an optimization for Low Energy only controllers.
 576          */
 577         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
 578                 return;
 579
 580         memset(&cp, 0, sizeof(cp));
 581
 582         /*
 583          * Silly workaround for a really stupid kernel bug :(
 584          *
 585          * All current kernel versions assign the major and minor numbers
 586          * straight to dev_class[0] and dev_class[1] without considering
 587          * the proper bit shifting.
 588          *
 589          * To make this work, shift the value in userspace for now until
 590          * we get a fixed kernel version.
 591          */
 592         cp.major = adapter->major_class & 0x1f;
 593         cp.minor = adapter->minor_class << 2;
 594
 595         DBG("sending set device class command for index %u", adapter->dev_id);
 596
 597         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_CLASS,
 598                                 adapter->dev_id, sizeof(cp), &cp,
 599                                 set_dev_class_complete, adapter, NULL) > 0)
 600                 return;
 601
 602         btd_error(adapter->dev_id,
 603                 "Failed to set class of device for index %u", adapter->dev_id);
 604 }
 605
 606 void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
 607                                                         uint8_t minor)
 608 {
 609         if (adapter->major_class == major && adapter->minor_class == minor)
 610                 return;
 611
 612         DBG("class: major %u minor %u", major, minor);
 613
 614         adapter->major_class = major;
 615         adapter->minor_class = minor;
 616
 617         set_dev_class(adapter);
 618 }
 619
 620 static uint8_t get_mode(const char *mode)
 621 {
 622         if (strcasecmp("off", mode) == 0)
 623                 return MODE_OFF;
 624         else if (strcasecmp("connectable", mode) == 0)
 625                 return MODE_CONNECTABLE;
 626         else if (strcasecmp("discoverable", mode) == 0)
 627                 return MODE_DISCOVERABLE;
 628         else
 629                 return MODE_UNKNOWN;
 630 }
 631
 632 const char *btd_adapter_get_storage_dir(struct btd_adapter *adapter)
 633 {
 634         static char dir[25];
 635
 636         if (adapter->bdaddr_type == BDADDR_LE_RANDOM) {
 637                 strcpy(dir, "static-");
 638                 ba2str(&adapter->bdaddr, dir + 7);
 639         } else {
 640                 ba2str(&adapter->bdaddr, dir);
 641         }
 642
 643         return dir;
 644 }
 645
 646 uint8_t btd_adapter_get_address_type(struct btd_adapter *adapter)
 647 {
 648         return adapter->bdaddr_type;
 649 }
 650
 651 static void store_adapter_info(struct btd_adapter *adapter)
 652 {
 653         GKeyFile *key_file;
 654         GError *gerr = NULL;
 655         char filename[PATH_MAX];
 656         char *str;
 657         gsize length = 0;
 658         gboolean discoverable;
 659
 660         key_file = g_key_file_new();
 661
 662         if (adapter->pairable_timeout != btd_opts.pairto)
 663                 g_key_file_set_integer(key_file, "General", "PairableTimeout",
 664                                         adapter->pairable_timeout);
 665
 666         if ((adapter->current_settings & MGMT_SETTING_DISCOVERABLE) &&
 667                                                 !adapter->discoverable_timeout)
 668                 discoverable = TRUE;
 669         else
 670                 discoverable = FALSE;
 671
 672         g_key_file_set_boolean(key_file, "General", "Discoverable",
 673                                                         discoverable);
 674
 675         if (adapter->discoverable_timeout != btd_opts.discovto)
 676                 g_key_file_set_integer(key_file, "General",
 677                                         "DiscoverableTimeout",
 678                                         adapter->discoverable_timeout);
 679
 680         if (adapter->stored_alias)
 681                 g_key_file_set_string(key_file, "General", "Alias",
 682                                                         adapter->stored_alias);
 683 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 684         /* Store A2DP Role */
 685         if (adapter->a2dp_role == BLUETOOTH_A2DP_SINK_ROLE)
 686                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "sink");
 687         else if (adapter->a2dp_role == BLUETOOTH_A2DP_BOTH_ROLE)
 688                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "both");
 689         else /* source */
 690                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "source");
 691 #endif
 692
 693         create_filename(filename, PATH_MAX, "/%s/settings",
 694                                                 btd_adapter_get_storage_dir(adapter));
 695         create_file(filename, 0600);
 696
 697         str = g_key_file_to_data(key_file, &length, NULL);
 698         if (!g_file_set_contents(filename, str, length, &gerr)) {
 699                 error("Unable set contents for %s: (%s)", filename,
 700                                                                 gerr->message);
 701                 g_error_free(gerr);
 702         }
 703         g_free(str);
 704
 705         g_key_file_free(key_file);
 706 }
 707
 708 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 709 bluetooth_a2dp_role_t btd_adapter_get_a2dp_role(struct btd_adapter *adapter)
 710 {
 711         if (!adapter)
 712                 return BLUETOOTH_A2DP_SOURCE_ROLE;
 713
 714         return adapter->a2dp_role;
 715 }
 716
 717 void btd_adapter_set_a2dp_role(struct btd_adapter *adapter, bluetooth_a2dp_role_t role)
 718 {
 719         if (!adapter) {
 720                 DBG("Could not set a2dp role");
 721                 return;
 722         }
 723
 724         if (role == BLUETOOTH_A2DP_SOURCE_ROLE) {
 725                 DBG("Set audio source role");
 726                 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
 727         } else if (role == BLUETOOTH_A2DP_SINK_ROLE) {
 728                 DBG("Set audio sink role");
 729                 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
 730 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 731         } else if (role == BLUETOOTH_A2DP_BOTH_ROLE) {
 732                 DBG("Set audio both role");
 733                 adapter->a2dp_role = BLUETOOTH_A2DP_BOTH_ROLE;
 734 #endif
 735         }
 736
 737         store_adapter_info(adapter);
 738 }
 739
 740 void btd_adapter_emit_a2dp_role_changed(struct btd_adapter *adapter)
 741 {
 742         if (!adapter) {
 743                 DBG("Could not emit signal for a2dp role");
 744                 return;
 745         }
 746
 747         DBG("A2dp role: %u", adapter->a2dp_role);
 748
 749         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 750                         ADAPTER_INTERFACE, "A2dpRole");
 751 }
 752 #endif
 753
 754 static void trigger_pairable_timeout(struct btd_adapter *adapter);
 755 static void adapter_start(struct btd_adapter *adapter);
 756 static void adapter_stop(struct btd_adapter *adapter);
 757 static void trigger_passive_scanning(struct btd_adapter *adapter);
 758 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
 759                                                         uint8_t mode);
 760 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 761 static bool load_local_irk(struct btd_adapter *adapter);
 762 static bool set_local_irk(struct btd_adapter *adapter);
 763 static bool set_privacy(struct btd_adapter *adapter, bool privacy);
 764 #endif
 765
 766 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 767 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 768 static gboolean charging_state_timeout_cb(gpointer user_data)
 769 {
 770         struct btd_adapter *adapter = user_data;
 771         int bredr_pkt_type = ACL_PTYPE_MASK;
 772
 773         adapter->charging_timeout = 0;
 774
 775         DBG("Set all connections to BR/EDR type");
 776         g_slist_foreach(adapter->devices, device_change_pkt_type,
 777                         (gpointer)bredr_pkt_type);
 778
 779         return FALSE;
 780 }
 781
 782 static void set_charging_state(struct btd_adapter *adapter,
 783                 charging_state_e state)
 784 {
 785         int br_pkt_type = ACL_PTYPE_MASK |
 786                 HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
 787                 HCI_3DH1 | HCI_3DH3 | HCI_3DH5;
 788
 789         if (adapter->charging == state)
 790                 return;
 791
 792         DBG("old charging state : %d, new charging_state : %d",
 793                         adapter->charging, state);
 794
 795         /*
 796          * Only none / wire charging <-> wireless charging state change should
 797          * be handled.
 798          */
 799         if ((adapter->charging == NONE_CHARGING && state == WIRE_CHARGING) ||
 800             (adapter->charging == WIRE_CHARGING && state == NONE_CHARGING)) {
 801                 DBG("Just update charging state");
 802                 adapter->charging = state;
 803                 return;
 804         }
 805
 806         if (adapter->charging_timeout) {
 807                 g_source_remove(adapter->charging_timeout);
 808                 adapter->charging_timeout = 0;
 809         }
 810
 811         adapter->charging = state;
 812         if (adapter->charging == NONE_CHARGING ||
 813             adapter->charging == WIRE_CHARGING) {
 814                 DBG("Trigger timeout to set connection to BR/EDR type");
 815                 adapter->charging_timeout = g_timeout_add(2000,
 816                                 charging_state_timeout_cb, adapter);
 817         } else if (adapter->charging == WIRELESS_CHARGING) {
 818                 DBG("Set all connections to BR type");
 819                 g_slist_foreach(adapter->devices, device_change_pkt_type,
 820                                 (gpointer)br_pkt_type);
 821         }
 822
 823         return;
 824 }
 825
 826 static gboolean charging_state_changed(DBusConnection *connection,
 827                 DBusMessage *msg, void *user_data)
 828 {
 829         struct btd_adapter *adapter = user_data;
 830         int state = 0;
 831
 832         DBG("charging_state_changed");
 833
 834         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &state,
 835                                 DBUS_TYPE_INVALID))
 836                 return TRUE;
 837
 838         set_charging_state(adapter, state);
 839
 840         return TRUE;
 841 }
 842
 843 charging_state_e get_charging_state(struct btd_adapter *adapter)
 844 {
 845         DBG("charging_state: %d", adapter->charging);
 846         return adapter->charging;
 847 }
 848 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 849
 850 static int compare_slot(gconstpointer a, gconstpointer b)
 851 {
 852         const struct adv_info *adv = a;
 853         const int id = *(int*)b;
 854
 855         return (adv->slot_id == id ? 0 : -1);
 856 }
 857
 858 static struct adv_info *find_advertiser(struct btd_adapter *adapter,
 859                                 int slot_id)
 860 {
 861         GSList *list;
 862
 863         list = g_slist_find_custom(adapter->adv_list, &slot_id,
 864                                                         compare_slot);
 865         if (list)
 866                 return list->data;
 867
 868         return NULL;
 869 }
 870
 871 static struct adv_info *create_advertiser(struct btd_adapter *adapter,
 872                                         int slot_id)
 873 {
 874         struct adv_info *adv;
 875
 876         if (!adapter)
 877                 return NULL;
 878
 879         adv = find_advertiser(adapter, slot_id);
 880         if (adv != NULL) {
 881                 DBG("Aleady existed. solt_id [%d]", slot_id);
 882                 return adv;
 883         }
 884
 885         DBG("Create adv slot id : %d", slot_id);
 886
 887         adv = g_new0(struct adv_info, 1);
 888         if (adv == NULL)
 889                 return NULL;
 890
 891         adv->slot_id = slot_id;
 892
 893         adapter->adv_list = g_slist_append(adapter->adv_list, adv);
 894         return adv;
 895 }
 896
 897
 898 static void advertising_state_changed(struct btd_adapter *adapter,
 899                                         int slot_id, bool enabled)
 900 {
 901         struct adv_info *adv;
 902         int id = slot_id;
 903         int state = enabled;
 904
 905         if (!adapter)
 906                 return;
 907
 908         adv = find_advertiser(adapter, slot_id);
 909         if (!adv) {
 910                 DBG("Unable to find advertiser [%d]", slot_id);
 911                 return;
 912         }
 913
 914         adv->status = enabled;
 915         DBG("slot_id %d, status %d", adv->slot_id, adv->status);
 916
 917         g_dbus_emit_signal(dbus_conn, adapter->path,
 918                         ADAPTER_INTERFACE, "AdvertisingEnabled",
 919                         DBUS_TYPE_INT32, &id,
 920                         DBUS_TYPE_BOOLEAN, &state,
 921                         DBUS_TYPE_INVALID);
 922 }
 923
 924 static void clear_advertiser_cb(gpointer data, gpointer user_data)
 925 {
 926         struct adv_info *adv = data;
 927         struct btd_adapter *adapter = user_data;
 928
 929         if (adv->status)
 930                 advertising_state_changed(adapter, adv->slot_id, 0);
 931 }
 932
 933 static void advertiser_cleanup(struct btd_adapter *adapter)
 934 {
 935         if (!adapter->adv_list)
 936                 return;
 937
 938         g_slist_foreach(adapter->adv_list, clear_advertiser_cb, adapter);
 939         g_slist_free(adapter->adv_list);
 940         adapter->adv_list = NULL;
 941 }
 942
 943 static void update_advertiser_address(gpointer data, gpointer user_data)
 944 {
 945         struct adv_info *adv = data;
 946         struct btd_adapter *adapter = user_data;
 947
 948         if (adv->slot_id > 0 && adv->status == 1)
 949                 adapter_le_set_random_address(adapter, &adapter->rpa, adv->slot_id);
 950 }
 951
 952 static void rpa_changed_callback(uint16_t index, uint16_t length,
 953                                         const void *param, void *user_data)
 954 {
 955         const struct mgmt_ev_rpa_changed *ev = param;
 956         struct btd_adapter *adapter = user_data;
 957         char addr[18];
 958
 959         if (length < sizeof(*ev)) {
 960                 error("Too small rpa changed event");
 961                 return;
 962         }
 963
 964         ba2str(&ev->bdaddr, addr);
 965         DBG("RPA changed %s", addr);
 966         bacpy(&adapter->rpa, &ev->bdaddr);
 967
 968         if (!adapter->adv_list)
 969                 return;
 970
 971         g_slist_foreach(adapter->adv_list, update_advertiser_address, adapter);
 972 }
 973
 974 #endif
 975
 976 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 977 #define OCF_PAGE_SCAN_TIMEOUT                   0x0018
 978 #define OGF_PAGE_SCAN_TIMEOUT           0x03
 979
 980 typedef struct {
 981         uint16_t        timeout;        /* Value */
 982 } __attribute__ ((packed)) hci_page_scan_timeout;
 983 #define HCI_PAGE_SCAN_TIMEOUT_CP_SIZE 2
 984
 985 static gboolean send_sprd_page_scan_timeout(gint value)
 986 {
 987         int dd;
 988         hci_page_scan_timeout cp;
 989         DBG("+");
 990         dd = hci_open_dev(0);
 991         cp.timeout = value;
 992         if (hci_send_cmd(dd, OGF_PAGE_SCAN_TIMEOUT, OCF_PAGE_SCAN_TIMEOUT,
 993                                 HCI_PAGE_SCAN_TIMEOUT_CP_SIZE, &cp) < 0) {
 994                 DBG("Error: While setting Page Timeout value");
 995                 hci_close_dev(dd);
 996                 return FALSE;
 997         }
 998         DBG("Page Scan Timeout Value Patch %d", value);
 999
1000         hci_close_dev(dd);
1001
1002         return TRUE;
1003 }
1004 #endif
1005
1006 static void settings_changed(struct btd_adapter *adapter, uint32_t settings)
1007 {
1008         uint32_t changed_mask;
1009
1010         changed_mask = adapter->current_settings ^ settings;
1011
1012         adapter->current_settings = settings;
1013         adapter->pending_settings &= ~changed_mask;
1014
1015         DBG("Changed settings: 0x%08x", changed_mask);
1016         DBG("Pending settings: 0x%08x", adapter->pending_settings);
1017
1018         if (changed_mask & MGMT_SETTING_POWERED) {
1019                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1020                                         ADAPTER_INTERFACE, "Powered");
1021
1022                 if (adapter->current_settings & MGMT_SETTING_POWERED) {
1023                         adapter_start(adapter);
1024
1025 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1026                         if (TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN) {
1027                                 /* Approx 6.4 Seconds of timeout */
1028                                 /* This Added because Z3 device was not able to connect with
1029                                   * some device as it was getting Page Timeout
1030                                   * (LG HBS800, sony carkit) etc. So, Increasing Page timeout value
1031                                   * from 5.12 Sec (which is default) to ~6.4sec*/
1032                                 DBG("Setting value");
1033                                 send_sprd_page_scan_timeout(10240);
1034                         }
1035 #endif
1036                 } else {
1037                         adapter_stop(adapter);
1038
1039                         if (powering_down) {
1040                                 adapter_remaining--;
1041
1042                                 if (!adapter_remaining)
1043                                         btd_exit();
1044                         }
1045                 }
1046         }
1047
1048         if ((changed_mask & MGMT_SETTING_LE) &&
1049                                 btd_adapter_get_powered(adapter) &&
1050                                 (adapter->current_settings & MGMT_SETTING_LE))
1051                 trigger_passive_scanning(adapter);
1052
1053         if (changed_mask & MGMT_SETTING_DISCOVERABLE) {
1054                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1055                                         ADAPTER_INTERFACE, "Discoverable");
1056                 /* Only persist discoverable setting if it was not set
1057                  * temporarily by discovery.
1058                  */
1059                 if (!adapter->discovery_discoverable)
1060                         store_adapter_info(adapter);
1061                 btd_adv_manager_refresh(adapter->adv_manager);
1062         }
1063
1064         if (changed_mask & MGMT_SETTING_BONDABLE) {
1065                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1066                                         ADAPTER_INTERFACE, "Pairable");
1067
1068                 trigger_pairable_timeout(adapter);
1069         }
1070
1071 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1072         if (changed_mask & MGMT_SETTING_ADVERTISING) {
1073                 if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
1074                         (adapter->advertising)) {
1075                         return;
1076                 }
1077
1078                 adapter->advertising = adapter->current_settings & MGMT_SETTING_ADVERTISING;
1079                 advertising_state_changed(adapter, 0, adapter->advertising);
1080         }
1081
1082         if ((changed_mask & MGMT_SETTING_PRIVACY) &&
1083             !(adapter->current_settings & MGMT_SETTING_PRIVACY)) {
1084                 DBG("LE Privacy feature is disabled");
1085
1086                 /*
1087                  * Some Android devices don't consider the device as LE one,
1088                  * if the device doesn't distribute IRK when pairing.
1089                  * Because of this compatibility issue, set IRK
1090                  * even though privacy feature is disabled.
1091                  */
1092                 set_local_irk(adapter);
1093         }
1094 #endif
1095 }
1096
1097 static void adapter_set_power_state(struct btd_adapter *adapter, uint32_t value)
1098 {
1099         if (adapter->power_state == value)
1100                 return;
1101
1102         DBG("%s", adapter_power_state_str(value));
1103         adapter->power_state = value;
1104         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1105                                         ADAPTER_INTERFACE, "PowerState");
1106 }
1107
1108 static void reset_power_state_target(struct btd_adapter *adapter,
1109                                         uint32_t value)
1110 {
1111         if (value &&
1112             adapter->power_state == ADAPTER_POWER_STATE_OFF_ENABLING) {
1113                 adapter_set_power_state(adapter, ADAPTER_POWER_STATE_ON);
1114         } else if (!value &&
1115                    adapter->power_state == ADAPTER_POWER_STATE_ON_DISABLING) {
1116                 adapter_set_power_state(adapter, ADAPTER_POWER_STATE_OFF);
1117         }
1118 }
1119
1120 static void new_settings_callback(uint16_t index, uint16_t length,
1121                                         const void *param, void *user_data)
1122 {
1123         struct btd_adapter *adapter = user_data;
1124         uint32_t settings;
1125
1126         if (length < sizeof(settings)) {
1127                 btd_error(adapter->dev_id,
1128                                 "Wrong size of new settings parameters");
1129                 return;
1130         }
1131
1132         settings = get_le32(param);
1133
1134         if (settings == adapter->current_settings)
1135                 return;
1136
1137         if ((adapter->current_settings ^ settings) & MGMT_SETTING_POWERED) {
1138                 reset_power_state_target(adapter,
1139                                         settings & MGMT_SETTING_POWERED ?
1140                                         0x01 : 0x00);
1141         }
1142
1143         DBG("Settings: 0x%08x", settings);
1144
1145         settings_changed(adapter, settings);
1146 }
1147
1148 struct set_mode_data {
1149         struct btd_adapter *adapter;
1150         uint32_t setting;
1151         uint8_t value;
1152 };
1153
1154 static void set_mode_complete(uint8_t status, uint16_t length,
1155                                         const void *param, void *user_data)
1156 {
1157         struct set_mode_data *data = user_data;
1158         struct btd_adapter *adapter = data->adapter;
1159
1160         if (status != MGMT_STATUS_SUCCESS) {
1161                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
1162                                                 mgmt_errstr(status), status);
1163                 if (status == MGMT_STATUS_RFKILLED)
1164                         adapter_set_power_state(adapter,
1165                                         ADAPTER_POWER_STATE_OFF_BLOCKED);
1166                 adapter->pending_settings &= ~data->setting;
1167                 if (status != MGMT_STATUS_RFKILLED &&
1168                     data->setting & MGMT_SETTING_POWERED)
1169                         reset_power_state_target(adapter, data->value);
1170                 return;
1171         }
1172
1173         /*
1174          * The parameters are identical and also the task that is
1175          * required in both cases. So it is safe to just call the
1176          * event handling functions here.
1177          */
1178         new_settings_callback(adapter->dev_id, length, param, adapter);
1179 }
1180
1181 static void remove_temporary_devices(struct btd_adapter *adapter)
1182 {
1183         GSList *l, *next;
1184
1185         for (l = adapter->devices; l; l = next) {
1186                 struct btd_device *dev = l->data;
1187
1188                 next = g_slist_next(l);
1189                 if (device_is_temporary(dev))
1190                         btd_adapter_remove_device(adapter, dev);
1191         }
1192 }
1193
1194 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
1195                                                         uint8_t mode)
1196 {
1197         struct mgmt_mode cp;
1198         uint32_t setting = 0;
1199         struct set_mode_data *data;
1200
1201         memset(&cp, 0, sizeof(cp));
1202         cp.val = mode;
1203
1204         switch (opcode) {
1205         case MGMT_OP_SET_POWERED:
1206                 setting = MGMT_SETTING_POWERED;
1207                 if (adapter->power_state != ADAPTER_POWER_STATE_OFF_BLOCKED) {
1208                         adapter_set_power_state(adapter, mode ?
1209                                         ADAPTER_POWER_STATE_OFF_ENABLING :
1210                                         ADAPTER_POWER_STATE_ON_DISABLING);
1211                 }
1212                 break;
1213         case MGMT_OP_SET_CONNECTABLE:
1214                 setting = MGMT_SETTING_CONNECTABLE;
1215                 break;
1216         case MGMT_OP_SET_FAST_CONNECTABLE:
1217                 setting = MGMT_SETTING_FAST_CONNECTABLE;
1218                 break;
1219         case MGMT_OP_SET_DISCOVERABLE:
1220                 setting = MGMT_SETTING_DISCOVERABLE;
1221                 break;
1222         case MGMT_OP_SET_BONDABLE:
1223                 setting = MGMT_SETTING_BONDABLE;
1224                 break;
1225         }
1226
1227         adapter->pending_settings |= setting;
1228
1229 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1230         DBG("sending 0x%4.4x set mode %d command for index %u", opcode, mode, adapter->dev_id);
1231 #else
1232         DBG("sending set mode command for index %u", adapter->dev_id);
1233 #endif
1234
1235         data = g_new0(struct set_mode_data, 1);
1236         data->adapter = adapter;
1237         data->setting = setting;
1238         data->value = mode;
1239
1240         if (mgmt_send(adapter->mgmt, opcode,
1241                                 adapter->dev_id, sizeof(cp), &cp,
1242                                 set_mode_complete, data, g_free) > 0){
1243                 adapter->pending_settings |= setting;
1244                 return true;
1245         }
1246         g_free(data);
1247         if (setting == MGMT_SETTING_POWERED) {
1248                 /* cancel the earlier setting */
1249                 adapter_set_power_state(adapter, mode ?
1250                                         ADAPTER_POWER_STATE_OFF :
1251                                         ADAPTER_POWER_STATE_ON);
1252         }
1253         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1254                                                         adapter->dev_id);
1255
1256         return false;
1257 }
1258
1259 static bool set_discoverable(struct btd_adapter *adapter, uint8_t mode,
1260                                                         uint16_t timeout)
1261 {
1262         struct mgmt_cp_set_discoverable cp;
1263         struct set_mode_data *data;
1264
1265         memset(&cp, 0, sizeof(cp));
1266         cp.val = mode;
1267         cp.timeout = htobs(timeout);
1268
1269         DBG("sending set mode command for index %u", adapter->dev_id);
1270
1271 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1272         if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
1273                 if (mode)
1274                         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, mode);
1275                 else
1276                         /* This also disables discoverable so we're done */
1277                         return set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
1278                                                                         mode);
1279         }
1280 #endif
1281
1282         data = g_new0(struct set_mode_data, 1);
1283         data->adapter = adapter;
1284         data->setting = 0;
1285
1286         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DISCOVERABLE,
1287                                 adapter->dev_id, sizeof(cp), &cp,
1288                                 set_mode_complete, data, g_free) > 0)
1289                 return true;
1290
1291         g_free(data);
1292         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1293                                                         adapter->dev_id);
1294
1295         return false;
1296 }
1297
1298 static bool pairable_timeout_handler(gpointer user_data)
1299 {
1300         struct btd_adapter *adapter = user_data;
1301
1302         adapter->pairable_timeout_id = 0;
1303
1304         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
1305
1306         return FALSE;
1307 }
1308
1309 static void trigger_pairable_timeout(struct btd_adapter *adapter)
1310 {
1311         if (adapter->pairable_timeout_id > 0) {
1312                 timeout_remove(adapter->pairable_timeout_id);
1313                 adapter->pairable_timeout_id = 0;
1314         }
1315
1316         if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
1317                 return;
1318
1319         if (adapter->pairable_timeout > 0)
1320                 adapter->pairable_timeout_id =
1321                         timeout_add_seconds(adapter->pairable_timeout,
1322                                         pairable_timeout_handler, adapter,
1323                                         NULL);
1324 }
1325
1326 static void local_name_changed_callback(uint16_t index, uint16_t length,
1327                                         const void *param, void *user_data)
1328 {
1329         struct btd_adapter *adapter = user_data;
1330         const struct mgmt_cp_set_local_name *rp = param;
1331
1332         if (length < sizeof(*rp)) {
1333                 btd_error(adapter->dev_id,
1334                                 "Wrong size of local name changed parameters");
1335                 return;
1336         }
1337
1338         if (!g_strcmp0(adapter->short_name, (const char *) rp->short_name) &&
1339                         !g_strcmp0(adapter->name, (const char *) rp->name))
1340                 return;
1341
1342         DBG("Name: %s", rp->name);
1343         DBG("Short name: %s", rp->short_name);
1344
1345         g_free(adapter->name);
1346         adapter->name = g_strdup((const char *) rp->name);
1347
1348         g_free(adapter->short_name);
1349         adapter->short_name = g_strdup((const char *) rp->short_name);
1350
1351         /*
1352          * Changing the name (even manually via HCI) will update the
1353          * current alias property.
1354          *
1355          * In case the name is empty, use the short name.
1356          *
1357          * There is a difference between the stored alias (which is
1358          * configured by the user) and the current alias. The current
1359          * alias is temporary for the lifetime of the daemon.
1360          */
1361         if (adapter->name && adapter->name[0] != '\0') {
1362                 g_free(adapter->current_alias);
1363                 adapter->current_alias = g_strdup(adapter->name);
1364         } else {
1365                 g_free(adapter->current_alias);
1366                 adapter->current_alias = g_strdup(adapter->short_name);
1367         }
1368
1369         DBG("Current alias: %s", adapter->current_alias);
1370
1371         if (!adapter->current_alias)
1372                 return;
1373
1374         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1375                                                 ADAPTER_INTERFACE, "Alias");
1376
1377         attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
1378                                 (const uint8_t *) adapter->current_alias,
1379                                         strlen(adapter->current_alias));
1380 }
1381
1382 static void set_local_name_complete(uint8_t status, uint16_t length,
1383                                         const void *param, void *user_data)
1384 {
1385         struct btd_adapter *adapter = user_data;
1386
1387         if (status != MGMT_STATUS_SUCCESS) {
1388                 btd_error(adapter->dev_id,
1389                                 "Failed to set local name: %s (0x%02x)",
1390                                                 mgmt_errstr(status), status);
1391                 return;
1392         }
1393
1394         /*
1395          * The parameters are identical and also the task that is
1396          * required in both cases. So it is safe to just call the
1397          * event handling functions here.
1398          */
1399         local_name_changed_callback(adapter->dev_id, length, param, adapter);
1400 }
1401
1402 static int set_name(struct btd_adapter *adapter, const char *name)
1403 {
1404         struct mgmt_cp_set_local_name cp;
1405         char maxname[MAX_NAME_LENGTH];
1406
1407         memset(maxname, 0, sizeof(maxname));
1408         strncpy(maxname, name, MAX_NAME_LENGTH - 1);
1409
1410         if (!g_utf8_validate(maxname, -1, NULL)) {
1411                 btd_error(adapter->dev_id,
1412                         "Name change failed: supplied name isn't valid UTF-8");
1413                 return -EINVAL;
1414         }
1415
1416         memset(&cp, 0, sizeof(cp));
1417         strncpy((char *) cp.name, maxname, sizeof(cp.name) - 1);
1418
1419         DBG("sending set local name command for index %u", adapter->dev_id);
1420
1421         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LOCAL_NAME,
1422                                 adapter->dev_id, sizeof(cp), &cp,
1423                                 set_local_name_complete, adapter, NULL) > 0)
1424                 return 0;
1425
1426         btd_error(adapter->dev_id, "Failed to set local name for index %u",
1427                                                         adapter->dev_id);
1428
1429         return -EIO;
1430 }
1431
1432 int adapter_set_name(struct btd_adapter *adapter, const char *name)
1433 {
1434         if (g_strcmp0(adapter->system_name, name) == 0)
1435                 return 0;
1436
1437         DBG("name: %s", name);
1438
1439         g_free(adapter->system_name);
1440         adapter->system_name = g_strdup(name);
1441
1442         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1443                                                 ADAPTER_INTERFACE, "Name");
1444
1445         /* alias is preferred over system name */
1446         if (adapter->stored_alias)
1447                 return 0;
1448
1449         DBG("alias: %s", name);
1450
1451         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1452                                                 ADAPTER_INTERFACE, "Alias");
1453
1454         return set_name(adapter, name);
1455 }
1456
1457 struct btd_device *btd_adapter_find_device(struct btd_adapter *adapter,
1458                                                         const bdaddr_t *dst,
1459                                                         uint8_t bdaddr_type)
1460 {
1461         struct device_addr_type addr;
1462         struct btd_device *device;
1463         GSList *list;
1464
1465         if (!adapter)
1466                 return NULL;
1467
1468         bacpy(&addr.bdaddr, dst);
1469         addr.bdaddr_type = bdaddr_type;
1470
1471 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1472         list = g_slist_find_custom(adapter->devices, &addr,
1473                                                 device_addr_type_strict_cmp);
1474         if (list) {
1475                 device = list->data;
1476                 return device;
1477         }
1478 #endif
1479         list = g_slist_find_custom(adapter->devices, &addr,
1480                                                         device_addr_type_cmp);
1481         if (!list)
1482                 return NULL;
1483
1484         device = list->data;
1485
1486         /*
1487          * If we're looking up based on public address and the address
1488          * was not previously used over this bearer we may need to
1489          * update LE or BR/EDR support information.
1490          */
1491         if (bdaddr_type == BDADDR_BREDR)
1492                 device_set_bredr_support(device);
1493         else
1494                 device_set_le_support(device, bdaddr_type);
1495
1496         return device;
1497 }
1498
1499 static int device_path_cmp(gconstpointer a, gconstpointer b)
1500 {
1501         const struct btd_device *device = a;
1502         const char *path = b;
1503         const char *dev_path = device_get_path(device);
1504
1505         return strcasecmp(dev_path, path);
1506 }
1507
1508 struct btd_device *btd_adapter_find_device_by_path(struct btd_adapter *adapter,
1509                                                    const char *path)
1510 {
1511         GSList *list;
1512
1513         if (!adapter)
1514                 return NULL;
1515
1516         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
1517         if (!list)
1518                 return NULL;
1519
1520         return list->data;
1521 }
1522
1523 static void uuid_to_uuid128(uuid_t *uuid128, const uuid_t *uuid)
1524 {
1525         if (uuid->type == SDP_UUID16)
1526                 sdp_uuid16_to_uuid128(uuid128, uuid);
1527         else if (uuid->type == SDP_UUID32)
1528                 sdp_uuid32_to_uuid128(uuid128, uuid);
1529         else
1530                 memcpy(uuid128, uuid, sizeof(*uuid));
1531 }
1532
1533 static bool is_supported_uuid(const uuid_t *uuid)
1534 {
1535         uuid_t tmp;
1536
1537         /* mgmt versions from 1.3 onwards support all types of UUIDs */
1538         if (MGMT_VERSION(mgmt_version, mgmt_revision) >= MGMT_VERSION(1, 3))
1539                 return true;
1540
1541         uuid_to_uuid128(&tmp, uuid);
1542
1543         if (!sdp_uuid128_to_uuid(&tmp))
1544                 return false;
1545
1546         if (tmp.type != SDP_UUID16)
1547                 return false;
1548
1549         return true;
1550 }
1551
1552 static void add_uuid_complete(uint8_t status, uint16_t length,
1553                                         const void *param, void *user_data)
1554 {
1555         struct btd_adapter *adapter = user_data;
1556
1557         if (status != MGMT_STATUS_SUCCESS) {
1558                 btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
1559                                                 mgmt_errstr(status), status);
1560                 return;
1561         }
1562
1563         /*
1564          * The parameters are identical and also the task that is
1565          * required in both cases. So it is safe to just call the
1566          * event handling functions here.
1567          */
1568         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1569
1570         if (adapter->initialized)
1571                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1572                                                 ADAPTER_INTERFACE, "UUIDs");
1573 }
1574
1575 static int add_uuid(struct btd_adapter *adapter, uuid_t *uuid, uint8_t svc_hint)
1576 {
1577         struct mgmt_cp_add_uuid cp;
1578         uuid_t uuid128;
1579         uint128_t uint128;
1580
1581         if (!is_supported_uuid(uuid)) {
1582                 btd_warn(adapter->dev_id,
1583                                 "Ignoring unsupported UUID for addition");
1584                 return 0;
1585         }
1586
1587         uuid_to_uuid128(&uuid128, uuid);
1588
1589         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1590         htob128(&uint128, (uint128_t *) cp.uuid);
1591         cp.svc_hint = svc_hint;
1592
1593         DBG("sending add uuid command for index %u", adapter->dev_id);
1594
1595         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_UUID,
1596                                 adapter->dev_id, sizeof(cp), &cp,
1597                                 add_uuid_complete, adapter, NULL) > 0)
1598                 return 0;
1599
1600         btd_error(adapter->dev_id, "Failed to add UUID for index %u",
1601                                                         adapter->dev_id);
1602
1603         return -EIO;
1604 }
1605
1606 static void remove_uuid_complete(uint8_t status, uint16_t length,
1607                                         const void *param, void *user_data)
1608 {
1609         struct btd_adapter *adapter = user_data;
1610
1611         if (status != MGMT_STATUS_SUCCESS) {
1612                 btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
1613                                                 mgmt_errstr(status), status);
1614                 return;
1615         }
1616
1617         /*
1618          * The parameters are identical and also the task that is
1619          * required in both cases. So it is safe to just call the
1620          * event handling functions here.
1621          */
1622         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1623
1624         if (adapter->initialized)
1625                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1626                                                 ADAPTER_INTERFACE, "UUIDs");
1627 }
1628
1629 static int remove_uuid(struct btd_adapter *adapter, uuid_t *uuid)
1630 {
1631         struct mgmt_cp_remove_uuid cp;
1632         uuid_t uuid128;
1633         uint128_t uint128;
1634
1635         if (!is_supported_uuid(uuid)) {
1636                 btd_warn(adapter->dev_id,
1637                                 "Ignoring unsupported UUID for removal");
1638                 return 0;
1639         }
1640
1641         uuid_to_uuid128(&uuid128, uuid);
1642
1643         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1644         htob128(&uint128, (uint128_t *) cp.uuid);
1645
1646         DBG("sending remove uuid command for index %u", adapter->dev_id);
1647
1648         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1649                                 adapter->dev_id, sizeof(cp), &cp,
1650                                 remove_uuid_complete, adapter, NULL) > 0)
1651                 return 0;
1652
1653         btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
1654                                                         adapter->dev_id);
1655
1656         return -EIO;
1657 }
1658
1659 static void clear_uuids_complete(uint8_t status, uint16_t length,
1660                                         const void *param, void *user_data)
1661 {
1662         struct btd_adapter *adapter = user_data;
1663
1664         if (status != MGMT_STATUS_SUCCESS) {
1665                 btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
1666                                                 mgmt_errstr(status), status);
1667                 return;
1668         }
1669
1670         /*
1671          * The parameters are identical and also the task that is
1672          * required in both cases. So it is safe to just call the
1673          * event handling functions here.
1674          */
1675         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1676 }
1677
1678 static int clear_uuids(struct btd_adapter *adapter)
1679 {
1680         struct mgmt_cp_remove_uuid cp;
1681
1682         memset(&cp, 0, sizeof(cp));
1683
1684         DBG("sending clear uuids command for index %u", adapter->dev_id);
1685
1686         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1687                                 adapter->dev_id, sizeof(cp), &cp,
1688                                 clear_uuids_complete, adapter, NULL) > 0)
1689                 return 0;
1690
1691         btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
1692                                                         adapter->dev_id);
1693
1694         return -EIO;
1695 }
1696
1697 static uint8_t get_uuid_mask(uuid_t *uuid)
1698 {
1699         if (uuid->type != SDP_UUID16)
1700                 return 0;
1701
1702         switch (uuid->value.uuid16) {
1703         case DIALUP_NET_SVCLASS_ID:
1704         case CIP_SVCLASS_ID:
1705                 return 0x42;    /* Telephony & Networking */
1706         case IRMC_SYNC_SVCLASS_ID:
1707         case OBEX_OBJPUSH_SVCLASS_ID:
1708         case OBEX_FILETRANS_SVCLASS_ID:
1709         case IRMC_SYNC_CMD_SVCLASS_ID:
1710         case PBAP_PSE_SVCLASS_ID:
1711                 return 0x10;    /* Object Transfer */
1712         case HEADSET_SVCLASS_ID:
1713         case HANDSFREE_SVCLASS_ID:
1714                 return 0x20;    /* Audio */
1715         case CORDLESS_TELEPHONY_SVCLASS_ID:
1716         case INTERCOM_SVCLASS_ID:
1717         case FAX_SVCLASS_ID:
1718         case SAP_SVCLASS_ID:
1719         /*
1720          * Setting the telephony bit for the handsfree audio gateway
1721          * role is not required by the HFP specification, but the
1722          * Nokia 616 carkit is just plain broken! It will refuse
1723          * pairing without this bit set.
1724          */
1725         case HANDSFREE_AGW_SVCLASS_ID:
1726                 return 0x40;    /* Telephony */
1727         case AUDIO_SOURCE_SVCLASS_ID:
1728         case VIDEO_SOURCE_SVCLASS_ID:
1729                 return 0x08;    /* Capturing */
1730         case AUDIO_SINK_SVCLASS_ID:
1731         case VIDEO_SINK_SVCLASS_ID:
1732                 return 0x04;    /* Rendering */
1733         case PANU_SVCLASS_ID:
1734         case NAP_SVCLASS_ID:
1735         case GN_SVCLASS_ID:
1736                 return 0x02;    /* Networking */
1737         default:
1738                 return 0;
1739         }
1740 }
1741
1742 static int uuid_cmp(const void *a, const void *b)
1743 {
1744         const sdp_record_t *rec = a;
1745         const uuid_t *uuid = b;
1746
1747         return sdp_uuid_cmp(&rec->svclass, uuid);
1748 }
1749
1750 static void adapter_service_insert(struct btd_adapter *adapter, sdp_record_t *rec)
1751 {
1752         sdp_list_t *browse_list = NULL;
1753         uuid_t browse_uuid;
1754         gboolean new_uuid;
1755
1756         DBG("%s", adapter->path);
1757
1758 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1759         if (rec == NULL) {
1760                 DBG("record is NULL return");
1761                 return;
1762         }
1763 #endif
1764
1765         /* skip record without a browse group */
1766         if (sdp_get_browse_groups(rec, &browse_list) < 0) {
1767                 DBG("skipping record without browse group");
1768                 return;
1769         }
1770
1771         sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
1772
1773         /* skip record without public browse group */
1774         if (!sdp_list_find(browse_list, &browse_uuid, sdp_uuid_cmp))
1775                 goto done;
1776
1777         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1778                 new_uuid = TRUE;
1779         else
1780                 new_uuid = FALSE;
1781
1782         adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1783                                                                 record_sort);
1784
1785         if (new_uuid) {
1786                 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1787                 add_uuid(adapter, &rec->svclass, svc_hint);
1788         }
1789
1790 done:
1791         sdp_list_free(browse_list, free);
1792 }
1793
1794 int adapter_service_add(struct btd_adapter *adapter, sdp_record_t *rec)
1795 {
1796         int ret;
1797
1798         /*
1799          * If the controller does not support BR/EDR operation,
1800          * there is no point in trying to add SDP records.
1801          */
1802         if (btd_opts.mode == BT_MODE_LE)
1803                 return -ENOTSUP;
1804
1805         DBG("%s", adapter->path);
1806
1807         ret = add_record_to_server(&adapter->bdaddr, rec);
1808         if (ret < 0)
1809                 return ret;
1810
1811         adapter_service_insert(adapter, rec);
1812
1813         return 0;
1814 }
1815
1816 void adapter_service_remove(struct btd_adapter *adapter, uint32_t handle)
1817 {
1818         sdp_record_t *rec;
1819         /*
1820          * If the controller does not support BR/EDR operation,
1821          * there is no point in trying to remote SDP records.
1822          */
1823         if (btd_opts.mode == BT_MODE_LE)
1824                 return;
1825
1826         DBG("%s", adapter->path);
1827
1828         rec = sdp_record_find(handle);
1829         if (!rec)
1830                 return;
1831
1832         adapter->services = sdp_list_remove(adapter->services, rec);
1833
1834         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1835                 remove_uuid(adapter, &rec->svclass);
1836
1837         remove_record_from_server(rec->handle);
1838 }
1839
1840 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1841 static void adapter_print_devices(struct btd_adapter *adapter)
1842 {
1843         GSList *dev;
1844
1845         dev = adapter->devices;
1846         for (; dev; dev = dev->next)
1847                 device_print_addr(dev->data);
1848 }
1849 #endif
1850
1851 static void adapter_add_device(struct btd_adapter *adapter,
1852                                                 struct btd_device *device);
1853
1854 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
1855                                                 const bdaddr_t *bdaddr,
1856                                                 uint8_t bdaddr_type)
1857 {
1858         struct btd_device *device;
1859
1860         device = device_create(adapter, bdaddr, bdaddr_type);
1861         if (!device)
1862                 return NULL;
1863
1864         adapter_add_device(adapter, device);
1865
1866 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1867         device_print_addr(device);
1868         DBG("devices list count : %d", g_slist_length(adapter->devices));
1869 #endif
1870
1871         return device;
1872 }
1873
1874 static void service_auth_cancel(struct service_auth *auth)
1875 {
1876         DBusError derr;
1877
1878         if (auth->svc_id > 0)
1879                 device_remove_svc_complete_callback(auth->device,
1880                                                                 auth->svc_id);
1881
1882         dbus_error_init(&derr);
1883         dbus_set_error_const(&derr, ERROR_INTERFACE ".Canceled", NULL);
1884
1885         auth->cb(&derr, auth->user_data);
1886
1887         dbus_error_free(&derr);
1888
1889         if (auth->agent != NULL) {
1890                 agent_cancel(auth->agent);
1891                 agent_unref(auth->agent);
1892         }
1893
1894         g_free(auth);
1895 }
1896
1897 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1898 void btd_adapter_unpair_device(struct btd_adapter *adapter,
1899                                 struct btd_device *dev)
1900 {
1901         DBG("+");
1902         GList *l;
1903
1904         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1905
1906 //      adapter->devices = g_slist_remove(adapter->devices, dev);
1907 //
1908 //      adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1909 //                                                                      dev);
1910
1911         adapter->connections = g_slist_remove(adapter->connections, dev);
1912
1913         if (adapter->connect_le == dev)
1914                 adapter->connect_le = NULL;
1915
1916         l = adapter->auths->head;
1917         while (l != NULL) {
1918                 struct service_auth *auth = l->data;
1919                 GList *next = g_list_next(l);
1920
1921                 if (auth->device != dev) {
1922                         l = next;
1923                         continue;
1924                 }
1925
1926                 g_queue_delete_link(adapter->auths, l);
1927                 l = next;
1928
1929                 service_auth_cancel(auth);
1930         }
1931
1932         device_unpair(dev, TRUE);
1933         DBG("-");
1934 }
1935 #endif
1936
1937 static void adapter_remove_device(struct btd_adapter *adapter,
1938                                                 struct btd_device *device);
1939
1940 void btd_adapter_remove_device(struct btd_adapter *adapter,
1941                                 struct btd_device *dev)
1942 {
1943         GList *l;
1944
1945         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1946
1947         adapter_remove_device(adapter, dev);
1948 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
1949         btd_adv_monitor_device_remove(adapter->adv_monitor_manager, dev);
1950 #endif
1951         adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1952                                                                         dev);
1953
1954         adapter->connections = g_slist_remove(adapter->connections, dev);
1955
1956         if (adapter->connect_le == dev)
1957                 adapter->connect_le = NULL;
1958
1959         l = adapter->auths->head;
1960         while (l != NULL) {
1961                 struct service_auth *auth = l->data;
1962                 GList *next = g_list_next(l);
1963
1964                 if (auth->device != dev) {
1965                         l = next;
1966                         continue;
1967                 }
1968
1969                 g_queue_delete_link(adapter->auths, l);
1970                 l = next;
1971
1972                 service_auth_cancel(auth);
1973         }
1974
1975         device_remove(dev, TRUE);
1976 }
1977
1978 struct btd_device *btd_adapter_get_device(struct btd_adapter *adapter,
1979                                         const bdaddr_t *addr,
1980                                         uint8_t addr_type)
1981 {
1982         struct btd_device *device;
1983
1984         if (!adapter)
1985                 return NULL;
1986
1987 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1988         if (!bacmp(addr, BDADDR_ANY))
1989                 return NULL;
1990 #endif
1991
1992         device = btd_adapter_find_device(adapter, addr, addr_type);
1993         if (device)
1994                 return device;
1995
1996         return adapter_create_device(adapter, addr, addr_type);
1997 }
1998
1999 struct btd_device *btd_adapter_find_device_by_fd(int fd)
2000 {
2001         bdaddr_t src, dst;
2002         uint8_t dst_type;
2003         GIOChannel *io = NULL;
2004         GError *gerr = NULL;
2005         struct btd_adapter *adapter;
2006
2007         io = g_io_channel_unix_new(fd);
2008         if (!io)
2009                 return NULL;
2010
2011         bt_io_get(io, &gerr,
2012                         BT_IO_OPT_SOURCE_BDADDR, &src,
2013                         BT_IO_OPT_DEST_BDADDR, &dst,
2014                         BT_IO_OPT_DEST_TYPE, &dst_type,
2015                         BT_IO_OPT_INVALID);
2016         if (gerr) {
2017                 error("bt_io_get: %s", gerr->message);
2018                 g_error_free(gerr);
2019                 g_io_channel_unref(io);
2020                 return NULL;
2021         }
2022
2023         g_io_channel_unref(io);
2024
2025         adapter = adapter_find(&src);
2026         if (!adapter)
2027                 return NULL;
2028
2029         return btd_adapter_find_device(adapter, &dst, dst_type);
2030 }
2031
2032 sdp_list_t *btd_adapter_get_services(struct btd_adapter *adapter)
2033 {
2034         return adapter->services;
2035 }
2036
2037 static void passive_scanning_complete(uint8_t status, uint16_t length,
2038                                         const void *param, void *user_data)
2039 {
2040         struct btd_adapter *adapter = user_data;
2041         const struct mgmt_cp_start_discovery *rp = param;
2042
2043         DBG("status 0x%02x", status);
2044
2045         if (length < sizeof(*rp)) {
2046                 btd_error(adapter->dev_id,
2047                         "Wrong size of start scanning return parameters");
2048                 return;
2049         }
2050
2051         if (status == MGMT_STATUS_SUCCESS) {
2052                 adapter->discovery_type = rp->type;
2053                 adapter->discovery_enable = 0x01;
2054         }
2055 }
2056
2057 static bool passive_scanning_timeout(gpointer user_data)
2058 {
2059         struct btd_adapter *adapter = user_data;
2060         struct mgmt_cp_start_discovery cp;
2061
2062         adapter->passive_scan_timeout = 0;
2063
2064         cp.type = SCAN_TYPE_LE;
2065 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2066         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2067                                 adapter->dev_id, sizeof(cp), &cp,
2068                                 passive_scanning_complete, adapter, NULL);
2069 #else
2070         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2071                                 adapter->dev_id, sizeof(cp), &cp,
2072                                 passive_scanning_complete, adapter, NULL);
2073 #endif
2074         return FALSE;
2075 }
2076
2077 static void trigger_passive_scanning(struct btd_adapter *adapter)
2078 {
2079         if (!(adapter->current_settings & MGMT_SETTING_LE))
2080                 return;
2081
2082         DBG("");
2083
2084         if (adapter->passive_scan_timeout > 0) {
2085                 timeout_remove(adapter->passive_scan_timeout);
2086                 adapter->passive_scan_timeout = 0;
2087         }
2088
2089         /*
2090          * When the kernel background scanning is available, there is
2091          * no need to start any discovery. The kernel will keep scanning
2092          * as long as devices are in its auto-connection list.
2093          */
2094         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
2095                 return;
2096
2097         /*
2098          * If any client is running a discovery right now, then do not
2099          * even try to start passive scanning.
2100          *
2101          * The discovery procedure is using interleaved scanning and
2102          * thus will discover Low Energy devices as well.
2103          */
2104 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2105         if (adapter->discovery_list || adapter->le_discovery_list)
2106                 return;
2107 #else
2108         if (adapter->discovery_list)
2109                 return;
2110 #endif
2111
2112         if (adapter->discovery_enable == 0x01)
2113                 return;
2114
2115         /*
2116          * In case the discovery is suspended (for example for an ongoing
2117          * pairing attempt), then also do not start passive scanning.
2118          */
2119         if (adapter->discovery_suspended)
2120                 return;
2121
2122         /*
2123          * If the list of connectable Low Energy devices is empty,
2124          * then do not start passive scanning.
2125          */
2126         if (!adapter->connect_list)
2127                 return;
2128
2129         adapter->passive_scan_timeout = timeout_add_seconds(CONN_SCAN_TIMEOUT,
2130                                         passive_scanning_timeout, adapter,
2131                                         NULL);
2132 }
2133
2134 static void stop_passive_scanning_complete(uint8_t status, uint16_t length,
2135                                         const void *param, void *user_data)
2136 {
2137         struct btd_adapter *adapter = user_data;
2138         struct btd_device *dev;
2139         int err;
2140
2141         DBG("status 0x%02x (%s)", status, mgmt_errstr(status));
2142
2143         dev = adapter->connect_le;
2144         adapter->connect_le = NULL;
2145
2146         /*
2147          * When the kernel background scanning is available, there is
2148          * no need to stop any discovery. The kernel will handle the
2149          * auto-connection by itself.
2150          */
2151         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
2152                 return;
2153
2154         /*
2155          * MGMT_STATUS_REJECTED may be returned from kernel because the passive
2156          * scan timer had expired in kernel and passive scan was disabled just
2157          * around the time we called stop_passive_scanning().
2158          */
2159         if (status != MGMT_STATUS_SUCCESS && status != MGMT_STATUS_REJECTED) {
2160                 btd_error(adapter->dev_id, "Stopping passive scanning failed: %s",
2161                                                         mgmt_errstr(status));
2162                 return;
2163         }
2164
2165         adapter->discovery_type = 0x00;
2166         adapter->discovery_enable = 0x00;
2167
2168         if (!dev) {
2169                 DBG("Device removed while stopping passive scanning");
2170                 trigger_passive_scanning(adapter);
2171                 return;
2172         }
2173
2174         err = device_connect_le(dev);
2175         if (err < 0) {
2176                 btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
2177                                                         strerror(-err), -err);
2178                 trigger_passive_scanning(adapter);
2179         }
2180 }
2181
2182 static void stop_passive_scanning(struct btd_adapter *adapter)
2183 {
2184         struct mgmt_cp_stop_discovery cp;
2185 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2186         struct mgmt_cp_stop_discovery le_cp;
2187 #endif
2188
2189         DBG("");
2190
2191         /* If there are any normal discovery clients passive scanning
2192          * wont be running */
2193 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2194         if (adapter->discovery_list || adapter->le_discovery_list)
2195                 return;
2196 #else
2197         if (adapter->discovery_list)
2198                 return;
2199 #endif
2200
2201         if (adapter->discovery_enable == 0x00)
2202                 return;
2203
2204 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2205         if ((adapter->discovery_type & 0x01) > 0) {
2206                 cp.type = 0x01;
2207                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2208                                 adapter->dev_id, sizeof(cp), &cp,
2209                                 stop_passive_scanning_complete, adapter, NULL);
2210         }
2211         if ((adapter->discovery_type & 0x06) > 0) {
2212                 le_cp.type = 0x06;
2213                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
2214                                 adapter->dev_id, sizeof(le_cp), &le_cp,
2215                                 stop_passive_scanning_complete, adapter, NULL);
2216         }
2217 #else
2218         cp.type = adapter->discovery_type;
2219
2220         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2221                         adapter->dev_id, sizeof(cp), &cp,
2222                         stop_passive_scanning_complete, adapter, NULL);
2223 #endif
2224 }
2225
2226 static void cancel_passive_scanning(struct btd_adapter *adapter)
2227 {
2228         if (!(adapter->current_settings & MGMT_SETTING_LE))
2229                 return;
2230
2231         DBG("");
2232
2233         if (adapter->passive_scan_timeout > 0) {
2234                 timeout_remove(adapter->passive_scan_timeout);
2235                 adapter->passive_scan_timeout = 0;
2236         }
2237 }
2238
2239 static uint8_t get_scan_type(struct btd_adapter *adapter)
2240 {
2241         uint8_t type;
2242
2243         if (adapter->current_settings & MGMT_SETTING_BREDR)
2244                 type = SCAN_TYPE_BREDR;
2245         else
2246                 type = 0;
2247
2248         if (adapter->current_settings & MGMT_SETTING_LE)
2249                 type |= SCAN_TYPE_LE;
2250
2251         return type;
2252 }
2253
2254 static void free_discovery_filter(struct discovery_filter *discovery_filter)
2255 {
2256         if (!discovery_filter)
2257                 return;
2258
2259         g_slist_free_full(discovery_filter->uuids, free);
2260         free(discovery_filter->pattern);
2261         g_free(discovery_filter);
2262 }
2263
2264 static void invalidate_rssi_and_tx_power(gpointer a)
2265 {
2266         struct btd_device *dev = a;
2267
2268         device_set_rssi(dev, 0);
2269         device_set_tx_power(dev, 127);
2270 }
2271
2272 static void discovery_cleanup(struct btd_adapter *adapter, int timeout)
2273 {
2274         GSList *l, *next;
2275
2276         adapter->discovery_type = 0x00;
2277
2278         if (adapter->discovery_idle_timeout > 0) {
2279                 timeout_remove(adapter->discovery_idle_timeout);
2280                 adapter->discovery_idle_timeout = 0;
2281         }
2282
2283         g_slist_free_full(adapter->discovery_found,
2284                                                 invalidate_rssi_and_tx_power);
2285         adapter->discovery_found = NULL;
2286
2287         if (!adapter->devices)
2288                 return;
2289
2290         for (l = adapter->devices; l != NULL; l = next) {
2291                 struct btd_device *dev = l->data;
2292
2293                 next = g_slist_next(l);
2294
2295 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2296         if (device_is_temporary(dev) && !device_is_connectable(dev)
2297                 && !btd_device_is_connected(dev))
2298 #else
2299         if (device_is_temporary(dev) && !device_is_connectable(dev))
2300 #endif
2301                 btd_adapter_remove_device(adapter, dev);
2302
2303         }
2304 }
2305
2306 static void discovery_free(void *user_data)
2307 {
2308         struct discovery_client *client = user_data;
2309         struct btd_adapter *adapter = client->adapter;
2310
2311 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2312         DBG("%p", client);
2313 #endif
2314         if (client->watch)
2315                 g_dbus_remove_watch(dbus_conn, client->watch);
2316
2317         if (client->discovery_filter) {
2318                 free_discovery_filter(client->discovery_filter);
2319                 client->discovery_filter = NULL;
2320         }
2321
2322         if (client->msg) {
2323                 if (client == adapter->client) {
2324                         g_dbus_send_message(dbus_conn,
2325                                                 btd_error_busy(client->msg));
2326                         adapter->client = NULL;
2327                 }
2328                 dbus_message_unref(client->msg);
2329         }
2330
2331         g_free(client->owner);
2332         g_free(client);
2333 }
2334
2335 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2336 static void discovery_remove(struct discovery_client *client, bool exit)
2337 #else
2338 static void discovery_remove(struct discovery_client *client)
2339 #endif
2340
2341 {
2342         struct btd_adapter *adapter = client->adapter;
2343
2344         DBG("owner %s", client->owner);
2345
2346         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2347                                                                 client);
2348
2349         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2350                                                                 client);
2351
2352 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2353         if (!exit && client->discovery_filter)
2354 #else
2355         if (adapter->client == client)
2356                 adapter->client = NULL;
2357
2358         if (client->watch && client->discovery_filter)
2359 #endif
2360                 adapter->set_filter_list = g_slist_prepend(
2361                                         adapter->set_filter_list, client);
2362         else
2363                 discovery_free(client);
2364
2365         /*
2366          * If there are other client discoveries in progress, then leave
2367          * it active. If not, then make sure to stop the restart timeout.
2368          */
2369         if (adapter->discovery_list)
2370                 return;
2371
2372         discovery_cleanup(adapter, TEMP_DEV_TIMEOUT);
2373 }
2374
2375 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay);
2376
2377 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2378 static void discovery_reply(struct discovery_client *client, uint8_t status)
2379 #else
2380 static struct discovery_client *discovery_complete(struct btd_adapter *adapter,
2381                                                 uint8_t status)
2382 #endif
2383 {
2384 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2385         struct discovery_client *client = adapter->client;
2386 #endif
2387         DBusMessage *reply;
2388 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2389
2390         if (!client)
2391                 return NULL;
2392
2393         adapter->client = NULL;
2394 #endif
2395
2396         if (!client->msg)
2397 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2398                 return;
2399 #else
2400                 return client;
2401 #endif
2402         if (!status) {
2403                 g_dbus_send_reply(dbus_conn, client->msg, DBUS_TYPE_INVALID);
2404         } else  {
2405                 reply = btd_error_busy(client->msg);
2406                 g_dbus_send_message(dbus_conn, reply);
2407         }
2408
2409         dbus_message_unref(client->msg);
2410         client->msg = NULL;
2411 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2412         return client;
2413 #endif
2414 }
2415
2416 static void start_discovery_complete(uint8_t status, uint16_t length,
2417                                         const void *param, void *user_data)
2418 {
2419         struct btd_adapter *adapter = user_data;
2420         struct discovery_client *client;
2421         const struct mgmt_cp_start_discovery *rp = param;
2422
2423         DBG("status 0x%02x", status);
2424
2425         /* Is there are no clients the discovery must have been stopped while
2426          * discovery command was pending.
2427          */
2428         if (!adapter->discovery_list) {
2429                 struct mgmt_cp_stop_discovery cp;
2430
2431                 if (status != MGMT_STATUS_SUCCESS)
2432                         return;
2433
2434                 /* Stop discovering as there are no clients left */
2435                 cp.type = rp->type;
2436                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2437                                         adapter->dev_id, sizeof(cp), &cp,
2438                                         NULL, NULL, NULL);
2439                 return;
2440         }
2441
2442         client = adapter->discovery_list->data;
2443
2444         if (length < sizeof(*rp)) {
2445                 btd_error(adapter->dev_id,
2446                         "Wrong size of start discovery return parameters");
2447                 if (client->msg)
2448                         goto fail;
2449                 return;
2450         }
2451
2452         if (status == MGMT_STATUS_SUCCESS) {
2453 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2454                 DBG("Return param discovery type 0x%02x", rp->type);
2455                 adapter->discovery_type |= rp->type;
2456 #else
2457                 adapter->discovery_type = rp->type;
2458 #endif
2459                 adapter->discovery_enable = 0x01;
2460
2461                 if (adapter->current_discovery_filter)
2462                         adapter->filtered_discovery = true;
2463                 else
2464                         adapter->filtered_discovery = false;
2465
2466 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2467                 discovery_reply(client, status);
2468 #else
2469                 discovery_complete(adapter, status);
2470 #endif
2471                 if (adapter->discovering)
2472                         return;
2473
2474                 adapter->discovering = true;
2475                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2476                                         ADAPTER_INTERFACE, "Discovering");
2477                 return;
2478 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2479         } else {
2480                 adapter->discovering = false;
2481                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2482                                         ADAPTER_INTERFACE, "Discovering");
2483 #endif
2484         }
2485
2486 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2487 fail:
2488         /* Reply with an error if the first discovery has failed */
2489         if (client->msg) {
2490                 discovery_reply(client, status);
2491                 discovery_remove(client, false);
2492 #else
2493         client = discovery_complete(adapter, status);
2494         if (client) {
2495                 discovery_remove(client);
2496 #endif
2497                 return;
2498         }
2499
2500         /*
2501          * In case the restart of the discovery failed, then just trigger
2502          * it for the next idle timeout again.
2503          */
2504 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2505         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
2506 #endif
2507 }
2508
2509 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2510 static void start_le_discovery_complete(uint8_t status, uint16_t length,
2511                                         const void *param, void *user_data)
2512 {
2513         struct btd_adapter *adapter = user_data;
2514         const struct mgmt_cp_start_discovery *rp = param;
2515
2516         if (!rp) {
2517                 error("Error ocurred in LEDiscovering, rp is NULL");
2518                 return;
2519         }
2520
2521         DBG("status 0x%02x", status);
2522         if (length < sizeof(*rp)) {
2523                 error("Wrong size of start discovery return parameters");
2524                 return;
2525         }
2526
2527         DBG("Discovery Type 0x%02x", rp->type);
2528         if (status == MGMT_STATUS_SUCCESS) {
2529                 adapter->discovery_type |= rp->type;
2530                 adapter->discovery_enable = 0x01;
2531
2532                 if (adapter->le_discovering)
2533                         return;
2534
2535                 adapter->le_discovering = true;
2536                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2537                                         ADAPTER_INTERFACE, "LEDiscovering");
2538
2539                 return;
2540         } else {
2541                 adapter->le_discovering = false;
2542                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2543                                         ADAPTER_INTERFACE, "LEDiscovering");
2544
2545         }
2546 }
2547 #endif
2548
2549 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2550 static bool start_le_discovery_timeout(gpointer user_data)
2551 {
2552         struct btd_adapter *adapter = user_data;
2553         uint8_t new_type;
2554
2555         DBG("");
2556
2557         adapter->le_discovery_idle_timeout = 0;
2558
2559         new_type = SCAN_TYPE_LE;
2560
2561         if (adapter->discovery_enable == 0x01) {
2562                 /*
2563                  * If there is an already running discovery and it has the
2564                  * same type, then just keep it.
2565                  */
2566
2567                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_LE) {
2568                         if (adapter->le_discovering)
2569                                 return FALSE;
2570
2571                         adapter->le_discovering = true;
2572                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2573                                         ADAPTER_INTERFACE, "LEDiscovering");
2574
2575                         return FALSE;
2576                 }
2577         }
2578
2579         struct mgmt_cp_start_discovery cp;
2580
2581         cp.type = new_type;
2582         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2583                         adapter->dev_id, sizeof(cp), &cp,
2584                         start_le_discovery_complete, adapter, NULL);
2585
2586         return FALSE;
2587 }
2588 #endif
2589
2590 static bool start_discovery_timeout(gpointer user_data)
2591 {
2592         struct btd_adapter *adapter = user_data;
2593 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2594         struct mgmt_cp_start_service_discovery *sd_cp;
2595 #endif
2596         uint8_t new_type;
2597
2598         DBG("");
2599
2600         adapter->discovery_idle_timeout = 0;
2601
2602 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2603         new_type = SCAN_TYPE_BREDR;
2604
2605         if (adapter->discovery_enable == 0x01) {
2606                 /*
2607                  * If there is an already running discovery and it has the
2608                  * same type, then just keep it.
2609                  */
2610                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_BREDR) {
2611                         if (adapter->discovering)
2612                                 return FALSE;
2613
2614                         adapter->discovering = true;
2615                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2616                                         ADAPTER_INTERFACE, "Discovering");
2617
2618                         return FALSE;
2619                 }
2620         }
2621
2622         struct mgmt_cp_start_discovery cp;
2623         cp.type = new_type;
2624         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2625                                         adapter->dev_id, sizeof(cp), &cp,
2626                                         start_discovery_complete, adapter,
2627                                         NULL);
2628
2629
2630 #else
2631         /* If we're doing filtered discovery, it must be quickly restarted */
2632         adapter->no_scan_restart_delay = !!adapter->current_discovery_filter;
2633
2634         DBG("adapter->current_discovery_filter == %d",
2635             !!adapter->current_discovery_filter);
2636
2637         new_type = get_scan_type(adapter);
2638
2639         if (adapter->discovery_enable == 0x01) {
2640                 struct mgmt_cp_stop_discovery cp;
2641
2642                 /*
2643                  * If we're asked to start regular discovery, and there is an
2644                  * already running regular discovery and it has the same type,
2645                  * then just keep it.
2646                  */
2647                 if (!adapter->current_discovery_filter &&
2648                     !adapter->filtered_discovery &&
2649                     adapter->discovery_type == new_type) {
2650                         if (adapter->discovering)
2651                                 return FALSE;
2652
2653                         adapter->discovering = true;
2654                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2655                                         ADAPTER_INTERFACE, "Discovering");
2656                         return FALSE;
2657                 }
2658
2659                 /*
2660                  * Otherwise the current discovery must be stopped. So
2661                  * queue up a stop discovery command.
2662                  *
2663                  * This can happen if a passive scanning for Low Energy
2664                  * devices is ongoing, or scan type is changed between
2665                  * regular and filtered, or filter was updated.
2666                  */
2667                 cp.type = adapter->discovery_type;
2668                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2669                                         adapter->dev_id, sizeof(cp), &cp,
2670                                         NULL, NULL, NULL);
2671
2672                 /* Don't even bother to try to quickly start discovery
2673                  * just after stopping it, it would fail with status
2674                  * MGMT_BUSY. Instead discovering_callback will take
2675                  * care of that.
2676                  */
2677                 return FALSE;
2678
2679         }
2680
2681         /* Regular discovery is required */
2682         if (!adapter->current_discovery_filter) {
2683                 struct mgmt_cp_start_discovery cp;
2684
2685                 cp.type = new_type;
2686                 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2687                                         adapter->dev_id, sizeof(cp), &cp,
2688                                         start_discovery_complete, adapter,
2689                                         NULL);
2690
2691                 return FALSE;
2692         }
2693
2694         /* Filtered discovery is required */
2695         sd_cp = adapter->current_discovery_filter;
2696
2697         DBG("sending MGMT_OP_START_SERVICE_DISCOVERY %d, %d, %d",
2698                                 sd_cp->rssi, sd_cp->type,
2699                                 btohs(sd_cp->uuid_count));
2700
2701         mgmt_send(adapter->mgmt, MGMT_OP_START_SERVICE_DISCOVERY,
2702                   adapter->dev_id, sizeof(*sd_cp) +
2703                   btohs(sd_cp->uuid_count) * 16,
2704                   sd_cp, start_discovery_complete, adapter, NULL);
2705
2706 #endif
2707
2708         return FALSE;
2709 }
2710
2711 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2712 static void trigger_start_le_discovery(struct btd_adapter *adapter, guint delay)
2713 {
2714
2715         DBG("");
2716
2717         cancel_passive_scanning(adapter);
2718
2719         if (adapter->le_discovery_idle_timeout > 0) {
2720                 g_source_remove(adapter->le_discovery_idle_timeout);
2721                 adapter->le_discovery_idle_timeout = 0;
2722         }
2723
2724         /*
2725          * If the controller got powered down in between, then ensure
2726          * that we do not keep trying to restart discovery.
2727          *
2728          * This is safe-guard and should actually never trigger.
2729          */
2730         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2731                 return;
2732
2733         adapter->le_discovery_idle_timeout = timeout_add_seconds(delay,
2734                                         start_le_discovery_timeout, adapter, NULL);
2735 }
2736 #endif
2737
2738 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
2739 {
2740
2741         DBG("");
2742
2743         cancel_passive_scanning(adapter);
2744
2745         if (adapter->discovery_idle_timeout > 0) {
2746                 timeout_remove(adapter->discovery_idle_timeout);
2747                 adapter->discovery_idle_timeout = 0;
2748         }
2749
2750         /*
2751          * If the controller got powered down in between, then ensure
2752          * that we do not keep trying to restart discovery.
2753          *
2754          * This is safe-guard and should actually never trigger.
2755          */
2756         if (!btd_adapter_get_powered(adapter))
2757                 return;
2758
2759         adapter->discovery_idle_timeout = timeout_add_seconds(delay,
2760                                         start_discovery_timeout, adapter, NULL);
2761 }
2762
2763 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2764 static void suspend_discovery_complete(uint8_t status, uint16_t length,
2765                                         const void *param, void *user_data)
2766 {
2767         struct btd_adapter *adapter = user_data;
2768
2769         DBG("status 0x%02x", status);
2770
2771         if (status == MGMT_STATUS_SUCCESS) {
2772                 adapter->discovery_type = 0x00;
2773                 adapter->discovery_enable = 0x00;
2774                 return;
2775         }
2776 }
2777
2778 static void suspend_discovery(struct btd_adapter *adapter)
2779 {
2780         struct mgmt_cp_stop_discovery cp;
2781
2782         DBG("");
2783
2784         adapter->discovery_suspended = true;
2785
2786         /*
2787          * If there are no clients discovering right now, then there is
2788          * also nothing to suspend.
2789          */
2790         if (!adapter->discovery_list)
2791                 return;
2792
2793         /*
2794          * In case of being inside the idle phase, make sure to remove
2795          * the timeout to not trigger a restart.
2796          *
2797          * The restart will be triggered when the discovery is resumed.
2798          */
2799         if (adapter->discovery_idle_timeout > 0) {
2800                 timeout_remove(adapter->discovery_idle_timeout);
2801                 adapter->discovery_idle_timeout = 0;
2802         }
2803
2804         if (adapter->discovery_enable == 0x00)
2805                 return;
2806
2807         cp.type = adapter->discovery_type;
2808
2809         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2810                                 adapter->dev_id, sizeof(cp), &cp,
2811                                 suspend_discovery_complete, adapter, NULL);
2812 }
2813
2814 static void resume_discovery(struct btd_adapter *adapter)
2815 {
2816         DBG("");
2817
2818         adapter->discovery_suspended = false;
2819
2820         /*
2821          * If there are no clients discovering right now, then there is
2822          * also nothing to resume.
2823          */
2824         if (!adapter->discovery_list)
2825                 return;
2826
2827         /*
2828          * Treat a suspended discovery session the same as extra long
2829          * idle time for a normal discovery. So just trigger the default
2830          * restart procedure.
2831          */
2832         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2833 }
2834 #endif
2835
2836 static void discovering_callback(uint16_t index, uint16_t length,
2837                                         const void *param, void *user_data)
2838 {
2839         const struct mgmt_ev_discovering *ev = param;
2840         struct btd_adapter *adapter = user_data;
2841
2842         if (length < sizeof(*ev)) {
2843                 btd_error(adapter->dev_id, "Too small discovering event");
2844                 return;
2845         }
2846
2847         DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
2848                                 ev->discovering, adapter->filtered_discovery);
2849
2850 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2851         DBG("info discov_type %d", adapter->discovery_type);
2852         if (ev->type == SCAN_TYPE_BREDR) {
2853                 if (ev->discovering == FALSE) {
2854                         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
2855                         adapter->discovering = false;
2856                 } else {
2857                         hci_set_bit(BDADDR_BREDR, &adapter->discovery_type);
2858                         adapter->discovering = true;
2859                 }
2860                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2861                                         ADAPTER_INTERFACE, "Discovering");
2862
2863         } else if (ev->type == SCAN_TYPE_LE) {
2864                 if (ev->discovering == FALSE) {
2865                         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2866                         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2867
2868                         if (adapter->le_discovering == true) {
2869                                 if (adapter->le_discovery_list) {
2870                                         struct discovery_client *client;
2871
2872                                         client = adapter->le_discovery_list->data;
2873                                         g_dbus_remove_watch(dbus_conn, client->watch);
2874                                 }
2875
2876                                 adapter->le_discovering = false;
2877                         }
2878                 } else {
2879                         hci_set_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2880                         hci_set_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2881                         adapter->le_discovering = true;
2882                 }
2883
2884                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2885                                         ADAPTER_INTERFACE, "LEDiscovering");
2886         }
2887 #else
2888         if (adapter->discovery_enable == ev->discovering)
2889                 return;
2890
2891         adapter->discovery_type = ev->type;
2892         adapter->discovery_enable = ev->discovering;
2893 #endif
2894
2895         /*
2896          * Check for existing discoveries triggered by client applications
2897          * and ignore all others.
2898          *
2899          * If there are no clients, then it is good idea to trigger a
2900          * passive scanning attempt.
2901          */
2902 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2903         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2904                 if (!adapter->connect_le)
2905                         trigger_passive_scanning(adapter);
2906                 return;
2907         }
2908 #else
2909         if (!adapter->discovery_list) {
2910                 if (!adapter->connect_le)
2911                         trigger_passive_scanning(adapter);
2912                 return;
2913         }
2914 #endif
2915
2916         if (adapter->discovery_suspended)
2917                 return;
2918
2919         switch (adapter->discovery_enable) {
2920         case 0x00:
2921                 if (adapter->no_scan_restart_delay)
2922                         trigger_start_discovery(adapter, 0);
2923                 else
2924                         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2925                 break;
2926
2927         case 0x01:
2928                 if (adapter->discovery_idle_timeout > 0) {
2929                         timeout_remove(adapter->discovery_idle_timeout);
2930                         adapter->discovery_idle_timeout = 0;
2931                 }
2932
2933                 break;
2934         }
2935 }
2936
2937 static bool set_discovery_discoverable(struct btd_adapter *adapter, bool enable)
2938 {
2939         if (adapter->discovery_discoverable == enable)
2940                 return true;
2941
2942         /* Reset discoverable filter if already set */
2943         if (enable && (adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
2944                 return true;
2945
2946         adapter->discovery_discoverable = enable;
2947
2948         return set_discoverable(adapter, enable, 0);
2949 }
2950
2951 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2952 static void stop_discovery_complete(uint8_t status, uint16_t length,
2953                                         const void *param, void *user_data)
2954 {
2955         struct discovery_client *client = user_data;
2956         struct btd_adapter *adapter = client->adapter;
2957         DBusMessage *reply;
2958
2959         DBG("status 0x%02x", status);
2960
2961         if (status != MGMT_STATUS_SUCCESS) {
2962                 if (client->msg) {
2963                         reply = btd_error_busy(client->msg);
2964                         g_dbus_send_message(dbus_conn, reply);
2965                 }
2966
2967                 goto done;
2968         }
2969
2970         if (client->msg) {
2971                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2972                 g_dbus_send_message(dbus_conn, reply);
2973         }
2974
2975         adapter->discovery_type &= (~0x01);
2976         DBG("Discovery Type 0x%02x", adapter->discovery_type);
2977
2978         adapter->filtered_discovery = false;
2979         adapter->no_scan_restart_delay = false;
2980         adapter->discovering = false;
2981         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2982                         ADAPTER_INTERFACE, "Discovering");
2983
2984         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2985                 adapter->discovery_enable = 0x00;
2986                 trigger_passive_scanning(adapter);
2987         }
2988
2989 done:
2990         discovery_remove(client, false);
2991 }
2992
2993 static void stop_le_discovery_complete(uint8_t status, uint16_t length,
2994                                         const void *param, void *user_data)
2995 {
2996         struct btd_adapter *adapter = user_data;
2997         struct discovery_client *client;
2998         DBusMessage *reply;
2999
3000         DBG("status 0x%02x", status);
3001
3002         /* Is there are no clients the discovery must have been stopped while
3003           * discovery command was pending.
3004           */
3005         if (!adapter->le_discovery_list)
3006                 return;
3007
3008         client = adapter->le_discovery_list->data;
3009
3010         if (status != MGMT_STATUS_SUCCESS) {
3011                 if (client->msg) {
3012                         reply = btd_error_busy(client->msg);
3013                         g_dbus_send_message(dbus_conn, reply);
3014                 }
3015
3016                 goto done;
3017         }
3018
3019         if (client->msg) {
3020                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
3021                 g_dbus_send_message(dbus_conn, reply);
3022         }
3023
3024         adapter->discovery_type &= (~0x06);
3025         DBG("Discovery Type 0x%02x", adapter->discovery_type);
3026
3027         adapter->filtered_discovery = false;
3028         adapter->no_scan_restart_delay = false;
3029         adapter->le_discovering = false;
3030         g_dbus_emit_property_changed(dbus_conn, adapter->path,
3031                         ADAPTER_INTERFACE, "LEDiscovering");
3032
3033         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
3034                 adapter->discovery_enable = 0x00;
3035                 trigger_passive_scanning(adapter);
3036         }
3037
3038 done:
3039         /*
3040          * The destroy function will cleanup the client information and
3041          * also remove it from the list of discovery clients.
3042          */
3043         g_dbus_remove_watch(dbus_conn, client->watch);
3044 }
3045 #else
3046
3047 static void stop_discovery_complete(uint8_t status, uint16_t length,
3048                                         const void *param, void *user_data)
3049 {
3050         struct btd_adapter *adapter = user_data;
3051         struct discovery_client *client;
3052
3053         DBG("status 0x%02x", status);
3054
3055         client = discovery_complete(adapter, status);
3056         if (client)
3057                 discovery_remove(client);
3058
3059         if (status != MGMT_STATUS_SUCCESS)
3060                 return;
3061
3062         adapter->discovery_type = 0x00;
3063         adapter->discovery_enable = 0x00;
3064         adapter->filtered_discovery = false;
3065         adapter->no_scan_restart_delay = false;
3066         adapter->discovering = false;
3067         g_dbus_emit_property_changed(dbus_conn, adapter->path,
3068                                         ADAPTER_INTERFACE, "Discovering");
3069
3070         trigger_passive_scanning(adapter);
3071 }
3072 #endif
3073
3074 static int compare_sender(gconstpointer a, gconstpointer b)
3075 {
3076         const struct discovery_client *client = a;
3077         const char *sender = b;
3078
3079         return g_strcmp0(client->owner, sender);
3080 }
3081
3082 static gint g_strcmp(gconstpointer a, gconstpointer b)
3083 {
3084         return strcmp(a, b);
3085 }
3086
3087 static void extract_unique_uuids(gpointer data, gpointer user_data)
3088 {
3089         char *uuid_str = data;
3090         GSList **uuids = user_data;
3091
3092         if (!g_slist_find_custom(*uuids, uuid_str, g_strcmp))
3093                 *uuids = g_slist_insert_sorted(*uuids, uuid_str, g_strcmp);
3094 }
3095
3096 /*
3097  * This method merges all adapter filters into rssi, transport and uuids.
3098  * Returns 1 if there was no filtered scan, 0 otherwise.
3099  */
3100 static int merge_discovery_filters(struct btd_adapter *adapter, int *rssi,
3101                                         uint8_t *transport, GSList **uuids)
3102 {
3103         GSList *l;
3104         bool empty_uuid = false;
3105         bool has_regular_discovery = false;
3106         bool has_filtered_discovery = false;
3107         uint8_t adapter_scan_type = get_scan_type(adapter);
3108
3109         for (l = adapter->discovery_list; l != NULL; l = g_slist_next(l)) {
3110                 struct discovery_client *client = l->data;
3111                 struct discovery_filter *item = client->discovery_filter;
3112
3113                 if (!item) {
3114                         has_regular_discovery = true;
3115                         continue;
3116                 }
3117
3118                 /*
3119                  * Detect empty filter with only discoverable
3120                  * (which does not require a kernel filter) set.
3121                  */
3122                 if (item->uuids == NULL &&
3123                     item->pathloss == DISTANCE_VAL_INVALID &&
3124                     item->rssi == DISTANCE_VAL_INVALID &&
3125                     item->type == adapter_scan_type &&
3126                     item->duplicate == false &&
3127                     item->pattern == NULL) {
3128                         has_regular_discovery = true;
3129                         continue;
3130                 }
3131
3132                 has_filtered_discovery = true;
3133
3134                 *transport |= item->type;
3135
3136                 /*
3137                  * Rule for merging rssi and pathloss into rssi field of kernel
3138                  * filter is as follow:
3139                  * - if there's any client without proximity filter, then do no
3140                  *   proximity filtering,
3141                  * - if all clients specified RSSI, then use lowest value,
3142                  * - if any client specified pathloss, then kernel filter should
3143                  *   do no proximity, as kernel can't compute pathloss. We'll do
3144                  *   filtering on our own.
3145                  */
3146                 if (item->rssi == DISTANCE_VAL_INVALID)
3147                         *rssi = HCI_RSSI_INVALID;
3148                 else if (*rssi != HCI_RSSI_INVALID && *rssi >= item->rssi)
3149                         *rssi = item->rssi;
3150                 else if (item->pathloss != DISTANCE_VAL_INVALID)
3151                         *rssi = HCI_RSSI_INVALID;
3152
3153                 if (!g_slist_length(item->uuids))
3154                         empty_uuid = true;
3155
3156                 g_slist_foreach(item->uuids, extract_unique_uuids, uuids);
3157         }
3158
3159         /* If no proximity filtering is set, disable it */
3160         if (*rssi == DISTANCE_VAL_INVALID)
3161                 *rssi = HCI_RSSI_INVALID;
3162
3163         /*
3164          * Empty_uuid variable determines wether there was any filter with no
3165          * uuids. In this case someone might be looking for all devices in
3166          * certain proximity, and we need to have empty uuids in kernel filter.
3167          */
3168         if (empty_uuid) {
3169                 g_slist_free(*uuids);
3170                 *uuids = NULL;
3171         }
3172
3173         if (has_regular_discovery) {
3174                 if (!has_filtered_discovery)
3175                         return 1;
3176
3177                 /*
3178                  * It there is both regular and filtered scan running, then
3179                  * clear whole fitler to report all devices.
3180                  */
3181                 *transport = adapter_scan_type;
3182                 *rssi = HCI_RSSI_INVALID;
3183                 g_slist_free(*uuids);
3184                 *uuids = NULL;
3185         }
3186
3187         return 0;
3188 }
3189
3190 static void populate_mgmt_filter_uuids(uint8_t (*mgmt_uuids)[16], GSList *uuids)
3191 {
3192         GSList *l;
3193
3194         for (l = uuids; l != NULL; l = g_slist_next(l)) {
3195                 bt_uuid_t uuid, u128;
3196                 uint128_t uint128;
3197
3198                 bt_string_to_uuid(&uuid, l->data);
3199                 bt_uuid_to_uuid128(&uuid, &u128);
3200
3201                 ntoh128((uint128_t *) u128.value.u128.data, &uint128);
3202                 htob128(&uint128, (uint128_t *) mgmt_uuids);
3203
3204                 mgmt_uuids++;
3205         }
3206 }
3207
3208 /*
3209  * This method merges all adapter filters into one that will be send to kernel.
3210  * cp_ptr is set to null when regular non-filtered discovery is needed,
3211  * otherwise it's pointing to filter. Returns 0 on succes, -1 on error
3212  */
3213 static int discovery_filter_to_mgmt_cp(struct btd_adapter *adapter,
3214                        struct mgmt_cp_start_service_discovery **cp_ptr)
3215 {
3216         GSList *uuids = NULL;
3217         struct mgmt_cp_start_service_discovery *cp;
3218         int rssi = DISTANCE_VAL_INVALID;
3219         int uuid_count;
3220         uint8_t discovery_type = 0;
3221
3222         DBG("");
3223
3224         if (merge_discovery_filters(adapter, &rssi, &discovery_type, &uuids)) {
3225                 /* There are only regular scans, run just regular scan. */
3226                 *cp_ptr = NULL;
3227                 return 0;
3228         }
3229
3230         uuid_count = g_slist_length(uuids);
3231
3232         cp = g_try_malloc(sizeof(*cp) + 16*uuid_count);
3233         *cp_ptr = cp;
3234         if (!cp) {
3235                 g_slist_free(uuids);
3236                 return -1;
3237         }
3238
3239         cp->type = discovery_type;
3240         cp->rssi = rssi;
3241         cp->uuid_count = htobs(uuid_count);
3242         populate_mgmt_filter_uuids(cp->uuids, uuids);
3243
3244         g_slist_free(uuids);
3245         return 0;
3246 }
3247
3248 static bool filters_equal(struct mgmt_cp_start_service_discovery *a,
3249                    struct mgmt_cp_start_service_discovery *b) {
3250         if (!a && !b)
3251                 return true;
3252
3253         if ((!a && b) || (a && !b))
3254                 return false;
3255
3256         if (a->type != b->type)
3257                 return false;
3258
3259         if (a->rssi != b->rssi)
3260                 return false;
3261
3262         /*
3263          * When we create mgmt_cp_start_service_discovery structure inside
3264          * discovery_filter_to_mgmt_cp, we always keep uuids sorted, and
3265          * unique, so we're safe to compare uuid_count, and uuids like that.
3266          */
3267         if (a->uuid_count != b->uuid_count)
3268                 return false;
3269
3270         if (memcmp(a->uuids, b->uuids, 16 * a->uuid_count) != 0)
3271                 return false;
3272
3273         return true;
3274 }
3275
3276 static int update_discovery_filter(struct btd_adapter *adapter)
3277 {
3278         struct mgmt_cp_start_service_discovery *sd_cp;
3279
3280         DBG("");
3281
3282         if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
3283                 btd_error(adapter->dev_id,
3284                                 "discovery_filter_to_mgmt_cp returned error");
3285                 return -ENOMEM;
3286         }
3287
3288         /* Only attempt to overwrite current discoverable setting when not
3289          * discoverable.
3290          */
3291         if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE)) {
3292                 GSList *l;
3293
3294                 for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
3295                         struct discovery_client *client = l->data;
3296
3297                         if (!client->discovery_filter)
3298                                 continue;
3299
3300                         if (client->discovery_filter->discoverable) {
3301                                 set_discovery_discoverable(adapter, true);
3302                                 break;
3303                         }
3304                 }
3305         }
3306
3307         /*
3308          * If filters are equal, then don't update scan, except for when
3309          * starting discovery.
3310          */
3311         if (filters_equal(adapter->current_discovery_filter, sd_cp) &&
3312             adapter->discovering != 0) {
3313                 DBG("filters were equal, deciding to not restart the scan.");
3314                 g_free(sd_cp);
3315                 return 0;
3316         }
3317
3318         g_free(adapter->current_discovery_filter);
3319         adapter->current_discovery_filter = sd_cp;
3320
3321         trigger_start_discovery(adapter, 0);
3322
3323         return -EINPROGRESS;
3324 }
3325
3326 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3327 static int discovery_stop(struct discovery_client *client, bool exit)
3328 #else
3329 static int discovery_stop(struct discovery_client *client)
3330 #endif
3331 {
3332         struct btd_adapter *adapter = client->adapter;
3333         struct mgmt_cp_stop_discovery cp;
3334
3335         /* Check if there are more client discovering */
3336         if (g_slist_next(adapter->discovery_list)) {
3337 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3338                 discovery_remove(client, exit);
3339 #else
3340                 discovery_remove(client);
3341 #endif
3342                 update_discovery_filter(adapter);
3343                 return 0;
3344         }
3345
3346         set_discovery_discoverable(adapter, false);
3347
3348         /*
3349          * In the idle phase of a discovery, there is no need to stop it
3350          * and so it is enough to send out the signal and just return.
3351          */
3352         if (adapter->discovery_enable == 0x00) {
3353 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3354                 discovery_remove(client, exit);
3355 #else
3356                 discovery_remove(client);
3357 #endif
3358                 adapter->discovering = false;
3359                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3360                                 ADAPTER_INTERFACE, "Discovering");
3361
3362                 trigger_passive_scanning(adapter);
3363
3364                 return 0;
3365         }
3366 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3367         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3368 #endif
3369         cp.type = adapter->discovery_type;
3370 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
3371         adapter->client = client;
3372 #endif
3373 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3374         cp.type = 0x01;
3375 #endif
3376         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
3377                         adapter->dev_id, sizeof(cp), &cp,
3378 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3379                         stop_discovery_complete, client, NULL);
3380 #else
3381                         stop_discovery_complete, adapter, NULL);
3382 #endif
3383
3384         return -EINPROGRESS;
3385 }
3386
3387 static void discovery_destroy(void *user_data)
3388 {
3389         struct discovery_client *client = user_data;
3390         struct btd_adapter *adapter = client->adapter;
3391
3392         DBG("owner %s", client->owner);
3393
3394         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
3395                                                                 client);
3396
3397         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
3398                                                                 client);
3399
3400         if (client->discovery_filter) {
3401                 free_discovery_filter(client->discovery_filter);
3402                 client->discovery_filter = NULL;
3403         }
3404
3405         g_free(client->owner);
3406         g_free(client);
3407
3408         /*
3409          * If there are other client discoveries in progress, then leave
3410          * it active. If not, then make sure to stop the restart timeout.
3411          */
3412         if (adapter->discovery_list)
3413                 return;
3414
3415 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3416         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
3417 #else
3418         adapter->discovery_type = 0x00;
3419 #endif
3420
3421         discovery_cleanup(adapter, 0);
3422
3423 }
3424
3425 static void discovery_disconnect(DBusConnection *conn, void *user_data)
3426 {
3427         struct discovery_client *client = user_data;
3428
3429         DBG("owner %s", client->owner);
3430 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3431         discovery_stop(client, true);
3432 #else
3433         client->watch = 0;
3434
3435         discovery_stop(client);
3436 #endif
3437 }
3438
3439 /*
3440  * Returns true if client was already discovering, false otherwise. *client
3441  * will point to discovering client, or client that have pre-set his filter.
3442  */
3443 static bool get_discovery_client(struct btd_adapter *adapter,
3444                                                 const char *owner,
3445                                                 struct discovery_client **client)
3446 {
3447         GSList *list = g_slist_find_custom(adapter->discovery_list, owner,
3448                                                                 compare_sender);
3449         if (list) {
3450                 *client = list->data;
3451                 return true;
3452         }
3453
3454         list = g_slist_find_custom(adapter->set_filter_list, owner,
3455                                                                 compare_sender);
3456         if (list) {
3457                 *client = list->data;
3458                 return false;
3459         }
3460
3461         *client = NULL;
3462         return false;
3463 }
3464
3465 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3466 static void le_discovery_destroy(void *user_data)
3467 {
3468         struct discovery_client *client = user_data;
3469         struct btd_adapter *adapter = client->adapter;
3470
3471         DBG("owner %s", client->owner);
3472
3473         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3474                                                                 client);
3475
3476         g_free(client->owner);
3477         g_free(client);
3478
3479         /*
3480          * If there are other client discoveries in progress, then leave
3481          * it active. If not, then make sure to stop the restart timeout.
3482          */
3483         DBG("adapter->discovery_list[%p] adapter->le_discovery_list[%p]",
3484                         adapter->discovery_list, adapter->le_discovery_list);
3485         if (adapter->discovery_list || adapter->le_discovery_list)
3486                 return;
3487
3488         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
3489         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
3490
3491         DBG("Restart Timer... adapter->discovery_type[%d]", adapter->discovery_type);
3492         if (adapter->discovery_idle_timeout > 0) {
3493                 g_source_remove(adapter->discovery_idle_timeout);
3494                 adapter->discovery_idle_timeout = 0;
3495         }
3496
3497         discovery_cleanup(adapter, 0);
3498 }
3499
3500 static void le_discovery_disconnect(DBusConnection *conn, void *user_data)
3501 {
3502         struct discovery_client *client = user_data;
3503         struct btd_adapter *adapter = client->adapter;
3504         struct mgmt_cp_stop_le_discovery cp;
3505
3506         DBG("owner %s", client->owner);
3507
3508         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3509                                                                 client);
3510
3511         /*
3512          * There is no need for extra cleanup of the client since that
3513          * will be done by the destroy callback.
3514          *
3515          * However in case this is the last client, the discovery in
3516          * the kernel needs to be disabled.
3517          */
3518         if (adapter->le_discovery_list)
3519                 return;
3520
3521         /*
3522          * In the idle phase of a discovery, there is no need to stop it
3523          * and so it is enough to send out the signal and just return.
3524          */
3525         if (adapter->discovery_enable == 0x00) {
3526                 adapter->le_discovering = false;
3527                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3528                                         ADAPTER_INTERFACE, "LEDiscovering");
3529
3530                 if (adapter->discovering == false  && adapter->le_discovering == false) {
3531                         trigger_passive_scanning(adapter);
3532                         return;
3533                 }
3534         }
3535
3536         cp.type = 0x06;
3537
3538         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
3539                                 adapter->dev_id, sizeof(cp), &cp,
3540                                 stop_le_discovery_complete, adapter, NULL);
3541 }
3542
3543 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
3544 static void addr_filter_params_free(gpointer data)
3545 {
3546         adapter_le_address_filter_params_t *params = data;
3547
3548         g_free(params);
3549 }
3550
3551 static void uuid_filter_params_free(gpointer data)
3552 {
3553         adapter_le_uuid_params_t *params = data;
3554
3555         g_free((char *)params->uuid);
3556         g_free((char *)params->uuid_mask);
3557         g_free(params);
3558 }
3559
3560 static void manufacturer_filter_params_free(gpointer data)
3561 {
3562         adapter_le_manf_data_params_t *params = data;
3563
3564         g_free((char *)params->man_data);
3565         g_free((char *)params->man_data_mask);
3566         g_free(params);
3567 }
3568
3569 static void local_name_filter_params_free(gpointer data)
3570 {
3571         adapter_le_local_name_params_t *params = data;
3572
3573         g_free((char *)params->local_name);
3574         g_free(params);
3575 }
3576
3577 static void service_data_filter_params_free(gpointer data)
3578 {
3579         adapter_le_service_data_params_t *params = data;
3580
3581         g_free((char *)params->service_data);
3582         g_free((char *)params->service_data_mask);
3583         g_free(params);
3584 }
3585
3586 static void scan_filter_params_free(gpointer data)
3587 {
3588         adapter_le_scan_filter_param_t *params = data;
3589         g_free(params);
3590 }
3591
3592 int adapter_le_address_cmp(gconstpointer a, gconstpointer b)
3593 {
3594         const adapter_le_address_filter_params_t *params = a;
3595         const char *address = b;
3596         char addr[18];
3597
3598         ba2str(&params->broadcaster_addr, addr);
3599         return strcasecmp(addr, address);
3600 }
3601
3602 int adapter_le_uuid_cmp(gconstpointer a, gconstpointer b)
3603 {
3604         const adapter_le_uuid_params_t *params = a;
3605         const char *uuid = b;
3606
3607         return strcasecmp((const char *)params->uuid, uuid);
3608 }
3609
3610 int adapter_le_manufacturer_data_cmp(gconstpointer a, gconstpointer b)
3611 {
3612         const adapter_le_manf_data_params_t *params = a;
3613         const struct eir_msd *msd = b;
3614
3615         if (msd->company == params->company_id) {
3616                 /* if the advertisiement packet is an iBeacon */
3617                 if (msd->company == COMPANY_ID_APPLE)
3618                         return 0;
3619                 return strncasecmp((const char *)params->man_data,
3620                                                 (const char *)msd->data,
3621                                                 params->man_data_len);
3622         } else {
3623                 return -1;
3624         }
3625 }
3626
3627 int adapter_le_local_name_cmp(gconstpointer a, gconstpointer b)
3628 {
3629         const adapter_le_local_name_params_t *params = a;
3630         const char *name = b;
3631
3632         return strcasecmp(params->local_name, name);
3633 }
3634
3635 int adapter_le_service_data_cmp(gconstpointer a, gconstpointer b)
3636 {
3637         const adapter_le_service_data_params_t *params = a;
3638         const struct eir_sd *sd = b;
3639         /* Todo, the service data format for 16 bit, 32bit and
3640          * 128 bit uuids needs to addressed */
3641         return strncasecmp((const char *)(params->service_data),
3642                                         (const char *)sd->data,
3643                                         sd->data_len);
3644 }
3645
3646 int adapter_le_address_filter_index_cmp(gconstpointer a, gconstpointer b)
3647 {
3648         const adapter_le_address_filter_params_t *params = a;
3649         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3650
3651         return params->filter_index - filter_inex;
3652 }
3653
3654 int adapter_le_uuid_filter_index_cmp(gconstpointer a, gconstpointer b)
3655 {
3656         const adapter_le_uuid_params_t *params = a;
3657         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3658
3659         return params->filter_index - filter_inex;
3660 }
3661
3662 int adapter_le_manufacturer_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3663 {
3664         const adapter_le_manf_data_params_t *params = a;
3665         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3666
3667         return params->filter_index - filter_inex;
3668 }
3669
3670 int adapter_le_local_name_filter_index_cmp(gconstpointer a, gconstpointer b)
3671 {
3672         const adapter_le_local_name_params_t *params = a;
3673         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3674
3675         return params->filter_index - filter_inex;
3676 }
3677
3678 int adapter_le_service_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3679 {
3680         const adapter_le_service_data_params_t *params = a;
3681         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3682
3683         return params->filter_index - filter_inex;
3684 }
3685
3686 int adapter_le_scan_params_filter_index_cmp(gconstpointer a, gconstpointer b)
3687 {
3688         const adapter_le_scan_filter_param_t *params = a;
3689         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3690
3691         return params->index - filter_inex;
3692 }
3693
3694 static gboolean adapter_le_clear_platform_scan_filter_data(
3695                         struct btd_adapter *adapter, int filter_index)
3696 {
3697         DBG("");
3698         GSList *list;
3699         if (!adapter)
3700                 return FALSE;
3701
3702         list = g_slist_find_custom(adapter->addr_filters,
3703                 GINT_TO_POINTER(filter_index), adapter_le_address_filter_index_cmp);
3704         if (list && list->data) {
3705                 /* Delete info from the struct to list */
3706                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3707         }
3708         list = g_slist_find_custom(adapter->service_data_changed_filters,
3709                 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3710         if (list && list->data) {
3711                 /* Delete info from the struct to list */
3712                 adapter->service_data_changed_filters = g_slist_delete_link(adapter->service_data_changed_filters, list);
3713         }
3714
3715         list = g_slist_find_custom(adapter->service_uuid_filters,
3716                 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3717         if (list && list->data) {
3718                 /* Delete info from the struct to list */
3719                 adapter->service_uuid_filters = g_slist_delete_link(adapter->service_uuid_filters, list);
3720         }
3721
3722         list = g_slist_find_custom(adapter->solicit_data_filters,
3723                 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3724         if (list && list->data) {
3725                 /* Delete info from the struct to list */
3726                 adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3727         }
3728
3729         list = g_slist_find_custom(adapter->local_name_filters,
3730                 GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
3731         if (list && list->data) {
3732                 /* Delete info from the struct to list */
3733                 adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
3734         }
3735
3736         list = g_slist_find_custom(adapter->manufaturer_data_filters,
3737                 GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3738         if (list && list->data) {
3739                 /* Delete info from the struct to list */
3740                 adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3741         }
3742
3743         list = g_slist_find_custom(adapter->service_data_filters,
3744                 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3745         if (list && list->data) {
3746                 /* Delete info from the struct to list */
3747                 adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
3748         }
3749
3750         list = g_slist_find_custom(adapter->scan_params,
3751                 GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
3752         if (list && list->data) {
3753                 /* Delete info from the struct to list */
3754                 adapter->scan_params = g_slist_delete_link(adapter->scan_params, list);
3755         }
3756
3757         return TRUE;
3758 }
3759
3760 static gboolean adapter_le_enable_platform_scan_filtering(
3761                         struct btd_adapter *adapter, gboolean enable)
3762 {
3763         if (!adapter)
3764                 return FALSE;
3765
3766         DBG("Platform scan filtering enable[%d]", enable);
3767
3768         adapter->scan_filter_support = enable;
3769
3770         return TRUE;
3771 }
3772
3773
3774 static gboolean adapter_le_service_add_addr_scan_filter_data(struct btd_adapter *adapter,
3775                                                 int filter_index, gchar *string, int addr_type)
3776 {
3777         /* TYPE_DEVICE_ADDRESS */
3778         adapter_le_address_filter_params_t *params;
3779
3780         DBG("");
3781
3782         params = g_new0(adapter_le_address_filter_params_t, 1);
3783         if (!params)
3784                 return FALSE;
3785
3786         params->filter_index = filter_index;
3787         str2ba(string, &params->broadcaster_addr);
3788         params->bdaddr_type = addr_type;
3789
3790         /* Store the struct to list */
3791         adapter->addr_filters = g_slist_append(adapter->addr_filters, params);
3792         return TRUE;
3793 }
3794
3795 static const char *adapter_le_service_find_addr_scan_filter_data(
3796                                                 struct btd_adapter *adapter, gchar *string)
3797 {
3798         GSList *list;
3799         DBG("");
3800
3801         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3802         if (!list)
3803                 return NULL;
3804         else
3805                 return list->data;
3806
3807         return NULL;
3808 }
3809
3810 static gboolean adapter_le_service_delete_addr_scan_filter_data(struct btd_adapter *adapter,
3811                                                 int filter_index, gchar *string, int addr_type)
3812 {
3813         GSList *list;
3814         DBG("");
3815
3816         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3817         if (!list)
3818                 return FALSE;
3819         else
3820                 /* Delete info from the struct to list */
3821                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3822
3823         return TRUE;
3824 }
3825
3826 static gboolean adapter_le_service_clear_addr_scan_filter_data(struct btd_adapter *adapter)
3827 {
3828         DBG("");
3829
3830         g_slist_free_full(adapter->addr_filters, addr_filter_params_free);
3831         adapter->addr_filters = NULL;
3832
3833         return TRUE;
3834 }
3835
3836 static gboolean adapter_le_service_add_uuid_scan_filter_data(struct btd_adapter *adapter,
3837                                                         int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3838                                                         uint8_t *p_uuid_mask, int uuid_mask_len)
3839 {
3840
3841         adapter_le_uuid_params_t *params;
3842         bt_uuid_t uuid;
3843
3844         DBG("");
3845
3846         params = g_new0(adapter_le_uuid_params_t, 1);
3847         if (!params)
3848                 return FALSE;
3849
3850         if (uuid_mask_len == UUID_16_LEN) {
3851                 uint16_t *uuid16 = (void *)p_uuid;
3852                 sdp_uuid16_create((uuid_t *)&uuid, get_be16(uuid16));
3853         } else if (uuid_mask_len == UUID_32_LEN) {
3854                 uint32_t *uuid32 = (void *)p_uuid;
3855                 sdp_uuid32_create((uuid_t *)&uuid, get_be32(uuid32));
3856         } else {
3857                 sdp_uuid128_create((uuid_t *)&uuid, p_uuid);
3858         }
3859         params->filter_index = filter_index;
3860         params->uuid = (uint8_t *)bt_uuid2string((uuid_t *)&uuid);
3861         params->uuid_mask = g_new0(uint8_t, uuid_mask_len);
3862         memcpy(params->uuid_mask, p_uuid_mask, uuid_mask_len);
3863         params->uuid_len = uuid_mask_len;
3864
3865         /* Store the struct to list */
3866         adapter->solicit_data_filters = g_slist_append(adapter->solicit_data_filters, params);
3867
3868         return TRUE;
3869 }
3870
3871 static adapter_le_uuid_params_t *adapter_le_service_find_uuid_scan_filter_data(struct btd_adapter *adapter,
3872                                                         uint8_t *p_uuid)
3873 {
3874         GSList *list;
3875         DBG("");
3876
3877         list = g_slist_find_custom(adapter->solicit_data_filters, p_uuid, adapter_le_uuid_cmp);
3878         if (!list)
3879                 return NULL;
3880         else
3881                 /* Delete info from the struct to list */
3882                 return list->data;
3883
3884         return NULL;
3885 }
3886
3887 static gboolean adapter_le_service_delete_uuid_scan_filter_data(struct btd_adapter *adapter,
3888                                                         int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3889                                                         uint8_t *p_uuid_mask, int uuid_mask_len)
3890 {
3891         GSList *list;
3892         DBG("");
3893
3894         list = g_slist_find_custom(adapter->solicit_data_filters, GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3895         if (!list)
3896                 return FALSE;
3897         else {
3898                 adapter_le_uuid_params_t *params = list->data;
3899                 /* Delete info from the struct to list */
3900                 if (params && strcasecmp((const char *)params->uuid, (const char *)p_uuid)) {
3901                         adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3902                 }
3903         }
3904
3905         return TRUE;
3906 }
3907
3908 static gboolean adapter_le_service_clear_uuid_scan_filter_data(struct btd_adapter *adapter)
3909 {
3910         DBG("");
3911
3912         g_slist_free_full(adapter->solicit_data_filters, uuid_filter_params_free);
3913         adapter->solicit_data_filters = NULL;
3914
3915         return TRUE;
3916 }
3917
3918 static gboolean adapter_le_service_add_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3919                                                         int filter_index, int company_id, int company_id_mask,
3920                                                         uint8_t *p_data, uint8_t *p_mask, int data_len)
3921 {
3922
3923         adapter_le_manf_data_params_t *params;
3924
3925         DBG("");
3926
3927         params = g_new0(adapter_le_manf_data_params_t, 1);
3928         if (!params)
3929                 return FALSE;
3930
3931         params->filter_index = filter_index;
3932         params->company_id = company_id;
3933         params->company_id_mask = company_id_mask;
3934         params->man_data = g_new0(uint8_t, data_len);
3935         memcpy(params->man_data, p_data, data_len);
3936         params->man_data_mask = g_new0(uint8_t, data_len);
3937         memcpy(params->man_data_mask, p_mask, data_len);
3938         params->man_data_len = data_len;
3939
3940         /* Store the struct to list */
3941         adapter->manufaturer_data_filters = g_slist_append(adapter->manufaturer_data_filters, params);
3942
3943         return TRUE;
3944 }
3945
3946 static adapter_le_manf_data_params_t *adapter_le_service_find_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3947                                                         struct eir_msd *msd)
3948 {
3949         GSList *list;
3950         DBG("");
3951         list = g_slist_find_custom(adapter->manufaturer_data_filters, msd, adapter_le_manufacturer_data_cmp);
3952         if (!list)
3953                 return NULL;
3954         else
3955                 return list->data;
3956
3957         return NULL;
3958 }
3959
3960 static gboolean adapter_le_service_delete_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3961                                                         int filter_index, int company_id, int company_id_mask,
3962                                                         uint8_t *p_data, uint8_t *p_mask, int data_len)
3963 {
3964         GSList *list;
3965         DBG("");
3966         list = g_slist_find_custom(adapter->manufaturer_data_filters, GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3967         if (!list)
3968                 return FALSE;
3969         else {
3970                 adapter_le_manf_data_params_t *params = list->data;
3971                 /* Delete info from the struct to list */
3972                 if (params && strcasecmp((const char *)params->man_data, (const char *)p_data)) {
3973                         adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3974                 }
3975         }
3976
3977         return TRUE;
3978 }
3979
3980 static gboolean adapter_le_service_clear_manufacturer_scan_filter_data(struct btd_adapter *adapter)
3981 {
3982         DBG("");
3983
3984         g_slist_free_full(adapter->manufaturer_data_filters, manufacturer_filter_params_free);
3985         adapter->manufaturer_data_filters = NULL;
3986
3987         return TRUE;
3988 }
3989
3990 static gboolean adapter_le_service_add_local_name_scan_filter_data(struct btd_adapter *adapter,
3991                                                                                         int filter_index, gchar *name)
3992 {
3993
3994         adapter_le_local_name_params_t *params;
3995
3996         DBG("");
3997
3998         params = g_new0(adapter_le_local_name_params_t, 1);
3999         if (!params)
4000                 return FALSE;
4001
4002         params->filter_index = filter_index;
4003         params->local_name = g_strdup(name);
4004         params->name_len = strlen(name);
4005
4006         /* Store the struct to list */
4007         adapter->local_name_filters = g_slist_append(adapter->local_name_filters, params);
4008
4009         return TRUE;
4010 }
4011
4012 static adapter_le_local_name_params_t *adapter_le_service_find_local_name_scan_filter_data(
4013                                                                                                 struct btd_adapter *adapter,
4014                                                                                                 gchar *name)
4015 {
4016         GSList *list;
4017         DBG("");
4018         list = g_slist_find_custom(adapter->local_name_filters, name, adapter_le_local_name_cmp);
4019         if (!list)
4020                 return NULL;
4021         else
4022                 return list->data;
4023
4024         return NULL;
4025 }
4026
4027 static gboolean adapter_le_service_delete_local_name_scan_filter_data(struct btd_adapter *adapter,
4028                                                                                                 int filter_index, gchar *name)
4029 {
4030         GSList *list;
4031         DBG("");
4032         list = g_slist_find_custom(adapter->local_name_filters, GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
4033         if (!list)
4034                 return FALSE;
4035         else {
4036                 adapter_le_local_name_params_t *params = list->data;
4037                 /* Delete info from the struct to list */
4038                 if (params && strcasecmp((const char *)params->local_name, (const char *)name)) {
4039                         adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
4040                 }
4041         }
4042
4043         return TRUE;
4044 }
4045
4046 static gboolean adapter_le_service_clear_local_name_scan_filter_data(struct btd_adapter *adapter)
4047 {
4048         DBG("");
4049
4050         g_slist_free_full(adapter->local_name_filters, local_name_filter_params_free);
4051         adapter->local_name_filters = NULL;
4052
4053         return TRUE;
4054 }
4055
4056 static gboolean adapter_le_service_add_service_scan_filter_data(struct btd_adapter *adapter,
4057                                                         int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
4058 {
4059         adapter_le_service_data_params_t *params;
4060
4061         DBG("");
4062
4063         params = g_new0(adapter_le_service_data_params_t, 1);
4064         if (!params)
4065                 return FALSE;
4066
4067         params->filter_index = filter_index;
4068         params->service_data = g_new0(uint8_t, data_len);
4069         memcpy(params->service_data, p_data, data_len);
4070         params->service_data_mask = g_new0(uint8_t, data_len);
4071         memcpy(params->service_data_mask, p_mask, data_len);
4072         params->service_data_len = data_len;
4073
4074         /* Store the struct to list */
4075         adapter->service_data_filters = g_slist_append(adapter->service_data_filters, params);
4076
4077         return TRUE;
4078 }
4079
4080 static adapter_le_service_data_params_t* adapter_le_service_find_service_scan_filter_data(
4081                                                         struct btd_adapter *adapter, struct eir_sd *sd)
4082 {
4083         GSList *list;
4084         DBG("");
4085
4086         list = g_slist_find_custom(adapter->service_data_filters, sd, adapter_le_service_data_cmp);
4087         if (!list)
4088                 return NULL;
4089         else
4090                 return list->data;
4091
4092         return NULL;
4093 }
4094
4095 static gboolean adapter_le_service_delete_service_scan_filter_data(struct btd_adapter *adapter,
4096                                                         int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
4097 {
4098         GSList *list;
4099         DBG("");
4100
4101         list = g_slist_find_custom(adapter->service_data_filters, GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
4102         if (!list)
4103                 return FALSE;
4104         else {
4105                 adapter_le_service_data_params_t *params = list->data;
4106                 /* Delete info from the struct to list */
4107                 if (params && strcasecmp((const char *)params->service_data, (const char *)p_data)) {
4108                         adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
4109                 }
4110         }
4111         return TRUE;
4112 }
4113
4114 static gboolean adapter_le_service_clear_service_scan_filter_data(struct btd_adapter *adapter)
4115 {
4116         DBG("");
4117
4118         g_slist_free_full(adapter->service_data_filters, service_data_filter_params_free);
4119         adapter->service_data_filters = NULL;
4120
4121         return TRUE;
4122 }
4123
4124 static gboolean adapter_le_service_add_scan_filter_params(struct btd_adapter *adapter,
4125                                                         adapter_le_scan_filter_param_t *params)
4126 {
4127         adapter_le_scan_filter_param_t *l_params;
4128
4129         DBG("");
4130
4131         l_params = g_new0(adapter_le_scan_filter_param_t, 1);
4132         if (!l_params)
4133                 return FALSE;
4134
4135         l_params->action = params->action;
4136         l_params->delivery_mode = params->delivery_mode;
4137         l_params->feature = params->feature;
4138         l_params->filter_logic_type = params->filter_logic_type;
4139         l_params->index = params->index;
4140         l_params->list_logic_type = params->list_logic_type;
4141         l_params->onfound_timeout = params->onfound_timeout;
4142         l_params->onfound_timeout_cnt = params->onfound_timeout_cnt;
4143         l_params->rssi_high_threshold = params->rssi_high_threshold;
4144         l_params->rssi_low_threshold = params->rssi_low_threshold;
4145
4146         /* Store the struct to list */
4147         adapter->scan_params = g_slist_append(adapter->scan_params, l_params);
4148
4149         return TRUE;
4150 }
4151
4152 static adapter_le_scan_filter_param_t *adapter_le_service_find_scan_filter_params(
4153                                                         struct btd_adapter *adapter, int filter_index)
4154 {
4155         GSList *list;
4156         DBG("");
4157
4158         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
4159         if (!list)
4160                 return NULL;
4161         else
4162                 return list->data;
4163
4164         return NULL;
4165 }
4166
4167 static gboolean adapter_le_service_delete_scan_filter_params(struct btd_adapter *adapter,
4168                                                         adapter_le_scan_filter_param_t *params)
4169 {
4170         GSList *list;
4171         DBG("");
4172
4173         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(params->index), adapter_le_scan_params_filter_index_cmp);
4174         if (!list)
4175                 return FALSE;
4176         else
4177                 adapter->scan_params = g_slist_remove(adapter->scan_params, list);
4178
4179         return TRUE;
4180 }
4181
4182 static gboolean adapter_le_service_clear_scan_filter_params(struct btd_adapter *adapter)
4183 {
4184         DBG("");
4185
4186         g_slist_free_full(adapter->scan_params, scan_filter_params_free);
4187         adapter->scan_params = NULL;
4188
4189         return TRUE;
4190 }
4191
4192 int adapter_byte_arr_cmp_with_mask(const char *data1, const char *data2,
4193         const char *mask, int data_len)
4194 {
4195         int i;
4196         char a, b;
4197         if (data1 == NULL || data2 == NULL || mask == NULL)
4198                 return -1;
4199         for (i = 0; i < data_len; i++) {
4200                 a = data1[i] & mask[i];
4201                 b = data2[i] & mask[i];
4202                 if (a != b)
4203                         return (int)(a - b);
4204         }
4205         return 0;
4206 }
4207
4208 static uint8_t validate_for_filter_policy(struct btd_adapter *adapter,
4209                                                                 const struct eir_data *eir, gchar *addr)
4210 {
4211         uint8_t allow_report = NONE_REPORT;
4212
4213         if (adapter->scan_filter_support == FALSE)
4214                 allow_report = SCAN_REPORT;
4215         else {
4216                 if (adapter_le_service_find_addr_scan_filter_data(adapter, addr))
4217                         allow_report = SCAN_REPORT;
4218                 if (eir->name) {
4219                         if(adapter_le_service_find_local_name_scan_filter_data(adapter, eir->name))
4220                                 allow_report = SCAN_REPORT;
4221                         }
4222                 if (eir->sd_list) {
4223                         GSList *list = NULL;
4224                         for (list = eir->sd_list; list != NULL; list = g_slist_next(list)) {
4225                                 struct eir_sd *sd = list->data;
4226                                 if (sd != NULL) {
4227                                         static adapter_le_uuid_params_t *uuid_data = NULL;
4228                                         static adapter_le_service_data_params_t *service_data = NULL;
4229                                         static adapter_le_scan_filter_param_t *scan_param_data = NULL;
4230                                         uuid_data = adapter_le_service_find_uuid_scan_filter_data(adapter, (uint8_t *)sd->uuid);
4231                                         service_data = adapter_le_service_find_service_scan_filter_data(adapter, sd);
4232                                         if (service_data != NULL) {
4233                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)service_data->service_data,
4234                                                 (const char *)sd->data, (const char *)service_data->service_data_mask,
4235                                                 service_data->service_data_len)) {
4236                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4237                                                                                 service_data->filter_index);
4238                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4239                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
4240                                                                 allow_report = SCAN_REPORT;
4241                                                 }
4242                                         }
4243                                         if (uuid_data != NULL) {
4244                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)uuid_data->uuid,
4245                                                 (const char *)sd->uuid, (const char *)uuid_data->uuid_mask,
4246                                                 uuid_data->uuid_len)) {
4247                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4248                                                                                                 uuid_data->filter_index);
4249                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4250                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
4251                                                                 allow_report = SCAN_REPORT;
4252                                                 }
4253                                         }
4254                                         if (allow_report)
4255                                                 break;
4256                                 }
4257                         }
4258                 }
4259                 if (eir->msd_list) {
4260                         GSList *list = NULL;
4261                         for (list = eir->msd_list; list != NULL; list = g_slist_next(list)) {
4262                                 struct eir_msd *msd = list->data;
4263                                 if (msd != NULL) {
4264                                         static adapter_le_manf_data_params_t *manuf_data;
4265                                         static adapter_le_scan_filter_param_t *scan_param_data = NULL;
4266                                         manuf_data = adapter_le_service_find_manufacturer_scan_filter_data(adapter,
4267                                                         msd);
4268                                         if (manuf_data != NULL) {
4269                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)msd->data,
4270                                                         (const char *)manuf_data->man_data, (const char *)manuf_data->man_data_mask,
4271                                                         manuf_data->man_data_len)) {
4272                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
4273                                                                                                 manuf_data->filter_index);
4274                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
4275                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
4276                                                                 allow_report = SCAN_REPORT;
4277                                                 }
4278                                                 if (msd->company == COMPANY_ID_APPLE)
4279                                                         allow_report = IBEACON_REPORT;
4280                                         }
4281                                 }
4282                         }
4283                 }
4284         }
4285         return allow_report;
4286 }
4287
4288 gboolean adapter_le_set_platform_scan_filter_params(struct btd_adapter *adapter,
4289                                         adapter_le_scan_filter_param_t *params)
4290 {
4291         gboolean ret = TRUE;
4292         DBG("adapter_le_scan_filter_param_t [%d]", params->index);
4293         adapter_le_scan_filter_action_type action_type = params->action;
4294
4295         if (action_type == ADD) {
4296                 ret = adapter_le_service_add_scan_filter_params(adapter, params);
4297         } else if (action_type == DELETE) {
4298                 ret = adapter_le_service_delete_scan_filter_params(adapter, params);
4299         } else if (action_type == CLEAR) {
4300                 ret = adapter_le_service_clear_scan_filter_params(adapter);
4301         } else {
4302                 DBG("filter_action error");
4303                 ret = FALSE;
4304         }
4305
4306         DBG("Scan Filter VSC :: Action [%x]",
4307                                         params->action);
4308         return ret;
4309 }
4310
4311 gboolean adapter_le_set_platform_scan_filter_data(struct btd_adapter *adapter,
4312                                                 int client_if, int action,
4313                                                 int filt_type, int filter_index,
4314                                                 int company_id,
4315                                                 int company_id_mask,
4316                                                 int uuid_len, uint8_t *p_uuid,
4317                                                 int uuid_mask_len, uint8_t *p_uuid_mask,
4318                                                 gchar *string, int addr_type,
4319                                                 int data_len, uint8_t *p_data,
4320                                                 int mask_len, uint8_t *p_mask)
4321 {
4322         gboolean ret = TRUE;
4323
4324         DBG("");
4325
4326         switch (filt_type) {
4327         case TYPE_DEVICE_ADDRESS: {
4328                 /* TYPE_DEVICE_ADDRESS */
4329                 adapter_le_scan_filter_action_type action_type = action;
4330
4331                 if (action_type == ADD) {
4332                         ret = adapter_le_service_add_addr_scan_filter_data(adapter,
4333                                                 filter_index, string, addr_type);
4334                 } else if (action_type == DELETE) {
4335                         ret = adapter_le_service_delete_addr_scan_filter_data(adapter,
4336                                                 filter_index, string, addr_type);
4337                 } else if (action_type == CLEAR) {
4338                         ret = adapter_le_service_clear_addr_scan_filter_data(adapter);
4339                 } else {
4340                         DBG("filter_action error");
4341                         ret = FALSE;
4342                 }
4343
4344                 break;
4345         }
4346
4347         case TYPE_SERVICE_UUID:
4348         case TYPE_SOLICIT_UUID: {
4349                 adapter_le_scan_filter_action_type action_type = action;
4350
4351                 gboolean is_solicited = (filt_type == TYPE_SOLICIT_UUID) ? TRUE : FALSE;
4352
4353                 if (uuid_len != UUID_16_LEN && uuid_len != UUID_32_LEN
4354                         && uuid_len != UUID_128_LEN) {
4355                         DBG("UUID length error");
4356                         return FALSE;
4357                 }
4358
4359                 if (uuid_len != uuid_mask_len) {
4360                         DBG("Both UUID and UUID_MASK length shoule be samed");
4361                         return FALSE;
4362                 }
4363
4364                 if (action_type == ADD) {
4365                         ret = adapter_le_service_add_uuid_scan_filter_data(adapter,
4366                                                 filter_index, is_solicited, p_uuid,
4367                                                 p_uuid_mask, uuid_len);
4368                 } else if (action_type == DELETE) {
4369                         ret = adapter_le_service_delete_uuid_scan_filter_data(adapter,
4370                                                 filter_index, is_solicited, p_uuid,
4371                                                 p_uuid_mask, uuid_len);
4372                 } else if (action_type == CLEAR) {
4373                         ret = adapter_le_service_clear_uuid_scan_filter_data(adapter);
4374                 } else {
4375                         DBG("filter_action error");
4376                         ret = FALSE;
4377                 }
4378
4379                 break;
4380         }
4381
4382         case TYPE_LOCAL_NAME: {
4383                 adapter_le_scan_filter_action_type action_type = action;
4384
4385                 if (action_type == ADD) {
4386                         ret = adapter_le_service_add_local_name_scan_filter_data(adapter,
4387                                                 filter_index, (gchar*)string);
4388                 } else if (action_type == DELETE) {
4389                         ret = adapter_le_service_delete_local_name_scan_filter_data(adapter,
4390                                                 filter_index, (gchar*)string);
4391                 } else if (action_type == CLEAR) {
4392                         ret = adapter_le_service_clear_local_name_scan_filter_data(adapter);
4393                 } else {
4394                         DBG("filter_action error");
4395                         ret = FALSE;
4396                 }
4397
4398                 break;
4399         }
4400
4401         case TYPE_MANUFACTURER_DATA: {
4402                 adapter_le_scan_filter_action_type action_type = action;
4403
4404                 if (data_len == 0 || (data_len != mask_len)) {
4405                         DBG("parameter length error");
4406                         return FALSE;
4407                 }
4408
4409                 if (action_type == ADD) {
4410                         ret = adapter_le_service_add_manufacturer_scan_filter_data(adapter,
4411                                                 filter_index,company_id, company_id_mask, p_data, p_mask, data_len);
4412                 } else if (action_type == DELETE) {
4413                         ret = adapter_le_service_delete_manufacturer_scan_filter_data(adapter,
4414                                                 filter_index, company_id, company_id_mask, p_data, p_mask, data_len);
4415                 } else if (action_type == CLEAR) {
4416                         ret = adapter_le_service_clear_manufacturer_scan_filter_data(adapter);
4417                 } else {
4418                         DBG("filter_action error");
4419                         ret = FALSE;
4420                 }
4421
4422                 break;
4423         }
4424
4425         case TYPE_SERVICE_DATA: {
4426                 adapter_le_scan_filter_action_type action_type = action;
4427
4428                 if (data_len == 0 || (data_len != mask_len)) {
4429                         DBG("parameter length error");
4430                         return FALSE;
4431                 }
4432
4433                 if (action_type == ADD) {
4434                         ret = adapter_le_service_add_service_scan_filter_data(adapter,
4435                                                 filter_index, p_data, p_mask, data_len);
4436                 } else if (action_type == DELETE) {
4437                         ret = adapter_le_service_delete_service_scan_filter_data(adapter,
4438                                                 filter_index, p_data, p_mask, data_len);
4439                 } else if (action_type == CLEAR) {
4440                         ret = adapter_le_service_clear_service_scan_filter_data(adapter);
4441                 } else {
4442                         DBG("filter_action error");
4443                         ret = FALSE;
4444                 }
4445
4446                 break;
4447         }
4448
4449         default:
4450                 DBG("filter_type error");
4451                 ret = FALSE;
4452         }
4453
4454         return ret;
4455 }
4456 #endif
4457
4458 static bool is_set_adv_data_flag(uint8_t *data, int data_len)
4459 {
4460         int adv_type;
4461         for (int i = 0; i < data_len; i++) {
4462                 adv_type = data[i + 1];
4463                 if (adv_type == EIR_FLAGS)
4464                         return true;
4465                 else
4466                         i = i + data[i];
4467         }
4468         return false;
4469 }
4470
4471 static int set_adv_data_flag(uint8_t *adv_data, uint8_t *data, int data_len, void *user_data)
4472 {
4473         struct btd_adapter *adapter = user_data;
4474
4475         if (is_set_adv_data_flag(data, data_len))
4476                 return data_len;
4477
4478         adv_data[0] = 2;
4479         adv_data[1] = EIR_FLAGS;
4480
4481         if (adapter->le_static_addr.b[5] != 0)
4482                 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER |
4483                                 EIR_SIM_HOST | EIR_BREDR_UNSUP;
4484         else {
4485                 if (TIZEN_FEATURE_BLUEZ_DA) {
4486                         DBG("Disable LE General Discoverable Mode");
4487                         adv_data[2] = EIR_CONTROLLER | EIR_SIM_HOST;
4488                 } else
4489                         adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER | EIR_SIM_HOST;
4490         }
4491
4492         memcpy(adv_data + 3, data, data_len);
4493         return data_len + 3;
4494 }
4495
4496 static int set_adv_data_device_name(uint8_t *adv_data, int adv_len, char *name)
4497 {
4498         int ad_type;
4499         int ad_len;
4500         int i, j;
4501         int name_len;
4502         uint8_t *data = NULL;
4503
4504         if (!name)
4505                 return adv_len;
4506
4507         data = g_memdup(adv_data, adv_len);
4508         if (!data)
4509                 return adv_len;
4510
4511         name_len = strlen(name);
4512
4513         for (i = 0; i <adv_len ; i++) {
4514                 ad_len = data[i];
4515                 ad_type = data[i + 1];
4516
4517                 if (ad_type == EIR_NAME_COMPLETE && ad_len == 1) {
4518                         /* Move to last position and update local name */
4519                         for (j = i; j < adv_len - 2; j++)
4520                                 adv_data[j] = data[j + 2];
4521
4522                         adv_data[j] = name_len + 1;
4523                         if (name_len > ADV_DATA_MAX_LENGTH - adv_len) {
4524                                 adv_data[j] = ADV_DATA_MAX_LENGTH - adv_len + 1;
4525                                 adv_data[j + 1] = EIR_NAME_SHORT;
4526                                 memcpy(adv_data + j + 2, name, ADV_DATA_MAX_LENGTH - adv_len);
4527                                 g_free(data);
4528                                 return ADV_DATA_MAX_LENGTH;
4529                         } else {
4530                                 adv_data[j + 1] = EIR_NAME_COMPLETE;
4531                                 memcpy(adv_data + j + 2, name, name_len);
4532                                 g_free(data);
4533                                 return adv_len + name_len;
4534                         }
4535
4536                 } else {
4537                         memcpy(adv_data + i, &data[i], ad_len + 1);
4538                         i = i + data[i];
4539                 }
4540         }
4541
4542         g_free(data);
4543         return adv_len;
4544 }
4545
4546 static int set_adv_data_tx_power(uint8_t *adv_data, int adv_len, int8_t tx_power)
4547 {
4548         int ad_type;
4549         int ad_len;
4550         int i, j;
4551         uint8_t *data = NULL;
4552
4553         data = g_memdup(adv_data, adv_len);
4554         if (!data)
4555                 return adv_len;
4556
4557         for (i = 0; i <adv_len ; i++) {
4558                 ad_len = data[i];
4559                 ad_type = data[i + 1];
4560
4561                 if (ad_type == EIR_TX_POWER) {
4562                         adv_data[i] = 2;
4563                         adv_data[i + 1] = EIR_TX_POWER;
4564                         adv_data[i + 2] = tx_power;
4565
4566                         for(j = i + 2; j < adv_len; j++)
4567                                 adv_data[j + 1] = data[j];
4568
4569                         g_free(data);
4570                         return adv_len + 1;
4571                 } else {
4572                         memcpy(adv_data + i, &data[i], ad_len + 1);
4573                         i = i + data[i];
4574                 }
4575         }
4576
4577         g_free(data);
4578         return adv_len;
4579 }
4580
4581
4582 static int adapter_le_set_missed_adv_data(uint8_t *p_data, uint8_t data_len,
4583                 gboolean is_scan_rsp, char *adapter_name, int8_t tx_power, uint8_t **adv_data, int *adv_len,
4584                 void *user_data)
4585 {
4586         uint8_t *data;
4587         int len;
4588
4589         data = g_malloc0(ADV_DATA_MAX_LENGTH);
4590         memcpy(data, p_data, data_len);
4591         len = data_len;
4592
4593         /* In case multi advertising, need to update the below AD type
4594                 since it handled into kernel */
4595         if (!is_scan_rsp) {
4596                 len = set_adv_data_flag(data, p_data, data_len, user_data);
4597         }
4598
4599         len = set_adv_data_tx_power(data, len, tx_power);
4600
4601         len = set_adv_data_device_name(data, len, adapter_name);
4602
4603         *adv_data = data;
4604         *adv_len = len;
4605         return 0;
4606 }
4607
4608 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
4609 static DBusMessage *adapter_get_psm_l2cap_le(DBusConnection *conn,
4610                                                 DBusMessage *msg, void *user_data)
4611 {
4612         return get_psm_l2cap_le(conn, msg);
4613 }
4614
4615 static DBusMessage *adapter_listen_l2cap_le_socket(DBusConnection *conn,
4616                                                 DBusMessage *msg, void *user_data)
4617 {
4618         return listen_l2cap_le_socket(conn, msg, user_data);
4619 }
4620
4621 static DBusMessage *adapter_remove_l2cap_le_socket(DBusConnection *conn,
4622                                                 DBusMessage *msg, void *user_data)
4623 {
4624         return remove_l2cap_le_socket(conn, msg);
4625 }
4626
4627 #endif
4628
4629 static DBusMessage *adapter_start_custom_discovery(DBusConnection *conn,
4630                                         DBusMessage *msg, void *user_data)
4631 {
4632         struct btd_adapter *adapter = user_data;
4633         const char *sender = dbus_message_get_sender(msg);
4634         struct discovery_client *client;
4635         GSList *list;
4636         const gchar *disc_type;
4637
4638         DBG("sender %s", sender);
4639
4640         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4641                 return btd_error_not_ready(msg);
4642
4643         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &disc_type,
4644                                                         DBUS_TYPE_INVALID)) {
4645                 return btd_error_invalid_args(msg);
4646         }
4647
4648         DBG("discovery type = %s", disc_type);
4649
4650         /*Valid strings: "BREDR", "LE", "LE_BREDR" */
4651         if (g_strcmp0(disc_type, "BREDR") == 0)
4652                 adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
4653         else if (g_strcmp0(disc_type, "LE") == 0)
4654                 adapter->disc_type =  BT_DISC_TYPE_LE_ONLY;
4655         else if (g_strcmp0(disc_type, "LE_BREDR") == 0)
4656                 adapter->disc_type =  BT_DISC_TYPE_LE_BREDR;
4657         else
4658                 return btd_error_invalid_args(msg);
4659
4660         /*
4661          * Every client can only start one discovery, if the client
4662          * already started a discovery then return an error.
4663          */
4664         list = g_slist_find_custom(adapter->discovery_list, sender,
4665                                                 compare_sender);
4666         if (list)
4667                 return btd_error_busy(msg);
4668
4669         client = g_new0(struct discovery_client, 1);
4670
4671         client->adapter = adapter;
4672         client->owner = g_strdup(sender);
4673         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4674                                                 discovery_disconnect, client,
4675                                                 discovery_destroy);
4676
4677         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
4678                                                                 client);
4679
4680         /*
4681          * Just trigger the discovery here. In case an already running
4682          * discovery in idle phase exists, it will be restarted right
4683          * away.
4684          */
4685         trigger_start_discovery(adapter, 0);
4686
4687         return dbus_message_new_method_return(msg);
4688 }
4689
4690 static DBusMessage *adapter_start_le_discovery(DBusConnection *conn,
4691                                         DBusMessage *msg, void *user_data)
4692 {
4693         struct btd_adapter *adapter = user_data;
4694         const char *sender = dbus_message_get_sender(msg);
4695         struct discovery_client *client;
4696         GSList *list;
4697
4698         DBG("sender %s", sender);
4699
4700         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4701                 return btd_error_not_ready(msg);
4702
4703         /*
4704          * Every client can only start one discovery, if the client
4705          * already started a discovery then return an error.
4706          */
4707
4708         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4709         DBG("adapter->disc_type[%d]", adapter->disc_type);
4710         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4711
4712         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4713                                                 compare_sender);
4714         if (list)
4715                 return btd_error_busy(msg);
4716
4717         client = g_new0(struct discovery_client, 1);
4718
4719         client->adapter = adapter;
4720         client->owner = g_strdup(sender);
4721         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4722                                                 le_discovery_disconnect, client,
4723                                                 le_discovery_destroy);
4724
4725         adapter->le_discovery_list = g_slist_prepend(adapter->le_discovery_list,
4726                                                                 client);
4727
4728         /*
4729          * Just trigger the discovery here. In case an already running
4730          * discovery in idle phase exists, it will be restarted right
4731          * away.
4732          */
4733         trigger_start_le_discovery(adapter, 0);
4734
4735         return dbus_message_new_method_return(msg);
4736 }
4737
4738 static DBusMessage *adapter_stop_le_discovery(DBusConnection *conn,
4739                                         DBusMessage *msg, void *user_data)
4740 {
4741         struct btd_adapter *adapter = user_data;
4742         const char *sender = dbus_message_get_sender(msg);
4743         struct mgmt_cp_stop_le_discovery cp;
4744         struct discovery_client *client;
4745         GSList *list;
4746
4747         DBG("sender %s", sender);
4748
4749         if (adapter->le_discovery_idle_timeout > 0) {
4750                 DBG("Remove LE scan trigger");
4751                 g_source_remove(adapter->le_discovery_idle_timeout);
4752                 adapter->le_discovery_idle_timeout = 0;
4753         }
4754
4755         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4756                 return btd_error_not_ready(msg);
4757
4758         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4759                                                 compare_sender);
4760         if (!list)
4761                 return btd_error_failed(msg, "No discovery started");
4762
4763         client = list->data;
4764
4765         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4766         DBG("adapter->disc_type[%d]", adapter->disc_type);
4767         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4768
4769         cp.type = adapter->discovery_type;
4770         DBG("cp.type %d", cp.type);
4771
4772         /*
4773          * As long as other discovery clients are still active, just
4774          * clenup client info and return success.
4775          */
4776         DBG("adapter->le_discovery_list %p", adapter->le_discovery_list);
4777         if (g_slist_next(adapter->le_discovery_list)) {
4778                 /*
4779                  * The destroy function will cleanup the client information and
4780                  * also remove it from the list of discovery clients.
4781                  */
4782                 g_dbus_remove_watch(dbus_conn, client->watch);
4783                 return dbus_message_new_method_return(msg);
4784         }
4785
4786         /*
4787          * In the idle phase of a discovery, there is no need to stop it
4788          * and so it is enough to send out the signal and just return.
4789          */
4790         DBG("cp.type %d", cp.type);
4791         DBG("adapter->discovery_enable %d", adapter->discovery_enable);
4792         if (adapter->discovery_enable == 0x00) {
4793                 adapter->le_discovering = false;
4794                 g_dbus_remove_watch(dbus_conn, client->watch);
4795                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
4796                                         ADAPTER_INTERFACE, "LEDiscovering");
4797
4798                 trigger_passive_scanning(adapter);
4799                 return dbus_message_new_method_return(msg);
4800         }
4801
4802         DBG("adapter->discovery_type %d", adapter->discovery_type);
4803         cp.type = 0x06;
4804         DBG("cp.type %d", cp.type);
4805         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
4806                                 adapter->dev_id, sizeof(cp), &cp,
4807                                 stop_le_discovery_complete, adapter, NULL);
4808
4809         client->msg = dbus_message_ref(msg);
4810         return NULL;
4811 }
4812
4813 static DBusMessage *adapter_set_advertising(DBusConnection *conn,
4814                                                 DBusMessage *msg, void *data)
4815 {
4816         struct btd_adapter *adapter = data;
4817         dbus_bool_t err;
4818         dbus_bool_t enable = FALSE;
4819         dbus_int32_t slot_id;
4820
4821         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4822                 return btd_error_not_ready(msg);
4823
4824         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &enable,
4825                                                 DBUS_TYPE_INT32, &slot_id,
4826                                                 DBUS_TYPE_INVALID))
4827                 return btd_error_invalid_args(msg);
4828
4829         if (adapter->adv_restart_timeout && adapter->adv_restart_instance == slot_id) {
4830                 DBG("restart advertising slot_id %d restart is in progress", slot_id);
4831                 return btd_error_in_progress(msg);
4832         }
4833
4834         DBG("%s advertising slot_id %d", enable ? "Enable" : "Disable", slot_id);
4835
4836         if (adapter_le_is_supported_multi_advertising() && slot_id > 0)
4837                 err = adapter_le_enable_multi_adv(adapter, enable, slot_id);
4838         else
4839                 err = set_mode(adapter, MGMT_OP_SET_ADVERTISING, enable);
4840
4841         if (!err)
4842                 return btd_error_failed(msg, "Set Advertising failed");
4843
4844         if (enable)
4845                 create_advertiser(adapter, slot_id);
4846
4847         if (err && slot_id > 0)
4848                 advertising_state_changed(adapter, slot_id, enable);
4849
4850         return dbus_message_new_method_return(msg);
4851 }
4852
4853 static DBusMessage *adapter_set_advertising_params(DBusConnection *conn,
4854                                                 DBusMessage *msg, void *data)
4855 {
4856         struct btd_adapter *adapter = data;
4857         struct mgmt_cp_set_advertising_params cp;
4858         dbus_uint32_t interval_min;
4859         dbus_uint32_t interval_max;
4860         dbus_uint32_t filter_policy;
4861         dbus_uint32_t type;
4862         dbus_int32_t tx_power_level;
4863         dbus_int32_t slot_id;
4864         gboolean ret;
4865
4866         DBG("Set customised advertising parameters");
4867
4868         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4869                 return btd_error_not_ready(msg);
4870
4871         if (!dbus_message_get_args(msg, NULL,
4872                                 DBUS_TYPE_UINT32, &interval_min,
4873                                 DBUS_TYPE_UINT32, &interval_max,
4874                                 DBUS_TYPE_UINT32, &filter_policy,
4875                                 DBUS_TYPE_UINT32, &type,
4876                                 DBUS_TYPE_INT32, &tx_power_level,
4877                                 DBUS_TYPE_INT32, &slot_id,
4878                                 DBUS_TYPE_INVALID))
4879                 return btd_error_invalid_args(msg);
4880
4881         memset(&cp, 0, sizeof(cp));
4882
4883         DBG("advertising interval min %x, max %x, filter %x type %x, tx power %d",
4884                                 interval_min, interval_max, filter_policy, type, tx_power_level);
4885
4886         if (filter_policy > 0x03)
4887                 return btd_error_invalid_args(msg);
4888
4889         if (type > 0x04)
4890                 return btd_error_invalid_args(msg);
4891
4892         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4893                 adapter_le_adv_inst_info_t *p_inst;
4894                 adapter_le_adv_param_t *p_params;
4895
4896                 p_inst = g_malloc0(sizeof(adapter_le_adv_inst_info_t));
4897                 p_params = g_malloc0(sizeof(adapter_le_adv_param_t));
4898                 p_inst->inst_id = slot_id;
4899                 p_params->adv_int_min = interval_min;
4900                 p_params->adv_int_max = interval_max;
4901                 p_params->adv_type = type;
4902                 p_params->channel_map = 0x07;   /* fixed channel :: will be used all */
4903                 p_params->adv_filter_policy = filter_policy;
4904                 p_params->tx_power = tx_power_level;
4905
4906                 if (adapter->current_settings & MGMT_SETTING_PRIVACY) {
4907                         p_inst->bdaddr_type = 0x01;
4908                         bacpy(&p_inst->bdaddr, &adapter->rpa);
4909                 } else if (adapter->le_static_addr.b[5] != 0) {
4910                         p_inst->bdaddr_type = 0x01;
4911                         bacpy(&p_inst->bdaddr, &adapter->le_static_addr);
4912                 } else {
4913                         p_inst->bdaddr_type = 0x00;
4914                         bacpy(&p_inst->bdaddr, &adapter->bdaddr);
4915                 }
4916
4917                 ret = adapter_le_set_multi_adv_params(p_inst, p_params);
4918
4919                 g_free(p_inst);
4920                 g_free(p_params);
4921
4922                 if (ret)
4923                         return dbus_message_new_method_return(msg);
4924                 else
4925                         return btd_error_failed(msg, "set advertising param failed");
4926         } else {
4927                 cp.interval_max = interval_max;
4928                 cp.interval_min = interval_min;
4929                 cp.filter_policy = filter_policy;
4930                 cp.type = type;
4931
4932                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_PARAMS,
4933                                         adapter->dev_id, sizeof(cp), &cp,
4934                                         NULL, NULL, NULL) > 0)
4935                         return dbus_message_new_method_return(msg);
4936
4937                 return btd_error_failed(msg, "set advertising param failed");
4938         }
4939 }
4940
4941 static DBusMessage *adapter_set_advertising_data(DBusConnection *conn,
4942                                                 DBusMessage *msg, void *data)
4943 {
4944         struct btd_adapter *adapter = data;
4945         struct mgmt_cp_set_advertising_data cp;
4946         uint8_t *value;
4947         int32_t len = 0;
4948         dbus_int32_t slot_id;
4949         uint8_t *adv_data = NULL;
4950         int adv_len = 0;
4951         char *adapter_name = adapter->name;
4952         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
4953
4954         DBG("Set advertising data");
4955
4956         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4957                 return btd_error_not_ready(msg);
4958
4959         if (!dbus_message_get_args(msg, NULL,
4960                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4961                         DBUS_TYPE_INT32, &slot_id,
4962                         DBUS_TYPE_INVALID))
4963                 return btd_error_invalid_args(msg);
4964
4965         if (is_set_adv_data_flag(value, len)) {
4966                 if (len > ADV_DATA_MAX_LENGTH)
4967                         return btd_error_invalid_args(msg);
4968         } else {
4969                 if (len > ADV_DATA_MAX_LENGTH - 3)
4970                         return btd_error_invalid_args(msg);
4971         }
4972
4973         if (adapter->le_static_addr.b[5] != 0) {
4974                 char *ptr = NULL;
4975
4976                 g_strlcpy(le_name, adapter_name,
4977                                 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
4978                 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
4979                         *ptr = '\0';
4980
4981                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
4982                 adapter_name = le_name;
4983         }
4984
4985         adapter_le_set_missed_adv_data(value, len, FALSE,
4986                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
4987
4988         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4989                 if (adapter_le_set_multi_adv_data(slot_id, FALSE, adv_len, adv_data)) {
4990                         g_free(adv_data);
4991                         return dbus_message_new_method_return(msg);
4992                 } else {
4993                         g_free(adv_data);
4994                         return btd_error_failed(msg, "set advertising data failed");
4995                 }
4996         } else {
4997                 memcpy(&cp, adv_data, adv_len);
4998
4999                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_DATA,
5000                                                 adapter->dev_id, adv_len,
5001                                                 &cp, NULL, NULL, NULL) > 0) {
5002                         g_free(adv_data);
5003                         return dbus_message_new_method_return(msg);
5004                 }
5005
5006                 g_free(adv_data);
5007                 return btd_error_failed(msg, "set advertising data failed");
5008         }
5009 }
5010
5011 static DBusMessage *adapter_le_scan_filter_param_setup(DBusConnection *conn,
5012                                                 DBusMessage *msg, void *data)
5013 {
5014         struct btd_adapter *adapter = data;
5015 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5016         dbus_bool_t ctlr_filter_support = TRUE;
5017 #endif
5018         dbus_int32_t client_if, action, filt_index;
5019         dbus_int32_t feat_seln, list_logic_type, filt_logic_type;
5020         dbus_int32_t rssi_high_thres, rssi_low_thres, dely_mode;
5021         dbus_int32_t found_timeout, lost_timeout, found_timeout_cnt;
5022         adapter_le_scan_filter_param_t params;
5023         gboolean err;
5024
5025         DBG("adapter_le_scan_filter_param_setup");
5026
5027         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5028                 return btd_error_not_ready(msg);
5029
5030         if (adapter_le_get_scan_filter_size() == 0)
5031 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5032                 return btd_error_not_supported(msg);
5033 #else
5034                 ctlr_filter_support = FALSE;
5035 #endif
5036
5037         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5038                                                 DBUS_TYPE_INT32, &action,
5039                                                 DBUS_TYPE_INT32, &filt_index,
5040                                                 DBUS_TYPE_INT32, &feat_seln,
5041                                                 DBUS_TYPE_INT32, &list_logic_type,
5042                                                 DBUS_TYPE_INT32, &filt_logic_type,
5043                                                 DBUS_TYPE_INT32, &rssi_high_thres,
5044                                                 DBUS_TYPE_INT32, &rssi_low_thres,
5045                                                 DBUS_TYPE_INT32, &dely_mode,
5046                                                 DBUS_TYPE_INT32, &found_timeout,
5047                                                 DBUS_TYPE_INT32, &lost_timeout,
5048                                                 DBUS_TYPE_INT32, &found_timeout_cnt,
5049                                                 DBUS_TYPE_INVALID))
5050                 return btd_error_invalid_args(msg);
5051
5052         memset(&params, 0, sizeof(params));
5053
5054         params.action = action;
5055         params.index = filt_index;
5056         params.feature = feat_seln;
5057         params.filter_logic_type = filt_logic_type;
5058         params.list_logic_type = list_logic_type;
5059         params.delivery_mode = dely_mode;
5060         params.rssi_high_threshold = rssi_high_thres;
5061
5062         if (params.delivery_mode == ON_FOUND) {
5063                 params.rssi_low_threshold = rssi_low_thres;
5064                 params.onfound_timeout = found_timeout;
5065                 params.onfound_timeout_cnt = found_timeout_cnt;
5066                 params.onlost_timeout = lost_timeout;
5067         }
5068
5069 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5070         if (ctlr_filter_support)
5071 #endif
5072         err = adapter_le_set_scan_filter_params(&params);
5073 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5074         else
5075                 err = adapter_le_set_platform_scan_filter_params(adapter, &params);
5076 #endif
5077
5078         if (!err)
5079                 return btd_error_failed(msg, "Failed to scan filter param setup");
5080
5081         return dbus_message_new_method_return(msg);
5082 }
5083
5084 static DBusMessage *adapter_le_scan_filter_add_remove(DBusConnection *conn,
5085                                                 DBusMessage *msg, void *data)
5086 {
5087         struct btd_adapter *adapter = data;
5088         struct btd_device *dev = NULL;
5089         dbus_int32_t client_if, action, filt_type, filt_index;
5090         dbus_int32_t company_id, company_id_mask;
5091         gchar *str = NULL;
5092         dbus_uint32_t address_type = 0;
5093         uint8_t addr_type = 0;
5094         GSList *list;
5095         char string[30];
5096         uint8_t *p_uuid, *p_uuid_mask, *p_data, *p_mask;
5097         int32_t uuid_len = 0, uuid_mask_len = 0, data_len = 0, mask_len = 0;
5098         gboolean err;
5099 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5100         dbus_bool_t ctlr_filter_support = TRUE;
5101 #endif
5102
5103         DBG("adapter_le_scan_filter_add_remove");
5104
5105         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5106                 return btd_error_not_ready(msg);
5107
5108         /* if controller does not support vendor specific scan filtering feature
5109          * then add the filter into platform supported scan filters.
5110          */
5111         if (adapter_le_get_scan_filter_size() == 0) {
5112 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5113                 return btd_error_not_supported(msg);
5114 #else
5115                 ctlr_filter_support = FALSE;
5116 #endif
5117         }
5118
5119         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5120                                                 DBUS_TYPE_INT32, &action,
5121                                                 DBUS_TYPE_INT32, &filt_type,
5122                                                 DBUS_TYPE_INT32, &filt_index,
5123                                                 DBUS_TYPE_INT32, &company_id,
5124                                                 DBUS_TYPE_INT32, &company_id_mask,
5125                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid, &uuid_len,
5126                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid_mask, &uuid_mask_len,
5127                                                 DBUS_TYPE_STRING, &str,
5128                                                 DBUS_TYPE_UINT32, &address_type,
5129                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_data, &data_len,
5130                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_mask, &mask_len,
5131                                                 DBUS_TYPE_INVALID))
5132                 return btd_error_invalid_args(msg);
5133
5134         if (filt_type == TYPE_DEVICE_ADDRESS) {
5135                 list = g_slist_find_custom(adapter->devices, str, device_rpa_cmp);
5136                 if (!list)
5137                         list = g_slist_find_custom(adapter->devices, str,
5138                                                                 device_address_cmp);
5139                 if (list)
5140                         dev = list->data;
5141                 if (dev && device_get_rpa_exist(dev) == true) {
5142                         ba2str(device_get_address(dev), string);
5143                         if (btd_device_get_bdaddr_type(dev) == BDADDR_LE_PUBLIC)
5144                                 addr_type = 0x00;
5145                         else
5146                                 addr_type = 0x01;
5147                 } else {
5148                         strncpy(string, str, sizeof(string) - 1);
5149                         addr_type = 0x00;
5150                 }
5151
5152                 DBG("addr %s, type %d", string, addr_type);
5153         } else {
5154                 strncpy(string, str, sizeof(string) - 1 );
5155         }
5156
5157 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5158         if (ctlr_filter_support)
5159 #endif
5160         err = adapter_le_set_scan_filter_data(client_if, action, filt_type,
5161                         filt_index, company_id, company_id_mask,
5162                         uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
5163                         string, addr_type, data_len, p_data, mask_len, p_mask);
5164 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5165         else
5166                 err = adapter_le_set_platform_scan_filter_data(adapter, client_if, action, filt_type,
5167                                 filt_index, company_id, company_id_mask,
5168                                 uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
5169                                 string, addr_type, data_len, p_data, mask_len, p_mask);
5170 #endif
5171         if (!err)
5172                 return btd_error_failed(msg, "Failed to add/remove filter");
5173
5174         return dbus_message_new_method_return(msg);
5175 }
5176
5177 static DBusMessage *adapter_le_scan_filter_clear(DBusConnection *conn,
5178                                                 DBusMessage *msg, void *data)
5179 {
5180         struct btd_adapter *adapter = data;
5181         dbus_int32_t client_if = 0;
5182         dbus_int32_t filt_index = 0;
5183         gboolean err;
5184 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5185         dbus_bool_t ctlr_filter_support = TRUE;
5186 #endif
5187
5188         DBG("adapter_le_scan_filter_clear");
5189
5190         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5191                 return btd_error_not_ready(msg);
5192
5193         if (adapter_le_get_scan_filter_size() == 0)
5194 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5195                 return btd_error_not_supported(msg);
5196 #else
5197                 ctlr_filter_support = FALSE;
5198 #endif
5199
5200         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5201                                                 DBUS_TYPE_INT32, &filt_index,
5202                                                 DBUS_TYPE_INVALID))
5203                 return btd_error_invalid_args(msg);
5204
5205 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5206         if (ctlr_filter_support)
5207 #endif
5208         err = adapter_le_clear_scan_filter_data(client_if, filt_index);
5209 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5210         else
5211                 err = adapter_le_clear_platform_scan_filter_data(adapter, filt_index);
5212 #endif
5213
5214         if (!err)
5215                 return btd_error_failed(msg, "Failed to clear filter");
5216
5217         return dbus_message_new_method_return(msg);
5218 }
5219
5220
5221 static DBusMessage *adapter_le_scan_filter_enable(DBusConnection *conn,
5222                                                 DBusMessage *msg, void *data)
5223 {
5224         struct btd_adapter *adapter = data;
5225         dbus_bool_t enable = FALSE;
5226         dbus_int32_t client_if = 0;
5227         gboolean err;
5228 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5229         dbus_bool_t ctlr_filter_support = TRUE;
5230 #endif
5231
5232         DBG("adapter_le_scan_filter_enable");
5233
5234         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5235                 return btd_error_not_ready(msg);
5236
5237 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5238         /* if controller does not support vendor specific scan filtering feature
5239          * then enable platform supported scan filtering functionalites.
5240          */
5241 #endif
5242         if (adapter_le_get_scan_filter_size() == 0)
5243 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5244                 return btd_error_not_supported(msg);
5245 #else
5246                 ctlr_filter_support = FALSE;
5247 #endif
5248
5249         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
5250                                                 DBUS_TYPE_BOOLEAN, &enable,
5251                                                 DBUS_TYPE_INVALID))
5252                 return btd_error_invalid_args(msg);
5253
5254 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5255         if (ctlr_filter_support)
5256 #endif
5257         err = adapter_le_enable_scan_filtering(enable);
5258 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5259         else
5260                 err = adapter_le_enable_platform_scan_filtering(adapter, enable);
5261 #endif
5262
5263         if (!err)
5264                 return btd_error_failed(msg, "Failed to enable scan filtering");
5265
5266         return dbus_message_new_method_return(msg);
5267 }
5268
5269 static DBusMessage *adapter_le_set_scan_params(DBusConnection *conn,
5270                                                 DBusMessage *msg, void *data)
5271 {
5272         struct btd_adapter *adapter = data;
5273         struct mgmt_cp_le_set_scan_params cp;
5274         uint32_t type;
5275         uint32_t interval;
5276         uint32_t window;
5277
5278         DBG("Set scan parameters");
5279
5280         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5281                 return btd_error_not_ready(msg);
5282
5283         if (!dbus_message_get_args(msg, NULL,
5284                                 DBUS_TYPE_UINT32, &type,
5285                                 DBUS_TYPE_UINT32, &interval,
5286                                 DBUS_TYPE_UINT32, &window,
5287                                 DBUS_TYPE_INVALID))
5288                 return btd_error_invalid_args(msg);
5289
5290         DBG("scan type %x, interval %x, window %x",
5291                                 type, interval, window);
5292         memset(&cp, 0, sizeof(cp));
5293
5294         cp.type = type;
5295         cp.interval = interval;
5296         cp.window = window;
5297 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
5298         adapter->scan_type = type;
5299 #endif
5300
5301         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_SCAN_PARAMS,
5302                                         adapter->dev_id, sizeof(cp), &cp,
5303                                         NULL, NULL, NULL) > 0)
5304                 return dbus_message_new_method_return(msg);
5305
5306         return btd_error_failed(msg, "set scan parameters failed");
5307 }
5308
5309 static DBusMessage *adapter_set_scan_rsp_data(DBusConnection *conn,
5310                                                 DBusMessage *msg, void *data)
5311 {
5312         struct btd_adapter *adapter = data;
5313         struct mgmt_cp_set_scan_rsp_data cp;
5314         uint8_t *value;
5315         int32_t len = 0;
5316         dbus_int32_t slot_id;
5317         uint8_t *adv_data = NULL;
5318         int adv_len = 0;
5319
5320         char *adapter_name = adapter->name;
5321         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
5322
5323         DBG("Set scan response data");
5324
5325         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5326                 return btd_error_not_ready(msg);
5327
5328         if (!dbus_message_get_args(msg, NULL,
5329                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
5330                         DBUS_TYPE_INT32, &slot_id,
5331                         DBUS_TYPE_INVALID))
5332                 return btd_error_invalid_args(msg);
5333
5334         if (len > SCAN_RESPONSE_DATA_LENGTH_MAX)
5335                 return btd_error_invalid_args(msg);
5336
5337         if (adapter->le_static_addr.b[5] != 0) {
5338                 char *ptr = NULL;
5339
5340                 g_strlcpy(le_name, adapter_name,
5341                                 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
5342                 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
5343                         *ptr = '\0';
5344
5345                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
5346                 adapter_name = le_name;
5347         }
5348
5349         adapter_le_set_missed_adv_data(value, len, TRUE,
5350                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
5351
5352         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
5353                 if (adapter_le_set_multi_adv_data(slot_id, TRUE, adv_len, (uint8_t *)adv_data)) {
5354                         g_free(adv_data);
5355                         return dbus_message_new_method_return(msg);
5356                 } else {
5357                         g_free(adv_data);
5358                         return btd_error_failed(msg, "set advertising data failed");
5359                 }
5360         } else {
5361                 memcpy(&cp, adv_data, adv_len);
5362
5363                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_SCAN_RSP_DATA,
5364                                                 adapter->dev_id, adv_len, &cp,
5365                                                 NULL, NULL, NULL) > 0) {
5366                         g_free(adv_data);
5367                         return dbus_message_new_method_return(msg);
5368                 }
5369
5370                 g_free(adv_data);
5371                 return btd_error_failed(msg, "set scan reponse data failed");
5372         }
5373 }
5374
5375 static DBusMessage *adapter_add_device_white_list(DBusConnection *conn,
5376                                         DBusMessage *msg, void *data)
5377 {
5378         struct btd_adapter *adapter = data;
5379         struct mgmt_cp_add_dev_white_list cp;
5380         const gchar *address;
5381         bdaddr_t bdaddr;
5382         dbus_uint32_t address_type;
5383         struct btd_device *dev;
5384
5385         DBG("Add device whie list");
5386         if (dbus_message_get_args(msg, NULL,
5387                                         DBUS_TYPE_STRING, &address,
5388                                         DBUS_TYPE_UINT32, &address_type,
5389                                         DBUS_TYPE_INVALID) == FALSE)
5390                 return btd_error_invalid_args(msg);
5391
5392         if (bachk(address) < 0)
5393                 return btd_error_invalid_args(msg);
5394
5395         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5396                 return btd_error_not_ready(msg);
5397
5398         DBG("addr %s, type %d", address, address_type);
5399         str2ba(address, &bdaddr);
5400
5401         dev = btd_adapter_find_device(adapter, &bdaddr,
5402                         address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5403         if (dev && device_get_rpa_exist(dev) == true) {
5404                 if (adapter_le_is_supported_offloading() == FALSE) {
5405                         error("Spec based command is not supported yet");
5406                         return btd_error_not_supported(msg);
5407                 }
5408
5409                 /* Add IRK value to list */
5410                 if (adapter_le_add_irk_to_list(device_get_irk_value(dev),
5411                                         device_get_address(dev),
5412                                         btd_device_get_bdaddr_type(dev))) {
5413                         return dbus_message_new_method_return(msg);
5414                 } else {
5415                         return btd_error_failed(msg, "Add LE IRK to list failed");
5416                 }
5417         }
5418
5419         memset(&cp, 0, sizeof(cp));
5420
5421         cp.bdaddr_type = address_type;
5422         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5423
5424         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEV_WHITE_LIST,
5425                                         adapter->dev_id, sizeof(cp), &cp,
5426                                         NULL, NULL, NULL) > 0)
5427                 return dbus_message_new_method_return(msg);
5428
5429         return btd_error_failed(msg, "add device white list failed");
5430 }
5431
5432 static DBusMessage *adapter_remove_device_white_list(DBusConnection *conn,
5433                                         DBusMessage *msg, void *data)
5434 {
5435         struct btd_adapter *adapter = data;
5436         struct mgmt_cp_remove_dev_white_list cp;
5437         const gchar *address;
5438         bdaddr_t bdaddr;
5439         dbus_uint32_t address_type;
5440         struct btd_device *dev;
5441
5442         DBG("Remove device whie list");
5443
5444         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5445                 return btd_error_not_ready(msg);
5446
5447         if (dbus_message_get_args(msg, NULL,
5448                                         DBUS_TYPE_STRING, &address,
5449                                         DBUS_TYPE_UINT32, &address_type,
5450                                         DBUS_TYPE_INVALID) == FALSE)
5451                 return btd_error_invalid_args(msg);
5452
5453         if (bachk(address) < 0)
5454                 return btd_error_invalid_args(msg);
5455
5456         DBG("addr %s, type %d", address, address_type);
5457         str2ba(address, &bdaddr);
5458
5459         dev = btd_adapter_find_device(adapter, &bdaddr,
5460                         address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5461         if (dev && device_get_rpa_exist(dev) == true) {
5462                 if (adapter_le_is_supported_offloading() == FALSE) {
5463                         error("Spec based command is not supported yet");
5464                         return btd_error_not_supported(msg);
5465                 }
5466
5467                 /* Remove IRK value to list */
5468                 if (adapter_le_remove_irk_to_list(device_get_address(dev),
5469                                         btd_device_get_bdaddr_type(dev))) {
5470                         return dbus_message_new_method_return(msg);
5471                 } else {
5472                         return btd_error_failed(msg, "Remove IRK is failed");
5473                 }
5474         }
5475
5476         memset(&cp, 0, sizeof(cp));
5477
5478         cp.bdaddr_type = address_type;
5479         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5480
5481         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEV_FROM_WHITE_LIST,
5482                                         adapter->dev_id, sizeof(cp), &cp,
5483                                         NULL, NULL, NULL) > 0)
5484                 return dbus_message_new_method_return(msg);
5485
5486         return btd_error_failed(msg, "remove device white list failed");
5487 }
5488
5489 static DBusMessage *adapter_clear_device_white_list(DBusConnection *conn,
5490                                         DBusMessage *msg, void *data)
5491 {
5492         struct btd_adapter *adapter = data;
5493
5494         DBG("Clear device whie list");
5495
5496         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5497                 return btd_error_not_ready(msg);
5498
5499         if (mgmt_send(adapter->mgmt, MGMT_OP_CLEAR_DEV_WHITE_LIST,
5500                                         adapter->dev_id, 0, NULL,
5501                                         NULL, NULL, NULL) > 0)
5502                 return dbus_message_new_method_return(msg);
5503
5504         return btd_error_failed(msg, "clear white list failed");
5505 }
5506
5507 static DBusMessage *adapter_set_le_privacy(DBusConnection *conn,
5508                                         DBusMessage *msg, void *data)
5509 {
5510         struct btd_adapter *adapter = data;
5511         dbus_bool_t err;
5512         dbus_bool_t enable_privacy = FALSE;
5513
5514         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
5515                 return btd_error_not_supported(msg);
5516
5517         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
5518                                 &enable_privacy, DBUS_TYPE_INVALID))
5519                 return btd_error_invalid_args(msg);
5520
5521         if (enable_privacy) {
5522                 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
5523                         return btd_error_already_exists(msg);
5524         } else {
5525                 if (!(adapter->current_settings & MGMT_SETTING_PRIVACY))
5526                         return btd_error_already_exists(msg);
5527         }
5528
5529         err = set_privacy(adapter, enable_privacy);
5530
5531         if (!err) {
5532                 return btd_error_failed(msg, "Set Le Privacy failed");
5533         } else {
5534                 if (enable_privacy)
5535                         adapter->current_settings = adapter->current_settings | MGMT_SETTING_PRIVACY;
5536                 else
5537                         adapter->current_settings = adapter->current_settings & ~(SETTING_PRIVACY_MASK);
5538         }
5539
5540         return dbus_message_new_method_return(msg);
5541 }
5542
5543 static void init_le_static_address(struct btd_adapter *adapter)
5544 {
5545         int fd;
5546         int ret;
5547         char address[18];
5548         char dirname[PATH_MAX];
5549         int i;
5550         bdaddr_t le_static_addr;
5551
5552         le_static_addr.b[5] = adapter->bdaddr.b[5] | 0xc0;
5553         for (i = 0; i < 5; i++) {
5554                 le_static_addr.b[i] =
5555                         (adapter->bdaddr.b[i] & 0x7f) << 1 |
5556                         (adapter->bdaddr.b[i] & 0x80) >> 7;
5557         }
5558
5559         /*
5560          * < How to get Public address from above static address >
5561          *
5562          * for (i = 0; i < 5; i++) {
5563          *      bredr_addr.b[i] =
5564          *              (adapter->le_static_addr.b[i] & 0xfe) >> 1 |
5565          *              (adapter->le_static_addr.b[i] & 0x01) << 7;
5566          * }
5567          * bredr_addr.b[5] = {the value from advertising data}
5568          */
5569
5570         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5571         fd = open(dirname, O_WRONLY | O_CREAT, 0644);
5572
5573         if (fd >= 0) {
5574                 ba2str(&le_static_addr, address);
5575                 DBG("LE static random : %s", address);
5576                 ret = write(fd, address, strlen(address));
5577                 if (ret < 0) {
5578                         error("Cannot save LE address : %s",
5579                                         strerror(errno));
5580                 }
5581
5582                 ret = fdatasync(fd);
5583                 if (ret < 0)
5584                         error("sync failed : %s", strerror(errno));
5585
5586                 close(fd);
5587         } else {
5588                 error("Cannot save LE address");
5589         }
5590 }
5591
5592 static void set_le_static_address(struct btd_adapter *adapter)
5593 {
5594         int fd;
5595         int ret;
5596         char address[18];
5597         char dirname[PATH_MAX];
5598
5599         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5600         if (access(dirname, F_OK) < 0)
5601                 init_le_static_address(adapter);
5602
5603         fd = open(dirname, O_RDONLY);
5604         if (fd >= 0) {
5605                 ret = read(fd, address, sizeof(address));
5606                 if (ret >= 17) {
5607                         /* xx:xx:xx:xx:xx:xx */
5608                         address[17] = '\0';
5609                         DBG("LE static random : %s", address);
5610                         str2ba(address, &adapter->le_static_addr);
5611                         adapter->le_static_addr.b[5] |= 0xc0;
5612                 } else
5613                         error("Invalid LE address");
5614                 close(fd);
5615         } else {
5616                 error("Cannot get LE address");
5617         }
5618
5619         return;
5620 }
5621
5622 static void set_le_static_address_complete(uint8_t status, uint16_t length,
5623                                         const void *param, void *user_data)
5624 {
5625         struct btd_adapter *adapter = user_data;
5626
5627         DBG("index %u status 0x%02x", adapter->dev_id, status);
5628
5629         if (status != MGMT_STATUS_SUCCESS) {
5630                 error("Failed to set static address for index %u: %s (0x%02x)",
5631                                 adapter->dev_id, mgmt_errstr(status), status);
5632                 if (adapter->le_static_addr.b[5] != 0)
5633                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5634                 else
5635                         set_le_static_address(adapter);
5636                 return;
5637         }
5638
5639         return;
5640 }
5641
5642 static DBusMessage *adapter_set_le_static_address(DBusConnection *conn,
5643                                         DBusMessage *msg, void *data)
5644 {
5645         struct btd_adapter *adapter = data;
5646         dbus_bool_t is_enable = FALSE;
5647         struct mgmt_cp_set_static_address cp;
5648
5649         if (!(adapter->supported_settings & MGMT_OP_SET_STATIC_ADDRESS)) {
5650                 error("LE static address is not supported");
5651                 return btd_error_not_supported(msg);
5652         }
5653
5654         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &is_enable,
5655                                 DBUS_TYPE_INVALID)) {
5656                 error("Invalid arguments");
5657                 return btd_error_invalid_args(msg);
5658         }
5659
5660         memset(&cp, 0x00, sizeof(cp));
5661         if (is_enable)  {
5662                 if (adapter->le_static_addr.b[5] != 0) {
5663                         DBG("LE static address is already configured");
5664                         return dbus_message_new_method_return(msg);
5665                 }
5666                 set_le_static_address(adapter);
5667                 bacpy(&cp.bdaddr, &adapter->le_static_addr);
5668         } else {
5669                 if (adapter->le_static_addr.b[5] == 0) {
5670                         DBG("LE static address is not configured");
5671                         return dbus_message_new_method_return(msg);
5672                 }
5673                 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5674         }
5675         DBG("Set static random address : %d", is_enable);
5676
5677         if (mgmt_send(mgmt_primary, MGMT_OP_SET_STATIC_ADDRESS, adapter->dev_id,
5678                         sizeof(cp), &cp,
5679                         set_le_static_address_complete, adapter, NULL) <= 0) {
5680                 error("Failed to set static address : %d", is_enable);
5681                 if (is_enable)
5682                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5683                 else
5684                         set_le_static_address(adapter);
5685                 return btd_error_failed(msg, "Unable to set static address");
5686         }
5687
5688         return dbus_message_new_method_return(msg);
5689 }
5690
5691 static DBusMessage *adapter_enable_rssi(DBusConnection *conn,
5692                                                 DBusMessage *msg, void *data)
5693 {
5694         struct btd_adapter *adapter = data;
5695         struct mgmt_cp_set_enable_rssi cp;
5696         struct mgmt_cp_disable_rssi cp_dis;
5697         bdaddr_t bt_addr = { { 0, } };
5698         const gchar *address = NULL;
5699
5700         const char *sender = dbus_message_get_sender(msg);
5701         dbus_int32_t link_type;
5702         dbus_int32_t low_threshold;
5703         dbus_int32_t in_range_threshold;
5704         dbus_int32_t high_threshold;
5705
5706         DBG("Enable RSSI called");
5707         DBG("sender %s", sender);
5708         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5709                 return btd_error_not_ready(msg);
5710
5711         if (!dbus_message_get_args(msg, NULL,
5712                                 DBUS_TYPE_STRING, &address,
5713                                 DBUS_TYPE_INT32, &link_type,
5714                                 DBUS_TYPE_INT32, &low_threshold,
5715                                 DBUS_TYPE_INT32, &in_range_threshold,
5716                                 DBUS_TYPE_INT32, &high_threshold,
5717                                 DBUS_TYPE_INVALID))
5718                 return btd_error_invalid_args(msg);
5719
5720         DBG("Enable RSSI: [%s %d %d %d %d]", address, link_type,
5721                         low_threshold, in_range_threshold, high_threshold);
5722
5723         DBG("BT address [%s]", address);
5724         memset(&bt_addr, 0, sizeof(bdaddr_t));
5725         str2ba(address, &bt_addr);
5726         memset(&cp, 0, sizeof(struct mgmt_cp_set_enable_rssi));
5727         memset(&cp_dis, 0, sizeof(struct mgmt_cp_disable_rssi));
5728
5729         if (bachk(address) < 0)
5730                 return btd_error_invalid_args(msg);
5731
5732 //      if (!btd_adapter_find_device(adapter, address))
5733 //              return btd_error_not_found(msg);
5734
5735         if (low_threshold == 0 && in_range_threshold == 0 && high_threshold == 0) {
5736                 cp_dis.bdaddr = bt_addr;
5737                 cp_dis.link_type = link_type;
5738                 DBG("Disable Request");
5739                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_DISABLE,
5740                                         adapter->dev_id, sizeof(cp_dis), &cp_dis,
5741                                         NULL, NULL, NULL) > 0)
5742                                         return dbus_message_new_method_return(msg);
5743         } else {
5744                 cp.low_th = low_threshold;
5745                 cp.in_range_th = in_range_threshold;
5746                 cp.high_th = high_threshold;
5747                 cp.bdaddr = bt_addr;
5748                 cp.link_type = link_type;
5749                 DBG("Enable Request");
5750                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_ENABLE,
5751                                         adapter->dev_id, sizeof(cp), &cp,
5752                                         NULL, NULL, NULL) > 0)
5753                         return dbus_message_new_method_return(msg);
5754         }
5755         return btd_error_failed(msg, "Enable/Disable RSSI Failed");
5756 }
5757
5758 static DBusMessage *adapter_get_rssi(DBusConnection *conn,
5759                                                 DBusMessage *msg, void *data)
5760 {
5761         struct btd_adapter *adapter = data;
5762         struct mgmt_cp_get_raw_rssi cp;
5763         bdaddr_t bt_addr;
5764         const gchar *address = NULL;
5765         dbus_int32_t link_type;
5766         const char *sender = dbus_message_get_sender(msg);
5767
5768         DBG("Get RSSI called");
5769         DBG("sender %s", sender);
5770         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5771                 return btd_error_not_ready(msg);
5772
5773         if (!dbus_message_get_args(msg, NULL,
5774                                 DBUS_TYPE_STRING, &address,
5775                                 DBUS_TYPE_INT32, &link_type,
5776                                 DBUS_TYPE_INVALID))
5777                 return btd_error_invalid_args(msg);
5778
5779         DBG("BT address [%s] link type [%d]", address, link_type);
5780         memset(&bt_addr, 0, sizeof(bdaddr_t));
5781         str2ba(address, &bt_addr);
5782         memset(&cp, 0, sizeof(struct mgmt_cp_get_raw_rssi));
5783
5784         if (bachk(address) < 0)
5785                 return btd_error_invalid_args(msg);
5786
5787 //      if (!btd_adapter_find_device(adapter, address))
5788 //              return btd_error_not_found(msg);
5789
5790         memcpy(&(cp.bt_address), &bt_addr, sizeof(bdaddr_t));
5791         cp.link_type = link_type;
5792         DBG("RAW RSSI Request");
5793         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_RAW_RSSI,
5794                                         adapter->dev_id, sizeof(cp), &cp,
5795                                         NULL, NULL, NULL) > 0)
5796                         return dbus_message_new_method_return(msg);
5797
5798         return btd_error_failed(msg, "Get Raw RSSI Failed");
5799 }
5800
5801 static DBusMessage *get_irk(DBusMessage *msg, uint8_t *irk_info,
5802                                                 uint16_t irk_size)
5803 {
5804         DBusMessage *reply;
5805         DBusMessageIter iter, array;
5806         reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
5807
5808         dbus_message_iter_init_append(reply, &iter);
5809         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "y", &array);
5810         dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
5811                                                 &irk_info, irk_size);
5812         dbus_message_iter_close_container(&iter, &array);
5813
5814         return reply;
5815 }
5816
5817
5818 static DBusMessage *adapter_get_local_irk(DBusConnection *conn,
5819                                                 DBusMessage *msg, void *data)
5820 {
5821         struct btd_adapter *adapter = data;
5822         if (!adapter->local_irk) {
5823                 if (!load_local_irk(adapter))
5824                         return g_dbus_create_error(msg, DBUS_ERROR_NO_MEMORY, "No Memory");
5825         }
5826         return get_irk(msg, adapter->local_irk, MGMT_IRK_SIZE);
5827 }
5828
5829 #if !defined(__SPRD_PATCH__)
5830 static void get_adv_tx_power_complete(uint8_t status, uint16_t length,
5831                                         const void *param, void *user_data)
5832 {
5833         struct btd_adapter *adapter = user_data;
5834         const struct mgmt_rp_get_adv_tx_power *rp = param;
5835
5836         if (!rp) {
5837                 error("Error ocurred in Getting adv tx power, rp is NULL");
5838                 return;
5839         }
5840
5841         if (status != MGMT_STATUS_SUCCESS) {
5842                 error("Failed to get adv tx power: %s (0x%02x)",
5843                                                 mgmt_errstr(status), status);
5844                 return;
5845         }
5846
5847         if (length < sizeof(*rp)) {
5848                 error("Wrong size of get adv tx power");
5849                 return;
5850         }
5851
5852         adapter->adv_tx_power = rp->adv_tx_power;
5853         return;
5854 }
5855
5856 static  void adapter_get_adv_tx_power(void *data)
5857 {
5858         struct btd_adapter *adapter = data;
5859
5860         mgmt_send(adapter->mgmt, MGMT_OP_GET_ADV_TX_POWER,
5861                                         adapter->dev_id, 0, NULL,
5862                                         get_adv_tx_power_complete, adapter, NULL);
5863         return;
5864 }
5865 #endif
5866
5867 static DBusMessage *set_wbs_parameters(DBusConnection *conn,
5868                                 DBusMessage *msg, void *data)
5869 {
5870         struct btd_adapter *adapter = data;
5871         const gchar *role = NULL;
5872         const gchar *address = NULL;
5873         struct mgmt_cp_set_voice_setting cp;
5874         bdaddr_t bt_addr = { { 0, } };
5875
5876         DBG("+");
5877
5878         if (!dbus_message_get_args(msg, NULL,
5879                                 DBUS_TYPE_STRING, &role,
5880                                 DBUS_TYPE_STRING, &address,
5881                                 DBUS_TYPE_INVALID)) {
5882                 return btd_error_invalid_args(msg);
5883         }
5884
5885         DBG("Role = %s", role);
5886         DBG("Address = %s", address);
5887
5888         memset(&cp, 0, sizeof(cp));
5889
5890         cp.voice_setting = BT_VOICE_TRANSPARENT | BT_VOICE_CVSD_16BIT;
5891
5892         if (g_strcmp0(role, "Handsfree") == 0)
5893                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5894         else if (g_strcmp0(role, "Gateway") == 0)
5895                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5896
5897         str2ba(address, &bt_addr);
5898         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5899
5900         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5901                                 adapter->dev_id, sizeof(cp), &cp,
5902                                 NULL, NULL, NULL) == 0)
5903                 error("mgmt_send failed for voice setting");
5904
5905         DBG("-");
5906         return dbus_message_new_method_return(msg);
5907 }
5908
5909 static DBusMessage *set_nb_parameters(DBusConnection *conn,
5910                                 DBusMessage *msg, void *data)
5911 {
5912         struct btd_adapter *adapter = data;
5913         const gchar *role;
5914         const gchar *address = NULL;
5915         struct mgmt_cp_set_voice_setting cp;
5916         bdaddr_t bt_addr = { { 0, } };
5917
5918         DBG("+");
5919
5920         if (!dbus_message_get_args(msg, NULL,
5921                                 DBUS_TYPE_STRING, &role,
5922                                 DBUS_TYPE_STRING, &address,
5923                                 DBUS_TYPE_INVALID)) {
5924                 return btd_error_invalid_args(msg);
5925         }
5926
5927         DBG("Role = %s", role);
5928         DBG("Address = %s", address);
5929
5930         memset(&cp, 0, sizeof(cp));
5931
5932         cp.voice_setting = BT_VOICE_CVSD_16BIT;
5933
5934         if (g_strcmp0(role, "Handsfree") == 0)
5935                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5936         else if (g_strcmp0(role, "Gateway") == 0)
5937                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5938
5939         str2ba(address, &bt_addr);
5940         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5941
5942         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5943                                 adapter->dev_id, sizeof(cp), &cp,
5944                                 NULL, NULL, NULL) == 0)
5945                 error("mgmt_send failed for voice setting");
5946
5947         DBG("-");
5948
5949         return dbus_message_new_method_return(msg);
5950 }
5951
5952 void btd_adapter_set_read_le_data_length_handler(
5953                         struct btd_adapter *adapter,
5954                         struct le_data_length_read_handler *handler)
5955 {
5956         adapter->read_handler = handler;
5957 }
5958
5959 static void le_read_maximum_data_length_return_param_complete(
5960                         uint8_t status, uint16_t length,
5961                         const void *param, void *user_data)
5962 {
5963         struct btd_adapter *adapter = user_data;
5964         const struct mgmt_rp_le_read_maximum_data_length *rp = param;
5965         uint16_t max_tx_octects = 0;
5966         uint16_t max_tx_time = 0;
5967         uint16_t max_rx_octects = 0;
5968         uint16_t max_rx_time = 0;
5969         int err = 0;
5970
5971         if (!rp) {
5972                 error("Error ocurred in Reading maximum data length, rp is NULL");
5973                 err = -EIO;
5974                 goto done;
5975         }
5976
5977         if (status != MGMT_STATUS_SUCCESS) {
5978                 error("le read maximum data length failed: %s (0x%02x)",
5979                         mgmt_errstr(status), status);
5980                 err = -EIO;
5981                 goto done;
5982         }
5983
5984         if (length < sizeof(*rp)) {
5985                 error("Too small le read maximum data length response");
5986                 err = -EIO;
5987                 goto done;
5988         } else {
5989                 max_tx_octects = rp->max_tx_octets;
5990                 max_tx_time =rp->max_tx_time;
5991                 max_rx_octects = rp->max_rx_octets;
5992                 max_rx_time = rp->max_rx_time;
5993         }
5994
5995 done:
5996         if (!adapter->read_handler ||
5997                 !adapter->read_handler->read_callback) {
5998                 g_free(adapter->read_handler);
5999                 return;
6000         }
6001
6002         adapter->read_handler->read_callback(adapter, err,
6003                         max_tx_octects, max_tx_time,
6004                         max_rx_octects, max_rx_time,
6005                         adapter->read_handler->user_data);
6006
6007         g_free(adapter->read_handler);
6008         adapter->read_handler = NULL;
6009 }
6010
6011 int btd_adapter_le_read_maximum_data_length(
6012         struct btd_adapter *adapter)
6013 {
6014         if (mgmt_send(adapter->mgmt,
6015                          MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
6016                          adapter->dev_id, 0, NULL,
6017                          le_read_maximum_data_length_return_param_complete,
6018                          adapter, NULL) > 0)
6019                 return 0;
6020
6021         return -EIO;
6022 }
6023
6024 static gint read_request_cmp(gconstpointer a, gconstpointer b)
6025 {
6026         const struct le_data_length_read_request *data = a;
6027         const struct btd_adapter *adapter = b;
6028
6029         return data->adapter !=  adapter;
6030 }
6031
6032 static struct le_data_length_read_request *find_read_le_data_length_request(
6033         struct btd_adapter *adapter)
6034 {
6035         GSList *match;
6036
6037         match = g_slist_find_custom(read_requests, adapter, read_request_cmp);
6038
6039         if (match)
6040                 return match->data;
6041
6042         return NULL;
6043 }
6044
6045 static void le_read_data_length_complete(
6046                         struct btd_adapter *adapter,
6047                         int err,
6048                         uint16_t max_tx_octects, uint16_t max_tx_time,
6049                         uint16_t max_rx_octects, uint16_t max_rx_time,
6050                         void *user_data)
6051 {
6052         DBusMessage *reply;
6053         struct le_data_length_read_request *read_request;
6054
6055         read_request = find_read_le_data_length_request(adapter);
6056
6057         if (!read_request)
6058                 return;
6059
6060         if (err) {
6061                 DBG("Failed to read max data length. errno[%d]", err);
6062                 reply = btd_error_failed(read_request->msg,
6063                                         "Failed to read max data length");
6064         } else {
6065                 reply = g_dbus_create_reply(read_request->msg,
6066                                         DBUS_TYPE_UINT16, &max_tx_octects,
6067                                         DBUS_TYPE_UINT16, &max_tx_time,
6068                                         DBUS_TYPE_UINT16, &max_rx_octects,
6069                                         DBUS_TYPE_UINT16, &max_rx_time,
6070                                         DBUS_TYPE_INVALID);
6071
6072                 if (!reply) {
6073                         reply = btd_error_failed(read_request->msg,
6074                                                 "Failed to create reply.");
6075                 }
6076         }
6077
6078         read_requests = g_slist_remove(read_requests, read_request);
6079         dbus_message_unref(read_request->msg);
6080         g_free(read_request);
6081
6082         if (!g_dbus_send_message(dbus_conn, reply))
6083                 error("D-Bus send failed");
6084 }
6085
6086 static DBusMessage *le_read_maximum_data_length(
6087                         DBusConnection *conn, DBusMessage *msg,
6088                         void *user_data)
6089 {
6090         struct btd_adapter *adapter = user_data;
6091         struct le_data_length_read_request *read_request;
6092         struct le_data_length_read_handler *handler;
6093
6094         if (find_read_le_data_length_request(adapter))
6095                 return btd_error_in_progress(msg);
6096
6097         if (btd_adapter_le_read_maximum_data_length(adapter))
6098                 return btd_error_failed(msg, "Unable to read maximum le data length");
6099
6100         read_request = g_new(struct le_data_length_read_request, 1);
6101
6102         read_request->msg = dbus_message_ref(msg);
6103         read_request->adapter = adapter;
6104
6105         read_requests = g_slist_append(read_requests, read_request);
6106
6107         handler = g_new0(struct le_data_length_read_handler, 1);
6108
6109         handler->read_callback =
6110                 (read_max_data_length_cb_t)le_read_data_length_complete;
6111
6112         btd_adapter_set_read_le_data_length_handler(
6113                         read_request->adapter, handler);
6114
6115         return NULL;
6116
6117 }
6118
6119 void le_write_host_suggested_data_length_return_param_complete(
6120                         uint8_t status, uint16_t length,
6121                         const void *param, void *user_data)
6122 {
6123         if (status != MGMT_STATUS_SUCCESS) {
6124                 error("le write host suggested data length failed: %s (0x%02x)",
6125                         mgmt_errstr(status), status);
6126         }
6127
6128         return;
6129 }
6130
6131 static DBusMessage *le_write_host_suggested_default_data_length(
6132                         DBusConnection *conn, DBusMessage *msg,
6133                         void *user_data)
6134 {
6135         struct btd_adapter *adapter = user_data;
6136         struct mgmt_cp_le_write_host_suggested_data_length cp;
6137         dbus_uint16_t def_tx_Octets;
6138         dbus_uint16_t def_tx_time;
6139
6140         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6141                 return btd_error_not_ready(msg);
6142
6143         if (!dbus_message_get_args(msg, NULL,
6144                                         DBUS_TYPE_UINT16, &def_tx_Octets,
6145                                         DBUS_TYPE_UINT16, &def_tx_time,
6146                                         DBUS_TYPE_INVALID))
6147                 return btd_error_invalid_args(msg);
6148
6149         memset(&cp, 0, sizeof(cp));
6150         cp.def_tx_octets = def_tx_Octets;
6151         cp.def_tx_time = def_tx_time;
6152
6153         if (mgmt_send(adapter->mgmt,
6154                          MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
6155                          adapter->dev_id, sizeof(cp), &cp,
6156                          le_write_host_suggested_data_length_return_param_complete,
6157                          adapter, NULL) > 0)
6158                 return dbus_message_new_method_return(msg);
6159
6160         return btd_error_failed(msg, "Unable to write host suggested le data length values");
6161 }
6162
6163 static void le_read_suggested_default_data_length_return_param_complete(
6164                         uint8_t status, uint16_t length,
6165                         const void *param, void *user_data)
6166 {
6167         struct btd_adapter *adapter = user_data;
6168         const struct mgmt_rp_le_read_host_suggested_data_length *rp = param;
6169         uint16_t def_tx_octects, def_tx_time;
6170
6171         if (!rp) {
6172                 error("Error ocurred in Reading suggested data length, rp is NULL");
6173                 if (adapter->def_read_handler)
6174                         g_free(adapter->def_read_handler->user_data);
6175
6176                 g_free(adapter->def_read_handler);
6177                 return;
6178         }
6179
6180         if (status != MGMT_STATUS_SUCCESS) {
6181                 error("Read host suggested def le data length values failed: %s (0x%02x)",
6182                         mgmt_errstr(status), status);
6183                 def_tx_octects = 0;
6184                 def_tx_time =0;
6185
6186                 if (adapter->def_read_handler)
6187                         g_free(adapter->def_read_handler->user_data);
6188
6189                 g_free(adapter->def_read_handler);
6190                 return;
6191         }
6192
6193         if (length < sizeof(*rp)) {
6194                 goto done;
6195         } else {
6196                 def_tx_octects = rp->def_tx_octets;
6197                 def_tx_time =rp->def_tx_time;
6198                 DBG("retrieving host suggested data length values %d %d", def_tx_octects, def_tx_time);
6199         }
6200
6201         if (!adapter->def_read_handler)
6202                 return;
6203
6204         if(!adapter->def_read_handler->read_callback) {
6205                 goto done;
6206         }
6207
6208         adapter->def_read_handler->read_callback(adapter,
6209                         def_tx_octects, def_tx_time,
6210                         adapter->def_read_handler->user_data);
6211 done:
6212         if (adapter->def_read_handler)
6213                 g_free(adapter->def_read_handler->user_data);
6214
6215         g_free(adapter->def_read_handler);
6216         adapter->def_read_handler = NULL;
6217 }
6218
6219 int btd_adapter_le_read_suggested_default_data_length(
6220         struct btd_adapter *adapter)
6221 {
6222         if (mgmt_send(adapter->mgmt,
6223                          MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
6224                          adapter->dev_id, 0, NULL,
6225                          le_read_suggested_default_data_length_return_param_complete,
6226                          adapter, NULL) > 0) {
6227                 return 0;
6228         }
6229
6230         return -EIO;
6231 }
6232
6233 static void le_read_host_suggested_default_length_complete(
6234                         struct btd_adapter *adapter,
6235                         uint16_t def_tx_octects, uint16_t def_tx_time,
6236                         void *user_data)
6237 {
6238         DBusMessage *reply;
6239         struct le_data_length_read_request *read_request;
6240
6241         read_request = find_read_le_data_length_request(adapter);
6242         if (!read_request)
6243                 return;
6244
6245         reply = g_dbus_create_reply(read_request->msg,
6246                         DBUS_TYPE_UINT16, &def_tx_octects,
6247                         DBUS_TYPE_UINT16, &def_tx_time,
6248                         DBUS_TYPE_INVALID);
6249
6250         if (!reply) {
6251                 btd_error_failed(read_request->msg,
6252                         "Failed to read host suggested def data length values");
6253                 return;
6254         }
6255
6256         read_requests = g_slist_remove(read_requests, read_request);
6257         dbus_message_unref(read_request->msg);
6258         g_free(read_request);
6259
6260         if (!g_dbus_send_message(dbus_conn, reply))
6261                 error("D-Bus send failed");
6262 }
6263
6264 static DBusMessage *le_read_host_suggested_default_data_length(
6265                         DBusConnection *conn, DBusMessage *msg,
6266                         void *user_data)
6267 {
6268         struct btd_adapter *adapter = user_data;
6269         struct le_data_length_read_request *read_request;
6270         struct le_data_length_read_default_data_length_handler *handler;
6271
6272         if (find_read_le_data_length_request(adapter))
6273                 return btd_error_in_progress(msg);
6274
6275         if (btd_adapter_le_read_suggested_default_data_length(adapter))
6276                 return btd_error_failed(msg, "Unable to read host suggested def data length");
6277
6278         read_request = g_new(struct le_data_length_read_request, 1);
6279
6280         read_request->msg = dbus_message_ref(msg);
6281         read_request->adapter = adapter;
6282
6283         read_requests = g_slist_append(read_requests, read_request);
6284
6285         handler = g_new0(struct le_data_length_read_default_data_length_handler, 1);
6286
6287         handler->read_callback =
6288                 (read_host_suggested_default_data_length_cb_t)le_read_host_suggested_default_length_complete;
6289
6290         read_request->adapter->def_read_handler = handler;
6291
6292         return NULL;
6293 }
6294
6295 static void get_le_batching_available_pkts_complete(
6296                         uint8_t status, uint16_t length,
6297                         const void *param, void *user_data)
6298 {
6299         const struct mgmt_rp_get_le_batching_buffer *rp = param;
6300         struct le_batching_request *request =
6301                 (struct le_batching_request*)user_data;
6302         DBusMessage *reply;
6303
6304         if (status != MGMT_STATUS_SUCCESS) {
6305                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6306                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6307                         reply = btd_error_not_supported(request->msg);
6308                 else
6309                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6310                 goto done;
6311         }
6312
6313         if (length < sizeof(*rp)) {
6314                 reply = btd_error_failed(request->msg,
6315                         "Wrong size of get le batching buffer");
6316                 goto done;
6317         }
6318
6319         DBG("LE Batching buffer: [%u]", rp->buffer);
6320         request->adapter->le_batching_available_pkts = rp->buffer;
6321         reply = g_dbus_create_reply(request->msg,
6322                                 DBUS_TYPE_UINT32, &rp->buffer,
6323                                 DBUS_TYPE_INVALID);
6324         if (!reply)
6325                 reply = btd_error_failed(request->msg,
6326                                         "Failed to create reply.");
6327
6328 done:
6329         if (!g_dbus_send_message(dbus_conn, reply))
6330                 error("D-Bus send failed");
6331
6332         dbus_message_unref(request->msg);
6333         g_free(request);
6334 }
6335
6336 static DBusMessage *adapter_get_le_batching_available_pkts(DBusConnection *conn,
6337                                                 DBusMessage *msg, void *data)
6338 {
6339         struct btd_adapter *adapter = data;
6340         struct le_batching_request *request;
6341         DBusMessage *reply;
6342         dbus_uint32_t val;
6343
6344         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6345                 return btd_error_not_ready(msg);
6346
6347         if (adapter->le_batching_available_pkts < 0)
6348                 return btd_error_not_supported(msg);
6349
6350         if (adapter->le_batching_available_pkts > 0) {
6351                 reply = dbus_message_new_method_return(msg);
6352                 if (!reply)
6353                         return NULL;
6354
6355                 val = adapter->le_batching_available_pkts;
6356                 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &val,
6357                                                                 DBUS_TYPE_INVALID);
6358                 DBG("LE Batching buffer: [%u]", val);
6359                 return reply;
6360         }
6361
6362         request = g_new(struct le_batching_request, 1);
6363
6364         request->msg = dbus_message_ref(msg);
6365         request->adapter = adapter;
6366
6367         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_LE_BATCHING_BUFFER,
6368                                 adapter->dev_id, 0, NULL,
6369                                 get_le_batching_available_pkts_complete, request, NULL) == 0) {
6370                 dbus_message_unref(request->msg);
6371                 g_free(request);
6372                 return btd_error_failed(msg, "Unable to get le batching buffer");
6373         }
6374
6375         return NULL;
6376 }
6377
6378 static void set_le_batching_enable_complete(
6379                         uint8_t status, uint16_t length,
6380                         const void *param, void *user_data)
6381 {
6382         const struct mgmt_rp_set_le_batching_enable *rp = param;
6383         struct le_batching_request *request =
6384                 (struct le_batching_request*)user_data;
6385         DBusMessage *reply;
6386
6387         DBG("");
6388         if (status != MGMT_STATUS_SUCCESS) {
6389                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6390                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6391                         reply = btd_error_not_supported(request->msg);
6392                 else
6393                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6394                 goto done;
6395         }
6396
6397         if (length < sizeof(*rp)) {
6398                 reply = btd_error_failed(request->msg,
6399                         "Wrong size of set le batching enable");
6400                 goto done;
6401         }
6402
6403         reply = g_dbus_create_reply(request->msg,
6404                                 DBUS_TYPE_INVALID);
6405         if (!reply)
6406                 reply = btd_error_failed(request->msg,
6407                                         "Failed to create reply.");
6408
6409 done:
6410         if (!g_dbus_send_message(dbus_conn, reply))
6411                 error("D-Bus send failed");
6412
6413         dbus_message_unref(request->msg);
6414         g_free(request);
6415 }
6416
6417 static void set_le_batching_param_complete(
6418                         uint8_t status, uint16_t length,
6419                         const void *param, void *user_data)
6420 {
6421         const struct mgmt_rp_set_le_batching_param *rp = param;
6422         struct mgmt_cp_set_le_batching_enable cp;
6423         struct le_batching_set_param_request *request =
6424                 (struct le_batching_set_param_request*)user_data;
6425         DBusMessage *reply;
6426
6427         if (status != MGMT_STATUS_SUCCESS) {
6428                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6429                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6430                         reply = btd_error_not_supported(request->msg);
6431                 else
6432                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6433                 goto done;
6434         }
6435
6436         if (length < sizeof(*rp)) {
6437                 reply = btd_error_failed(request->msg,
6438                         "Wrong size of set le batching param");
6439                 goto done;
6440         }
6441
6442         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6443         cp.bdaddr = request->bdaddr;
6444         cp.enable = 1;
6445         if (mgmt_send(request->adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6446                         request->adapter->dev_id, sizeof(cp), &cp,
6447                         set_le_batching_enable_complete, request, NULL) == 0) {
6448                 reply = btd_error_failed(request->msg, "Unable to set le batching enable");
6449                 goto done;
6450         }
6451
6452         return;
6453 done:
6454         if (!g_dbus_send_message(dbus_conn, reply))
6455                 error("D-Bus send failed");
6456
6457         dbus_message_unref(request->msg);
6458         g_free(request);
6459 }
6460
6461 static DBusMessage *adapter_enable_le_batching(DBusConnection *conn,
6462                                                 DBusMessage *msg, void *data)
6463 {
6464         struct btd_adapter *adapter = data;
6465         struct mgmt_cp_set_le_batching_param cp;
6466         struct le_batching_set_param_request *request;
6467         bdaddr_t bt_addr = { { 0, } };
6468         const gchar *address = NULL;
6469         dbus_int32_t packet_threshold;
6470         dbus_int32_t timeout;
6471
6472         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6473                 return btd_error_not_ready(msg);
6474
6475         if (!dbus_message_get_args(msg, NULL,
6476                                 DBUS_TYPE_STRING, &address,
6477                                 DBUS_TYPE_INT32, &packet_threshold,
6478                                 DBUS_TYPE_INT32, &timeout,
6479                                 DBUS_TYPE_INVALID))
6480                 return btd_error_invalid_args(msg);
6481
6482         if (packet_threshold < 0 || packet_threshold > 0x7fff ||
6483                 timeout < 0 || timeout > 0x7fff)
6484                 return btd_error_invalid_args(msg);
6485
6486         DBG("Set LE batching param: [%s %d %d]", address,
6487                         packet_threshold, timeout);
6488
6489         memset(&bt_addr, 0, sizeof(bdaddr_t));
6490         str2ba(address, &bt_addr);
6491         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_param));
6492
6493         if (bachk(address) < 0)
6494                 return btd_error_invalid_args(msg);
6495
6496         cp.bdaddr = bt_addr;
6497         cp.pkt_th = packet_threshold;
6498         /* 1sec = 100 */
6499         cp.timeout = timeout * 100;
6500
6501         request = g_new(struct le_batching_set_param_request, 1);
6502         request->msg = dbus_message_ref(msg);
6503         request->adapter = adapter;
6504         request->bdaddr = bt_addr;
6505         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_PARAM,
6506                         adapter->dev_id, sizeof(cp), &cp,
6507                         set_le_batching_param_complete, request, NULL) == 0) {
6508                 dbus_message_unref(request->msg);
6509                 g_free(request);
6510                 return btd_error_failed(msg, "Unable to set le batching param");
6511         }
6512
6513         return NULL;
6514 }
6515
6516 static DBusMessage *adapter_disable_le_batching(DBusConnection *conn,
6517                                                 DBusMessage *msg, void *data)
6518 {
6519         struct btd_adapter *adapter = data;
6520         struct le_batching_request *request;
6521         struct mgmt_cp_set_le_batching_enable cp;
6522         bdaddr_t bt_addr = { { 0, } };
6523         const gchar *address = NULL;
6524
6525         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6526                 return btd_error_not_ready(msg);
6527
6528         if (!dbus_message_get_args(msg, NULL,
6529                                 DBUS_TYPE_STRING, &address,
6530                                 DBUS_TYPE_INVALID))
6531                 return btd_error_invalid_args(msg);
6532
6533         DBG("Disable LE Batching: [%s]", address);
6534
6535         memset(&bt_addr, 0, sizeof(bdaddr_t));
6536         str2ba(address, &bt_addr);
6537         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6538
6539         if (bachk(address) < 0)
6540                 return btd_error_invalid_args(msg);
6541
6542         cp.bdaddr = bt_addr;
6543         cp.enable = 0;
6544
6545         request = g_new(struct le_batching_request, 1);
6546         request->msg = dbus_message_ref(msg);
6547         request->adapter = adapter;
6548         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6549                         adapter->dev_id, sizeof(cp), &cp,
6550                         set_le_batching_enable_complete, request, NULL) == 0) {
6551                 dbus_message_unref(request->msg);
6552                 g_free(request);
6553                 return btd_error_failed(msg, "Unable to set le batching enable");
6554         }
6555
6556         return NULL;
6557 }
6558
6559 void le_set_data_length_return_param_complete(
6560                         uint8_t status, uint16_t length,
6561                         const void *param, void *user_data)
6562 {
6563         if (status != MGMT_STATUS_SUCCESS) {
6564                 error("le_set_data_length failed: %s (0x%02x)",
6565                         mgmt_errstr(status), status);
6566         }
6567
6568         return;
6569 }
6570
6571 int btd_adapter_le_set_data_length(struct btd_adapter *adapter, bdaddr_t *bdaddr,
6572                                 uint16_t max_tx_octets, uint16_t max_tx_time)
6573 {
6574         struct mgmt_cp_le_set_data_length cp;
6575
6576         memset(&cp, 0, sizeof(cp));
6577
6578         bacpy(&cp.bdaddr, bdaddr);
6579
6580         cp.max_tx_octets = max_tx_octets;
6581         cp.max_tx_time = max_tx_time;
6582
6583         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_DATA_LENGTH,
6584                         adapter->dev_id, sizeof(cp), &cp,
6585                         le_set_data_length_return_param_complete,
6586                         adapter, NULL) > 0)
6587                 return 0;
6588
6589         return -EIO;
6590 }
6591
6592 static DBusMessage *adapter_set_manufacturer_data(DBusConnection *conn,
6593                                                 DBusMessage *msg, void *data)
6594 {
6595         struct btd_adapter *adapter = data;
6596         struct mgmt_cp_set_manufacturer_data cp;
6597         uint8_t *value;
6598         int32_t len = 0;
6599
6600         DBG("Set manufacturer data");
6601
6602         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6603                 return btd_error_not_ready(msg);
6604
6605         if (!dbus_message_get_args(msg, NULL,
6606                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
6607                         DBUS_TYPE_INVALID))
6608                 return btd_error_invalid_args(msg);
6609
6610         if (len > EIR_MANUFACTURER_DATA_LENGTH_MAX)
6611                 return btd_error_invalid_args(msg);
6612
6613         memcpy(&cp, value, len);
6614
6615         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_MANUFACTURER_DATA,
6616                                         adapter->dev_id, EIR_MANUFACTURER_DATA_LENGTH_MAX,
6617                                         &cp, NULL, NULL, NULL) > 0)
6618                 return dbus_message_new_method_return(msg);
6619
6620         return btd_error_failed(msg, "Set manufacturer data failed");
6621 }
6622
6623 static DBusMessage *adapter_get_energy_info(DBusConnection *conn,
6624                                                 DBusMessage *msg, void *user_data)
6625 {
6626         DBusMessage *reply;
6627         uint32_t tx_time = 0;
6628         uint32_t rx_time = 0;
6629         uint32_t idle_time = 0;
6630         uint32_t energy_used = 0;
6631
6632         if (adapter_le_get_energy_info(&tx_time, &rx_time,
6633                                         &idle_time, &energy_used) == FALSE) {
6634                 error("Fail to send vcs for getting energy info");
6635                 reply = btd_error_not_supported(msg);
6636                 goto done;
6637         }
6638
6639         reply = g_dbus_create_reply(msg,
6640                                 DBUS_TYPE_UINT32, &tx_time,
6641                                 DBUS_TYPE_UINT32, &rx_time,
6642                                 DBUS_TYPE_UINT32, &idle_time,
6643                                 DBUS_TYPE_UINT32, &energy_used,
6644                                 DBUS_TYPE_INVALID);
6645
6646         if (!reply)
6647                 reply = btd_error_failed(msg,
6648                                         "Failed to create reply.");
6649
6650 done:
6651         return reply;
6652 }
6653
6654
6655 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
6656
6657 static DBusMessage *start_discovery(DBusConnection *conn,
6658                                         DBusMessage *msg, void *user_data)
6659 {
6660         struct btd_adapter *adapter = user_data;
6661         const char *sender = dbus_message_get_sender(msg);
6662         struct discovery_client *client;
6663         bool is_discovering;
6664         int err;
6665
6666         DBG("sender %s", sender);
6667
6668         if (!btd_adapter_get_powered(adapter))
6669                 return btd_error_not_ready(msg);
6670
6671         is_discovering = get_discovery_client(adapter, sender, &client);
6672
6673         /*
6674          * Every client can only start one discovery, if the client
6675          * already started a discovery then return an error.
6676          */
6677         if (is_discovering)
6678                 return btd_error_busy(msg);
6679
6680         /*
6681          * If there was pre-set filter, just reconnect it to discovery_list,
6682          * and trigger scan.
6683          */
6684         if (client) {
6685                 if (client->msg)
6686                         return btd_error_busy(msg);
6687
6688                 adapter->set_filter_list = g_slist_remove(
6689                                              adapter->set_filter_list, client);
6690                 adapter->discovery_list = g_slist_prepend(
6691                                               adapter->discovery_list, client);
6692
6693                 goto done;
6694         }
6695
6696         client = g_new0(struct discovery_client, 1);
6697
6698         client->adapter = adapter;
6699         client->owner = g_strdup(sender);
6700         client->discovery_filter = NULL;
6701         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6702                                                 discovery_disconnect, client,
6703                                                 NULL);
6704         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
6705                                                                 client);
6706
6707 done:
6708         /*
6709          * Just trigger the discovery here. In case an already running
6710          * discovery in idle phase exists, it will be restarted right
6711          * away.
6712          */
6713         err = update_discovery_filter(adapter);
6714         if (!err)
6715                 return dbus_message_new_method_return(msg);
6716
6717         /* If the discovery has to be started wait it complete to reply */
6718         if (err == -EINPROGRESS) {
6719                 client->msg = dbus_message_ref(msg);
6720 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
6721                 adapter->client = client;
6722 #endif
6723                 return NULL;
6724
6725         }
6726
6727         return btd_error_failed(msg, strerror(-err));
6728 }
6729
6730 static bool parse_uuids(DBusMessageIter *value, struct discovery_filter *filter)
6731 {
6732         DBusMessageIter arriter;
6733
6734         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_ARRAY)
6735                 return false;
6736
6737         dbus_message_iter_recurse(value, &arriter);
6738         while (dbus_message_iter_get_arg_type(&arriter) != DBUS_TYPE_INVALID) {
6739                 bt_uuid_t uuid, u128;
6740                 char uuidstr[MAX_LEN_UUID_STR + 1];
6741                 char *uuid_param;
6742
6743                 if (dbus_message_iter_get_arg_type(&arriter) !=
6744                                                 DBUS_TYPE_STRING)
6745                         return false;
6746
6747                 dbus_message_iter_get_basic(&arriter, &uuid_param);
6748
6749                 if (bt_string_to_uuid(&uuid, uuid_param))
6750                         return false;
6751
6752                 bt_uuid_to_uuid128(&uuid, &u128);
6753                 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
6754
6755                 filter->uuids = g_slist_prepend(filter->uuids, g_strdup(uuidstr));
6756
6757                 dbus_message_iter_next(&arriter);
6758         }
6759
6760         return true;
6761 }
6762
6763 static bool parse_rssi(DBusMessageIter *value, struct discovery_filter *filter)
6764 {
6765         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_INT16)
6766                 return false;
6767
6768         dbus_message_iter_get_basic(value, &filter->rssi);
6769         /* -127 <= RSSI <= +20 (spec V4.2 [Vol 2, Part E] 7.7.65.2) */
6770         if (filter->rssi > 20 || filter->rssi < -127)
6771                 return false;
6772
6773         return true;
6774 }
6775
6776 static bool parse_pathloss(DBusMessageIter *value,
6777                                 struct discovery_filter *filter)
6778 {
6779         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT16)
6780                 return false;
6781
6782         dbus_message_iter_get_basic(value, &filter->pathloss);
6783         /* pathloss filter must be smaller that PATHLOSS_MAX */
6784         if (filter->pathloss > PATHLOSS_MAX)
6785                 return false;
6786
6787         return true;
6788 }
6789
6790 static bool parse_transport(DBusMessageIter *value,
6791                                         struct discovery_filter *filter)
6792 {
6793         char *transport_str;
6794
6795         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6796                 return false;
6797
6798         dbus_message_iter_get_basic(value, &transport_str);
6799
6800         if (!strcmp(transport_str, "bredr"))
6801                 filter->type = SCAN_TYPE_BREDR;
6802         else if (!strcmp(transport_str, "le"))
6803                 filter->type = SCAN_TYPE_LE;
6804         else if (strcmp(transport_str, "auto"))
6805                 return false;
6806
6807         return true;
6808 }
6809
6810 static bool parse_duplicate_data(DBusMessageIter *value,
6811                                         struct discovery_filter *filter)
6812 {
6813         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6814                 return false;
6815
6816         dbus_message_iter_get_basic(value, &filter->duplicate);
6817
6818         return true;
6819 }
6820
6821 static bool parse_discoverable(DBusMessageIter *value,
6822                                         struct discovery_filter *filter)
6823 {
6824         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6825                 return false;
6826
6827         dbus_message_iter_get_basic(value, &filter->discoverable);
6828
6829         return true;
6830 }
6831
6832 static bool parse_pattern(DBusMessageIter *value,
6833                                         struct discovery_filter *filter)
6834 {
6835         const char *pattern;
6836
6837         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6838                 return false;
6839
6840         dbus_message_iter_get_basic(value, &pattern);
6841
6842         free(filter->pattern);
6843         filter->pattern = strdup(pattern);
6844
6845         return true;
6846 }
6847
6848 struct filter_parser {
6849         const char *name;
6850         bool (*func)(DBusMessageIter *iter, struct discovery_filter *filter);
6851 } parsers[] = {
6852         { "UUIDs", parse_uuids },
6853         { "RSSI", parse_rssi },
6854         { "Pathloss", parse_pathloss },
6855         { "Transport", parse_transport },
6856         { "DuplicateData", parse_duplicate_data },
6857         { "Discoverable", parse_discoverable },
6858         { "Pattern", parse_pattern },
6859         { }
6860 };
6861
6862 static bool parse_discovery_filter_entry(char *key, DBusMessageIter *value,
6863                                                 struct discovery_filter *filter)
6864 {
6865         struct filter_parser *parser;
6866
6867         for (parser = parsers; parser && parser->name; parser++) {
6868                 if (!strcmp(parser->name, key))
6869                         return parser->func(value, filter);
6870         }
6871
6872         DBG("Unknown key parameter: %s!\n", key);
6873         return false;
6874 }
6875
6876 /*
6877  * This method is responsible for parsing parameters to SetDiscoveryFilter. If
6878  * filter in msg was empty, sets *filter to NULL. If whole parsing was
6879  * successful, sets *filter to proper value.
6880  * Returns false on any error, and true on success.
6881  */
6882 static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
6883                                         struct discovery_filter **filter,
6884                                         DBusMessage *msg)
6885 {
6886         DBusMessageIter iter, subiter, dictiter, variantiter;
6887         bool is_empty = true;
6888
6889         *filter = g_try_malloc(sizeof(**filter));
6890         if (!*filter)
6891                 return false;
6892
6893         (*filter)->uuids = NULL;
6894         (*filter)->pathloss = DISTANCE_VAL_INVALID;
6895         (*filter)->rssi = DISTANCE_VAL_INVALID;
6896         (*filter)->type = get_scan_type(adapter);
6897         (*filter)->duplicate = false;
6898         (*filter)->discoverable = false;
6899         (*filter)->pattern = NULL;
6900
6901         dbus_message_iter_init(msg, &iter);
6902         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
6903             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
6904                 goto invalid_args;
6905
6906         dbus_message_iter_recurse(&iter, &subiter);
6907         do {
6908                 int type = dbus_message_iter_get_arg_type(&subiter);
6909                 char *key;
6910
6911                 if (type == DBUS_TYPE_INVALID)
6912                         break;
6913
6914                 is_empty = false;
6915                 dbus_message_iter_recurse(&subiter, &dictiter);
6916
6917                 dbus_message_iter_get_basic(&dictiter, &key);
6918                 if (!dbus_message_iter_next(&dictiter))
6919                         goto invalid_args;
6920
6921                 if (dbus_message_iter_get_arg_type(&dictiter) !=
6922                                                              DBUS_TYPE_VARIANT)
6923                         goto invalid_args;
6924
6925                 dbus_message_iter_recurse(&dictiter, &variantiter);
6926
6927                 if (!parse_discovery_filter_entry(key, &variantiter, *filter))
6928                         goto invalid_args;
6929
6930                 dbus_message_iter_next(&subiter);
6931         } while (true);
6932
6933         if (is_empty) {
6934                 g_free(*filter);
6935                 *filter = NULL;
6936                 return true;
6937         }
6938
6939         /* only pathlos or rssi can be set, never both */
6940         if ((*filter)->pathloss != DISTANCE_VAL_INVALID &&
6941             (*filter)->rssi != DISTANCE_VAL_INVALID)
6942                 goto invalid_args;
6943
6944         DBG("filtered discovery params: transport: %d rssi: %d pathloss: %d "
6945                 " duplicate data: %s discoverable %s pattern %s",
6946                 (*filter)->type, (*filter)->rssi, (*filter)->pathloss,
6947                 (*filter)->duplicate ? "true" : "false",
6948                 (*filter)->discoverable ? "true" : "false",
6949                 (*filter)->pattern);
6950
6951         return true;
6952
6953 invalid_args:
6954         g_slist_free_full((*filter)->uuids, g_free);
6955         g_free(*filter);
6956         *filter = NULL;
6957         return false;
6958 }
6959
6960 static DBusMessage *set_discovery_filter(DBusConnection *conn,
6961                                         DBusMessage *msg, void *user_data)
6962 {
6963         struct btd_adapter *adapter = user_data;
6964         struct discovery_client *client;
6965         struct discovery_filter *discovery_filter;
6966         const char *sender = dbus_message_get_sender(msg);
6967         bool is_discovering;
6968
6969         DBG("sender %s", sender);
6970
6971         if (!btd_adapter_get_powered(adapter))
6972                 return btd_error_not_ready(msg);
6973
6974         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 8))
6975                 return btd_error_not_supported(msg);
6976
6977         /* parse parameters */
6978         if (!parse_discovery_filter_dict(adapter, &discovery_filter, msg))
6979                 return btd_error_invalid_args(msg);
6980
6981         is_discovering = get_discovery_client(adapter, sender, &client);
6982
6983         if (client) {
6984                 free_discovery_filter(client->discovery_filter);
6985                 client->discovery_filter = discovery_filter;
6986
6987                 if (is_discovering)
6988                         update_discovery_filter(adapter);
6989
6990                 if (discovery_filter || is_discovering)
6991                         return dbus_message_new_method_return(msg);
6992
6993                 /* Removing pre-set filter */
6994                 adapter->set_filter_list = g_slist_remove(
6995                                               adapter->set_filter_list,
6996                                               client);
6997                 discovery_free(client);
6998                 DBG("successfully cleared pre-set filter");
6999         } else if (discovery_filter) {
7000                 /* Client pre-setting his filter for first time */
7001                 client = g_new0(struct discovery_client, 1);
7002                 client->adapter = adapter;
7003                 client->owner = g_strdup(sender);
7004                 client->discovery_filter = discovery_filter;
7005                 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
7006                                                 discovery_disconnect, client,
7007                                                 NULL);
7008                 adapter->set_filter_list = g_slist_prepend(
7009                                              adapter->set_filter_list, client);
7010
7011                 DBG("successfully pre-set filter");
7012         }
7013
7014         return dbus_message_new_method_return(msg);
7015 }
7016
7017 static DBusMessage *stop_discovery(DBusConnection *conn,
7018                                         DBusMessage *msg, void *user_data)
7019 {
7020         struct btd_adapter *adapter = user_data;
7021         const char *sender = dbus_message_get_sender(msg);
7022         struct discovery_client *client;
7023         GSList *list;
7024         int err;
7025
7026         DBG("sender %s", sender);
7027
7028         if (!btd_adapter_get_powered(adapter))
7029                 return btd_error_not_ready(msg);
7030
7031         list = g_slist_find_custom(adapter->discovery_list, sender,
7032                         compare_sender);
7033         if (!list)
7034                 return btd_error_failed(msg, "No discovery started");
7035
7036         client = list->data;
7037
7038         if (client->msg)
7039                 return btd_error_busy(msg);
7040
7041 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7042         err = discovery_stop(client, false);
7043 #else
7044         err = discovery_stop(client);
7045 #endif
7046         switch (err) {
7047                 case 0:
7048                         return dbus_message_new_method_return(msg);
7049                 case -EINPROGRESS:
7050                         client->msg = dbus_message_ref(msg);
7051 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7052                         adapter->client = client;
7053 #endif
7054                         return NULL;
7055                 default:
7056                         return btd_error_failed(msg, strerror(-err));
7057         }
7058 }
7059
7060 static gboolean property_get_address(const GDBusPropertyTable *property,
7061                                         DBusMessageIter *iter, void *user_data)
7062 {
7063         struct btd_adapter *adapter = user_data;
7064         char addr[18];
7065         const char *str = addr;
7066
7067         ba2str(&adapter->bdaddr, addr);
7068
7069         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7070
7071         return TRUE;
7072 }
7073
7074 static gboolean property_get_address_type(const GDBusPropertyTable *property,
7075                                         DBusMessageIter *iter, void *user_data)
7076 {
7077         struct btd_adapter *adapter = user_data;
7078         const char *str;
7079
7080         if ((adapter->current_settings & MGMT_SETTING_LE) &&
7081                                 (adapter->bdaddr_type == BDADDR_LE_RANDOM))
7082                 str = "random";
7083         else
7084                 str = "public";
7085
7086         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7087
7088         return TRUE;
7089 }
7090
7091 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7092 static gboolean property_get_le_address(const GDBusPropertyTable *property,
7093                                         DBusMessageIter *iter, void *user_data)
7094 {
7095         struct btd_adapter *adapter = user_data;
7096         DBusMessageIter entry;
7097         char addr[18];
7098         const char *str = addr;
7099         char *type = NULL;
7100
7101         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7102                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7103
7104         if (adapter->le_static_addr.b[5] != 0) {
7105                 ba2str(&adapter->le_static_addr, addr);
7106                 type = g_strdup_printf("%d", BDADDR_LE_RANDOM);
7107         } else {
7108                 ba2str(&adapter->bdaddr, addr);
7109                 type = g_strdup_printf("%d", BDADDR_LE_PUBLIC);
7110         }
7111
7112         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &type);
7113         g_free((void *)type);
7114
7115         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7116
7117         dbus_message_iter_close_container(iter, &entry);
7118
7119         return TRUE;
7120 }
7121 #endif
7122
7123 static gboolean property_get_name(const GDBusPropertyTable *property,
7124                                         DBusMessageIter *iter, void *user_data)
7125 {
7126         struct btd_adapter *adapter = user_data;
7127         const char *str = adapter->system_name ? : "";
7128
7129         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7130
7131         return TRUE;
7132 }
7133
7134 static gboolean property_get_alias(const GDBusPropertyTable *property,
7135                                         DBusMessageIter *iter, void *user_data)
7136 {
7137         struct btd_adapter *adapter = user_data;
7138         const char *str;
7139
7140         if (adapter->current_alias)
7141                 str = adapter->current_alias;
7142         else if (adapter->stored_alias)
7143                 str = adapter->stored_alias;
7144         else
7145                 str = adapter->system_name ? : "";
7146
7147         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7148
7149         return TRUE;
7150 }
7151
7152 static void property_set_alias(const GDBusPropertyTable *property,
7153                                 DBusMessageIter *iter,
7154                                 GDBusPendingPropertySet id, void *user_data)
7155 {
7156         struct btd_adapter *adapter = user_data;
7157         const char *name;
7158         int ret;
7159
7160         dbus_message_iter_get_basic(iter, &name);
7161
7162         if (g_str_equal(name, "")  == TRUE) {
7163                 if (adapter->stored_alias == NULL) {
7164                         /* no alias set, nothing to restore */
7165                         g_dbus_pending_property_success(id);
7166                         return;
7167                 }
7168
7169                 /* restore to system name */
7170                 ret = set_name(adapter, adapter->system_name);
7171         } else {
7172                 if (g_strcmp0(adapter->stored_alias, name) == 0) {
7173                         /* alias already set, nothing to do */
7174                         g_dbus_pending_property_success(id);
7175                         return;
7176                 }
7177
7178                 /* set to alias */
7179                 ret = set_name(adapter, name);
7180         }
7181
7182         if (ret >= 0) {
7183                 g_free(adapter->stored_alias);
7184
7185                 if (g_str_equal(name, "")  == TRUE)
7186                         adapter->stored_alias = NULL;
7187                 else
7188                         adapter->stored_alias = g_strdup(name);
7189
7190                 store_adapter_info(adapter);
7191
7192                 g_dbus_pending_property_success(id);
7193                 return;
7194         }
7195
7196         if (ret == -EINVAL)
7197                 g_dbus_pending_property_error(id,
7198                                         ERROR_INTERFACE ".InvalidArguments",
7199                                         "Invalid arguments in method call");
7200         else
7201                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7202                                                         strerror(-ret));
7203 }
7204
7205 static gboolean property_get_class(const GDBusPropertyTable *property,
7206                                         DBusMessageIter *iter, void *user_data)
7207 {
7208         struct btd_adapter *adapter = user_data;
7209         dbus_uint32_t val = adapter->dev_class;
7210
7211         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
7212
7213         return TRUE;
7214 }
7215
7216 static gboolean property_get_a2dp_role(const GDBusPropertyTable *property,
7217                                         DBusMessageIter *iter, void *user_data)
7218 {
7219         struct btd_adapter *adapter = user_data;
7220         dbus_uint32_t val = adapter->a2dp_role;
7221
7222         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
7223
7224         return TRUE;
7225 }
7226
7227 static gboolean property_get_mode(struct btd_adapter *adapter,
7228                                 uint32_t setting, DBusMessageIter *iter)
7229 {
7230         dbus_bool_t enable;
7231
7232         enable = (adapter->current_settings & setting) ? TRUE : FALSE;
7233
7234         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
7235
7236         return TRUE;
7237 }
7238
7239 struct property_set_data {
7240         struct btd_adapter *adapter;
7241         uint32_t setting;
7242         GDBusPendingPropertySet id;
7243         uint8_t value;
7244 };
7245
7246 static void property_set_mode_complete(uint8_t status, uint16_t length,
7247                                         const void *param, void *user_data)
7248 {
7249         struct property_set_data *data = user_data;
7250         struct btd_adapter *adapter = data->adapter;
7251
7252         DBG("%s (0x%02x)", mgmt_errstr(status), status);
7253
7254         if (status != MGMT_STATUS_SUCCESS) {
7255                 const char *dbus_err;
7256
7257                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
7258                                                 mgmt_errstr(status), status);
7259
7260                 if (status == MGMT_STATUS_RFKILLED) {
7261                         dbus_err = ERROR_INTERFACE ".Blocked";
7262                         adapter_set_power_state(adapter,
7263                                         ADAPTER_POWER_STATE_OFF_BLOCKED);
7264                 } else {
7265                         dbus_err = ERROR_INTERFACE ".Failed";
7266                 }
7267
7268                 g_dbus_pending_property_error(data->id, dbus_err,
7269                                                         mgmt_errstr(status));
7270
7271                 adapter->pending_settings &= ~data->setting;
7272                 if (status != MGMT_STATUS_RFKILLED &&
7273                     data->setting & MGMT_SETTING_POWERED)
7274                         reset_power_state_target(adapter, data->value);
7275                 return;
7276         }
7277
7278         g_dbus_pending_property_success(data->id);
7279
7280         /*
7281          * The parameters are identical and also the task that is
7282          * required in both cases. So it is safe to just call the
7283          * event handling functions here.
7284          */
7285         new_settings_callback(adapter->dev_id, length, param, adapter);
7286 }
7287
7288 static void clear_discoverable(struct btd_adapter *adapter)
7289 {
7290         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
7291                 return;
7292
7293         if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
7294                 return;
7295
7296         /* If no timeout is set do nothing as both connectable and discoverable
7297          * flags are persistent on power toggle.
7298          */
7299         if (!adapter->discoverable_timeout)
7300                 return;
7301
7302         /* If timeout was set kernel clears discoverable on its own when
7303          * powering off controller. This would leave connectable flag set
7304          * after power on.
7305          *
7306          * With kernel control clearing connectable clear also discoverable
7307          * flag so we need to clear connectable.
7308          */
7309         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
7310 }
7311
7312 static void property_set_mode(struct btd_adapter *adapter, uint32_t setting,
7313                                                 DBusMessageIter *value,
7314                                                 GDBusPendingPropertySet id)
7315 {
7316         struct property_set_data *data;
7317         struct mgmt_cp_set_discoverable cp;
7318         void *param;
7319         dbus_bool_t enable, current_enable;
7320         uint16_t opcode, len;
7321         uint8_t mode;
7322
7323         dbus_message_iter_get_basic(value, &enable);
7324
7325         if (adapter->pending_settings & setting) {
7326                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Busy",
7327                                                 NULL);
7328                 return;
7329         }
7330
7331         if (adapter->current_settings & setting)
7332                 current_enable = TRUE;
7333         else
7334                 current_enable = FALSE;
7335
7336         if (enable == current_enable) {
7337                 g_dbus_pending_property_success(id);
7338                 return;
7339         }
7340
7341         mode = (enable == TRUE) ? 0x01 : 0x00;
7342
7343         switch (setting) {
7344         case MGMT_SETTING_POWERED:
7345                 opcode = MGMT_OP_SET_POWERED;
7346                 param = &mode;
7347                 len = sizeof(mode);
7348
7349                 if (!mode) {
7350                         btd_adv_monitor_power_down(
7351                                                 adapter->adv_monitor_manager);
7352                         clear_discoverable(adapter);
7353                         remove_temporary_devices(adapter);
7354                 }
7355
7356                 break;
7357         case MGMT_SETTING_DISCOVERABLE:
7358 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
7359                 if (btd_has_kernel_features(KERNEL_CONN_CONTROL)) {
7360                         if (mode) {
7361                                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
7362                                                                         mode);
7363                         } else {
7364                                 opcode = MGMT_OP_SET_CONNECTABLE;
7365                                 param = &mode;
7366                                 len = sizeof(mode);
7367                                 break;
7368                         }
7369                 }
7370 #endif
7371
7372                 memset(&cp, 0, sizeof(cp));
7373                 cp.val = mode;
7374                 if (cp.val)
7375                         cp.timeout = htobs(adapter->discoverable_timeout);
7376
7377                 opcode = MGMT_OP_SET_DISCOVERABLE;
7378                 param = &cp;
7379                 len = sizeof(cp);
7380                 break;
7381         case MGMT_SETTING_BONDABLE:
7382                 opcode = MGMT_OP_SET_BONDABLE;
7383                 param = &mode;
7384                 len = sizeof(mode);
7385                 break;
7386 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7387         case MGMT_SETTING_CONNECTABLE:
7388                 opcode = MGMT_OP_SET_CONNECTABLE;
7389                 param = &mode;
7390                 len = sizeof(mode);
7391                 break;
7392 #endif
7393         default:
7394                 goto failed;
7395         }
7396
7397         DBG("sending %s command for index %u", mgmt_opstr(opcode),
7398                                                         adapter->dev_id);
7399
7400         data = g_try_new0(struct property_set_data, 1);
7401         if (!data)
7402                 goto failed;
7403
7404         data->adapter = adapter;
7405         data->setting = setting;
7406         data->id = id;
7407         data->setting = setting;
7408         data->value = mode;
7409
7410         if (setting == MGMT_SETTING_POWERED &&
7411             adapter->power_state != ADAPTER_POWER_STATE_OFF_BLOCKED) {
7412                 adapter_set_power_state(adapter, mode ?
7413                                         ADAPTER_POWER_STATE_OFF_ENABLING :
7414                                         ADAPTER_POWER_STATE_ON_DISABLING);
7415         }
7416
7417 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7418         /*
7419          * Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
7420          */
7421         if (mgmt_send_nowait(adapter->mgmt, opcode, adapter->dev_id, len, param,
7422                                 property_set_mode_complete, data, g_free) > 0)
7423                 return;
7424 #else
7425         if (mgmt_send(adapter->mgmt, opcode, adapter->dev_id, len, param,
7426                         propertyi_set_mode_complete, data, g_free) > 0){
7427                 adapter->pending_settings |= setting;
7428                 return;
7429         }
7430 #endif
7431
7432         g_free(data);
7433         if (setting == MGMT_SETTING_POWERED) {
7434                 /* cancel the earlier setting */
7435                 adapter_set_power_state(adapter, mode ?
7436                                         ADAPTER_POWER_STATE_OFF :
7437                                         ADAPTER_POWER_STATE_ON);
7438         }
7439
7440 failed:
7441         btd_error(adapter->dev_id, "Failed to set mode for index %u",
7442                                                         adapter->dev_id);
7443
7444         g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
7445 }
7446
7447 static gboolean property_get_powered(const GDBusPropertyTable *property,
7448                                         DBusMessageIter *iter, void *user_data)
7449 {
7450         struct btd_adapter *adapter = user_data;
7451
7452         return property_get_mode(adapter, MGMT_SETTING_POWERED, iter);
7453 }
7454
7455 static void property_set_powered(const GDBusPropertyTable *property,
7456                                 DBusMessageIter *iter,
7457                                 GDBusPendingPropertySet id, void *user_data)
7458 {
7459         struct btd_adapter *adapter = user_data;
7460
7461         if (powering_down) {
7462                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7463                                                         "Powering down");
7464                 return;
7465         }
7466
7467         property_set_mode(adapter, MGMT_SETTING_POWERED, iter, id);
7468 }
7469
7470 static gboolean property_get_power_state(const GDBusPropertyTable *property,
7471                                         DBusMessageIter *iter, void *user_data)
7472 {
7473         struct btd_adapter *adapter = user_data;
7474         const char *str;
7475
7476         str = adapter_power_state_str(adapter->power_state);
7477         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7478
7479         return TRUE;
7480 }
7481
7482 static gboolean property_get_discoverable(const GDBusPropertyTable *property,
7483                                         DBusMessageIter *iter, void *user_data)
7484 {
7485         struct btd_adapter *adapter = user_data;
7486
7487         return property_get_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter);
7488 }
7489
7490 static void property_set_discoverable(const GDBusPropertyTable *property,
7491                                 DBusMessageIter *iter,
7492                                 GDBusPendingPropertySet id, void *user_data)
7493 {
7494         struct btd_adapter *adapter = user_data;
7495
7496         if (adapter->discoverable_timeout > 0 &&
7497                         !btd_adapter_get_powered(adapter)) {
7498                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7499                                                                 "Not Powered");
7500                 return;
7501         }
7502
7503         /* Reset discovery_discoverable as Discoverable takes precedence */
7504         adapter->discovery_discoverable = false;
7505
7506         property_set_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter, id);
7507 }
7508
7509 static gboolean property_get_discoverable_timeout(
7510                                         const GDBusPropertyTable *property,
7511                                         DBusMessageIter *iter, void *user_data)
7512 {
7513         struct btd_adapter *adapter = user_data;
7514         dbus_uint32_t value = adapter->discoverable_timeout;
7515
7516         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7517
7518         return TRUE;
7519 }
7520
7521 static void property_set_discoverable_timeout(
7522                                 const GDBusPropertyTable *property,
7523                                 DBusMessageIter *iter,
7524                                 GDBusPendingPropertySet id, void *user_data)
7525 {
7526         struct btd_adapter *adapter = user_data;
7527         bool enabled;
7528         dbus_uint32_t value;
7529
7530         dbus_message_iter_get_basic(iter, &value);
7531
7532         adapter->discoverable_timeout = value;
7533
7534         g_dbus_pending_property_success(id);
7535
7536         store_adapter_info(adapter);
7537
7538         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7539                                 ADAPTER_INTERFACE, "DiscoverableTimeout");
7540
7541         if (adapter->pending_settings & MGMT_SETTING_DISCOVERABLE) {
7542                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7543                         enabled = false;
7544                 else
7545                         enabled = true;
7546         } else {
7547                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7548                         enabled = true;
7549                 else
7550                         enabled = false;
7551         }
7552
7553         if (enabled)
7554                 set_discoverable(adapter, 0x01, adapter->discoverable_timeout);
7555 }
7556
7557 static gboolean property_get_pairable(const GDBusPropertyTable *property,
7558                                         DBusMessageIter *iter, void *user_data)
7559 {
7560         struct btd_adapter *adapter = user_data;
7561
7562         return property_get_mode(adapter, MGMT_SETTING_BONDABLE, iter);
7563 }
7564
7565 static void property_set_pairable(const GDBusPropertyTable *property,
7566                                 DBusMessageIter *iter,
7567                                 GDBusPendingPropertySet id, void *user_data)
7568 {
7569         struct btd_adapter *adapter = user_data;
7570
7571         property_set_mode(adapter, MGMT_SETTING_BONDABLE, iter, id);
7572 }
7573
7574 static gboolean property_get_pairable_timeout(
7575                                         const GDBusPropertyTable *property,
7576                                         DBusMessageIter *iter, void *user_data)
7577 {
7578         struct btd_adapter *adapter = user_data;
7579         dbus_uint32_t value = adapter->pairable_timeout;
7580
7581         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7582
7583         return TRUE;
7584 }
7585
7586 static void property_set_pairable_timeout(const GDBusPropertyTable *property,
7587                                 DBusMessageIter *iter,
7588                                 GDBusPendingPropertySet id, void *user_data)
7589 {
7590         struct btd_adapter *adapter = user_data;
7591         dbus_uint32_t value;
7592
7593         dbus_message_iter_get_basic(iter, &value);
7594
7595         adapter->pairable_timeout = value;
7596
7597         g_dbus_pending_property_success(id);
7598
7599         store_adapter_info(adapter);
7600
7601         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7602                                         ADAPTER_INTERFACE, "PairableTimeout");
7603
7604         trigger_pairable_timeout(adapter);
7605 }
7606
7607 static gboolean property_get_discovering(const GDBusPropertyTable *property,
7608                                         DBusMessageIter *iter, void *user_data)
7609 {
7610         struct btd_adapter *adapter = user_data;
7611         dbus_bool_t discovering = adapter->discovering;
7612
7613         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7614
7615         return TRUE;
7616 }
7617
7618 static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
7619 {
7620         GHashTable *uuids = user_data;
7621         bt_uuid_t uuid, u128;
7622         char uuidstr[MAX_LEN_UUID_STR + 1];
7623
7624         if (!gatt_db_service_get_active(attrib))
7625                 return;
7626
7627         if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
7628                 return;
7629
7630         bt_uuid_to_uuid128(&uuid, &u128);
7631         bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
7632
7633         g_hash_table_add(uuids, strdup(uuidstr));
7634 }
7635
7636 static void iter_append_uuid(gpointer key, gpointer value, gpointer user_data)
7637 {
7638         DBusMessageIter *iter = user_data;
7639         const char *uuid = key;
7640
7641         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
7642 }
7643
7644 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7645 static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
7646                                         DBusMessageIter *iter, void *user_data)
7647 {
7648         struct btd_adapter *adapter = user_data;
7649         dbus_bool_t discovering = adapter->le_discovering;
7650
7651         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7652
7653         return TRUE;
7654 }
7655
7656 static gboolean property_get_connectable(const GDBusPropertyTable *property,
7657                                         DBusMessageIter *iter, void *user_data)
7658 {
7659         struct btd_adapter *adapter = user_data;
7660
7661         return property_get_mode(adapter, MGMT_SETTING_CONNECTABLE, iter);
7662 }
7663
7664 static void property_set_connectable(const GDBusPropertyTable *property,
7665                                 DBusMessageIter *iter,
7666                                 GDBusPendingPropertySet id, void *user_data)
7667 {
7668         struct btd_adapter *adapter = user_data;
7669
7670         property_set_mode(adapter, MGMT_SETTING_CONNECTABLE, iter, id);
7671 }
7672
7673 static gboolean property_get_version(const GDBusPropertyTable *property,
7674                                         DBusMessageIter *iter, void *user_data)
7675 {
7676         struct btd_adapter *adapter = user_data;
7677         const char *str = adapter->version ? : "";
7678
7679         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7680
7681         return TRUE;
7682 }
7683
7684 static gboolean property_get_supported_le_features(
7685                                         const GDBusPropertyTable *property,
7686                                         DBusMessageIter *iter, void *user_data)
7687 {
7688         const char *str, *val;
7689         int value;
7690         DBusMessageIter entry;
7691         struct btd_adapter *adapter = user_data;
7692
7693         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7694                         DBUS_TYPE_STRING_AS_STRING, &entry);
7695
7696         value = adapter_le_get_max_adv_instance();
7697         if (value > 0) {
7698                 str = g_strdup("adv_inst_max");
7699                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7700
7701                 val = g_strdup_printf("%d", value);
7702                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7703
7704                 g_free((void *)str);
7705                 g_free((void *)val);
7706         }
7707
7708         value = adapter_le_is_supported_offloading();
7709         if (value > 0) {
7710                 str = g_strdup("rpa_offloading");
7711                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7712
7713                 val = g_strdup_printf("%d", value);
7714                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7715
7716                 g_free((void *)str);
7717                 g_free((void *)val);
7718         }
7719
7720         value = adapter_le_get_scan_filter_size();
7721 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
7722         if (value <= 0)
7723                 value = SCAN_FILTER_SLOTS_MAX;
7724 #endif
7725         if (value >= 0) {
7726                 str = g_strdup("max_filter");
7727                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7728
7729                 val = g_strdup_printf("%d", value);
7730                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7731
7732                 g_free((void *)str);
7733                 g_free((void *)val);
7734         }
7735
7736         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
7737                 /* 2M PHY Support */
7738                 str = g_strdup("2m_phy");
7739                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7740
7741                 if (adapter->le_2m_phy_supported)
7742                         val = g_strdup("true");
7743                 else
7744                         val = g_strdup("false");
7745
7746                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7747
7748                 g_free((void *)str);
7749                 g_free((void *)val);
7750
7751                 /* CODED PHY Support */
7752                 str = g_strdup("coded_phy");
7753                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7754
7755                 if (adapter->le_coded_phy_supported)
7756                         val = g_strdup("true");
7757                 else
7758                         val = g_strdup("false");
7759
7760                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7761
7762                 g_free((void *)str);
7763                 g_free((void *)val);
7764         }
7765
7766         dbus_message_iter_close_container(iter, &entry);
7767
7768         return TRUE;
7769 }
7770
7771 static gboolean property_get_ipsp_init_state(
7772                                         const GDBusPropertyTable *property,
7773                                         DBusMessageIter *iter, void *data)
7774 {
7775         struct btd_adapter *adapter = data;
7776         dbus_bool_t ipsp_initialized;
7777
7778         if (adapter->ipsp_intialized)
7779                 ipsp_initialized = TRUE;
7780         else
7781                 ipsp_initialized = FALSE;
7782
7783         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
7784                                         &ipsp_initialized);
7785
7786         return TRUE;
7787 }
7788 #endif
7789
7790 static gboolean property_get_uuids(const GDBusPropertyTable *property,
7791                                         DBusMessageIter *iter, void *user_data)
7792 {
7793         struct btd_adapter *adapter = user_data;
7794         DBusMessageIter entry;
7795         sdp_list_t *l;
7796         struct gatt_db *db;
7797         GHashTable *uuids;
7798
7799         uuids = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
7800         if (!uuids)
7801                 return FALSE;
7802
7803         /* SDP records */
7804         for (l = adapter->services; l != NULL; l = l->next) {
7805                 sdp_record_t *rec = l->data;
7806                 char *uuid;
7807
7808                 uuid = bt_uuid2string(&rec->svclass);
7809                 if (uuid == NULL)
7810                         continue;
7811
7812                 g_hash_table_add(uuids, uuid);
7813         }
7814
7815         /* GATT services */
7816         db = btd_gatt_database_get_db(adapter->database);
7817         if (db)
7818                 gatt_db_foreach_service(db, NULL, add_gatt_uuid, uuids);
7819
7820         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7821                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7822         g_hash_table_foreach(uuids, iter_append_uuid, &entry);
7823         dbus_message_iter_close_container(iter, &entry);
7824
7825         g_hash_table_destroy(uuids);
7826
7827         return TRUE;
7828 }
7829
7830 static gboolean property_exists_modalias(const GDBusPropertyTable *property,
7831                                                         void *user_data)
7832 {
7833         struct btd_adapter *adapter = user_data;
7834
7835         return adapter->modalias ? TRUE : FALSE;
7836 }
7837
7838 static gboolean property_get_modalias(const GDBusPropertyTable *property,
7839                                         DBusMessageIter *iter, void *user_data)
7840 {
7841         struct btd_adapter *adapter = user_data;
7842         const char *str = adapter->modalias ? : "";
7843
7844         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7845
7846         return TRUE;
7847 }
7848
7849 static gboolean property_get_roles(const GDBusPropertyTable *property,
7850                                         DBusMessageIter *iter, void *user_data)
7851 {
7852         struct btd_adapter *adapter = user_data;
7853         DBusMessageIter entry;
7854
7855         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7856                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7857
7858         if (adapter->supported_settings & MGMT_SETTING_LE) {
7859                 const char *str = "central";
7860                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7861         }
7862
7863         if (adapter->supported_settings & MGMT_SETTING_ADVERTISING) {
7864                 const char *str = "peripheral";
7865                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7866         }
7867
7868         if (queue_find(adapter->exps, NULL,
7869                                 le_simult_central_peripheral_uuid.val)) {
7870                 const char *str = "central-peripheral";
7871                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7872         }
7873
7874         dbus_message_iter_close_container(iter, &entry);
7875
7876         return TRUE;
7877 }
7878
7879 static void property_append_experimental(void *data, void *user_data)
7880 {
7881         uint8_t *feature = data;
7882         DBusMessageIter *iter = user_data;
7883         uint128_t value;
7884         bt_uuid_t uuid;
7885         char str[MAX_LEN_UUID_STR + 1];
7886         char *ptr;
7887
7888         bswap_128(feature, &value);
7889         bt_uuid128_create(&uuid, value);
7890         bt_uuid_to_string(&uuid, str, sizeof(str));
7891
7892         ptr = str;
7893
7894         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &ptr);
7895 }
7896
7897 static gboolean property_get_experimental(const GDBusPropertyTable *property,
7898                                         DBusMessageIter *iter, void *user_data)
7899 {
7900         struct btd_adapter *adapter = user_data;
7901         DBusMessageIter entry;
7902
7903         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7904                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7905
7906         queue_foreach(adapter->exps, property_append_experimental, &entry);
7907
7908         dbus_message_iter_close_container(iter, &entry);
7909
7910         return TRUE;
7911 }
7912
7913 static gboolean property_experimental_exists(const GDBusPropertyTable *property,
7914                                                                 void *data)
7915 {
7916         struct btd_adapter *adapter = data;
7917
7918         return !queue_isempty(adapter->exps);
7919 }
7920
7921 static DBusMessage *remove_device(DBusConnection *conn,
7922                                         DBusMessage *msg, void *user_data)
7923 {
7924         struct btd_adapter *adapter = user_data;
7925         struct btd_device *device;
7926         const char *path;
7927         GSList *list;
7928
7929         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
7930                                                 DBUS_TYPE_INVALID) == FALSE)
7931                 return btd_error_invalid_args(msg);
7932
7933         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7934         if (!list)
7935                 return btd_error_does_not_exist(msg);
7936
7937         if (!btd_adapter_get_powered(adapter))
7938                 return btd_error_not_ready(msg);
7939
7940         device = list->data;
7941
7942         btd_device_set_temporary(device, true);
7943
7944         if (!btd_device_is_connected(device)) {
7945                 btd_adapter_remove_device(adapter, device);
7946                 return dbus_message_new_method_return(msg);
7947         }
7948
7949         device_request_disconnect(device, msg);
7950
7951         return NULL;
7952 }
7953
7954 static DBusMessage *get_discovery_filters(DBusConnection *conn,
7955                                         DBusMessage *msg, void *user_data)
7956 {
7957         DBusMessage *reply;
7958         DBusMessageIter iter, array;
7959         struct filter_parser *parser;
7960
7961         reply = dbus_message_new_method_return(msg);
7962
7963         dbus_message_iter_init_append(reply, &iter);
7964
7965         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
7966                                         DBUS_TYPE_STRING_AS_STRING, &array);
7967
7968         for (parser = parsers; parser && parser->name; parser++) {
7969                 dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
7970                                                         &parser->name);
7971         }
7972
7973         dbus_message_iter_close_container(&iter, &array);
7974
7975         return reply;
7976 }
7977
7978 struct device_connect_data {
7979         struct btd_adapter *adapter;
7980         bdaddr_t dst;
7981         uint8_t dst_type;
7982         DBusMessage *msg;
7983 };
7984
7985 static void device_browse_cb(struct btd_device *dev, int err, void *user_data)
7986 {
7987         DBG("err %d (%s)", err, strerror(-err));
7988
7989         if (!err)
7990                 btd_device_connect_services(dev, NULL);
7991 }
7992
7993 static void device_connect_cb(GIOChannel *io, GError *gerr, gpointer user_data)
7994 {
7995         struct device_connect_data *data = user_data;
7996         struct btd_adapter *adapter = data->adapter;
7997         struct btd_device *device;
7998         const char *path;
7999
8000         DBG("%s", gerr ? gerr->message : "");
8001
8002         if (gerr)
8003                 goto failed;
8004
8005         /* object might already exist due to mgmt socket event */
8006         device = btd_adapter_get_device(adapter, &data->dst, data->dst_type);
8007         if (!device)
8008                 goto failed;
8009
8010         path = device_get_path(device);
8011
8012         g_dbus_send_reply(dbus_conn, data->msg, DBUS_TYPE_OBJECT_PATH, &path,
8013                                                         DBUS_TYPE_INVALID);
8014
8015         /* continue with service discovery and connection */
8016         btd_device_set_temporary(device, false);
8017 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8018         device_update_last_seen(device, data->dst_type);
8019 #else
8020         device_update_last_seen(device, data->dst_type, true);
8021 #endif
8022
8023         if (data->dst_type != BDADDR_BREDR){
8024                 g_io_channel_set_close_on_unref(io, FALSE);
8025                 device_attach_att(device, io);
8026         }
8027
8028         device_discover_services(device);
8029         device_wait_for_svc_complete(device, device_browse_cb, NULL);
8030
8031         g_io_channel_unref(io);
8032         dbus_message_unref(data->msg);
8033         free(data);
8034         return;
8035
8036 failed:
8037         g_dbus_send_error(dbus_conn, data->msg, "org.bluez.Failed", NULL);
8038         g_io_channel_unref(io);
8039         dbus_message_unref(data->msg);
8040         free(data);
8041 }
8042
8043 static void device_connect(struct btd_adapter *adapter, const bdaddr_t *dst,
8044                                         uint8_t dst_type, DBusMessage *msg)
8045 {
8046         struct device_connect_data *data;
8047         GIOChannel *io;
8048
8049         data = new0(struct device_connect_data, 1);
8050         data->adapter = adapter;
8051         bacpy(&data->dst, dst);
8052         data->dst_type = dst_type;
8053         data->msg = dbus_message_ref(msg);
8054
8055         if (dst_type == BDADDR_BREDR)
8056                 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
8057                                 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
8058                                 BT_IO_OPT_SOURCE_TYPE, BDADDR_BREDR,
8059                                 BT_IO_OPT_DEST_BDADDR, dst,
8060                                 BT_IO_OPT_DEST_TYPE, BDADDR_BREDR,
8061                                 BT_IO_OPT_PSM, SDP_PSM,
8062                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
8063                                 BT_IO_OPT_INVALID);
8064         else
8065                 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
8066                                 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
8067                                 BT_IO_OPT_SOURCE_TYPE, adapter->bdaddr_type,
8068                                 BT_IO_OPT_DEST_BDADDR, dst,
8069                                 BT_IO_OPT_DEST_TYPE, dst_type,
8070                                 BT_IO_OPT_CID, ATT_CID,
8071                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
8072                                 BT_IO_OPT_INVALID);
8073
8074         if (!io) {
8075                 g_dbus_send_message(dbus_conn,
8076                                 btd_error_failed(msg, "Connect failed"));
8077                 dbus_message_unref(data->msg);
8078                 free(data);
8079         }
8080 }
8081
8082 static DBusMessage *connect_device(DBusConnection *conn,
8083                                         DBusMessage *msg, void *user_data)
8084 {
8085         struct btd_adapter *adapter = user_data;
8086         DBusMessageIter iter, subiter, dictiter, value;
8087         uint8_t addr_type = BDADDR_BREDR;
8088         bdaddr_t addr = *BDADDR_ANY;
8089
8090         DBG("sender %s", dbus_message_get_sender(msg));
8091
8092         if (!btd_adapter_get_powered(adapter))
8093                 return btd_error_not_ready(msg);
8094
8095         dbus_message_iter_init(msg, &iter);
8096         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
8097             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
8098                 return btd_error_invalid_args(msg);
8099
8100         dbus_message_iter_recurse(&iter, &subiter);
8101         while (true) {
8102                 int type = dbus_message_iter_get_arg_type(&subiter);
8103                 char *key;
8104                 char *str;
8105
8106                 if (type == DBUS_TYPE_INVALID)
8107                         break;
8108
8109                 dbus_message_iter_recurse(&subiter, &dictiter);
8110
8111                 dbus_message_iter_get_basic(&dictiter, &key);
8112                 if (!dbus_message_iter_next(&dictiter))
8113                         return btd_error_invalid_args(msg);
8114
8115                 if (dbus_message_iter_get_arg_type(&dictiter) !=
8116                                                         DBUS_TYPE_VARIANT)
8117                         return btd_error_invalid_args(msg);
8118
8119                 dbus_message_iter_recurse(&dictiter, &value);
8120
8121                 if (!strcmp(key, "Address")) {
8122                         if (dbus_message_iter_get_arg_type(&value) !=
8123                                                         DBUS_TYPE_STRING)
8124                                 return btd_error_invalid_args(msg);
8125
8126                         dbus_message_iter_get_basic(&value, &str);
8127
8128                         if (str2ba(str, &addr) < 0 )
8129                                 return btd_error_invalid_args(msg);
8130                 } else if (!strcmp(key, "AddressType")) {
8131                         if (dbus_message_iter_get_arg_type(&value) !=
8132                                                         DBUS_TYPE_STRING)
8133                                 return btd_error_invalid_args(msg);
8134
8135                         dbus_message_iter_get_basic(&value, &str);
8136
8137
8138                         if (!strcmp(str, "public"))
8139                                 addr_type = BDADDR_LE_PUBLIC;
8140                         else if (!strcmp(str, "random"))
8141                                 addr_type = BDADDR_LE_RANDOM;
8142                         else
8143                                 return btd_error_invalid_args(msg);
8144                 } else {
8145                         return btd_error_invalid_args(msg);
8146                 }
8147
8148                 dbus_message_iter_next(&subiter);
8149         }
8150
8151         if (!bacmp(&addr, BDADDR_ANY))
8152                 return btd_error_invalid_args(msg);
8153
8154         device_connect(adapter, &addr, addr_type, msg);
8155         return NULL;
8156 }
8157
8158 static void update_device_allowed_services(void *data, void *user_data)
8159 {
8160         struct btd_device *device = data;
8161
8162         btd_device_update_allowed_services(device);
8163 }
8164
8165 static void add_uuid_to_uuid_set(void *data, void *user_data)
8166 {
8167         bt_uuid_t *uuid = data;
8168         GHashTable *uuid_set = user_data;
8169
8170         if (!uuid) {
8171                 error("Found NULL in UUID allowed list");
8172                 return;
8173         }
8174
8175         g_hash_table_add(uuid_set, uuid);
8176 }
8177
8178 static guint bt_uuid_hash(gconstpointer key)
8179 {
8180         const bt_uuid_t *uuid = key;
8181         uint64_t uuid_128[2];
8182
8183         if (!uuid)
8184                 return 0;
8185
8186         bt_uuid_to_uuid128(uuid, (bt_uuid_t *)uuid_128);
8187
8188         return g_int64_hash(uuid_128) ^ g_int64_hash(uuid_128+1);
8189 }
8190
8191 static gboolean bt_uuid_equal(gconstpointer v1, gconstpointer v2)
8192 {
8193         const bt_uuid_t *uuid1 = v1;
8194         const bt_uuid_t *uuid2 = v2;
8195
8196         if (!uuid1 || !uuid2)
8197                 return !uuid1 && !uuid2;
8198
8199         return bt_uuid_cmp(uuid1, uuid2) == 0;
8200 }
8201
8202 bool btd_adapter_set_allowed_uuids(struct btd_adapter *adapter,
8203                                                         struct queue *uuids)
8204 {
8205         if (!adapter)
8206                 return false;
8207
8208         if (adapter->allowed_uuid_set)
8209                 g_hash_table_destroy(adapter->allowed_uuid_set);
8210
8211         adapter->allowed_uuid_set = g_hash_table_new(bt_uuid_hash,
8212                                                                 bt_uuid_equal);
8213         if (!adapter->allowed_uuid_set) {
8214                 btd_error(adapter->dev_id,
8215                                         "Failed to allocate allowed_uuid_set");
8216                 return false;
8217         }
8218
8219         queue_foreach(uuids, add_uuid_to_uuid_set, adapter->allowed_uuid_set);
8220         g_slist_foreach(adapter->devices, update_device_allowed_services, NULL);
8221
8222         return true;
8223 }
8224
8225 bool btd_adapter_is_uuid_allowed(struct btd_adapter *adapter,
8226                                                         const char *uuid_str)
8227 {
8228         bt_uuid_t uuid;
8229
8230         if (!adapter || !adapter->allowed_uuid_set)
8231                 return true;
8232
8233         if (bt_string_to_uuid(&uuid, uuid_str)) {
8234                 btd_error(adapter->dev_id,
8235                                 "Failed to parse UUID string '%s'", uuid_str);
8236                 return false;
8237         }
8238
8239         return !g_hash_table_size(adapter->allowed_uuid_set) ||
8240                 g_hash_table_contains(adapter->allowed_uuid_set, &uuid);
8241 }
8242
8243 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8244 static DBusMessage *adapter_unpair_device(DBusConnection *conn,
8245                                         DBusMessage *msg, void *user_data)
8246 {
8247         DBG("+");
8248         struct btd_adapter *adapter = user_data;
8249         struct btd_device *device;
8250         const char *path;
8251         GSList *list;
8252
8253         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
8254                                                 DBUS_TYPE_INVALID) == FALSE)
8255                 return btd_error_invalid_args(msg);
8256
8257         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
8258         if (!list)
8259                 return btd_error_does_not_exist(msg);
8260
8261         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8262                 return btd_error_not_ready(msg);
8263
8264         device = list->data;
8265
8266         btd_device_set_temporary(device, TRUE);
8267
8268         if (!btd_device_is_connected(device)) {
8269                 btd_adapter_unpair_device(adapter, device);
8270                 return dbus_message_new_method_return(msg);
8271         }
8272
8273         device_request_disconnect(device, msg);
8274
8275         DBG("-");
8276         return NULL;
8277 }
8278
8279 static DBusMessage *create_device(DBusConnection *conn,
8280                                         DBusMessage *msg, void *data)
8281 {
8282         struct btd_adapter *adapter = data;
8283         const gchar *address;
8284         bdaddr_t addr;
8285         DBG("+");
8286
8287         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8288                                                 DBUS_TYPE_INVALID) == FALSE)
8289                 return btd_error_invalid_args(msg);
8290
8291         if (bachk(address) < 0)
8292                 return btd_error_invalid_args(msg);
8293
8294         DBG("%s", address);
8295
8296         str2ba(address, &addr);
8297         btd_adapter_get_device(adapter, &addr, BDADDR_BREDR);
8298
8299         DBG("-");
8300         return dbus_message_new_method_return(msg);
8301 }
8302
8303 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
8304                                         void *data)
8305 {
8306         struct btd_adapter *adapter = data;
8307         struct btd_device *device;
8308         DBusMessage *reply;
8309         const gchar *address;
8310         GSList *l;
8311         const gchar *dev_path;
8312
8313         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
8314                                 DBUS_TYPE_INVALID))
8315                 return btd_error_invalid_args(msg);
8316
8317         l = g_slist_find_custom(adapter->devices, address, device_rpa_cmp);
8318         if (!l)
8319                 l = g_slist_find_custom(adapter->devices, address,
8320                                                         device_address_cmp);
8321         if (!l)
8322                 return btd_error_does_not_exist(msg);
8323
8324         device = l->data;
8325
8326         reply = dbus_message_new_method_return(msg);
8327         if (!reply)
8328                 return NULL;
8329
8330         dev_path = device_get_path(device);
8331
8332         dbus_message_append_args(reply,
8333                         DBUS_TYPE_OBJECT_PATH, &dev_path,
8334                         DBUS_TYPE_INVALID);
8335
8336         return reply;
8337 }
8338
8339 static gboolean adapter_ipsp_connected(struct btd_adapter *adapter)
8340 {
8341         GSList *l, *next;
8342
8343         DBG("%s", adapter->path);
8344
8345         for (l = adapter->connections; l != NULL; l = next) {
8346                 struct btd_device *dev = l->data;
8347
8348                 next = g_slist_next(l);
8349
8350                 if (device_is_ipsp_connected(dev))
8351                         return TRUE;
8352         }
8353
8354         return FALSE;
8355 }
8356
8357 static void adapter_set_ipsp_init_state(struct btd_adapter *adapter, gboolean initialized)
8358 {
8359         if (adapter->ipsp_intialized == initialized)
8360                 return;
8361
8362         adapter->ipsp_intialized = initialized;
8363
8364         g_dbus_emit_property_changed(dbus_conn, adapter->path,
8365                                                 ADAPTER_INTERFACE, "IpspInitStateChanged");
8366 }
8367
8368 static void deinitialize_6lowpan_complete(uint8_t status, uint16_t length,
8369         const void *param, void *user_data)
8370 {
8371         struct btd_adapter *adapter = user_data;
8372         bool initialized = FALSE;
8373
8374         if (status != MGMT_STATUS_SUCCESS)
8375                 error("De-Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
8376                         adapter->dev_id, mgmt_errstr(status), status);
8377         else {
8378                 adapter_set_ipsp_init_state(adapter, initialized);
8379                 DBG("De-Initialize BT 6lowpan successfully for hci%u",
8380                         adapter->dev_id);
8381         }
8382 }
8383
8384 static bool deinitialize_6lowpan(struct btd_adapter *adapter)
8385 {
8386         struct mgmt_cp_enable_6lowpan cp;
8387
8388         memset(&cp, 0, sizeof(cp));
8389
8390         cp.enable_6lowpan = DEINIT_6LOWPAN;
8391         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
8392                         adapter->dev_id, sizeof(cp), &cp,
8393                         deinitialize_6lowpan_complete, adapter, NULL) > 0)
8394                 return true;
8395
8396         error("Failed to de-initialize BT 6Lowpan for index %u",
8397                 adapter->dev_id);
8398         return false;
8399 }
8400
8401 static void initialize_6lowpan_complete(uint8_t status, uint16_t length,
8402         const void *param, void *user_data)
8403 {
8404         struct btd_adapter *adapter = user_data;
8405         bool initialized = TRUE;
8406
8407         if (status != MGMT_STATUS_SUCCESS)
8408                 error("Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
8409                         adapter->dev_id, mgmt_errstr(status), status);
8410         else {
8411                 adapter_set_ipsp_init_state(adapter, initialized);
8412                 DBG("Initialize BT 6lowpan successfully for hci%u",
8413                         adapter->dev_id);
8414         }
8415 }
8416
8417 static bool initialize_6lowpan(struct btd_adapter *adapter)
8418 {
8419         struct mgmt_cp_enable_6lowpan cp;
8420
8421         memset(&cp, 0, sizeof(cp));
8422
8423         cp.enable_6lowpan = INIT_6LOWPAN;
8424         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
8425                         adapter->dev_id, sizeof(cp), &cp,
8426                         initialize_6lowpan_complete, adapter, NULL) > 0)
8427                 return true;
8428
8429         error("Failed to initialize BT 6Lowpan for index %u",
8430                 adapter->dev_id);
8431         return false;
8432 }
8433
8434 static DBusMessage *adapter_initialize_ipsp(DBusConnection *conn,
8435                                         DBusMessage *msg, void *data)
8436 {
8437         struct btd_adapter *adapter = data;
8438         dbus_bool_t err;
8439
8440         DBG("Initialize IPSP");
8441
8442         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8443                 return btd_error_not_ready(msg);
8444
8445         if (adapter->ipsp_intialized)
8446                 return btd_error_already_exists(msg);
8447
8448         /* Enable BT 6lowpan in kernel */
8449         err = initialize_6lowpan(adapter);
8450
8451         if (!err)
8452                 return btd_error_failed(msg, "Failed to initialize BT 6lowpan");
8453
8454         return dbus_message_new_method_return(msg);
8455 }
8456
8457 static DBusMessage *adapter_deinitialize_ipsp(DBusConnection *conn,
8458                                         DBusMessage *msg, void *data)
8459 {
8460         struct btd_adapter *adapter = data;
8461         dbus_bool_t err;
8462
8463         DBG("De-initialize IPSP");
8464
8465         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
8466                 return btd_error_not_ready(msg);
8467
8468         if (!adapter->ipsp_intialized)
8469                 return btd_error_not_permitted(msg, "IPSP not initialized");
8470
8471         if (adapter_ipsp_connected(adapter))
8472                 return btd_error_not_permitted(msg, "IPSP Client device found connected");
8473
8474         /* Disable BT 6lowpan in kernel */
8475         err = deinitialize_6lowpan(adapter);
8476
8477         if (!err)
8478                 return btd_error_failed(msg, "Failed to deinitialize BT 6lowpan");
8479
8480         return dbus_message_new_method_return(msg);
8481 }
8482 #endif
8483
8484 static const GDBusMethodTable adapter_methods[] = {
8485         { GDBUS_ASYNC_METHOD("StartDiscovery", NULL, NULL, start_discovery) },
8486         { GDBUS_METHOD("SetDiscoveryFilter",
8487                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8488                                 set_discovery_filter) },
8489         { GDBUS_ASYNC_METHOD("StopDiscovery", NULL, NULL, stop_discovery) },
8490 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8491         { GDBUS_METHOD("GetPSML2capLE",
8492                         GDBUS_ARGS({ "path", "o"}),
8493                         GDBUS_ARGS({ "psm", "i" }),
8494                         adapter_get_psm_l2cap_le) },
8495         { GDBUS_METHOD("ListenL2capLESocket",
8496                         GDBUS_ARGS({ "path", "o"}, { "psm", "i" }, { "options", "a{sv}" }),
8497                         NULL, adapter_listen_l2cap_le_socket) },
8498         { GDBUS_METHOD("RemoveL2capLESocket", GDBUS_ARGS({ "path", "o" }),
8499                         NULL, adapter_remove_l2cap_le_socket) },
8500         { GDBUS_METHOD("StartCustomDiscovery",
8501                         GDBUS_ARGS({ "type", "s" }), NULL,
8502                         adapter_start_custom_discovery) },
8503         { GDBUS_METHOD("StartLEDiscovery", NULL, NULL,
8504                         adapter_start_le_discovery) },
8505         { GDBUS_ASYNC_METHOD("StopLEDiscovery", NULL, NULL,
8506                         adapter_stop_le_discovery) },
8507         { GDBUS_METHOD("SetAdvertising",
8508                         GDBUS_ARGS({ "enable", "b" },
8509                                 { "slot_id", "i" }), NULL,
8510                         adapter_set_advertising) },
8511         { GDBUS_METHOD("SetAdvertisingParameters",
8512                         GDBUS_ARGS({ "interval_min", "u" },
8513                                 { "interval_max", "u" },
8514                                 { "filter_policy", "u" },
8515                                 { "type", "u" },
8516                                 { "tx_power_level", "i" },
8517                                 { "slot_id", "i" }), NULL,
8518                         adapter_set_advertising_params) },
8519         { GDBUS_METHOD("SetAdvertisingData",
8520                         GDBUS_ARGS({ "value", "ay" },
8521                                 { "slot_id", "i" }), NULL,
8522                         adapter_set_advertising_data) },
8523         { GDBUS_METHOD("SetScanParameters",
8524                         GDBUS_ARGS({ "type", "u" },
8525                                 { "interval", "u" },
8526                                 { "window", "u" }), NULL,
8527                         adapter_le_set_scan_params) },
8528         { GDBUS_METHOD("GetLocalIrk",
8529                                 NULL,
8530                                 GDBUS_ARGS({ "value", "ay" }),
8531                         adapter_get_local_irk) },
8532         { GDBUS_ASYNC_METHOD("scan_filter_param_setup",
8533                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
8534                                 { "filt_index", "i" }, { "feat_seln", "i"},
8535                                 { "list_logic_type", "i" }, { "filt_logic_type", "i"},
8536                                 { "rssi_high_thres", "i" }, { "rssi_low_thres", "i"},
8537                                 { "dely_mode", "i" }, { "found_timeout", "i"},
8538                                 { "lost_timeout", "i" }, { "found_timeout_cnt", "i"}), NULL,
8539                         adapter_le_scan_filter_param_setup) },
8540         { GDBUS_ASYNC_METHOD("scan_filter_add_remove",
8541                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
8542                                 { "filt_type", "i" }, { "filt_index", "i"},
8543                                 { "company_id", "i" }, { "company_id_mask", "i"},
8544                                 { "p_uuid", "ay" }, { "p_uuid_mask", "ay" },
8545                                 { "string", "s" }, { "address_type", "u" },
8546                                 /*{ "data_len", "i" },*/ { "p_data", "ay" },
8547                                 /*{ "mask_len", "i" },*/ { "p_mask", "ay" }), NULL,
8548                         adapter_le_scan_filter_add_remove) },
8549         { GDBUS_ASYNC_METHOD("scan_filter_clear",
8550                         GDBUS_ARGS({ "client_if", "i" }, { "filt_index", "i" }), NULL,
8551                         adapter_le_scan_filter_clear) },
8552         { GDBUS_ASYNC_METHOD("scan_filter_enable",
8553                         GDBUS_ARGS({ "client_if", "i" }, { "enable", "b" }), NULL,
8554                         adapter_le_scan_filter_enable) },
8555         { GDBUS_METHOD("InitializeIpsp",
8556                         NULL, NULL,
8557                         adapter_initialize_ipsp) },
8558         { GDBUS_METHOD("DeinitializeIpsp",
8559                         NULL, NULL,
8560                         adapter_deinitialize_ipsp) },
8561         { GDBUS_METHOD("SetScanRespData",
8562                         GDBUS_ARGS({ "value", "ay" },
8563                                 { "slot_id", "i" }), NULL,
8564                         adapter_set_scan_rsp_data) },
8565         { GDBUS_METHOD("AddDeviceWhiteList",
8566                         GDBUS_ARGS({ "address", "s" },
8567                                 { "address_type", "u" }), NULL,
8568                         adapter_add_device_white_list) },
8569         { GDBUS_METHOD("RemoveDeviceWhiteList",
8570                         GDBUS_ARGS({ "address", "s" },
8571                                 { "address_type", "u" }), NULL,
8572                         adapter_remove_device_white_list) },
8573         { GDBUS_METHOD("ClearDeviceWhiteList",
8574                         NULL, NULL,
8575                         adapter_clear_device_white_list) },
8576         { GDBUS_METHOD("SetLePrivacy",
8577                         GDBUS_ARGS({ "enable", "b" }), NULL,
8578                         adapter_set_le_privacy) },
8579         { GDBUS_METHOD("SetLeStaticRandomAddress",
8580                         GDBUS_ARGS({ "enable", "b" }), NULL,
8581                         adapter_set_le_static_address) },
8582         { GDBUS_ASYNC_METHOD("EnableRssi",
8583                         GDBUS_ARGS({ "bt_address", "s" },
8584                                 { "link_type", "i" },
8585                                 { "low_th", "i" },
8586                                 { "in_range_th", "i" },
8587                                 { "high_th", "i"}),
8588                         NULL,
8589                         adapter_enable_rssi) },
8590         { GDBUS_ASYNC_METHOD("GetRssiStrength",
8591                         GDBUS_ARGS({ "bt_address", "s" }, { "link_type", "i" }),
8592                         NULL,
8593                         adapter_get_rssi) },
8594         { GDBUS_ASYNC_METHOD("UnpairDevice",
8595                         GDBUS_ARGS({ "device", "o" }), NULL, adapter_unpair_device) },
8596         { GDBUS_METHOD("FindDevice",
8597                         GDBUS_ARGS({ "address", "s" }),
8598                         GDBUS_ARGS({ "device", "o" }),
8599                         find_device) },
8600         { GDBUS_METHOD("SetWbsParameters",
8601                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8602                         NULL,
8603                         set_wbs_parameters) },
8604         { GDBUS_METHOD("SetNbParameters",
8605                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
8606                         NULL,
8607                         set_nb_parameters) },
8608         { GDBUS_METHOD("SetManufacturerData",
8609                         GDBUS_ARGS({ "value", "ay" }), NULL,
8610                         adapter_set_manufacturer_data) },
8611         { GDBUS_ASYNC_METHOD("CreateDevice",
8612                         GDBUS_ARGS({ "address", "s" }), NULL,
8613                         create_device) },
8614         { GDBUS_METHOD("GetEnergyInfo",
8615                         NULL,
8616                         GDBUS_ARGS({ "tx_time", "u" },
8617                                 { "rx_time", "u" },
8618                                 { "idle_time", "u" },
8619                                 { "energy_used", "u" }),
8620                         adapter_get_energy_info) },
8621 #endif
8622         { GDBUS_ASYNC_METHOD("RemoveDevice",
8623                         GDBUS_ARGS({ "device", "o" }), NULL, remove_device) },
8624 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8625         { GDBUS_ASYNC_METHOD("LEReadMaximumDataLength", NULL,
8626                         GDBUS_ARGS({"maxTxOctets", "q" }, { "maxTxTime", "q" },
8627                                 {"maxRxOctets", "q" }, { "maxRxTime", "q" }),
8628                         le_read_maximum_data_length)},
8629         { GDBUS_ASYNC_METHOD("LEWriteHostSuggestedDataLength",
8630                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }), NULL,
8631                         le_write_host_suggested_default_data_length)},
8632         { GDBUS_ASYNC_METHOD("LEReadHostSuggestedDataLength", NULL,
8633                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }),
8634                         le_read_host_suggested_default_data_length)},
8635         { GDBUS_ASYNC_METHOD("GetLeBatchingAvailablePkts",
8636                         NULL,
8637                         GDBUS_ARGS({ "AvailablePkts", "u" }),
8638                         adapter_get_le_batching_available_pkts) },
8639         { GDBUS_ASYNC_METHOD("EnableLeBatching",
8640                         GDBUS_ARGS({ "bt_address", "s" },
8641                                 { "packet_threshold", "i" },
8642                                 { "timeout", "i"}),
8643                         NULL,
8644                         adapter_enable_le_batching) },
8645         { GDBUS_ASYNC_METHOD("DisableLeBatching",
8646                         GDBUS_ARGS({ "bt_address", "s" }),
8647                         NULL,
8648                         adapter_disable_le_batching) },
8649 #endif
8650         { GDBUS_METHOD("GetDiscoveryFilters", NULL,
8651                         GDBUS_ARGS({ "filters", "as" }),
8652                         get_discovery_filters) },
8653         { GDBUS_EXPERIMENTAL_ASYNC_METHOD("ConnectDevice",
8654                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8655                                 connect_device) },
8656         { }
8657 };
8658
8659 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8660 static const GDBusSignalTable adapter_signals[] = {
8661         { GDBUS_SIGNAL("AdvertisingEnabled",
8662                         GDBUS_ARGS({ "slot_id", "i" },
8663                                         { "enabled", "b"})) },
8664         { GDBUS_SIGNAL("RssiEnabled",
8665                         GDBUS_ARGS({"address","s"},
8666                                         { "link_type", "i" },
8667                                         { "enabled", "b"})) },
8668         { GDBUS_SIGNAL("RssiAlert",
8669                         GDBUS_ARGS({"address","s"},
8670                                         { "link_type", "i" },
8671                                         { "alert_type", "i" },
8672                                         { "rssi_dbm", "i"})) },
8673         { GDBUS_SIGNAL("RawRssi",
8674                         GDBUS_ARGS({"address","s"},
8675                                         { "link_type", "i" },
8676                                         { "rssi_dbm", "i"})) },
8677         { GDBUS_SIGNAL("HardwareError", NULL) },
8678         { GDBUS_SIGNAL("TxTimeoutError", NULL) },
8679         { }
8680 };
8681 #endif
8682
8683 static const GDBusPropertyTable adapter_properties[] = {
8684         { "Address", "s", property_get_address },
8685         { "AddressType", "s", property_get_address_type },
8686         { "Name", "s", property_get_name },
8687         { "Alias", "s", property_get_alias, property_set_alias },
8688         { "Class", "u", property_get_class },
8689         { "Powered", "b", property_get_powered, property_set_powered },
8690         { "PowerState", "s", property_get_power_state, NULL, NULL,
8691                              G_DBUS_PROPERTY_FLAG_EXPERIMENTAL },
8692         { "Discoverable", "b", property_get_discoverable,
8693                                         property_set_discoverable },
8694         { "DiscoverableTimeout", "u", property_get_discoverable_timeout,
8695                                         property_set_discoverable_timeout },
8696         { "Pairable", "b", property_get_pairable, property_set_pairable },
8697         { "PairableTimeout", "u", property_get_pairable_timeout,
8698                                         property_set_pairable_timeout },
8699         { "Discovering", "b", property_get_discovering },
8700 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8701         { "LEDiscovering", "b", property_get_le_discovering },
8702 #endif
8703         { "UUIDs", "as", property_get_uuids },
8704         { "Modalias", "s", property_get_modalias, NULL,
8705                                         property_exists_modalias },
8706         { "Roles", "as", property_get_roles },
8707         { "ExperimentalFeatures", "as", property_get_experimental, NULL,
8708                                         property_experimental_exists },
8709 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8710         { "Connectable", "b", property_get_connectable,
8711                                         property_set_connectable },
8712         { "Version", "s", property_get_version },
8713         { "SupportedLEFeatures", "as", property_get_supported_le_features},
8714         { "IpspInitStateChanged", "b", property_get_ipsp_init_state},
8715         { "LEAddress", "as", property_get_le_address },
8716         { "A2dpRole", "u", property_get_a2dp_role },
8717 #endif
8718
8719         { }
8720 };
8721
8722 static int str2buf(const char *str, uint8_t *buf, size_t blen)
8723 {
8724         int i, dlen;
8725
8726         if (str == NULL)
8727                 return -EINVAL;
8728
8729         memset(buf, 0, blen);
8730
8731         dlen = MIN((strlen(str) / 2), blen);
8732
8733         for (i = 0; i < dlen; i++)
8734                 sscanf(str + (i * 2), "%02hhX", &buf[i]);
8735
8736         return 0;
8737 }
8738
8739 static bool is_blocked_key(uint8_t key_type, uint8_t *key_value)
8740 {
8741         uint32_t i = 0;
8742
8743         for (i = 0; i < ARRAY_SIZE(blocked_keys); ++i) {
8744                 if (key_type == blocked_keys[i].type &&
8745                                 !memcmp(blocked_keys[i].val, key_value,
8746                                                 sizeof(blocked_keys[i].val)))
8747                         return true;
8748         }
8749
8750         return false;
8751 }
8752
8753 static struct link_key_info *get_key_info(GKeyFile *key_file, const char *peer)
8754 {
8755         struct link_key_info *info = NULL;
8756         char *str;
8757
8758         str = g_key_file_get_string(key_file, "LinkKey", "Key", NULL);
8759         if (!str || strlen(str) < 32)
8760                 goto failed;
8761
8762         info = g_new0(struct link_key_info, 1);
8763
8764         str2ba(peer, &info->bdaddr);
8765
8766         if (!strncmp(str, "0x", 2))
8767                 str2buf(&str[2], info->key, sizeof(info->key));
8768         else
8769                 str2buf(&str[0], info->key, sizeof(info->key));
8770
8771         info->type = g_key_file_get_integer(key_file, "LinkKey", "Type", NULL);
8772         info->pin_len = g_key_file_get_integer(key_file, "LinkKey", "PINLength",
8773                                                 NULL);
8774
8775         info->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8776                                                                 info->key);
8777
8778 failed:
8779         g_free(str);
8780
8781         return info;
8782 }
8783
8784 static struct smp_ltk_info *get_ltk(GKeyFile *key_file, const char *peer,
8785                                         uint8_t peer_type, const char *group)
8786 {
8787         struct smp_ltk_info *ltk = NULL;
8788         char *key;
8789         char *rand = NULL;
8790
8791         key = g_key_file_get_string(key_file, group, "Key", NULL);
8792         if (!key || strlen(key) < 32)
8793                 goto failed;
8794
8795         rand = g_key_file_get_string(key_file, group, "Rand", NULL);
8796         if (!rand)
8797                 goto failed;
8798
8799         ltk = g_new0(struct smp_ltk_info, 1);
8800
8801         /* Default to assuming a central key */
8802         ltk->central = true;
8803
8804         str2ba(peer, &ltk->bdaddr);
8805         ltk->bdaddr_type = peer_type;
8806
8807         /*
8808          * Long term keys should respond to an identity address which can
8809          * either be a public address or a random static address. Keys
8810          * stored for resolvable random and unresolvable random addresses
8811          * are ignored.
8812          *
8813          * This is an extra sanity check for older kernel versions or older
8814          * daemons that might have been instructed to store long term keys
8815          * for these temporary addresses.
8816          */
8817         if (ltk->bdaddr_type == BDADDR_LE_RANDOM &&
8818                                         (ltk->bdaddr.b[5] & 0xc0) != 0xc0) {
8819                 g_free(ltk);
8820                 ltk = NULL;
8821                 goto failed;
8822         }
8823
8824         if (!strncmp(key, "0x", 2))
8825                 str2buf(&key[2], ltk->val, sizeof(ltk->val));
8826         else
8827                 str2buf(&key[0], ltk->val, sizeof(ltk->val));
8828
8829         if (!strncmp(rand, "0x", 2)) {
8830                 uint64_t rand_le;
8831                 str2buf(&rand[2], (uint8_t *) &rand_le, sizeof(rand_le));
8832                 ltk->rand = le64_to_cpu(rand_le);
8833         } else {
8834                 sscanf(rand, "%" PRIu64, &ltk->rand);
8835         }
8836
8837         ltk->authenticated = g_key_file_get_integer(key_file, group,
8838                                                         "Authenticated", NULL);
8839         ltk->enc_size = g_key_file_get_integer(key_file, group, "EncSize",
8840                                                                         NULL);
8841         ltk->ediv = g_key_file_get_integer(key_file, group, "EDiv", NULL);
8842
8843         ltk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LTK,
8844                                                                 ltk->val);
8845
8846 failed:
8847         g_free(key);
8848         g_free(rand);
8849
8850         return ltk;
8851 }
8852
8853 static struct smp_ltk_info *get_ltk_info(GKeyFile *key_file, const char *peer,
8854                                                         uint8_t bdaddr_type)
8855 {
8856         DBG("%s", peer);
8857
8858         return get_ltk(key_file, peer, bdaddr_type, "LongTermKey");
8859 }
8860
8861 static struct smp_ltk_info *get_peripheral_ltk_info(GKeyFile *key_file,
8862                                                         const char *peer,
8863                                                         uint8_t bdaddr_type)
8864 {
8865         struct smp_ltk_info *ltk;
8866
8867         DBG("%s", peer);
8868
8869         /* Peripheral* is the proper term, but for now read both entries
8870          * so it won't break when user up/downgrades. Remove the other
8871          * term after a few releases.
8872          */
8873         ltk = get_ltk(key_file, peer, bdaddr_type, "PeripheralLongTermKey");
8874         if (!ltk)
8875                 ltk = get_ltk(key_file, peer, bdaddr_type, "SlaveLongTermKey");
8876
8877         if (ltk)
8878                 ltk->central = false;
8879
8880         return ltk;
8881 }
8882
8883 static struct irk_info *get_irk_info(GKeyFile *key_file, const char *peer,
8884                                                         uint8_t bdaddr_type)
8885 {
8886         struct irk_info *irk = NULL;
8887         char *str;
8888
8889         str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
8890 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8891         if (!str)
8892                 return NULL;
8893         if (strlen(str) < 32) {
8894                 g_free(str);
8895                 return NULL;
8896         }
8897 #else
8898         if (!str || strlen(str) < 32)
8899                 goto failed;
8900 #endif
8901
8902         irk = g_new0(struct irk_info, 1);
8903
8904         str2ba(peer, &irk->bdaddr);
8905         irk->bdaddr_type = bdaddr_type;
8906
8907         if (!strncmp(str, "0x", 2))
8908                 str2buf(&str[2], irk->val, sizeof(irk->val));
8909         else
8910                 str2buf(&str[0], irk->val, sizeof(irk->val));
8911
8912         irk->is_blocked = is_blocked_key(HCI_BLOCKED_KEY_TYPE_LINKKEY,
8913                                                                 irk->val);
8914
8915 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
8916 failed:
8917 #endif
8918         g_free(str);
8919
8920         return irk;
8921 }
8922
8923 static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
8924                                                         uint8_t bdaddr_type)
8925 {
8926         struct conn_param *param;
8927
8928         if (!g_key_file_has_group(key_file, "ConnectionParameters"))
8929                 return NULL;
8930
8931         param = g_new0(struct conn_param, 1);
8932
8933         param->min_interval = g_key_file_get_integer(key_file,
8934                                                         "ConnectionParameters",
8935                                                         "MinInterval", NULL);
8936         param->max_interval = g_key_file_get_integer(key_file,
8937                                                         "ConnectionParameters",
8938                                                         "MaxInterval", NULL);
8939         param->latency = g_key_file_get_integer(key_file,
8940                                                         "ConnectionParameters",
8941                                                         "Latency", NULL);
8942         param->timeout = g_key_file_get_integer(key_file,
8943                                                         "ConnectionParameters",
8944                                                         "Timeout", NULL);
8945         str2ba(peer, &param->bdaddr);
8946         param->bdaddr_type = bdaddr_type;
8947
8948         return param;
8949 }
8950
8951 #if 0
8952 static int generate_and_write_irk(uint8_t *irk, GKeyFile *key_file,
8953                                                         const char *filename)
8954 {
8955         struct bt_crypto *crypto;
8956         char str_irk_out[33];
8957         gsize length = 0;
8958         GError *gerr = NULL;
8959         char *str;
8960         int i;
8961
8962         crypto = bt_crypto_new();
8963         if (!crypto) {
8964                 error("Failed to open crypto");
8965                 return -1;
8966         }
8967
8968         if (!bt_crypto_random_bytes(crypto, irk, 16)) {
8969                 error("Failed to generate IRK");
8970                 bt_crypto_unref(crypto);
8971                 return -1;
8972         }
8973
8974         bt_crypto_unref(crypto);
8975
8976         for (i = 0; i < 16; i++)
8977                 sprintf(str_irk_out + (i * 2), "%02x", irk[i]);
8978
8979         str_irk_out[32] = '\0';
8980         info("Generated IRK successfully");
8981
8982         g_key_file_set_string(key_file, "General", "IdentityResolvingKey",
8983                                                                 str_irk_out);
8984         create_file(filename, S_IRUSR | S_IWUSR);
8985         str = g_key_file_to_data(key_file, &length, NULL);
8986         if (!g_file_set_contents(filename, str, length, &gerr)) {
8987                 error("Unable set contents for %s: (%s)", filename,
8988                                                                 gerr->message);
8989                 g_error_free(gerr);
8990         }
8991         g_free(str);
8992         DBG("Generated IRK written to file");
8993         return 0;
8994 }
8995
8996 static int load_irk(struct btd_adapter *adapter, uint8_t *irk)
8997 {
8998         char filename[PATH_MAX];
8999         GKeyFile *key_file;
9000         GError *gerr = NULL;
9001         char *str_irk;
9002         int ret;
9003
9004         create_filename(filename, PATH_MAX, "/%s/identity",
9005                                         btd_adapter_get_storage_dir(adapter));
9006
9007         key_file = g_key_file_new();
9008         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
9009                 error("Unable to load key file from %s: (%s)", filename,
9010                                                                 gerr->message);
9011                 g_error_free(gerr);
9012         }
9013
9014         str_irk = g_key_file_get_string(key_file, "General",
9015                                                 "IdentityResolvingKey", NULL);
9016         if (!str_irk) {
9017                 info("No IRK stored");
9018                 ret = generate_and_write_irk(irk, key_file, filename);
9019                 g_key_file_free(key_file);
9020                 return ret;
9021         }
9022
9023         g_key_file_free(key_file);
9024
9025         if (strlen(str_irk) != 32 || str2buf(str_irk, irk, 16)) {
9026                 /* TODO re-create new IRK here? */
9027                 error("Invalid IRK format, disabling privacy");
9028                 g_free(str_irk);
9029                 return -1;
9030         }
9031
9032         g_free(str_irk);
9033         DBG("Successfully read IRK from file");
9034         return 0;
9035 }
9036
9037 static void set_privacy_complete(uint8_t status, uint16_t length,
9038                                         const void *param, void *user_data)
9039 {
9040         struct btd_adapter *adapter = user_data;
9041
9042         if (status != MGMT_STATUS_SUCCESS) {
9043                 btd_error(adapter->dev_id, "Failed to set privacy: %s (0x%02x)",
9044                                                 mgmt_errstr(status), status);
9045                 return;
9046         }
9047
9048         DBG("Successfuly set privacy for index %u", adapter->dev_id);
9049 }
9050
9051 static int set_privacy(struct btd_adapter *adapter, uint8_t privacy)
9052 {
9053         struct mgmt_cp_set_privacy cp;
9054
9055         memset(&cp, 0, sizeof(cp));
9056
9057         if (privacy) {
9058                 uint8_t irk[16];
9059
9060                 if (load_irk(adapter, irk) == 0) {
9061                         cp.privacy = privacy;
9062                         memcpy(cp.irk, irk, 16);
9063                 }
9064         }
9065
9066         DBG("sending set privacy command for index %u", adapter->dev_id);
9067         DBG("setting privacy mode 0x%02x for index %u", cp.privacy,
9068                                                         adapter->dev_id);
9069
9070         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
9071                                 adapter->dev_id, sizeof(cp), &cp,
9072                                 set_privacy_complete, adapter, NULL) > 0)
9073                 return 0;
9074
9075         btd_error(adapter->dev_id, "Failed to set privacy for index %u",
9076                                                         adapter->dev_id);
9077
9078         return -1;
9079 }
9080 #endif
9081
9082 static void load_link_keys_complete(uint8_t status, uint16_t length,
9083                                         const void *param, void *user_data)
9084 {
9085         struct btd_adapter *adapter = user_data;
9086
9087         if (status != MGMT_STATUS_SUCCESS) {
9088                 btd_error(adapter->dev_id,
9089                         "Failed to load link keys for hci%u: %s (0x%02x)",
9090                                 adapter->dev_id, mgmt_errstr(status), status);
9091                 return;
9092         }
9093
9094         DBG("link keys loaded for hci%u", adapter->dev_id);
9095 }
9096
9097 static void load_link_keys(struct btd_adapter *adapter, GSList *keys,
9098                                                         bool debug_keys)
9099 {
9100         struct mgmt_cp_load_link_keys *cp;
9101         struct mgmt_link_key_info *key;
9102         size_t key_count, cp_size;
9103         unsigned int id;
9104         GSList *l;
9105
9106         /*
9107          * If the controller does not support BR/EDR operation,
9108          * there is no point in trying to load the link keys into
9109          * the kernel.
9110          *
9111          * This is an optimization for Low Energy only controllers.
9112          */
9113         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
9114                 return;
9115
9116         key_count = g_slist_length(keys);
9117
9118         DBG("hci%u keys %zu debug_keys %d", adapter->dev_id, key_count,
9119                                                                 debug_keys);
9120
9121         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
9122
9123         cp = g_try_malloc0(cp_size);
9124         if (cp == NULL) {
9125                 btd_error(adapter->dev_id, "No memory for link keys for hci%u",
9126                                                         adapter->dev_id);
9127                 return;
9128         }
9129
9130         /*
9131          * Even if the list of stored keys is empty, it is important to
9132          * load an empty list into the kernel. That way it is ensured
9133          * that no old keys from a previous daemon are present.
9134          *
9135          * In addition it is also the only way to toggle the different
9136          * behavior for debug keys.
9137          */
9138         cp->debug_keys = debug_keys;
9139         cp->key_count = htobs(key_count);
9140
9141         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
9142                 struct link_key_info *info = l->data;
9143
9144                 bacpy(&key->addr.bdaddr, &info->bdaddr);
9145                 key->addr.type = BDADDR_BREDR;
9146                 key->type = info->type;
9147                 memcpy(key->val, info->key, 16);
9148                 key->pin_len = info->pin_len;
9149         }
9150
9151         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_LINK_KEYS,
9152                                 adapter->dev_id, cp_size, cp,
9153                                 load_link_keys_complete, adapter, NULL);
9154
9155         g_free(cp);
9156
9157         if (id == 0)
9158                 btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
9159                                                         adapter->dev_id);
9160 }
9161
9162 static void load_ltks_complete(uint8_t status, uint16_t length,
9163                                         const void *param, void *user_data)
9164 {
9165         struct btd_adapter *adapter = user_data;
9166
9167         if (status != MGMT_STATUS_SUCCESS) {
9168                 btd_error(adapter->dev_id,
9169                                 "Failed to load LTKs for hci%u: %s (0x%02x)",
9170                                 adapter->dev_id, mgmt_errstr(status), status);
9171         }
9172
9173         DBG("LTKs loaded for hci%u", adapter->dev_id);
9174 }
9175
9176 static void load_ltks(struct btd_adapter *adapter, GSList *keys)
9177 {
9178         struct mgmt_cp_load_long_term_keys *cp;
9179         struct mgmt_ltk_info *key;
9180         size_t key_count, max_key_count, cp_size;
9181         GSList *l;
9182         uint16_t mtu;
9183
9184         /*
9185          * If the controller does not support Low Energy operation,
9186          * there is no point in trying to load the long term keys
9187          * into the kernel.
9188          *
9189          * While there is no harm in loading keys into the kernel,
9190          * this is an optimization to avoid a confusing warning
9191          * message when the loading of the keys timed out due to
9192          * a kernel bug (see comment below).
9193          */
9194         if (!(adapter->supported_settings & MGMT_SETTING_LE))
9195                 return;
9196
9197         key_count = g_slist_length(keys);
9198         mtu = mgmt_get_mtu(adapter->mgmt);
9199         max_key_count = (mtu - sizeof(*cp)) / sizeof(*key);
9200         key_count = MIN(max_key_count, key_count);
9201
9202         DBG("hci%u keys %zu", adapter->dev_id, key_count);
9203
9204         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
9205
9206         cp = g_try_malloc0(cp_size);
9207         if (cp == NULL) {
9208                 btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
9209                                                         adapter->dev_id);
9210                 return;
9211         }
9212
9213         /*
9214          * Even if the list of stored keys is empty, it is important to
9215          * load an empty list into the kernel. That way it is ensured
9216          * that no old keys from a previous daemon are present.
9217          */
9218         cp->key_count = htobs(key_count);
9219
9220         for (l = keys, key = cp->keys; l && key_count;
9221                         l = g_slist_next(l), key++, key_count--) {
9222                 struct smp_ltk_info *info = l->data;
9223                 struct btd_device *dev;
9224
9225                 bacpy(&key->addr.bdaddr, &info->bdaddr);
9226                 key->addr.type = info->bdaddr_type;
9227                 memcpy(key->val, info->val, sizeof(info->val));
9228                 key->rand = cpu_to_le64(info->rand);
9229                 key->ediv = cpu_to_le16(info->ediv);
9230                 key->type = info->authenticated;
9231                 key->central = info->central;
9232                 key->enc_size = info->enc_size;
9233
9234                 /* Mark device as paired as their LTKs can be loaded. */
9235                 dev = btd_adapter_find_device(adapter, &info->bdaddr,
9236                                                         info->bdaddr_type);
9237                 if (dev) {
9238                         device_set_paired(dev, info->bdaddr_type);
9239                         device_set_bonded(dev, info->bdaddr_type);
9240                         device_set_ltk(dev, info->val, info->central,
9241                                                 info->enc_size);
9242                 }
9243         }
9244
9245         /*
9246          * This timeout handling is needed since the kernel is stupid
9247          * and forgets to send a command complete response. However in
9248          * case of failures it does send a command status.
9249          */
9250         if (!mgmt_send_timeout(adapter->mgmt, MGMT_OP_LOAD_LONG_TERM_KEYS,
9251                         adapter->dev_id, cp_size, cp, load_ltks_complete,
9252                         adapter, NULL, 2))
9253                 btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
9254                                                         adapter->dev_id);
9255
9256         g_free(cp);
9257 }
9258
9259 static void load_irks_complete(uint8_t status, uint16_t length,
9260                                         const void *param, void *user_data)
9261 {
9262         struct btd_adapter *adapter = user_data;
9263
9264         if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
9265                 btd_info(adapter->dev_id,
9266                         "Load IRKs failed: Kernel doesn't support LE Privacy");
9267                 return;
9268         }
9269
9270         if (status != MGMT_STATUS_SUCCESS) {
9271                 btd_error(adapter->dev_id,
9272                                 "Failed to load IRKs for hci%u: %s (0x%02x)",
9273                                 adapter->dev_id, mgmt_errstr(status), status);
9274                 return;
9275         }
9276
9277         DBG("IRKs loaded for hci%u", adapter->dev_id);
9278 }
9279
9280 static void load_irks(struct btd_adapter *adapter, GSList *irks)
9281 {
9282         struct mgmt_cp_load_irks *cp;
9283         struct mgmt_irk_info *irk;
9284         size_t irk_count, cp_size;
9285         unsigned int id;
9286         GSList *l;
9287
9288         /*
9289          * If the controller does not support LE Privacy operation,
9290          * there is no support for loading identity resolving keys
9291          * into the kernel.
9292          */
9293         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
9294                 return;
9295
9296         irk_count = g_slist_length(irks);
9297
9298         DBG("hci%u irks %zu", adapter->dev_id, irk_count);
9299
9300         cp_size = sizeof(*cp) + (irk_count * sizeof(*irk));
9301
9302         cp = g_try_malloc0(cp_size);
9303         if (cp == NULL) {
9304                 btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
9305                                                         adapter->dev_id);
9306                 return;
9307         }
9308
9309         /*
9310          * Even if the list of stored keys is empty, it is important to
9311          * load an empty list into the kernel. That way we tell the
9312          * kernel that we are able to handle New IRK events.
9313          */
9314         cp->irk_count = htobs(irk_count);
9315
9316         for (l = irks, irk = cp->irks; l != NULL; l = g_slist_next(l), irk++) {
9317                 struct irk_info *info = l->data;
9318
9319                 bacpy(&irk->addr.bdaddr, &info->bdaddr);
9320                 irk->addr.type = info->bdaddr_type;
9321                 memcpy(irk->val, info->val, sizeof(irk->val));
9322         }
9323
9324         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_IRKS, adapter->dev_id,
9325                         cp_size, cp, load_irks_complete, adapter, NULL);
9326
9327         g_free(cp);
9328
9329         if (id == 0)
9330                 btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
9331                                                         adapter->dev_id);
9332 }
9333
9334 static void load_conn_params_complete(uint8_t status, uint16_t length,
9335                                         const void *param, void *user_data)
9336 {
9337         struct btd_adapter *adapter = user_data;
9338
9339         if (status != MGMT_STATUS_SUCCESS) {
9340                 btd_error(adapter->dev_id,
9341                         "hci%u Load Connection Parameters failed: %s (0x%02x)",
9342                                 adapter->dev_id, mgmt_errstr(status), status);
9343                 return;
9344         }
9345
9346         DBG("Connection Parameters loaded for hci%u", adapter->dev_id);
9347 }
9348
9349 static void load_conn_params(struct btd_adapter *adapter, GSList *params)
9350 {
9351         struct mgmt_cp_load_conn_param *cp;
9352         struct mgmt_conn_param *param;
9353         size_t param_count, cp_size;
9354         unsigned int id;
9355         GSList *l;
9356
9357         /*
9358          * If the controller does not support Low Energy operation,
9359          * there is no point in trying to load the connection
9360          * parameters into the kernel.
9361          */
9362         if (!(adapter->supported_settings & MGMT_SETTING_LE))
9363                 return;
9364
9365         param_count = g_slist_length(params);
9366
9367         DBG("hci%u conn params %zu", adapter->dev_id, param_count);
9368
9369         cp_size = sizeof(*cp) + (param_count * sizeof(*param));
9370
9371         cp = g_try_malloc0(cp_size);
9372         if (cp == NULL) {
9373                 btd_error(adapter->dev_id,
9374                         "Failed to allocate memory for connection parameters");
9375                 return;
9376         }
9377
9378         cp->param_count = htobs(param_count);
9379
9380         for (l = params, param = cp->params; l; l = g_slist_next(l), param++) {
9381                 struct conn_param *info = l->data;
9382
9383                 bacpy(&param->addr.bdaddr, &info->bdaddr);
9384                 param->addr.type = info->bdaddr_type;
9385                 param->min_interval = htobs(info->min_interval);
9386                 param->max_interval = htobs(info->max_interval);
9387                 param->latency = htobs(info->latency);
9388                 param->timeout = htobs(info->timeout);
9389         }
9390
9391         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_PARAM, adapter->dev_id,
9392                         cp_size, cp, load_conn_params_complete, adapter, NULL);
9393
9394         g_free(cp);
9395
9396         if (id == 0)
9397                 btd_error(adapter->dev_id, "Load connection parameters failed");
9398 }
9399
9400 static uint8_t get_le_addr_type(GKeyFile *keyfile)
9401 {
9402         uint8_t addr_type;
9403         char *type;
9404
9405         type = g_key_file_get_string(keyfile, "General", "AddressType", NULL);
9406         if (!type)
9407                 return BDADDR_LE_PUBLIC;
9408
9409         if (g_str_equal(type, "public"))
9410                 addr_type = BDADDR_LE_PUBLIC;
9411         else if (g_str_equal(type, "static"))
9412                 addr_type = BDADDR_LE_RANDOM;
9413         else
9414                 addr_type = BDADDR_LE_PUBLIC;
9415
9416         g_free(type);
9417
9418         return addr_type;
9419 }
9420
9421 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9422 static uint8_t get_addr_type(GKeyFile *keyfile)
9423 {
9424         char **techno, **t;
9425         char *str;
9426         uint8_t bdaddr_type = BDADDR_BREDR;
9427         bool le = false;
9428
9429         /* Load device technology */
9430         techno = g_key_file_get_string_list(keyfile, "General",
9431                                         "SupportedTechnologies", NULL, NULL);
9432         if (!techno)
9433                 return 0xff;
9434
9435         for (t = techno; *t; t++) {
9436                 if (g_str_equal(*t, "LE"))
9437                         le = true;
9438         }
9439
9440         if (!le) {
9441                 bdaddr_type = BDADDR_BREDR;
9442         } else {
9443                 str = g_key_file_get_string(keyfile, "General",
9444                                                 "AddressType", NULL);
9445
9446                 if (str && g_str_equal(str, "public"))
9447                         bdaddr_type = BDADDR_LE_PUBLIC;
9448                 else if (str && g_str_equal(str, "static"))
9449                         bdaddr_type = BDADDR_LE_RANDOM;
9450                 else
9451                         error("Unknown LE device technology");
9452
9453                 g_free(str);
9454         }
9455
9456         g_strfreev(techno);
9457
9458         return bdaddr_type;
9459 }
9460 #endif
9461
9462 static void probe_devices(void *user_data)
9463 {
9464         struct btd_device *device = user_data;
9465
9466         device_probe_profiles(device, btd_device_get_uuids(device));
9467         device_resolved_drivers(device_get_adapter(device), device);
9468 }
9469
9470 static bool load_bredr_defaults(struct btd_adapter *adapter,
9471                                 struct mgmt_tlv_list *list,
9472                                 struct btd_br_defaults *defaults)
9473 {
9474         if (btd_opts.mode == BT_MODE_LE)
9475                 return true;
9476
9477         if (defaults->page_scan_type != 0xFFFF) {
9478                 if (!mgmt_tlv_add_fixed(list, 0x0000,
9479                                         &defaults->page_scan_type))
9480                         return false;
9481         }
9482
9483         if (defaults->page_scan_interval) {
9484                 if (!mgmt_tlv_add_fixed(list, 0x0001,
9485                                         &defaults->page_scan_interval))
9486                         return false;
9487         }
9488
9489         if (defaults->page_scan_win) {
9490                 if (!mgmt_tlv_add_fixed(list, 0x0002,
9491                                         &defaults->page_scan_win))
9492                         return false;
9493         }
9494
9495         if (defaults->scan_type != 0xFFFF) {
9496                 if (!mgmt_tlv_add_fixed(list, 0x0003,
9497                                         &defaults->scan_type))
9498                         return false;
9499         }
9500
9501         if (defaults->scan_interval) {
9502                 if (!mgmt_tlv_add_fixed(list, 0x0004,
9503                                         &defaults->scan_interval))
9504                         return false;
9505         }
9506
9507         if (defaults->scan_win) {
9508                 if (!mgmt_tlv_add_fixed(list, 0x0005,
9509                                         &defaults->scan_win))
9510                         return false;
9511         }
9512
9513         if (defaults->link_supervision_timeout) {
9514                 if (!mgmt_tlv_add_fixed(list, 0x0006,
9515                                         &defaults->link_supervision_timeout))
9516                         return false;
9517         }
9518
9519         if (defaults->page_timeout) {
9520                 if (!mgmt_tlv_add_fixed(list, 0x0007,
9521                                         &defaults->page_timeout))
9522                         return false;
9523         }
9524
9525         if (defaults->min_sniff_interval) {
9526                 if (!mgmt_tlv_add_fixed(list, 0x0008,
9527                                         &defaults->min_sniff_interval))
9528                         return false;
9529         }
9530
9531         if (defaults->max_sniff_interval) {
9532                 if (!mgmt_tlv_add_fixed(list, 0x0009,
9533                                         &defaults->max_sniff_interval))
9534                         return false;
9535         }
9536
9537         return true;
9538 }
9539
9540 static bool load_le_defaults(struct btd_adapter *adapter,
9541                                 struct mgmt_tlv_list *list,
9542                                 struct btd_le_defaults *defaults)
9543 {
9544         if (btd_opts.mode == BT_MODE_BREDR)
9545                 return true;
9546
9547         if (defaults->min_adv_interval) {
9548                 if (!mgmt_tlv_add_fixed(list, 0x000a,
9549                                         &defaults->min_adv_interval))
9550                         return false;
9551         }
9552
9553         if (defaults->max_adv_interval) {
9554                 if (!mgmt_tlv_add_fixed(list, 0x000b,
9555                                         &defaults->max_adv_interval))
9556                         return false;
9557         }
9558
9559         if (defaults->adv_rotation_interval) {
9560                 if (!mgmt_tlv_add_fixed(list, 0x000c,
9561                                         &defaults->adv_rotation_interval))
9562                         return false;
9563         }
9564
9565         if (defaults->scan_interval_autoconnect) {
9566                 if (!mgmt_tlv_add_fixed(list, 0x000d,
9567                                         &defaults->scan_interval_autoconnect))
9568                         return false;
9569         }
9570
9571         if (defaults->scan_win_autoconnect) {
9572                 if (!mgmt_tlv_add_fixed(list, 0x000e,
9573                                         &defaults->scan_win_autoconnect))
9574                         return false;
9575         }
9576
9577         if (defaults->scan_interval_suspend) {
9578                 if (!mgmt_tlv_add_fixed(list, 0x000f,
9579                                         &defaults->scan_interval_suspend))
9580                         return false;
9581         }
9582
9583         if (defaults->scan_win_suspend) {
9584                 if (!mgmt_tlv_add_fixed(list, 0x0010,
9585                                         &defaults->scan_win_suspend))
9586                         return false;
9587         }
9588
9589         if (defaults->scan_interval_discovery) {
9590                 if (!mgmt_tlv_add_fixed(list, 0x0011,
9591                                         &defaults->scan_interval_discovery))
9592                         return false;
9593         }
9594
9595         if (defaults->scan_win_discovery) {
9596                 if (!mgmt_tlv_add_fixed(list, 0x0012,
9597                                         &defaults->scan_win_discovery))
9598                         return false;
9599         }
9600
9601         if (defaults->scan_interval_adv_monitor) {
9602                 if (!mgmt_tlv_add_fixed(list, 0x0013,
9603                                         &defaults->scan_interval_adv_monitor))
9604                         return false;
9605         }
9606
9607         if (defaults->scan_win_adv_monitor) {
9608                 if (!mgmt_tlv_add_fixed(list, 0x0014,
9609                                         &defaults->scan_win_adv_monitor))
9610                         return false;
9611         }
9612
9613         if (defaults->scan_interval_connect) {
9614                 if (!mgmt_tlv_add_fixed(list, 0x0015,
9615                                         &defaults->scan_interval_connect))
9616                         return false;
9617         }
9618
9619         if (defaults->scan_win_connect) {
9620                 if (!mgmt_tlv_add_fixed(list, 0x0016,
9621                                         &defaults->scan_win_connect))
9622                         return false;
9623         }
9624
9625         if (defaults->min_conn_interval) {
9626                 if (!mgmt_tlv_add_fixed(list, 0x0017,
9627                                         &defaults->min_conn_interval))
9628                         return false;
9629         }
9630
9631         if (defaults->max_conn_interval) {
9632                 if (!mgmt_tlv_add_fixed(list, 0x0018,
9633                                         &defaults->max_conn_interval))
9634                         return false;
9635         }
9636
9637         if (defaults->conn_latency) {
9638                 if (!mgmt_tlv_add_fixed(list, 0x0019,
9639                                         &defaults->conn_latency))
9640                         return false;
9641         }
9642
9643         if (defaults->conn_lsto) {
9644                 if (!mgmt_tlv_add_fixed(list, 0x001a,
9645                                         &defaults->conn_lsto))
9646                         return false;
9647         }
9648
9649         if (defaults->autoconnect_timeout) {
9650                 if (!mgmt_tlv_add_fixed(list, 0x001b,
9651                                         &defaults->autoconnect_timeout))
9652                         return false;
9653         }
9654
9655         if (defaults->advmon_allowlist_scan_duration) {
9656                 if (!mgmt_tlv_add_fixed(list, 0x001d,
9657                                 &defaults->advmon_allowlist_scan_duration))
9658                         return false;
9659         }
9660
9661         if (defaults->advmon_no_filter_scan_duration) {
9662                 if (!mgmt_tlv_add_fixed(list, 0x001e,
9663                                 &defaults->advmon_no_filter_scan_duration))
9664                         return false;
9665         }
9666
9667         if (defaults->enable_advmon_interleave_scan != 0xFF) {
9668                 if (!mgmt_tlv_add_fixed(list, 0x001f,
9669                                 &defaults->enable_advmon_interleave_scan))
9670                         return false;
9671         }
9672
9673         return true;
9674 }
9675
9676 static void load_defaults(struct btd_adapter *adapter)
9677 {
9678         struct mgmt_tlv_list *list;
9679         unsigned int err = 0;
9680
9681         if (!btd_opts.defaults.num_entries ||
9682             !btd_has_kernel_features(KERNEL_SET_SYSTEM_CONFIG))
9683                 return;
9684
9685         list = mgmt_tlv_list_new();
9686
9687         if (!load_bredr_defaults(adapter, list, &btd_opts.defaults.br))
9688                 goto done;
9689
9690         if (!load_le_defaults(adapter, list, &btd_opts.defaults.le))
9691                 goto done;
9692
9693         err = mgmt_send_tlv(adapter->mgmt, MGMT_OP_SET_DEF_SYSTEM_CONFIG,
9694                         adapter->dev_id, list, NULL, NULL, NULL);
9695
9696 done:
9697         if (!err)
9698                 btd_error(adapter->dev_id,
9699                                 "Failed to set default system config for hci%u",
9700                                 adapter->dev_id);
9701
9702         mgmt_tlv_list_free(list);
9703 }
9704
9705 static void load_devices(struct btd_adapter *adapter)
9706 {
9707         char dirname[PATH_MAX];
9708         GSList *keys = NULL;
9709         GSList *ltks = NULL;
9710         GSList *irks = NULL;
9711         GSList *params = NULL;
9712         GSList *added_devices = NULL;
9713         GError *gerr = NULL;
9714         DIR *dir;
9715         struct dirent *entry;
9716
9717         create_filename(dirname, PATH_MAX, "/%s",
9718                                 btd_adapter_get_storage_dir(adapter));
9719
9720         dir = opendir(dirname);
9721         if (!dir) {
9722                 btd_error(adapter->dev_id,
9723                                 "Unable to open adapter storage directory: %s",
9724                                                                 dirname);
9725                 return;
9726         }
9727
9728         while ((entry = readdir(dir)) != NULL) {
9729                 struct btd_device *device;
9730                 char filename[PATH_MAX];
9731                 GKeyFile *key_file;
9732 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9733                 struct link_key_info *key_info = NULL;
9734                 struct smp_ltk_info *ltk_info = NULL;
9735                 struct smp_ltk_info *peripheral_ltk_info;
9736                 GSList *list = NULL;
9737                 struct device_addr_type addr;
9738 #else
9739                 struct link_key_info *key_info;
9740                 struct smp_ltk_info *ltk_info;
9741                 struct smp_ltk_info *peripheral_ltk_info;
9742                 GSList *list;
9743 #endif
9744                 struct irk_info *irk_info;
9745                 struct conn_param *param;
9746                 uint8_t bdaddr_type;
9747
9748                 if (entry->d_type == DT_UNKNOWN)
9749                         entry->d_type = util_get_dt(dirname, entry->d_name);
9750
9751                 if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
9752                         continue;
9753
9754 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9755 {
9756                 bdaddr_t bdaddr;
9757
9758                 str2ba(entry->d_name, &bdaddr);
9759
9760                 if (!bacmp(&bdaddr, BDADDR_ANY)) {
9761                         error("No Bluetooth address");
9762                         continue;
9763                 }
9764 }
9765 #endif
9766         create_filename(filename, PATH_MAX, "/%s/%s/info",
9767                                         btd_adapter_get_storage_dir(adapter),
9768                                         entry->d_name);
9769
9770                 key_file = g_key_file_new();
9771                 if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
9772                         error("Unable to load key file from %s: (%s)", filename,
9773                                                                 gerr->message);
9774                         g_clear_error(&gerr);
9775                 }
9776
9777                 key_info = get_key_info(key_file, entry->d_name);
9778
9779                 bdaddr_type = get_le_addr_type(key_file);
9780
9781                 ltk_info = get_ltk_info(key_file, entry->d_name, bdaddr_type);
9782
9783                 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9784                                                 entry->d_name, bdaddr_type);
9785
9786                 irk_info = get_irk_info(key_file, entry->d_name, bdaddr_type);
9787
9788                 // If any key for the device is blocked, we discard all.
9789                 if ((key_info && key_info->is_blocked) ||
9790                                 (ltk_info && ltk_info->is_blocked) ||
9791                                 (peripheral_ltk_info &&
9792                                         peripheral_ltk_info->is_blocked) ||
9793                                 (irk_info && irk_info->is_blocked)) {
9794
9795                         if (key_info) {
9796                                 g_free(key_info);
9797                                 key_info = NULL;
9798                         }
9799
9800                         if (ltk_info) {
9801                                 g_free(ltk_info);
9802                                 ltk_info = NULL;
9803                         }
9804
9805                         if (peripheral_ltk_info) {
9806                                 g_free(peripheral_ltk_info);
9807                                 peripheral_ltk_info = NULL;
9808                         }
9809
9810                         if (irk_info) {
9811                                 g_free(irk_info);
9812                                 irk_info = NULL;
9813                         }
9814
9815                         goto free;
9816                 }
9817
9818                 if (key_info)
9819                         keys = g_slist_append(keys, key_info);
9820
9821                 if (ltk_info)
9822                         ltks = g_slist_append(ltks, ltk_info);
9823
9824                 if (peripheral_ltk_info)
9825                         ltks = g_slist_append(ltks, peripheral_ltk_info);
9826
9827                 if (irk_info)
9828                         irks = g_slist_append(irks, irk_info);
9829
9830                 param = get_conn_param(key_file, entry->d_name, bdaddr_type);
9831                 if (param)
9832                         params = g_slist_append(params, param);
9833
9834 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9835                 str2ba(entry->d_name, &addr.bdaddr);
9836                 addr.bdaddr_type = get_addr_type(key_file);
9837                 if (addr.bdaddr_type == 0xff) {
9838                         error("No SupportedTechnologies. Skipping");
9839                         goto free;
9840                 }
9841
9842                 list = g_slist_find_custom(adapter->devices, &addr,
9843                                                 device_addr_type_strict_cmp);
9844 #else
9845                 list = g_slist_find_custom(adapter->devices, entry->d_name,
9846                                                         device_address_cmp);
9847 #endif
9848                 if (list) {
9849 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9850                         DBG("Skip already loaded device [%s] [%d]",
9851                                         entry->d_name, addr.bdaddr_type);
9852 #endif
9853                         device = list->data;
9854                         goto device_exist;
9855                 }
9856
9857                 device = device_create_from_storage(adapter, entry->d_name,
9858                                                         key_file);
9859                 if (!device)
9860                         goto free;
9861
9862 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
9863 {
9864                 char idaddr[18];
9865
9866                 /*
9867                  * After loading IRK information from file,
9868                  * store it into device->bdaddr.
9869                  * RPA is stored in device->rpa_addr
9870                  */
9871                 ba2str(device_get_address(device), idaddr);
9872
9873                 DBG("irk address: %s, rpa_exist %d",
9874                                 idaddr, device_get_rpa_exist(device));
9875
9876                 if (device_get_rpa_exist(device) == true) {
9877                         if (key_info)
9878                                 str2ba(idaddr, &key_info->bdaddr);
9879
9880                         if (ltk_info) {
9881                                 ltks = g_slist_remove(ltks, ltk_info);
9882                                 ltk_info = get_ltk_info(key_file,
9883                                                 idaddr, bdaddr_type);
9884                                 if (ltk_info)
9885                                         ltks = g_slist_append(ltks, ltk_info);
9886                         }
9887
9888                         if (peripheral_ltk_info) {
9889                                 ltks = g_slist_remove(ltks, peripheral_ltk_info);
9890                                 peripheral_ltk_info = get_peripheral_ltk_info(key_file,
9891                                                 idaddr, bdaddr_type);
9892                                 if (peripheral_ltk_info)
9893                                         ltks = g_slist_append(ltks, peripheral_ltk_info);
9894                         }
9895
9896                         if (irk_info) {
9897                                 str2ba(idaddr, &irk_info->bdaddr);
9898                                 device_set_irk_value(device, irk_info->val);
9899                         }
9900
9901                         if (param)
9902                                 str2ba(idaddr, &param->bdaddr);
9903                 }
9904 }
9905 #endif
9906                 if (irk_info)
9907                         device_set_rpa(device, true);
9908
9909                 btd_device_set_temporary(device, false);
9910                 adapter_add_device(adapter, device);
9911
9912                 /* TODO: register services from pre-loaded list of primaries */
9913
9914                 added_devices = g_slist_append(added_devices, device);
9915
9916 device_exist:
9917                 if (key_info) {
9918                         device_set_paired(device, BDADDR_BREDR);
9919                         device_set_bonded(device, BDADDR_BREDR);
9920                 }
9921
9922 free:
9923                 g_key_file_free(key_file);
9924         }
9925
9926         closedir(dir);
9927
9928         load_link_keys(adapter, keys, btd_opts.debug_keys);
9929         g_slist_free_full(keys, g_free);
9930
9931         load_ltks(adapter, ltks);
9932         g_slist_free_full(ltks, g_free);
9933         load_irks(adapter, irks);
9934         g_slist_free_full(irks, g_free);
9935         load_conn_params(adapter, params);
9936         g_slist_free_full(params, g_free);
9937
9938         g_slist_free_full(added_devices, probe_devices);
9939 }
9940
9941 int btd_adapter_block_address(struct btd_adapter *adapter,
9942                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9943 {
9944         struct mgmt_cp_block_device cp;
9945         char addr[18];
9946
9947         ba2str(bdaddr, addr);
9948         DBG("hci%u %s", adapter->dev_id, addr);
9949
9950         memset(&cp, 0, sizeof(cp));
9951         bacpy(&cp.addr.bdaddr, bdaddr);
9952         cp.addr.type = bdaddr_type;
9953
9954         if (mgmt_send(adapter->mgmt, MGMT_OP_BLOCK_DEVICE,
9955                                 adapter->dev_id, sizeof(cp), &cp,
9956                                 NULL, NULL, NULL) > 0)
9957                 return 0;
9958
9959         return -EIO;
9960 }
9961
9962 int btd_adapter_unblock_address(struct btd_adapter *adapter,
9963                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9964 {
9965         struct mgmt_cp_unblock_device cp;
9966         char addr[18];
9967
9968         ba2str(bdaddr, addr);
9969         DBG("hci%u %s", adapter->dev_id, addr);
9970
9971         memset(&cp, 0, sizeof(cp));
9972         bacpy(&cp.addr.bdaddr, bdaddr);
9973         cp.addr.type = bdaddr_type;
9974
9975         if (mgmt_send(adapter->mgmt, MGMT_OP_UNBLOCK_DEVICE,
9976                                 adapter->dev_id, sizeof(cp), &cp,
9977                                 NULL, NULL, NULL) > 0)
9978                 return 0;
9979
9980         return -EIO;
9981 }
9982
9983 static int clear_blocked(struct btd_adapter *adapter)
9984 {
9985         return btd_adapter_unblock_address(adapter, BDADDR_ANY, 0);
9986 }
9987
9988 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
9989 {
9990         struct btd_adapter_driver *driver = user_data;
9991         int err;
9992
9993         if (driver->probe == NULL)
9994                 return;
9995
9996         err = driver->probe(adapter);
9997         if (err < 0) {
9998                 btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
9999                                                         strerror(-err), -err);
10000                 return;
10001         }
10002
10003         adapter->drivers = g_slist_prepend(adapter->drivers, driver);
10004 }
10005
10006 static void load_drivers(struct btd_adapter *adapter)
10007 {
10008         GSList *l;
10009
10010         for (l = adapter_drivers; l; l = l->next)
10011                 probe_driver(adapter, l->data);
10012 }
10013
10014 static void probe_profile(struct btd_profile *profile, void *data)
10015 {
10016         struct btd_adapter *adapter = data;
10017         int err;
10018
10019         if (profile->adapter_probe == NULL)
10020                 return;
10021
10022         err = profile->adapter_probe(profile, adapter);
10023         if (err < 0) {
10024                 btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
10025                                                         strerror(-err), -err);
10026                 return;
10027         }
10028
10029         adapter->profiles = g_slist_prepend(adapter->profiles, profile);
10030 }
10031
10032 void adapter_add_profile(struct btd_adapter *adapter, gpointer p)
10033 {
10034         struct btd_profile *profile = p;
10035
10036         if (!adapter->initialized)
10037                 return;
10038
10039         probe_profile(profile, adapter);
10040
10041         g_slist_foreach(adapter->devices, device_probe_profile, profile);
10042 }
10043
10044 void adapter_remove_profile(struct btd_adapter *adapter, gpointer p)
10045 {
10046         struct btd_profile *profile = p;
10047
10048         if (!adapter->initialized)
10049                 return;
10050
10051         if (profile->device_remove)
10052                 g_slist_foreach(adapter->devices, device_remove_profile, p);
10053
10054         adapter->profiles = g_slist_remove(adapter->profiles, profile);
10055
10056         if (profile->adapter_remove)
10057                 profile->adapter_remove(profile, adapter);
10058 }
10059
10060 static void device_added_drivers(struct btd_adapter *adapter,
10061                                                 struct btd_device *device)
10062 {
10063         struct btd_adapter_driver *driver;
10064         GSList *l;
10065
10066         for (l = adapter_drivers; l; l = l->next) {
10067                 driver = l->data;
10068
10069                 if (driver->device_added)
10070                         driver->device_added(adapter, device);
10071         }
10072 }
10073
10074 static void device_removed_drivers(struct btd_adapter *adapter,
10075                                                 struct btd_device *device)
10076 {
10077         struct btd_adapter_driver *driver;
10078         GSList *l;
10079
10080         for (l = adapter_drivers; l; l = l->next) {
10081                 driver = l->data;
10082
10083                 if (driver->device_removed)
10084                         driver->device_removed(adapter, device);
10085         }
10086 }
10087
10088 void device_resolved_drivers(struct btd_adapter *adapter,
10089                                                 struct btd_device *device)
10090 {
10091         struct btd_adapter_driver *driver;
10092         GSList *l;
10093
10094         for (l = adapter_drivers; l; l = l->next) {
10095                 driver = l->data;
10096
10097                 if (driver->device_resolved)
10098                         driver->device_resolved(adapter, device);
10099         }
10100 }
10101
10102 static void adapter_add_device(struct btd_adapter *adapter,
10103                                                 struct btd_device *device)
10104 {
10105         adapter->devices = g_slist_append(adapter->devices, device);
10106         device_added_drivers(adapter, device);
10107 }
10108
10109 static void adapter_remove_device(struct btd_adapter *adapter,
10110                                                 struct btd_device *device)
10111 {
10112         adapter->devices = g_slist_remove(adapter->devices, device);
10113         device_removed_drivers(adapter, device);
10114 }
10115
10116 static void adapter_add_connection(struct btd_adapter *adapter,
10117                                                 struct btd_device *device,
10118                                                 uint8_t bdaddr_type,
10119                                                 uint32_t flags)
10120 {
10121         device_add_connection(device, bdaddr_type, flags);
10122
10123         if (g_slist_find(adapter->connections, device)) {
10124                 btd_error(adapter->dev_id,
10125                                 "Device is already marked as connected");
10126                 return;
10127         }
10128
10129         adapter->connections = g_slist_append(adapter->connections, device);
10130 }
10131
10132 static void get_connections_complete(uint8_t status, uint16_t length,
10133                                         const void *param, void *user_data)
10134 {
10135         struct btd_adapter *adapter = user_data;
10136         const struct mgmt_rp_get_connections *rp = param;
10137         uint16_t i, conn_count;
10138
10139         if (status != MGMT_STATUS_SUCCESS) {
10140                 btd_error(adapter->dev_id,
10141                                 "Failed to get connections: %s (0x%02x)",
10142                                                 mgmt_errstr(status), status);
10143                 return;
10144         }
10145
10146         if (length < sizeof(*rp)) {
10147                 btd_error(adapter->dev_id,
10148                                 "Wrong size of get connections response");
10149                 return;
10150         }
10151
10152         conn_count = btohs(rp->conn_count);
10153
10154         DBG("Connection count: %d", conn_count);
10155
10156         if (conn_count * sizeof(struct mgmt_addr_info) +
10157                                                 sizeof(*rp) != length) {
10158                 btd_error(adapter->dev_id,
10159                         "Incorrect packet size for get connections response");
10160                 return;
10161         }
10162
10163         for (i = 0; i < conn_count; i++) {
10164                 const struct mgmt_addr_info *addr = &rp->addr[i];
10165                 struct btd_device *device;
10166                 char address[18];
10167
10168                 ba2str(&addr->bdaddr, address);
10169                 DBG("Adding existing connection to %s", address);
10170
10171                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
10172                                                                 addr->type);
10173                 if (device)
10174                         adapter_add_connection(adapter, device, addr->type, 0);
10175         }
10176 }
10177
10178 static void load_connections(struct btd_adapter *adapter)
10179 {
10180         DBG("sending get connections command for index %u", adapter->dev_id);
10181
10182         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_CONNECTIONS,
10183                                 adapter->dev_id, 0, NULL,
10184                                 get_connections_complete, adapter, NULL) > 0)
10185                 return;
10186
10187         btd_error(adapter->dev_id, "Failed to get connections for index %u",
10188                                                         adapter->dev_id);
10189 }
10190
10191 bool btd_adapter_get_pairable(struct btd_adapter *adapter)
10192 {
10193         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
10194                 return true;
10195
10196         return false;
10197 }
10198
10199 bool btd_adapter_get_powered(struct btd_adapter *adapter)
10200 {
10201         if ((adapter->current_settings & MGMT_SETTING_POWERED) &&
10202                         !(adapter->pending_settings & MGMT_SETTING_POWERED))
10203                 return true;
10204
10205         return false;
10206 }
10207
10208 bool btd_adapter_get_connectable(struct btd_adapter *adapter)
10209 {
10210         if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
10211                 return true;
10212
10213         return false;
10214 }
10215
10216 bool btd_adapter_get_discoverable(struct btd_adapter *adapter)
10217 {
10218         if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
10219                 return true;
10220
10221         return false;
10222 }
10223
10224 bool btd_adapter_get_bredr(struct btd_adapter *adapter)
10225 {
10226         if (adapter->current_settings & MGMT_SETTING_BREDR)
10227                 return true;
10228
10229         return false;
10230 }
10231
10232 struct btd_gatt_database *btd_adapter_get_database(struct btd_adapter *adapter)
10233 {
10234         if (!adapter)
10235                 return NULL;
10236
10237         return adapter->database;
10238 }
10239
10240 uint32_t btd_adapter_get_class(struct btd_adapter *adapter)
10241 {
10242         return adapter->dev_class;
10243 }
10244
10245 const char *btd_adapter_get_name(struct btd_adapter *adapter)
10246 {
10247         if (adapter->stored_alias)
10248                 return adapter->stored_alias;
10249
10250         if (adapter->system_name)
10251                 return adapter->system_name;
10252
10253         return NULL;
10254 }
10255
10256 int adapter_connect_list_add(struct btd_adapter *adapter,
10257                                         struct btd_device *device)
10258 {
10259         /*
10260          * If the adapter->connect_le device is getting added back to
10261          * the connect list it probably means that the connect attempt
10262          * failed and hence we should clear this pointer
10263          */
10264         if (device == adapter->connect_le)
10265                 adapter->connect_le = NULL;
10266
10267         /*
10268          * If kernel background scanning is supported then the
10269          * adapter_auto_connect_add() function is used to maintain what to
10270          * connect.
10271          */
10272         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10273                 return 0;
10274
10275         if (g_slist_find(adapter->connect_list, device)) {
10276                 DBG("ignoring already added device %s",
10277                                                 device_get_path(device));
10278                 goto done;
10279         }
10280
10281         if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
10282                 btd_error(adapter->dev_id,
10283                         "Can't add %s to non-LE capable adapter connect list",
10284                                                 device_get_path(device));
10285                 return -ENOTSUP;
10286         }
10287
10288         adapter->connect_list = g_slist_append(adapter->connect_list, device);
10289         DBG("%s added to %s's connect_list", device_get_path(device),
10290                                                         adapter->system_name);
10291
10292 done:
10293         if (!btd_adapter_get_powered(adapter))
10294                 return 0;
10295
10296         trigger_passive_scanning(adapter);
10297
10298         return 0;
10299 }
10300
10301 void adapter_connect_list_remove(struct btd_adapter *adapter,
10302                                         struct btd_device *device)
10303 {
10304         /*
10305          * If the adapter->connect_le device is being removed from the
10306          * connect list it means the connection was successful and hence
10307          * the pointer should be cleared
10308          */
10309         if (device == adapter->connect_le)
10310                 adapter->connect_le = NULL;
10311
10312         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
10313                 return;
10314
10315         if (!g_slist_find(adapter->connect_list, device)) {
10316                 DBG("device %s is not on the list, ignoring",
10317                                                 device_get_path(device));
10318                 return;
10319         }
10320
10321         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10322         DBG("%s removed from %s's connect_list", device_get_path(device),
10323                                                         adapter->system_name);
10324
10325         if (!adapter->connect_list) {
10326                 stop_passive_scanning(adapter);
10327                 return;
10328         }
10329
10330         if (!btd_adapter_get_powered(adapter))
10331                 return;
10332
10333         trigger_passive_scanning(adapter);
10334 }
10335
10336 static void add_accept_list_complete(uint8_t status, uint16_t length,
10337                                         const void *param, void *user_data)
10338 {
10339         const struct mgmt_rp_add_device *rp = param;
10340         struct btd_adapter *adapter = user_data;
10341         struct btd_device *dev;
10342         char addr[18];
10343
10344         if (length < sizeof(*rp)) {
10345                 btd_error(adapter->dev_id,
10346                                 "Too small Add Device complete event");
10347                 return;
10348         }
10349
10350         ba2str(&rp->addr.bdaddr, addr);
10351
10352         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10353                                                         rp->addr.type);
10354         if (!dev) {
10355                 btd_error(adapter->dev_id,
10356                         "Add Device complete for unknown device %s", addr);
10357                 return;
10358         }
10359
10360         if (status != MGMT_STATUS_SUCCESS) {
10361                 btd_error(adapter->dev_id,
10362                                         "Failed to add device %s: %s (0x%02x)",
10363                                         addr, mgmt_errstr(status), status);
10364                 return;
10365         }
10366
10367         DBG("%s added to kernel accept list", addr);
10368 }
10369
10370 void adapter_accept_list_add(struct btd_adapter *adapter,
10371                                                         struct btd_device *dev)
10372 {
10373         struct mgmt_cp_add_device cp;
10374
10375         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10376                 return;
10377
10378         memset(&cp, 0, sizeof(cp));
10379         bacpy(&cp.addr.bdaddr, device_get_address(dev));
10380         cp.addr.type = BDADDR_BREDR;
10381         cp.action = 0x01;
10382
10383         mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10384                                 adapter->dev_id, sizeof(cp), &cp,
10385                                 add_accept_list_complete, adapter, NULL);
10386 }
10387
10388 static void remove_accept_list_complete(uint8_t status, uint16_t length,
10389                                         const void *param, void *user_data)
10390 {
10391         const struct mgmt_rp_remove_device *rp = param;
10392         char addr[18];
10393
10394         if (length < sizeof(*rp)) {
10395                 error("Too small Remove Device complete event");
10396                 return;
10397         }
10398
10399         ba2str(&rp->addr.bdaddr, addr);
10400
10401         if (status != MGMT_STATUS_SUCCESS) {
10402                 error("Failed to remove device %s: %s (0x%02x)",
10403                                         addr, mgmt_errstr(status), status);
10404                 return;
10405         }
10406
10407         DBG("%s removed from kernel accept list", addr);
10408 }
10409
10410 void adapter_accept_list_remove(struct btd_adapter *adapter,
10411                                                         struct btd_device *dev)
10412 {
10413         struct mgmt_cp_remove_device cp;
10414
10415         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10416                 return;
10417
10418         memset(&cp, 0, sizeof(cp));
10419         bacpy(&cp.addr.bdaddr, device_get_address(dev));
10420         cp.addr.type = BDADDR_BREDR;
10421
10422         mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10423                                 adapter->dev_id, sizeof(cp), &cp,
10424                                 remove_accept_list_complete, adapter, NULL);
10425 }
10426
10427 static void set_device_privacy_complete(uint8_t status, uint16_t length,
10428                                          const void *param, void *user_data)
10429 {
10430         const struct mgmt_rp_set_device_flags *rp = param;
10431
10432         if (status != MGMT_STATUS_SUCCESS) {
10433                 error("Set device flags return status: %s",
10434                                         mgmt_errstr(status));
10435                 return;
10436         }
10437
10438         if (length < sizeof(*rp)) {
10439                 error("Too small Set Device Flags complete event: %d", length);
10440                 return;
10441         }
10442 }
10443
10444 static void add_device_complete(uint8_t status, uint16_t length,
10445                                         const void *param, void *user_data)
10446 {
10447         const struct mgmt_rp_add_device *rp = param;
10448         struct btd_adapter *adapter = user_data;
10449         struct btd_device *dev;
10450         char addr[18];
10451
10452         if (length < sizeof(*rp)) {
10453                 btd_error(adapter->dev_id,
10454                                 "Too small Add Device complete event");
10455                 return;
10456         }
10457
10458         ba2str(&rp->addr.bdaddr, addr);
10459
10460         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
10461                                                         rp->addr.type);
10462         if (!dev) {
10463                 btd_error(adapter->dev_id,
10464                         "Add Device complete for unknown device %s", addr);
10465                 return;
10466         }
10467
10468         if (status != MGMT_STATUS_SUCCESS) {
10469                 btd_error(adapter->dev_id,
10470                         "Failed to add device %s (%u): %s (0x%02x)",
10471                         addr, rp->addr.type, mgmt_errstr(status), status);
10472                 adapter->connect_list = g_slist_remove(adapter->connect_list,
10473                                                                         dev);
10474                 return;
10475         }
10476
10477         DBG("%s (%u) added to kernel connect list", addr, rp->addr.type);
10478
10479         if (btd_opts.device_privacy) {
10480                 uint32_t flags = btd_device_get_current_flags(dev);
10481
10482                 /* Set Device Privacy Mode has not set the flag yet. */
10483                 if (!(flags & DEVICE_FLAG_DEVICE_PRIVACY)) {
10484                         adapter_set_device_flags(adapter, dev, flags |
10485                                                 DEVICE_FLAG_DEVICE_PRIVACY,
10486                                                 set_device_privacy_complete,
10487                                                 NULL);
10488                 }
10489         }
10490 }
10491
10492 void adapter_auto_connect_add(struct btd_adapter *adapter,
10493                                         struct btd_device *device)
10494 {
10495         struct mgmt_cp_add_device cp;
10496         const bdaddr_t *bdaddr;
10497         uint8_t bdaddr_type;
10498         unsigned int id;
10499
10500         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10501                 return;
10502
10503         if (g_slist_find(adapter->connect_list, device)) {
10504                 DBG("ignoring already added device %s",
10505                                                 device_get_path(device));
10506                 return;
10507         }
10508
10509         bdaddr = device_get_address(device);
10510         bdaddr_type = btd_device_get_bdaddr_type(device);
10511
10512         if (bdaddr_type == BDADDR_BREDR) {
10513                 DBG("auto-connection feature is not avaiable for BR/EDR");
10514                 return;
10515         }
10516
10517         memset(&cp, 0, sizeof(cp));
10518         bacpy(&cp.addr.bdaddr, bdaddr);
10519         cp.addr.type = bdaddr_type;
10520         cp.action = 0x02;
10521
10522         id = mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
10523                         adapter->dev_id, sizeof(cp), &cp, add_device_complete,
10524                         adapter, NULL);
10525         if (id == 0)
10526                 return;
10527
10528         adapter->connect_list = g_slist_append(adapter->connect_list, device);
10529 }
10530
10531 void adapter_set_device_flags(struct btd_adapter *adapter,
10532                                 struct btd_device *device, uint32_t flags,
10533                                 mgmt_request_func_t func, void *user_data)
10534 {
10535         struct mgmt_cp_set_device_flags cp;
10536         uint32_t supported = btd_device_get_supported_flags(device);
10537         const bdaddr_t *bdaddr;
10538         uint8_t bdaddr_type;
10539
10540         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL) ||
10541                                 (supported | flags) != supported)
10542                 return;
10543
10544         bdaddr = device_get_address(device);
10545         bdaddr_type = btd_device_get_bdaddr_type(device);
10546
10547         memset(&cp, 0, sizeof(cp));
10548         bacpy(&cp.addr.bdaddr, bdaddr);
10549         cp.addr.type = bdaddr_type;
10550         cp.current_flags = cpu_to_le32(flags);
10551
10552         mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_FLAGS, adapter->dev_id,
10553                   sizeof(cp), &cp, func, user_data, NULL);
10554 }
10555
10556 static void device_flags_changed_callback(uint16_t index, uint16_t length,
10557                                           const void *param, void *user_data)
10558 {
10559         const struct mgmt_ev_device_flags_changed *ev = param;
10560         struct btd_adapter *adapter = user_data;
10561         struct btd_device *dev;
10562         char addr[18];
10563
10564         if (length < sizeof(*ev)) {
10565                 btd_error(adapter->dev_id,
10566                           "Too small Device Flags Changed event: %d",
10567                           length);
10568                 return;
10569         }
10570
10571         ba2str(&ev->addr.bdaddr, addr);
10572
10573         dev = btd_adapter_find_device(adapter, &ev->addr.bdaddr, ev->addr.type);
10574         if (!dev) {
10575                 btd_error(adapter->dev_id,
10576                         "Device Flags Changed for unknown device %s", addr);
10577                 return;
10578         }
10579
10580         btd_device_flags_changed(dev, ev->supported_flags, ev->current_flags);
10581 }
10582
10583
10584 static void remove_device_complete(uint8_t status, uint16_t length,
10585                                         const void *param, void *user_data)
10586 {
10587         const struct mgmt_rp_remove_device *rp = param;
10588         char addr[18];
10589
10590         if (length < sizeof(*rp)) {
10591                 error("Too small Remove Device complete event");
10592                 return;
10593         }
10594
10595         ba2str(&rp->addr.bdaddr, addr);
10596
10597         if (status != MGMT_STATUS_SUCCESS) {
10598                 error("Failed to remove device %s (%u): %s (0x%02x)",
10599                         addr, rp->addr.type, mgmt_errstr(status), status);
10600                 return;
10601         }
10602
10603         DBG("%s (%u) removed from kernel connect list", addr, rp->addr.type);
10604 }
10605
10606 void adapter_auto_connect_remove(struct btd_adapter *adapter,
10607                                         struct btd_device *device)
10608 {
10609         struct mgmt_cp_remove_device cp;
10610         const bdaddr_t *bdaddr;
10611         uint8_t bdaddr_type;
10612         unsigned int id;
10613
10614         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
10615                 return;
10616
10617         if (!g_slist_find(adapter->connect_list, device)) {
10618                 DBG("ignoring not added device %s", device_get_path(device));
10619                 return;
10620         }
10621
10622         bdaddr = device_get_address(device);
10623         bdaddr_type = btd_device_get_bdaddr_type(device);
10624
10625         if (bdaddr_type == BDADDR_BREDR) {
10626                 DBG("auto-connection feature is not avaiable for BR/EDR");
10627                 return;
10628         }
10629
10630         memset(&cp, 0, sizeof(cp));
10631         bacpy(&cp.addr.bdaddr, bdaddr);
10632         cp.addr.type = bdaddr_type;
10633
10634         id = mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
10635                         adapter->dev_id, sizeof(cp), &cp,
10636                         remove_device_complete, adapter, NULL);
10637         if (id == 0)
10638                 return;
10639
10640         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
10641 }
10642
10643 #if defined (TIZEN_FEATURE_BLUEZ_MODIFY)
10644 static void get_phy_configuration_resp(uint8_t status, uint16_t len, const void *param,
10645                                                         void *user_data)
10646 {
10647         uint32_t supported_phys;
10648         uint32_t configurable_phys;
10649         uint32_t selected_phys;
10650
10651         const struct mgmt_rp_get_phy_confguration *rp = param;
10652         struct btd_adapter *adapter = user_data;
10653
10654         if (status != MGMT_STATUS_SUCCESS) {
10655                 error("Get PHY Configuration failed with status 0x%02x (%s)",
10656                                 status, mgmt_errstr(status));
10657                 return;
10658         }
10659
10660         if (len < sizeof(*rp)) {
10661                 error("Too small get-phy reply (%u bytes)", len);
10662                 return;
10663         }
10664
10665         supported_phys = get_le32(&rp->supported_phys);
10666         configurable_phys = get_le32(&rp-> configurable_phys);
10667         selected_phys = get_le16(&rp->selected_phys);
10668
10669         DBG("Supported phys: [0x%x]", supported_phys);
10670         DBG("Configurable phys: [0x%x]", configurable_phys);
10671         DBG("Selected phys: [0x%x]", selected_phys);
10672
10673         if (adapter->supported_settings & MGMT_SETTING_LE) {
10674                 if ((supported_phys & MGMT_PHY_LE_2M_TX) &&
10675                                 (supported_phys & MGMT_PHY_LE_2M_RX)) {
10676                         DBG("Adapter supports LE 2M PHY");
10677                         adapter->le_2m_phy_supported = TRUE;
10678                 } else
10679                         DBG("Adapter does not support LE 2M PHY");
10680
10681                 if ((supported_phys & MGMT_PHY_LE_CODED_TX) &&
10682                                 (supported_phys & MGMT_PHY_LE_CODED_RX)) {
10683                         adapter->le_coded_phy_supported = TRUE;
10684                         DBG("Adapter supports LE CODED PHY");
10685                 } else
10686                         DBG("Adapter does not support LE CODED PHY");
10687         }
10688
10689         /* Emit Property Changed Signal */
10690          g_dbus_emit_property_changed(dbus_conn, adapter->path,
10691                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10692
10693 }
10694 #endif
10695
10696 static void adapter_start(struct btd_adapter *adapter)
10697 {
10698
10699 #if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__SPRD_PATCH__)
10700         if (adapter_le_read_ble_feature_info())
10701                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10702                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10703 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
10704         else
10705                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
10706                         ADAPTER_INTERFACE, "SupportedLEFeatures");
10707 #endif
10708
10709         adapter_get_adv_tx_power(adapter);
10710
10711         /* By default enable offloading for testing, this should be modified */
10712         if (!TIZEN_FEATURE_BLUEZ_DA)
10713                 if (adapter_le_is_supported_offloading())
10714                         adapter_le_enable_offloading(TRUE);
10715 #endif
10716
10717 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
10718         g_dbus_emit_property_changed(dbus_conn, adapter->path,
10719                                                 ADAPTER_INTERFACE, "Powered");
10720 #else
10721         g_dbus_emit_property_changed_full(dbus_conn, adapter->path,
10722                                                 ADAPTER_INTERFACE, "Powered", 1);
10723 #endif
10724         adapter_set_power_state(adapter, ADAPTER_POWER_STATE_ON);
10725
10726         DBG("adapter %s has been enabled", adapter->path);
10727
10728         trigger_passive_scanning(adapter);
10729 }
10730
10731 static void reply_pending_requests(struct btd_adapter *adapter)
10732 {
10733         GSList *l;
10734
10735         if (!adapter)
10736                 return;
10737
10738         /* pending bonding */
10739         for (l = adapter->devices; l; l = l->next) {
10740                 struct btd_device *device = l->data;
10741
10742                 if (device_is_bonding(device, NULL))
10743                         device_bonding_failed(device,
10744                                                 HCI_OE_USER_ENDED_CONNECTION);
10745         }
10746 }
10747
10748 static void remove_driver(gpointer data, gpointer user_data)
10749 {
10750         struct btd_adapter_driver *driver = data;
10751         struct btd_adapter *adapter = user_data;
10752
10753         if (driver->remove)
10754                 driver->remove(adapter);
10755 }
10756
10757 static void remove_profile(gpointer data, gpointer user_data)
10758 {
10759         struct btd_profile *profile = data;
10760         struct btd_adapter *adapter = user_data;
10761
10762         if (profile->adapter_remove)
10763                 profile->adapter_remove(profile, adapter);
10764 }
10765
10766 static void unload_drivers(struct btd_adapter *adapter)
10767 {
10768         g_slist_foreach(adapter->drivers, remove_driver, adapter);
10769         g_slist_free(adapter->drivers);
10770         adapter->drivers = NULL;
10771
10772         g_slist_foreach(adapter->profiles, remove_profile, adapter);
10773         g_slist_free(adapter->profiles);
10774         adapter->profiles = NULL;
10775 }
10776
10777 static void free_service_auth(gpointer data, gpointer user_data)
10778 {
10779         struct service_auth *auth = data;
10780
10781         g_free(auth);
10782 }
10783
10784 static void remove_discovery_list(struct btd_adapter *adapter)
10785 {
10786         g_slist_free_full(adapter->set_filter_list, discovery_free);
10787         adapter->set_filter_list = NULL;
10788
10789         g_slist_free_full(adapter->discovery_list, discovery_free);
10790         adapter->discovery_list = NULL;
10791 }
10792
10793 static void cancel_exp_pending(void *data)
10794 {
10795         struct exp_pending *pending = data;
10796         struct btd_adapter *adapter = pending->adapter;
10797
10798         pending->adapter = NULL;
10799         mgmt_cancel(adapter->mgmt, pending->id);
10800         g_free(pending);
10801 }
10802
10803 static void adapter_free(gpointer user_data)
10804 {
10805         struct btd_adapter *adapter = user_data;
10806
10807         DBG("%p", adapter);
10808
10809         /* Make sure the adapter's discovery list is cleaned up before freeing
10810          * the adapter.
10811          */
10812         remove_discovery_list(adapter);
10813
10814         if (adapter->pairable_timeout_id > 0) {
10815                 timeout_remove(adapter->pairable_timeout_id);
10816                 adapter->pairable_timeout_id = 0;
10817         }
10818
10819         if (adapter->passive_scan_timeout > 0) {
10820                 timeout_remove(adapter->passive_scan_timeout);
10821                 adapter->passive_scan_timeout = 0;
10822         }
10823
10824         if (adapter->auth_idle_id)
10825                 timeout_remove(adapter->auth_idle_id);
10826
10827         g_queue_foreach(adapter->auths, free_service_auth, NULL);
10828         g_queue_free(adapter->auths);
10829         queue_destroy(adapter->exps, NULL);
10830
10831         queue_destroy(adapter->exp_pending, cancel_exp_pending);
10832
10833         /*
10834          * Unregister all handlers for this specific index since
10835          * the adapter bound to them is no longer valid.
10836          *
10837          * This also avoids having multiple instances of the same
10838          * handler in case indexes got removed and re-added.
10839          */
10840         mgmt_unregister_index(adapter->mgmt, adapter->dev_id);
10841
10842         /*
10843          * Cancel all pending commands for this specific index
10844          * since the adapter bound to them is no longer valid.
10845          */
10846         mgmt_cancel_index(adapter->mgmt, adapter->dev_id);
10847
10848         mgmt_unref(adapter->mgmt);
10849
10850         sdp_list_free(adapter->services, NULL);
10851
10852         g_slist_free(adapter->connections);
10853
10854         g_free(adapter->path);
10855         g_free(adapter->name);
10856         g_free(adapter->short_name);
10857         g_free(adapter->system_name);
10858         g_free(adapter->stored_alias);
10859         g_free(adapter->current_alias);
10860         free(adapter->modalias);
10861
10862         if (adapter->allowed_uuid_set)
10863                 g_hash_table_destroy(adapter->allowed_uuid_set);
10864
10865         g_free(adapter);
10866 }
10867
10868 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
10869 {
10870         __sync_fetch_and_add(&adapter->ref_count, 1);
10871
10872         return adapter;
10873 }
10874
10875 void btd_adapter_unref(struct btd_adapter *adapter)
10876 {
10877         if (__sync_sub_and_fetch(&adapter->ref_count, 1))
10878                 return;
10879
10880         if (!adapter->path) {
10881                 DBG("Freeing adapter %u", adapter->dev_id);
10882
10883                 adapter_free(adapter);
10884                 return;
10885         }
10886
10887         DBG("Freeing adapter %s", adapter->path);
10888
10889         g_dbus_unregister_interface(dbus_conn, adapter->path,
10890                                                 ADAPTER_INTERFACE);
10891 }
10892
10893 static void convert_names_entry(char *key, char *value, void *user_data)
10894 {
10895         char *address = user_data;
10896         char *str = key;
10897         char filename[PATH_MAX];
10898         GKeyFile *key_file;
10899         GError *gerr = NULL;
10900         char *data;
10901         gsize length = 0;
10902
10903         if (strchr(key, '#'))
10904                 str[17] = '\0';
10905
10906         if (bachk(str) != 0)
10907                 return;
10908
10909         create_filename(filename, PATH_MAX, "/%s/cache/%s", address, str);
10910         create_file(filename, 0600);
10911
10912         key_file = g_key_file_new();
10913         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
10914                 error("Unable to load key file from %s: (%s)", filename,
10915                                                                 gerr->message);
10916                 g_clear_error(&gerr);
10917         }
10918         g_key_file_set_string(key_file, "General", "Name", value);
10919
10920         data = g_key_file_to_data(key_file, &length, NULL);
10921         if (!g_file_set_contents(filename, data, length, &gerr)) {
10922                 error("Unable set contents for %s: (%s)", filename,
10923                                                                 gerr->message);
10924                 g_error_free(gerr);
10925         }
10926         g_free(data);
10927
10928         g_key_file_free(key_file);
10929 }
10930
10931 struct device_converter {
10932         char *address;
10933         void (*cb)(GKeyFile *key_file, void *value);
10934         gboolean force;
10935 };
10936
10937 static void set_device_type(GKeyFile *key_file, char type)
10938 {
10939         char *techno;
10940         char *addr_type = NULL;
10941         char *str;
10942
10943         switch (type) {
10944         case BDADDR_BREDR:
10945                 techno = "BR/EDR";
10946                 break;
10947         case BDADDR_LE_PUBLIC:
10948                 techno = "LE";
10949                 addr_type = "public";
10950                 break;
10951         case BDADDR_LE_RANDOM:
10952                 techno = "LE";
10953                 addr_type = "static";
10954                 break;
10955         default:
10956                 return;
10957         }
10958
10959         str = g_key_file_get_string(key_file, "General",
10960                                         "SupportedTechnologies", NULL);
10961         if (!str)
10962                 g_key_file_set_string(key_file, "General",
10963                                         "SupportedTechnologies", techno);
10964         else if (!strstr(str, techno))
10965                 g_key_file_set_string(key_file, "General",
10966                                         "SupportedTechnologies", "BR/EDR;LE");
10967
10968         g_free(str);
10969
10970         if (addr_type)
10971                 g_key_file_set_string(key_file, "General", "AddressType",
10972                                         addr_type);
10973 }
10974
10975 static void convert_aliases_entry(GKeyFile *key_file, void *value)
10976 {
10977         g_key_file_set_string(key_file, "General", "Alias", value);
10978 }
10979
10980 static void convert_trusts_entry(GKeyFile *key_file, void *value)
10981 {
10982         g_key_file_set_boolean(key_file, "General", "Trusted", TRUE);
10983 }
10984
10985 static void convert_classes_entry(GKeyFile *key_file, void *value)
10986 {
10987         g_key_file_set_string(key_file, "General", "Class", value);
10988 }
10989
10990 static void convert_blocked_entry(GKeyFile *key_file, void *value)
10991 {
10992         g_key_file_set_boolean(key_file, "General", "Blocked", TRUE);
10993 }
10994
10995 static void convert_did_entry(GKeyFile *key_file, void *value)
10996 {
10997         char *vendor_str, *product_str, *version_str;
10998         uint16_t val;
10999
11000         vendor_str = strchr(value, ' ');
11001         if (!vendor_str)
11002                 return;
11003
11004         *(vendor_str++) = 0;
11005
11006         if (g_str_equal(value, "FFFF"))
11007                 return;
11008
11009         product_str = strchr(vendor_str, ' ');
11010         if (!product_str)
11011                 return;
11012
11013         *(product_str++) = 0;
11014
11015         version_str = strchr(product_str, ' ');
11016         if (!version_str)
11017                 return;
11018
11019         *(version_str++) = 0;
11020
11021         val = (uint16_t) strtol(value, NULL, 16);
11022         g_key_file_set_integer(key_file, "DeviceID", "Source", val);
11023
11024         val = (uint16_t) strtol(vendor_str, NULL, 16);
11025         g_key_file_set_integer(key_file, "DeviceID", "Vendor", val);
11026
11027         val = (uint16_t) strtol(product_str, NULL, 16);
11028         g_key_file_set_integer(key_file, "DeviceID", "Product", val);
11029
11030         val = (uint16_t) strtol(version_str, NULL, 16);
11031         g_key_file_set_integer(key_file, "DeviceID", "Version", val);
11032 }
11033
11034 static void convert_linkkey_entry(GKeyFile *key_file, void *value)
11035 {
11036         char *type_str, *length_str, *str;
11037         int val;
11038
11039         type_str = strchr(value, ' ');
11040         if (!type_str)
11041                 return;
11042
11043         *(type_str++) = 0;
11044
11045         length_str = strchr(type_str, ' ');
11046         if (!length_str)
11047                 return;
11048
11049         *(length_str++) = 0;
11050
11051         str = g_strconcat("0x", value, NULL);
11052         g_key_file_set_string(key_file, "LinkKey", "Key", str);
11053         g_free(str);
11054
11055         val = strtol(type_str, NULL, 16);
11056         g_key_file_set_integer(key_file, "LinkKey", "Type", val);
11057
11058         val = strtol(length_str, NULL, 16);
11059         g_key_file_set_integer(key_file, "LinkKey", "PINLength", val);
11060 }
11061
11062 static void convert_ltk_entry(GKeyFile *key_file, void *value)
11063 {
11064         char *auth_str, *rand_str, *str;
11065         int i, ret;
11066         unsigned char auth, central, enc_size;
11067         unsigned short ediv;
11068
11069         auth_str = strchr(value, ' ');
11070         if (!auth_str)
11071                 return;
11072
11073         *(auth_str++) = 0;
11074
11075         for (i = 0, rand_str = auth_str; i < 4; i++) {
11076                 rand_str = strchr(rand_str, ' ');
11077                 if (!rand_str || rand_str[1] == '\0')
11078                         return;
11079
11080                 rand_str++;
11081         }
11082
11083         ret = sscanf(auth_str, " %hhd %hhd %hhd %hd", &auth, &central,
11084                                                         &enc_size, &ediv);
11085         if (ret < 4)
11086                 return;
11087
11088         str = g_strconcat("0x", value, NULL);
11089         g_key_file_set_string(key_file, "LongTermKey", "Key", str);
11090         g_free(str);
11091
11092         g_key_file_set_integer(key_file, "LongTermKey", "Authenticated", auth);
11093         g_key_file_set_integer(key_file, "LongTermKey", "EncSize", enc_size);
11094         g_key_file_set_integer(key_file, "LongTermKey", "EDiv", ediv);
11095
11096         str = g_strconcat("0x", rand_str, NULL);
11097         g_key_file_set_string(key_file, "LongTermKey", "Rand", str);
11098         g_free(str);
11099 }
11100
11101 static void convert_profiles_entry(GKeyFile *key_file, void *value)
11102 {
11103         g_strdelimit(value, " ", ';');
11104         g_key_file_set_string(key_file, "General", "Services", value);
11105 }
11106
11107 static void convert_appearances_entry(GKeyFile *key_file, void *value)
11108 {
11109         g_key_file_set_string(key_file, "General", "Appearance", value);
11110 }
11111
11112 static void convert_entry(char *key, char *value, void *user_data)
11113 {
11114         struct device_converter *converter = user_data;
11115         char type = BDADDR_BREDR;
11116         char filename[PATH_MAX];
11117         GKeyFile *key_file;
11118         GError *gerr = NULL;
11119         char *data;
11120         gsize length = 0;
11121
11122         if (strchr(key, '#')) {
11123                 key[17] = '\0';
11124                 type = key[18] - '0';
11125         }
11126
11127         if (bachk(key) != 0)
11128                 return;
11129
11130         if (converter->force == FALSE) {
11131                 struct stat st;
11132                 int err;
11133
11134                 create_filename(filename, PATH_MAX, "/%s/%s",
11135                                 converter->address, key);
11136
11137                 err = stat(filename, &st);
11138                 if (err || !S_ISDIR(st.st_mode))
11139                         return;
11140         }
11141
11142         create_filename(filename, PATH_MAX, "/%s/%s/info",
11143                         converter->address, key);
11144
11145         key_file = g_key_file_new();
11146         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11147                 error("Unable to load key file from %s: (%s)", filename,
11148                                                                 gerr->message);
11149                 g_clear_error(&gerr);
11150         }
11151
11152         set_device_type(key_file, type);
11153
11154         converter->cb(key_file, value);
11155
11156         data = g_key_file_to_data(key_file, &length, NULL);
11157         if (length > 0) {
11158                 create_file(filename, 0600);
11159                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11160                         error("Unable set contents for %s: (%s)", filename,
11161                                                                 gerr->message);
11162                         g_error_free(gerr);
11163                 }
11164         }
11165
11166         g_free(data);
11167
11168         g_key_file_free(key_file);
11169 }
11170
11171 static void convert_file(char *file, char *address,
11172                                 void (*cb)(GKeyFile *key_file, void *value),
11173                                 gboolean force)
11174 {
11175         char filename[PATH_MAX];
11176         struct device_converter converter;
11177
11178         create_filename(filename, PATH_MAX, "/%s/%s", address, file);
11179
11180         converter.address = address;
11181         converter.cb = cb;
11182         converter.force = force;
11183
11184         textfile_foreach(filename, convert_entry, &converter);
11185 }
11186
11187 static gboolean record_has_uuid(const sdp_record_t *rec,
11188                                 const char *profile_uuid)
11189 {
11190         sdp_list_t *pat;
11191
11192         for (pat = rec->pattern; pat != NULL; pat = pat->next) {
11193                 char *uuid;
11194                 int ret;
11195
11196                 uuid = bt_uuid2string(pat->data);
11197                 if (!uuid)
11198                         continue;
11199
11200                 ret = strcasecmp(uuid, profile_uuid);
11201
11202                 free(uuid);
11203
11204                 if (ret == 0)
11205                         return TRUE;
11206         }
11207
11208         return FALSE;
11209 }
11210
11211 static void store_attribute_uuid(GKeyFile *key_file, uint16_t start,
11212                                         uint16_t end, char *att_uuid,
11213                                         uuid_t uuid)
11214 {
11215         char handle[6], uuid_str[33];
11216         int i;
11217
11218         switch (uuid.type) {
11219         case SDP_UUID16:
11220                 sprintf(uuid_str, "%4.4X", uuid.value.uuid16);
11221                 break;
11222         case SDP_UUID32:
11223                 sprintf(uuid_str, "%8.8X", uuid.value.uuid32);
11224                 break;
11225         case SDP_UUID128:
11226                 for (i = 0; i < 16; i++)
11227                         sprintf(uuid_str + (i * 2), "%2.2X",
11228                                         uuid.value.uuid128.data[i]);
11229                 break;
11230         default:
11231                 uuid_str[0] = '\0';
11232         }
11233
11234         sprintf(handle, "%hu", start);
11235         g_key_file_set_string(key_file, handle, "UUID", att_uuid);
11236         g_key_file_set_string(key_file, handle, "Value", uuid_str);
11237         g_key_file_set_integer(key_file, handle, "EndGroupHandle", end);
11238 }
11239
11240 static void store_sdp_record(char *local, char *peer, int handle, char *value)
11241 {
11242         char filename[PATH_MAX];
11243         GKeyFile *key_file;
11244         GError *gerr = NULL;
11245         char handle_str[11];
11246         char *data;
11247         gsize length = 0;
11248
11249         create_filename(filename, PATH_MAX, "/%s/cache/%s", local, peer);
11250
11251         key_file = g_key_file_new();
11252         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11253                 error("Unable to load key file from %s: (%s)", filename,
11254                                                                 gerr->message);
11255                 g_clear_error(&gerr);
11256         }
11257
11258         sprintf(handle_str, "0x%8.8X", handle);
11259         g_key_file_set_string(key_file, "ServiceRecords", handle_str, value);
11260
11261         data = g_key_file_to_data(key_file, &length, NULL);
11262         if (length > 0) {
11263                 create_file(filename, 0600);
11264                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11265                         error("Unable set contents for %s: (%s)", filename,
11266                                                                 gerr->message);
11267                         g_error_free(gerr);
11268                 }
11269         }
11270
11271         g_free(data);
11272
11273         g_key_file_free(key_file);
11274 }
11275
11276 static void convert_sdp_entry(char *key, char *value, void *user_data)
11277 {
11278         char *src_addr = user_data;
11279         char dst_addr[18];
11280         char type = BDADDR_BREDR;
11281         int handle, ret;
11282         char filename[PATH_MAX];
11283         GKeyFile *key_file;
11284         GError *gerr = NULL;
11285         struct stat st;
11286         sdp_record_t *rec;
11287         uuid_t uuid;
11288         char *att_uuid, *prim_uuid;
11289         uint16_t start = 0, end = 0, psm = 0;
11290         int err;
11291         char *data;
11292         gsize length = 0;
11293
11294         ret = sscanf(key, "%17s#%hhu#%08X", dst_addr, &type, &handle);
11295         if (ret < 3) {
11296                 ret = sscanf(key, "%17s#%08X", dst_addr, &handle);
11297                 if (ret < 2)
11298                         return;
11299         }
11300
11301         if (bachk(dst_addr) != 0)
11302                 return;
11303
11304         /* Check if the device directory has been created as records should
11305          * only be converted for known devices */
11306         create_filename(filename, PATH_MAX, "/%s/%s", src_addr, dst_addr);
11307
11308         err = stat(filename, &st);
11309         if (err || !S_ISDIR(st.st_mode))
11310                 return;
11311
11312         /* store device records in cache */
11313         store_sdp_record(src_addr, dst_addr, handle, value);
11314
11315         /* Retrieve device record and check if there is an
11316          * attribute entry in it */
11317         sdp_uuid16_create(&uuid, ATT_UUID);
11318         att_uuid = bt_uuid2string(&uuid);
11319
11320         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11321         prim_uuid = bt_uuid2string(&uuid);
11322
11323         rec = record_from_string(value);
11324
11325         if (record_has_uuid(rec, att_uuid))
11326                 goto failed;
11327
11328         /* TODO: Do this through btd_gatt_database */
11329         if (!gatt_parse_record(rec, &uuid, &psm, &start, &end))
11330                 goto failed;
11331
11332         create_filename(filename, PATH_MAX, "/%s/%s/attributes", src_addr,
11333                                                                 dst_addr);
11334
11335         key_file = g_key_file_new();
11336         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11337                 error("Unable to load key file from %s: (%s)", filename,
11338                                                                 gerr->message);
11339                 g_clear_error(&gerr);
11340         }
11341
11342         store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11343
11344         data = g_key_file_to_data(key_file, &length, NULL);
11345         if (length > 0) {
11346                 create_file(filename, 0600);
11347                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11348                         error("Unable set contents for %s: (%s)", filename,
11349                                                                 gerr->message);
11350                         g_error_free(gerr);
11351                 }
11352         }
11353
11354         g_free(data);
11355         g_key_file_free(key_file);
11356
11357 failed:
11358         sdp_record_free(rec);
11359         free(prim_uuid);
11360         free(att_uuid);
11361 }
11362
11363 static void convert_primaries_entry(char *key, char *value, void *user_data)
11364 {
11365         char *address = user_data;
11366         int device_type = -1;
11367         uuid_t uuid;
11368         char **services, **service, *prim_uuid;
11369         char filename[PATH_MAX];
11370         GKeyFile *key_file;
11371         GError *gerr = NULL;
11372         int ret;
11373         uint16_t start, end;
11374         char uuid_str[MAX_LEN_UUID_STR + 1];
11375         char *data;
11376         gsize length = 0;
11377
11378         if (strchr(key, '#')) {
11379                 key[17] = '\0';
11380                 device_type = key[18] - '0';
11381         }
11382
11383         if (bachk(key) != 0)
11384                 return;
11385
11386         services = g_strsplit(value, " ", 0);
11387         if (services == NULL)
11388                 return;
11389
11390         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
11391         prim_uuid = bt_uuid2string(&uuid);
11392
11393         create_filename(filename, PATH_MAX, "/%s/%s/attributes", address, key);
11394
11395         key_file = g_key_file_new();
11396         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11397                 error("Unable to load key file from %s: (%s)", filename,
11398                                                                 gerr->message);
11399                 g_clear_error(&gerr);
11400         }
11401
11402         for (service = services; *service; service++) {
11403                 ret = sscanf(*service, "%04hX#%04hX#%s", &start, &end,
11404                                                                 uuid_str);
11405                 if (ret < 3)
11406                         continue;
11407
11408                 bt_string2uuid(&uuid, uuid_str);
11409                 sdp_uuid128_to_uuid(&uuid);
11410
11411                 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
11412         }
11413
11414         g_strfreev(services);
11415
11416         data = g_key_file_to_data(key_file, &length, NULL);
11417         if (length == 0)
11418                 goto end;
11419
11420         create_file(filename, 0600);
11421         if (!g_file_set_contents(filename, data, length, &gerr)) {
11422                 error("Unable set contents for %s: (%s)", filename,
11423                                                                 gerr->message);
11424                 g_clear_error(&gerr);
11425         }
11426
11427         if (device_type < 0)
11428                 goto end;
11429
11430         g_free(data);
11431         g_key_file_free(key_file);
11432
11433         create_filename(filename, PATH_MAX, "/%s/%s/info", address, key);
11434
11435         key_file = g_key_file_new();
11436         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11437                 error("Unable to load key file from %s: (%s)", filename,
11438                                                                 gerr->message);
11439                 g_clear_error(&gerr);
11440         }
11441         set_device_type(key_file, device_type);
11442
11443         data = g_key_file_to_data(key_file, &length, NULL);
11444         if (length > 0) {
11445                 create_file(filename, 0600);
11446                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11447                         error("Unable set contents for %s: (%s)", filename,
11448                                                                 gerr->message);
11449                         g_error_free(gerr);
11450                 }
11451         }
11452
11453 end:
11454         g_free(data);
11455         free(prim_uuid);
11456         g_key_file_free(key_file);
11457 }
11458
11459 static void convert_ccc_entry(char *key, char *value, void *user_data)
11460 {
11461         char *src_addr = user_data;
11462         char dst_addr[18];
11463         char type = BDADDR_BREDR;
11464         uint16_t handle;
11465         int ret, err;
11466         char filename[PATH_MAX];
11467         GKeyFile *key_file;
11468         GError *gerr = NULL;
11469         struct stat st;
11470         char group[6];
11471         char *data;
11472         gsize length = 0;
11473
11474         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11475         if (ret < 3)
11476                 return;
11477
11478         if (bachk(dst_addr) != 0)
11479                 return;
11480
11481         /* Check if the device directory has been created as records should
11482          * only be converted for known devices */
11483         create_filename(filename, PATH_MAX, "/%s/%s", src_addr, dst_addr);
11484
11485         err = stat(filename, &st);
11486         if (err || !S_ISDIR(st.st_mode))
11487                 return;
11488
11489         create_filename(filename, PATH_MAX, "/%s/%s/ccc", src_addr, dst_addr);
11490
11491         key_file = g_key_file_new();
11492         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11493                 error("Unable to load key file from %s: (%s)", filename,
11494                                                                 gerr->message);
11495                 g_clear_error(&gerr);
11496         }
11497
11498         sprintf(group, "%hu", handle);
11499         g_key_file_set_string(key_file, group, "Value", value);
11500
11501         data = g_key_file_to_data(key_file, &length, NULL);
11502         if (length > 0) {
11503                 create_file(filename, 0600);
11504                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11505                         error("Unable set contents for %s: (%s)", filename,
11506                                                                 gerr->message);
11507                         g_error_free(gerr);
11508                 }
11509         }
11510
11511         g_free(data);
11512         g_key_file_free(key_file);
11513 }
11514
11515 static void convert_gatt_entry(char *key, char *value, void *user_data)
11516 {
11517         char *src_addr = user_data;
11518         char dst_addr[18];
11519         char type = BDADDR_BREDR;
11520         uint16_t handle;
11521         int ret, err;
11522         char filename[PATH_MAX];
11523         GKeyFile *key_file;
11524         GError *gerr = NULL;
11525         struct stat st;
11526         char group[6];
11527         char *data;
11528         gsize length = 0;
11529
11530         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
11531         if (ret < 3)
11532                 return;
11533
11534         if (bachk(dst_addr) != 0)
11535                 return;
11536
11537         /* Check if the device directory has been created as records should
11538          * only be converted for known devices */
11539         create_filename(filename, PATH_MAX, "/%s/%s", src_addr, dst_addr);
11540
11541         err = stat(filename, &st);
11542         if (err || !S_ISDIR(st.st_mode))
11543                 return;
11544
11545         create_filename(filename, PATH_MAX, "/%s/%s/gatt", src_addr, dst_addr);
11546
11547         key_file = g_key_file_new();
11548         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11549                 error("Unable to load key file from %s: (%s)", filename,
11550                                                                 gerr->message);
11551                 g_clear_error(&gerr);
11552         }
11553
11554         sprintf(group, "%hu", handle);
11555         g_key_file_set_string(key_file, group, "Value", value);
11556
11557         data = g_key_file_to_data(key_file, &length, NULL);
11558         if (length > 0) {
11559                 create_file(filename, 0600);
11560                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11561                         error("Unable set contents for %s: (%s)", filename,
11562                                                                 gerr->message);
11563                         g_error_free(gerr);
11564                 }
11565         }
11566
11567         g_free(data);
11568         g_key_file_free(key_file);
11569 }
11570
11571 static void convert_proximity_entry(char *key, char *value, void *user_data)
11572 {
11573         char *src_addr = user_data;
11574         char *alert;
11575         char filename[PATH_MAX];
11576         GKeyFile *key_file;
11577         GError *gerr = NULL;
11578         struct stat st;
11579         int err;
11580         char *data;
11581         gsize length = 0;
11582
11583         if (!strchr(key, '#'))
11584                 return;
11585
11586         key[17] = '\0';
11587         alert = &key[18];
11588
11589         if (bachk(key) != 0)
11590                 return;
11591
11592         /* Check if the device directory has been created as records should
11593          * only be converted for known devices */
11594         create_filename(filename, PATH_MAX, "/%s/%s", src_addr, key);
11595
11596         err = stat(filename, &st);
11597         if (err || !S_ISDIR(st.st_mode))
11598                 return;
11599
11600         create_filename(filename, PATH_MAX, "/%s/%s/proximity", src_addr, key);
11601
11602         key_file = g_key_file_new();
11603         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11604                 error("Unable to load key file from %s: (%s)", filename,
11605                                                                 gerr->message);
11606                 g_clear_error(&gerr);
11607         }
11608
11609         g_key_file_set_string(key_file, alert, "Level", value);
11610
11611         data = g_key_file_to_data(key_file, &length, NULL);
11612         if (length > 0) {
11613                 create_file(filename, 0600);
11614                 if (!g_file_set_contents(filename, data, length, &gerr)) {
11615                         error("Unable set contents for %s: (%s)", filename,
11616                                                                 gerr->message);
11617                         g_error_free(gerr);
11618                 }
11619         }
11620
11621         g_free(data);
11622         g_key_file_free(key_file);
11623 }
11624
11625 static void convert_device_storage(struct btd_adapter *adapter)
11626 {
11627         char filename[PATH_MAX];
11628         char address[18];
11629
11630         ba2str(&adapter->bdaddr, address);
11631
11632         /* Convert device's name cache */
11633         create_filename(filename, PATH_MAX, "/%s/names", address);
11634         textfile_foreach(filename, convert_names_entry, address);
11635
11636         /* Convert aliases */
11637         convert_file("aliases", address, convert_aliases_entry, TRUE);
11638
11639         /* Convert trusts */
11640         convert_file("trusts", address, convert_trusts_entry, TRUE);
11641
11642         /* Convert blocked */
11643         convert_file("blocked", address, convert_blocked_entry, TRUE);
11644
11645         /* Convert profiles */
11646         convert_file("profiles", address, convert_profiles_entry, TRUE);
11647
11648         /* Convert primaries */
11649         create_filename(filename, PATH_MAX, "/%s/primaries", address);
11650         textfile_foreach(filename, convert_primaries_entry, address);
11651
11652         /* Convert linkkeys */
11653         convert_file("linkkeys", address, convert_linkkey_entry, TRUE);
11654
11655         /* Convert longtermkeys */
11656         convert_file("longtermkeys", address, convert_ltk_entry, TRUE);
11657
11658         /* Convert classes */
11659         convert_file("classes", address, convert_classes_entry, FALSE);
11660
11661         /* Convert device ids */
11662         convert_file("did", address, convert_did_entry, FALSE);
11663
11664         /* Convert sdp */
11665         create_filename(filename, PATH_MAX, "/%s/sdp", address);
11666         textfile_foreach(filename, convert_sdp_entry, address);
11667
11668         /* Convert ccc */
11669         create_filename(filename, PATH_MAX, "/%s/ccc", address);
11670         textfile_foreach(filename, convert_ccc_entry, address);
11671
11672         /* Convert appearances */
11673         convert_file("appearances", address, convert_appearances_entry, FALSE);
11674
11675         /* Convert gatt */
11676         create_filename(filename, PATH_MAX, "/%s/gatt", address);
11677         textfile_foreach(filename, convert_gatt_entry, address);
11678
11679         /* Convert proximity */
11680         create_filename(filename, PATH_MAX, "/%s/proximity", address);
11681         textfile_foreach(filename, convert_proximity_entry, address);
11682 }
11683
11684 static void convert_config(struct btd_adapter *adapter, const char *filename,
11685                                                         GKeyFile *key_file)
11686 {
11687         char address[18];
11688         char str[MAX_NAME_LENGTH + 1];
11689         char config_path[PATH_MAX];
11690         int timeout;
11691         uint8_t mode;
11692         char *data;
11693         gsize length = 0;
11694         GError *gerr = NULL;
11695
11696         ba2str(&adapter->bdaddr, address);
11697         create_filename(config_path, PATH_MAX, "/%s/config", address);
11698
11699         if (read_pairable_timeout(address, &timeout) == 0)
11700                 g_key_file_set_integer(key_file, "General",
11701                                                 "PairableTimeout", timeout);
11702
11703         if (read_discoverable_timeout(address, &timeout) == 0)
11704                 g_key_file_set_integer(key_file, "General",
11705                                                 "DiscoverableTimeout", timeout);
11706
11707         if (read_on_mode(address, str, sizeof(str)) == 0) {
11708                 mode = get_mode(str);
11709                 g_key_file_set_boolean(key_file, "General", "Discoverable",
11710                                         mode == MODE_DISCOVERABLE);
11711         }
11712
11713         if (read_local_name(&adapter->bdaddr, str) == 0)
11714                 g_key_file_set_string(key_file, "General", "Alias", str);
11715
11716         create_file(filename, 0600);
11717
11718         data = g_key_file_to_data(key_file, &length, NULL);
11719         if (!g_file_set_contents(filename, data, length, &gerr)) {
11720                 error("Unable set contents for %s: (%s)", filename,
11721                                                                 gerr->message);
11722                 g_error_free(gerr);
11723         }
11724         g_free(data);
11725 }
11726
11727 static void fix_storage(struct btd_adapter *adapter)
11728 {
11729         char filename[PATH_MAX];
11730         char address[18];
11731         char *converted;
11732
11733         ba2str(&adapter->bdaddr, address);
11734
11735         create_filename(filename, PATH_MAX, "/%s/config", address);
11736
11737         converted = textfile_get(filename, "converted");
11738         if (!converted)
11739                 return;
11740
11741         free(converted);
11742
11743         textfile_del(filename, "converted");
11744
11745         create_filename(filename, PATH_MAX, "/%s/names", address);
11746         textfile_del(filename, "converted");
11747
11748         create_filename(filename, PATH_MAX, "/%s/aliases", address);
11749         textfile_del(filename, "converted");
11750
11751         create_filename(filename, PATH_MAX, "/%s/trusts", address);
11752         textfile_del(filename, "converted");
11753
11754         create_filename(filename, PATH_MAX, "/%s/blocked", address);
11755         textfile_del(filename, "converted");
11756
11757         create_filename(filename, PATH_MAX, "/%s/profiles", address);
11758         textfile_del(filename, "converted");
11759
11760         create_filename(filename, PATH_MAX, "/%s/primaries", address);
11761         textfile_del(filename, "converted");
11762
11763         create_filename(filename, PATH_MAX, "/%s/linkkeys", address);
11764         textfile_del(filename, "converted");
11765
11766         create_filename(filename, PATH_MAX, "/%s/longtermkeys", address);
11767         textfile_del(filename, "converted");
11768
11769         create_filename(filename, PATH_MAX, "/%s/classes", address);
11770         textfile_del(filename, "converted");
11771
11772         create_filename(filename, PATH_MAX, "/%s/did", address);
11773         textfile_del(filename, "converted");
11774
11775         create_filename(filename, PATH_MAX, "/%s/sdp", address);
11776         textfile_del(filename, "converted");
11777
11778         create_filename(filename, PATH_MAX, "/%s/ccc", address);
11779         textfile_del(filename, "converted");
11780
11781         create_filename(filename, PATH_MAX, "/%s/appearances", address);
11782         textfile_del(filename, "converted");
11783
11784         create_filename(filename, PATH_MAX, "/%s/gatt", address);
11785         textfile_del(filename, "converted");
11786
11787         create_filename(filename, PATH_MAX, "/%s/proximity", address);
11788         textfile_del(filename, "converted");
11789 }
11790
11791 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11792 static bool is_tempfile(const char *filename)
11793 {
11794         char *p;
11795         int i;
11796
11797         /* tempfile has ^[A-Z0-9]{6}$ suffix (e.g. "settings.1LS4BZ") */
11798         p = strrchr(filename, '.');
11799         if (p == NULL)
11800                 return false;
11801
11802         if (strlen(++p) != 6)
11803                 return false;
11804
11805         for (i = 0; i < 6; i++) {
11806                 if (isdigit(p[i]) || isupper(p[i]))
11807                         continue;
11808                 else
11809                         return false;
11810         }
11811         return true;
11812 }
11813
11814 static void delete_tempfiles(const char *dirname)
11815 {
11816         DIR *dir;
11817         struct dirent *entry;
11818         char filename[PATH_MAX];
11819
11820         dir = opendir(dirname);
11821         if (dir == NULL)
11822                 return;
11823
11824         while ((entry = readdir(dir)) != NULL) {
11825                 if (g_str_equal(entry->d_name, ".") || g_str_equal(entry->d_name, ".."))
11826                         continue;
11827
11828                 if (entry->d_type == DT_UNKNOWN)
11829                         entry->d_type = util_get_dt(dirname, entry->d_name);
11830
11831                 snprintf(filename, PATH_MAX, "%s/%s", dirname, entry->d_name);
11832
11833                 if (entry->d_type == DT_DIR) {
11834                         delete_tempfiles(filename);
11835                 } else if (entry->d_type == DT_REG && is_tempfile(entry->d_name)) {
11836                         unlink(filename);
11837                 }
11838         }
11839         closedir(dir);
11840 }
11841 #endif
11842
11843 static void load_config(struct btd_adapter *adapter)
11844 {
11845         GKeyFile *key_file;
11846         char filename[PATH_MAX];
11847         struct stat st;
11848         GError *gerr = NULL;
11849 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11850         char *str;
11851 #endif
11852
11853         key_file = g_key_file_new();
11854
11855         create_filename(filename, PATH_MAX, "/%s/settings",
11856                                         btd_adapter_get_storage_dir(adapter));
11857
11858         if (stat(filename, &st) < 0) {
11859                 convert_config(adapter, filename, key_file);
11860                 convert_device_storage(adapter);
11861         }
11862
11863         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
11864                 error("Unable to load key file from %s: (%s)", filename,
11865                                                                 gerr->message);
11866                 g_clear_error(&gerr);
11867         }
11868
11869         /* Get alias */
11870         adapter->stored_alias = g_key_file_get_string(key_file, "General",
11871                                                                 "Alias", NULL);
11872         if (!adapter->stored_alias) {
11873                 /* fallback */
11874                 adapter->stored_alias = g_key_file_get_string(key_file,
11875                                                 "General", "Name", NULL);
11876         }
11877
11878         /* Get pairable timeout */
11879         adapter->pairable_timeout = g_key_file_get_integer(key_file, "General",
11880                                                 "PairableTimeout", &gerr);
11881         if (gerr) {
11882                 adapter->pairable_timeout = btd_opts.pairto;
11883                 g_error_free(gerr);
11884                 gerr = NULL;
11885         }
11886
11887         /* Get discoverable mode */
11888         adapter->stored_discoverable = g_key_file_get_boolean(key_file,
11889                                         "General", "Discoverable", &gerr);
11890         if (gerr) {
11891 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11892                 if (TIZEN_FEATURE_BLUEZ_FHUB) {
11893                         DBG("Default Discoverable mode is TRUE");
11894                         adapter->stored_discoverable = true;
11895                 } else
11896 #endif
11897                         adapter->stored_discoverable = false;
11898                 g_error_free(gerr);
11899                 gerr = NULL;
11900         }
11901
11902         /* Get discoverable timeout */
11903         adapter->discoverable_timeout = g_key_file_get_integer(key_file,
11904                                 "General", "DiscoverableTimeout", &gerr);
11905         if (gerr) {
11906                 adapter->discoverable_timeout = btd_opts.discovto;
11907                 g_error_free(gerr);
11908                 gerr = NULL;
11909         }
11910
11911 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11912         /* Get A2DP Role */
11913         str = g_key_file_get_string(key_file, "General", "DefaultA2DPRole", &gerr);
11914         if (gerr || !str) {
11915                 if (btd_opts.default_a2dp_role) {
11916                         DBG("Default A2DP role is %s", btd_opts.default_a2dp_role);
11917                         if (g_strcmp0(btd_opts.default_a2dp_role, "sink") == 0) {
11918                                 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
11919                         } else if (g_strcmp0(btd_opts.default_a2dp_role, "both") == 0) {
11920                                 adapter->a2dp_role = BLUETOOTH_A2DP_BOTH_ROLE;
11921                         } else { /* source */
11922                                 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11923                         }
11924                 } else {
11925                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11926                 }
11927                 g_error_free(gerr);
11928                 gerr = NULL;
11929         } else {
11930                 if (g_strcmp0(str, "sink") == 0)
11931                         adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
11932                 else if (g_strcmp0(str, "both") == 0)
11933                         adapter->a2dp_role = BLUETOOTH_A2DP_BOTH_ROLE;
11934                 else /* source */
11935                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
11936                 g_free(str);
11937         }
11938 #endif
11939
11940         g_key_file_free(key_file);
11941 }
11942
11943 static struct btd_adapter *btd_adapter_new(uint16_t index)
11944 {
11945         struct btd_adapter *adapter;
11946         int blocked;
11947
11948 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11949 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
11950         DBusConnection *conn = btd_get_dbus_connection();
11951         DBusMessage *msg = NULL;
11952         DBusMessage *reply = NULL;
11953         int charging_state = 0;
11954 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
11955 #endif
11956
11957         adapter = g_try_new0(struct btd_adapter, 1);
11958         if (!adapter)
11959                 return NULL;
11960
11961         adapter->dev_id = index;
11962         adapter->mgmt = mgmt_ref(mgmt_primary);
11963         adapter->pincode_requested = false;
11964         blocked = rfkill_get_blocked(index);
11965         if (blocked > 0)
11966                 adapter->power_state = ADAPTER_POWER_STATE_OFF_BLOCKED;
11967
11968         /*
11969          * Setup default configuration values. These are either adapter
11970          * defaults or from a system wide configuration file.
11971          *
11972          * Some value might be overwritten later on by adapter specific
11973          * configuration. This is to make sure that sane defaults are
11974          * always present.
11975          */
11976         adapter->system_name = g_strdup(btd_opts.name);
11977         adapter->major_class = (btd_opts.class & 0x001f00) >> 8;
11978         adapter->minor_class = (btd_opts.class & 0x0000fc) >> 2;
11979         adapter->modalias = bt_modalias(btd_opts.did_source,
11980                                                 btd_opts.did_vendor,
11981                                                 btd_opts.did_product,
11982                                                 btd_opts.did_version);
11983         adapter->discoverable_timeout = btd_opts.discovto;
11984         adapter->pairable_timeout = btd_opts.pairto;
11985 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11986         adapter->advertising = FALSE;
11987 #endif
11988
11989         DBG("System name: %s", adapter->system_name);
11990         DBG("Major class: %u", adapter->major_class);
11991         DBG("Minor class: %u", adapter->minor_class);
11992         DBG("Modalias: %s", adapter->modalias);
11993         DBG("Discoverable timeout: %u seconds", adapter->discoverable_timeout);
11994         DBG("Pairable timeout: %u seconds", adapter->pairable_timeout);
11995         if (blocked > 0)
11996                 DBG("Power state: %s",
11997                         adapter_power_state_str(adapter->power_state));
11998
11999         adapter->auths = g_queue_new();
12000         adapter->exps = queue_new();
12001         adapter->exp_pending = queue_new();
12002
12003 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12004 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
12005         adapter->charging_watch = g_dbus_add_signal_watch(conn, DEVICED_DEST,
12006                         DEVICED_BATT_OBJECT_PATH,
12007                         DEVICED_BATT_INTERFACE, "ChargerType",
12008                         charging_state_changed, adapter, NULL);
12009         if (adapter->charging_watch == 0)
12010                 error("Cannot add signal watch for ChargerType");
12011
12012         msg = dbus_message_new_method_call(DEVICED_DEST,
12013                         DEVICED_BATT_OBJECT_PATH,
12014                         DEVICED_BATT_INTERFACE, "ChargerType");
12015         if (msg) {
12016                 reply = dbus_connection_send_with_reply_and_block(conn,
12017                                 msg, 1000, NULL);
12018                 if (reply) {
12019                         if (dbus_message_get_args(reply, NULL,
12020                                         DBUS_TYPE_INT32, &charging_state,
12021                                         DBUS_TYPE_INVALID) == TRUE) {
12022                                 set_charging_state(adapter, charging_state);
12023                         }
12024                         dbus_message_unref(reply);
12025                 } else {
12026                         error("Reply is NULL");
12027                 }
12028                 dbus_message_unref(msg);
12029         } else {
12030                 error("Unable to create dbus message for charging state");
12031         }
12032 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
12033 #endif
12034
12035         return btd_adapter_ref(adapter);
12036 }
12037
12038 static void adapter_remove(struct btd_adapter *adapter)
12039 {
12040         GSList *l;
12041 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12042         struct gatt_db *db;
12043 #endif
12044
12045         DBG("Removing adapter %s", adapter->path);
12046
12047 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12048 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
12049         if (adapter->charging_watch > 0) {
12050                 g_dbus_remove_watch(btd_get_dbus_connection(),
12051                                 adapter->charging_watch);
12052                 adapter->charging_watch = 0;
12053         }
12054
12055         if (adapter->charging_timeout) {
12056                 g_source_remove(adapter->charging_timeout);
12057                 adapter->charging_timeout = 0;
12058         }
12059 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
12060 #endif
12061
12062         if (adapter->discovery_idle_timeout > 0) {
12063                 g_source_remove(adapter->discovery_idle_timeout);
12064                 adapter->discovery_idle_timeout = 0;
12065         }
12066
12067         discovery_cleanup(adapter, 0);
12068
12069         g_slist_free(adapter->connect_list);
12070         adapter->connect_list = NULL;
12071
12072         for (l = adapter->devices; l; l = l->next) {
12073                 device_removed_drivers(adapter, l->data);
12074                 device_remove(l->data, FALSE);
12075         }
12076
12077         g_slist_free(adapter->devices);
12078         adapter->devices = NULL;
12079
12080         discovery_cleanup(adapter, 0);
12081
12082         unload_drivers(adapter);
12083
12084 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12085         db = btd_gatt_database_get_db(adapter->database);
12086         gatt_db_unregister(db, adapter->db_id);
12087         adapter->db_id = 0;
12088
12089         btd_gatt_database_destroy(adapter->database);
12090         adapter->database = NULL;
12091 #else
12092         btd_adapter_gatt_server_stop(adapter);
12093 #endif
12094         btd_adv_manager_destroy(adapter->adv_manager);
12095         adapter->adv_manager = NULL;
12096
12097         btd_adv_monitor_manager_destroy(adapter->adv_monitor_manager);
12098         adapter->adv_monitor_manager = NULL;
12099
12100         btd_battery_provider_manager_destroy(adapter->battery_provider_manager);
12101         adapter->battery_provider_manager = NULL;
12102
12103         g_slist_free(adapter->pin_callbacks);
12104         adapter->pin_callbacks = NULL;
12105
12106         g_slist_free(adapter->msd_callbacks);
12107         adapter->msd_callbacks = NULL;
12108
12109         queue_remove_all(adapter->exp_pending, NULL, NULL, cancel_exp_pending);
12110 }
12111
12112 const char *adapter_get_path(struct btd_adapter *adapter)
12113 {
12114         if (!adapter)
12115                 return NULL;
12116
12117         return adapter->path;
12118 }
12119
12120 const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter)
12121 {
12122         return &adapter->bdaddr;
12123 }
12124
12125 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12126 const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter)
12127 {
12128         if (adapter->current_settings & MGMT_SETTING_PRIVACY)
12129                 return &adapter->rpa;
12130         else if (adapter->le_static_addr.b[5] != 0)
12131                 return &adapter->le_static_addr;
12132         else
12133                 return &adapter->bdaddr;
12134 }
12135
12136 uint8_t btd_adapter_get_le_address_type(struct btd_adapter * adapter)
12137 {
12138         if (adapter->current_settings & MGMT_SETTING_PRIVACY ||
12139                                 adapter->le_static_addr.b[5] != 0)
12140                         return BDADDR_LE_RANDOM;
12141                 else
12142                         return BDADDR_LE_PUBLIC;
12143 }
12144 #endif
12145
12146 static void confirm_name_complete(uint8_t status, uint16_t length,
12147                                         const void *param, void *user_data)
12148 {
12149         struct btd_adapter *adapter = user_data;
12150
12151         if (status != MGMT_STATUS_SUCCESS) {
12152                 btd_error(adapter->dev_id,
12153                                 "Failed to confirm name for hci%u: %s (0x%02x)",
12154                                 adapter->dev_id, mgmt_errstr(status), status);
12155                 return;
12156         }
12157
12158         DBG("Confirm name complete for hci%u", adapter->dev_id);
12159 }
12160
12161 static void confirm_name(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12162                                         uint8_t bdaddr_type, bool name_known)
12163 {
12164         struct mgmt_cp_confirm_name cp;
12165         char addr[18];
12166
12167         ba2str(bdaddr, addr);
12168         DBG("hci%d bdaddr %s name_known %u", adapter->dev_id, addr,
12169                                                                 name_known);
12170
12171         memset(&cp, 0, sizeof(cp));
12172         bacpy(&cp.addr.bdaddr, bdaddr);
12173         cp.addr.type = bdaddr_type;
12174         cp.name_known = name_known;
12175
12176         /*
12177          * This timeout handling is needed since the kernel is stupid
12178          * and forgets to send a command complete response. However in
12179          * case of failures it does send a command status.
12180          */
12181         if (!mgmt_reply_timeout(adapter->mgmt, MGMT_OP_CONFIRM_NAME,
12182                                 adapter->dev_id, sizeof(cp), &cp,
12183                                 confirm_name_complete, adapter, NULL, 2))
12184                 btd_error(adapter->dev_id, "Failed to confirm name for hci%u",
12185                                                         adapter->dev_id);
12186 }
12187
12188 static void adapter_msd_notify(struct btd_adapter *adapter,
12189                                                         struct btd_device *dev,
12190                                                         GSList *msd_list)
12191 {
12192         GSList *cb_l, *cb_next;
12193         GSList *msd_l, *msd_next;
12194
12195         for (cb_l = adapter->msd_callbacks; cb_l != NULL; cb_l = cb_next) {
12196                 btd_msd_cb_t cb = cb_l->data;
12197
12198                 cb_next = g_slist_next(cb_l);
12199
12200                 for (msd_l = msd_list; msd_l != NULL; msd_l = msd_next) {
12201                         const struct eir_msd *msd = msd_l->data;
12202
12203                         msd_next = g_slist_next(msd_l);
12204
12205                         cb(adapter, dev, msd->company, msd->data,
12206                                                                 msd->data_len);
12207                 }
12208         }
12209 }
12210
12211 static bool is_filter_match(GSList *discovery_filter, struct eir_data *eir_data,
12212                                                                 int8_t rssi)
12213 {
12214         GSList *l, *m;
12215         bool got_match = false;
12216
12217         for (l = discovery_filter; l != NULL && got_match != true;
12218                                                         l = g_slist_next(l)) {
12219                 struct discovery_client *client = l->data;
12220                 struct discovery_filter *item = client->discovery_filter;
12221
12222                 /*
12223                  * If one of currently running scans is regular scan, then
12224                  * return all devices as matches
12225                  */
12226                 if (!item) {
12227                         got_match = true;
12228                         continue;
12229                 }
12230
12231                 /* if someone started discovery with empty uuids, he wants all
12232                  * devices in given proximity.
12233                  */
12234                 if (!item->uuids)
12235                         got_match = true;
12236                 else {
12237                         for (m = item->uuids; m != NULL && got_match != true;
12238                                                         m = g_slist_next(m)) {
12239                                 /* m->data contains string representation of
12240                                  * uuid.
12241                                  */
12242                                 if (g_slist_find_custom(eir_data->services,
12243                                                         m->data,
12244                                                         g_strcmp) != NULL)
12245                                         got_match = true;
12246                         }
12247                 }
12248
12249                 if (got_match) {
12250                         /* we have service match, check proximity */
12251                         if (item->rssi == DISTANCE_VAL_INVALID ||
12252                             item->rssi <= rssi ||
12253                             item->pathloss == DISTANCE_VAL_INVALID ||
12254                             (eir_data->tx_power != 127 &&
12255                              eir_data->tx_power - rssi <= item->pathloss))
12256                                 return true;
12257
12258                         got_match = false;
12259                 }
12260         }
12261
12262         return got_match;
12263 }
12264
12265 static void filter_duplicate_data(void *data, void *user_data)
12266 {
12267         struct discovery_client *client = data;
12268         bool *duplicate = user_data;
12269
12270         if (*duplicate || !client->discovery_filter)
12271                 return;
12272
12273         *duplicate = client->discovery_filter->duplicate;
12274 }
12275
12276 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12277 static bool device_is_discoverable(struct btd_adapter *adapter,
12278                                         struct eir_data *eir, const char *addr,
12279                                         uint8_t bdaddr_type)
12280 {
12281         GSList *l;
12282         bool discoverable;
12283
12284         if (bdaddr_type == BDADDR_BREDR || adapter->filtered_discovery)
12285                 discoverable = true;
12286         else
12287                 discoverable = eir->flags & (EIR_LIM_DISC | EIR_GEN_DISC);
12288
12289         /*
12290          * Mark as not discoverable if no client has requested discovery and
12291          * report has not set any discoverable flags.
12292          */
12293         if (!adapter->discovery_list && !discoverable)
12294                 return false;
12295
12296         /* Do a prefix match for both address and name if pattern is set */
12297         for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
12298                 struct dicovery_client *client = l->data;
12299                 struct discovery_filter *filter = client->discovery_filter;
12300                 size_t pattern_len;
12301
12302                 if (!filter || !filter->pattern)
12303                         continue;
12304
12305                 /* Reset discoverable if a client has a pattern filter */
12306                 discoverable = false;
12307
12308                 pattern_len = strlen(filter->pattern);
12309                 if (!pattern_len)
12310                         return true;
12311
12312                 if (!strncmp(filter->pattern, addr, pattern_len))
12313                         return true;
12314
12315                 if (eir->name && !strncmp(filter->pattern, eir->name,
12316                                                         pattern_len))
12317                         return true;
12318         }
12319
12320         return discoverable;
12321 }
12322 #endif
12323
12324 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12325 void btd_adapter_device_found(struct btd_adapter *adapter,
12326                                         const bdaddr_t *bdaddr,
12327                                         uint8_t bdaddr_type, int8_t rssi,
12328                                         uint8_t adv_type, uint32_t flags,
12329                                         const uint8_t *data, uint8_t data_len,
12330                                         bool monitoring)
12331 #else
12332 void btd_adapter_device_found(struct btd_adapter *adapter,
12333                                         const bdaddr_t *bdaddr,
12334                                         uint8_t bdaddr_type, int8_t rssi,
12335                                         uint8_t adv_type, uint32_t flags,
12336                                         const uint8_t *data, uint8_t data_len,
12337                                         bool monitoring)
12338 #endif
12339 {
12340         struct btd_device *dev;
12341 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12342         struct bt_ad *ad = NULL;
12343 #endif
12344         struct eir_data eir_data;
12345 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12346         bool name_known, discoverable;
12347         bool not_connectable;
12348 #else
12349         bool name_known;
12350 #endif
12351 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12352         uint8_t allow_report;
12353 #endif
12354         char addr[18];
12355         bool confirm;
12356         bool legacy;
12357 //      bool not_connectable;
12358         bool name_resolve_failed;
12359         bool scan_rsp;
12360         bool duplicate = false;
12361
12362         confirm = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
12363         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
12364 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12365         not_connectable = (flags & MGMT_DEV_FOUND_NOT_CONNECTABLE);
12366 #endif
12367         name_resolve_failed = (flags & MGMT_DEV_FOUND_NAME_REQUEST_FAILED);
12368         scan_rsp = (flags & MGMT_DEV_FOUND_SCAN_RSP);
12369
12370 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12371         struct queue *matched_monitors = NULL;
12372
12373         if (!btd_adv_monitor_offload_enabled(adapter->adv_monitor_manager) ||
12374                                (MGMT_VERSION(mgmt_version, mgmt_revision) <
12375                                                        MGMT_VERSION(1, 22))) {
12376                 if (bdaddr_type != BDADDR_BREDR)
12377                         ad = bt_ad_new_with_data(data_len, data);
12378
12379                 /* During the background scanning, update the device only when
12380                 * the data match at least one Adv monitor
12381                 */
12382                 if (ad) {
12383                         matched_monitors = btd_adv_monitor_content_filter(
12384                                                 adapter->adv_monitor_manager,
12385                                                 ad);
12386                         bt_ad_unref(ad);
12387                         ad = NULL;
12388                         monitoring = matched_monitors ? true : false;
12389                 }
12390         }
12391
12392         if (!adapter->discovering && !monitoring)
12393                 return;
12394 #endif
12395         memset(&eir_data, 0, sizeof(eir_data));
12396         eir_parse(&eir_data, data, data_len);
12397         ba2str(bdaddr, addr);
12398 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12399         discoverable = device_is_discoverable(adapter, &eir_data, addr,
12400                                                         bdaddr_type);
12401
12402 #endif
12403
12404 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
12405         /* Check if the any filter policy */
12406         allow_report = validate_for_filter_policy(adapter, &eir_data, addr);
12407         if (allow_report == NONE_REPORT &&
12408                 ((adapter->scan_type == LE_ACTIVE_SCAN && adv_type == ADV_TYPE_SCAN_RESPONSE) ||
12409                 adapter->scan_type == LE_PASSIVE_SCAN)) {
12410                 eir_data_free(&eir_data);
12411                 return;
12412         }
12413 #endif
12414         dev = btd_adapter_find_device(adapter, bdaddr, bdaddr_type);
12415         if (!dev) {
12416                 /*
12417                  * If no client has requested discovery or the device is
12418                  * not marked as discoverable, then do not create new
12419                  * device objects.
12420                  */
12421
12422                 /* In case of being just a scan response don't attempt to create
12423                  * the device.
12424                  */
12425                 if (scan_rsp) {
12426                         eir_data_free(&eir_data);
12427                         return;
12428                 }
12429
12430         /* Monitor Devices advertising Broadcast Announcements if the
12431          * adapter is capable of synchronizing to it.
12432          */
12433         if (eir_get_service_data(&eir_data, BCAA_SERVICE_UUID) &&
12434                                 btd_adapter_has_settings(adapter,
12435                                 MGMT_SETTING_ISO_SYNC_RECEIVER))
12436                 monitoring = true;
12437 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12438                 /*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
12439                         adapter->le_discovery_list, discoverable);*/
12440                 if ((adapter->discovery_list == NULL &&
12441                                 adapter->le_discovery_list == NULL)) {
12442                         DBG("discovery list is NULL");
12443                         eir_data_free(&eir_data);
12444                         return;
12445                 }
12446 #else
12447                 if (!adapter->discovery_list || !discoverable &&
12448                          !matched_monitors && !eir_data.rsi) {
12449                         eir_data_free(&eir_data);
12450                         return;
12451                 }
12452 #endif
12453
12454                 dev = adapter_create_device(adapter, bdaddr, bdaddr_type);
12455         }
12456
12457         if (!dev) {
12458                 btd_error(adapter->dev_id,
12459                         "Unable to create object for found device %s", addr);
12460                 eir_data_free(&eir_data);
12461                 return;
12462         }
12463
12464 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12465         if (device_get_rpa_exist(dev) == true)
12466                 bdaddr_type = BDADDR_LE_RANDOM;
12467
12468         device_update_last_seen(dev, bdaddr_type);
12469 #else
12470         device_update_last_seen(dev, bdaddr_type, !not_connectable);
12471 #endif
12472
12473         /*
12474          * FIXME: We need to check for non-zero flags first because
12475          * older kernels send separate adv_ind and scan_rsp. Newer
12476          * kernels send them merged, so once we know which mgmt version
12477          * supports this we can make the non-zero check conditional.
12478          */
12479 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12480         if (bdaddr_type == BDADDR_LE_PUBLIC && eir_data.flags &&
12481                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
12482                 device_set_bredr_support(dev);
12483                 /* Update last seen for BR/EDR in case its flag is set */
12484                 device_update_last_seen(dev, BDADDR_BREDR);
12485         }
12486 #else
12487         if (bdaddr_type != BDADDR_BREDR && eir_data.flags &&
12488                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
12489                 device_set_bredr_support(dev);
12490                 /* Update last seen for BR/EDR in case its flag is set */
12491                 device_update_last_seen(dev, BDADDR_BREDR, !not_connectable);
12492         }
12493 #endif
12494
12495         if (eir_data.name != NULL && eir_data.name_complete)
12496                 device_store_cached_name(dev, eir_data.name);
12497
12498         /*
12499          * Only skip devices that are not connected, are temporary, and there
12500          * is no active discovery session ongoing and no matched Adv monitors
12501          */
12502 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12503         if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
12504                         adapter->le_discovery_list == NULL) {
12505                 DBG("discovery list is NULL");
12506                 eir_data_free(&eir_data);
12507                 return;
12508         }
12509
12510         device_set_last_addr_type(dev, bdaddr_type);
12511         device_set_ipsp_connected(dev, FALSE, NULL);
12512 #else
12513         if (!btd_device_is_connected(dev) &&
12514                 (device_is_temporary(dev) && !adapter->discovery_list) &&
12515                 !monitoring) {
12516                 eir_data_free(&eir_data);
12517                 return;
12518         }
12519 #endif
12520
12521 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12522         if (bdaddr_type == BDADDR_BREDR) {
12523         if (adapter->filtered_discovery &&
12524             !is_filter_match(adapter->discovery_list, &eir_data, rssi)) {
12525 #else
12526         /* If there is no matched Adv monitors, don't continue if not
12527          * discoverable or if active discovery filter don't match.
12528          */
12529         if (!eir_data.rsi && !monitoring && (!discoverable ||
12530                 (adapter->filtered_discovery && !is_filter_match(
12531                                 adapter->discovery_list, &eir_data, rssi)))) {
12532 #endif
12533                 eir_data_free(&eir_data);
12534                 return;
12535         }
12536
12537         device_set_legacy(dev, legacy);
12538
12539         if (name_resolve_failed)
12540                 device_name_resolve_fail(dev);
12541
12542         if (adapter->filtered_discovery)
12543                 device_set_rssi_with_delta(dev, rssi, 0);
12544         else
12545                 device_set_rssi(dev, rssi);
12546
12547         if (eir_data.tx_power != 127)
12548                 device_set_tx_power(dev, eir_data.tx_power);
12549 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12550         }
12551 #endif
12552
12553         if (eir_data.appearance != 0)
12554                 device_set_appearance(dev, eir_data.appearance);
12555
12556         /* Report an unknown name to the kernel even if there is a short name
12557          * known, but still update the name with the known short name. */
12558 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12559         if (eir_data.name_complete)
12560                 name_known = device_name_known(dev);
12561         else
12562                 name_known = false;
12563 #else
12564         name_known = device_name_known(dev);
12565 #endif
12566
12567         if (eir_data.name && (eir_data.name_complete || !name_known))
12568                 btd_device_device_set_name(dev, eir_data.name);
12569
12570         if (eir_data.class != 0)
12571                 device_set_class(dev, eir_data.class);
12572
12573         if (eir_data.did_source || eir_data.did_vendor ||
12574                         eir_data.did_product || eir_data.did_version)
12575                 btd_device_set_pnpid(dev, eir_data.did_source,
12576                                                         eir_data.did_vendor,
12577                                                         eir_data.did_product,
12578                                                         eir_data.did_version);
12579
12580         device_add_eir_uuids(dev, eir_data.services);
12581
12582         if (adapter->discovery_list)
12583                 g_slist_foreach(adapter->discovery_list, filter_duplicate_data,
12584                                                                 &duplicate);
12585 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12586         if (eir_data.flags != 0)
12587                 device_set_remote_feature_flag(dev, eir_data.flags);
12588
12589         if (bdaddr_type == BDADDR_BREDR)
12590                 device_set_manufacturer_info(dev, &eir_data);
12591         else {
12592                 /* if the application has registered for iBeacon report,
12593                  * then send ibeacon report along with advertisement report */
12594                 device_set_adv_report_info(dev, (void*)data, data_len, adv_type, rssi);
12595         }
12596 #endif
12597
12598         if (eir_data.msd_list) {
12599                 device_set_manufacturer_data(dev, eir_data.msd_list, duplicate);
12600                 adapter_msd_notify(adapter, dev, eir_data.msd_list);
12601         }
12602
12603         if (eir_data.sd_list)
12604                 device_set_service_data(dev, eir_data.sd_list, duplicate);
12605
12606         if (eir_data.data_list)
12607                 device_set_data(dev, eir_data.data_list, duplicate);
12608
12609 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12610         if (bdaddr_type != BDADDR_BREDR && adv_type != ADV_TYPE_SCAN_RESPONSE) {
12611                 device_set_flags(dev, eir_data.flags);
12612                 device_set_le_connectable(dev, adv_type);
12613         }
12614 #else
12615         if (bdaddr_type != BDADDR_BREDR)
12616                 device_set_flags(dev, eir_data.flags);
12617 #endif
12618
12619         eir_data_free(&eir_data);
12620
12621 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12622         /* After the device is updated, notify the matched Adv monitors */
12623         if (matched_monitors) {
12624                 btd_adv_monitor_notify_monitors(adapter->adv_monitor_manager,
12625                                                 dev, rssi, matched_monitors);
12626                 queue_destroy(matched_monitors, NULL);
12627                 matched_monitors = NULL;
12628         }
12629 #endif
12630         /*
12631          * Only if at least one client has requested discovery, maintain
12632          * list of found devices and name confirming for legacy devices.
12633          * Otherwise, this is an event from passive discovery and we
12634          * should check if the device needs connecting to.
12635          */
12636 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12637         if (!adapter->discovery_list && !adapter->le_discovery_list)
12638 #else
12639         if (!adapter->discovery_list)
12640 #endif
12641                 goto connect_le;
12642
12643         if (g_slist_find(adapter->discovery_found, dev))
12644                 return;
12645
12646         /* If name is unknown but it's not allowed to resolve, don't send
12647          * MGMT_OP_CONFIRM_NAME.
12648          */
12649         if (confirm && (name_known || device_is_name_resolve_allowed(dev)))
12650                 confirm_name(adapter, bdaddr, bdaddr_type, name_known);
12651
12652         adapter->discovery_found = g_slist_prepend(adapter->discovery_found,
12653                                                                         dev);
12654
12655         return;
12656
12657 connect_le:
12658 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12659         /* Ignore non-connectable events */
12660         if (not_connectable)
12661                 return;
12662 #endif
12663
12664         /*
12665          * If we're in the process of stopping passive scanning and
12666          * connecting another (or maybe even the same) LE device just
12667          * ignore this one.
12668          */
12669         if (adapter->connect_le)
12670                 return;
12671
12672         /*
12673          * If kernel background scan is used then the kernel is
12674          * responsible for connecting.
12675          */
12676         if (btd_has_kernel_features(KERNEL_CONN_CONTROL))
12677                 return;
12678
12679         /*
12680          * If this is an LE device that's not connected and part of the
12681          * connect_list stop passive scanning so that a connection
12682          * attempt to it can be made
12683          */
12684         if (bdaddr_type != BDADDR_BREDR && !btd_device_is_connected(dev) &&
12685                                 g_slist_find(adapter->connect_list, dev)) {
12686                 adapter->connect_le = dev;
12687                 stop_passive_scanning(adapter);
12688         }
12689 }
12690
12691 static void device_found_callback(uint16_t index, uint16_t length,
12692                                         const void *param, void *user_data)
12693 {
12694         const struct mgmt_ev_device_found *ev = param;
12695         struct btd_adapter *adapter = user_data;
12696         const uint8_t *eir;
12697         uint16_t eir_len;
12698         uint32_t flags;
12699         char addr[18];
12700         if (length < sizeof(*ev)) {
12701                 btd_error(adapter->dev_id,
12702                         "Too short device found event (%u bytes)", length);
12703                 return;
12704         }
12705
12706         eir_len = btohs(ev->eir_len);
12707         if (length != sizeof(*ev) + eir_len) {
12708                 btd_error(adapter->dev_id,
12709                                 "Device found event size mismatch (%u != %zu)",
12710                                         length, sizeof(*ev) + eir_len);
12711                 return;
12712         }
12713
12714         if (eir_len == 0)
12715                 eir = NULL;
12716         else
12717                 eir = ev->eir;
12718
12719         flags = le32_to_cpu(ev->flags);
12720
12721         ba2str(&ev->addr.bdaddr, addr);
12722         DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12723                         index, addr, ev->rssi, flags, eir_len);
12724
12725 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12726         btd_adapter_device_found(adapter, &ev->addr.bdaddr,
12727                                         ev->addr.type, ev->rssi, 0, flags,
12728                                         eir, eir_len, false);
12729 #else
12730         btd_adapter_device_found(adapter, &ev->addr.bdaddr,
12731                                         ev->addr.type, ev->rssi, 0, flags,
12732                                         eir, eir_len, false);
12733 #endif
12734 }
12735
12736 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12737 static void le_device_found_callback(uint16_t index, uint16_t length,
12738                                         const void *param, void *user_data)
12739 {
12740         const struct mgmt_ev_le_device_found *ev = param;
12741         struct btd_adapter *adapter = user_data;
12742         const uint8_t *eir;
12743         uint16_t eir_len;
12744         uint32_t flags;
12745         char addr[18];
12746
12747         if (length < sizeof(*ev)) {
12748                 error("Too short device found event (%u bytes)", length);
12749                 return;
12750         }
12751
12752         eir_len = btohs(ev->eir_len);
12753         if (length != sizeof(*ev) + eir_len) {
12754                 error("Device found event size mismatch (%u != %zu)",
12755                                         length, sizeof(*ev) + eir_len);
12756                 return;
12757         }
12758
12759         if (eir_len == 0)
12760                 eir = NULL;
12761         else
12762                 eir = ev->eir;
12763
12764         flags = btohl(ev->flags);
12765
12766         ba2str(&ev->addr.bdaddr, addr);
12767         /*DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
12768                         index, addr, ev->rssi, flags, eir_len);*/
12769
12770         btd_adapter_device_found(adapter, &ev->addr.bdaddr, ev->addr.type,
12771                                         ev->rssi, ev->adv_type, flags,
12772                                         eir, eir_len, false);
12773 }
12774 #endif
12775
12776 struct agent *adapter_get_agent(struct btd_adapter *adapter)
12777 {
12778         return agent_get(NULL);
12779 }
12780
12781 static void adapter_remove_connection(struct btd_adapter *adapter,
12782                                                 struct btd_device *device,
12783                                                 uint8_t bdaddr_type)
12784 {
12785         bool remove_device = false;
12786
12787         DBG("");
12788
12789         if (!g_slist_find(adapter->connections, device)) {
12790                 btd_error(adapter->dev_id, "No matching connection for device");
12791                 return;
12792         }
12793
12794         device_remove_connection(device, bdaddr_type, &remove_device);
12795
12796 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12797         if (device_is_authenticating(device, bdaddr_type))
12798 #else
12799         if (device_is_authenticating(device))
12800 #endif
12801                 device_cancel_authentication(device, TRUE);
12802
12803         /* If another bearer is still connected */
12804         if (btd_device_is_connected(device))
12805                 return;
12806
12807         adapter->connections = g_slist_remove(adapter->connections, device);
12808
12809         if (remove_device) {
12810                 const char *path = device_get_path(device);
12811
12812                 DBG("Removing temporary device %s", path);
12813                 btd_adapter_remove_device(adapter, device);
12814         }
12815
12816 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12817         DBG("isPaired %d, isBonded %d", device_is_paired(device, bdaddr_type),
12818                         device_is_bonded(device, bdaddr_type));
12819         if ((device_is_temporary(device) && !device_is_retrying(device)) ||
12820                         (!device_is_bonded(device, bdaddr_type))) {
12821
12822                 const char *path = device_get_path(device);
12823
12824                 DBG("Removing temporary device %s", path);
12825
12826                 /* device_is_paired is added incase of tempoary bonded
12827                  * oop file transfer in that device is not bonded it's paired.
12828                  */
12829                 if (!(device_is_bonded(device, bdaddr_type) ||
12830                                 device_is_paired(device, bdaddr_type))) {
12831                         DBG("addr type %d, bonded", bdaddr_type);
12832                         return;
12833                 }
12834
12835                 btd_adapter_unpair_device(adapter, device);
12836 #endif
12837         }
12838 }
12839
12840 static void adapter_stop(struct btd_adapter *adapter)
12841 {
12842         /* check pending requests */
12843         reply_pending_requests(adapter);
12844
12845         cancel_passive_scanning(adapter);
12846
12847         remove_discovery_list(adapter);
12848
12849         discovery_cleanup(adapter, 0);
12850
12851         adapter->filtered_discovery = false;
12852         adapter->no_scan_restart_delay = false;
12853         g_free(adapter->current_discovery_filter);
12854         adapter->current_discovery_filter = NULL;
12855
12856         set_discovery_discoverable(adapter, false);
12857         adapter->discovering = false;
12858
12859         while (adapter->connections) {
12860                 struct btd_device *device = adapter->connections->data;
12861                 uint8_t addr_type = btd_device_get_bdaddr_type(device);
12862
12863                 adapter_remove_connection(adapter, device, BDADDR_BREDR);
12864                 if (addr_type != BDADDR_BREDR)
12865                         adapter_remove_connection(adapter, device, addr_type);
12866         }
12867
12868         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12869                                         ADAPTER_INTERFACE, "Discovering");
12870 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12871         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12872                                                 ADAPTER_INTERFACE, "LEDiscovering");
12873 #endif
12874
12875         if (adapter->dev_class) {
12876                 /* the kernel should reset the class of device when powering
12877                  * down, but it does not. So force it here ... */
12878                 adapter->dev_class = 0;
12879                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
12880                                                 ADAPTER_INTERFACE, "Class");
12881         }
12882
12883 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12884         advertiser_cleanup(adapter);
12885 #endif
12886         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12887                                                 ADAPTER_INTERFACE, "Powered");
12888         g_dbus_emit_property_changed(dbus_conn, adapter->path,
12889                                                 ADAPTER_INTERFACE,
12890                                                 "PowerState");
12891
12892         DBG("adapter %s has been disabled", adapter->path);
12893 }
12894
12895 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
12896 {
12897         if (driver->experimental && !(g_dbus_get_flags() &
12898                                         G_DBUS_FLAG_ENABLE_EXPERIMENTAL)) {
12899                 DBG("D-Bus experimental not enabled");
12900                 return -ENOTSUP;
12901         }
12902
12903         adapter_drivers = g_slist_append(adapter_drivers, driver);
12904
12905         if (driver->probe == NULL)
12906                 return 0;
12907
12908         adapter_foreach(probe_driver, driver);
12909
12910         return 0;
12911 }
12912
12913 static void unload_driver(struct btd_adapter *adapter, gpointer data)
12914 {
12915         struct btd_adapter_driver *driver = data;
12916
12917         if (driver->remove)
12918                 driver->remove(adapter);
12919
12920         adapter->drivers = g_slist_remove(adapter->drivers, data);
12921 }
12922
12923 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
12924 {
12925         adapter_drivers = g_slist_remove(adapter_drivers, driver);
12926
12927         adapter_foreach(unload_driver, driver);
12928 }
12929
12930 static void agent_auth_cb(struct agent *agent, DBusError *derr,
12931                                                         void *user_data)
12932 {
12933         struct btd_adapter *adapter = user_data;
12934         struct service_auth *auth = g_queue_pop_head(adapter->auths);
12935
12936         if (!auth) {
12937                 DBG("No pending authorization");
12938                 return;
12939         }
12940
12941         auth->cb(derr, auth->user_data);
12942
12943         if (auth->agent)
12944                 agent_unref(auth->agent);
12945
12946         g_free(auth);
12947
12948         /* Stop processing if queue is empty */
12949         if (g_queue_is_empty(adapter->auths)) {
12950                 if (adapter->auth_idle_id > 0)
12951                         g_source_remove(adapter->auth_idle_id);
12952                 return;
12953         }
12954
12955         if (adapter->auth_idle_id > 0)
12956                 return;
12957
12958         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
12959 }
12960
12961 static gboolean process_auth_queue(gpointer user_data)
12962 {
12963         struct btd_adapter *adapter = user_data;
12964         DBusError err;
12965
12966         adapter->auth_idle_id = 0;
12967
12968         dbus_error_init(&err);
12969         dbus_set_error_const(&err, ERROR_INTERFACE ".Rejected", NULL);
12970
12971         while (!g_queue_is_empty(adapter->auths)) {
12972                 struct service_auth *auth = adapter->auths->head->data;
12973                 struct btd_device *device = auth->device;
12974
12975                 /* Wait services to be resolved before asking authorization */
12976                 if (auth->svc_id > 0) {
12977 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12978                         DBG("Wait services to be resolved before asking authorization");
12979 #endif
12980                         return FALSE;
12981                 }
12982                 if (!btd_adapter_is_uuid_allowed(adapter, auth->uuid)) {
12983                         auth->cb(&err, auth->user_data);
12984                         goto next;
12985                 }
12986
12987 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12988                 if (btd_device_is_trusted(device) == TRUE) {
12989 #else
12990                 if (btd_device_is_trusted(device) == TRUE
12991                                 || device_is_profile_trusted(device, auth->uuid)
12992                                 || btd_opts.pin_code) {
12993                         /* In headless device(pin_code is existing),
12994                            no need to request to agent */
12995 #endif
12996                         auth->cb(NULL, auth->user_data);
12997                         goto next;
12998                 }
12999
13000 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13001                 /* If Profile is Blocked, Simply reject Authorization*/
13002                 if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
13003                         auth->cb(&err, auth->user_data);
13004                         goto next;
13005                 }
13006 #endif
13007
13008                 /* If agent is set authorization is already ongoing */
13009                 if (auth->agent)
13010                         return FALSE;
13011
13012                 auth->agent = agent_get(NULL);
13013                 if (auth->agent == NULL) {
13014                         btd_warn(adapter->dev_id,
13015                                         "Authentication attempt without agent");
13016                         auth->cb(&err, auth->user_data);
13017                         goto next;
13018                 }
13019
13020                 if (agent_authorize_service(auth->agent, device, auth->uuid,
13021                                         agent_auth_cb, adapter, NULL) < 0) {
13022                         auth->cb(&err, auth->user_data);
13023                         goto next;
13024                 }
13025
13026                 break;
13027
13028 next:
13029                 if (auth->agent)
13030                         agent_unref(auth->agent);
13031
13032                 g_free(auth);
13033
13034                 g_queue_pop_head(adapter->auths);
13035         }
13036
13037         dbus_error_free(&err);
13038
13039         return FALSE;
13040 }
13041
13042 static void svc_complete(struct btd_device *dev, int err, void *user_data)
13043 {
13044         struct service_auth *auth = user_data;
13045         struct btd_adapter *adapter = auth->adapter;
13046
13047         auth->svc_id = 0;
13048
13049         if (adapter->auth_idle_id != 0)
13050                 return;
13051
13052         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
13053 }
13054
13055 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
13056                                         const char *uuid,
13057                                         adapter_authorize_type check_for_connection,
13058                                         service_auth_cb cb, void *user_data)
13059 {
13060         struct service_auth *auth;
13061         struct btd_device *device;
13062         static guint id = 0;
13063
13064 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13065         if (!strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
13066                 device = btd_adapter_find_device(adapter, dst, BDADDR_LE_PUBLIC);
13067         else
13068                 device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
13069 #else
13070         device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
13071 #endif
13072
13073         if (!device)
13074                 return 0;
13075
13076         if (device_is_disconnecting(device)) {
13077                 DBG("Authorization request while disconnecting");
13078                 return 0;
13079         }
13080
13081         /* Device connected? */
13082         if (check_for_connection && !g_slist_find(adapter->connections, device))
13083                 btd_error(adapter->dev_id,
13084                         "Authorization request for non-connected device!?");
13085
13086         auth = g_try_new0(struct service_auth, 1);
13087         if (!auth)
13088                 return 0;
13089
13090         auth->cb = cb;
13091         auth->user_data = user_data;
13092         auth->uuid = uuid;
13093         auth->device = device;
13094         auth->adapter = adapter;
13095         auth->id = ++id;
13096 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13097         if (check_for_connection &&
13098                 strncmp(uuid, L2CAP_LE_UUID_SUBSTR, strlen(L2CAP_LE_UUID_SUBSTR)))
13099 #else
13100         if (check_for_connection)
13101 #endif
13102                 auth->svc_id = device_wait_for_svc_complete(device, svc_complete, auth);
13103         else {
13104                 if (adapter->auth_idle_id == 0)
13105                         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
13106         }
13107
13108         g_queue_push_tail(adapter->auths, auth);
13109
13110         return auth->id;
13111 }
13112
13113 guint btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
13114                                         const char *uuid, service_auth_cb cb,
13115                                         void *user_data)
13116 {
13117         struct btd_adapter *adapter;
13118         GSList *l;
13119
13120         if (bacmp(src, BDADDR_ANY) != 0) {
13121                 adapter = adapter_find(src);
13122                 if (!adapter)
13123                         return 0;
13124
13125                 return adapter_authorize(adapter, dst, uuid,
13126                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
13127         }
13128
13129         for (l = adapters; l != NULL; l = g_slist_next(l)) {
13130                 guint id;
13131
13132                 adapter = l->data;
13133
13134                 id = adapter_authorize(adapter, dst, uuid,
13135                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
13136                 if (id != 0)
13137                         return id;
13138         }
13139
13140         return 0;
13141 }
13142
13143 guint btd_request_authorization_cable_configured(const bdaddr_t *src, const bdaddr_t *dst,
13144                                                 const char *uuid, service_auth_cb cb,
13145                                                 void *user_data)
13146 {
13147         struct btd_adapter *adapter;
13148
13149         if (bacmp(src, BDADDR_ANY) == 0)
13150                 return 0;
13151
13152         adapter = adapter_find(src);
13153         if (!adapter)
13154                 return 0;
13155
13156         return adapter_authorize(adapter, dst, uuid,
13157                         ADAPTER_AUTHORIZE_DISCONNECTED, cb, user_data);
13158 }
13159
13160 static struct service_auth *find_authorization(guint id)
13161 {
13162         GSList *l;
13163         GList *l2;
13164
13165         for (l = adapters; l != NULL; l = g_slist_next(l)) {
13166                 struct btd_adapter *adapter = l->data;
13167
13168                 for (l2 = adapter->auths->head; l2 != NULL; l2 = l2->next) {
13169                         struct service_auth *auth = l2->data;
13170
13171                         if (auth->id == id)
13172                                 return auth;
13173                 }
13174         }
13175
13176         return NULL;
13177 }
13178
13179 int btd_cancel_authorization(guint id)
13180 {
13181         struct service_auth *auth;
13182
13183         auth = find_authorization(id);
13184         if (auth == NULL)
13185                 return -EPERM;
13186
13187         if (auth->svc_id > 0)
13188                 device_remove_svc_complete_callback(auth->device,
13189                                                                 auth->svc_id);
13190
13191         g_queue_remove(auth->adapter->auths, auth);
13192
13193         if (auth->agent) {
13194                 agent_cancel(auth->agent);
13195                 agent_unref(auth->agent);
13196         }
13197
13198         g_free(auth);
13199
13200         return 0;
13201 }
13202
13203 int btd_adapter_restore_powered(struct btd_adapter *adapter)
13204 {
13205         bool powered;
13206
13207         powered = btd_adapter_get_powered(adapter);
13208         if (adapter->power_state == ADAPTER_POWER_STATE_OFF_BLOCKED &&
13209             rfkill_get_blocked(adapter->dev_id) == 0) {
13210                 adapter_set_power_state(adapter,
13211                                         powered ?
13212                                         ADAPTER_POWER_STATE_ON :
13213                                         ADAPTER_POWER_STATE_OFF);
13214         }
13215
13216         if (powered)
13217                 return 0;
13218
13219         set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
13220
13221         return 0;
13222 }
13223
13224 int btd_adapter_set_blocked(struct btd_adapter *adapter)
13225 {
13226         adapter_set_power_state(adapter, ADAPTER_POWER_STATE_OFF_BLOCKED);
13227         return 0;
13228 }
13229
13230 void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
13231                                                         btd_adapter_pin_cb_t cb)
13232 {
13233         adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
13234 }
13235
13236 void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
13237                                                         btd_adapter_pin_cb_t cb)
13238 {
13239         adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
13240 }
13241
13242 void btd_adapter_unregister_msd_cb(struct btd_adapter *adapter,
13243                                                         btd_msd_cb_t cb)
13244 {
13245         adapter->msd_callbacks = g_slist_remove(adapter->msd_callbacks, cb);
13246 }
13247
13248 void btd_adapter_register_msd_cb(struct btd_adapter *adapter,
13249                                                         btd_msd_cb_t cb)
13250 {
13251         adapter->msd_callbacks = g_slist_prepend(adapter->msd_callbacks, cb);
13252 }
13253
13254 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
13255                                                         gboolean enable)
13256 {
13257         if (!btd_adapter_get_powered(adapter))
13258                 return -EINVAL;
13259
13260         set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, enable ? 0x01 : 0x00);
13261
13262         return 0;
13263 }
13264
13265 int btd_adapter_read_clock(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
13266                                 int which, int timeout, uint32_t *clock,
13267                                 uint16_t *accuracy)
13268 {
13269         if (!btd_adapter_get_powered(adapter))
13270                 return -EINVAL;
13271
13272         return -ENOSYS;
13273 }
13274
13275 int btd_adapter_remove_bonding(struct btd_adapter *adapter,
13276                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
13277 {
13278         struct mgmt_cp_unpair_device cp;
13279
13280         memset(&cp, 0, sizeof(cp));
13281         bacpy(&cp.addr.bdaddr, bdaddr);
13282         cp.addr.type = bdaddr_type;
13283         cp.disconnect = 1;
13284
13285         if (mgmt_send(adapter->mgmt, MGMT_OP_UNPAIR_DEVICE,
13286                                 adapter->dev_id, sizeof(cp), &cp,
13287                                 NULL, NULL, NULL) > 0)
13288                 return 0;
13289
13290         return -EIO;
13291 }
13292
13293 static void pincode_reply_complete(uint8_t status, uint16_t length,
13294                                         const void *param, void *user_data)
13295 {
13296         struct btd_device *device = user_data;
13297
13298         /* If the MGMT_OP_PIN_CODE_REPLY command is acknowledged, move the
13299          * starting time to that point. This give a better sense of time
13300          * evaluating the pincode. */
13301         device_bonding_restart_timer(device);
13302 }
13303
13304 int btd_adapter_pincode_reply(struct btd_adapter *adapter,
13305                                         const bdaddr_t *bdaddr,
13306                                         const char *pin, size_t pin_len)
13307 {
13308         struct btd_device *device;
13309         unsigned int id;
13310         char addr[18];
13311
13312         ba2str(bdaddr, addr);
13313         DBG("hci%u addr %s pinlen %zu", adapter->dev_id, addr, pin_len);
13314
13315         if (pin == NULL) {
13316                 struct mgmt_cp_pin_code_neg_reply cp;
13317
13318                 memset(&cp, 0, sizeof(cp));
13319                 bacpy(&cp.addr.bdaddr, bdaddr);
13320                 cp.addr.type = BDADDR_BREDR;
13321
13322                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
13323                                         adapter->dev_id, sizeof(cp), &cp,
13324                                         NULL, NULL, NULL);
13325         } else {
13326                 struct mgmt_cp_pin_code_reply cp;
13327
13328                 if (pin_len > 16)
13329                         return -EINVAL;
13330
13331                 memset(&cp, 0, sizeof(cp));
13332                 bacpy(&cp.addr.bdaddr, bdaddr);
13333                 cp.addr.type = BDADDR_BREDR;
13334                 cp.pin_len = pin_len;
13335                 memcpy(cp.pin_code, pin, pin_len);
13336
13337                 /* Since a pincode was requested, update the starting time to
13338                  * the point where the pincode is provided. */
13339                 device = btd_adapter_find_device(adapter, bdaddr, BDADDR_BREDR);
13340                 device_bonding_restart_timer(device);
13341
13342                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_REPLY,
13343                                         adapter->dev_id, sizeof(cp), &cp,
13344                                         pincode_reply_complete, device, NULL);
13345         }
13346
13347         if (id == 0)
13348                 return -EIO;
13349
13350         return 0;
13351 }
13352
13353 int btd_adapter_confirm_reply(struct btd_adapter *adapter,
13354                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13355                                 gboolean success)
13356 {
13357         struct mgmt_cp_user_confirm_reply cp;
13358         uint16_t opcode;
13359         char addr[18];
13360
13361         ba2str(bdaddr, addr);
13362         DBG("hci%u addr %s success %d", adapter->dev_id, addr, success);
13363
13364         if (success)
13365                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
13366         else
13367                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
13368
13369         memset(&cp, 0, sizeof(cp));
13370         bacpy(&cp.addr.bdaddr, bdaddr);
13371         cp.addr.type = bdaddr_type;
13372
13373         if (mgmt_reply(adapter->mgmt, opcode, adapter->dev_id, sizeof(cp), &cp,
13374                                                         NULL, NULL, NULL) > 0)
13375                 return 0;
13376
13377         return -EIO;
13378 }
13379
13380 static void user_confirm_request_callback(uint16_t index, uint16_t length,
13381                                         const void *param, void *user_data)
13382 {
13383         const struct mgmt_ev_user_confirm_request *ev = param;
13384         struct btd_adapter *adapter = user_data;
13385         struct btd_device *device;
13386         char addr[18];
13387         int err;
13388
13389         if (length < sizeof(*ev)) {
13390                 btd_error(adapter->dev_id,
13391                                 "Too small user confirm request event");
13392                 return;
13393         }
13394
13395         ba2str(&ev->addr.bdaddr, addr);
13396         DBG("hci%u %s confirm_hint %u", adapter->dev_id, addr,
13397                                                         ev->confirm_hint);
13398         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13399                                                                 ev->addr.type);
13400         if (!device) {
13401                 btd_error(adapter->dev_id,
13402                                 "Unable to get device object for %s", addr);
13403                 return;
13404         }
13405
13406 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13407         device_set_auth_addr_type(device, ev->addr.type);
13408 #endif
13409         err = device_confirm_passkey(device, ev->addr.type, btohl(ev->value),
13410                                                         ev->confirm_hint);
13411         if (err < 0) {
13412                 btd_error(adapter->dev_id,
13413                                 "device_confirm_passkey: %s", strerror(-err));
13414                 btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
13415                                                         ev->addr.type, FALSE);
13416         }
13417 }
13418
13419 int btd_adapter_passkey_reply(struct btd_adapter *adapter,
13420                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13421                                 uint32_t passkey)
13422 {
13423         unsigned int id;
13424         char addr[18];
13425
13426         ba2str(bdaddr, addr);
13427         DBG("hci%u addr %s passkey %06u", adapter->dev_id, addr, passkey);
13428
13429         if (passkey == INVALID_PASSKEY) {
13430                 struct mgmt_cp_user_passkey_neg_reply cp;
13431
13432                 memset(&cp, 0, sizeof(cp));
13433                 bacpy(&cp.addr.bdaddr, bdaddr);
13434                 cp.addr.type = bdaddr_type;
13435
13436                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
13437                                         adapter->dev_id, sizeof(cp), &cp,
13438                                         NULL, NULL, NULL);
13439         } else {
13440                 struct mgmt_cp_user_passkey_reply cp;
13441
13442                 memset(&cp, 0, sizeof(cp));
13443                 bacpy(&cp.addr.bdaddr, bdaddr);
13444                 cp.addr.type = bdaddr_type;
13445                 cp.passkey = htobl(passkey);
13446
13447                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_REPLY,
13448                                         adapter->dev_id, sizeof(cp), &cp,
13449                                         NULL, NULL, NULL);
13450         }
13451
13452         if (id == 0)
13453                 return -EIO;
13454
13455         return 0;
13456 }
13457
13458 static void user_passkey_request_callback(uint16_t index, uint16_t length,
13459                                         const void *param, void *user_data)
13460 {
13461         const struct mgmt_ev_user_passkey_request *ev = param;
13462         struct btd_adapter *adapter = user_data;
13463         struct btd_device *device;
13464         char addr[18];
13465         int err;
13466
13467         if (length < sizeof(*ev)) {
13468                 btd_error(adapter->dev_id, "Too small passkey request event");
13469                 return;
13470         }
13471
13472         ba2str(&ev->addr.bdaddr, addr);
13473         DBG("hci%u %s", index, addr);
13474
13475         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13476                                                                 ev->addr.type);
13477         if (!device) {
13478                 btd_error(adapter->dev_id,
13479                                 "Unable to get device object for %s", addr);
13480                 return;
13481         }
13482
13483 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13484         device_set_auth_addr_type(device, ev->addr.type);
13485 #endif
13486         err = device_request_passkey(device, ev->addr.type);
13487         if (err < 0) {
13488                 btd_error(adapter->dev_id,
13489                                 "device_request_passkey: %s", strerror(-err));
13490                 btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
13491                                         ev->addr.type, INVALID_PASSKEY);
13492         }
13493 }
13494
13495 static void user_passkey_notify_callback(uint16_t index, uint16_t length,
13496                                         const void *param, void *user_data)
13497 {
13498         const struct mgmt_ev_passkey_notify *ev = param;
13499         struct btd_adapter *adapter = user_data;
13500         struct btd_device *device;
13501         uint32_t passkey;
13502         char addr[18];
13503         int err;
13504
13505         if (length < sizeof(*ev)) {
13506                 btd_error(adapter->dev_id, "Too small passkey notify event");
13507                 return;
13508         }
13509
13510         ba2str(&ev->addr.bdaddr, addr);
13511         DBG("hci%u %s", index, addr);
13512
13513         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13514                                                                 ev->addr.type);
13515         if (!device) {
13516                 btd_error(adapter->dev_id,
13517                                 "Unable to get device object for %s", addr);
13518                 return;
13519         }
13520
13521         passkey = get_le32(&ev->passkey);
13522
13523         DBG("passkey %06u entered %u", passkey, ev->entered);
13524
13525         err = device_notify_passkey(device, ev->addr.type, passkey,
13526                                                                 ev->entered);
13527         if (err < 0)
13528                 btd_error(adapter->dev_id,
13529                                 "device_notify_passkey: %s", strerror(-err));
13530 }
13531
13532 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13533 static void rssi_alert_callback(uint16_t index, uint16_t length,
13534                                         const void *param, void *user_data)
13535 {
13536         const struct mgmt_ev_vendor_specific_rssi_alert *ev = param;
13537         struct btd_adapter *adapter = user_data;
13538         char addr[18];
13539         char *bt_addr =  NULL;
13540         int link_type = -1;
13541         int alert_type = -1;
13542         int rssi_dbm = 0;
13543
13544         if (length < sizeof(*ev)) {
13545                 error("Too small rssi alert event");
13546                 return;
13547         }
13548
13549         ba2str(&ev->bdaddr, addr);
13550         DBG("hci%u %s %d", index, addr, ev->link_type);
13551         DBG("RSSI Alert Params [%d %d]", ev->alert_type, ev->rssi_dbm);
13552
13553         bt_addr = (char *)&addr;
13554         link_type = ev->link_type;
13555         alert_type = ev->alert_type;
13556         rssi_dbm = ev->rssi_dbm;
13557         g_dbus_emit_signal(dbus_conn, adapter->path,
13558                         ADAPTER_INTERFACE, "RssiAlert",
13559                         DBUS_TYPE_STRING, &bt_addr,
13560                         DBUS_TYPE_INT32, &link_type,
13561                         DBUS_TYPE_INT32, &alert_type,
13562                         DBUS_TYPE_INT32, &rssi_dbm,
13563                         DBUS_TYPE_INVALID);
13564 }
13565
13566 static void get_raw_rssi_callback(uint16_t index, uint16_t length,
13567                                         const void *param, void *user_data)
13568 {
13569         const struct mgmt_cc_rp_get_raw_rssi *ev = param;
13570         struct btd_adapter *adapter = user_data;
13571         char addr[18];
13572         char *bt_addr =  NULL;
13573         int link_type = -1;
13574         int rssi_dbm = 0;
13575
13576         if (length < sizeof(*ev)) {
13577                 error("Too small raw RSSI event");
13578                 return;
13579         }
13580
13581         ba2str(&ev->bt_address, addr);
13582         DBG("hci%u %s", index, addr);
13583         DBG("Raw RSSI Params [%d %d]", ev->link_type, ev->rssi_dbm);
13584
13585         bt_addr = (char *)&addr;
13586         link_type = ev->link_type;
13587         rssi_dbm = ev->rssi_dbm;
13588
13589         g_dbus_emit_signal(dbus_conn, adapter->path,
13590                         ADAPTER_INTERFACE, "RawRssi",
13591                         DBUS_TYPE_STRING, &bt_addr,
13592                         DBUS_TYPE_INT32, &link_type,
13593                         DBUS_TYPE_INT32, &rssi_dbm,
13594                         DBUS_TYPE_INVALID);
13595 }
13596
13597 static void rssi_enabled_callback(uint16_t index, uint16_t length,
13598                                         const void *param, void *user_data)
13599 {
13600         const struct mgmt_cc_rsp_enable_rssi *ev = param;
13601         struct btd_adapter *adapter = user_data;
13602         char addr[18];
13603         char *bt_addr =  NULL;
13604         int enabled = TRUE;
13605         int link_type = -1;
13606
13607         if (length < sizeof(*ev)) {
13608                 error("Too small rssi enabled event");
13609                 return;
13610         }
13611
13612         ba2str(&ev->bt_address, addr);
13613         DBG("hci%u %s %d", index, addr, ev->link_type);
13614         DBG("RSSI Enabled [%d %d]", ev->le_ext_opcode, ev->status);
13615
13616         bt_addr = (char *)&addr;
13617         link_type = ev->link_type;
13618
13619         g_dbus_emit_signal(dbus_conn, adapter->path,
13620                         ADAPTER_INTERFACE, "RssiEnabled",
13621                         DBUS_TYPE_STRING, &bt_addr,
13622                         DBUS_TYPE_INT32, &link_type,
13623                         DBUS_TYPE_BOOLEAN, &enabled,
13624                         DBUS_TYPE_INVALID);
13625 }
13626
13627 static void rssi_disabled_callback(uint16_t index, uint16_t length,
13628                                         const void *param, void *user_data)
13629 {
13630         const struct mgmt_cc_rp_disable_rssi *ev = param;
13631         struct btd_adapter *adapter = user_data;
13632         char addr[18];
13633         char *bt_addr =  NULL;
13634         int disabled = FALSE;
13635         int link_type = -1;
13636
13637         if (length < sizeof(*ev)) {
13638                 error("Too small RSSI disabled event");
13639                 return;
13640         }
13641
13642         ba2str(&ev->bt_address, addr);
13643         DBG("hci%u %s %d", index, addr, ev->link_type);
13644         DBG("RSSI Disabled Params [%d %d]", ev->le_ext_opcode, ev->status);
13645
13646         bt_addr = (char *)&addr;
13647         link_type = ev->link_type;
13648
13649         g_dbus_emit_signal(dbus_conn, adapter->path,
13650                         ADAPTER_INTERFACE, "RssiEnabled",
13651                         DBUS_TYPE_STRING, &bt_addr,
13652                         DBUS_TYPE_INT32, &link_type,
13653                         DBUS_TYPE_BOOLEAN, &disabled,
13654                         DBUS_TYPE_INVALID);
13655 }
13656
13657 void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver)
13658 {
13659         char *ver;
13660
13661         switch (hci_ver) {
13662         case 0:
13663                 ver = "Bluetooth 1.0b";
13664                 break;
13665         case 1:
13666                 ver = "Bluetooth 1.1";
13667                 break;
13668         case 2:
13669                 ver = "Bluetooth 1.2";
13670                 break;
13671         case 3:
13672                 ver = "Bluetooth 2.0 + EDR";
13673                 break;
13674         case 4:
13675                 ver = "Bluetooth 2.1 + EDR";
13676                 break;
13677         case 5:
13678                 ver = "Bluetooth 3.0 + HS";
13679                 break;
13680         case 6:
13681                 ver = "Bluetooth 4.0";
13682                 break;
13683         case 7:
13684                 ver = "Bluetooth 4.1";
13685                 break;
13686         default:
13687                 ver = "Unknown";
13688                 break;
13689         }
13690
13691         if (adapter->version)
13692                 g_free(adapter->version);
13693
13694         adapter->version = g_strdup(ver);
13695 }
13696
13697 static void hardware_error_callback(uint16_t index, uint16_t length,
13698                 const void *param, void *user_data)
13699 {
13700         const struct mgmt_ev_hardware_error *ev = param;
13701         struct btd_adapter *adapter = user_data;
13702
13703         if (length < sizeof(*ev)) {
13704                 error("Too small Hardware error event");
13705                 return;
13706         }
13707
13708         error("Hardware error occurred : %d", ev->error_code);
13709         g_dbus_emit_signal(dbus_conn, adapter->path,
13710                         ADAPTER_INTERFACE, "HardwareError",
13711                         DBUS_TYPE_INVALID);
13712 }
13713
13714 static void tx_timeout_error_callback(uint16_t index, uint16_t length,
13715                 const void *param, void *user_data)
13716 {
13717         struct btd_adapter *adapter = user_data;
13718
13719         error("Tx Timeout error occurred");
13720         g_dbus_emit_signal(dbus_conn, adapter->path,
13721                         ADAPTER_INTERFACE, "TxTimeoutError",
13722                         DBUS_TYPE_INVALID);
13723 }
13724
13725 static void device_name_update_callback(uint16_t index, uint16_t length,
13726                 const void *param, void *user_data)
13727 {
13728         const struct mgmt_ev_device_name_update *ev = param;
13729         struct btd_adapter *adapter = user_data;
13730         struct btd_device *device;
13731         char addr[18];
13732         const uint8_t *eir_name;
13733         struct eir_data eir_data;
13734
13735         if (length < sizeof(*ev)) {
13736                 error("Name update error event");
13737                 return;
13738         }
13739
13740         ba2str(&ev->addr.bdaddr, addr);
13741         DBG("hci%u %s", index, addr);
13742
13743         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13744                                                                 ev->addr.type);
13745         if (!device) {
13746                 error("Unable to get device object for %s", addr);
13747                 return;
13748         }
13749
13750         if (ev->eir_len == 0)
13751                 return;
13752
13753         eir_name = ev->eir;
13754
13755         memset(&eir_data, 0, sizeof(eir_data));
13756         eir_parse(&eir_data, eir_name, ev->eir_len);
13757
13758         if (eir_data.name)
13759                 btd_device_device_set_name(device, eir_data.name);
13760
13761         eir_data_free(&eir_data);
13762 }
13763
13764 struct multi_adv_data {
13765         struct btd_adapter *adapter;
13766         uint8_t slot_id;
13767 };
13768
13769 static gboolean multi_adv_start_timeout_cb(gpointer user_data)
13770 {
13771         struct multi_adv_data *data = user_data;
13772         struct btd_adapter *adapter = data->adapter;
13773         dbus_bool_t err;
13774
13775         adapter->adv_restart_timeout = 0;
13776
13777         err = adapter_le_enable_multi_adv(adapter, TRUE, data->slot_id);
13778         if (!err)
13779                 advertising_state_changed(adapter, data->slot_id, FALSE);
13780
13781         g_free(data);
13782         return FALSE;
13783 }
13784
13785 static void multi_adv_state_change_callback(uint16_t index, uint16_t length,
13786                                         const void *param, void *user_data)
13787 {
13788         const struct mgmt_ev_vendor_specific_multi_adv_state_changed *ev = param;
13789         struct btd_adapter *adapter = user_data;
13790         struct multi_adv_data *data;
13791         struct adv_info *adv;
13792
13793         if (length < sizeof(*ev)) {
13794                 error("Too small adv state change event");
13795                 return;
13796         }
13797
13798         DBG("adv id %d, state change reason %d, connection_handle %x",
13799                 ev->adv_instance, ev->state_change_reason, ev->connection_handle);
13800
13801         adv = find_advertiser(adapter, ev->adv_instance);
13802         DBG("current advertising status %d", adv->status);
13803
13804         if ((ev->adv_instance > 0 && ev->adv_instance < adapter_le_get_max_adv_instance()) &&
13805                         ev->state_change_reason == 0 && adv->status) {
13806                 /* advertising is stopped by controller, it should be enabled again.
13807                 * If fails, state should be changed to FALSE */
13808                 data = g_new0(struct multi_adv_data, 1);
13809                 data->adapter = adapter;
13810                 data->slot_id = ev->adv_instance;
13811
13812                 adapter->adv_restart_instance = ev->adv_instance;
13813                 adapter->adv_restart_timeout =
13814                         g_timeout_add(300, multi_adv_start_timeout_cb, data);
13815         }
13816 }
13817
13818 static void le_conn_update_completed_callback(uint16_t index, uint16_t length,
13819                                         const void *param, void *user_data)
13820 {
13821         const struct mgmt_ev_conn_updated *ev = param;
13822         struct btd_adapter *adapter = user_data;
13823         struct btd_device *device;
13824         char addr[18];
13825         GSList *list = NULL;
13826
13827         if (length < sizeof(*ev)) {
13828                 error("Too small le conn update completed event");
13829                 return;
13830         }
13831
13832         ba2str(&ev->addr.bdaddr, addr);
13833         if (ev->addr.type == BDADDR_LE_PUBLIC) {
13834                 /* Private Random Address */
13835                 list = g_slist_find_custom(adapter->devices, addr,
13836                                                 device_rpa_ida_cmp);
13837                 /* LE Public */
13838                 if (!list)
13839                         list = g_slist_find_custom(adapter->devices, addr,
13840                                                         device_address_cmp);
13841         } else if (ev->addr.type == BDADDR_LE_RANDOM) {
13842                 /* LE Static Random address */
13843                 list = g_slist_find_custom(adapter->devices, addr,
13844                                                         device_address_cmp);
13845         }
13846
13847         if (list) {
13848                 device = list->data;
13849                 device_print_addr(device);
13850
13851                 if (device_get_conn_update_state(device))
13852                         device_set_conn_update_state(device, false);
13853         }
13854 }
13855
13856 static void bt_6lowpan_conn_state_change_callback(uint16_t index, uint16_t length,
13857                                         const void *param, void *user_data)
13858 {
13859         const struct mgmt_ev_6lowpan_conn_state_changed *ev = param;
13860         struct btd_adapter *adapter = user_data;
13861         struct btd_device *device;
13862         char addr[18];
13863         gboolean connected = 0;
13864
13865         if (length < sizeof(*ev)) {
13866                 btd_error(adapter->dev_id,
13867                         "Too small device connected event");
13868                 return;
13869         }
13870
13871         ba2str(&ev->addr.bdaddr, addr);
13872
13873         DBG("hci%u device %s", index, addr);
13874
13875         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13876                                                                 ev->addr.type);
13877         if (!device) {
13878                 btd_error(adapter->dev_id,
13879                         "Unable to get device object for %s", addr);
13880                 return;
13881         }
13882
13883         if (ev->connected)
13884                 connected = TRUE;
13885         else
13886                 connected = FALSE;
13887
13888         device_set_ipsp_connected(device, connected, ev->ifname);
13889 }
13890
13891 static void bt_le_data_length_changed_callback(uint16_t index, uint16_t length,
13892                                         const void *param, void *user_data)
13893 {
13894         const struct mgmt_ev_le_data_length_changed *ev = param;
13895         struct btd_adapter *adapter = user_data;
13896         struct btd_device *device;
13897         char addr[18];
13898
13899         if (length < sizeof(*ev)) {
13900                 btd_error(adapter->dev_id,
13901                         "Too small data length changed event");
13902                 return;
13903         }
13904
13905         ba2str(&ev->addr.bdaddr, addr);
13906
13907         DBG("hci%u device %s", index, addr);
13908
13909         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
13910                                                                 ev->addr.type);
13911         if (!device) {
13912                 btd_error(adapter->dev_id,
13913                         "Unable to get device object for %s", addr);
13914                 return;
13915         }
13916
13917         device_le_data_length_changed(device, ev->max_tx_octets, ev->max_tx_time,
13918                 ev->max_rx_octets, ev->max_rx_time);
13919 }
13920
13921 #endif
13922
13923 struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
13924                                                 struct btd_adapter *adapter)
13925 {
13926         struct btd_adapter_pin_cb_iter *iter =
13927                                 g_new0(struct btd_adapter_pin_cb_iter, 1);
13928
13929         iter->it = adapter->pin_callbacks;
13930         iter->attempt = 1;
13931
13932         return iter;
13933 }
13934
13935 void btd_adapter_pin_cb_iter_free(struct btd_adapter_pin_cb_iter *iter)
13936 {
13937         g_free(iter);
13938 }
13939
13940 bool btd_adapter_pin_cb_iter_end(struct btd_adapter_pin_cb_iter *iter)
13941 {
13942         return iter->it == NULL && iter->attempt == 0;
13943 }
13944
13945 static ssize_t btd_adapter_pin_cb_iter_next(
13946                                         struct btd_adapter_pin_cb_iter *iter,
13947                                         struct btd_adapter *adapter,
13948                                         struct btd_device *device,
13949                                         char *pin_buf, bool *display)
13950 {
13951         btd_adapter_pin_cb_t cb;
13952         ssize_t ret;
13953
13954         while (iter->it != NULL) {
13955                 cb = iter->it->data;
13956                 ret = cb(adapter, device, pin_buf, display, iter->attempt);
13957                 iter->attempt++;
13958                 if (ret > 0)
13959                         return ret;
13960                 iter->attempt = 1;
13961                 iter->it = g_slist_next(iter->it);
13962         }
13963         iter->attempt = 0;
13964
13965         return 0;
13966 }
13967
13968 static void pin_code_request_callback(uint16_t index, uint16_t length,
13969                                         const void *param, void *user_data)
13970 {
13971         const struct mgmt_ev_pin_code_request *ev = param;
13972         struct btd_adapter *adapter = user_data;
13973         struct btd_device *device;
13974         bool display = false;
13975         char pin[17];
13976         ssize_t pinlen;
13977         char addr[18];
13978         int err;
13979         struct btd_adapter_pin_cb_iter *iter;
13980
13981         if (length < sizeof(*ev)) {
13982                 btd_error(adapter->dev_id, "Too small PIN code request event");
13983                 return;
13984         }
13985
13986         ba2str(&ev->addr.bdaddr, addr);
13987
13988         DBG("hci%u %s", adapter->dev_id, addr);
13989
13990         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
13991                                                                 ev->addr.type);
13992         if (!device) {
13993                 btd_error(adapter->dev_id,
13994                                 "Unable to get device object for %s", addr);
13995                 return;
13996         }
13997
13998         /* Flag the request of a pincode to allow a bonding retry. */
13999         adapter->pincode_requested = true;
14000 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14001         btd_device_set_legacy_pairing(device, true);
14002 #endif
14003
14004         memset(pin, 0, sizeof(pin));
14005
14006         iter = device_bonding_iter(device);
14007         if (iter == NULL)
14008                 pinlen = 0;
14009         else
14010                 pinlen = btd_adapter_pin_cb_iter_next(iter, adapter, device,
14011                                                                 pin, &display);
14012
14013         if (pinlen > 0 && (!ev->secure || pinlen == 16)) {
14014                 if (display && device_is_bonding(device, NULL)) {
14015                         err = device_notify_pincode(device, ev->secure, pin);
14016                         if (err < 0) {
14017                                 btd_error(adapter->dev_id,
14018                                                 "device_notify_pin: %s",
14019                                                         strerror(-err));
14020                                 btd_adapter_pincode_reply(adapter,
14021                                                         &ev->addr.bdaddr,
14022                                                         NULL, 0);
14023                         }
14024                 } else {
14025                         btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
14026                                                                 pin, pinlen);
14027                 }
14028                 return;
14029         }
14030
14031 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14032         if (btd_opts.pin_code) {
14033                 /* Because we can't receive user input on headless device,
14034                    no need to request pincode. Use the 'PinCode' in headless conf file */
14035                 DBG("Use configured PinCode in headless device");
14036                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
14037                                 btd_opts.pin_code, strlen(btd_opts.pin_code));
14038                 return;
14039         }
14040 #endif
14041
14042         err = device_request_pincode(device, ev->secure);
14043         if (err < 0) {
14044                 btd_error(adapter->dev_id, "device_request_pin: %s",
14045                                                         strerror(-err));
14046                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
14047         }
14048 }
14049
14050 int adapter_cancel_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14051                                                         uint8_t addr_type)
14052 {
14053         struct mgmt_addr_info cp;
14054         char addr[18];
14055
14056         ba2str(bdaddr, addr);
14057         DBG("hci%u bdaddr %s type %u", adapter->dev_id, addr, addr_type);
14058
14059         memset(&cp, 0, sizeof(cp));
14060         bacpy(&cp.bdaddr, bdaddr);
14061         cp.type = addr_type;
14062
14063         if (mgmt_reply(adapter->mgmt, MGMT_OP_CANCEL_PAIR_DEVICE,
14064                                 adapter->dev_id, sizeof(cp), &cp,
14065                                 NULL, NULL, NULL) > 0)
14066                 return 0;
14067
14068         return -EIO;
14069 }
14070
14071 static void check_oob_bonding_complete(struct btd_adapter *adapter,
14072                                         const bdaddr_t *bdaddr, uint8_t status)
14073 {
14074         if (!adapter->oob_handler || !adapter->oob_handler->bonding_cb)
14075                 return;
14076
14077         if (bacmp(bdaddr, &adapter->oob_handler->remote_addr) != 0)
14078                 return;
14079
14080         adapter->oob_handler->bonding_cb(adapter, bdaddr, status,
14081                                         adapter->oob_handler->user_data);
14082
14083         g_free(adapter->oob_handler);
14084         adapter->oob_handler = NULL;
14085 }
14086
14087 static void bonding_complete(struct btd_adapter *adapter,
14088                                         const bdaddr_t *bdaddr,
14089                                         uint8_t addr_type, uint8_t status)
14090 {
14091         struct btd_device *device;
14092
14093         if (status == 0)
14094                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
14095         else
14096                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
14097
14098         if (device != NULL)
14099                 device_bonding_complete(device, addr_type, status);
14100
14101 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14102         resume_discovery(adapter);
14103 #endif
14104         check_oob_bonding_complete(adapter, bdaddr, status);
14105 }
14106
14107 /* bonding_attempt_complete() handles the end of a "bonding attempt" checking if
14108  * it should begin a new attempt or complete the bonding.
14109  */
14110 static void bonding_attempt_complete(struct btd_adapter *adapter,
14111                                         const bdaddr_t *bdaddr,
14112                                         uint8_t addr_type, uint8_t status)
14113 {
14114         struct btd_device *device;
14115         char addr[18];
14116
14117         ba2str(bdaddr, addr);
14118         DBG("hci%u bdaddr %s type %u status 0x%x", adapter->dev_id, addr,
14119                                                         addr_type, status);
14120
14121         if (status == 0)
14122                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
14123         else
14124                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
14125
14126         if (status == MGMT_STATUS_AUTH_FAILED && adapter->pincode_requested) {
14127                 /* On faliure, issue a bonding_retry if possible. */
14128                 if (device != NULL) {
14129                         if (device_bonding_attempt_retry(device) == 0)
14130                                 return;
14131                 }
14132         }
14133
14134         /* Ignore disconnects during retry. */
14135         if (status == MGMT_STATUS_DISCONNECTED &&
14136                                         device && device_is_retrying(device))
14137                 return;
14138
14139         /* In any other case, finish the bonding. */
14140         bonding_complete(adapter, bdaddr, addr_type, status);
14141 }
14142
14143 struct pair_device_data {
14144         struct btd_adapter *adapter;
14145         bdaddr_t bdaddr;
14146         uint8_t addr_type;
14147 };
14148
14149 static void free_pair_device_data(void *user_data)
14150 {
14151         struct pair_device_data *data = user_data;
14152
14153         g_free(data);
14154 }
14155
14156 static void pair_device_complete(uint8_t status, uint16_t length,
14157                                         const void *param, void *user_data)
14158 {
14159         const struct mgmt_rp_pair_device *rp = param;
14160         struct pair_device_data *data = user_data;
14161         struct btd_adapter *adapter = data->adapter;
14162
14163         DBG("%s (0x%02x)", mgmt_errstr(status), status);
14164
14165         /* Workaround for a kernel bug
14166          *
14167          * Broken kernels may reply to device pairing command with command
14168          * status instead of command complete event e.g. if adapter was not
14169          * powered.
14170          */
14171         if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
14172                 btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
14173                                                 mgmt_errstr(status), status);
14174
14175                 bonding_attempt_complete(adapter, &data->bdaddr,
14176                                                 data->addr_type, status);
14177                 return;
14178         }
14179
14180         if (length < sizeof(*rp)) {
14181                 btd_error(adapter->dev_id, "Too small pair device response");
14182                 return;
14183         }
14184
14185         bonding_attempt_complete(adapter, &rp->addr.bdaddr, rp->addr.type,
14186                                                                         status);
14187 }
14188
14189 int adapter_create_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14190                                         uint8_t addr_type, uint8_t io_cap)
14191 {
14192 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14193         suspend_discovery(adapter);
14194 #endif
14195         return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
14196 }
14197
14198 /* Starts a new bonding attempt in a fresh new bonding_req or a retried one. */
14199 int adapter_bonding_attempt(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
14200                                         uint8_t addr_type, uint8_t io_cap)
14201 {
14202         struct mgmt_cp_pair_device cp;
14203         char addr[18];
14204         struct pair_device_data *data;
14205         unsigned int id;
14206
14207         ba2str(bdaddr, addr);
14208         DBG("hci%u bdaddr %s type %d io_cap 0x%02x",
14209                                 adapter->dev_id, addr, addr_type, io_cap);
14210
14211         /* Reset the pincode_requested flag for a new bonding attempt. */
14212         adapter->pincode_requested = false;
14213
14214         memset(&cp, 0, sizeof(cp));
14215         bacpy(&cp.addr.bdaddr, bdaddr);
14216         cp.addr.type = addr_type;
14217         cp.io_cap = io_cap;
14218
14219         data = g_new0(struct pair_device_data, 1);
14220         data->adapter = adapter;
14221         bacpy(&data->bdaddr, bdaddr);
14222         data->addr_type = addr_type;
14223
14224         /* Due to a bug in the kernel it is possible that a LE pairing
14225          * request never times out. Therefore, add a timer to clean up
14226          * if no response arrives
14227          */
14228         id = mgmt_send_timeout(adapter->mgmt, MGMT_OP_PAIR_DEVICE,
14229                                 adapter->dev_id, sizeof(cp), &cp,
14230                                 pair_device_complete, data,
14231                                 free_pair_device_data, BONDING_TIMEOUT);
14232         if (id == 0) {
14233                 btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
14234                                                         addr, adapter->dev_id);
14235                 free_pair_device_data(data);
14236                 return -EIO;
14237         }
14238
14239         return 0;
14240 }
14241
14242 static void disconnect_notify(struct btd_device *dev, uint8_t reason)
14243 {
14244         GSList *l;
14245
14246         for (l = disconnect_list; l; l = g_slist_next(l)) {
14247                 btd_disconnect_cb disconnect_cb = l->data;
14248                 disconnect_cb(dev, reason);
14249         }
14250 }
14251
14252 static void dev_disconnected(struct btd_adapter *adapter,
14253                                         const struct mgmt_addr_info *addr,
14254                                         uint8_t reason)
14255 {
14256         struct btd_device *device;
14257         char dst[18];
14258 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14259         struct device_addr_type t_addr;
14260 #endif
14261
14262         ba2str(&addr->bdaddr, dst);
14263
14264         DBG("Device %s disconnected, reason %u", dst, reason);
14265
14266         device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
14267
14268 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14269         if (device) {
14270                 device_get_tizen_addr(device, addr->type, &t_addr);
14271
14272                 device_set_disconnect_reason(device, reason);
14273                 adapter_remove_connection(adapter, device, t_addr.bdaddr_type);
14274                 disconnect_notify(device, reason);
14275                 if (device_is_bonded(device, t_addr.bdaddr_type)) {
14276                         DBG("addr type %d, bonded", t_addr.bdaddr_type);
14277                         return;
14278                 }
14279
14280                 bonding_attempt_complete(adapter, &t_addr.bdaddr,
14281                                 t_addr.bdaddr_type, MGMT_STATUS_DISCONNECTED);
14282                 return;
14283         }
14284 #else
14285         if (device) {
14286                 adapter_remove_connection(adapter, device, addr->type);
14287                 disconnect_notify(device, reason);
14288         }
14289 #endif
14290
14291         bonding_attempt_complete(adapter, &addr->bdaddr, addr->type,
14292                                                 MGMT_STATUS_DISCONNECTED);
14293 }
14294
14295 void btd_add_disconnect_cb(btd_disconnect_cb func)
14296 {
14297         disconnect_list = g_slist_append(disconnect_list, func);
14298 }
14299
14300 void btd_remove_disconnect_cb(btd_disconnect_cb func)
14301 {
14302         disconnect_list = g_slist_remove(disconnect_list, func);
14303 }
14304
14305 static void disconnect_complete(uint8_t status, uint16_t length,
14306                                         const void *param, void *user_data)
14307 {
14308         const struct mgmt_rp_disconnect *rp = param;
14309         struct btd_adapter *adapter = user_data;
14310
14311         if (status == MGMT_STATUS_NOT_CONNECTED) {
14312                 btd_warn(adapter->dev_id,
14313                                 "Disconnecting failed: already disconnected");
14314         } else if (status != MGMT_STATUS_SUCCESS) {
14315                 btd_error(adapter->dev_id,
14316                                 "Failed to disconnect device: %s (0x%02x)",
14317                                                 mgmt_errstr(status), status);
14318                 return;
14319         }
14320
14321         if (length < sizeof(*rp)) {
14322                 btd_error(adapter->dev_id,
14323                                 "Too small device disconnect response");
14324                 return;
14325         }
14326
14327 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14328         /* Use HCI error code instead of MGMT disconnection reason */
14329         dev_disconnected(adapter, &rp->addr, 0x16);
14330 #else
14331         dev_disconnected(adapter, &rp->addr, MGMT_DEV_DISCONN_LOCAL_HOST);
14332 #endif
14333 }
14334
14335 int btd_adapter_disconnect_device(struct btd_adapter *adapter,
14336                                                 const bdaddr_t *bdaddr,
14337                                                 uint8_t bdaddr_type)
14338
14339 {
14340         struct mgmt_cp_disconnect cp;
14341
14342         memset(&cp, 0, sizeof(cp));
14343         bacpy(&cp.addr.bdaddr, bdaddr);
14344         cp.addr.type = bdaddr_type;
14345
14346         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT,
14347                                 adapter->dev_id, sizeof(cp), &cp,
14348                                 disconnect_complete, adapter, NULL) > 0)
14349                 return 0;
14350
14351         return -EIO;
14352 }
14353
14354 static void auth_failed_callback(uint16_t index, uint16_t length,
14355                                         const void *param, void *user_data)
14356 {
14357         const struct mgmt_ev_auth_failed *ev = param;
14358         struct btd_adapter *adapter = user_data;
14359
14360         if (length < sizeof(*ev)) {
14361                 btd_error(adapter->dev_id, "Too small auth failed mgmt event");
14362                 return;
14363         }
14364
14365         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
14366                                                                 ev->status);
14367 }
14368
14369 static void store_link_key(struct btd_adapter *adapter,
14370                                 struct btd_device *device, const uint8_t *key,
14371                                 uint8_t type, uint8_t pin_length)
14372 {
14373         char device_addr[18];
14374         char filename[PATH_MAX];
14375         GKeyFile *key_file;
14376         GError *gerr = NULL;
14377         gsize length = 0;
14378         char key_str[33];
14379         char *str;
14380         int i;
14381
14382         ba2str(device_get_address(device), device_addr);
14383
14384         create_filename(filename, PATH_MAX, "/%s/%s/info",
14385                         btd_adapter_get_storage_dir(adapter), device_addr);
14386         create_file(filename, 0600);
14387
14388         key_file = g_key_file_new();
14389         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14390                 error("Unable to load key file from %s: (%s)", filename,
14391                                                                 gerr->message);
14392                 g_error_free(gerr);
14393                 g_key_file_free(key_file);
14394                 return;
14395         }
14396
14397         for (i = 0; i < 16; i++)
14398                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14399
14400         g_key_file_set_string(key_file, "LinkKey", "Key", key_str);
14401
14402         g_key_file_set_integer(key_file, "LinkKey", "Type", type);
14403         g_key_file_set_integer(key_file, "LinkKey", "PINLength", pin_length);
14404
14405         str = g_key_file_to_data(key_file, &length, NULL);
14406         if (!g_file_set_contents(filename, str, length, &gerr)) {
14407                 error("Unable set contents for %s: (%s)", filename,
14408                                                                 gerr->message);
14409                 g_error_free(gerr);
14410         }
14411         g_free(str);
14412
14413         g_key_file_free(key_file);
14414 }
14415
14416 static void new_link_key_callback(uint16_t index, uint16_t length,
14417                                         const void *param, void *user_data)
14418 {
14419         const struct mgmt_ev_new_link_key *ev = param;
14420         const struct mgmt_addr_info *addr = &ev->key.addr;
14421         struct btd_adapter *adapter = user_data;
14422         struct btd_device *device;
14423         char dst[18];
14424
14425         if (length < sizeof(*ev)) {
14426                 btd_error(adapter->dev_id, "Too small new link key event");
14427                 return;
14428         }
14429
14430         ba2str(&addr->bdaddr, dst);
14431
14432         DBG("hci%u new key for %s type %u pin_len %u store_hint %u",
14433                 adapter->dev_id, dst, ev->key.type, ev->key.pin_len,
14434                 ev->store_hint);
14435
14436         if (ev->key.pin_len > 16) {
14437                 btd_error(adapter->dev_id,
14438                                 "Invalid PIN length (%u) in new_key event",
14439                                                         ev->key.pin_len);
14440                 return;
14441         }
14442
14443         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14444         if (!device) {
14445                 btd_error(adapter->dev_id,
14446                                 "Unable to get device object for %s", dst);
14447                 return;
14448         }
14449
14450         if (ev->store_hint) {
14451                 const struct mgmt_link_key_info *key = &ev->key;
14452
14453                 store_link_key(adapter, device, key->val, key->type,
14454                                                                 key->pin_len);
14455
14456                 device_set_bonded(device, BDADDR_BREDR);
14457 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14458         } else {
14459                 if (btd_adapter_get_a2dp_role(adapter) & BLUETOOTH_A2DP_SINK_ROLE) {
14460                         DBG("store_hint %d", ev->store_hint);
14461                         btd_device_set_temporary(device, false);
14462                 }
14463 #endif
14464         }
14465
14466         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14467 }
14468
14469 static void store_ltk_group(struct btd_adapter *adapter, const bdaddr_t *peer,
14470                                 uint8_t bdaddr_type, const unsigned char *key,
14471                                 const char *group, uint8_t authenticated,
14472                                 uint8_t enc_size, uint16_t ediv,
14473                                 uint64_t rand)
14474 {
14475         char device_addr[18];
14476         char filename[PATH_MAX];
14477         GKeyFile *key_file;
14478         GError *gerr = NULL;
14479         char key_str[33];
14480         gsize length = 0;
14481         char *str;
14482         int i;
14483
14484         ba2str(peer, device_addr);
14485
14486         create_filename(filename, PATH_MAX, "/%s/%s/info",
14487                         btd_adapter_get_storage_dir(adapter), device_addr);
14488         create_file(filename, 0600);
14489
14490         key_file = g_key_file_new();
14491         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14492                 error("Unable to load key file from %s: (%s)", filename,
14493                                                                 gerr->message);
14494                 g_error_free(gerr);
14495                 g_key_file_free(key_file);
14496                 return;
14497         }
14498
14499         for (i = 0; i < 16; i++)
14500                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14501
14502         g_key_file_set_string(key_file, group, "Key", key_str);
14503
14504         g_key_file_set_integer(key_file, group, "Authenticated",
14505                         authenticated);
14506         g_key_file_set_integer(key_file, group, "EncSize", enc_size);
14507
14508         g_key_file_set_integer(key_file, group, "EDiv", ediv);
14509         g_key_file_set_uint64(key_file, group, "Rand", rand);
14510
14511         create_file(filename, 0600);
14512
14513         str = g_key_file_to_data(key_file, &length, NULL);
14514         if (!g_file_set_contents(filename, str, length, &gerr)) {
14515                 error("Unable set contents for %s: (%s)", filename,
14516                                                                 gerr->message);
14517                 g_error_free(gerr);
14518         }
14519         g_free(str);
14520
14521         g_key_file_free(key_file);
14522 }
14523
14524 static void store_longtermkey(struct btd_adapter *adapter, const bdaddr_t *peer,
14525                                 uint8_t bdaddr_type, const unsigned char *key,
14526                                 uint8_t central, uint8_t authenticated,
14527                                 uint8_t enc_size, uint16_t ediv,
14528                                 uint64_t rand)
14529 {
14530         if (central != 0x00 && central != 0x01) {
14531                 error("Unsupported LTK type %u", central);
14532                 return;
14533         }
14534
14535         if (central) {
14536                 store_ltk_group(adapter, peer, bdaddr_type, key, "LongTermKey",
14537                                 authenticated, enc_size, ediv, rand);
14538         } else {
14539                 /* Peripheral* is the proper term, but for now keep duplicates
14540                  * so it won't break when user up/downgrades. Remove the other
14541                  * term after a few releases.
14542                  */
14543                 store_ltk_group(adapter, peer, bdaddr_type, key,
14544                                 "PeripheralLongTermKey", authenticated,
14545                                 enc_size, ediv, rand);
14546                 store_ltk_group(adapter, peer, bdaddr_type, key,
14547                                 "SlaveLongTermKey", authenticated,
14548                                 enc_size, ediv, rand);
14549         }
14550 }
14551
14552 static void new_long_term_key_callback(uint16_t index, uint16_t length,
14553                                         const void *param, void *user_data)
14554 {
14555         const struct mgmt_ev_new_long_term_key *ev = param;
14556         const struct mgmt_addr_info *addr = &ev->key.addr;
14557         struct btd_adapter *adapter = user_data;
14558         struct btd_device *device;
14559         bool persistent;
14560         char dst[18];
14561 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14562         struct device_addr_type t_addr;
14563 #endif
14564
14565         if (length < sizeof(*ev)) {
14566                 btd_error(adapter->dev_id, "Too small long term key event");
14567                 return;
14568         }
14569
14570         ba2str(&addr->bdaddr, dst);
14571
14572         DBG("hci%u new LTK for %s type %u enc_size %u",
14573                 adapter->dev_id, dst, ev->key.type, ev->key.enc_size);
14574
14575         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14576         if (!device) {
14577                 btd_error(adapter->dev_id,
14578                                 "Unable to get device object for %s", dst);
14579                 return;
14580         }
14581
14582         /*
14583          * Some older kernel versions set store_hint for long term keys
14584          * from resolvable and unresolvable random addresses, but there
14585          * is no point in storing these. Next time around the device
14586          * address will be invalid.
14587          *
14588          * So only for identity addresses (public and static random) use
14589          * the store_hint as an indication if the long term key should
14590          * be persistently stored.
14591          *
14592          */
14593         if (addr->type == BDADDR_LE_RANDOM &&
14594                                 (addr->bdaddr.b[5] & 0xc0) != 0xc0)
14595                 persistent = false;
14596         else
14597                 persistent = !!ev->store_hint;
14598
14599         if (persistent) {
14600                 const struct mgmt_ltk_info *key = &ev->key;
14601                 uint16_t ediv;
14602                 uint64_t rand;
14603
14604                 ediv = le16_to_cpu(key->ediv);
14605                 rand = le64_to_cpu(key->rand);
14606
14607 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14608                 device_get_tizen_addr(device, addr->type, &t_addr);
14609                 store_longtermkey(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14610                                         key->val, key->central, key->type,
14611                                         key->enc_size, ediv, rand);
14612 #else
14613                 store_longtermkey(adapter, &key->addr.bdaddr,
14614                                         key->addr.type, key->val, key->central,
14615                                         key->type, key->enc_size, ediv, rand);
14616 #endif
14617
14618                 device_set_bonded(device, addr->type);
14619         }
14620
14621         device_set_ltk(device, ev->key.val, ev->key.central, ev->key.enc_size);
14622
14623         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
14624 }
14625
14626 static void store_csrk(struct btd_adapter *adapter, const bdaddr_t *peer,
14627                                 uint8_t bdaddr_type, const unsigned char *key,
14628                                 uint32_t counter, uint8_t type)
14629 {
14630         const char *group;
14631         char device_addr[18];
14632         char filename[PATH_MAX];
14633         GKeyFile *key_file;
14634         GError *gerr = NULL;
14635         char key_str[33];
14636         gsize length = 0;
14637         gboolean auth;
14638         char *str;
14639         int i;
14640
14641         switch (type) {
14642         case 0x00:
14643                 group = "LocalSignatureKey";
14644                 auth = FALSE;
14645                 break;
14646         case 0x01:
14647                 group = "RemoteSignatureKey";
14648                 auth = FALSE;
14649                 break;
14650         case 0x02:
14651                 group = "LocalSignatureKey";
14652                 auth = TRUE;
14653                 break;
14654         case 0x03:
14655                 group = "RemoteSignatureKey";
14656                 auth = TRUE;
14657                 break;
14658         default:
14659                 warn("Unsupported CSRK type %u", type);
14660                 return;
14661         }
14662
14663         ba2str(peer, device_addr);
14664
14665         create_filename(filename, PATH_MAX, "/%s/%s/info",
14666                         btd_adapter_get_storage_dir(adapter), device_addr);
14667
14668         key_file = g_key_file_new();
14669         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14670                 error("Unable to load key file from %s: (%s)", filename,
14671                                                                 gerr->message);
14672                 g_clear_error(&gerr);
14673         }
14674
14675         for (i = 0; i < 16; i++)
14676                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
14677
14678         g_key_file_set_string(key_file, group, "Key", key_str);
14679         g_key_file_set_integer(key_file, group, "Counter", counter);
14680         g_key_file_set_boolean(key_file, group, "Authenticated", auth);
14681
14682         create_file(filename, 0600);
14683
14684         str = g_key_file_to_data(key_file, &length, NULL);
14685         if (!g_file_set_contents(filename, str, length, &gerr)) {
14686                 error("Unable set contents for %s: (%s)", filename,
14687                                                                 gerr->message);
14688                 g_error_free(gerr);
14689         }
14690         g_free(str);
14691
14692         g_key_file_free(key_file);
14693 }
14694
14695 static void new_csrk_callback(uint16_t index, uint16_t length,
14696                                         const void *param, void *user_data)
14697 {
14698         const struct mgmt_ev_new_csrk *ev = param;
14699         const struct mgmt_addr_info *addr = &ev->key.addr;
14700         const struct mgmt_csrk_info *key = &ev->key;
14701         struct btd_adapter *adapter = user_data;
14702         struct btd_device *device;
14703         char dst[18];
14704 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14705         struct device_addr_type t_addr;
14706 #endif
14707
14708         if (length < sizeof(*ev)) {
14709                 btd_error(adapter->dev_id, "Too small CSRK event");
14710                 return;
14711         }
14712
14713         ba2str(&addr->bdaddr, dst);
14714
14715         DBG("hci%u new CSRK for %s type %u", adapter->dev_id, dst,
14716                                                                 ev->key.type);
14717
14718         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
14719         if (!device) {
14720                 btd_error(adapter->dev_id,
14721                                 "Unable to get device object for %s", dst);
14722                 return;
14723         }
14724
14725         if (!ev->store_hint)
14726                 return;
14727
14728 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14729         device_get_tizen_addr(device, addr->type, &t_addr);
14730         store_csrk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, key->val, 0,
14731                                                                 key->type);
14732 #else
14733         store_csrk(adapter, &key->addr.bdaddr, key->addr.type, key->val, 0,
14734                                                                 key->type);
14735 #endif
14736
14737         btd_device_set_temporary(device, false);
14738 }
14739
14740 static void store_irk(struct btd_adapter *adapter, const bdaddr_t *peer,
14741                                 uint8_t bdaddr_type, const unsigned char *key)
14742 {
14743         char device_addr[18];
14744         char filename[PATH_MAX];
14745         GKeyFile *key_file;
14746         GError *gerr = NULL;
14747         char *store_data;
14748         char str[33];
14749         size_t length = 0;
14750         int i;
14751
14752         ba2str(peer, device_addr);
14753
14754         create_filename(filename, PATH_MAX, "/%s/%s/info",
14755                         btd_adapter_get_storage_dir(adapter), device_addr);
14756         key_file = g_key_file_new();
14757         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14758                 error("Unable to load key file from %s: (%s)", filename,
14759                                                                 gerr->message);
14760                 g_clear_error(&gerr);
14761         }
14762
14763         for (i = 0; i < 16; i++)
14764                 sprintf(str + (i * 2), "%2.2X", key[i]);
14765
14766         g_key_file_set_string(key_file, "IdentityResolvingKey", "Key", str);
14767
14768         store_data = g_key_file_to_data(key_file, &length, NULL);
14769         if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14770                 error("Unable set contents for %s: (%s)", filename,
14771                                                                 gerr->message);
14772                 g_error_free(gerr);
14773         }
14774         g_free(store_data);
14775
14776         g_key_file_free(key_file);
14777 }
14778
14779 static void new_irk_callback(uint16_t index, uint16_t length,
14780                                         const void *param, void *user_data)
14781 {
14782         const struct mgmt_ev_new_irk *ev = param;
14783         const struct mgmt_addr_info *addr = &ev->key.addr;
14784         const struct mgmt_irk_info *irk = &ev->key;
14785         struct btd_adapter *adapter = user_data;
14786         struct btd_device *device, *duplicate;
14787         bool persistent;
14788         char dst[18], rpa[18];
14789 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14790         struct device_addr_type t_addr;
14791 #endif
14792
14793         if (length < sizeof(*ev)) {
14794                 btd_error(adapter->dev_id, "Too small New IRK event");
14795                 return;
14796         }
14797
14798         ba2str(&addr->bdaddr, dst);
14799         ba2str(&ev->rpa, rpa);
14800
14801         DBG("hci%u new IRK for %s RPA %s", adapter->dev_id, dst, rpa);
14802
14803         if (bacmp(&ev->rpa, BDADDR_ANY)) {
14804                 device = btd_adapter_get_device(adapter, &ev->rpa,
14805                                 BDADDR_LE_RANDOM);
14806 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14807                 device = btd_adapter_get_device(adapter, &ev->rpa,
14808                                                         BDADDR_LE_RANDOM);
14809                 duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
14810                                                                 addr->type);
14811                 if (duplicate == device)
14812                         duplicate = NULL;
14813 #else
14814                 device_set_rpa_addr(device, &ev->rpa);
14815                 duplicate = NULL;
14816 #endif
14817         } else {
14818                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
14819                                                                 addr->type);
14820                 duplicate = NULL;
14821         }
14822
14823         if (!device) {
14824                 btd_error(adapter->dev_id,
14825                                 "Unable to get device object for %s", dst);
14826                 return;
14827         }
14828
14829         device_update_addr(device, &addr->bdaddr, addr->type);
14830
14831         if (duplicate)
14832                 device_merge_duplicate(device, duplicate);
14833
14834 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14835         device_set_irk_value(device, irk->val);
14836 #endif
14837
14838         persistent = !!ev->store_hint;
14839         if (!persistent)
14840                 return;
14841
14842 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14843         device_get_tizen_addr(device, addr->type, &t_addr);
14844         store_irk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, irk->val);
14845 #else
14846         store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
14847 #endif
14848
14849         btd_device_set_temporary(device, false);
14850 }
14851
14852 static void store_conn_param(struct btd_adapter *adapter, const bdaddr_t *peer,
14853                                 uint8_t bdaddr_type, uint16_t min_interval,
14854                                 uint16_t max_interval, uint16_t latency,
14855                                 uint16_t timeout)
14856 {
14857         char device_addr[18];
14858         char filename[PATH_MAX];
14859         GKeyFile *key_file;
14860         GError *gerr = NULL;
14861         char *store_data;
14862         size_t length = 0;
14863
14864         ba2str(peer, device_addr);
14865
14866         DBG("");
14867
14868         create_filename(filename, PATH_MAX, "/%s/%s/info",
14869                         btd_adapter_get_storage_dir(adapter), device_addr);
14870         key_file = g_key_file_new();
14871         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
14872                 error("Unable to load key file from %s: (%s)", filename,
14873                                                                 gerr->message);
14874                 g_clear_error(&gerr);
14875         }
14876
14877         g_key_file_set_integer(key_file, "ConnectionParameters",
14878                                                 "MinInterval", min_interval);
14879         g_key_file_set_integer(key_file, "ConnectionParameters",
14880                                                 "MaxInterval", max_interval);
14881         g_key_file_set_integer(key_file, "ConnectionParameters",
14882                                                 "Latency", latency);
14883         g_key_file_set_integer(key_file, "ConnectionParameters",
14884                                                 "Timeout", timeout);
14885
14886         create_file(filename, 0600);
14887
14888         store_data = g_key_file_to_data(key_file, &length, NULL);
14889         if (!g_file_set_contents(filename, store_data, length, &gerr)) {
14890                 error("Unable set contents for %s: (%s)", filename,
14891                                                                 gerr->message);
14892                 g_error_free(gerr);
14893         }
14894         g_free(store_data);
14895
14896         g_key_file_free(key_file);
14897 }
14898
14899 static void new_conn_param(uint16_t index, uint16_t length,
14900                                         const void *param, void *user_data)
14901 {
14902         const struct mgmt_ev_new_conn_param *ev = param;
14903         struct btd_adapter *adapter = user_data;
14904         uint16_t min, max, latency, timeout;
14905         struct btd_device *dev;
14906         char dst[18];
14907 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14908         struct device_addr_type t_addr;
14909 #endif
14910
14911         if (length < sizeof(*ev)) {
14912                 btd_error(adapter->dev_id,
14913                                 "Too small New Connection Parameter event");
14914                 return;
14915         }
14916
14917         ba2str(&ev->addr.bdaddr, dst);
14918
14919         min = btohs(ev->min_interval);
14920         max = btohs(ev->max_interval);
14921         latency = btohs(ev->latency);
14922         timeout = btohs(ev->timeout);
14923
14924         DBG("hci%u %s (%u) min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
14925                 adapter->dev_id, dst, ev->addr.type, min, max, latency, timeout);
14926
14927         dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
14928         if (!dev) {
14929                 btd_error(adapter->dev_id,
14930                                 "Unable to get device object for %s", dst);
14931                 return;
14932         }
14933
14934         if (!ev->store_hint)
14935                 return;
14936
14937 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14938         device_get_tizen_addr(dev, ev->addr.type, &t_addr);
14939         store_conn_param(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
14940                                         ev->min_interval, ev->max_interval,
14941                                         ev->latency, ev->timeout);
14942 #else
14943         store_conn_param(adapter, &ev->addr.bdaddr, ev->addr.type,
14944                                         ev->min_interval, ev->max_interval,
14945                                         ev->latency, ev->timeout);
14946 #endif
14947 }
14948
14949 int adapter_set_io_capability(struct btd_adapter *adapter, uint8_t io_cap)
14950 {
14951         struct mgmt_cp_set_io_capability cp;
14952
14953         if (!btd_opts.pairable) {
14954                 if (io_cap == IO_CAPABILITY_INVALID) {
14955                         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
14956                                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
14957
14958                         return 0;
14959                 }
14960
14961                 if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
14962                         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
14963         } else if (io_cap == IO_CAPABILITY_INVALID)
14964                 io_cap = IO_CAPABILITY_NOINPUTNOOUTPUT;
14965
14966         memset(&cp, 0, sizeof(cp));
14967         cp.io_capability = io_cap;
14968
14969         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IO_CAPABILITY,
14970                                 adapter->dev_id, sizeof(cp), &cp,
14971                                 NULL, NULL, NULL) > 0)
14972                 return 0;
14973
14974         return -EIO;
14975 }
14976
14977 int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
14978                                         const bdaddr_t *bdaddr,
14979                                         uint8_t *hash, uint8_t *randomizer)
14980 {
14981         struct mgmt_cp_add_remote_oob_data cp;
14982         char addr[18];
14983
14984         ba2str(bdaddr, addr);
14985         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
14986
14987         memset(&cp, 0, sizeof(cp));
14988         bacpy(&cp.addr.bdaddr, bdaddr);
14989         memcpy(cp.hash192, hash, 16);
14990
14991         if (randomizer)
14992                 memcpy(cp.rand192, randomizer, 16);
14993
14994         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
14995                                 adapter->dev_id, sizeof(cp), &cp,
14996                                 NULL, NULL, NULL) > 0)
14997                 return 0;
14998
14999         return -EIO;
15000 }
15001
15002 int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
15003                                                         const bdaddr_t *bdaddr)
15004 {
15005         struct mgmt_cp_remove_remote_oob_data cp;
15006         char addr[18];
15007
15008         ba2str(bdaddr, addr);
15009         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
15010
15011         memset(&cp, 0, sizeof(cp));
15012         bacpy(&cp.addr.bdaddr, bdaddr);
15013
15014         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
15015                                 adapter->dev_id, sizeof(cp), &cp,
15016                                 NULL, NULL, NULL) > 0)
15017                 return 0;
15018
15019         return -EIO;
15020 }
15021
15022 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15023 int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
15024                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
15025                                 uint8_t *hash192, uint8_t *randomizer192,
15026                                 uint8_t *hash256, uint8_t *randomizer256)
15027 {
15028         struct mgmt_cp_add_remote_oob_data cp;
15029         char addr[18];
15030
15031         ba2str(bdaddr, addr);
15032         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
15033
15034         memset(&cp, 0, sizeof(cp));
15035         bacpy(&cp.addr.bdaddr, bdaddr);
15036         cp.addr.type = bdaddr_type;
15037
15038         if (hash192 && randomizer192) {
15039                 memcpy(cp.hash192, hash192, 16);
15040                 memcpy(cp.rand192, randomizer192, 16);
15041         }
15042
15043         if (hash256 && randomizer256) {
15044                 memcpy(cp.hash256, hash256, 16);
15045                 memcpy(cp.rand256, randomizer256, 16);
15046         }
15047
15048         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
15049                                 adapter->dev_id, sizeof(cp), &cp,
15050                                 NULL, NULL, NULL) > 0)
15051                 return 0;
15052
15053         return -EIO;
15054 }
15055
15056 int btd_adapter_remove_remote_oob_ext_data(struct btd_adapter *adapter,
15057                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
15058 {
15059         struct mgmt_cp_remove_remote_oob_data cp;
15060         char addr[18];
15061
15062         ba2str(bdaddr, addr);
15063         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
15064
15065         memset(&cp, 0, sizeof(cp));
15066         bacpy(&cp.addr.bdaddr, bdaddr);
15067         cp.addr.type = bdaddr_type;
15068
15069         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
15070                                 adapter->dev_id, sizeof(cp), &cp,
15071                                 NULL, NULL, NULL) > 0)
15072                 return 0;
15073
15074         return -EIO;
15075 }
15076 #endif
15077
15078 bool btd_adapter_ssp_enabled(struct btd_adapter *adapter)
15079 {
15080         if (adapter->current_settings & MGMT_SETTING_SSP)
15081                 return true;
15082
15083         return false;
15084 }
15085
15086 void btd_adapter_set_oob_handler(struct btd_adapter *adapter,
15087                                                 struct oob_handler *handler)
15088 {
15089         adapter->oob_handler = handler;
15090 }
15091
15092 gboolean btd_adapter_check_oob_handler(struct btd_adapter *adapter)
15093 {
15094         return adapter->oob_handler != NULL;
15095 }
15096
15097 static void read_local_oob_data_complete(uint8_t status, uint16_t length,
15098                                         const void *param, void *user_data)
15099 {
15100         const struct mgmt_rp_read_local_oob_data *rp = param;
15101         struct btd_adapter *adapter = user_data;
15102         const uint8_t *hash, *randomizer;
15103 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15104         const uint8_t *hash256 = NULL;
15105         const uint8_t *randomizer256 = NULL;
15106 #endif
15107
15108         if (status != MGMT_STATUS_SUCCESS) {
15109                 btd_error(adapter->dev_id,
15110                                 "Read local OOB data failed: %s (0x%02x)",
15111                                                 mgmt_errstr(status), status);
15112                 hash = NULL;
15113                 randomizer = NULL;
15114 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15115         } else if (length < 32) {
15116 #else
15117         } else if (length < sizeof(*rp)) {
15118 #endif
15119                 btd_error(adapter->dev_id,
15120                                 "Too small read local OOB data response");
15121                 return;
15122         } else {
15123                 hash = rp->hash192;
15124                 randomizer = rp->rand192;
15125 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15126                 if (length > 32) {
15127                         hash256 = rp->hash256;
15128                         randomizer256 = rp->rand256;
15129                 }
15130 #endif
15131         }
15132
15133         if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
15134                 return;
15135
15136 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15137         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
15138                                         hash256, randomizer256,
15139                                         adapter->oob_handler->user_data);
15140 #else
15141         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
15142                                         adapter->oob_handler->user_data);
15143 #endif
15144
15145         g_free(adapter->oob_handler);
15146         adapter->oob_handler = NULL;
15147 }
15148
15149 int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
15150 {
15151         DBG("hci%u", adapter->dev_id);
15152
15153         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_DATA,
15154                         adapter->dev_id, 0, NULL, read_local_oob_data_complete,
15155                         adapter, NULL) > 0)
15156                 return 0;
15157
15158         return -EIO;
15159 }
15160
15161 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15162 static void le_read_local_oob_data_complete(uint8_t status, uint16_t length,
15163                                         const void *param, void *user_data)
15164 {
15165         const struct mgmt_rp_read_local_oob_ext_data *rp = param;
15166         struct btd_adapter *adapter = user_data;
15167
15168         if (status != MGMT_STATUS_SUCCESS) {
15169                 btd_error(adapter->dev_id, "LE Read local OOB data failed: %s (0x%02x)",
15170                                                 mgmt_errstr(status), status);
15171         } else if (length < sizeof(struct mgmt_rp_read_local_oob_ext_data)) {
15172                 btd_error(adapter->dev_id,
15173                                 "Too small read local OOB ext data response");
15174                 return;
15175         }
15176
15177         if (!adapter->oob_handler || !adapter->oob_handler->le_read_local_cb) {
15178                 btd_error(adapter->dev_id, "oob_handler is not valid : %p",
15179                                 adapter->oob_handler);
15180                 return;
15181         }
15182
15183         adapter->oob_handler->le_read_local_cb(adapter, rp->eir_len, rp->eir,
15184                         adapter->oob_handler->user_data);
15185
15186         g_free(adapter->oob_handler);
15187         adapter->oob_handler = NULL;
15188 }
15189
15190 int btd_adapter_le_read_local_oob_data(struct btd_adapter *adapter)
15191 {
15192         struct mgmt_cp_read_local_oob_ext_data cp;
15193
15194         DBG("hci%u", adapter->dev_id);
15195
15196         memset(&cp, 0, sizeof(cp));
15197         cp.type = (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
15198
15199         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
15200                         adapter->dev_id, sizeof(cp), &cp, le_read_local_oob_data_complete,
15201                         adapter, NULL) > 0)
15202                 return 0;
15203
15204         return -EIO;
15205 }
15206 #endif
15207
15208 void btd_adapter_for_each_device(struct btd_adapter *adapter,
15209                         void (*cb)(struct btd_device *device, void *data),
15210                         void *data)
15211 {
15212         g_slist_foreach(adapter->devices, (GFunc) cb, data);
15213 }
15214
15215 static int adapter_cmp(gconstpointer a, gconstpointer b)
15216 {
15217         struct btd_adapter *adapter = (struct btd_adapter *) a;
15218         const bdaddr_t *bdaddr = b;
15219
15220         return bacmp(&adapter->bdaddr, bdaddr);
15221 }
15222
15223 static int adapter_id_cmp(gconstpointer a, gconstpointer b)
15224 {
15225         struct btd_adapter *adapter = (struct btd_adapter *) a;
15226         uint16_t id = GPOINTER_TO_UINT(b);
15227
15228         return adapter->dev_id == id ? 0 : -1;
15229 }
15230
15231 struct btd_adapter *adapter_find(const bdaddr_t *sba)
15232 {
15233         GSList *match;
15234
15235         match = g_slist_find_custom(adapters, sba, adapter_cmp);
15236         if (!match)
15237                 return NULL;
15238
15239         return match->data;
15240 }
15241
15242 struct btd_adapter *adapter_find_by_id(int id)
15243 {
15244         GSList *match;
15245
15246         match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
15247                                                         adapter_id_cmp);
15248         if (!match)
15249                 return NULL;
15250
15251         return match->data;
15252 }
15253
15254 void adapter_foreach(adapter_cb func, gpointer user_data)
15255 {
15256         g_slist_foreach(adapters, (GFunc) func, user_data);
15257 }
15258
15259 static int set_did(struct btd_adapter *adapter, uint16_t vendor,
15260                         uint16_t product, uint16_t version, uint16_t source)
15261 {
15262         struct mgmt_cp_set_device_id cp;
15263
15264         DBG("hci%u source %x vendor %x product %x version %x",
15265                         adapter->dev_id, source, vendor, product, version);
15266
15267         memset(&cp, 0, sizeof(cp));
15268
15269         cp.source = htobs(source);
15270         cp.vendor = htobs(vendor);
15271         cp.product = htobs(product);
15272         cp.version = htobs(version);
15273
15274         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_ID,
15275                                 adapter->dev_id, sizeof(cp), &cp,
15276                                 NULL, NULL, NULL) > 0)
15277                 return 0;
15278
15279         return -EIO;
15280 }
15281
15282 static void services_modified(struct gatt_db_attribute *attrib, void *user_data)
15283 {
15284         struct btd_adapter *adapter = user_data;
15285
15286         g_dbus_emit_property_changed(dbus_conn, adapter->path,
15287                                                 ADAPTER_INTERFACE, "UUIDs");
15288 }
15289
15290 static int adapter_register(struct btd_adapter *adapter)
15291 {
15292         struct agent *agent;
15293         struct gatt_db *db;
15294 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15295         char address[18] = { 0 };
15296         char filename[PATH_MAX] = { 0 };
15297 #endif
15298
15299         if (powering_down)
15300                 return -EBUSY;
15301
15302         adapter->path = g_strdup_printf("/org/bluez/hci%d", adapter->dev_id);
15303
15304         if (!g_dbus_register_interface(dbus_conn,
15305                                         adapter->path, ADAPTER_INTERFACE,
15306 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15307                                         adapter_methods, adapter_signals,
15308 #else
15309                                         adapter_methods, NULL,
15310 #endif
15311                                         adapter_properties, adapter,
15312                                         adapter_free)) {
15313                 btd_error(adapter->dev_id,
15314                                 "Adapter interface init failed on path %s",
15315                                                         adapter->path);
15316                 g_free(adapter->path);
15317                 adapter->path = NULL;
15318                 return -EINVAL;
15319         }
15320
15321         if (adapters == NULL)
15322                 adapter->is_default = true;
15323
15324         adapters = g_slist_append(adapters, adapter);
15325
15326         agent = agent_get(NULL);
15327         if (agent) {
15328                 uint8_t io_cap = agent_get_io_capability(agent);
15329                 adapter_set_io_capability(adapter, io_cap);
15330                 agent_unref(agent);
15331         }
15332
15333         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15334                 adapter->battery_provider_manager =
15335                         btd_battery_provider_manager_create(adapter);
15336         }
15337
15338         /* Don't start GATT database and advertising managers on
15339          * non-LE controllers.
15340          */
15341         if (!(adapter->supported_settings & MGMT_SETTING_LE) ||
15342                                         btd_opts.mode == BT_MODE_BREDR)
15343                 goto load;
15344
15345         adapter->database = btd_gatt_database_new(adapter);
15346         if (!adapter->database) {
15347                 btd_error(adapter->dev_id,
15348                                 "Failed to create GATT database for adapter");
15349                 adapters = g_slist_remove(adapters, adapter);
15350                 return -EINVAL;
15351         }
15352
15353         adapter->adv_manager = btd_adv_manager_new(adapter, adapter->mgmt);
15354
15355         if (g_dbus_get_flags() & G_DBUS_FLAG_ENABLE_EXPERIMENTAL) {
15356                 if (adapter->supported_settings & MGMT_SETTING_LE) {
15357                         adapter->adv_monitor_manager =
15358                                 btd_adv_monitor_manager_create(adapter,
15359                                                                 adapter->mgmt);
15360                         if (!adapter->adv_monitor_manager) {
15361                                 btd_error(adapter->dev_id,
15362                                                 "Failed to create Adv Monitor "
15363                                                 "Manager for adapter");
15364                                 return -EINVAL;
15365                         }
15366                 } else {
15367                         btd_info(adapter->dev_id, "Adv Monitor Manager "
15368                                         "skipped, LE unavailable");
15369                 }
15370         }
15371
15372         db = btd_gatt_database_get_db(adapter->database);
15373         adapter->db_id = gatt_db_register(db, services_modified,
15374                                                         services_modified,
15375                                                         adapter, NULL);
15376
15377 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15378         ba2str(&adapter->bdaddr, address);
15379         snprintf(filename, PATH_MAX, STORAGEDIR "/%s", address);
15380         delete_tempfiles(filename);
15381 #endif
15382
15383 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15384         adapter_print_devices(adapter);
15385
15386         if (load_local_irk(adapter)) {
15387                 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
15388                         btd_opts.le_privacy = false;
15389
15390                 /*
15391                  * Some Android devices don't consider the device as LE one,
15392                  * if the device doesn't distribute IRK when pairing.
15393                  * Because of this compatibility issue, set IRK
15394                  * even though privacy feature is disabled.
15395                  */
15396                 set_local_irk(adapter);
15397
15398                 if (btd_opts.le_privacy) {
15399                         DBG("Enable LE Privacy feature");
15400                         set_privacy(adapter, true);
15401                 } else {
15402                         DBG("Disable LE Privacy feature");
15403                 }
15404         }
15405 #endif
15406
15407 load:
15408         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FLAGS_CHANGED,
15409                                                 adapter->dev_id,
15410                                                 device_flags_changed_callback,
15411                                                 adapter, NULL);
15412
15413         load_config(adapter);
15414         fix_storage(adapter);
15415         load_drivers(adapter);
15416         btd_profile_foreach(probe_profile, adapter);
15417         clear_blocked(adapter);
15418         load_defaults(adapter);
15419         load_devices(adapter);
15420
15421         /* restore Service Changed CCC value for bonded devices */
15422         btd_gatt_database_restore_svc_chng_ccc(adapter->database);
15423
15424         /* retrieve the active connections: address the scenario where
15425          * the are active connections before the daemon've started */
15426         if (btd_adapter_get_powered(adapter))
15427                 load_connections(adapter);
15428
15429         adapter->initialized = TRUE;
15430
15431         if (btd_opts.did_source) {
15432                 /* DeviceID record is added by sdpd-server before any other
15433                  * record is registered. */
15434                 adapter_service_insert(adapter, sdp_record_find(0x10000));
15435                 set_did(adapter, btd_opts.did_vendor, btd_opts.did_product,
15436                                 btd_opts.did_version, btd_opts.did_source);
15437         }
15438
15439         DBG("Adapter %s registered", adapter->path);
15440
15441         return 0;
15442 }
15443
15444 static int adapter_unregister(struct btd_adapter *adapter)
15445 {
15446         DBG("Unregister path: %s", adapter->path);
15447
15448         adapters = g_slist_remove(adapters, adapter);
15449
15450         if (adapter->is_default && adapters != NULL) {
15451                 struct btd_adapter *new_default;
15452
15453                 new_default = adapter_find_by_id(hci_get_route(NULL));
15454                 if (new_default == NULL)
15455                         new_default = adapters->data;
15456
15457                 new_default->is_default = true;
15458         }
15459
15460         adapter_list = g_list_remove(adapter_list, adapter);
15461
15462         adapter_remove(adapter);
15463         btd_adapter_unref(adapter);
15464
15465         return 0;
15466 }
15467
15468 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15469 /* ---- HCI Error Codes ---- */
15470 #define HCI_ERROR_AUTH_FAILURE          0x05
15471 #define HCI_ERROR_PIN_OR_KEY_MISSING    0x06
15472 #define HCI_ERROR_MEMORY_EXCEEDED       0x07
15473 #define HCI_ERROR_CONNECTION_TIMEOUT    0x08
15474 #define HCI_ERROR_REJ_LIMITED_RESOURCES 0x0d
15475 #define HCI_ERROR_REJ_BAD_ADDR          0x0f
15476 #define HCI_ERROR_REMOTE_USER_TERM      0x13
15477 #define HCI_ERROR_REMOTE_LOW_RESOURCES  0x14
15478 #define HCI_ERROR_REMOTE_POWER_OFF      0x15
15479 #define HCI_ERROR_LOCAL_HOST_TERM       0x16
15480 #define HCI_ERROR_PAIRING_NOT_ALLOWED   0x18
15481 #define HCI_ERROR_INVALID_LL_PARAMS     0x1e
15482 #define HCI_ERROR_UNSPECIFIED           0x1f
15483 #define HCI_ERROR_ADVERTISING_TIMEOUT   0x3c
15484
15485 static uint8_t mgmt_to_hci_reason(uint8_t err)
15486 {
15487         switch (err) {
15488         case MGMT_DEV_DISCONN_TIMEOUT:
15489                 return HCI_ERROR_CONNECTION_TIMEOUT;
15490         case MGMT_DEV_DISCONN_REMOTE:
15491                 return HCI_ERROR_REMOTE_USER_TERM;
15492         case MGMT_DEV_DISCONN_LOCAL_HOST:
15493                 return HCI_ERROR_LOCAL_HOST_TERM;
15494         default:
15495                 error("No match MGMT error");
15496                 return err;
15497         }
15498 }
15499 #endif
15500
15501 static void disconnected_callback(uint16_t index, uint16_t length,
15502                                         const void *param, void *user_data)
15503 {
15504         const struct mgmt_ev_device_disconnected *ev = param;
15505         struct btd_adapter *adapter = user_data;
15506         uint8_t reason;
15507
15508         if (length < sizeof(struct mgmt_addr_info)) {
15509                 btd_error(adapter->dev_id,
15510                                 "Too small device disconnected event");
15511                 return;
15512         }
15513
15514         if (length < sizeof(*ev))
15515                 reason = MGMT_DEV_DISCONN_UNKNOWN;
15516         else
15517                 reason = ev->reason;
15518
15519 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15520          /* Use HCI error code instead of MGMT disconnection reason */
15521         dev_disconnected(adapter, &ev->addr, mgmt_to_hci_reason(reason));
15522 #else
15523         dev_disconnected(adapter, &ev->addr, reason);
15524 #endif
15525 }
15526
15527 static void connected_callback(uint16_t index, uint16_t length,
15528                                         const void *param, void *user_data)
15529 {
15530         const struct mgmt_ev_device_connected *ev = param;
15531         struct btd_adapter *adapter = user_data;
15532         struct btd_device *device;
15533         struct eir_data eir_data;
15534         uint16_t eir_len;
15535         char addr[18];
15536         bool name_known;
15537
15538         if (length < sizeof(*ev)) {
15539                 btd_error(adapter->dev_id, "Too small device connected event");
15540                 return;
15541         }
15542
15543         eir_len = btohs(ev->eir_len);
15544         if (length < sizeof(*ev) + eir_len) {
15545                 btd_error(adapter->dev_id, "Too small device connected event");
15546                 return;
15547         }
15548
15549         ba2str(&ev->addr.bdaddr, addr);
15550
15551         DBG("hci%u device %s connected eir_len %u", index, addr, eir_len);
15552
15553         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
15554                                                                 ev->addr.type);
15555         if (!device) {
15556                 btd_error(adapter->dev_id,
15557                                 "Unable to get device object for %s", addr);
15558                 return;
15559         }
15560
15561         memset(&eir_data, 0, sizeof(eir_data));
15562         if (eir_len > 0)
15563                 eir_parse(&eir_data, ev->eir, eir_len);
15564
15565         if (eir_data.class != 0)
15566                 device_set_class(device, eir_data.class);
15567
15568         adapter_add_connection(adapter, device, ev->addr.type,
15569                                         le32_to_cpu(ev->flags));
15570
15571         name_known = device_name_known(device);
15572
15573         if (eir_data.name && (eir_data.name_complete || !name_known)) {
15574                 device_store_cached_name(device, eir_data.name);
15575                 btd_device_device_set_name(device, eir_data.name);
15576         }
15577
15578         if (eir_data.msd_list)
15579                 adapter_msd_notify(adapter, device, eir_data.msd_list);
15580
15581         eir_data_free(&eir_data);
15582 }
15583
15584 static void controller_resume_notify(struct btd_adapter *adapter)
15585 {
15586         GSList *l;
15587
15588         for (l = adapter->drivers; l; l = g_slist_next(l)) {
15589                 struct btd_adapter_driver *driver = l->data;
15590                 if (driver->resume)
15591                         driver->resume(adapter);
15592         }
15593 }
15594
15595 static void controller_resume_callback(uint16_t index, uint16_t length,
15596                                        const void *param, void *user_data)
15597 {
15598         const struct mgmt_ev_controller_resume *ev = param;
15599         struct btd_adapter *adapter = user_data;
15600
15601         if (length < sizeof(*ev)) {
15602                 btd_error(adapter->dev_id, "Too small device resume event");
15603                 return;
15604         }
15605
15606         info("Controller resume with wake event 0x%x", ev->wake_reason);
15607
15608         controller_resume_notify(adapter);
15609 }
15610
15611 static void device_blocked_callback(uint16_t index, uint16_t length,
15612                                         const void *param, void *user_data)
15613 {
15614         const struct mgmt_ev_device_blocked *ev = param;
15615         struct btd_adapter *adapter = user_data;
15616         struct btd_device *device;
15617         char addr[18];
15618
15619         if (length < sizeof(*ev)) {
15620                 btd_error(adapter->dev_id, "Too small device blocked event");
15621                 return;
15622         }
15623
15624         ba2str(&ev->addr.bdaddr, addr);
15625         DBG("hci%u %s blocked", index, addr);
15626
15627         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15628                                                                 ev->addr.type);
15629         if (device)
15630                 device_block(device, TRUE);
15631 }
15632
15633 static void device_unblocked_callback(uint16_t index, uint16_t length,
15634                                         const void *param, void *user_data)
15635 {
15636         const struct mgmt_ev_device_unblocked *ev = param;
15637         struct btd_adapter *adapter = user_data;
15638         struct btd_device *device;
15639         char addr[18];
15640
15641         if (length < sizeof(*ev)) {
15642                 btd_error(adapter->dev_id, "Too small device unblocked event");
15643                 return;
15644         }
15645
15646         ba2str(&ev->addr.bdaddr, addr);
15647         DBG("hci%u %s unblocked", index, addr);
15648
15649         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15650                                                                 ev->addr.type);
15651         if (device)
15652                 device_unblock(device, FALSE, TRUE);
15653 }
15654
15655 static void conn_fail_notify(struct btd_device *dev, uint8_t status)
15656 {
15657         GSList *l;
15658
15659         for (l = conn_fail_list; l; l = g_slist_next(l)) {
15660                 btd_conn_fail_cb conn_fail_cb = l->data;
15661                 conn_fail_cb(dev, status);
15662         }
15663 }
15664
15665 void btd_add_conn_fail_cb(btd_conn_fail_cb func)
15666 {
15667         conn_fail_list = g_slist_append(conn_fail_list, func);
15668 }
15669
15670 void btd_remove_conn_fail_cb(btd_conn_fail_cb func)
15671 {
15672         conn_fail_list = g_slist_remove(conn_fail_list, func);
15673 }
15674
15675 static void connect_failed_callback(uint16_t index, uint16_t length,
15676                                         const void *param, void *user_data)
15677 {
15678         const struct mgmt_ev_connect_failed *ev = param;
15679         struct btd_adapter *adapter = user_data;
15680         struct btd_device *device;
15681         char addr[18];
15682
15683         if (length < sizeof(*ev)) {
15684                 btd_error(adapter->dev_id, "Too small connect failed event");
15685                 return;
15686         }
15687
15688         ba2str(&ev->addr.bdaddr, addr);
15689
15690         DBG("hci%u %s status %u", index, addr, ev->status);
15691
15692         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15693                                                                 ev->addr.type);
15694         if (device) {
15695                 conn_fail_notify(device, ev->status);
15696
15697                 /* If the device is in a bonding process cancel any auth request
15698                  * sent to the agent before proceeding, but keep the bonding
15699                  * request structure. */
15700                 if (device_is_bonding(device, NULL))
15701                         device_cancel_authentication(device, FALSE);
15702         }
15703
15704         /* In the case of security mode 3 devices */
15705         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
15706                                                                 ev->status);
15707
15708         /* If the device is scheduled to retry the bonding wait until the retry
15709          * happens. In other case, proceed with cancel the bondig.
15710          */
15711         if (device && device_is_bonding(device, NULL)
15712                                         && !device_is_retrying(device)) {
15713                 device_cancel_authentication(device, TRUE);
15714                 device_bonding_failed(device, ev->status);
15715         }
15716
15717 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
15718         /* In the case the bonding was canceled or did exists, remove the device
15719          * when it is temporary. */
15720         if (device && !device_is_bonding(device, NULL)
15721                                                 && device_is_temporary(device))
15722                 btd_adapter_remove_device(adapter, device);
15723 #endif
15724 }
15725
15726 static void remove_keys(struct btd_adapter *adapter,
15727                                         struct btd_device *device, uint8_t type)
15728 {
15729         char device_addr[18];
15730         char filename[PATH_MAX];
15731         GKeyFile *key_file;
15732         GError *gerr = NULL;
15733         gsize length = 0;
15734         char *str;
15735
15736         ba2str(device_get_address(device), device_addr);
15737
15738 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15739         if (device_get_rpa_exist(device) == true)
15740                 ba2str(device_get_rpa(device), device_addr);
15741 #endif
15742
15743         create_filename(filename, PATH_MAX, "/%s/%s/info",
15744                         btd_adapter_get_storage_dir(adapter), device_addr);
15745
15746         key_file = g_key_file_new();
15747         if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) {
15748                 error("Unable to load key file from %s: (%s)", filename,
15749                                                                 gerr->message);
15750                 g_clear_error(&gerr);
15751         }
15752
15753         if (type == BDADDR_BREDR) {
15754                 g_key_file_remove_group(key_file, "LinkKey", NULL);
15755         } else {
15756                 g_key_file_remove_group(key_file, "LongTermKey", NULL);
15757                 g_key_file_remove_group(key_file, "LocalSignatureKey", NULL);
15758                 g_key_file_remove_group(key_file, "RemoteSignatureKey", NULL);
15759                 g_key_file_remove_group(key_file, "IdentityResolvingKey", NULL);
15760         }
15761
15762         str = g_key_file_to_data(key_file, &length, NULL);
15763         if (!g_file_set_contents(filename, str, length, &gerr)) {
15764                 error("Unable set contents for %s: (%s)", filename,
15765                                                                 gerr->message);
15766                 g_error_free(gerr);
15767         }
15768         g_free(str);
15769
15770         g_key_file_free(key_file);
15771 }
15772
15773 static void unpaired_callback(uint16_t index, uint16_t length,
15774                                         const void *param, void *user_data)
15775 {
15776         const struct mgmt_ev_device_unpaired *ev = param;
15777         struct btd_adapter *adapter = user_data;
15778         struct btd_device *device;
15779         char addr[18];
15780
15781         if (length < sizeof(*ev)) {
15782                 btd_error(adapter->dev_id, "Too small device unpaired event");
15783                 return;
15784         }
15785
15786         ba2str(&ev->addr.bdaddr, addr);
15787
15788         DBG("hci%u addr %s", index, addr);
15789
15790         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
15791                                                                 ev->addr.type);
15792         if (!device) {
15793                 btd_warn(adapter->dev_id,
15794                         "No device object for unpaired device %s", addr);
15795                 return;
15796         }
15797
15798         remove_keys(adapter, device, ev->addr.type);
15799         device_set_unpaired(device, ev->addr.type);
15800 }
15801
15802 static void clear_devices_complete(uint8_t status, uint16_t length,
15803                                         const void *param, void *user_data)
15804 {
15805         if (status != MGMT_STATUS_SUCCESS) {
15806                 error("Failed to clear devices: %s (0x%02x)",
15807                                                 mgmt_errstr(status), status);
15808                 return;
15809         }
15810 }
15811
15812 static int clear_devices(struct btd_adapter *adapter)
15813 {
15814         struct mgmt_cp_remove_device cp;
15815
15816         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
15817                 return 0;
15818
15819         memset(&cp, 0, sizeof(cp));
15820
15821         DBG("sending clear devices command for index %u", adapter->dev_id);
15822
15823         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
15824                                 adapter->dev_id, sizeof(cp), &cp,
15825                                 clear_devices_complete, adapter, NULL) > 0)
15826                 return 0;
15827
15828         btd_error(adapter->dev_id, "Failed to clear devices for index %u",
15829                                                         adapter->dev_id);
15830
15831         return -EIO;
15832 }
15833
15834 static bool get_static_addr(struct btd_adapter *adapter)
15835 {
15836         struct bt_crypto *crypto;
15837         GKeyFile *file;
15838         GError *gerr = NULL;
15839         char filename[PATH_MAX];
15840         char **addrs;
15841         char mfg[7];
15842         char *str;
15843         bool ret;
15844         gsize len, i;
15845
15846         snprintf(mfg, sizeof(mfg), "0x%04x", adapter->manufacturer);
15847
15848         create_filename(filename, PATH_MAX, "/addresses");
15849
15850         file = g_key_file_new();
15851         if (!g_key_file_load_from_file(file, filename, 0, &gerr)) {
15852                 error("Unable to load key file from %s: (%s)",
15853                                         filename, gerr->message);
15854                 g_clear_error(&gerr);
15855         }
15856         addrs = g_key_file_get_string_list(file, "Static", mfg, &len, NULL);
15857         if (addrs) {
15858                 for (i = 0; i < len; i++) {
15859                         bdaddr_t addr;
15860
15861                         str2ba(addrs[i], &addr);
15862                         if (adapter_find(&addr))
15863                                 continue;
15864
15865                         /* Usable address found in list */
15866                         bacpy(&adapter->bdaddr, &addr);
15867                         adapter->bdaddr_type = BDADDR_LE_RANDOM;
15868                         ret = true;
15869                         goto done;
15870                 }
15871
15872                 len++;
15873                 addrs = g_renew(char *, addrs, len + 1);
15874         } else {
15875                 len = 1;
15876                 addrs = g_new(char *, len + 1);
15877         }
15878
15879         /* Initialize slot for new address */
15880         addrs[len - 1] = g_malloc(18);
15881         addrs[len] = NULL;
15882
15883         crypto = bt_crypto_new();
15884         if (!crypto) {
15885                 error("Failed to open crypto");
15886                 ret = false;
15887                 goto done;
15888         }
15889
15890         ret = bt_crypto_random_bytes(crypto, &adapter->bdaddr,
15891                                                 sizeof(adapter->bdaddr));
15892         if (!ret) {
15893                 error("Failed to generate static address");
15894                 bt_crypto_unref(crypto);
15895                 goto done;
15896         }
15897
15898         bt_crypto_unref(crypto);
15899
15900         adapter->bdaddr.b[5] |= 0xc0;
15901         adapter->bdaddr_type = BDADDR_LE_RANDOM;
15902
15903         ba2str(&adapter->bdaddr, addrs[len - 1]);
15904
15905         g_key_file_set_string_list(file, "Static", mfg,
15906                                                 (const char **)addrs, len);
15907
15908         str = g_key_file_to_data(file, &len, NULL);
15909         if (!g_file_set_contents(filename, str, len, &gerr)) {
15910                 error("Unable set contents for %s: (%s)",
15911                                         filename, gerr->message);
15912                 g_error_free(gerr);
15913         }
15914         g_free(str);
15915
15916         ret = true;
15917
15918 done:
15919         g_key_file_free(file);
15920         g_strfreev(addrs);
15921
15922         return ret;
15923 }
15924
15925 static bool set_static_addr(struct btd_adapter *adapter)
15926 {
15927         struct mgmt_cp_set_static_address cp;
15928
15929         /* dual-mode adapters must have a public address */
15930         if (adapter->supported_settings & MGMT_SETTING_BREDR)
15931                 return false;
15932
15933         if (!(adapter->supported_settings & MGMT_SETTING_LE))
15934                 return false;
15935
15936         DBG("Setting static address");
15937
15938         if (!get_static_addr(adapter))
15939                 return false;
15940
15941         bacpy(&cp.bdaddr, &adapter->bdaddr);
15942         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STATIC_ADDRESS,
15943                                 adapter->dev_id, sizeof(cp), &cp,
15944                                 NULL, NULL, NULL) > 0) {
15945                 return true;
15946         }
15947
15948         return false;
15949 }
15950
15951 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15952 static uint8_t *generate_irk(void)
15953 {
15954         int fd;
15955         uint8_t *irk;
15956
15957         DBG("Generate IRK");
15958
15959         fd = open("/dev/urandom", O_RDONLY);
15960         if (fd < 0)
15961                 return NULL;
15962
15963         irk = g_malloc0(MGMT_IRK_SIZE);
15964         if (read(fd, irk, MGMT_IRK_SIZE) != MGMT_IRK_SIZE) {
15965                 error("Cannot read random bytes");
15966                 g_free(irk);
15967                 close(fd);
15968                 return NULL;
15969         }
15970         close(fd);
15971
15972         return irk;
15973 }
15974
15975 #define LOCAL_IRK_DIRNAME       "/csa/bluetooth"
15976 #define LOCAL_IRK_FILENAME      ".local_irk"
15977
15978 static bool store_local_irk(struct btd_adapter *adapter)
15979 {
15980         int fd;
15981         int ret;
15982
15983         if (adapter->local_irk == NULL) {
15984                 error("Local IRK is not proper");
15985                 return false;
15986         }
15987
15988         if (access(LOCAL_IRK_DIRNAME, F_OK) < 0) {
15989                 if (mkdir(LOCAL_IRK_DIRNAME, 0755) < 0) {
15990                         error("Cannot create a directory for local IRK : %s",
15991                                         strerror(errno));
15992                         return false;
15993                 }
15994         }
15995
15996         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME,
15997                         O_WRONLY | O_CREAT | O_TRUNC, 0644);
15998         if (fd < 0) {
15999                 error("Cannot open a file for local IRK : %s", strerror(errno));
16000                 return false;
16001         }
16002
16003         ret = write(fd, adapter->local_irk, MGMT_IRK_SIZE);
16004         if (ret != MGMT_IRK_SIZE) {
16005                 error("Cannot write local IRK [%d] : %s", ret, strerror(errno));
16006
16007                 close(fd);
16008                 unlink(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME);
16009                 return false;
16010         }
16011
16012         ret = fdatasync(fd);
16013         if (ret < 0)
16014                 error("sync failed : %s", strerror(errno));
16015
16016         close(fd);
16017         return true;
16018 }
16019
16020 static bool load_local_irk(struct btd_adapter *adapter)
16021 {
16022         int fd;
16023         int ret;
16024
16025         if (access(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, F_OK) < 0) {
16026                 adapter->local_irk = generate_irk();
16027                 if (store_local_irk(adapter) == false) {
16028                         error("Cannot store Local IRK");
16029                         g_free(adapter->local_irk);
16030                         return false;
16031                 }
16032
16033                 return true;
16034         }
16035
16036         if (adapter->local_irk) {
16037                 DBG("Local IRK is already loaded");
16038                 return true;
16039         }
16040
16041         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, O_RDONLY);
16042         if (fd < 0) {
16043                 error("Cannot open local IRK file : %s", strerror(errno));
16044                 return false;
16045         }
16046
16047         adapter->local_irk = g_malloc0(MGMT_IRK_SIZE);
16048
16049         ret = read(fd, adapter->local_irk, MGMT_IRK_SIZE);
16050         if (ret != MGMT_IRK_SIZE) {
16051                 error("Cannot read local IRK [%d] : %s", ret, strerror(errno));
16052                 g_free(adapter->local_irk);
16053                 close(fd);
16054                 return false;
16055         }
16056
16057         close(fd);
16058         return true;
16059 }
16060
16061 static void set_privacy_complete(uint8_t status, uint16_t length,
16062         const void *param, void *user_data)
16063 {
16064         struct btd_adapter *adapter = user_data;
16065
16066         if (status != MGMT_STATUS_SUCCESS)
16067                 error("Setting privacy failed for hci%u: %s (0x%02x)",
16068                         adapter->dev_id, mgmt_errstr(status), status);
16069         else
16070                 DBG("Privacy feature is set/unset successfully for hci%u",
16071                         adapter->dev_id);
16072 }
16073
16074 static bool set_privacy(struct btd_adapter *adapter, bool privacy)
16075 {
16076         struct mgmt_cp_set_privacy cp;
16077
16078         if (!adapter->local_irk) {
16079                 error("Local IRK is not available");
16080                 return false;
16081         }
16082
16083         memset(&cp, 0, sizeof(cp));
16084         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
16085
16086         if (privacy)
16087                 cp.privacy = 0x01;
16088
16089         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
16090                                 adapter->dev_id, sizeof(cp), &cp,
16091                                 set_privacy_complete, adapter, NULL) > 0)
16092                 return true;
16093
16094         error("Failed to set privacy and load local irk for index %u",
16095                         adapter->dev_id);
16096         return false;
16097 }
16098
16099 static void set_irk_complete(uint8_t status, uint16_t length,
16100                 const void *param, void *user_data)
16101 {
16102         struct btd_adapter *adapter = user_data;
16103
16104         if (status != MGMT_STATUS_SUCCESS)
16105                 error("Setting IRK is failed for hci%u: %s (0x%02x)",
16106                         adapter->dev_id, mgmt_errstr(status), status);
16107         else
16108                 DBG("Setting IRK is succeed for hci%u", adapter->dev_id);
16109 }
16110
16111 static bool set_local_irk(struct btd_adapter *adapter)
16112 {
16113         struct mgmt_cp_set_irk cp;
16114
16115         if (!adapter->local_irk) {
16116                 error("Local IRK is not available");
16117                 return false;
16118         }
16119
16120         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
16121
16122         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IRK,
16123                                 adapter->dev_id, sizeof(cp), &cp,
16124                                 set_irk_complete, adapter, NULL) > 0)
16125                 return true;
16126
16127         error("Failed to set irk %u", adapter->dev_id);
16128         return false;
16129 }
16130
16131 int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
16132                                                 const bdaddr_t *bdaddr,
16133                                                 uint8_t bdaddr_type)
16134
16135 {
16136         struct mgmt_cp_connect_6lowpan cp;
16137
16138         memset(&cp, 0, sizeof(cp));
16139         bacpy(&cp.addr.bdaddr, bdaddr);
16140         cp.addr.type = bdaddr_type;
16141
16142         if (mgmt_send(adapter->mgmt, MGMT_OP_CONNECT_6LOWPAN,
16143                                 adapter->dev_id, sizeof(cp), &cp,
16144                                 NULL, NULL, NULL) > 0)
16145                 return 0;
16146
16147         return -EIO;
16148 }
16149
16150 int btd_adapter_disconnect_ipsp(struct btd_adapter *adapter,
16151                                                 const bdaddr_t *bdaddr,
16152                                                 uint8_t bdaddr_type)
16153
16154 {
16155         struct mgmt_cp_disconnect_6lowpan cp;
16156
16157         memset(&cp, 0, sizeof(cp));
16158         bacpy(&cp.addr.bdaddr, bdaddr);
16159         cp.addr.type = bdaddr_type;
16160
16161         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT_6LOWPAN,
16162                                 adapter->dev_id, sizeof(cp), &cp,
16163                                 NULL, NULL, NULL) > 0)
16164                 return 0;
16165
16166         return -EIO;
16167 }
16168
16169 uint8_t btd_adapter_get_rpa_res_support_value(
16170                 struct btd_adapter *adapter)
16171 {
16172         return adapter->central_rpa_res_support;
16173 }
16174
16175 static void set_dev_rpa_res_support_complete(uint8_t status,
16176                                         uint16_t length, const void *param,
16177                                         void *user_data)
16178 {
16179         if (status != MGMT_STATUS_SUCCESS)
16180                 error("Failed to set RPA resolution support of device : %s (0x%02x)",
16181                                                 mgmt_errstr(status), status);
16182         else
16183                 DBG("Set RPA resolution support successful");
16184 }
16185
16186 int btd_adapter_set_dev_rpa_res_support(struct btd_adapter *adapter,
16187                                         struct btd_device *device)
16188
16189 {
16190         struct mgmt_cp_set_dev_rpa_res_support cp;
16191
16192         DBG("btd_adapter_set_dev_rpa_res_support called");
16193
16194         memset(&cp, 0, sizeof(cp));
16195
16196         bacpy(&cp.addr.bdaddr, device_get_address(device));
16197         cp.addr.type = btd_device_get_bdaddr_type(device);
16198         cp.res_support = device_get_rpa_res_char_value(device);
16199
16200         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_RPA_RES_SUPPORT,
16201                                 adapter->dev_id, sizeof(cp), &cp,
16202                                 set_dev_rpa_res_support_complete, NULL, NULL) > 0)
16203                 return 0;
16204
16205         return -EIO;
16206 }
16207 #endif
16208
16209 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16210 static gboolean adapter_start_idle_cb(gpointer user_data)
16211 {
16212         struct btd_adapter *adapter = (struct btd_adapter*)user_data;
16213
16214         adapter_start(adapter);
16215
16216         return FALSE;
16217 }
16218 #endif
16219
16220 static void set_blocked_keys_complete(uint8_t status, uint16_t length,
16221                                         const void *param, void *user_data)
16222 {
16223         struct btd_adapter *adapter = user_data;
16224
16225         if (status != MGMT_STATUS_SUCCESS) {
16226                 btd_error(adapter->dev_id,
16227                                 "Failed to set blocked keys: %s (0x%02x)",
16228                                 mgmt_errstr(status), status);
16229                 return;
16230         }
16231
16232         DBG("Successfully set blocked keys for index %u", adapter->dev_id);
16233 }
16234
16235 static bool set_blocked_keys(struct btd_adapter *adapter)
16236 {
16237         uint8_t buffer[sizeof(struct mgmt_cp_set_blocked_keys) +
16238                                         sizeof(blocked_keys)] = { 0 };
16239         struct mgmt_cp_set_blocked_keys *cp =
16240                                 (struct mgmt_cp_set_blocked_keys *)buffer;
16241         int i;
16242
16243         cp->key_count = ARRAY_SIZE(blocked_keys);
16244         for (i = 0; i < cp->key_count; ++i) {
16245                 cp->keys[i].type = blocked_keys[i].type;
16246                 memcpy(cp->keys[i].val, blocked_keys[i].val,
16247                                                 sizeof(cp->keys[i].val));
16248         }
16249
16250         return mgmt_send(mgmt_primary, MGMT_OP_SET_BLOCKED_KEYS,
16251                                                 adapter->dev_id,
16252                                                 sizeof(buffer), buffer,
16253                                                 set_blocked_keys_complete,
16254                                                 adapter, NULL);
16255 }
16256
16257 #define EXP_FEAT(_flag, _uuid, _func) \
16258 { \
16259         .flag = _flag, \
16260         .uuid = _uuid, \
16261         .func = _func, \
16262 }
16263
16264 static void exp_complete(void *user_data);
16265
16266 static bool exp_mgmt_send(struct btd_adapter *adapter, uint16_t opcode,
16267                         uint16_t index, uint16_t length, const void *param,
16268                         mgmt_request_func_t callback)
16269 {
16270         struct exp_pending *pending;
16271
16272         pending = g_new0(struct exp_pending, 1);
16273         pending->adapter = adapter;
16274
16275         if (!queue_push_tail(adapter->exp_pending, pending)) {
16276                 g_free(pending);
16277                 return false;
16278         }
16279
16280         pending->id = mgmt_send(adapter->mgmt, opcode, index, length, param,
16281                                         callback, pending, exp_complete);
16282         if (!pending->id) {
16283                 queue_remove(adapter->exp_pending, pending);
16284                 g_free(pending);
16285                 return false;
16286         }
16287
16288         return true;
16289 }
16290
16291 static void set_exp_debug_complete(uint8_t status, uint16_t len,
16292                                         const void *param, void *user_data)
16293 {
16294         struct exp_pending *pending = user_data;
16295         struct btd_adapter *adapter = pending->adapter;
16296         uint8_t action;
16297
16298         if (status != 0) {
16299                 error("Set Experimental Debug failed with status 0x%02x (%s)",
16300                                                 status, mgmt_errstr(status));
16301                 return;
16302         }
16303
16304         action = btd_kernel_experimental_enabled(debug_uuid.str);
16305
16306         DBG("Experimental Debug successfully %s", action ? "set" : "reset");
16307
16308         if (action)
16309                 queue_push_tail(adapter->exps, (void *)debug_uuid.val);
16310 }
16311
16312 static void exp_debug_func(struct btd_adapter *adapter, uint8_t action)
16313 {
16314         struct mgmt_cp_set_exp_feature cp;
16315
16316         memset(&cp, 0, sizeof(cp));
16317         memcpy(cp.uuid, debug_uuid.val, 16);
16318         cp.action = action;
16319
16320         if (exp_mgmt_send(adapter, MGMT_OP_SET_EXP_FEATURE,
16321                         adapter->dev_id, sizeof(cp), &cp,
16322                         set_exp_debug_complete))
16323                 return;
16324
16325         btd_error(adapter->dev_id, "Failed to set exp debug");
16326 }
16327
16328 static void le_simult_central_peripheral_func(struct btd_adapter *adapter,
16329                                                         uint8_t action)
16330 {
16331         if (action)
16332                 queue_push_tail(adapter->exps,
16333                                 (void *)le_simult_central_peripheral_uuid.val);
16334 }
16335
16336 static void quality_report_func(struct btd_adapter *adapter, uint8_t action)
16337 {
16338         if (action)
16339                 queue_push_tail(adapter->exps, (void *)quality_report_uuid.val);
16340 }
16341
16342 static void set_rpa_resolution_complete(uint8_t status, uint16_t len,
16343                                         const void *param, void *user_data)
16344 {
16345         struct exp_pending *pending = user_data;
16346         struct btd_adapter *adapter = pending->adapter;
16347         uint8_t action;
16348
16349         if (status != 0) {
16350                 error("Set RPA Resolution failed with status 0x%02x (%s)",
16351                                                 status, mgmt_errstr(status));
16352                 return;
16353         }
16354
16355         action = btd_kernel_experimental_enabled(rpa_resolution_uuid.str);
16356
16357         DBG("RPA Resolution successfully %s", action ? "set" : "reset");
16358
16359         if (action)
16360                 queue_push_tail(adapter->exps, (void *)rpa_resolution_uuid.val);
16361 }
16362
16363 static void rpa_resolution_func(struct btd_adapter *adapter, uint8_t action)
16364 {
16365         struct mgmt_cp_set_exp_feature cp;
16366
16367         memset(&cp, 0, sizeof(cp));
16368         memcpy(cp.uuid, rpa_resolution_uuid.val, 16);
16369         cp.action = action;
16370
16371         if (exp_mgmt_send(adapter, MGMT_OP_SET_EXP_FEATURE,
16372                         adapter->dev_id, sizeof(cp), &cp,
16373                         set_rpa_resolution_complete))
16374                 return;
16375
16376         btd_error(adapter->dev_id, "Failed to set RPA Resolution");
16377 }
16378
16379 static void codec_offload_complete(uint8_t status, uint16_t len,
16380                                         const void *param, void *user_data)
16381 {
16382         struct exp_pending *pending = user_data;
16383         struct btd_adapter *adapter = pending->adapter;
16384         uint8_t action;
16385
16386         if (status != 0) {
16387                 error("Set Codec Offload failed with status 0x%02x (%s)",
16388                                                 status, mgmt_errstr(status));
16389                 return;
16390         }
16391
16392         action = btd_kernel_experimental_enabled(codec_offload_uuid.str);
16393
16394         DBG("Codec Offload successfully %s", action ? "set" : "reset");
16395
16396         if (action)
16397                 queue_push_tail(adapter->exps, (void *)codec_offload_uuid.val);
16398 }
16399
16400 static void codec_offload_func(struct btd_adapter *adapter, uint8_t action)
16401 {
16402         struct mgmt_cp_set_exp_feature cp;
16403
16404         memset(&cp, 0, sizeof(cp));
16405         memcpy(cp.uuid, codec_offload_uuid.val, 16);
16406         cp.action = action;
16407
16408         if (exp_mgmt_send(adapter, MGMT_OP_SET_EXP_FEATURE,
16409                         adapter->dev_id, sizeof(cp), &cp,
16410                         codec_offload_complete))
16411                 return;
16412
16413         btd_error(adapter->dev_id, "Failed to set Codec Offload");
16414 }
16415
16416 static void iso_socket_complete(uint8_t status, uint16_t len,
16417                                 const void *param, void *user_data)
16418 {
16419         struct exp_pending *pending = user_data;
16420         struct btd_adapter *adapter = pending->adapter;
16421         uint8_t action;
16422
16423         if (status != 0) {
16424                 error("Set ISO Socket failed with status 0x%02x (%s)",
16425                                                 status, mgmt_errstr(status));
16426                 return;
16427         }
16428
16429         action = btd_kernel_experimental_enabled(iso_socket_uuid.str);
16430
16431         DBG("ISO Socket successfully %s", action ? "set" : "reset");
16432
16433         if (action)
16434                 queue_push_tail(adapter->exps, (void *)iso_socket_uuid.val);
16435 }
16436
16437 static void iso_socket_func(struct btd_adapter *adapter, uint8_t action)
16438 {
16439         struct mgmt_cp_set_exp_feature cp;
16440
16441         memset(&cp, 0, sizeof(cp));
16442         memcpy(cp.uuid, iso_socket_uuid.val, 16);
16443         cp.action = action;
16444
16445         if (exp_mgmt_send(adapter, MGMT_OP_SET_EXP_FEATURE,
16446                         MGMT_INDEX_NONE, sizeof(cp), &cp,
16447                         iso_socket_complete))
16448                 return;
16449
16450         btd_error(adapter->dev_id, "Failed to set ISO Socket");
16451 }
16452
16453 static const struct exp_feat {
16454         uint32_t flag;
16455         const struct mgmt_exp_uuid *uuid;
16456         void (*func)(struct btd_adapter *adapter, uint8_t action);
16457 } exp_table[] = {
16458         EXP_FEAT(EXP_FEAT_DEBUG, &debug_uuid, exp_debug_func),
16459         EXP_FEAT(EXP_FEAT_LE_SIMULT_ROLES, &le_simult_central_peripheral_uuid,
16460                  le_simult_central_peripheral_func),
16461         EXP_FEAT(EXP_FEAT_BQR, &quality_report_uuid, quality_report_func),
16462         EXP_FEAT(EXP_FEAT_RPA_RESOLUTION, &rpa_resolution_uuid,
16463                 rpa_resolution_func),
16464         EXP_FEAT(EXP_FEAT_CODEC_OFFLOAD, &codec_offload_uuid,
16465                 codec_offload_func),
16466         EXP_FEAT(EXP_FEAT_ISO_SOCKET, &iso_socket_uuid, iso_socket_func),
16467 };
16468
16469 static void read_exp_features_complete(uint8_t status, uint16_t length,
16470                                         const void *param, void *user_data)
16471 {
16472         struct exp_pending *pending = user_data;
16473         struct btd_adapter *adapter = pending->adapter;
16474         const struct mgmt_rp_read_exp_features_info *rp = param;
16475         size_t feature_count = 0;
16476         size_t i = 0;
16477
16478         DBG("index %u status 0x%02x", adapter->dev_id, status);
16479
16480         if (status != MGMT_STATUS_SUCCESS) {
16481                 btd_error(adapter->dev_id,
16482                                 "Failed to read exp features info: %s (0x%02x)",
16483                                 mgmt_errstr(status), status);
16484                 return;
16485         }
16486
16487         if (length < sizeof(*rp)) {
16488                 btd_error(adapter->dev_id, "Response too small");
16489                 return;
16490         }
16491
16492         feature_count = le16_to_cpu(rp->feature_count);
16493
16494         if (length < sizeof(*rp) + (sizeof(*rp->features) * feature_count)) {
16495                 btd_error(adapter->dev_id, "Response too small");
16496                 return;
16497         }
16498
16499         for (i = 0; i < feature_count; ++i) {
16500                 size_t j;
16501                 for (j = 0; j < ARRAY_SIZE(exp_table); j++) {
16502                         const struct exp_feat *feat = &exp_table[j];
16503                         const char *str;
16504                         uint8_t action;
16505
16506                         if (memcmp(rp->features[i].uuid, feat->uuid->val,
16507                                         sizeof(rp->features[i].uuid)))
16508                                 continue;
16509
16510                         str = feat->uuid->str;
16511                         action = btd_kernel_experimental_enabled(str);
16512
16513                         DBG("%s flags %u action %u", str,
16514                                         rp->features[i].flags, action);
16515
16516                         /* If already set don't attempt to set it again */
16517                         if (action == (rp->features[i].flags & BIT(0))) {
16518                                 if (action & BIT(0))
16519                                         queue_push_tail(adapter->exps,
16520                                                 (void *)feat->uuid->val);
16521                                 continue;
16522                         }
16523
16524                         if (feat->func)
16525                                 feat->func(adapter, action);
16526                 }
16527         }
16528 }
16529
16530 static void read_exp_features(struct btd_adapter *adapter)
16531 {
16532         if (exp_mgmt_send(adapter, MGMT_OP_READ_EXP_FEATURES_INFO,
16533                         adapter->dev_id, 0, NULL, read_exp_features_complete))
16534                 return;
16535
16536         btd_error(adapter->dev_id, "Failed to read exp features info");
16537 }
16538
16539 static void read_info_complete(uint8_t status, uint16_t length,
16540                                         const void *param, void *user_data)
16541 {
16542         struct btd_adapter *adapter = user_data;
16543         const struct mgmt_rp_read_info *rp = param;
16544         uint32_t missing_settings;
16545         int err;
16546
16547         DBG("index %u status 0x%02x", adapter->dev_id, status);
16548
16549         if (status != MGMT_STATUS_SUCCESS) {
16550                 btd_error(adapter->dev_id,
16551                                 "Failed to read info for index %u: %s (0x%02x)",
16552                                 adapter->dev_id, mgmt_errstr(status), status);
16553                 goto failed;
16554         }
16555
16556         if (length < sizeof(*rp)) {
16557                 btd_error(adapter->dev_id,
16558                                 "Too small read info complete response");
16559                 goto failed;
16560         }
16561
16562         /*
16563          * Store controller information for class of device, device
16564          * name, short name and settings.
16565          *
16566          * During the lifetime of the controller these will be updated by
16567          * events and the information is required to keep the current
16568          * state of the controller.
16569          */
16570         adapter->dev_class = rp->dev_class[0] | (rp->dev_class[1] << 8) |
16571                                                 (rp->dev_class[2] << 16);
16572         adapter->name = g_strdup((const char *) rp->name);
16573         adapter->short_name = g_strdup((const char *) rp->short_name);
16574
16575         adapter->manufacturer = btohs(rp->manufacturer);
16576
16577         adapter->supported_settings = btohl(rp->supported_settings);
16578         adapter->current_settings = btohl(rp->current_settings);
16579
16580 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16581         adapter_check_version(adapter, rp->version);
16582 #endif
16583         clear_uuids(adapter);
16584         clear_devices(adapter);
16585
16586         if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
16587                 if (!set_static_addr(adapter)) {
16588                         btd_error(adapter->dev_id,
16589                                         "No Bluetooth address for index %u",
16590                                         adapter->dev_id);
16591                         goto failed;
16592                 }
16593         } else {
16594                 struct btd_adapter *tmp;
16595
16596                 tmp = adapter_find(&rp->bdaddr);
16597                 if (tmp) {
16598                         btd_error(adapter->dev_id,
16599                                 "Bluetooth address for index %u match index %u",
16600                                 adapter->dev_id, tmp->dev_id);
16601                         goto failed;
16602                 }
16603
16604                 bacpy(&adapter->bdaddr, &rp->bdaddr);
16605                 if (!(adapter->supported_settings & MGMT_SETTING_LE))
16606                         adapter->bdaddr_type = BDADDR_BREDR;
16607                 else
16608                         adapter->bdaddr_type = BDADDR_LE_PUBLIC;
16609         }
16610
16611         missing_settings = adapter->current_settings ^
16612                                                 adapter->supported_settings;
16613
16614 /* If adapter supports PHY CONFIGURATION SETTING, then read PHY configuration and save them */
16615 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16616         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
16617                 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_PHY_CONFIGURATION, adapter->dev_id, 0, NULL,
16618                                         get_phy_configuration_resp, adapter, NULL) == 0)
16619                         error("Unable to send %s cmd",
16620                                         mgmt_opstr(MGMT_OP_GET_PHY_CONFIGURATION));
16621         }
16622 #endif
16623         switch (btd_opts.mode) {
16624         case BT_MODE_DUAL:
16625                 if (missing_settings & MGMT_SETTING_SSP) {
16626 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16627                         if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16628                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16629                         else
16630 #endif
16631                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16632                 }
16633                 if (missing_settings & MGMT_SETTING_LE)
16634                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16635                 if (missing_settings & MGMT_SETTING_BREDR)
16636                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16637                 break;
16638         case BT_MODE_BREDR:
16639                 if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
16640                         btd_error(adapter->dev_id,
16641                                 "Ignoring adapter withouth BR/EDR support");
16642                         goto failed;
16643                 }
16644
16645 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16646                 if (btd_opts.pin_code || (btd_opts.class & 0x1f00) >> 8 == 0x05)
16647                         set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
16648                 else
16649                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16650 #else
16651                 if (missing_settings & MGMT_SETTING_SSP)
16652                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
16653 #endif
16654                 if (missing_settings & MGMT_SETTING_BREDR)
16655                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
16656                 if (adapter->current_settings & MGMT_SETTING_LE)
16657                         set_mode(adapter, MGMT_OP_SET_LE, 0x00);
16658                 break;
16659         case BT_MODE_LE:
16660                 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
16661                         btd_error(adapter->dev_id,
16662                                 "Ignoring adapter withouth LE support");
16663                         goto failed;
16664                 }
16665
16666                 if (missing_settings & MGMT_SETTING_LE)
16667                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
16668                 if (adapter->current_settings & MGMT_SETTING_BREDR)
16669                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x00);
16670                 break;
16671         }
16672
16673         if (missing_settings & MGMT_SETTING_SECURE_CONN)
16674                 set_mode(adapter, MGMT_OP_SET_SECURE_CONN,
16675                                         btd_opts.secure_conn);
16676
16677         if (adapter->supported_settings & MGMT_SETTING_PRIVACY)
16678                 set_privacy(adapter, btd_opts.privacy);
16679
16680         if (btd_opts.fast_conn &&
16681                         (missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
16682                 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
16683
16684 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16685         /* Set the RPA resolution value to '1' if privacy is supported */
16686         if (btd_opts.le_privacy &&
16687                         adapter->supported_settings & MGMT_SETTING_PRIVACY)
16688                 adapter->central_rpa_res_support = 0x01;
16689 #endif
16690
16691         err = adapter_register(adapter);
16692         if (err < 0) {
16693                 btd_error(adapter->dev_id, "Unable to register new adapter");
16694                 goto failed;
16695         }
16696
16697         /*
16698          * Register all event notification handlers for controller.
16699          *
16700          * The handlers are registered after a succcesful read of the
16701          * controller info. From now on they can track updates and
16702          * notifications.
16703          */
16704         mgmt_register(adapter->mgmt, MGMT_EV_NEW_SETTINGS, adapter->dev_id,
16705                                         new_settings_callback, adapter, NULL);
16706
16707         mgmt_register(adapter->mgmt, MGMT_EV_CLASS_OF_DEV_CHANGED,
16708                                                 adapter->dev_id,
16709                                                 dev_class_changed_callback,
16710                                                 adapter, NULL);
16711         mgmt_register(adapter->mgmt, MGMT_EV_LOCAL_NAME_CHANGED,
16712                                                 adapter->dev_id,
16713                                                 local_name_changed_callback,
16714                                                 adapter, NULL);
16715
16716         mgmt_register(adapter->mgmt, MGMT_EV_DISCOVERING,
16717                                                 adapter->dev_id,
16718                                                 discovering_callback,
16719                                                 adapter, NULL);
16720
16721         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FOUND,
16722                                                 adapter->dev_id,
16723                                                 device_found_callback,
16724                                                 adapter, NULL);
16725
16726 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16727         mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
16728                                                 adapter->dev_id,
16729                                                 le_device_found_callback,
16730                                                 adapter, NULL);
16731 #endif
16732
16733         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_DISCONNECTED,
16734                                                 adapter->dev_id,
16735                                                 disconnected_callback,
16736                                                 adapter, NULL);
16737
16738         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_CONNECTED,
16739                                                 adapter->dev_id,
16740                                                 connected_callback,
16741                                                 adapter, NULL);
16742
16743         mgmt_register(adapter->mgmt, MGMT_EV_CONNECT_FAILED,
16744                                                 adapter->dev_id,
16745                                                 connect_failed_callback,
16746                                                 adapter, NULL);
16747
16748         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNPAIRED,
16749                                                 adapter->dev_id,
16750                                                 unpaired_callback,
16751                                                 adapter, NULL);
16752
16753         mgmt_register(adapter->mgmt, MGMT_EV_AUTH_FAILED,
16754                                                 adapter->dev_id,
16755                                                 auth_failed_callback,
16756                                                 adapter, NULL);
16757
16758         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LINK_KEY,
16759                                                 adapter->dev_id,
16760                                                 new_link_key_callback,
16761                                                 adapter, NULL);
16762
16763         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LONG_TERM_KEY,
16764                                                 adapter->dev_id,
16765                                                 new_long_term_key_callback,
16766                                                 adapter, NULL);
16767
16768         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CSRK,
16769                                                 adapter->dev_id,
16770                                                 new_csrk_callback,
16771                                                 adapter, NULL);
16772
16773         mgmt_register(adapter->mgmt, MGMT_EV_NEW_IRK,
16774                                                 adapter->dev_id,
16775                                                 new_irk_callback,
16776                                                 adapter, NULL);
16777
16778         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CONN_PARAM,
16779                                                 adapter->dev_id,
16780                                                 new_conn_param,
16781                                                 adapter, NULL);
16782
16783         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
16784                                                 adapter->dev_id,
16785                                                 device_blocked_callback,
16786                                                 adapter, NULL);
16787         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNBLOCKED,
16788                                                 adapter->dev_id,
16789                                                 device_unblocked_callback,
16790                                                 adapter, NULL);
16791
16792         mgmt_register(adapter->mgmt, MGMT_EV_PIN_CODE_REQUEST,
16793                                                 adapter->dev_id,
16794                                                 pin_code_request_callback,
16795                                                 adapter, NULL);
16796
16797         mgmt_register(adapter->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
16798                                                 adapter->dev_id,
16799                                                 user_confirm_request_callback,
16800                                                 adapter, NULL);
16801
16802         mgmt_register(adapter->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
16803                                                 adapter->dev_id,
16804                                                 user_passkey_request_callback,
16805                                                 adapter, NULL);
16806
16807         mgmt_register(adapter->mgmt, MGMT_EV_PASSKEY_NOTIFY,
16808                                                 adapter->dev_id,
16809                                                 user_passkey_notify_callback,
16810                                                 adapter, NULL);
16811
16812         mgmt_register(adapter->mgmt, MGMT_EV_CONTROLLER_RESUME,
16813                                                 adapter->dev_id,
16814                                                 controller_resume_callback,
16815                                                 adapter, NULL);
16816
16817 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16818         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
16819                                                 adapter->dev_id,
16820                                                 rssi_alert_callback,
16821                                                 adapter, NULL);
16822
16823         mgmt_register(adapter->mgmt, MGMT_EV_RAW_RSSI,
16824                                                 adapter->dev_id,
16825                                                 get_raw_rssi_callback,
16826                                                 adapter, NULL);
16827
16828         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ENABLED,
16829                                                         adapter->dev_id,
16830                                                         rssi_enabled_callback,
16831                                                         adapter, NULL);
16832
16833         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_DISABLED,
16834                                                         adapter->dev_id,
16835                                                         rssi_disabled_callback,
16836                                                         adapter, NULL);
16837
16838         mgmt_register(adapter->mgmt, MGMT_EV_HARDWARE_ERROR,
16839                                                 adapter->dev_id,
16840                                                 hardware_error_callback,
16841                                                 adapter, NULL);
16842
16843         mgmt_register(adapter->mgmt, MGMT_EV_TX_TIMEOUT_ERROR,
16844                                                 adapter->dev_id,
16845                                                 tx_timeout_error_callback,
16846                                                 adapter, NULL);
16847
16848         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_NAME_UPDATE,
16849                                         adapter->dev_id,
16850                                         device_name_update_callback,
16851                                         adapter, NULL);
16852
16853         mgmt_register(adapter->mgmt, MGMT_EV_MULTI_ADV_STATE_CHANGED,
16854                                         adapter->dev_id,
16855                                         multi_adv_state_change_callback,
16856                                         adapter, NULL);
16857
16858         mgmt_register(adapter->mgmt, MGMT_EV_6LOWPAN_CONN_STATE_CHANGED,
16859                                                 adapter->dev_id,
16860                                                 bt_6lowpan_conn_state_change_callback,
16861                                                 adapter, NULL);
16862
16863         mgmt_register(adapter->mgmt, MGMT_EV_LE_DATA_LENGTH_CHANGED,
16864                                                 adapter->dev_id,
16865                                                 bt_le_data_length_changed_callback,
16866                                                 adapter, NULL);
16867
16868         mgmt_register(adapter->mgmt, MGMT_EV_CONN_UPDATED,
16869                                         adapter->dev_id,
16870                                         le_conn_update_completed_callback,
16871                                         adapter, NULL);
16872
16873         mgmt_register(adapter->mgmt, MGMT_EV_RPA_CHANGED,
16874                                         adapter->dev_id,
16875                                         rpa_changed_callback,
16876                                         adapter, NULL);
16877 #endif
16878
16879         set_dev_class(adapter);
16880
16881         set_name(adapter, btd_adapter_get_name(adapter));
16882
16883         if (btd_has_kernel_features(KERNEL_BLOCKED_KEYS_SUPPORTED) &&
16884                         !set_blocked_keys(adapter)) {
16885                 btd_error(adapter->dev_id,
16886                                 "Failed to set blocked keys for index %u",
16887                                 adapter->dev_id);
16888                 goto failed;
16889         }
16890
16891         if (btd_opts.pairable &&
16892                         !(adapter->current_settings & MGMT_SETTING_BONDABLE))
16893                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
16894
16895         if (!btd_has_kernel_features(KERNEL_CONN_CONTROL))
16896                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x01);
16897         else if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
16898                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
16899
16900         if (adapter->stored_discoverable && !adapter->discoverable_timeout)
16901                 set_discoverable(adapter, 0x01, 0);
16902
16903         if (btd_adapter_get_powered(adapter))
16904 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16905                 g_idle_add(adapter_start_idle_cb, adapter);
16906 #else
16907                 adapter_start(adapter);
16908 #endif
16909 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16910         else
16911                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
16912 #endif
16913
16914 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
16915         init_le_static_address(adapter);
16916 #endif
16917
16918         return;
16919
16920 failed:
16921         /*
16922          * Remove adapter from list in case of a failure.
16923          *
16924          * Leaving an adapter structure around for a controller that can
16925          * not be initilized makes no sense at the moment.
16926          *
16927          * This is a simplification to avoid constant checks if the
16928          * adapter is ready to do anything.
16929          */
16930         adapter_list = g_list_remove(adapter_list, adapter);
16931
16932         btd_adapter_unref(adapter);
16933 }
16934
16935 static void reset_adv_monitors_complete(uint8_t status, uint16_t length,
16936                                         const void *param, void *user_data)
16937 {
16938         const struct mgmt_rp_remove_adv_monitor *rp = param;
16939
16940         if (status != MGMT_STATUS_SUCCESS) {
16941                 error("Failed to reset Adv Monitors: %s (0x%02x)",
16942                         mgmt_errstr(status), status);
16943                 return;
16944         }
16945
16946         if (length < sizeof(*rp)) {
16947                 error("Wrong size of remove Adv Monitor response for reset "
16948                         "all Adv Monitors");
16949                 return;
16950         }
16951
16952         DBG("Removed all Adv Monitors");
16953 }
16954
16955 static void reset_adv_monitors(uint16_t index)
16956 {
16957         struct mgmt_cp_remove_adv_monitor cp;
16958
16959         DBG("sending remove Adv Monitor command with handle 0");
16960
16961         /* Handle 0 indicates to remove all */
16962         cp.monitor_handle = 0;
16963         if (mgmt_send(mgmt_primary, MGMT_OP_REMOVE_ADV_MONITOR, index,
16964                         sizeof(cp), &cp, reset_adv_monitors_complete, NULL,
16965                         NULL) > 0) {
16966                 return;
16967         }
16968
16969         error("Failed to reset Adv Monitors");
16970 }
16971
16972 static void read_info(struct btd_adapter *adapter)
16973 {
16974         DBG("sending read info command for index %u", adapter->dev_id);
16975
16976         if (mgmt_send(mgmt_primary, MGMT_OP_READ_INFO, adapter->dev_id, 0, NULL,
16977                                         read_info_complete, adapter, NULL) > 0)
16978                 return;
16979
16980         btd_error(adapter->dev_id,
16981                         "Failed to read controller info for index %u",
16982                         adapter->dev_id);
16983
16984         adapter_list = g_list_remove(adapter_list, adapter);
16985
16986         btd_adapter_unref(adapter);
16987 }
16988
16989 static void exp_complete(void *user_data)
16990 {
16991         struct exp_pending *pending = user_data;
16992         struct btd_adapter *adapter = pending->adapter;
16993
16994         if (!adapter)
16995                 return;  /* canceled */
16996
16997         queue_remove(adapter->exp_pending, pending);
16998         g_free(pending);
16999
17000         if (queue_isempty(adapter->exp_pending)) {
17001                 read_info(adapter);
17002                 return;
17003         }
17004
17005         DBG("index %u has %u pending MGMT EXP requests", adapter->dev_id,
17006                                         queue_length(adapter->exp_pending));
17007 }
17008
17009 static void index_added(uint16_t index, uint16_t length, const void *param,
17010                                                         void *user_data)
17011 {
17012         struct btd_adapter *adapter;
17013
17014         DBG("index %u", index);
17015
17016         adapter = btd_adapter_lookup(index);
17017         if (adapter) {
17018                 btd_warn(adapter->dev_id,
17019                         "Ignoring index added for an already existing adapter");
17020                 return;
17021         }
17022
17023         /* Check if at maximum adapters allowed in the system then ignore the
17024          * adapter.
17025          */
17026         if (btd_opts.max_adapters &&
17027                         btd_opts.max_adapters == g_slist_length(adapters))
17028                 return;
17029
17030         reset_adv_monitors(index);
17031
17032         adapter = btd_adapter_new(index);
17033         if (!adapter) {
17034                 btd_error(index,
17035                         "Unable to create new adapter for index %u", index);
17036                 return;
17037         }
17038
17039         if (btd_has_kernel_features(KERNEL_EXP_FEATURES))
17040                 read_exp_features(adapter);
17041
17042         /*
17043          * Protect against potential two executions of read controller info.
17044          *
17045          * In case the start of the daemon and the action of adding a new
17046          * controller coincide this function might be called twice.
17047          *
17048          * To avoid the double execution of reading the controller info,
17049          * add the adapter already to the list. If an adapter is already
17050          * present, the second notification will cause a warning. If the
17051          * command fails the adapter is removed from the list again.
17052          */
17053         adapter_list = g_list_append(adapter_list, adapter);
17054
17055         if (queue_isempty(adapter->exp_pending))
17056                 read_info(adapter);
17057 }
17058
17059 static void index_removed(uint16_t index, uint16_t length, const void *param,
17060                                                         void *user_data)
17061 {
17062         struct btd_adapter *adapter;
17063
17064         DBG("index %u", index);
17065
17066         adapter = btd_adapter_lookup(index);
17067         if (!adapter) {
17068                 warn("Ignoring index removal for a non-existent adapter");
17069                 return;
17070         }
17071
17072         adapter_unregister(adapter);
17073 }
17074
17075 static void read_index_list_complete(uint8_t status, uint16_t length,
17076                                         const void *param, void *user_data)
17077 {
17078         const struct mgmt_rp_read_index_list *rp = param;
17079         uint16_t num;
17080         int i;
17081
17082         if (status != MGMT_STATUS_SUCCESS) {
17083                 error("Failed to read index list: %s (0x%02x)",
17084                                                 mgmt_errstr(status), status);
17085                 return;
17086         }
17087
17088         if (length < sizeof(*rp)) {
17089                 error("Wrong size of read index list response");
17090                 return;
17091         }
17092
17093         num = btohs(rp->num_controllers);
17094
17095         DBG("Number of controllers: %d", num);
17096
17097         if (num * sizeof(uint16_t) + sizeof(*rp) != length) {
17098                 error("Incorrect packet size for index list response");
17099                 return;
17100         }
17101
17102         for (i = 0; i < num; i++) {
17103                 uint16_t index;
17104
17105                 index = btohs(rp->index[i]);
17106
17107                 DBG("Found index %u", index);
17108
17109                 /*
17110                  * Pretend to be index added event notification.
17111                  *
17112                  * It is safe to just trigger the procedure for index
17113                  * added notification. It does check against itself.
17114                  */
17115                 index_added(index, 0, NULL, NULL);
17116         }
17117 }
17118
17119 static void read_commands_complete(uint8_t status, uint16_t length,
17120                                         const void *param, void *user_data)
17121 {
17122         const struct mgmt_rp_read_commands *rp = param;
17123         uint16_t num_commands, num_events;
17124         size_t expected_len;
17125         int i;
17126
17127         if (status != MGMT_STATUS_SUCCESS) {
17128                 error("Failed to read supported commands: %s (0x%02x)",
17129                                                 mgmt_errstr(status), status);
17130                 return;
17131         }
17132
17133         if (length < sizeof(*rp)) {
17134                 error("Wrong size of read commands response");
17135                 return;
17136         }
17137
17138         num_commands = btohs(rp->num_commands);
17139         num_events = btohs(rp->num_events);
17140
17141         DBG("Number of commands: %d", num_commands);
17142         DBG("Number of events: %d", num_events);
17143
17144         expected_len = sizeof(*rp) + num_commands * sizeof(uint16_t) +
17145                                                 num_events * sizeof(uint16_t);
17146
17147         if (length < expected_len) {
17148                 error("Too small reply for supported commands: (%u != %zu)",
17149                                                         length, expected_len);
17150                 return;
17151         }
17152
17153         for (i = 0; i < num_commands; i++) {
17154                 uint16_t op = get_le16(rp->opcodes + i);
17155
17156                 switch (op) {
17157                 case MGMT_OP_ADD_DEVICE:
17158                         DBG("enabling kernel-side connection control");
17159                         kernel_features |= KERNEL_CONN_CONTROL;
17160                         break;
17161                 case MGMT_OP_SET_BLOCKED_KEYS:
17162                         DBG("kernel supports the set_blocked_keys op");
17163                         kernel_features |= KERNEL_BLOCKED_KEYS_SUPPORTED;
17164                         break;
17165                 case MGMT_OP_SET_DEF_SYSTEM_CONFIG:
17166                         DBG("kernel supports set system confic");
17167                         kernel_features |= KERNEL_SET_SYSTEM_CONFIG;
17168                         break;
17169                 case MGMT_OP_READ_EXP_FEATURES_INFO:
17170                         DBG("kernel supports exp features");
17171                         kernel_features |= KERNEL_EXP_FEATURES;
17172                         break;
17173                 case MGMT_OP_ADD_EXT_ADV_PARAMS:
17174                         DBG("kernel supports ext adv commands");
17175                         kernel_features |= KERNEL_HAS_EXT_ADV_ADD_CMDS;
17176                         break;
17177                 case MGMT_OP_READ_CONTROLLER_CAP:
17178                         DBG("kernel supports controller cap command");
17179                         kernel_features |= KERNEL_HAS_CONTROLLER_CAP_CMD;
17180                         break;
17181                 default:
17182                         break;
17183                 }
17184         }
17185
17186         for (i = 0; i < num_events; i++) {
17187                 uint16_t ev = get_le16(rp->opcodes + num_commands + i);
17188
17189                 switch(ev) {
17190                 case MGMT_EV_CONTROLLER_RESUME:
17191                         DBG("kernel supports suspend/resume events");
17192                         kernel_features |= KERNEL_HAS_RESUME_EVT;
17193                         break;
17194                 }
17195         }
17196 }
17197
17198 static void read_version_complete(uint8_t status, uint16_t length,
17199                                         const void *param, void *user_data)
17200 {
17201         const struct mgmt_rp_read_version *rp = param;
17202
17203         if (status != MGMT_STATUS_SUCCESS) {
17204                 error("Failed to read version information: %s (0x%02x)",
17205                                                 mgmt_errstr(status), status);
17206                 return;
17207         }
17208
17209         if (length < sizeof(*rp)) {
17210                 error("Wrong size of read version response");
17211                 return;
17212         }
17213
17214         mgmt_version = rp->version;
17215         mgmt_revision = btohs(rp->revision);
17216
17217         info("Bluetooth management interface %u.%u initialized",
17218                                                 mgmt_version, mgmt_revision);
17219
17220         if (mgmt_version < 1) {
17221                 error("Version 1.0 or later of management interface required");
17222                 abort();
17223         }
17224
17225         DBG("sending read supported commands command");
17226
17227         /*
17228          * It is irrelevant if this command succeeds or fails. In case of
17229          * failure safe settings are assumed.
17230          */
17231         mgmt_send(mgmt_primary, MGMT_OP_READ_COMMANDS,
17232                                 MGMT_INDEX_NONE, 0, NULL,
17233                                 read_commands_complete, NULL, NULL);
17234
17235         mgmt_register(mgmt_primary, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
17236                                                 index_added, NULL, NULL);
17237         mgmt_register(mgmt_primary, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
17238                                                 index_removed, NULL, NULL);
17239
17240         DBG("sending read index list command");
17241
17242         if (mgmt_send(mgmt_primary, MGMT_OP_READ_INDEX_LIST,
17243                                 MGMT_INDEX_NONE, 0, NULL,
17244                                 read_index_list_complete, NULL, NULL) > 0)
17245                 return;
17246
17247         error("Failed to read controller index list");
17248 }
17249
17250 static void mgmt_debug(const char *str, void *user_data)
17251 {
17252         DBG_IDX(0xffff, "%s", str);
17253 }
17254
17255 int adapter_init(void)
17256 {
17257         dbus_conn = btd_get_dbus_connection();
17258
17259         mgmt_primary = mgmt_new_default();
17260         if (!mgmt_primary) {
17261                 error("Failed to access management interface");
17262                 return -EIO;
17263         }
17264
17265         mgmt_set_debug(mgmt_primary, mgmt_debug, NULL, NULL);
17266
17267         DBG("sending read version command");
17268
17269         if (mgmt_send(mgmt_primary, MGMT_OP_READ_VERSION,
17270                                 MGMT_INDEX_NONE, 0, NULL,
17271                                 read_version_complete, NULL, NULL) > 0)
17272                 return 0;
17273
17274         error("Failed to read management version information");
17275
17276         return -EIO;
17277 }
17278
17279 void adapter_cleanup(void)
17280 {
17281         g_list_free(adapter_list);
17282
17283         while (adapters) {
17284                 struct btd_adapter *adapter = adapters->data;
17285
17286                 adapter_remove(adapter);
17287                 adapters = g_slist_remove(adapters, adapter);
17288                 btd_adapter_unref(adapter);
17289         }
17290
17291         /*
17292          * In case there is another reference active, clear out
17293          * registered handlers for index added and index removed.
17294          *
17295          * This is just an extra precaution to be safe, and in
17296          * reality should not make a difference.
17297          */
17298         mgmt_unregister_index(mgmt_primary, MGMT_INDEX_NONE);
17299
17300         /*
17301          * In case there is another reference active, cancel
17302          * all pending global commands.
17303          *
17304          * This is just an extra precaution to avoid callbacks
17305          * that potentially then could leak memory or access
17306          * an invalid structure.
17307          */
17308         mgmt_cancel_index(mgmt_primary, MGMT_INDEX_NONE);
17309
17310         mgmt_unref(mgmt_primary);
17311         mgmt_primary = NULL;
17312
17313         dbus_conn = NULL;
17314 }
17315
17316 void adapter_shutdown(void)
17317 {
17318         GList *list;
17319
17320         DBG("");
17321
17322         powering_down = true;
17323
17324         for (list = g_list_first(adapter_list); list;
17325                                                 list = g_list_next(list)) {
17326                 struct btd_adapter *adapter = list->data;
17327
17328                 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
17329                         continue;
17330
17331                 clear_discoverable(adapter);
17332                 remove_temporary_devices(adapter);
17333                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x00);
17334
17335                 adapter_remaining++;
17336         }
17337
17338         if (!adapter_remaining)
17339                 btd_exit();
17340 }
17341
17342 /*
17343  * Check if workaround for broken ATT server socket behavior is needed
17344  * where we need to connect an ATT client socket before pairing to get
17345  * early access to the ATT channel.
17346  */
17347 bool btd_le_connect_before_pairing(void)
17348 {
17349         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 4))
17350                 return true;
17351
17352         return false;
17353 }
17354
17355 bool btd_adapter_has_settings(struct btd_adapter *adapter, uint32_t settings)
17356 {
17357         if (!adapter)
17358                 return false;
17359
17360         return (adapter->current_settings & settings) ? true : false;
17361 }
17362
17363 bool btd_has_kernel_features(uint32_t features)
17364 {
17365         return !!(kernel_features & features);
17366 }
17367
17368 bool btd_adapter_has_exp_feature(struct btd_adapter *adapter, uint32_t feature)
17369 {
17370         size_t i;
17371
17372         for (i = 0; i < ARRAY_SIZE(exp_table); i++) {
17373                 const struct exp_feat *feat = &exp_table[i];
17374
17375                 if ((feat->flag & feature) && queue_find(adapter->exps, NULL,
17376                                                         feat->uuid->val))
17377                 return true;
17378         }
17379
17380         return false;
17381 }
17382
17383 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
17384 int btd_adapter_set_streaming_mode(struct btd_adapter *adapter,
17385                                    const bdaddr_t *bdaddr, gboolean enable)
17386 {
17387         struct mgmt_cp_set_streaming_mode cp;
17388         char addr[18];
17389
17390         ba2str(bdaddr, addr);
17391         DBG("hci%u device %s", adapter->dev_id, addr);
17392
17393         memset(&cp, 0, sizeof(cp));
17394
17395         cp.streaming_mode = enable ? 1 : 0;
17396         bacpy(&cp.bdaddr, bdaddr);
17397
17398         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STREAMING_MODE,
17399                                         adapter->dev_id, sizeof(cp), &cp,
17400                                         NULL, NULL, NULL) > 0)
17401                 return 0;
17402
17403         return -EIO;
17404 }
17405
17406 void adapter_send_event(const char *event)
17407 {
17408         struct btd_adapter *adapter = btd_adapter_get_default();
17409         if (adapter == NULL) {
17410                 error("adapter is NULL");
17411                 return;
17412         }
17413
17414         g_dbus_emit_signal(dbus_conn, adapter->path,
17415                         ADAPTER_INTERFACE, event,
17416                         DBUS_TYPE_INVALID);
17417 }
17418
17419 #endif