src/adapter.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <inttypes.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <stdbool.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/file.h>
  37 #include <sys/stat.h>
  38 #include <dirent.h>
  39
  40 #include <glib.h>
  41 #include <dbus/dbus.h>
  42
  43 #include "bluetooth/bluetooth.h"
  44 #include "bluetooth/hci.h"
  45 #include "bluetooth/hci_lib.h"
  46 #include "bluetooth/sdp.h"
  47 #include "bluetooth/sdp_lib.h"
  48 #include "lib/uuid.h"
  49 #include "lib/mgmt.h"
  50
  51 #include "gdbus/gdbus.h"
  52
  53 #include "log.h"
  54 #include "textfile.h"
  55
  56 #include "src/shared/mgmt.h"
  57 #include "src/shared/util.h"
  58 #include "src/shared/queue.h"
  59 #include "src/shared/att.h"
  60 #include "src/shared/gatt-db.h"
  61
  62 #include "btio/btio.h"
  63 #include "hcid.h"
  64 #include "sdpd.h"
  65 #include "adapter.h"
  66 #include "device.h"
  67 #include "profile.h"
  68 #include "dbus-common.h"
  69 #include "error.h"
  70 #include "uuid-helper.h"
  71 #include "agent.h"
  72 #include "storage.h"
  73 #include "attrib/gattrib.h"
  74 #include "attrib/att.h"
  75 #include "attrib/gatt.h"
  76 #include "attrib-server.h"
  77 #include "gatt-database.h"
  78 #include "advertising.h"
  79 #include "eir.h"
  80
  81 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
  82 #include <ctype.h>
  83 #include "adapter_le_vsc_features.h"
  84 #include "../profile.h"
  85 #endif
  86
  87 #define ADAPTER_INTERFACE       "org.bluez.Adapter1"
  88
  89 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
  90 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
  91 #define DEVICED_DEST                    "org.tizen.system.deviced"
  92 #define DEVICED_BATT_INTERFACE          "org.tizen.system.deviced.Battery"
  93 #define DEVICED_BATT_OBJECT_PATH        "/Org/Tizen/System/DeviceD/Battery"
  94 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
  95 #endif
  96
  97 #define MODE_OFF                0x00
  98 #define MODE_CONNECTABLE        0x01
  99 #define MODE_DISCOVERABLE       0x02
 100 #define MODE_UNKNOWN            0xff
 101
 102 #define CONN_SCAN_TIMEOUT (3)
 103 #define IDLE_DISCOV_TIMEOUT (5)
 104 #define TEMP_DEV_TIMEOUT (3 * 60)
 105 #define BONDING_TIMEOUT (2 * 60)
 106
 107 #define SCAN_TYPE_BREDR (1 << BDADDR_BREDR)
 108 #define SCAN_TYPE_LE ((1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM))
 109 #define SCAN_TYPE_DUAL (SCAN_TYPE_BREDR | SCAN_TYPE_LE)
 110 #define SETTING_PRIVACY_MASK (1<<13)
 111
 112 #define HCI_RSSI_INVALID        127
 113 #define DISTANCE_VAL_INVALID    0x7FFF
 114 #define PATHLOSS_MAX            137
 115
 116 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 117 #define ADV_DATA_MAX_LENGTH 31
 118 #define SCAN_RESPONSE_DATA_LENGTH_MAX 31
 119 #define EIR_MANUFACTURER_DATA_LENGTH_MAX 100
 120
 121 #define LE_BEARER_POSTFIX       " LE"
 122 #define LE_BEARER_POSTFIX_LEN   3
 123 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
 124
 125
 126 static DBusConnection *dbus_conn = NULL;
 127
 128 static bool kernel_conn_control = false;
 129
 130 static GList *adapter_list = NULL;
 131 static unsigned int adapter_remaining = 0;
 132 static bool powering_down = false;
 133
 134 static GSList *adapters = NULL;
 135
 136 static struct mgmt *mgmt_master = NULL;
 137
 138 static uint8_t mgmt_version = 0;
 139 static uint8_t mgmt_revision = 0;
 140
 141 static GSList *adapter_drivers = NULL;
 142
 143 static GSList *disconnect_list = NULL;
 144 static GSList *conn_fail_list = NULL;
 145
 146 struct link_key_info {
 147         bdaddr_t bdaddr;
 148         unsigned char key[16];
 149         uint8_t type;
 150         uint8_t pin_len;
 151 };
 152
 153 struct smp_ltk_info {
 154         bdaddr_t bdaddr;
 155         uint8_t bdaddr_type;
 156         uint8_t authenticated;
 157         bool master;
 158         uint8_t enc_size;
 159         uint16_t ediv;
 160         uint64_t rand;
 161         uint8_t val[16];
 162 };
 163
 164 struct irk_info {
 165         bdaddr_t bdaddr;
 166         uint8_t bdaddr_type;
 167         uint8_t val[16];
 168 };
 169
 170 struct conn_param {
 171         bdaddr_t bdaddr;
 172         uint8_t  bdaddr_type;
 173         uint16_t min_interval;
 174         uint16_t max_interval;
 175         uint16_t latency;
 176         uint16_t timeout;
 177 };
 178
 179 struct discovery_filter {
 180         uint8_t type;
 181         uint16_t pathloss;
 182         int16_t rssi;
 183         GSList *uuids;
 184         bool duplicate;
 185         bool discoverable;
 186 };
 187
 188 struct watch_client {
 189         struct btd_adapter *adapter;
 190         DBusMessage *msg;
 191         char *owner;
 192         guint watch;
 193         struct discovery_filter *discovery_filter;
 194 };
 195
 196 struct service_auth {
 197         guint id;
 198         unsigned int svc_id;
 199         service_auth_cb cb;
 200         void *user_data;
 201         const char *uuid;
 202         struct btd_device *device;
 203         struct btd_adapter *adapter;
 204         struct agent *agent;            /* NULL for queued auths */
 205 };
 206
 207 struct btd_adapter_pin_cb_iter {
 208         GSList *it;                     /* current callback function */
 209         unsigned int attempt;           /* numer of times it() was called */
 210         /* When the iterator reaches the end, it is NULL and attempt is 0 */
 211 };
 212
 213 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 214 struct adv_info {
 215         int slot_id;    /* Reservied slot id is 0 (Single adv) */
 216         bool status;            /* Advertising status */
 217 };
 218
 219 static GSList *read_requests = NULL;
 220
 221 struct le_data_length_read_request {
 222         struct btd_adapter *adapter;
 223         DBusMessage *msg;
 224 };
 225
 226 struct le_batching_request {
 227         struct btd_adapter *adapter;
 228         DBusMessage *msg;
 229 };
 230
 231 struct le_batching_set_param_request {
 232         struct btd_adapter *adapter;
 233         DBusMessage *msg;
 234         bdaddr_t bdaddr;
 235 };
 236 #endif
 237
 238 struct btd_adapter {
 239         int ref_count;
 240
 241         uint16_t dev_id;
 242         struct mgmt *mgmt;
 243
 244         bdaddr_t bdaddr;                /* controller Bluetooth address */
 245 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 246         bdaddr_t le_static_addr;
 247         bdaddr_t rpa;
 248 #endif
 249         uint8_t bdaddr_type;            /* address type */
 250         uint32_t dev_class;             /* controller class of device */
 251         char *name;                     /* controller device name */
 252         char *short_name;               /* controller short name */
 253         uint32_t supported_settings;    /* controller supported settings */
 254         uint32_t pending_settings;      /* pending controller settings */
 255         uint32_t current_settings;      /* current controller settings */
 256
 257         char *path;                     /* adapter object path */
 258         uint16_t manufacturer;          /* adapter manufacturer */
 259         uint8_t major_class;            /* configured major class */
 260         uint8_t minor_class;            /* configured minor class */
 261         char *system_name;              /* configured system name */
 262         char *modalias;                 /* device id (modalias) */
 263         bool stored_discoverable;       /* stored discoverable mode */
 264         uint32_t discoverable_timeout;  /* discoverable time(sec) */
 265         uint32_t pairable_timeout;      /* pairable time(sec) */
 266
 267         char *current_alias;            /* current adapter name alias */
 268         char *stored_alias;             /* stored adapter name alias */
 269 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 270         uint8_t *local_irk;     /* adapter local IRK */
 271         uint8_t disc_type;
 272         bool ipsp_intialized;           /* Ipsp Initialization state */
 273         struct le_data_length_read_handler *read_handler;
 274         struct le_data_length_read_default_data_length_handler *def_read_handler;
 275 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 276         guint charging_watch;
 277         guint charging_timeout;
 278         charging_state_e charging;
 279 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 280 #endif
 281
 282         bool discovering;               /* discovering property state */
 283         bool filtered_discovery;        /* we are doing filtered discovery */
 284         bool no_scan_restart_delay;     /* when this flag is set, restart scan
 285                                          * without delay */
 286         uint8_t discovery_type;         /* current active discovery type */
 287         uint8_t discovery_enable;       /* discovery enabled/disabled */
 288         bool discovery_suspended;       /* discovery has been suspended */
 289         bool discovery_discoverable;    /* discoverable while discovering */
 290         GSList *discovery_list;         /* list of discovery clients */
 291         GSList *set_filter_list;        /* list of clients that specified
 292                                          * filter, but don't scan yet
 293                                          */
 294         /* current discovery filter, if any */
 295         struct mgmt_cp_start_service_discovery *current_discovery_filter;
 296
 297         GSList *discovery_found;        /* list of found devices */
 298         guint discovery_idle_timeout;   /* timeout between discovery runs */
 299 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 300         guint le_discovery_idle_timeout;        /* timeout between le discovery runs */
 301 #endif
 302         guint passive_scan_timeout;     /* timeout between passive scans */
 303         guint temp_devices_timeout;     /* timeout for temporary devices */
 304
 305         guint pairable_timeout_id;      /* pairable timeout id */
 306         guint auth_idle_id;             /* Pending authorization dequeue */
 307         GQueue *auths;                  /* Ongoing and pending auths */
 308         bool pincode_requested;         /* PIN requested during last bonding */
 309         GSList *connections;            /* Connected devices */
 310         GSList *devices;                /* Devices structure pointers */
 311         GSList *connect_list;           /* Devices to connect when found */
 312         struct btd_device *connect_le;  /* LE device waiting to be connected */
 313         sdp_list_t *services;           /* Services associated to adapter */
 314
 315         struct btd_gatt_database *database;
 316         struct btd_adv_manager *adv_manager;
 317
 318         gboolean initialized;
 319 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 320         GSList *adv_list;       /* List of advertising instance */
 321         bool advertising;               /* Advertising active */
 322         gchar *version;                 /* Bluetooth Version */
 323         uint8_t adv_tx_power;
 324         guint adv_restart_timeout;
 325         bool le_discovering;                    /* LE Discovery active */
 326         GSList *le_discovery_list;              /* list of LE discovery clients */
 327 #endif
 328
 329         GSList *pin_callbacks;
 330         GSList *msd_callbacks;
 331
 332         GSList *drivers;
 333         GSList *profiles;
 334
 335         struct oob_handler *oob_handler;
 336
 337         unsigned int load_ltks_id;
 338         guint load_ltks_timeout;
 339
 340         unsigned int confirm_name_id;
 341         guint confirm_name_timeout;
 342
 343         unsigned int pair_device_id;
 344         guint pair_device_timeout;
 345
 346         unsigned int db_id;             /* Service event handler for GATT db */
 347 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 348         uint8_t central_rpa_res_support;
 349         bluetooth_a2dp_role_t a2dp_role;
 350 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
 351         bool scan_filter_support;               /* platform's scan filtering support */
 352         uint8_t scan_type;              /* scan type */
 353         GSList *scan_params;    /* scan filter parameters */
 354         GSList *addr_filters;   /* adress scan filters list */
 355         GSList *service_data_changed_filters;   /* service data changed scan filters list */
 356         GSList *service_uuid_filters;   /* service uuid scan filters list */
 357         GSList *solicit_data_filters;   /* solicitation data scan filters list */
 358         GSList *local_name_filters;     /* local name scan filters list */
 359         GSList *manufaturer_data_filters;       /* manufacturer data scan filters list */
 360         GSList *service_data_filters;   /* service data scan filters list */
 361 #endif
 362 #endif
 363         bool is_default;                /* true if adapter is default one */
 364
 365 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 366         bool le_2m_phy_supported;
 367         bool le_coded_phy_supported;
 368         guint le_batching_available_pkts;
 369 #endif
 370 };
 371
 372 typedef enum {
 373         ADAPTER_AUTHORIZE_DISCONNECTED = 0,
 374         ADAPTER_AUTHORIZE_CHECK_CONNECTED
 375 } adapter_authorize_type;
 376
 377 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 378 enum {
 379         DEINIT_6LOWPAN,
 380         INIT_6LOWPAN
 381 };
 382 #endif
 383
 384 static struct btd_adapter *btd_adapter_lookup(uint16_t index)
 385 {
 386         GList *list;
 387
 388         for (list = g_list_first(adapter_list); list;
 389                                                 list = g_list_next(list)) {
 390                 struct btd_adapter *adapter = list->data;
 391
 392                 if (adapter->dev_id == index)
 393                         return adapter;
 394         }
 395
 396         return NULL;
 397 }
 398
 399 struct btd_adapter *btd_adapter_get_default(void)
 400 {
 401         GList *list;
 402
 403         for (list = g_list_first(adapter_list); list;
 404                                                 list = g_list_next(list)) {
 405                 struct btd_adapter *adapter = list->data;
 406
 407                 if (adapter->is_default)
 408                         return adapter;
 409         }
 410
 411         return NULL;
 412 }
 413
 414 bool btd_adapter_is_default(struct btd_adapter *adapter)
 415 {
 416         if (!adapter)
 417                 return false;
 418
 419         return adapter->is_default;
 420 }
 421
 422 uint16_t btd_adapter_get_index(struct btd_adapter *adapter)
 423 {
 424         if (!adapter)
 425                 return MGMT_INDEX_NONE;
 426
 427         return adapter->dev_id;
 428 }
 429
 430 static gboolean process_auth_queue(gpointer user_data);
 431
 432 static void dev_class_changed_callback(uint16_t index, uint16_t length,
 433                                         const void *param, void *user_data)
 434 {
 435         struct btd_adapter *adapter = user_data;
 436         const struct mgmt_cod *rp = param;
 437         uint32_t dev_class;
 438
 439         if (length < sizeof(*rp)) {
 440                 btd_error(adapter->dev_id,
 441                         "Wrong size of class of device changed parameters");
 442                 return;
 443         }
 444
 445         dev_class = rp->val[0] | (rp->val[1] << 8) | (rp->val[2] << 16);
 446
 447         if (dev_class == adapter->dev_class)
 448                 return;
 449
 450         DBG("Class: 0x%06x", dev_class);
 451
 452         adapter->dev_class = dev_class;
 453
 454         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 455                                                 ADAPTER_INTERFACE, "Class");
 456 }
 457
 458 static void set_dev_class_complete(uint8_t status, uint16_t length,
 459                                         const void *param, void *user_data)
 460 {
 461         struct btd_adapter *adapter = user_data;
 462
 463         if (status != MGMT_STATUS_SUCCESS) {
 464                 btd_error(adapter->dev_id,
 465                                 "Failed to set device class: %s (0x%02x)",
 466                                                 mgmt_errstr(status), status);
 467                 return;
 468         }
 469
 470         /*
 471          * The parameters are identical and also the task that is
 472          * required in both cases. So it is safe to just call the
 473          * event handling functions here.
 474          */
 475         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
 476 }
 477
 478 static void set_dev_class(struct btd_adapter *adapter)
 479 {
 480         struct mgmt_cp_set_dev_class cp;
 481
 482         /*
 483          * If the controller does not support BR/EDR operation,
 484          * there is no point in trying to set a major and minor
 485          * class value.
 486          *
 487          * This is an optimization for Low Energy only controllers.
 488          */
 489         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
 490                 return;
 491
 492         memset(&cp, 0, sizeof(cp));
 493
 494         /*
 495          * Silly workaround for a really stupid kernel bug :(
 496          *
 497          * All current kernel versions assign the major and minor numbers
 498          * straight to dev_class[0] and dev_class[1] without considering
 499          * the proper bit shifting.
 500          *
 501          * To make this work, shift the value in userspace for now until
 502          * we get a fixed kernel version.
 503          */
 504         cp.major = adapter->major_class & 0x1f;
 505         cp.minor = adapter->minor_class << 2;
 506
 507         DBG("sending set device class command for index %u", adapter->dev_id);
 508
 509         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_CLASS,
 510                                 adapter->dev_id, sizeof(cp), &cp,
 511                                 set_dev_class_complete, adapter, NULL) > 0)
 512                 return;
 513
 514         btd_error(adapter->dev_id,
 515                 "Failed to set class of device for index %u", adapter->dev_id);
 516 }
 517
 518 void btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
 519                                                         uint8_t minor)
 520 {
 521         if (adapter->major_class == major && adapter->minor_class == minor)
 522                 return;
 523
 524         DBG("class: major %u minor %u", major, minor);
 525
 526         adapter->major_class = major;
 527         adapter->minor_class = minor;
 528
 529         set_dev_class(adapter);
 530 }
 531
 532 static uint8_t get_mode(const char *mode)
 533 {
 534         if (strcasecmp("off", mode) == 0)
 535                 return MODE_OFF;
 536         else if (strcasecmp("connectable", mode) == 0)
 537                 return MODE_CONNECTABLE;
 538         else if (strcasecmp("discoverable", mode) == 0)
 539                 return MODE_DISCOVERABLE;
 540         else
 541                 return MODE_UNKNOWN;
 542 }
 543
 544 const char *btd_adapter_get_storage_dir(struct btd_adapter *adapter)
 545 {
 546         static char dir[25];
 547
 548         if (adapter->bdaddr_type == BDADDR_LE_RANDOM) {
 549                 strcpy(dir, "static-");
 550                 ba2str(&adapter->bdaddr, dir + 7);
 551         } else {
 552                 ba2str(&adapter->bdaddr, dir);
 553         }
 554
 555         return dir;
 556 }
 557
 558 uint8_t btd_adapter_get_address_type(struct btd_adapter *adapter)
 559 {
 560         return adapter->bdaddr_type;
 561 }
 562
 563 static void store_adapter_info(struct btd_adapter *adapter)
 564 {
 565         GKeyFile *key_file;
 566         char filename[PATH_MAX];
 567         char *str;
 568         gsize length = 0;
 569         gboolean discoverable;
 570
 571         key_file = g_key_file_new();
 572
 573         if (adapter->pairable_timeout != main_opts.pairto)
 574                 g_key_file_set_integer(key_file, "General", "PairableTimeout",
 575                                         adapter->pairable_timeout);
 576
 577         if ((adapter->current_settings & MGMT_SETTING_DISCOVERABLE) &&
 578                                                 !adapter->discoverable_timeout)
 579                 discoverable = TRUE;
 580         else
 581                 discoverable = FALSE;
 582
 583         g_key_file_set_boolean(key_file, "General", "Discoverable",
 584                                                         discoverable);
 585
 586         if (adapter->discoverable_timeout != main_opts.discovto)
 587                 g_key_file_set_integer(key_file, "General",
 588                                         "DiscoverableTimeout",
 589                                         adapter->discoverable_timeout);
 590
 591         if (adapter->stored_alias)
 592                 g_key_file_set_string(key_file, "General", "Alias",
 593                                                         adapter->stored_alias);
 594 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 595         /* Store A2DP Role */
 596         if (adapter->a2dp_role == BLUETOOTH_A2DP_SINK_ROLE)
 597                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "sink");
 598         else
 599                 g_key_file_set_string(key_file, "General", "DefaultA2DPRole", "source");
 600 #endif
 601
 602         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/settings",
 603                                                 btd_adapter_get_storage_dir(adapter));
 604
 605         create_file(filename, S_IRUSR | S_IWUSR);
 606
 607         str = g_key_file_to_data(key_file, &length, NULL);
 608         g_file_set_contents(filename, str, length, NULL);
 609         g_free(str);
 610
 611         g_key_file_free(key_file);
 612 }
 613
 614 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 615 bluetooth_a2dp_role_t btd_adapter_get_a2dp_role(struct btd_adapter *adapter)
 616 {
 617         if (!adapter)
 618                 return BLUETOOTH_A2DP_SOURCE_ROLE;
 619
 620         return adapter->a2dp_role;
 621 }
 622
 623 void btd_adapter_set_a2dp_role(struct btd_adapter *adapter, bluetooth_a2dp_role_t role)
 624 {
 625         if (!adapter) {
 626                 DBG("Could not set a2dp role");
 627                 return;
 628         }
 629
 630         if (role == BLUETOOTH_A2DP_SOURCE_ROLE) {
 631                 DBG("Set audio source role");
 632                 adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
 633         } else if (role == BLUETOOTH_A2DP_SINK_ROLE) {
 634                 DBG("Set audio sink role");
 635                 adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
 636         }
 637
 638         store_adapter_info(adapter);
 639 }
 640
 641 void btd_adapter_emit_a2dp_role_changed(struct btd_adapter *adapter)
 642 {
 643         if (!adapter) {
 644                 DBG("Could not emit signal for a2dp role");
 645                 return;
 646         }
 647
 648         DBG("A2dp role: %u", adapter->a2dp_role);
 649
 650         g_dbus_emit_property_changed(dbus_conn, adapter->path,
 651                         ADAPTER_INTERFACE, "A2dpRole");
 652 }
 653 #endif
 654
 655 static void trigger_pairable_timeout(struct btd_adapter *adapter);
 656 static void adapter_start(struct btd_adapter *adapter);
 657 static void adapter_stop(struct btd_adapter *adapter);
 658 static void trigger_passive_scanning(struct btd_adapter *adapter);
 659 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
 660                                                         uint8_t mode);
 661 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 662 static bool load_local_irk(struct btd_adapter *adapter);
 663 static bool set_local_irk(struct btd_adapter *adapter);
 664 static bool set_privacy(struct btd_adapter *adapter, bool privacy);
 665 #endif
 666
 667 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 668 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
 669 static gboolean charging_state_timeout_cb(gpointer user_data)
 670 {
 671         struct btd_adapter *adapter = user_data;
 672         int bredr_pkt_type = ACL_PTYPE_MASK;
 673
 674         adapter->charging_timeout = 0;
 675
 676         DBG("Set all connections to BR/EDR type");
 677         g_slist_foreach(adapter->devices, device_change_pkt_type,
 678                         (gpointer)bredr_pkt_type);
 679
 680         return FALSE;
 681 }
 682
 683 static void set_charging_state(struct btd_adapter *adapter,
 684                 charging_state_e state)
 685 {
 686         int br_pkt_type = ACL_PTYPE_MASK |
 687                 HCI_2DH1 | HCI_2DH3 | HCI_2DH5 |
 688                 HCI_3DH1 | HCI_3DH3 | HCI_3DH5;
 689
 690         if (adapter->charging == state)
 691                 return;
 692
 693         DBG("old charging state : %d, new charging_state : %d",
 694                         adapter->charging, state);
 695
 696         /*
 697          * Only none / wire charging <-> wireless charging state change should
 698          * be handled.
 699          */
 700         if ((adapter->charging == NONE_CHARGING && state == WIRE_CHARGING) ||
 701             (adapter->charging == WIRE_CHARGING && state == NONE_CHARGING)) {
 702                 DBG("Just update charging state");
 703                 adapter->charging = state;
 704                 return;
 705         }
 706
 707         if (adapter->charging_timeout) {
 708                 g_source_remove(adapter->charging_timeout);
 709                 adapter->charging_timeout = 0;
 710         }
 711
 712         adapter->charging = state;
 713         if (adapter->charging == NONE_CHARGING ||
 714             adapter->charging == WIRE_CHARGING) {
 715                 DBG("Trigger timeout to set connection to BR/EDR type");
 716                 adapter->charging_timeout = g_timeout_add(2000,
 717                                 charging_state_timeout_cb, adapter);
 718         } else if (adapter->charging == WIRELESS_CHARGING) {
 719                 DBG("Set all connections to BR type");
 720                 g_slist_foreach(adapter->devices, device_change_pkt_type,
 721                                 (gpointer)br_pkt_type);
 722         }
 723
 724         return;
 725 }
 726
 727 static gboolean charging_state_changed(DBusConnection *connection,
 728                 DBusMessage *msg, void *user_data)
 729 {
 730         struct btd_adapter *adapter = user_data;
 731         int state = 0;
 732
 733         DBG("charging_state_changed");
 734
 735         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &state,
 736                                 DBUS_TYPE_INVALID))
 737                 return TRUE;
 738
 739         set_charging_state(adapter, state);
 740
 741         return TRUE;
 742 }
 743
 744 charging_state_e get_charging_state(struct btd_adapter *adapter)
 745 {
 746         DBG("charging_state: %d", adapter->charging);
 747         return adapter->charging;
 748 }
 749 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
 750
 751 static int compare_slot(gconstpointer a, gconstpointer b)
 752 {
 753         const struct adv_info *adv = a;
 754         const int id = *(int*)b;
 755
 756         return (adv->slot_id == id ? 0 : -1);
 757 }
 758
 759 static struct adv_info *find_advertiser(struct btd_adapter *adapter,
 760                                 int slot_id)
 761 {
 762         GSList *list;
 763
 764         list = g_slist_find_custom(adapter->adv_list, &slot_id,
 765                                                         compare_slot);
 766         if (list)
 767                 return list->data;
 768
 769         return NULL;
 770 }
 771
 772 static struct adv_info *create_advertiser(struct btd_adapter *adapter,
 773                                         int slot_id)
 774 {
 775         struct adv_info *adv;
 776
 777         if (!adapter)
 778                 return NULL;
 779
 780         adv = find_advertiser(adapter, slot_id);
 781         if (adv != NULL) {
 782                 DBG("Aleady existed. solt_id [%d]", slot_id);
 783                 return adv;
 784         }
 785
 786         DBG("Create adv slot id : %d", slot_id);
 787
 788         adv = g_new0(struct adv_info, 1);
 789         if (adv == NULL)
 790                 return NULL;
 791
 792         adv->slot_id = slot_id;
 793
 794         adapter->adv_list = g_slist_append(adapter->adv_list, adv);
 795         return adv;
 796 }
 797
 798
 799 static void advertising_state_changed(struct btd_adapter *adapter,
 800                                         int slot_id, bool enabled)
 801 {
 802         struct adv_info *adv;
 803         int id = slot_id;
 804         int state = enabled;
 805
 806         if (!adapter)
 807                 return;
 808
 809         adv = find_advertiser(adapter, slot_id);
 810         if (!adv) {
 811                 DBG("Unable to find advertiser [%d]", slot_id);
 812                 return;
 813         }
 814
 815         adv->status = enabled;
 816         DBG("slot_id %d, status %d", adv->slot_id, adv->status);
 817
 818         g_dbus_emit_signal(dbus_conn, adapter->path,
 819                         ADAPTER_INTERFACE, "AdvertisingEnabled",
 820                         DBUS_TYPE_INT32, &id,
 821                         DBUS_TYPE_BOOLEAN, &state,
 822                         DBUS_TYPE_INVALID);
 823 }
 824
 825 static void clear_advertiser_cb(gpointer data, gpointer user_data)
 826 {
 827         struct adv_info *adv = data;
 828         struct btd_adapter *adapter = user_data;
 829
 830         if (adv->status)
 831                 advertising_state_changed(adapter, adv->slot_id, 0);
 832 }
 833
 834 static void advertiser_cleanup(struct btd_adapter *adapter)
 835 {
 836         if (!adapter->adv_list)
 837                 return;
 838
 839         g_slist_foreach(adapter->adv_list, clear_advertiser_cb, adapter);
 840         g_slist_free(adapter->adv_list);
 841         adapter->adv_list = NULL;
 842 }
 843
 844 static void update_advertiser_address(gpointer data, gpointer user_data)
 845 {
 846         struct adv_info *adv = data;
 847         struct btd_adapter *adapter = user_data;
 848
 849         if (adv->slot_id > 0 && adv->status == 1)
 850                 adapter_le_set_random_address(adapter, &adapter->rpa, adv->slot_id);
 851 }
 852
 853 static void rpa_changed_callback(uint16_t index, uint16_t length,
 854                                         const void *param, void *user_data)
 855 {
 856         const struct mgmt_ev_rpa_changed *ev = param;
 857         struct btd_adapter *adapter = user_data;
 858         char addr[18];
 859
 860         if (length < sizeof(*ev)) {
 861                 error("Too small rpa changed event");
 862                 return;
 863         }
 864
 865         ba2str(&ev->bdaddr, addr);
 866         DBG("RPA changed %s", addr);
 867         bacpy(&adapter->rpa, &ev->bdaddr);
 868
 869         if (!adapter->adv_list)
 870                 return;
 871
 872         g_slist_foreach(adapter->adv_list, update_advertiser_address, adapter);
 873 }
 874
 875 #endif
 876
 877 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 878 #define OCF_PAGE_SCAN_TIMEOUT                   0x0018
 879 #define OGF_PAGE_SCAN_TIMEOUT           0x03
 880
 881 typedef struct {
 882         uint16_t        timeout;        /* Value */
 883 } __attribute__ ((packed)) hci_page_scan_timeout;
 884 #define HCI_PAGE_SCAN_TIMEOUT_CP_SIZE 2
 885
 886 static gboolean send_sprd_page_scan_timeout(gint value)
 887 {
 888         int dd;
 889         hci_page_scan_timeout cp;
 890         DBG("+");
 891         dd = hci_open_dev(0);
 892         cp.timeout = value;
 893         if (hci_send_cmd(dd, OGF_PAGE_SCAN_TIMEOUT, OCF_PAGE_SCAN_TIMEOUT,
 894                                 HCI_PAGE_SCAN_TIMEOUT_CP_SIZE, &cp) < 0) {
 895                 DBG("Error: While setting Page Timeout value");
 896                 hci_close_dev(dd);
 897                 return FALSE;
 898         }
 899         DBG("Page Scan Timeout Value Patch %d", value);
 900
 901         hci_close_dev(dd);
 902
 903         return TRUE;
 904 }
 905 #endif
 906
 907 static void settings_changed(struct btd_adapter *adapter, uint32_t settings)
 908 {
 909         uint32_t changed_mask;
 910
 911         changed_mask = adapter->current_settings ^ settings;
 912
 913         adapter->current_settings = settings;
 914         adapter->pending_settings &= ~changed_mask;
 915
 916         DBG("Changed settings: 0x%08x", changed_mask);
 917         DBG("Pending settings: 0x%08x", adapter->pending_settings);
 918
 919         if (changed_mask & MGMT_SETTING_POWERED) {
 920                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 921                                         ADAPTER_INTERFACE, "Powered");
 922
 923                 if (adapter->current_settings & MGMT_SETTING_POWERED) {
 924                         adapter_start(adapter);
 925
 926 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 927                         if (TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN) {
 928                                 /* Approx 6.4 Seconds of timeout */
 929                                 /* This Added because Z3 device was not able to connect with
 930                                   * some device as it was getting Page Timeout
 931                                   * (LG HBS800, sony carkit) etc. So, Increasing Page timeout value
 932                                   * from 5.12 Sec (which is default) to ~6.4sec*/
 933                                 DBG("Setting value");
 934                                 send_sprd_page_scan_timeout(10240);
 935                         }
 936 #endif
 937                 } else {
 938                         adapter_stop(adapter);
 939
 940                         if (powering_down) {
 941                                 adapter_remaining--;
 942
 943                                 if (!adapter_remaining)
 944                                         btd_exit();
 945                         }
 946                 }
 947         }
 948
 949         if (changed_mask & MGMT_SETTING_LE) {
 950                 if ((adapter->current_settings & MGMT_SETTING_POWERED) &&
 951                                 (adapter->current_settings & MGMT_SETTING_LE))
 952                         trigger_passive_scanning(adapter);
 953         }
 954
 955         if (changed_mask & MGMT_SETTING_DISCOVERABLE) {
 956                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 957                                         ADAPTER_INTERFACE, "Discoverable");
 958                 store_adapter_info(adapter);
 959                 btd_adv_manager_refresh(adapter->adv_manager);
 960         }
 961
 962         if (changed_mask & MGMT_SETTING_BONDABLE) {
 963                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
 964                                         ADAPTER_INTERFACE, "Pairable");
 965
 966                 trigger_pairable_timeout(adapter);
 967         }
 968
 969 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 970         if (changed_mask & MGMT_SETTING_ADVERTISING) {
 971                 if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
 972                         (adapter->advertising)) {
 973                         return;
 974                 }
 975
 976                 adapter->advertising = adapter->current_settings & MGMT_SETTING_ADVERTISING;
 977                 advertising_state_changed(adapter, 0, adapter->advertising);
 978         }
 979
 980         if ((changed_mask & MGMT_SETTING_PRIVACY) &&
 981             !(adapter->current_settings & MGMT_SETTING_PRIVACY)) {
 982                 DBG("LE Privacy feature is disabled");
 983
 984                 /*
 985                  * Some Android devices don't consider the device as LE one,
 986                  * if the device doesn't distribute IRK when pairing.
 987                  * Because of this compatibility issue, set IRK
 988                  * even though privacy feature is disabled.
 989                  */
 990                 set_local_irk(adapter);
 991         }
 992 #endif
 993 }
 994
 995 static void new_settings_callback(uint16_t index, uint16_t length,
 996                                         const void *param, void *user_data)
 997 {
 998         struct btd_adapter *adapter = user_data;
 999         uint32_t settings;
1000
1001         if (length < sizeof(settings)) {
1002                 btd_error(adapter->dev_id,
1003                                 "Wrong size of new settings parameters");
1004                 return;
1005         }
1006
1007         settings = get_le32(param);
1008
1009         if (settings == adapter->current_settings)
1010                 return;
1011
1012         DBG("Settings: 0x%08x", settings);
1013
1014         settings_changed(adapter, settings);
1015 }
1016
1017 static void set_mode_complete(uint8_t status, uint16_t length,
1018                                         const void *param, void *user_data)
1019 {
1020         struct btd_adapter *adapter = user_data;
1021
1022         if (status != MGMT_STATUS_SUCCESS) {
1023                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
1024                                                 mgmt_errstr(status), status);
1025                 return;
1026         }
1027
1028         /*
1029          * The parameters are identical and also the task that is
1030          * required in both cases. So it is safe to just call the
1031          * event handling functions here.
1032          */
1033         new_settings_callback(adapter->dev_id, length, param, adapter);
1034 }
1035
1036 static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
1037                                                         uint8_t mode)
1038 {
1039         struct mgmt_mode cp;
1040         uint32_t setting = 0;
1041
1042         memset(&cp, 0, sizeof(cp));
1043         cp.val = mode;
1044
1045         switch (mode) {
1046         case MGMT_OP_SET_POWERED:
1047                 setting = MGMT_SETTING_POWERED;
1048                 break;
1049         case MGMT_OP_SET_CONNECTABLE:
1050                 setting = MGMT_SETTING_CONNECTABLE;
1051                 break;
1052         case MGMT_OP_SET_FAST_CONNECTABLE:
1053                 setting = MGMT_SETTING_FAST_CONNECTABLE;
1054                 break;
1055         case MGMT_OP_SET_DISCOVERABLE:
1056                 setting = MGMT_SETTING_DISCOVERABLE;
1057                 break;
1058         case MGMT_OP_SET_BONDABLE:
1059                 setting = MGMT_SETTING_DISCOVERABLE;
1060                 break;
1061         }
1062
1063         adapter->pending_settings |= setting;
1064
1065         DBG("sending set mode command for index %u", adapter->dev_id);
1066
1067         if (mgmt_send(adapter->mgmt, opcode,
1068                                 adapter->dev_id, sizeof(cp), &cp,
1069                                 set_mode_complete, adapter, NULL) > 0)
1070                 return true;
1071
1072         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1073                                                         adapter->dev_id);
1074
1075         return false;
1076 }
1077
1078 static bool set_discoverable(struct btd_adapter *adapter, uint8_t mode,
1079                                                         uint16_t timeout)
1080 {
1081         struct mgmt_cp_set_discoverable cp;
1082
1083         memset(&cp, 0, sizeof(cp));
1084         cp.val = mode;
1085         cp.timeout = htobs(timeout);
1086
1087         DBG("sending set mode command for index %u", adapter->dev_id);
1088
1089         if (kernel_conn_control) {
1090                 if (mode)
1091                         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, mode);
1092                 else
1093                         /* This also disables discoverable so we're done */
1094                         return set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
1095                                                                         mode);
1096         }
1097
1098         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DISCOVERABLE,
1099                                 adapter->dev_id, sizeof(cp), &cp,
1100                                 set_mode_complete, adapter, NULL) > 0)
1101                 return true;
1102
1103         btd_error(adapter->dev_id, "Failed to set mode for index %u",
1104                                                         adapter->dev_id);
1105
1106         return false;
1107 }
1108
1109 static gboolean pairable_timeout_handler(gpointer user_data)
1110 {
1111         struct btd_adapter *adapter = user_data;
1112
1113         adapter->pairable_timeout_id = 0;
1114
1115         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
1116
1117         return FALSE;
1118 }
1119
1120 static void trigger_pairable_timeout(struct btd_adapter *adapter)
1121 {
1122         if (adapter->pairable_timeout_id > 0) {
1123                 g_source_remove(adapter->pairable_timeout_id);
1124                 adapter->pairable_timeout_id = 0;
1125         }
1126
1127         if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
1128                 return;
1129
1130         if (adapter->pairable_timeout > 0)
1131                 adapter->pairable_timeout_id =
1132                         g_timeout_add_seconds(adapter->pairable_timeout,
1133                                         pairable_timeout_handler, adapter);
1134 }
1135
1136 static void local_name_changed_callback(uint16_t index, uint16_t length,
1137                                         const void *param, void *user_data)
1138 {
1139         struct btd_adapter *adapter = user_data;
1140         const struct mgmt_cp_set_local_name *rp = param;
1141
1142         if (length < sizeof(*rp)) {
1143                 btd_error(adapter->dev_id,
1144                                 "Wrong size of local name changed parameters");
1145                 return;
1146         }
1147
1148         if (!g_strcmp0(adapter->short_name, (const char *) rp->short_name) &&
1149                         !g_strcmp0(adapter->name, (const char *) rp->name))
1150                 return;
1151
1152         DBG("Name: %s", rp->name);
1153         DBG("Short name: %s", rp->short_name);
1154
1155         g_free(adapter->name);
1156         adapter->name = g_strdup((const char *) rp->name);
1157
1158         g_free(adapter->short_name);
1159         adapter->short_name = g_strdup((const char *) rp->short_name);
1160
1161         /*
1162          * Changing the name (even manually via HCI) will update the
1163          * current alias property.
1164          *
1165          * In case the name is empty, use the short name.
1166          *
1167          * There is a difference between the stored alias (which is
1168          * configured by the user) and the current alias. The current
1169          * alias is temporary for the lifetime of the daemon.
1170          */
1171         if (adapter->name && adapter->name[0] != '\0') {
1172                 g_free(adapter->current_alias);
1173                 adapter->current_alias = g_strdup(adapter->name);
1174         } else {
1175                 g_free(adapter->current_alias);
1176                 adapter->current_alias = g_strdup(adapter->short_name);
1177         }
1178
1179         DBG("Current alias: %s", adapter->current_alias);
1180
1181         if (!adapter->current_alias)
1182                 return;
1183
1184         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1185                                                 ADAPTER_INTERFACE, "Alias");
1186
1187         attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
1188                                 (const uint8_t *) adapter->current_alias,
1189                                         strlen(adapter->current_alias));
1190 }
1191
1192 static void set_local_name_complete(uint8_t status, uint16_t length,
1193                                         const void *param, void *user_data)
1194 {
1195         struct btd_adapter *adapter = user_data;
1196
1197         if (status != MGMT_STATUS_SUCCESS) {
1198                 btd_error(adapter->dev_id,
1199                                 "Failed to set local name: %s (0x%02x)",
1200                                                 mgmt_errstr(status), status);
1201                 return;
1202         }
1203
1204         /*
1205          * The parameters are identical and also the task that is
1206          * required in both cases. So it is safe to just call the
1207          * event handling functions here.
1208          */
1209         local_name_changed_callback(adapter->dev_id, length, param, adapter);
1210 }
1211
1212 static int set_name(struct btd_adapter *adapter, const char *name)
1213 {
1214         struct mgmt_cp_set_local_name cp;
1215         char maxname[MAX_NAME_LENGTH];
1216
1217         memset(maxname, 0, sizeof(maxname));
1218         strncpy(maxname, name, MAX_NAME_LENGTH - 1);
1219
1220         if (!g_utf8_validate(maxname, -1, NULL)) {
1221                 btd_error(adapter->dev_id,
1222                         "Name change failed: supplied name isn't valid UTF-8");
1223                 return -EINVAL;
1224         }
1225
1226         memset(&cp, 0, sizeof(cp));
1227         strncpy((char *) cp.name, maxname, sizeof(cp.name) - 1);
1228
1229         DBG("sending set local name command for index %u", adapter->dev_id);
1230
1231         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LOCAL_NAME,
1232                                 adapter->dev_id, sizeof(cp), &cp,
1233                                 set_local_name_complete, adapter, NULL) > 0)
1234                 return 0;
1235
1236         btd_error(adapter->dev_id, "Failed to set local name for index %u",
1237                                                         adapter->dev_id);
1238
1239         return -EIO;
1240 }
1241
1242 int adapter_set_name(struct btd_adapter *adapter, const char *name)
1243 {
1244         if (g_strcmp0(adapter->system_name, name) == 0)
1245                 return 0;
1246
1247         DBG("name: %s", name);
1248
1249         g_free(adapter->system_name);
1250         adapter->system_name = g_strdup(name);
1251
1252         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1253                                                 ADAPTER_INTERFACE, "Name");
1254
1255         /* alias is preferred over system name */
1256         if (adapter->stored_alias)
1257                 return 0;
1258
1259         DBG("alias: %s", name);
1260
1261         g_dbus_emit_property_changed(dbus_conn, adapter->path,
1262                                                 ADAPTER_INTERFACE, "Alias");
1263
1264         return set_name(adapter, name);
1265 }
1266
1267 struct btd_device *btd_adapter_find_device(struct btd_adapter *adapter,
1268                                                         const bdaddr_t *dst,
1269                                                         uint8_t bdaddr_type)
1270 {
1271         struct device_addr_type addr;
1272         struct btd_device *device;
1273         GSList *list;
1274
1275         if (!adapter)
1276                 return NULL;
1277
1278         bacpy(&addr.bdaddr, dst);
1279         addr.bdaddr_type = bdaddr_type;
1280
1281 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1282         list = g_slist_find_custom(adapter->devices, &addr,
1283                                                 device_addr_type_strict_cmp);
1284         if (list) {
1285                 device = list->data;
1286                 return device;
1287         }
1288 #endif
1289         list = g_slist_find_custom(adapter->devices, &addr,
1290                                                         device_addr_type_cmp);
1291         if (!list)
1292                 return NULL;
1293
1294         device = list->data;
1295
1296         /*
1297          * If we're looking up based on public address and the address
1298          * was not previously used over this bearer we may need to
1299          * update LE or BR/EDR support information.
1300          */
1301         if (bdaddr_type == BDADDR_BREDR)
1302                 device_set_bredr_support(device);
1303         else
1304                 device_set_le_support(device, bdaddr_type);
1305
1306         return device;
1307 }
1308
1309 static void uuid_to_uuid128(uuid_t *uuid128, const uuid_t *uuid)
1310 {
1311         if (uuid->type == SDP_UUID16)
1312                 sdp_uuid16_to_uuid128(uuid128, uuid);
1313         else if (uuid->type == SDP_UUID32)
1314                 sdp_uuid32_to_uuid128(uuid128, uuid);
1315         else
1316                 memcpy(uuid128, uuid, sizeof(*uuid));
1317 }
1318
1319 static bool is_supported_uuid(const uuid_t *uuid)
1320 {
1321         uuid_t tmp;
1322
1323         /* mgmt versions from 1.3 onwards support all types of UUIDs */
1324         if (MGMT_VERSION(mgmt_version, mgmt_revision) >= MGMT_VERSION(1, 3))
1325                 return true;
1326
1327         uuid_to_uuid128(&tmp, uuid);
1328
1329         if (!sdp_uuid128_to_uuid(&tmp))
1330                 return false;
1331
1332         if (tmp.type != SDP_UUID16)
1333                 return false;
1334
1335         return true;
1336 }
1337
1338 static void add_uuid_complete(uint8_t status, uint16_t length,
1339                                         const void *param, void *user_data)
1340 {
1341         struct btd_adapter *adapter = user_data;
1342
1343         if (status != MGMT_STATUS_SUCCESS) {
1344                 btd_error(adapter->dev_id, "Failed to add UUID: %s (0x%02x)",
1345                                                 mgmt_errstr(status), status);
1346                 return;
1347         }
1348
1349         /*
1350          * The parameters are identical and also the task that is
1351          * required in both cases. So it is safe to just call the
1352          * event handling functions here.
1353          */
1354         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1355
1356         if (adapter->initialized)
1357                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1358                                                 ADAPTER_INTERFACE, "UUIDs");
1359 }
1360
1361 static int add_uuid(struct btd_adapter *adapter, uuid_t *uuid, uint8_t svc_hint)
1362 {
1363         struct mgmt_cp_add_uuid cp;
1364         uuid_t uuid128;
1365         uint128_t uint128;
1366
1367         if (!is_supported_uuid(uuid)) {
1368                 btd_warn(adapter->dev_id,
1369                                 "Ignoring unsupported UUID for addition");
1370                 return 0;
1371         }
1372
1373         uuid_to_uuid128(&uuid128, uuid);
1374
1375         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1376         htob128(&uint128, (uint128_t *) cp.uuid);
1377         cp.svc_hint = svc_hint;
1378
1379         DBG("sending add uuid command for index %u", adapter->dev_id);
1380
1381         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_UUID,
1382                                 adapter->dev_id, sizeof(cp), &cp,
1383                                 add_uuid_complete, adapter, NULL) > 0)
1384                 return 0;
1385
1386         btd_error(adapter->dev_id, "Failed to add UUID for index %u",
1387                                                         adapter->dev_id);
1388
1389         return -EIO;
1390 }
1391
1392 static void remove_uuid_complete(uint8_t status, uint16_t length,
1393                                         const void *param, void *user_data)
1394 {
1395         struct btd_adapter *adapter = user_data;
1396
1397         if (status != MGMT_STATUS_SUCCESS) {
1398                 btd_error(adapter->dev_id, "Failed to remove UUID: %s (0x%02x)",
1399                                                 mgmt_errstr(status), status);
1400                 return;
1401         }
1402
1403         /*
1404          * The parameters are identical and also the task that is
1405          * required in both cases. So it is safe to just call the
1406          * event handling functions here.
1407          */
1408         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1409
1410         if (adapter->initialized)
1411                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
1412                                                 ADAPTER_INTERFACE, "UUIDs");
1413 }
1414
1415 static int remove_uuid(struct btd_adapter *adapter, uuid_t *uuid)
1416 {
1417         struct mgmt_cp_remove_uuid cp;
1418         uuid_t uuid128;
1419         uint128_t uint128;
1420
1421         if (!is_supported_uuid(uuid)) {
1422                 btd_warn(adapter->dev_id,
1423                                 "Ignoring unsupported UUID for removal");
1424                 return 0;
1425         }
1426
1427         uuid_to_uuid128(&uuid128, uuid);
1428
1429         ntoh128((uint128_t *) uuid128.value.uuid128.data, &uint128);
1430         htob128(&uint128, (uint128_t *) cp.uuid);
1431
1432         DBG("sending remove uuid command for index %u", adapter->dev_id);
1433
1434         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1435                                 adapter->dev_id, sizeof(cp), &cp,
1436                                 remove_uuid_complete, adapter, NULL) > 0)
1437                 return 0;
1438
1439         btd_error(adapter->dev_id, "Failed to remove UUID for index %u",
1440                                                         adapter->dev_id);
1441
1442         return -EIO;
1443 }
1444
1445 static void clear_uuids_complete(uint8_t status, uint16_t length,
1446                                         const void *param, void *user_data)
1447 {
1448         struct btd_adapter *adapter = user_data;
1449
1450         if (status != MGMT_STATUS_SUCCESS) {
1451                 btd_error(adapter->dev_id, "Failed to clear UUIDs: %s (0x%02x)",
1452                                                 mgmt_errstr(status), status);
1453                 return;
1454         }
1455
1456         /*
1457          * The parameters are identical and also the task that is
1458          * required in both cases. So it is safe to just call the
1459          * event handling functions here.
1460          */
1461         dev_class_changed_callback(adapter->dev_id, length, param, adapter);
1462 }
1463
1464 static int clear_uuids(struct btd_adapter *adapter)
1465 {
1466         struct mgmt_cp_remove_uuid cp;
1467
1468         memset(&cp, 0, sizeof(cp));
1469
1470         DBG("sending clear uuids command for index %u", adapter->dev_id);
1471
1472         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_UUID,
1473                                 adapter->dev_id, sizeof(cp), &cp,
1474                                 clear_uuids_complete, adapter, NULL) > 0)
1475                 return 0;
1476
1477         btd_error(adapter->dev_id, "Failed to clear UUIDs for index %u",
1478                                                         adapter->dev_id);
1479
1480         return -EIO;
1481 }
1482
1483 static uint8_t get_uuid_mask(uuid_t *uuid)
1484 {
1485         if (uuid->type != SDP_UUID16)
1486                 return 0;
1487
1488         switch (uuid->value.uuid16) {
1489         case DIALUP_NET_SVCLASS_ID:
1490         case CIP_SVCLASS_ID:
1491                 return 0x42;    /* Telephony & Networking */
1492         case IRMC_SYNC_SVCLASS_ID:
1493         case OBEX_OBJPUSH_SVCLASS_ID:
1494         case OBEX_FILETRANS_SVCLASS_ID:
1495         case IRMC_SYNC_CMD_SVCLASS_ID:
1496         case PBAP_PSE_SVCLASS_ID:
1497                 return 0x10;    /* Object Transfer */
1498         case HEADSET_SVCLASS_ID:
1499         case HANDSFREE_SVCLASS_ID:
1500                 return 0x20;    /* Audio */
1501         case CORDLESS_TELEPHONY_SVCLASS_ID:
1502         case INTERCOM_SVCLASS_ID:
1503         case FAX_SVCLASS_ID:
1504         case SAP_SVCLASS_ID:
1505         /*
1506          * Setting the telephony bit for the handsfree audio gateway
1507          * role is not required by the HFP specification, but the
1508          * Nokia 616 carkit is just plain broken! It will refuse
1509          * pairing without this bit set.
1510          */
1511         case HANDSFREE_AGW_SVCLASS_ID:
1512                 return 0x40;    /* Telephony */
1513         case AUDIO_SOURCE_SVCLASS_ID:
1514         case VIDEO_SOURCE_SVCLASS_ID:
1515                 return 0x08;    /* Capturing */
1516         case AUDIO_SINK_SVCLASS_ID:
1517         case VIDEO_SINK_SVCLASS_ID:
1518                 return 0x04;    /* Rendering */
1519         case PANU_SVCLASS_ID:
1520         case NAP_SVCLASS_ID:
1521         case GN_SVCLASS_ID:
1522                 return 0x02;    /* Networking */
1523         default:
1524                 return 0;
1525         }
1526 }
1527
1528 static int uuid_cmp(const void *a, const void *b)
1529 {
1530         const sdp_record_t *rec = a;
1531         const uuid_t *uuid = b;
1532
1533         return sdp_uuid_cmp(&rec->svclass, uuid);
1534 }
1535
1536 static void adapter_service_insert(struct btd_adapter *adapter, sdp_record_t *rec)
1537 {
1538         sdp_list_t *browse_list = NULL;
1539         uuid_t browse_uuid;
1540         gboolean new_uuid;
1541
1542         DBG("%s", adapter->path);
1543
1544 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1545         if (rec == NULL) {
1546                 DBG("record is NULL return");
1547                 return;
1548         }
1549 #endif
1550
1551         /* skip record without a browse group */
1552         if (sdp_get_browse_groups(rec, &browse_list) < 0) {
1553                 DBG("skipping record without browse group");
1554                 return;
1555         }
1556
1557         sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
1558
1559         /* skip record without public browse group */
1560         if (!sdp_list_find(browse_list, &browse_uuid, sdp_uuid_cmp))
1561                 goto done;
1562
1563         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1564                 new_uuid = TRUE;
1565         else
1566                 new_uuid = FALSE;
1567
1568         adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1569                                                                 record_sort);
1570
1571         if (new_uuid) {
1572                 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1573                 add_uuid(adapter, &rec->svclass, svc_hint);
1574         }
1575
1576 done:
1577         sdp_list_free(browse_list, free);
1578 }
1579
1580 int adapter_service_add(struct btd_adapter *adapter, sdp_record_t *rec)
1581 {
1582         int ret;
1583
1584         DBG("%s", adapter->path);
1585
1586         ret = add_record_to_server(&adapter->bdaddr, rec);
1587         if (ret < 0)
1588                 return ret;
1589
1590         adapter_service_insert(adapter, rec);
1591
1592         return 0;
1593 }
1594
1595 void adapter_service_remove(struct btd_adapter *adapter, uint32_t handle)
1596 {
1597         sdp_record_t *rec = sdp_record_find(handle);
1598
1599         DBG("%s", adapter->path);
1600
1601         if (!rec)
1602                 return;
1603
1604         adapter->services = sdp_list_remove(adapter->services, rec);
1605
1606         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1607                 remove_uuid(adapter, &rec->svclass);
1608
1609         remove_record_from_server(rec->handle);
1610 }
1611
1612 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1613 static void adapter_print_devices(struct btd_adapter *adapter)
1614 {
1615         GSList *dev;
1616
1617         dev = adapter->devices;
1618         for (; dev; dev = dev->next)
1619                 device_print_addr(dev->data);
1620 }
1621 #endif
1622
1623 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
1624                                                 const bdaddr_t *bdaddr,
1625                                                 uint8_t bdaddr_type)
1626 {
1627         struct btd_device *device;
1628
1629         device = device_create(adapter, bdaddr, bdaddr_type);
1630         if (!device)
1631                 return NULL;
1632
1633         adapter->devices = g_slist_append(adapter->devices, device);
1634
1635 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1636         device_print_addr(device);
1637         DBG("devices list count : %d", g_slist_length(adapter->devices));
1638 #endif
1639
1640         return device;
1641 }
1642
1643 static void service_auth_cancel(struct service_auth *auth)
1644 {
1645         DBusError derr;
1646
1647         if (auth->svc_id > 0)
1648                 device_remove_svc_complete_callback(auth->device,
1649                                                                 auth->svc_id);
1650
1651         dbus_error_init(&derr);
1652         dbus_set_error_const(&derr, ERROR_INTERFACE ".Canceled", NULL);
1653
1654         auth->cb(&derr, auth->user_data);
1655
1656         dbus_error_free(&derr);
1657
1658         if (auth->agent != NULL) {
1659                 agent_cancel(auth->agent);
1660                 agent_unref(auth->agent);
1661         }
1662
1663         g_free(auth);
1664 }
1665
1666 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1667 void btd_adapter_unpair_device(struct btd_adapter *adapter,
1668                                 struct btd_device *dev)
1669 {
1670         DBG("+");
1671         GList *l;
1672
1673         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1674
1675 //      adapter->devices = g_slist_remove(adapter->devices, dev);
1676 //
1677 //      adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1678 //                                                                      dev);
1679
1680         adapter->connections = g_slist_remove(adapter->connections, dev);
1681
1682         if (adapter->connect_le == dev)
1683                 adapter->connect_le = NULL;
1684
1685         l = adapter->auths->head;
1686         while (l != NULL) {
1687                 struct service_auth *auth = l->data;
1688                 GList *next = g_list_next(l);
1689
1690                 if (auth->device != dev) {
1691                         l = next;
1692                         continue;
1693                 }
1694
1695                 g_queue_delete_link(adapter->auths, l);
1696                 l = next;
1697
1698                 service_auth_cancel(auth);
1699         }
1700
1701         device_unpair(dev, TRUE);
1702         DBG("-");
1703 }
1704 #endif
1705
1706 void btd_adapter_remove_device(struct btd_adapter *adapter,
1707                                 struct btd_device *dev)
1708 {
1709         GList *l;
1710
1711         adapter->connect_list = g_slist_remove(adapter->connect_list, dev);
1712
1713         adapter->devices = g_slist_remove(adapter->devices, dev);
1714
1715         adapter->discovery_found = g_slist_remove(adapter->discovery_found,
1716                                                                         dev);
1717
1718         adapter->connections = g_slist_remove(adapter->connections, dev);
1719
1720         if (adapter->connect_le == dev)
1721                 adapter->connect_le = NULL;
1722
1723         l = adapter->auths->head;
1724         while (l != NULL) {
1725                 struct service_auth *auth = l->data;
1726                 GList *next = g_list_next(l);
1727
1728                 if (auth->device != dev) {
1729                         l = next;
1730                         continue;
1731                 }
1732
1733                 g_queue_delete_link(adapter->auths, l);
1734                 l = next;
1735
1736                 service_auth_cancel(auth);
1737         }
1738
1739         device_remove(dev, TRUE);
1740 }
1741
1742 struct btd_device *btd_adapter_get_device(struct btd_adapter *adapter,
1743                                         const bdaddr_t *addr,
1744                                         uint8_t addr_type)
1745 {
1746         struct btd_device *device;
1747
1748         if (!adapter)
1749                 return NULL;
1750
1751 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1752         if (!bacmp(addr, BDADDR_ANY))
1753                 return NULL;
1754 #endif
1755
1756         device = btd_adapter_find_device(adapter, addr, addr_type);
1757         if (device)
1758                 return device;
1759
1760         return adapter_create_device(adapter, addr, addr_type);
1761 }
1762
1763 sdp_list_t *btd_adapter_get_services(struct btd_adapter *adapter)
1764 {
1765         return adapter->services;
1766 }
1767
1768 static void passive_scanning_complete(uint8_t status, uint16_t length,
1769                                         const void *param, void *user_data)
1770 {
1771         struct btd_adapter *adapter = user_data;
1772         const struct mgmt_cp_start_discovery *rp = param;
1773
1774         DBG("status 0x%02x", status);
1775
1776         if (length < sizeof(*rp)) {
1777                 btd_error(adapter->dev_id,
1778                         "Wrong size of start scanning return parameters");
1779                 return;
1780         }
1781
1782         if (status == MGMT_STATUS_SUCCESS) {
1783                 adapter->discovery_type = rp->type;
1784                 adapter->discovery_enable = 0x01;
1785         }
1786 }
1787
1788 static gboolean passive_scanning_timeout(gpointer user_data)
1789 {
1790         struct btd_adapter *adapter = user_data;
1791         struct mgmt_cp_start_discovery cp;
1792
1793         adapter->passive_scan_timeout = 0;
1794
1795         cp.type = SCAN_TYPE_LE;
1796 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1797         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
1798                                 adapter->dev_id, sizeof(cp), &cp,
1799                                 passive_scanning_complete, adapter, NULL);
1800 #else
1801         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
1802                                 adapter->dev_id, sizeof(cp), &cp,
1803                                 passive_scanning_complete, adapter, NULL);
1804 #endif
1805         return FALSE;
1806 }
1807
1808 static void trigger_passive_scanning(struct btd_adapter *adapter)
1809 {
1810         if (!(adapter->current_settings & MGMT_SETTING_LE))
1811                 return;
1812
1813         DBG("");
1814
1815         if (adapter->passive_scan_timeout > 0) {
1816                 g_source_remove(adapter->passive_scan_timeout);
1817                 adapter->passive_scan_timeout = 0;
1818         }
1819
1820         /*
1821          * When the kernel background scanning is available, there is
1822          * no need to start any discovery. The kernel will keep scanning
1823          * as long as devices are in its auto-connection list.
1824          */
1825         if (kernel_conn_control)
1826                 return;
1827
1828         /*
1829          * If any client is running a discovery right now, then do not
1830          * even try to start passive scanning.
1831          *
1832          * The discovery procedure is using interleaved scanning and
1833          * thus will discover Low Energy devices as well.
1834          */
1835 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1836         if (adapter->discovery_list || adapter->le_discovery_list)
1837                 return;
1838 #else
1839         if (adapter->discovery_list)
1840                 return;
1841 #endif
1842
1843         if (adapter->discovery_enable == 0x01)
1844                 return;
1845
1846         /*
1847          * In case the discovery is suspended (for example for an ongoing
1848          * pairing attempt), then also do not start passive scanning.
1849          */
1850         if (adapter->discovery_suspended)
1851                 return;
1852
1853         /*
1854          * If the list of connectable Low Energy devices is empty,
1855          * then do not start passive scanning.
1856          */
1857         if (!adapter->connect_list)
1858                 return;
1859
1860         adapter->passive_scan_timeout = g_timeout_add_seconds(CONN_SCAN_TIMEOUT,
1861                                         passive_scanning_timeout, adapter);
1862 }
1863
1864 static void stop_passive_scanning_complete(uint8_t status, uint16_t length,
1865                                         const void *param, void *user_data)
1866 {
1867         struct btd_adapter *adapter = user_data;
1868         struct btd_device *dev;
1869         int err;
1870
1871         DBG("status 0x%02x (%s)", status, mgmt_errstr(status));
1872
1873         dev = adapter->connect_le;
1874         adapter->connect_le = NULL;
1875
1876         /*
1877          * When the kernel background scanning is available, there is
1878          * no need to stop any discovery. The kernel will handle the
1879          * auto-connection by itself.
1880          */
1881         if (kernel_conn_control)
1882                 return;
1883
1884         /*
1885          * MGMT_STATUS_REJECTED may be returned from kernel because the passive
1886          * scan timer had expired in kernel and passive scan was disabled just
1887          * around the time we called stop_passive_scanning().
1888          */
1889         if (status != MGMT_STATUS_SUCCESS && status != MGMT_STATUS_REJECTED) {
1890                 btd_error(adapter->dev_id, "Stopping passive scanning failed: %s",
1891                                                         mgmt_errstr(status));
1892                 return;
1893         }
1894
1895         adapter->discovery_type = 0x00;
1896         adapter->discovery_enable = 0x00;
1897
1898         if (!dev) {
1899                 DBG("Device removed while stopping passive scanning");
1900                 trigger_passive_scanning(adapter);
1901                 return;
1902         }
1903
1904         err = device_connect_le(dev);
1905         if (err < 0) {
1906                 btd_error(adapter->dev_id, "LE auto connection failed: %s (%d)",
1907                                                         strerror(-err), -err);
1908                 trigger_passive_scanning(adapter);
1909         }
1910 }
1911
1912 static void stop_passive_scanning(struct btd_adapter *adapter)
1913 {
1914         struct mgmt_cp_stop_discovery cp;
1915 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1916         struct mgmt_cp_stop_discovery le_cp;
1917 #endif
1918
1919         DBG("");
1920
1921         /* If there are any normal discovery clients passive scanning
1922          * wont be running */
1923 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1924         if (adapter->discovery_list || adapter->le_discovery_list)
1925                 return;
1926 #else
1927         if (adapter->discovery_list)
1928                 return;
1929 #endif
1930
1931         if (adapter->discovery_enable == 0x00)
1932                 return;
1933
1934 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
1935         if ((adapter->discovery_type & 0x01) > 0) {
1936                 cp.type = 0x01;
1937                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
1938                                 adapter->dev_id, sizeof(cp), &cp,
1939                                 stop_passive_scanning_complete, adapter, NULL);
1940         }
1941         if ((adapter->discovery_type & 0x06) > 0) {
1942                 le_cp.type = 0x06;
1943                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
1944                                 adapter->dev_id, sizeof(le_cp), &le_cp,
1945                                 stop_passive_scanning_complete, adapter, NULL);
1946         }
1947 #else
1948         cp.type = adapter->discovery_type;
1949
1950         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
1951                         adapter->dev_id, sizeof(cp), &cp,
1952                         stop_passive_scanning_complete, adapter, NULL);
1953 #endif
1954 }
1955
1956 static void cancel_passive_scanning(struct btd_adapter *adapter)
1957 {
1958         if (!(adapter->current_settings & MGMT_SETTING_LE))
1959                 return;
1960
1961         DBG("");
1962
1963         if (adapter->passive_scan_timeout > 0) {
1964                 g_source_remove(adapter->passive_scan_timeout);
1965                 adapter->passive_scan_timeout = 0;
1966         }
1967 }
1968
1969 static uint8_t get_scan_type(struct btd_adapter *adapter)
1970 {
1971         uint8_t type;
1972
1973         if (adapter->current_settings & MGMT_SETTING_BREDR)
1974                 type = SCAN_TYPE_BREDR;
1975         else
1976                 type = 0;
1977
1978         if (adapter->current_settings & MGMT_SETTING_LE)
1979                 type |= SCAN_TYPE_LE;
1980
1981         return type;
1982 }
1983
1984 static void free_discovery_filter(struct discovery_filter *discovery_filter)
1985 {
1986         if (!discovery_filter)
1987                 return;
1988
1989         g_slist_free_full(discovery_filter->uuids, free);
1990         g_free(discovery_filter);
1991 }
1992
1993 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay);
1994
1995 static void start_discovery_complete(uint8_t status, uint16_t length,
1996                                         const void *param, void *user_data)
1997 {
1998         struct btd_adapter *adapter = user_data;
1999         struct watch_client *client;
2000         const struct mgmt_cp_start_discovery *rp = param;
2001         DBusMessage *reply;
2002
2003         DBG("status 0x%02x", status);
2004
2005         /* Is there are no clients the discovery must have been stopped while
2006          * discovery command was pending.
2007          */
2008         if (!adapter->discovery_list) {
2009                 struct mgmt_cp_stop_discovery cp;
2010
2011                 if (status != MGMT_STATUS_SUCCESS)
2012                         return;
2013
2014                 /* Stop discovering as there are no clients left */
2015                 cp.type = rp->type;
2016                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2017                                         adapter->dev_id, sizeof(cp), &cp,
2018                                         NULL, NULL, NULL);
2019                 return;
2020         }
2021
2022         client = adapter->discovery_list->data;
2023
2024         if (length < sizeof(*rp)) {
2025                 btd_error(adapter->dev_id,
2026                         "Wrong size of start discovery return parameters");
2027                 if (client->msg)
2028                         goto fail;
2029                 return;
2030         }
2031
2032         if (status == MGMT_STATUS_SUCCESS) {
2033 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2034                 DBG("Return param discovery type 0x%02x", rp->type);
2035                 adapter->discovery_type |= rp->type;
2036 #else
2037                 adapter->discovery_type = rp->type;
2038 #endif
2039                 adapter->discovery_enable = 0x01;
2040
2041                 if (adapter->current_discovery_filter)
2042                         adapter->filtered_discovery = true;
2043                 else
2044                         adapter->filtered_discovery = false;
2045
2046                 if (client->msg) {
2047                         g_dbus_send_reply(dbus_conn, client->msg,
2048                                                 DBUS_TYPE_INVALID);
2049                         dbus_message_unref(client->msg);
2050                         client->msg = NULL;
2051                 }
2052
2053                 if (adapter->discovering)
2054                         return;
2055
2056                 adapter->discovering = true;
2057                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2058                                         ADAPTER_INTERFACE, "Discovering");
2059                 return;
2060 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2061         } else {
2062                 adapter->discovering = false;
2063                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2064                                         ADAPTER_INTERFACE, "Discovering");
2065 #endif
2066         }
2067
2068 fail:
2069         /* Reply with an error if the first discovery has failed */
2070         if (client->msg) {
2071                 reply = btd_error_busy(client->msg);
2072                 g_dbus_send_message(dbus_conn, reply);
2073                 g_dbus_remove_watch(dbus_conn, client->watch);
2074                 return;
2075         }
2076
2077         /*
2078          * In case the restart of the discovery failed, then just trigger
2079          * it for the next idle timeout again.
2080          */
2081 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2082         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
2083 #endif
2084 }
2085
2086 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2087 static void start_le_discovery_complete(uint8_t status, uint16_t length,
2088                                         const void *param, void *user_data)
2089 {
2090         struct btd_adapter *adapter = user_data;
2091         const struct mgmt_cp_start_discovery *rp = param;
2092
2093         if (!rp) {
2094                 error("Error ocurred in LEDiscovering, rp is NULL");
2095                 return;
2096         }
2097
2098         DBG("status 0x%02x", status);
2099         if (length < sizeof(*rp)) {
2100                 error("Wrong size of start discovery return parameters");
2101                 return;
2102         }
2103
2104         DBG("Discovery Type 0x%02x", rp->type);
2105         if (status == MGMT_STATUS_SUCCESS) {
2106                 adapter->discovery_type |= rp->type;
2107                 adapter->discovery_enable = 0x01;
2108
2109                 if (adapter->le_discovering)
2110                         return;
2111
2112                 adapter->le_discovering = true;
2113                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2114                                         ADAPTER_INTERFACE, "LEDiscovering");
2115
2116                 return;
2117         } else {
2118                 adapter->le_discovering = false;
2119                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2120                                         ADAPTER_INTERFACE, "LEDiscovering");
2121
2122         }
2123 }
2124 #endif
2125
2126 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2127 static gboolean start_le_discovery_timeout(gpointer user_data)
2128 {
2129         struct btd_adapter *adapter = user_data;
2130         uint8_t new_type;
2131
2132         DBG("");
2133
2134         adapter->le_discovery_idle_timeout = 0;
2135
2136         new_type = SCAN_TYPE_LE;
2137
2138         if (adapter->discovery_enable == 0x01) {
2139                 /*
2140                  * If there is an already running discovery and it has the
2141                  * same type, then just keep it.
2142                  */
2143
2144                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_LE) {
2145                         if (adapter->le_discovering)
2146                                 return FALSE;
2147
2148                         adapter->le_discovering = true;
2149                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2150                                         ADAPTER_INTERFACE, "LEDiscovering");
2151
2152                         return FALSE;
2153                 }
2154         }
2155
2156         struct mgmt_cp_start_discovery cp;
2157
2158         cp.type = new_type;
2159         mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
2160                         adapter->dev_id, sizeof(cp), &cp,
2161                         start_le_discovery_complete, adapter, NULL);
2162
2163         return FALSE;
2164 }
2165 #endif
2166
2167 static gboolean start_discovery_timeout(gpointer user_data)
2168 {
2169         struct btd_adapter *adapter = user_data;
2170 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2171         struct mgmt_cp_start_service_discovery *sd_cp;
2172 #endif
2173         uint8_t new_type;
2174
2175         DBG("");
2176
2177         adapter->discovery_idle_timeout = 0;
2178
2179 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2180         new_type = SCAN_TYPE_BREDR;
2181
2182         if (adapter->discovery_enable == 0x01) {
2183                 /*
2184                  * If there is an already running discovery and it has the
2185                  * same type, then just keep it.
2186                  */
2187                 if ((adapter->discovery_type & new_type) == SCAN_TYPE_BREDR) {
2188                         if (adapter->discovering)
2189                                 return FALSE;
2190
2191                         adapter->discovering = true;
2192                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2193                                         ADAPTER_INTERFACE, "Discovering");
2194
2195                         return FALSE;
2196                 }
2197         }
2198
2199         struct mgmt_cp_start_discovery cp;
2200         cp.type = new_type;
2201         mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2202                                 adapter->dev_id, sizeof(cp), &cp,
2203                                 start_discovery_complete, adapter, NULL);
2204
2205 #else
2206         /* If we're doing filtered discovery, it must be quickly restarted */
2207         adapter->no_scan_restart_delay = !!adapter->current_discovery_filter;
2208
2209         DBG("adapter->current_discovery_filter == %d",
2210             !!adapter->current_discovery_filter);
2211
2212         new_type = get_scan_type(adapter);
2213
2214         if (adapter->discovery_enable == 0x01) {
2215                 struct mgmt_cp_stop_discovery cp;
2216
2217                 /*
2218                  * If we're asked to start regular discovery, and there is an
2219                  * already running regular discovery and it has the same type,
2220                  * then just keep it.
2221                  */
2222                 if (!adapter->current_discovery_filter &&
2223                     !adapter->filtered_discovery &&
2224                     adapter->discovery_type == new_type) {
2225                         if (adapter->discovering)
2226                                 return FALSE;
2227
2228                         adapter->discovering = true;
2229                         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2230                                         ADAPTER_INTERFACE, "Discovering");
2231                         return FALSE;
2232                 }
2233
2234                 /*
2235                  * Otherwise the current discovery must be stopped. So
2236                  * queue up a stop discovery command.
2237                  *
2238                  * This can happen if a passive scanning for Low Energy
2239                  * devices is ongoing, or scan type is changed between
2240                  * regular and filtered, or filter was updated.
2241                  */
2242                 cp.type = adapter->discovery_type;
2243                 mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2244                                         adapter->dev_id, sizeof(cp), &cp,
2245                                         NULL, NULL, NULL);
2246
2247                 /* Don't even bother to try to quickly start discovery
2248                  * just after stopping it, it would fail with status
2249                  * MGMT_BUSY. Instead discovering_callback will take
2250                  * care of that.
2251                  */
2252                 return FALSE;
2253
2254         }
2255
2256         /* Regular discovery is required */
2257         if (!adapter->current_discovery_filter) {
2258                 struct mgmt_cp_start_discovery cp;
2259
2260                 cp.type = new_type;
2261                 mgmt_send(adapter->mgmt, MGMT_OP_START_DISCOVERY,
2262                                 adapter->dev_id, sizeof(cp), &cp,
2263                                 start_discovery_complete, adapter, NULL);
2264                 return FALSE;
2265         }
2266
2267         /* Filtered discovery is required */
2268         sd_cp = adapter->current_discovery_filter;
2269
2270         DBG("sending MGMT_OP_START_SERVICE_DISCOVERY %d, %d, %d",
2271                                 sd_cp->rssi, sd_cp->type,
2272                                 btohs(sd_cp->uuid_count));
2273
2274         mgmt_send(adapter->mgmt, MGMT_OP_START_SERVICE_DISCOVERY,
2275                   adapter->dev_id, sizeof(*sd_cp) +
2276                   btohs(sd_cp->uuid_count) * 16,
2277                   sd_cp, start_discovery_complete, adapter, NULL);
2278
2279 #endif
2280
2281         return FALSE;
2282 }
2283
2284 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2285 static void trigger_start_le_discovery(struct btd_adapter *adapter, guint delay)
2286 {
2287
2288         DBG("");
2289
2290         cancel_passive_scanning(adapter);
2291
2292         if (adapter->le_discovery_idle_timeout > 0) {
2293                 g_source_remove(adapter->le_discovery_idle_timeout);
2294                 adapter->le_discovery_idle_timeout = 0;
2295         }
2296
2297         /*
2298          * If the controller got powered down in between, then ensure
2299          * that we do not keep trying to restart discovery.
2300          *
2301          * This is safe-guard and should actually never trigger.
2302          */
2303         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2304                 return;
2305
2306         adapter->le_discovery_idle_timeout = g_timeout_add_seconds(delay,
2307                                         start_le_discovery_timeout, adapter);
2308 }
2309 #endif
2310
2311 static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
2312 {
2313
2314         DBG("");
2315
2316         cancel_passive_scanning(adapter);
2317
2318         if (adapter->discovery_idle_timeout > 0) {
2319                 g_source_remove(adapter->discovery_idle_timeout);
2320                 adapter->discovery_idle_timeout = 0;
2321         }
2322
2323         /*
2324          * If the controller got powered down in between, then ensure
2325          * that we do not keep trying to restart discovery.
2326          *
2327          * This is safe-guard and should actually never trigger.
2328          */
2329         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
2330                 return;
2331
2332         adapter->discovery_idle_timeout = g_timeout_add_seconds(delay,
2333                                         start_discovery_timeout, adapter);
2334 }
2335
2336 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
2337 static void suspend_discovery_complete(uint8_t status, uint16_t length,
2338                                         const void *param, void *user_data)
2339 {
2340         struct btd_adapter *adapter = user_data;
2341
2342         DBG("status 0x%02x", status);
2343
2344         if (status == MGMT_STATUS_SUCCESS) {
2345                 adapter->discovery_type = 0x00;
2346                 adapter->discovery_enable = 0x00;
2347                 return;
2348         }
2349 }
2350
2351 static void suspend_discovery(struct btd_adapter *adapter)
2352 {
2353         struct mgmt_cp_stop_discovery cp;
2354
2355         DBG("");
2356
2357         adapter->discovery_suspended = true;
2358
2359         /*
2360          * If there are no clients discovering right now, then there is
2361          * also nothing to suspend.
2362          */
2363         if (!adapter->discovery_list)
2364                 return;
2365
2366         /*
2367          * In case of being inside the idle phase, make sure to remove
2368          * the timeout to not trigger a restart.
2369          *
2370          * The restart will be triggered when the discovery is resumed.
2371          */
2372         if (adapter->discovery_idle_timeout > 0) {
2373                 g_source_remove(adapter->discovery_idle_timeout);
2374                 adapter->discovery_idle_timeout = 0;
2375         }
2376
2377         if (adapter->discovery_enable == 0x00)
2378                 return;
2379
2380         cp.type = adapter->discovery_type;
2381
2382         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
2383                                 adapter->dev_id, sizeof(cp), &cp,
2384                                 suspend_discovery_complete, adapter, NULL);
2385 }
2386
2387 static void resume_discovery(struct btd_adapter *adapter)
2388 {
2389         DBG("");
2390
2391         adapter->discovery_suspended = false;
2392
2393         /*
2394          * If there are no clients discovering right now, then there is
2395          * also nothing to resume.
2396          */
2397         if (!adapter->discovery_list)
2398                 return;
2399
2400         /*
2401          * Treat a suspended discovery session the same as extra long
2402          * idle time for a normal discovery. So just trigger the default
2403          * restart procedure.
2404          */
2405         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2406 }
2407 #endif
2408
2409 static void discovering_callback(uint16_t index, uint16_t length,
2410                                         const void *param, void *user_data)
2411 {
2412         const struct mgmt_ev_discovering *ev = param;
2413         struct btd_adapter *adapter = user_data;
2414
2415         if (length < sizeof(*ev)) {
2416                 btd_error(adapter->dev_id, "Too small discovering event");
2417                 return;
2418         }
2419
2420         DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
2421                                 ev->discovering, adapter->filtered_discovery);
2422
2423 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2424         DBG("info discov_type %d", adapter->discovery_type);
2425         if (ev->type == SCAN_TYPE_BREDR) {
2426                 if (ev->discovering == FALSE) {
2427                         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
2428                         adapter->discovering = false;
2429                 } else {
2430                         hci_set_bit(BDADDR_BREDR, &adapter->discovery_type);
2431                         adapter->discovering = true;
2432                 }
2433                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2434                                         ADAPTER_INTERFACE, "Discovering");
2435
2436         } else if (ev->type == SCAN_TYPE_LE) {
2437                 if (ev->discovering == FALSE) {
2438                         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2439                         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2440
2441                         if (adapter->le_discovering == true) {
2442                                 struct watch_client *client;
2443                                 client = adapter->le_discovery_list->data;
2444                                 adapter->le_discovering = false;
2445                                 g_dbus_remove_watch(dbus_conn, client->watch);
2446                         }
2447                 } else {
2448                         hci_set_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
2449                         hci_set_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
2450                         adapter->le_discovering = true;
2451                 }
2452
2453                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
2454                                         ADAPTER_INTERFACE, "LEDiscovering");
2455         }
2456 #else
2457         if (adapter->discovery_enable == ev->discovering)
2458                 return;
2459
2460         adapter->discovery_type = ev->type;
2461         adapter->discovery_enable = ev->discovering;
2462 #endif
2463
2464         /*
2465          * Check for existing discoveries triggered by client applications
2466          * and ignore all others.
2467          *
2468          * If there are no clients, then it is good idea to trigger a
2469          * passive scanning attempt.
2470          */
2471 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2472         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2473                 if (!adapter->connect_le)
2474                         trigger_passive_scanning(adapter);
2475                 return;
2476         }
2477 #else
2478         if (!adapter->discovery_list) {
2479                 if (!adapter->connect_le)
2480                         trigger_passive_scanning(adapter);
2481                 return;
2482         }
2483 #endif
2484
2485         if (adapter->discovery_suspended)
2486                 return;
2487
2488         switch (adapter->discovery_enable) {
2489         case 0x00:
2490                 if (adapter->no_scan_restart_delay)
2491                         trigger_start_discovery(adapter, 0);
2492                 else
2493                         trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT);
2494                 break;
2495
2496         case 0x01:
2497                 if (adapter->discovery_idle_timeout > 0) {
2498                         g_source_remove(adapter->discovery_idle_timeout);
2499                         adapter->discovery_idle_timeout = 0;
2500                 }
2501
2502                 break;
2503         }
2504 }
2505
2506 static void invalidate_rssi_and_tx_power(gpointer a)
2507 {
2508         struct btd_device *dev = a;
2509
2510         device_set_rssi(dev, 0);
2511         device_set_tx_power(dev, 127);
2512 }
2513
2514 static gboolean remove_temp_devices(gpointer user_data)
2515 {
2516         struct btd_adapter *adapter = user_data;
2517         GSList *l, *next;
2518
2519         DBG("%s", adapter->path);
2520
2521         adapter->temp_devices_timeout = 0;
2522
2523         for (l = adapter->devices; l != NULL; l = next) {
2524                 struct btd_device *dev = l->data;
2525
2526                 next = g_slist_next(l);
2527
2528                 if (device_is_temporary(dev) && !btd_device_is_connected(dev))
2529                         btd_adapter_remove_device(adapter, dev);
2530         }
2531
2532         return FALSE;
2533 }
2534
2535 static void discovery_cleanup(struct btd_adapter *adapter)
2536 {
2537         GSList *l, *next;
2538
2539         adapter->discovery_type = 0x00;
2540
2541         if (adapter->discovery_idle_timeout > 0) {
2542                 g_source_remove(adapter->discovery_idle_timeout);
2543                 adapter->discovery_idle_timeout = 0;
2544         }
2545
2546         if (adapter->temp_devices_timeout > 0) {
2547                 g_source_remove(adapter->temp_devices_timeout);
2548                 adapter->temp_devices_timeout = 0;
2549         }
2550
2551         g_slist_free_full(adapter->discovery_found,
2552                                                 invalidate_rssi_and_tx_power);
2553         adapter->discovery_found = NULL;
2554
2555         if (!adapter->devices)
2556                 return;
2557
2558         for (l = adapter->devices; l != NULL; l = next) {
2559                 struct btd_device *dev = l->data;
2560
2561                 next = g_slist_next(l);
2562
2563 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2564                 if (device_is_temporary(dev) && !device_is_connectable(dev)
2565                         && !btd_device_is_connected(dev))
2566 #else
2567                 if (device_is_temporary(dev) && !device_is_connectable(dev))
2568 #endif
2569                         btd_adapter_remove_device(adapter, dev);
2570         }
2571
2572         adapter->temp_devices_timeout = g_timeout_add_seconds(TEMP_DEV_TIMEOUT,
2573                                                 remove_temp_devices, adapter);
2574 }
2575
2576 static void discovery_free(void *user_data)
2577 {
2578         struct watch_client *client = user_data;
2579
2580         if (client->watch)
2581                 g_dbus_remove_watch(dbus_conn, client->watch);
2582
2583         if (client->discovery_filter) {
2584                 free_discovery_filter(client->discovery_filter);
2585                 client->discovery_filter = NULL;
2586         }
2587
2588         if (client->msg)
2589                 dbus_message_unref(client->msg);
2590
2591         g_free(client->owner);
2592         g_free(client);
2593 }
2594
2595 static bool set_discovery_discoverable(struct btd_adapter *adapter, bool enable)
2596 {
2597         if (adapter->discovery_discoverable == enable)
2598                 return true;
2599
2600         /* Reset discoverable filter if already set */
2601         if (enable && (adapter->current_settings & MGMT_OP_SET_DISCOVERABLE))
2602                 return true;
2603
2604         adapter->discovery_discoverable = enable;
2605
2606         return set_discoverable(adapter, enable, 0);
2607 }
2608
2609 static void discovery_remove(struct watch_client *client, bool exit)
2610 {
2611         struct btd_adapter *adapter = client->adapter;
2612
2613         DBG("owner %s", client->owner);
2614
2615         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
2616                         client);
2617
2618         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
2619                         client);
2620
2621         if (!exit && client->discovery_filter)
2622                 adapter->set_filter_list = g_slist_prepend(
2623                                         adapter->set_filter_list, client);
2624         else
2625                 discovery_free(client);
2626
2627         /*
2628          * If there are other client discoveries in progress, then leave
2629          * it active. If not, then make sure to stop the restart timeout.
2630          */
2631         if (adapter->discovery_list)
2632                 return;
2633
2634         discovery_cleanup(adapter);
2635 }
2636
2637 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
2638 static void stop_discovery_complete(uint8_t status, uint16_t length,
2639                                         const void *param, void *user_data)
2640 {
2641         struct watch_client *client = user_data;
2642         struct btd_adapter *adapter = client->adapter;
2643         DBusMessage *reply;
2644
2645         DBG("status 0x%02x", status);
2646
2647         if (status != MGMT_STATUS_SUCCESS) {
2648                 if (client->msg) {
2649                         reply = btd_error_busy(client->msg);
2650                         g_dbus_send_message(dbus_conn, reply);
2651                 }
2652
2653                 goto done;
2654         }
2655
2656         if (client->msg) {
2657                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2658                 g_dbus_send_message(dbus_conn, reply);
2659         }
2660
2661         adapter->discovery_type &= (~0x01);
2662         DBG("Discovery Type 0x%02x", adapter->discovery_type);
2663
2664         adapter->filtered_discovery = false;
2665         adapter->no_scan_restart_delay = false;
2666         adapter->discovering = false;
2667         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2668                         ADAPTER_INTERFACE, "Discovering");
2669
2670         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2671                 adapter->discovery_enable = 0x00;
2672                 trigger_passive_scanning(adapter);
2673         }
2674
2675 done:
2676         discovery_remove(client, false);
2677 }
2678
2679 static void stop_le_discovery_complete(uint8_t status, uint16_t length,
2680                                         const void *param, void *user_data)
2681 {
2682         struct watch_client *client = user_data;
2683         struct btd_adapter *adapter = client->adapter;
2684         DBusMessage *reply;
2685
2686         DBG("status 0x%02x", status);
2687
2688         if (status != MGMT_STATUS_SUCCESS) {
2689                 if (client->msg) {
2690                         reply = btd_error_busy(client->msg);
2691                         g_dbus_send_message(dbus_conn, reply);
2692                 }
2693
2694                 goto done;
2695         }
2696
2697         if (client->msg) {
2698                 reply = g_dbus_create_reply(client->msg, DBUS_TYPE_INVALID);
2699                 g_dbus_send_message(dbus_conn, reply);
2700         }
2701
2702         adapter->discovery_type &= (~0x06);
2703         DBG("Discovery Type 0x%02x", adapter->discovery_type);
2704
2705         adapter->filtered_discovery = false;
2706         adapter->no_scan_restart_delay = false;
2707         adapter->le_discovering = false;
2708         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2709                         ADAPTER_INTERFACE, "LEDiscovering");
2710
2711         if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
2712                 adapter->discovery_enable = 0x00;
2713                 trigger_passive_scanning(adapter);
2714         }
2715
2716 done:
2717         /*
2718          * The destroy function will cleanup the client information and
2719          * also remove it from the list of discovery clients.
2720          */
2721         g_dbus_remove_watch(dbus_conn, client->watch);
2722 }
2723 #else
2724
2725 static void stop_discovery_complete(uint8_t status, uint16_t length,
2726                                         const void *param, void *user_data)
2727 {
2728         struct watch_client *client = user_data;
2729         struct btd_adapter *adapter = client->adapter;
2730         DBusMessage *reply;
2731
2732         DBG("status 0x%02x", status);
2733
2734         if (status != MGMT_STATUS_SUCCESS) {
2735                 if (client->msg) {
2736                         reply = btd_error_busy(client->msg);
2737                         g_dbus_send_message(dbus_conn, reply);
2738                 }
2739                 goto done;
2740         }
2741
2742         if (client->msg) {
2743                 g_dbus_send_reply(dbus_conn, client->msg, DBUS_TYPE_INVALID);
2744                 dbus_message_unref(client->msg);
2745                 client->msg = NULL;
2746         }
2747
2748         adapter->discovery_type = 0x00;
2749         adapter->discovery_enable = 0x00;
2750         adapter->filtered_discovery = false;
2751         adapter->no_scan_restart_delay = false;
2752         adapter->discovering = false;
2753         g_dbus_emit_property_changed(dbus_conn, adapter->path,
2754                                         ADAPTER_INTERFACE, "Discovering");
2755
2756         trigger_passive_scanning(adapter);
2757
2758 done:
2759         discovery_remove(client);
2760 }
2761 #endif
2762
2763 static int compare_sender(gconstpointer a, gconstpointer b)
2764 {
2765         const struct watch_client *client = a;
2766         const char *sender = b;
2767
2768         return g_strcmp0(client->owner, sender);
2769 }
2770
2771 static gint g_strcmp(gconstpointer a, gconstpointer b)
2772 {
2773         return strcmp(a, b);
2774 }
2775
2776 static void extract_unique_uuids(gpointer data, gpointer user_data)
2777 {
2778         char *uuid_str = data;
2779         GSList **uuids = user_data;
2780
2781         if (!g_slist_find_custom(*uuids, uuid_str, g_strcmp))
2782                 *uuids = g_slist_insert_sorted(*uuids, uuid_str, g_strcmp);
2783 }
2784
2785 /*
2786  * This method merges all adapter filters into rssi, transport and uuids.
2787  * Returns 1 if there was no filtered scan, 0 otherwise.
2788  */
2789 static int merge_discovery_filters(struct btd_adapter *adapter, int *rssi,
2790                                         uint8_t *transport, GSList **uuids)
2791 {
2792         GSList *l;
2793         bool empty_uuid = false;
2794         bool has_regular_discovery = false;
2795         bool has_filtered_discovery = false;
2796
2797         for (l = adapter->discovery_list; l != NULL; l = g_slist_next(l)) {
2798                 struct watch_client *client = l->data;
2799                 struct discovery_filter *item = client->discovery_filter;
2800
2801                 if (!item) {
2802                         has_regular_discovery = true;
2803                         continue;
2804                 }
2805
2806                 has_filtered_discovery = true;
2807
2808                 *transport |= item->type;
2809
2810                 /*
2811                  * Rule for merging rssi and pathloss into rssi field of kernel
2812                  * filter is as follow:
2813                  * - if there's any client without proximity filter, then do no
2814                  *   proximity filtering,
2815                  * - if all clients specified RSSI, then use lowest value,
2816                  * - if any client specified pathloss, then kernel filter should
2817                  *   do no proximity, as kernel can't compute pathloss. We'll do
2818                  *   filtering on our own.
2819                  */
2820                 if (item->rssi == DISTANCE_VAL_INVALID)
2821                         *rssi = HCI_RSSI_INVALID;
2822                 else if (*rssi != HCI_RSSI_INVALID && *rssi >= item->rssi)
2823                         *rssi = item->rssi;
2824                 else if (item->pathloss != DISTANCE_VAL_INVALID)
2825                         *rssi = HCI_RSSI_INVALID;
2826
2827                 if (!g_slist_length(item->uuids))
2828                         empty_uuid = true;
2829
2830                 g_slist_foreach(item->uuids, extract_unique_uuids, uuids);
2831         }
2832
2833         /* If no proximity filtering is set, disable it */
2834         if (*rssi == DISTANCE_VAL_INVALID)
2835                 *rssi = HCI_RSSI_INVALID;
2836
2837         /*
2838          * Empty_uuid variable determines wether there was any filter with no
2839          * uuids. In this case someone might be looking for all devices in
2840          * certain proximity, and we need to have empty uuids in kernel filter.
2841          */
2842         if (empty_uuid) {
2843                 g_slist_free(*uuids);
2844                 *uuids = NULL;
2845         }
2846
2847         if (has_regular_discovery) {
2848                 if (!has_filtered_discovery)
2849                         return 1;
2850
2851                 /*
2852                  * It there is both regular and filtered scan running, then
2853                  * clear whole fitler to report all devices.
2854                  */
2855                 *transport = get_scan_type(adapter);
2856                 *rssi = HCI_RSSI_INVALID;
2857                 g_slist_free(*uuids);
2858                 *uuids = NULL;
2859         }
2860
2861         return 0;
2862 }
2863
2864 static void populate_mgmt_filter_uuids(uint8_t (*mgmt_uuids)[16], GSList *uuids)
2865 {
2866         GSList *l;
2867
2868         for (l = uuids; l != NULL; l = g_slist_next(l)) {
2869                 bt_uuid_t uuid, u128;
2870                 uint128_t uint128;
2871
2872                 bt_string_to_uuid(&uuid, l->data);
2873                 bt_uuid_to_uuid128(&uuid, &u128);
2874
2875                 ntoh128((uint128_t *) u128.value.u128.data, &uint128);
2876                 htob128(&uint128, (uint128_t *) mgmt_uuids);
2877
2878                 mgmt_uuids++;
2879         }
2880 }
2881
2882 /*
2883  * This method merges all adapter filters into one that will be send to kernel.
2884  * cp_ptr is set to null when regular non-filtered discovery is needed,
2885  * otherwise it's pointing to filter. Returns 0 on succes, -1 on error
2886  */
2887 static int discovery_filter_to_mgmt_cp(struct btd_adapter *adapter,
2888                        struct mgmt_cp_start_service_discovery **cp_ptr)
2889 {
2890         GSList *uuids = NULL;
2891         struct mgmt_cp_start_service_discovery *cp;
2892         int rssi = DISTANCE_VAL_INVALID;
2893         int uuid_count;
2894         uint8_t discovery_type = 0;
2895
2896         DBG("");
2897
2898         if (merge_discovery_filters(adapter, &rssi, &discovery_type, &uuids)) {
2899                 /* There are only regular scans, run just regular scan. */
2900                 *cp_ptr = NULL;
2901                 return 0;
2902         }
2903
2904         uuid_count = g_slist_length(uuids);
2905
2906         cp = g_try_malloc(sizeof(*cp) + 16*uuid_count);
2907         *cp_ptr = cp;
2908         if (!cp) {
2909                 g_slist_free(uuids);
2910                 return -1;
2911         }
2912
2913         cp->type = discovery_type;
2914         cp->rssi = rssi;
2915         cp->uuid_count = htobs(uuid_count);
2916         populate_mgmt_filter_uuids(cp->uuids, uuids);
2917
2918         g_slist_free(uuids);
2919         return 0;
2920 }
2921
2922 static bool filters_equal(struct mgmt_cp_start_service_discovery *a,
2923                    struct mgmt_cp_start_service_discovery *b) {
2924         if (!a && !b)
2925                 return true;
2926
2927         if ((!a && b) || (a && !b))
2928                 return false;
2929
2930         if (a->type != b->type)
2931                 return false;
2932
2933         if (a->rssi != b->rssi)
2934                 return false;
2935
2936         /*
2937          * When we create mgmt_cp_start_service_discovery structure inside
2938          * discovery_filter_to_mgmt_cp, we always keep uuids sorted, and
2939          * unique, so we're safe to compare uuid_count, and uuids like that.
2940          */
2941         if (a->uuid_count != b->uuid_count)
2942                 return false;
2943
2944         if (memcmp(a->uuids, b->uuids, 16 * a->uuid_count) != 0)
2945                 return false;
2946
2947         return true;
2948 }
2949
2950 static int update_discovery_filter(struct btd_adapter *adapter)
2951 {
2952         struct mgmt_cp_start_service_discovery *sd_cp;
2953         GSList *l;
2954
2955
2956         DBG("");
2957
2958         if (discovery_filter_to_mgmt_cp(adapter, &sd_cp)) {
2959                 btd_error(adapter->dev_id,
2960                                 "discovery_filter_to_mgmt_cp returned error");
2961                 return -ENOMEM;
2962         }
2963
2964         for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
2965                 struct watch_client *client = l->data;
2966
2967                 if (!client->discovery_filter)
2968                         continue;
2969
2970                 if (client->discovery_filter->discoverable)
2971                         break;
2972         }
2973
2974         set_discovery_discoverable(adapter, l ? true : false);
2975
2976         /*
2977          * If filters are equal, then don't update scan, except for when
2978          * starting discovery.
2979          */
2980         if (filters_equal(adapter->current_discovery_filter, sd_cp) &&
2981             adapter->discovering != 0) {
2982                 DBG("filters were equal, deciding to not restart the scan.");
2983                 g_free(sd_cp);
2984                 return 0;
2985         }
2986
2987         g_free(adapter->current_discovery_filter);
2988         adapter->current_discovery_filter = sd_cp;
2989
2990         trigger_start_discovery(adapter, 0);
2991
2992         return -EINPROGRESS;
2993 }
2994
2995 static int discovery_stop(struct watch_client *client, bool exit)
2996 {
2997         struct btd_adapter *adapter = client->adapter;
2998         struct mgmt_cp_stop_discovery cp;
2999
3000         /* Check if there are more client discovering */
3001         if (g_slist_next(adapter->discovery_list)) {
3002                 discovery_remove(client, exit);
3003                 update_discovery_filter(adapter);
3004                 return 0;
3005         }
3006
3007         if (adapter->discovery_discoverable)
3008                 set_discovery_discoverable(adapter, false);
3009
3010         /*
3011          * In the idle phase of a discovery, there is no need to stop it
3012          * and so it is enough to send out the signal and just return.
3013          */
3014         if (adapter->discovery_enable == 0x00) {
3015                 discovery_remove(client, exit);
3016                 adapter->discovering = false;
3017                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3018                                 ADAPTER_INTERFACE, "Discovering");
3019
3020                 trigger_passive_scanning(adapter);
3021
3022                 return 0;
3023         }
3024 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3025         adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
3026 #endif
3027         cp.type = adapter->discovery_type;
3028
3029 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3030         cp.type = 0x01;
3031 #endif
3032         mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
3033                         adapter->dev_id, sizeof(cp), &cp,
3034                         stop_discovery_complete, client, NULL);
3035
3036         return -EINPROGRESS;
3037 }
3038
3039 static void discovery_destroy(void *user_data)
3040 {
3041         struct watch_client *client = user_data;
3042         struct btd_adapter *adapter = client->adapter;
3043
3044         DBG("owner %s", client->owner);
3045
3046         adapter->set_filter_list = g_slist_remove(adapter->set_filter_list,
3047                                                                 client);
3048
3049         adapter->discovery_list = g_slist_remove(adapter->discovery_list,
3050                                                                 client);
3051
3052         if (client->discovery_filter) {
3053                 free_discovery_filter(client->discovery_filter);
3054                 client->discovery_filter = NULL;
3055         }
3056
3057         g_free(client->owner);
3058         g_free(client);
3059
3060         /*
3061          * If there are other client discoveries in progress, then leave
3062          * it active. If not, then make sure to stop the restart timeout.
3063          */
3064         if (adapter->discovery_list)
3065                 return;
3066
3067 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3068         hci_clear_bit(BDADDR_BREDR, &adapter->discovery_type);
3069 #else
3070         adapter->discovery_type = 0x00;
3071 #endif
3072
3073         if (adapter->discovery_idle_timeout > 0) {
3074                 g_source_remove(adapter->discovery_idle_timeout);
3075                 adapter->discovery_idle_timeout = 0;
3076         }
3077
3078         if (adapter->temp_devices_timeout > 0) {
3079                 g_source_remove(adapter->temp_devices_timeout);
3080                 adapter->temp_devices_timeout = 0;
3081         }
3082
3083         discovery_cleanup(adapter);
3084
3085         adapter->temp_devices_timeout = g_timeout_add_seconds(TEMP_DEV_TIMEOUT,
3086                                                 remove_temp_devices, adapter);
3087 }
3088
3089 static void discovery_disconnect(DBusConnection *conn, void *user_data)
3090 {
3091         struct watch_client *client = user_data;
3092
3093         DBG("owner %s", client->owner);
3094
3095         discovery_stop(client, true);
3096 }
3097
3098 /*
3099  * Returns true if client was already discovering, false otherwise. *client
3100  * will point to discovering client, or client that have pre-set his filter.
3101  */
3102 static bool get_discovery_client(struct btd_adapter *adapter,
3103                                                 const char *owner,
3104                                                 struct watch_client **client)
3105 {
3106         GSList *list = g_slist_find_custom(adapter->discovery_list, owner,
3107                                                                 compare_sender);
3108         if (list) {
3109                 *client = list->data;
3110                 return true;
3111         }
3112
3113         list = g_slist_find_custom(adapter->set_filter_list, owner,
3114                                                                 compare_sender);
3115         if (list) {
3116                 *client = list->data;
3117                 return false;
3118         }
3119
3120         *client = NULL;
3121         return false;
3122 }
3123
3124 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
3125 static void le_discovery_destroy(void *user_data)
3126 {
3127         struct watch_client *client = user_data;
3128         struct btd_adapter *adapter = client->adapter;
3129
3130         DBG("owner %s", client->owner);
3131
3132         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3133                                                                 client);
3134
3135         g_free(client->owner);
3136         g_free(client);
3137
3138         /*
3139          * If there are other client discoveries in progress, then leave
3140          * it active. If not, then make sure to stop the restart timeout.
3141          */
3142         DBG("adapter->discovery_list[%p] adapter->le_discovery_list[%p]",
3143                         adapter->discovery_list, adapter->le_discovery_list);
3144         if (adapter->discovery_list || adapter->le_discovery_list)
3145                 return;
3146
3147         hci_clear_bit(BDADDR_LE_PUBLIC, &adapter->discovery_type);
3148         hci_clear_bit(BDADDR_LE_RANDOM, &adapter->discovery_type);
3149
3150         DBG("Restart Timer... adapter->discovery_type[%d]", adapter->discovery_type);
3151         if (adapter->discovery_idle_timeout > 0) {
3152                 g_source_remove(adapter->discovery_idle_timeout);
3153                 adapter->discovery_idle_timeout = 0;
3154         }
3155
3156         if (adapter->temp_devices_timeout > 0) {
3157                 g_source_remove(adapter->temp_devices_timeout);
3158                 adapter->temp_devices_timeout = 0;
3159         }
3160
3161         discovery_cleanup(adapter);
3162 }
3163
3164 static void le_discovery_disconnect(DBusConnection *conn, void *user_data)
3165 {
3166         struct watch_client *client = user_data;
3167         struct btd_adapter *adapter = client->adapter;
3168         struct mgmt_cp_stop_le_discovery cp;
3169
3170         DBG("owner %s", client->owner);
3171
3172         adapter->le_discovery_list = g_slist_remove(adapter->le_discovery_list,
3173                                                                 client);
3174
3175         /*
3176          * There is no need for extra cleanup of the client since that
3177          * will be done by the destroy callback.
3178          *
3179          * However in case this is the last client, the discovery in
3180          * the kernel needs to be disabled.
3181          */
3182         if (adapter->le_discovery_list)
3183                 return;
3184
3185         /*
3186          * In the idle phase of a discovery, there is no need to stop it
3187          * and so it is enough to send out the signal and just return.
3188          */
3189         if (adapter->discovery_enable == 0x00) {
3190                 adapter->le_discovering = false;
3191                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
3192                                         ADAPTER_INTERFACE, "LEDiscovering");
3193
3194                 if (adapter->discovering == false  && adapter->le_discovering == false) {
3195                         trigger_passive_scanning(adapter);
3196                         return;
3197                 }
3198         }
3199
3200         cp.type = 0x06;
3201
3202         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
3203                                 adapter->dev_id, sizeof(cp), &cp,
3204                                 stop_discovery_complete, client, NULL);
3205 }
3206
3207 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
3208 static void addr_filter_params_free(gpointer data)
3209 {
3210         adapter_le_address_filter_params_t *params = data;
3211
3212         g_free(params);
3213 }
3214
3215 static void uuid_filter_params_free(gpointer data)
3216 {
3217         adapter_le_uuid_params_t *params = data;
3218
3219         g_free((char *)params->uuid);
3220         g_free((char *)params->uuid_mask);
3221         g_free(params);
3222 }
3223
3224 static void manufacturer_filter_params_free(gpointer data)
3225 {
3226         adapter_le_manf_data_params_t *params = data;
3227
3228         g_free((char *)params->man_data);
3229         g_free((char *)params->man_data_mask);
3230         g_free(params);
3231 }
3232
3233 static void local_name_filter_params_free(gpointer data)
3234 {
3235         adapter_le_local_name_params_t *params = data;
3236
3237         g_free((char *)params->local_name);
3238         g_free(params);
3239 }
3240
3241 static void service_data_filter_params_free(gpointer data)
3242 {
3243         adapter_le_service_data_params_t *params = data;
3244
3245         g_free((char *)params->service_data);
3246         g_free((char *)params->service_data_mask);
3247         g_free(params);
3248 }
3249
3250 static void scan_filter_params_free(gpointer data)
3251 {
3252         adapter_le_scan_filter_param_t *params = data;
3253         g_free(params);
3254 }
3255
3256 int adapter_le_address_cmp(gconstpointer a, gconstpointer b)
3257 {
3258         const adapter_le_address_filter_params_t *params = a;
3259         const char *address = b;
3260         char addr[18];
3261
3262         ba2str(&params->broadcaster_addr, addr);
3263         return strcasecmp(addr, address);
3264 }
3265
3266 int adapter_le_uuid_cmp(gconstpointer a, gconstpointer b)
3267 {
3268         const adapter_le_uuid_params_t *params = a;
3269         const char *uuid = b;
3270
3271         return strcasecmp((const char *)params->uuid, uuid);
3272 }
3273
3274 int adapter_le_manufacturer_data_cmp(gconstpointer a, gconstpointer b)
3275 {
3276         const adapter_le_manf_data_params_t *params = a;
3277         const struct eir_msd *msd = b;
3278
3279         if (msd->company == params->company_id) {
3280                 /* if the advertisiement packet is an iBeacon */
3281                 if (msd->company == COMPANY_ID_APPLE)
3282                         return 0;
3283                 return strncasecmp((const char *)params->man_data,
3284                                                 (const char *)msd->data,
3285                                                 params->man_data_len);
3286         } else {
3287                 return -1;
3288         }
3289 }
3290
3291 int adapter_le_local_name_cmp(gconstpointer a, gconstpointer b)
3292 {
3293         const adapter_le_local_name_params_t *params = a;
3294         const char *name = b;
3295
3296         return strcasecmp(params->local_name, name);
3297 }
3298
3299 int adapter_le_service_data_cmp(gconstpointer a, gconstpointer b)
3300 {
3301         const adapter_le_service_data_params_t *params = a;
3302         const struct eir_sd *sd = b;
3303         /* Todo, the service data format for 16 bit, 32bit and
3304          * 128 bit uuids needs to addressed */
3305         return strncasecmp((const char *)(params->service_data),
3306                                         (const char *)sd->data,
3307                                         sd->data_len);
3308 }
3309
3310 int adapter_le_address_filter_index_cmp(gconstpointer a, gconstpointer b)
3311 {
3312         const adapter_le_address_filter_params_t *params = a;
3313         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3314
3315         return params->filter_index - filter_inex;
3316 }
3317
3318 int adapter_le_uuid_filter_index_cmp(gconstpointer a, gconstpointer b)
3319 {
3320         const adapter_le_uuid_params_t *params = a;
3321         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3322
3323         return params->filter_index - filter_inex;
3324 }
3325
3326 int adapter_le_manufacturer_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3327 {
3328         const adapter_le_manf_data_params_t *params = a;
3329         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3330
3331         return params->filter_index - filter_inex;
3332 }
3333
3334 int adapter_le_local_name_filter_index_cmp(gconstpointer a, gconstpointer b)
3335 {
3336         const adapter_le_local_name_params_t *params = a;
3337         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3338
3339         return params->filter_index - filter_inex;
3340 }
3341
3342 int adapter_le_service_data_filter_index_cmp(gconstpointer a, gconstpointer b)
3343 {
3344         const adapter_le_service_data_params_t *params = a;
3345         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3346
3347         return params->filter_index - filter_inex;
3348 }
3349
3350 int adapter_le_scan_params_filter_index_cmp(gconstpointer a, gconstpointer b)
3351 {
3352         const adapter_le_scan_filter_param_t *params = a;
3353         uint16_t filter_inex = GPOINTER_TO_UINT(b);
3354
3355         return params->index - filter_inex;
3356 }
3357
3358 static gboolean adapter_le_clear_platform_scan_filter_data(
3359                         struct btd_adapter *adapter, int filter_index)
3360 {
3361         DBG("");
3362         GSList *list;
3363         if (!adapter)
3364                 return FALSE;
3365
3366         list = g_slist_find_custom(adapter->addr_filters,
3367                 GINT_TO_POINTER(filter_index), adapter_le_address_filter_index_cmp);
3368         if (list && list->data) {
3369                 /* Delete info from the struct to list */
3370                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3371         }
3372         list = g_slist_find_custom(adapter->service_data_changed_filters,
3373                 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3374         if (list && list->data) {
3375                 /* Delete info from the struct to list */
3376                 adapter->service_data_changed_filters = g_slist_delete_link(adapter->service_data_changed_filters, list);
3377         }
3378
3379         list = g_slist_find_custom(adapter->service_uuid_filters,
3380                 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3381         if (list && list->data) {
3382                 /* Delete info from the struct to list */
3383                 adapter->service_uuid_filters = g_slist_delete_link(adapter->service_uuid_filters, list);
3384         }
3385
3386         list = g_slist_find_custom(adapter->solicit_data_filters,
3387                 GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3388         if (list && list->data) {
3389                 /* Delete info from the struct to list */
3390                 adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3391         }
3392
3393         list = g_slist_find_custom(adapter->local_name_filters,
3394                 GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
3395         if (list && list->data) {
3396                 /* Delete info from the struct to list */
3397                 adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
3398         }
3399
3400         list = g_slist_find_custom(adapter->manufaturer_data_filters,
3401                 GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3402         if (list && list->data) {
3403                 /* Delete info from the struct to list */
3404                 adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3405         }
3406
3407         list = g_slist_find_custom(adapter->service_data_filters,
3408                 GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3409         if (list && list->data) {
3410                 /* Delete info from the struct to list */
3411                 adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
3412         }
3413
3414         list = g_slist_find_custom(adapter->scan_params,
3415                 GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
3416         if (list && list->data) {
3417                 /* Delete info from the struct to list */
3418                 adapter->scan_params = g_slist_delete_link(adapter->scan_params, list);
3419         }
3420
3421         return TRUE;
3422 }
3423
3424 static gboolean adapter_le_enable_platform_scan_filtering(
3425                         struct btd_adapter *adapter, gboolean enable)
3426 {
3427         if (!adapter)
3428                 return FALSE;
3429
3430         DBG("Platform scan filtering enable[%d]", enable);
3431
3432         adapter->scan_filter_support = enable;
3433
3434         return TRUE;
3435 }
3436
3437
3438 static gboolean adapter_le_service_add_addr_scan_filter_data(struct btd_adapter *adapter,
3439                                                 int filter_index, gchar *string, int addr_type)
3440 {
3441         /* TYPE_DEVICE_ADDRESS */
3442         adapter_le_address_filter_params_t *params;
3443
3444         DBG("");
3445
3446         params = g_new0(adapter_le_address_filter_params_t, 1);
3447         if (!params)
3448                 return FALSE;
3449
3450         params->filter_index = filter_index;
3451         str2ba(string, &params->broadcaster_addr);
3452         params->bdaddr_type = addr_type;
3453
3454         /* Store the struct to list */
3455         adapter->addr_filters = g_slist_append(adapter->addr_filters, params);
3456         return TRUE;
3457 }
3458
3459 static const char *adapter_le_service_find_addr_scan_filter_data(
3460                                                 struct btd_adapter *adapter, gchar *string)
3461 {
3462         GSList *list;
3463         DBG("");
3464
3465         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3466         if (!list)
3467                 return NULL;
3468         else
3469                 return list->data;
3470
3471         return NULL;
3472 }
3473
3474 static gboolean adapter_le_service_delete_addr_scan_filter_data(struct btd_adapter *adapter,
3475                                                 int filter_index, gchar *string, int addr_type)
3476 {
3477         GSList *list;
3478         DBG("");
3479
3480         list = g_slist_find_custom(adapter->addr_filters, string, adapter_le_address_cmp);
3481         if (!list)
3482                 return FALSE;
3483         else
3484                 /* Delete info from the struct to list */
3485                 adapter->addr_filters = g_slist_delete_link(adapter->addr_filters, list);
3486
3487         return TRUE;
3488 }
3489
3490 static gboolean adapter_le_service_clear_addr_scan_filter_data(struct btd_adapter *adapter)
3491 {
3492         DBG("");
3493
3494         g_slist_free_full(adapter->addr_filters, addr_filter_params_free);
3495         adapter->addr_filters = NULL;
3496
3497         return TRUE;
3498 }
3499
3500 static gboolean adapter_le_service_add_uuid_scan_filter_data(struct btd_adapter *adapter,
3501                                                         int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3502                                                         uint8_t *p_uuid_mask, int uuid_mask_len)
3503 {
3504
3505         adapter_le_uuid_params_t *params;
3506         bt_uuid_t uuid;
3507
3508         DBG("");
3509
3510         params = g_new0(adapter_le_uuid_params_t, 1);
3511         if (!params)
3512                 return FALSE;
3513
3514         if (uuid_mask_len == UUID_16_LEN) {
3515                 uint16_t *uuid16 = (void *)p_uuid;
3516                 sdp_uuid16_create((uuid_t *)&uuid, get_be16(uuid16));
3517         } else if (uuid_mask_len == UUID_32_LEN) {
3518                 uint32_t *uuid32 = (void *)p_uuid;
3519                 sdp_uuid32_create((uuid_t *)&uuid, get_be32(uuid32));
3520         } else {
3521                 sdp_uuid128_create((uuid_t *)&uuid, p_uuid);
3522         }
3523         params->filter_index = filter_index;
3524         params->uuid = (uint8_t *)bt_uuid2string((uuid_t *)&uuid);
3525         params->uuid_mask = g_new0(uint8_t, uuid_mask_len);
3526         memcpy(params->uuid_mask, p_uuid_mask, uuid_mask_len);
3527         params->uuid_len = uuid_mask_len;
3528
3529         /* Store the struct to list */
3530         adapter->solicit_data_filters = g_slist_append(adapter->solicit_data_filters, params);
3531
3532         return TRUE;
3533 }
3534
3535 static adapter_le_uuid_params_t *adapter_le_service_find_uuid_scan_filter_data(struct btd_adapter *adapter,
3536                                                         uint8_t *p_uuid)
3537 {
3538         GSList *list;
3539         DBG("");
3540
3541         list = g_slist_find_custom(adapter->solicit_data_filters, p_uuid, adapter_le_uuid_cmp);
3542         if (!list)
3543                 return NULL;
3544         else
3545                 /* Delete info from the struct to list */
3546                 return list->data;
3547
3548         return NULL;
3549 }
3550
3551 static gboolean adapter_le_service_delete_uuid_scan_filter_data(struct btd_adapter *adapter,
3552                                                         int filter_index, gboolean is_solicited, uint8_t *p_uuid,
3553                                                         uint8_t *p_uuid_mask, int uuid_mask_len)
3554 {
3555         GSList *list;
3556         DBG("");
3557
3558         list = g_slist_find_custom(adapter->solicit_data_filters, GINT_TO_POINTER(filter_index), adapter_le_uuid_filter_index_cmp);
3559         if (!list)
3560                 return FALSE;
3561         else {
3562                 adapter_le_uuid_params_t *params = list->data;
3563                 /* Delete info from the struct to list */
3564                 if (params && strcasecmp((const char *)params->uuid, (const char *)p_uuid)) {
3565                         adapter->solicit_data_filters = g_slist_delete_link(adapter->solicit_data_filters, list);
3566                 }
3567         }
3568
3569         return TRUE;
3570 }
3571
3572 static gboolean adapter_le_service_clear_uuid_scan_filter_data(struct btd_adapter *adapter)
3573 {
3574         DBG("");
3575
3576         g_slist_free_full(adapter->solicit_data_filters, uuid_filter_params_free);
3577         adapter->solicit_data_filters = NULL;
3578
3579         return TRUE;
3580 }
3581
3582 static gboolean adapter_le_service_add_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3583                                                         int filter_index, int company_id, int company_id_mask,
3584                                                         uint8_t *p_data, uint8_t *p_mask, int data_len)
3585 {
3586
3587         adapter_le_manf_data_params_t *params;
3588
3589         DBG("");
3590
3591         params = g_new0(adapter_le_manf_data_params_t, 1);
3592         if (!params)
3593                 return FALSE;
3594
3595         params->filter_index = filter_index;
3596         params->company_id = company_id;
3597         params->company_id_mask = company_id_mask;
3598         params->man_data = g_new0(uint8_t, data_len);
3599         memcpy(params->man_data, p_data, data_len);
3600         params->man_data_mask = g_new0(uint8_t, data_len);
3601         memcpy(params->man_data_mask, p_mask, data_len);
3602         params->man_data_len = data_len;
3603
3604         /* Store the struct to list */
3605         adapter->manufaturer_data_filters = g_slist_append(adapter->manufaturer_data_filters, params);
3606
3607         return TRUE;
3608 }
3609
3610 static adapter_le_manf_data_params_t *adapter_le_service_find_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3611                                                         struct eir_msd *msd)
3612 {
3613         GSList *list;
3614         DBG("");
3615         list = g_slist_find_custom(adapter->manufaturer_data_filters, msd, adapter_le_manufacturer_data_cmp);
3616         if (!list)
3617                 return NULL;
3618         else
3619                 return list->data;
3620
3621         return NULL;
3622 }
3623
3624 static gboolean adapter_le_service_delete_manufacturer_scan_filter_data(struct btd_adapter *adapter,
3625                                                         int filter_index, int company_id, int company_id_mask,
3626                                                         uint8_t *p_data, uint8_t *p_mask, int data_len)
3627 {
3628         GSList *list;
3629         DBG("");
3630         list = g_slist_find_custom(adapter->manufaturer_data_filters, GINT_TO_POINTER(filter_index), adapter_le_manufacturer_data_filter_index_cmp);
3631         if (!list)
3632                 return FALSE;
3633         else {
3634                 adapter_le_manf_data_params_t *params = list->data;
3635                 /* Delete info from the struct to list */
3636                 if (params && strcasecmp((const char *)params->man_data, (const char *)p_data)) {
3637                         adapter->manufaturer_data_filters = g_slist_delete_link(adapter->manufaturer_data_filters, list);
3638                 }
3639         }
3640
3641         return TRUE;
3642 }
3643
3644 static gboolean adapter_le_service_clear_manufacturer_scan_filter_data(struct btd_adapter *adapter)
3645 {
3646         DBG("");
3647
3648         g_slist_free_full(adapter->manufaturer_data_filters, manufacturer_filter_params_free);
3649         adapter->manufaturer_data_filters = NULL;
3650
3651         return TRUE;
3652 }
3653
3654 static gboolean adapter_le_service_add_local_name_scan_filter_data(struct btd_adapter *adapter,
3655                                                                                         int filter_index, gchar *name)
3656 {
3657
3658         adapter_le_local_name_params_t *params;
3659
3660         DBG("");
3661
3662         params = g_new0(adapter_le_local_name_params_t, 1);
3663         if (!params)
3664                 return FALSE;
3665
3666         params->filter_index = filter_index;
3667         params->local_name = g_strdup(name);
3668         params->name_len = strlen(name);
3669
3670         /* Store the struct to list */
3671         adapter->local_name_filters = g_slist_append(adapter->local_name_filters, params);
3672
3673         return TRUE;
3674 }
3675
3676 static adapter_le_local_name_params_t *adapter_le_service_find_local_name_scan_filter_data(
3677                                                                                                 struct btd_adapter *adapter,
3678                                                                                                 gchar *name)
3679 {
3680         GSList *list;
3681         DBG("");
3682         list = g_slist_find_custom(adapter->local_name_filters, name, adapter_le_local_name_cmp);
3683         if (!list)
3684                 return NULL;
3685         else
3686                 return list->data;
3687
3688         return NULL;
3689 }
3690
3691 static gboolean adapter_le_service_delete_local_name_scan_filter_data(struct btd_adapter *adapter,
3692                                                                                                 int filter_index, gchar *name)
3693 {
3694         GSList *list;
3695         DBG("");
3696         list = g_slist_find_custom(adapter->local_name_filters, GINT_TO_POINTER(filter_index), adapter_le_local_name_filter_index_cmp);
3697         if (!list)
3698                 return FALSE;
3699         else {
3700                 adapter_le_local_name_params_t *params = list->data;
3701                 /* Delete info from the struct to list */
3702                 if (params && strcasecmp((const char *)params->local_name, (const char *)name)) {
3703                         adapter->local_name_filters = g_slist_delete_link(adapter->local_name_filters, list);
3704                 }
3705         }
3706
3707         return TRUE;
3708 }
3709
3710 static gboolean adapter_le_service_clear_local_name_scan_filter_data(struct btd_adapter *adapter)
3711 {
3712         DBG("");
3713
3714         g_slist_free_full(adapter->local_name_filters, local_name_filter_params_free);
3715         adapter->local_name_filters = NULL;
3716
3717         return TRUE;
3718 }
3719
3720 static gboolean adapter_le_service_add_service_scan_filter_data(struct btd_adapter *adapter,
3721                                                         int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
3722 {
3723         adapter_le_service_data_params_t *params;
3724
3725         DBG("");
3726
3727         params = g_new0(adapter_le_service_data_params_t, 1);
3728         if (!params)
3729                 return FALSE;
3730
3731         params->filter_index = filter_index;
3732         params->service_data = g_new0(uint8_t, data_len);
3733         memcpy(params->service_data, p_data, data_len);
3734         params->service_data_mask = g_new0(uint8_t, data_len);
3735         memcpy(params->service_data_mask, p_mask, data_len);
3736         params->service_data_len = data_len;
3737
3738         /* Store the struct to list */
3739         adapter->service_data_filters = g_slist_append(adapter->service_data_filters, params);
3740
3741         return TRUE;
3742 }
3743
3744 static adapter_le_service_data_params_t* adapter_le_service_find_service_scan_filter_data(
3745                                                         struct btd_adapter *adapter, struct eir_sd *sd)
3746 {
3747         GSList *list;
3748         DBG("");
3749
3750         list = g_slist_find_custom(adapter->service_data_filters, sd, adapter_le_service_data_cmp);
3751         if (!list)
3752                 return NULL;
3753         else
3754                 return list->data;
3755
3756         return NULL;
3757 }
3758
3759 static gboolean adapter_le_service_delete_service_scan_filter_data(struct btd_adapter *adapter,
3760                                                         int filter_index, uint8_t *p_data, uint8_t *p_mask, int data_len)
3761 {
3762         GSList *list;
3763         DBG("");
3764
3765         list = g_slist_find_custom(adapter->service_data_filters, GINT_TO_POINTER(filter_index), adapter_le_service_data_filter_index_cmp);
3766         if (!list)
3767                 return FALSE;
3768         else {
3769                 adapter_le_service_data_params_t *params = list->data;
3770                 /* Delete info from the struct to list */
3771                 if (params && strcasecmp((const char *)params->service_data, (const char *)p_data)) {
3772                         adapter->service_data_filters = g_slist_delete_link(adapter->service_data_filters, list);
3773                 }
3774         }
3775         return TRUE;
3776 }
3777
3778 static gboolean adapter_le_service_clear_service_scan_filter_data(struct btd_adapter *adapter)
3779 {
3780         DBG("");
3781
3782         g_slist_free_full(adapter->service_data_filters, service_data_filter_params_free);
3783         adapter->service_data_filters = NULL;
3784
3785         return TRUE;
3786 }
3787
3788 static gboolean adapter_le_service_add_scan_filter_params(struct btd_adapter *adapter,
3789                                                         adapter_le_scan_filter_param_t *params)
3790 {
3791         adapter_le_scan_filter_param_t *l_params;
3792
3793         DBG("");
3794
3795         l_params = g_new0(adapter_le_scan_filter_param_t, 1);
3796         if (!l_params)
3797                 return FALSE;
3798
3799         l_params->action = params->action;
3800         l_params->delivery_mode = params->delivery_mode;
3801         l_params->feature = params->feature;
3802         l_params->filter_logic_type = params->filter_logic_type;
3803         l_params->index = params->index;
3804         l_params->list_logic_type = params->list_logic_type;
3805         l_params->onfound_timeout = params->onfound_timeout;
3806         l_params->onfound_timeout_cnt = params->onfound_timeout_cnt;
3807         l_params->rssi_high_threshold = params->rssi_high_threshold;
3808         l_params->rssi_low_threshold = params->rssi_low_threshold;
3809
3810         /* Store the struct to list */
3811         adapter->scan_params = g_slist_append(adapter->scan_params, l_params);
3812
3813         return TRUE;
3814 }
3815
3816 static adapter_le_scan_filter_param_t *adapter_le_service_find_scan_filter_params(
3817                                                         struct btd_adapter *adapter, int filter_index)
3818 {
3819         GSList *list;
3820         DBG("");
3821
3822         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(filter_index), adapter_le_scan_params_filter_index_cmp);
3823         if (!list)
3824                 return NULL;
3825         else
3826                 return list->data;
3827
3828         return NULL;
3829 }
3830
3831 static gboolean adapter_le_service_delete_scan_filter_params(struct btd_adapter *adapter,
3832                                                         adapter_le_scan_filter_param_t *params)
3833 {
3834         GSList *list;
3835         DBG("");
3836
3837         list = g_slist_find_custom(adapter->scan_params, GINT_TO_POINTER(params->index), adapter_le_scan_params_filter_index_cmp);
3838         if (!list)
3839                 return FALSE;
3840         else
3841                 adapter->scan_params = g_slist_remove(adapter->scan_params, list);
3842
3843         return TRUE;
3844 }
3845
3846 static gboolean adapter_le_service_clear_scan_filter_params(struct btd_adapter *adapter)
3847 {
3848         DBG("");
3849
3850         g_slist_free_full(adapter->scan_params, scan_filter_params_free);
3851         adapter->scan_params = NULL;
3852
3853         return TRUE;
3854 }
3855
3856 int adapter_byte_arr_cmp_with_mask(const char *data1, const char *data2,
3857         const char *mask, int data_len)
3858 {
3859         int i;
3860         char a, b;
3861         if (data1 == NULL || data2 == NULL || mask == NULL)
3862                 return -1;
3863         for (i = 0; i < data_len; i++) {
3864                 a = data1[i] & mask[i];
3865                 b = data2[i] & mask[i];
3866                 if (a != b)
3867                         return (int)(a - b);
3868         }
3869         return 0;
3870 }
3871
3872 static uint8_t validate_for_filter_policy(struct btd_adapter *adapter,
3873                                                                 const struct eir_data *eir, gchar *addr)
3874 {
3875         uint8_t allow_report = NONE_REPORT;
3876
3877         if (adapter->scan_filter_support == FALSE)
3878                 allow_report = SCAN_REPORT;
3879         else {
3880                 if (adapter_le_service_find_addr_scan_filter_data(adapter, addr))
3881                         allow_report = SCAN_REPORT;
3882                 if (eir->name) {
3883                         if(adapter_le_service_find_local_name_scan_filter_data(adapter, eir->name))
3884                                 allow_report = SCAN_REPORT;
3885                         }
3886                 if (eir->sd_list) {
3887                         GSList *list = NULL;
3888                         for (list = eir->sd_list; list != NULL; list = g_slist_next(list)) {
3889                                 struct eir_sd *sd = list->data;
3890                                 if (sd != NULL) {
3891                                         static adapter_le_uuid_params_t *uuid_data = NULL;
3892                                         static adapter_le_service_data_params_t *service_data = NULL;
3893                                         static adapter_le_scan_filter_param_t *scan_param_data = NULL;
3894                                         uuid_data = adapter_le_service_find_uuid_scan_filter_data(adapter, (uint8_t *)sd->uuid);
3895                                         service_data = adapter_le_service_find_service_scan_filter_data(adapter, sd);
3896                                         if (service_data != NULL) {
3897                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)service_data->service_data,
3898                                                 (const char *)sd->data, (const char *)service_data->service_data_mask,
3899                                                 service_data->service_data_len)) {
3900                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
3901                                                                                 service_data->filter_index);
3902                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
3903                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
3904                                                                 allow_report = SCAN_REPORT;
3905                                                 }
3906                                         }
3907                                         if (uuid_data != NULL) {
3908                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)uuid_data->uuid,
3909                                                 (const char *)sd->uuid, (const char *)uuid_data->uuid_mask,
3910                                                 uuid_data->uuid_len)) {
3911                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
3912                                                                                                 uuid_data->filter_index);
3913                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
3914                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
3915                                                                 allow_report = SCAN_REPORT;
3916                                                 }
3917                                         }
3918                                         if (allow_report)
3919                                                 break;
3920                                 }
3921                         }
3922                 }
3923                 if (eir->msd_list) {
3924                         GSList *list = NULL;
3925                         for (list = eir->msd_list; list != NULL; list = g_slist_next(list)) {
3926                                 struct eir_msd *msd = list->data;
3927                                 if (msd != NULL) {
3928                                         static adapter_le_manf_data_params_t *manuf_data;
3929                                         static adapter_le_scan_filter_param_t *scan_param_data = NULL;
3930                                         manuf_data = adapter_le_service_find_manufacturer_scan_filter_data(adapter,
3931                                                         msd);
3932                                         if (manuf_data != NULL) {
3933                                                 if (!adapter_byte_arr_cmp_with_mask((const char *)msd->data,
3934                                                         (const char *)manuf_data->man_data, (const char *)manuf_data->man_data_mask,
3935                                                         manuf_data->man_data_len)) {
3936                                                         scan_param_data = adapter_le_service_find_scan_filter_params(adapter,
3937                                                                                                 manuf_data->filter_index);
3938                                                         if (scan_param_data && scan_param_data->rssi_high_threshold > eir->tx_power &&
3939                                                                 scan_param_data->rssi_low_threshold < eir->tx_power)
3940                                                                 allow_report = SCAN_REPORT;
3941                                                 }
3942                                                 if (msd->company == COMPANY_ID_APPLE)
3943                                                         allow_report = IBEACON_REPORT;
3944                                         }
3945                                 }
3946                         }
3947                 }
3948         }
3949         return allow_report;
3950 }
3951
3952 gboolean adapter_le_set_platform_scan_filter_params(struct btd_adapter *adapter,
3953                                         adapter_le_scan_filter_param_t *params)
3954 {
3955         gboolean ret = TRUE;
3956         DBG("adapter_le_scan_filter_param_t [%d]", params->index);
3957         adapter_le_scan_filter_action_type action_type = params->action;
3958
3959         if (action_type == ADD) {
3960                 ret = adapter_le_service_add_scan_filter_params(adapter, params);
3961         } else if (action_type == DELETE) {
3962                 ret = adapter_le_service_delete_scan_filter_params(adapter, params);
3963         } else if (action_type == CLEAR) {
3964                 ret = adapter_le_service_clear_scan_filter_params(adapter);
3965         } else {
3966                 DBG("filter_action error");
3967                 ret = FALSE;
3968         }
3969
3970         DBG("Scan Filter VSC :: Action [%x]",
3971                                         params->action);
3972         return ret;
3973 }
3974
3975 gboolean adapter_le_set_platform_scan_filter_data(struct btd_adapter *adapter,
3976                                                 int client_if, int action,
3977                                                 int filt_type, int filter_index,
3978                                                 int company_id,
3979                                                 int company_id_mask,
3980                                                 int uuid_len, uint8_t *p_uuid,
3981                                                 int uuid_mask_len, uint8_t *p_uuid_mask,
3982                                                 gchar *string, int addr_type,
3983                                                 int data_len, uint8_t *p_data,
3984                                                 int mask_len, uint8_t *p_mask)
3985 {
3986         gboolean ret = TRUE;
3987
3988         DBG("");
3989
3990         switch (filt_type) {
3991         case TYPE_DEVICE_ADDRESS: {
3992                 /* TYPE_DEVICE_ADDRESS */
3993                 adapter_le_scan_filter_action_type action_type = action;
3994
3995                 if (action_type == ADD) {
3996                         ret = adapter_le_service_add_addr_scan_filter_data(adapter,
3997                                                 filter_index, string, addr_type);
3998                 } else if (action_type == DELETE) {
3999                         ret = adapter_le_service_delete_addr_scan_filter_data(adapter,
4000                                                 filter_index, string, addr_type);
4001                 } else if (action_type == CLEAR) {
4002                         ret = adapter_le_service_clear_addr_scan_filter_data(adapter);
4003                 } else {
4004                         DBG("filter_action error");
4005                         ret = FALSE;
4006                 }
4007
4008                 break;
4009         }
4010
4011         case TYPE_SERVICE_UUID:
4012         case TYPE_SOLICIT_UUID: {
4013                 adapter_le_scan_filter_action_type action_type = action;
4014
4015                 gboolean is_solicited = (filt_type == TYPE_SOLICIT_UUID) ? TRUE : FALSE;
4016
4017                 if (uuid_len != UUID_16_LEN && uuid_len != UUID_32_LEN
4018                         && uuid_len != UUID_128_LEN) {
4019                         DBG("UUID length error");
4020                         return FALSE;
4021                 }
4022
4023                 if (uuid_len != uuid_mask_len) {
4024                         DBG("Both UUID and UUID_MASK length shoule be samed");
4025                         return FALSE;
4026                 }
4027
4028                 if (action_type == ADD) {
4029                         ret = adapter_le_service_add_uuid_scan_filter_data(adapter,
4030                                                 filter_index, is_solicited, p_uuid,
4031                                                 p_uuid_mask, uuid_len);
4032                 } else if (action_type == DELETE) {
4033                         ret = adapter_le_service_delete_uuid_scan_filter_data(adapter,
4034                                                 filter_index, is_solicited, p_uuid,
4035                                                 p_uuid_mask, uuid_len);
4036                 } else if (action_type == CLEAR) {
4037                         ret = adapter_le_service_clear_uuid_scan_filter_data(adapter);
4038                 } else {
4039                         DBG("filter_action error");
4040                         ret = FALSE;
4041                 }
4042
4043                 break;
4044         }
4045
4046         case TYPE_LOCAL_NAME: {
4047                 adapter_le_scan_filter_action_type action_type = action;
4048
4049                 if (action_type == ADD) {
4050                         ret = adapter_le_service_add_local_name_scan_filter_data(adapter,
4051                                                 filter_index, (gchar*)string);
4052                 } else if (action_type == DELETE) {
4053                         ret = adapter_le_service_delete_local_name_scan_filter_data(adapter,
4054                                                 filter_index, (gchar*)string);
4055                 } else if (action_type == CLEAR) {
4056                         ret = adapter_le_service_clear_local_name_scan_filter_data(adapter);
4057                 } else {
4058                         DBG("filter_action error");
4059                         ret = FALSE;
4060                 }
4061
4062                 break;
4063         }
4064
4065         case TYPE_MANUFACTURER_DATA: {
4066                 adapter_le_scan_filter_action_type action_type = action;
4067
4068                 if (data_len == 0 || (data_len != mask_len)) {
4069                         DBG("parameter length error");
4070                         return FALSE;
4071                 }
4072
4073                 if (action_type == ADD) {
4074                         ret = adapter_le_service_add_manufacturer_scan_filter_data(adapter,
4075                                                 filter_index,company_id, company_id_mask, p_data, p_mask, data_len);
4076                 } else if (action_type == DELETE) {
4077                         ret = adapter_le_service_delete_manufacturer_scan_filter_data(adapter,
4078                                                 filter_index, company_id, company_id_mask, p_data, p_mask, data_len);
4079                 } else if (action_type == CLEAR) {
4080                         ret = adapter_le_service_clear_manufacturer_scan_filter_data(adapter);
4081                 } else {
4082                         DBG("filter_action error");
4083                         ret = FALSE;
4084                 }
4085
4086                 break;
4087         }
4088
4089         case TYPE_SERVICE_DATA: {
4090                 adapter_le_scan_filter_action_type action_type = action;
4091
4092                 if (data_len == 0 || (data_len != mask_len)) {
4093                         DBG("parameter length error");
4094                         return FALSE;
4095                 }
4096
4097                 if (action_type == ADD) {
4098                         ret = adapter_le_service_add_service_scan_filter_data(adapter,
4099                                                 filter_index, p_data, p_mask, data_len);
4100                 } else if (action_type == DELETE) {
4101                         ret = adapter_le_service_delete_service_scan_filter_data(adapter,
4102                                                 filter_index, p_data, p_mask, data_len);
4103                 } else if (action_type == CLEAR) {
4104                         ret = adapter_le_service_clear_service_scan_filter_data(adapter);
4105                 } else {
4106                         DBG("filter_action error");
4107                         ret = FALSE;
4108                 }
4109
4110                 break;
4111         }
4112
4113         default:
4114                 DBG("filter_type error");
4115                 ret = FALSE;
4116         }
4117
4118         return ret;
4119 }
4120 #endif
4121
4122 static int set_adv_data_flag(uint8_t *adv_data, uint8_t *data, int data_len, void *user_data)
4123 {
4124         struct btd_adapter *adapter = user_data;
4125
4126         adv_data[0] = 2;
4127         adv_data[1] = EIR_FLAGS;
4128
4129         if (adapter->le_static_addr.b[5] != 0)
4130                 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER |
4131                                 EIR_SIM_HOST | EIR_BREDR_UNSUP;
4132         else
4133                 adv_data[2] = EIR_GEN_DISC | EIR_CONTROLLER | EIR_SIM_HOST;
4134
4135         memcpy(adv_data + 3, data, data_len);
4136         return data_len + 3;
4137 }
4138
4139 static int set_adv_data_device_name(uint8_t *adv_data, int adv_len, char *name)
4140 {
4141         int ad_type;
4142         int ad_len;
4143         int i, j;
4144         int name_len;
4145         uint8_t *data = NULL;
4146
4147         if (!name)
4148                 return adv_len;
4149
4150         data = g_memdup(adv_data, adv_len);
4151         if (!data)
4152                 return adv_len;
4153
4154         name_len = strlen(name);
4155
4156         for (i = 0; i <adv_len ; i++) {
4157                 ad_len = data[i];
4158                 ad_type = data[i + 1];
4159
4160                 if (ad_type == EIR_NAME_COMPLETE) {
4161                         /* Move to last position and update local name */
4162                         for (j = i; j < adv_len - 2; j++)
4163                                 adv_data[j] = data[j + 2];
4164
4165                         adv_data[j] = name_len + 1;
4166                         if (name_len > ADV_DATA_MAX_LENGTH - adv_len) {
4167                                 adv_data[j] = ADV_DATA_MAX_LENGTH - adv_len + 1;
4168                                 adv_data[j + 1] = EIR_NAME_SHORT;
4169                                 memcpy(adv_data + j + 2, name, ADV_DATA_MAX_LENGTH - adv_len);
4170                                 g_free(data);
4171                                 return ADV_DATA_MAX_LENGTH;
4172                         } else {
4173                                 adv_data[j + 1] = EIR_NAME_COMPLETE;
4174                                 memcpy(adv_data + j + 2, name, name_len);
4175                                 g_free(data);
4176                                 return adv_len + name_len;
4177                         }
4178
4179                 } else {
4180                         memcpy(adv_data + i, &data[i], ad_len + 1);
4181                         i = i + data[i];
4182                 }
4183         }
4184
4185         g_free(data);
4186         return adv_len;
4187 }
4188
4189 static int set_adv_data_tx_power(uint8_t *adv_data, int adv_len, int8_t tx_power)
4190 {
4191         int ad_type;
4192         int ad_len;
4193         int i, j;
4194         uint8_t *data = NULL;
4195
4196         data = g_memdup(adv_data, adv_len);
4197         if (!data)
4198                 return adv_len;
4199
4200         for (i = 0; i <adv_len ; i++) {
4201                 ad_len = data[i];
4202                 ad_type = data[i + 1];
4203
4204                 if (ad_type == EIR_TX_POWER) {
4205                         adv_data[i] = 2;
4206                         adv_data[i + 1] = EIR_TX_POWER;
4207                         adv_data[i + 2] = tx_power;
4208
4209                         for(j = i + 2; j < adv_len; j++)
4210                                 adv_data[j + 1] = data[j];
4211
4212                         g_free(data);
4213                         return adv_len + 1;
4214                 } else {
4215                         memcpy(adv_data + i, &data[i], ad_len + 1);
4216                         i = i + data[i];
4217                 }
4218         }
4219
4220         g_free(data);
4221         return adv_len;
4222 }
4223
4224
4225 static int adapter_le_set_missed_adv_data(uint8_t *p_data, uint8_t data_len,
4226                 gboolean is_scan_rsp, char *adapter_name, int8_t tx_power, uint8_t **adv_data, int *adv_len,
4227                 void *user_data)
4228 {
4229         uint8_t *data;
4230         int len;
4231
4232         data = g_malloc0(ADV_DATA_MAX_LENGTH);
4233         memcpy(data, p_data, data_len);
4234         len = data_len;
4235
4236         /* In case multi advertising, need to update the below AD type
4237                 since it handled into kernel */
4238         if (!is_scan_rsp) {
4239                 len = set_adv_data_flag(data, p_data, data_len, user_data);
4240         }
4241
4242         len = set_adv_data_tx_power(data, len, tx_power);
4243
4244         len = set_adv_data_device_name(data, len, adapter_name);
4245
4246         *adv_data = data;
4247         *adv_len = len;
4248         return 0;
4249 }
4250
4251 static DBusMessage *adapter_start_custom_discovery(DBusConnection *conn,
4252                                         DBusMessage *msg, void *user_data)
4253 {
4254         struct btd_adapter *adapter = user_data;
4255         const char *sender = dbus_message_get_sender(msg);
4256         struct watch_client *client;
4257         GSList *list;
4258         const gchar *disc_type;
4259
4260         DBG("sender %s", sender);
4261
4262         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4263                 return btd_error_not_ready(msg);
4264
4265         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &disc_type,
4266                                                         DBUS_TYPE_INVALID)) {
4267                 return btd_error_invalid_args(msg);
4268         }
4269
4270         DBG("discovery type = %s", disc_type);
4271
4272         /*Valid strings: "BREDR", "LE", "LE_BREDR" */
4273         if (g_strcmp0(disc_type, "BREDR") == 0)
4274                 adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
4275         else if (g_strcmp0(disc_type, "LE") == 0)
4276                 adapter->disc_type =  BT_DISC_TYPE_LE_ONLY;
4277         else if (g_strcmp0(disc_type, "LE_BREDR") == 0)
4278                 adapter->disc_type =  BT_DISC_TYPE_LE_BREDR;
4279         else
4280                 return btd_error_invalid_args(msg);
4281
4282         /*
4283          * Every client can only start one discovery, if the client
4284          * already started a discovery then return an error.
4285          */
4286         list = g_slist_find_custom(adapter->discovery_list, sender,
4287                                                 compare_sender);
4288         if (list)
4289                 return btd_error_busy(msg);
4290
4291         client = g_new0(struct watch_client, 1);
4292
4293         client->adapter = adapter;
4294         client->owner = g_strdup(sender);
4295         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4296                                                 discovery_disconnect, client,
4297                                                 discovery_destroy);
4298
4299         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
4300                                                                 client);
4301
4302         /*
4303          * Just trigger the discovery here. In case an already running
4304          * discovery in idle phase exists, it will be restarted right
4305          * away.
4306          */
4307         trigger_start_discovery(adapter, 0);
4308
4309         return dbus_message_new_method_return(msg);
4310 }
4311
4312 static DBusMessage *adapter_start_le_discovery(DBusConnection *conn,
4313                                         DBusMessage *msg, void *user_data)
4314 {
4315         struct btd_adapter *adapter = user_data;
4316         const char *sender = dbus_message_get_sender(msg);
4317         struct watch_client *client;
4318         GSList *list;
4319
4320         DBG("sender %s", sender);
4321
4322         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4323                 return btd_error_not_ready(msg);
4324
4325         /*
4326          * Every client can only start one discovery, if the client
4327          * already started a discovery then return an error.
4328          */
4329
4330         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4331         DBG("adapter->disc_type[%d]", adapter->disc_type);
4332         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4333
4334         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4335                                                 compare_sender);
4336         if (list)
4337                 return btd_error_busy(msg);
4338
4339         client = g_new0(struct watch_client, 1);
4340
4341         client->adapter = adapter;
4342         client->owner = g_strdup(sender);
4343         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
4344                                                 le_discovery_disconnect, client,
4345                                                 le_discovery_destroy);
4346
4347         adapter->le_discovery_list = g_slist_prepend(adapter->le_discovery_list,
4348                                                                 client);
4349
4350         /*
4351          * Just trigger the discovery here. In case an already running
4352          * discovery in idle phase exists, it will be restarted right
4353          * away.
4354          */
4355         trigger_start_le_discovery(adapter, 0);
4356
4357         return dbus_message_new_method_return(msg);
4358 }
4359
4360 static DBusMessage *adapter_stop_le_discovery(DBusConnection *conn,
4361                                         DBusMessage *msg, void *user_data)
4362 {
4363         struct btd_adapter *adapter = user_data;
4364         const char *sender = dbus_message_get_sender(msg);
4365         struct mgmt_cp_stop_le_discovery cp;
4366         struct watch_client *client;
4367         GSList *list;
4368
4369         DBG("sender %s", sender);
4370
4371         if (adapter->le_discovery_idle_timeout > 0) {
4372                 DBG("Remove LE scan trigger");
4373                 g_source_remove(adapter->le_discovery_idle_timeout);
4374                 adapter->le_discovery_idle_timeout = 0;
4375         }
4376
4377         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4378                 return btd_error_not_ready(msg);
4379
4380         list = g_slist_find_custom(adapter->le_discovery_list, sender,
4381                                                 compare_sender);
4382         if (!list)
4383                 return btd_error_failed(msg, "No discovery started");
4384
4385         client = list->data;
4386
4387         adapter->disc_type = BT_DISC_TYPE_LE_ONLY;
4388         DBG("adapter->disc_type[%d]", adapter->disc_type);
4389         DBG("adapter->discovery_type [%d]", adapter->discovery_type);
4390
4391         cp.type = adapter->discovery_type;
4392         DBG("cp.type %d", cp.type);
4393
4394         /*
4395          * As long as other discovery clients are still active, just
4396          * clenup client info and return success.
4397          */
4398         DBG("adapter->le_discovery_list %p", adapter->le_discovery_list);
4399         if (g_slist_next(adapter->le_discovery_list)) {
4400                 /*
4401                  * The destroy function will cleanup the client information and
4402                  * also remove it from the list of discovery clients.
4403                  */
4404                 g_dbus_remove_watch(dbus_conn, client->watch);
4405                 return dbus_message_new_method_return(msg);
4406         }
4407
4408         /*
4409          * In the idle phase of a discovery, there is no need to stop it
4410          * and so it is enough to send out the signal and just return.
4411          */
4412         DBG("cp.type %d", cp.type);
4413         DBG("adapter->discovery_enable %d", adapter->discovery_enable);
4414         if (adapter->discovery_enable == 0x00) {
4415                 adapter->le_discovering = false;
4416                 g_dbus_remove_watch(dbus_conn, client->watch);
4417                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
4418                                         ADAPTER_INTERFACE, "LEDiscovering");
4419
4420                 trigger_passive_scanning(adapter);
4421                 return dbus_message_new_method_return(msg);
4422         }
4423
4424         DBG("adapter->discovery_type %d", adapter->discovery_type);
4425         cp.type = 0x06;
4426         DBG("cp.type %d", cp.type);
4427         mgmt_send(adapter->mgmt, MGMT_OP_STOP_LE_DISCOVERY,
4428                                 adapter->dev_id, sizeof(cp), &cp,
4429                                 stop_le_discovery_complete, client, NULL);
4430
4431         client->msg = dbus_message_ref(msg);
4432         return NULL;
4433 }
4434
4435 static DBusMessage *adapter_set_advertising(DBusConnection *conn,
4436                                                 DBusMessage *msg, void *data)
4437 {
4438         struct btd_adapter *adapter = data;
4439         dbus_bool_t err;
4440         dbus_bool_t enable = FALSE;
4441         dbus_int32_t slot_id;
4442
4443         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4444                 return btd_error_not_ready(msg);
4445
4446         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &enable,
4447                                                 DBUS_TYPE_INT32, &slot_id,
4448                                                 DBUS_TYPE_INVALID))
4449                 return btd_error_invalid_args(msg);
4450
4451         if (adapter->adv_restart_timeout > 0)
4452                 return btd_error_in_progress(msg);
4453
4454         DBG("%s advertising slot_id %d", enable ? "Enable" : "Disable", slot_id);
4455
4456         if (adapter_le_is_supported_multi_advertising() && slot_id > 0)
4457                 err = adapter_le_enable_multi_adv(adapter, enable, slot_id);
4458         else
4459                 err = set_mode(adapter, MGMT_OP_SET_ADVERTISING, enable);
4460
4461         if (!err)
4462                 return btd_error_failed(msg, "Set Advertising failed");
4463
4464         if (enable)
4465                 create_advertiser(adapter, slot_id);
4466
4467         if (err && slot_id > 0)
4468                 advertising_state_changed(adapter, slot_id, enable);
4469
4470         return dbus_message_new_method_return(msg);
4471 }
4472
4473 static DBusMessage *adapter_set_advertising_params(DBusConnection *conn,
4474                                                 DBusMessage *msg, void *data)
4475 {
4476         struct btd_adapter *adapter = data;
4477         struct mgmt_cp_set_advertising_params cp;
4478         dbus_uint32_t interval_min;
4479         dbus_uint32_t interval_max;
4480         dbus_uint32_t filter_policy;
4481         dbus_uint32_t type;
4482         dbus_int32_t tx_power_level;
4483         dbus_int32_t slot_id;
4484         gboolean ret;
4485
4486         DBG("Set customised advertising parameters");
4487
4488         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4489                 return btd_error_not_ready(msg);
4490
4491         if (!dbus_message_get_args(msg, NULL,
4492                                 DBUS_TYPE_UINT32, &interval_min,
4493                                 DBUS_TYPE_UINT32, &interval_max,
4494                                 DBUS_TYPE_UINT32, &filter_policy,
4495                                 DBUS_TYPE_UINT32, &type,
4496                                 DBUS_TYPE_INT32, &tx_power_level,
4497                                 DBUS_TYPE_INT32, &slot_id,
4498                                 DBUS_TYPE_INVALID))
4499                 return btd_error_invalid_args(msg);
4500
4501         memset(&cp, 0, sizeof(cp));
4502
4503         DBG("advertising interval min %x, max %x, filter %x type %x, tx power %d",
4504                                 interval_min, interval_max, filter_policy, type, tx_power_level);
4505
4506         if (filter_policy > 0x03)
4507                 return btd_error_invalid_args(msg);
4508
4509         if (type > 0x04)
4510                 return btd_error_invalid_args(msg);
4511
4512         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4513                 adapter_le_adv_inst_info_t *p_inst;
4514                 adapter_le_adv_param_t *p_params;
4515
4516                 p_inst = g_malloc0(sizeof(adapter_le_adv_inst_info_t));
4517                 p_params = g_malloc0(sizeof(adapter_le_adv_param_t));
4518                 p_inst->inst_id = slot_id;
4519                 p_params->adv_int_min = interval_min;
4520                 p_params->adv_int_max = interval_max;
4521                 p_params->adv_type = type;
4522                 p_params->channel_map = 0x07;   /* fixed channel :: will be used all */
4523                 p_params->adv_filter_policy = filter_policy;
4524                 p_params->tx_power = tx_power_level;
4525
4526                 if (adapter->current_settings & MGMT_SETTING_PRIVACY) {
4527                         p_inst->bdaddr_type = 0x01;
4528                         bacpy(&p_inst->bdaddr, &adapter->rpa);
4529                 } else if (adapter->le_static_addr.b[5] != 0) {
4530                         p_inst->bdaddr_type = 0x01;
4531                         bacpy(&p_inst->bdaddr, &adapter->le_static_addr);
4532                 } else {
4533                         p_inst->bdaddr_type = 0x00;
4534                         bacpy(&p_inst->bdaddr, &adapter->bdaddr);
4535                 }
4536
4537                 ret = adapter_le_set_multi_adv_params(p_inst, p_params);
4538
4539                 g_free(p_inst);
4540                 g_free(p_params);
4541
4542                 if (ret)
4543                         return dbus_message_new_method_return(msg);
4544                 else
4545                         return btd_error_failed(msg, "set advertising param failed");
4546         } else {
4547                 cp.interval_max = interval_max;
4548                 cp.interval_min = interval_min;
4549                 cp.filter_policy = filter_policy;
4550                 cp.type = type;
4551
4552                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_PARAMS,
4553                                         adapter->dev_id, sizeof(cp), &cp,
4554                                         NULL, NULL, NULL) > 0)
4555                         return dbus_message_new_method_return(msg);
4556
4557                 return btd_error_failed(msg, "set advertising param failed");
4558         }
4559 }
4560
4561 static DBusMessage *adapter_set_advertising_data(DBusConnection *conn,
4562                                                 DBusMessage *msg, void *data)
4563 {
4564         struct btd_adapter *adapter = data;
4565         struct mgmt_cp_set_advertising_data cp;
4566         uint8_t *value;
4567         int32_t len = 0;
4568         dbus_int32_t slot_id;
4569         uint8_t *adv_data = NULL;
4570         int adv_len = 0;
4571         char *adapter_name = adapter->name;
4572         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
4573
4574         DBG("Set advertising data");
4575
4576         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4577                 return btd_error_not_ready(msg);
4578
4579         if (!dbus_message_get_args(msg, NULL,
4580                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4581                         DBUS_TYPE_INT32, &slot_id,
4582                         DBUS_TYPE_INVALID))
4583                 return btd_error_invalid_args(msg);
4584
4585         if (len > ADV_DATA_MAX_LENGTH - 3)
4586                 return btd_error_invalid_args(msg);
4587
4588         if (adapter->le_static_addr.b[5] != 0) {
4589                 char *ptr = NULL;
4590
4591                 g_strlcpy(le_name, adapter_name,
4592                                 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
4593                 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
4594                         *ptr = '\0';
4595
4596                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
4597                 adapter_name = le_name;
4598         }
4599
4600         adapter_le_set_missed_adv_data(value, len, FALSE,
4601                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
4602
4603         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4604                 if (adapter_le_set_multi_adv_data(slot_id, FALSE, adv_len, adv_data)) {
4605                         g_free(adv_data);
4606                         return dbus_message_new_method_return(msg);
4607                 } else {
4608                         g_free(adv_data);
4609                         return btd_error_failed(msg, "set advertising data failed");
4610                 }
4611         } else {
4612                 memcpy(&cp, adv_data, adv_len);
4613
4614                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_ADVERTISING_DATA,
4615                                                 adapter->dev_id, adv_len,
4616                                                 &cp, NULL, NULL, NULL) > 0) {
4617                         g_free(adv_data);
4618                         return dbus_message_new_method_return(msg);
4619                 }
4620
4621                 g_free(adv_data);
4622                 return btd_error_failed(msg, "set advertising data failed");
4623         }
4624 }
4625
4626 static DBusMessage *adapter_le_scan_filter_param_setup(DBusConnection *conn,
4627                                                 DBusMessage *msg, void *data)
4628 {
4629         struct btd_adapter *adapter = data;
4630 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4631         dbus_bool_t ctlr_filter_support = TRUE;
4632 #endif
4633         dbus_int32_t client_if, action, filt_index;
4634         dbus_int32_t feat_seln, list_logic_type, filt_logic_type;
4635         dbus_int32_t rssi_high_thres, rssi_low_thres, dely_mode;
4636         dbus_int32_t found_timeout, lost_timeout, found_timeout_cnt;
4637         adapter_le_scan_filter_param_t params;
4638         gboolean err;
4639
4640         DBG("adapter_le_scan_filter_param_setup");
4641
4642         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4643                 return btd_error_not_ready(msg);
4644
4645         if (adapter_le_get_scan_filter_size() == 0)
4646 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4647                 return btd_error_not_supported(msg);
4648 #else
4649                 ctlr_filter_support = FALSE;
4650 #endif
4651
4652         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4653                                                 DBUS_TYPE_INT32, &action,
4654                                                 DBUS_TYPE_INT32, &filt_index,
4655                                                 DBUS_TYPE_INT32, &feat_seln,
4656                                                 DBUS_TYPE_INT32, &list_logic_type,
4657                                                 DBUS_TYPE_INT32, &filt_logic_type,
4658                                                 DBUS_TYPE_INT32, &rssi_high_thres,
4659                                                 DBUS_TYPE_INT32, &rssi_low_thres,
4660                                                 DBUS_TYPE_INT32, &dely_mode,
4661                                                 DBUS_TYPE_INT32, &found_timeout,
4662                                                 DBUS_TYPE_INT32, &lost_timeout,
4663                                                 DBUS_TYPE_INT32, &found_timeout_cnt,
4664                                                 DBUS_TYPE_INVALID))
4665                 return btd_error_invalid_args(msg);
4666
4667         memset(&params, 0, sizeof(params));
4668
4669         params.action = action;
4670         params.index = filt_index;
4671         params.feature = feat_seln;
4672         params.filter_logic_type = filt_logic_type;
4673         params.list_logic_type = list_logic_type;
4674         params.delivery_mode = dely_mode;
4675         params.rssi_high_threshold = rssi_high_thres;
4676
4677         if (params.delivery_mode == ON_FOUND) {
4678                 params.rssi_low_threshold = rssi_low_thres;
4679                 params.onfound_timeout = found_timeout;
4680                 params.onfound_timeout_cnt = found_timeout_cnt;
4681                 params.onlost_timeout = lost_timeout;
4682         }
4683
4684 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4685         if (ctlr_filter_support)
4686 #endif
4687         err = adapter_le_set_scan_filter_params(&params);
4688 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4689         else
4690                 err = adapter_le_set_platform_scan_filter_params(adapter, &params);
4691 #endif
4692
4693         if (!err)
4694                 return btd_error_failed(msg, "Failed to scan filter param setup");
4695
4696         return dbus_message_new_method_return(msg);
4697 }
4698
4699 static DBusMessage *adapter_le_scan_filter_add_remove(DBusConnection *conn,
4700                                                 DBusMessage *msg, void *data)
4701 {
4702         struct btd_adapter *adapter = data;
4703         struct btd_device *dev = NULL;
4704         dbus_int32_t client_if, action, filt_type, filt_index;
4705         dbus_int32_t company_id, company_id_mask;
4706         gchar *str = NULL;
4707         dbus_uint32_t address_type = 0;
4708         uint8_t addr_type = 0;
4709         GSList *list;
4710         char string[30];
4711         uint8_t *p_uuid, *p_uuid_mask, *p_data, *p_mask;
4712         int32_t uuid_len = 0, uuid_mask_len = 0, data_len = 0, mask_len = 0;
4713         gboolean err;
4714 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4715         dbus_bool_t ctlr_filter_support = TRUE;
4716 #endif
4717
4718         DBG("adapter_le_scan_filter_add_remove");
4719
4720         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4721                 return btd_error_not_ready(msg);
4722
4723         /* if controller does not support vendor specific scan filtering feature
4724          * then add the filter into platform supported scan filters.
4725          */
4726         if (adapter_le_get_scan_filter_size() == 0) {
4727 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4728                 return btd_error_not_supported(msg);
4729 #else
4730                 ctlr_filter_support = FALSE;
4731 #endif
4732         }
4733
4734         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4735                                                 DBUS_TYPE_INT32, &action,
4736                                                 DBUS_TYPE_INT32, &filt_type,
4737                                                 DBUS_TYPE_INT32, &filt_index,
4738                                                 DBUS_TYPE_INT32, &company_id,
4739                                                 DBUS_TYPE_INT32, &company_id_mask,
4740                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid, &uuid_len,
4741                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_uuid_mask, &uuid_mask_len,
4742                                                 DBUS_TYPE_STRING, &str,
4743                                                 DBUS_TYPE_UINT32, &address_type,
4744                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_data, &data_len,
4745                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &p_mask, &mask_len,
4746                                                 DBUS_TYPE_INVALID))
4747                 return btd_error_invalid_args(msg);
4748
4749         if (filt_type == TYPE_DEVICE_ADDRESS) {
4750                 list = g_slist_find_custom(adapter->devices, str, device_rpa_cmp);
4751                 if (!list)
4752                         list = g_slist_find_custom(adapter->devices, str,
4753                                                                 device_address_cmp);
4754                 if (list)
4755                         dev = list->data;
4756                 if (dev && device_get_rpa_exist(dev) == true) {
4757                         ba2str(device_get_address(dev), string);
4758                         if (btd_device_get_bdaddr_type(dev) == BDADDR_LE_PUBLIC)
4759                                 addr_type = 0x00;
4760                         else
4761                                 addr_type = 0x01;
4762                 } else {
4763                         strncpy(string, str, sizeof(string) - 1);
4764                         addr_type = 0x00;
4765                 }
4766
4767                 DBG("addr %s, type %d", string, addr_type);
4768         } else {
4769                 strncpy(string, str, sizeof(string) - 1 );
4770         }
4771
4772 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4773         if (ctlr_filter_support)
4774 #endif
4775         err = adapter_le_set_scan_filter_data(client_if, action, filt_type,
4776                         filt_index, company_id, company_id_mask,
4777                         uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
4778                         string, addr_type, data_len, p_data, mask_len, p_mask);
4779 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4780         else
4781                 err = adapter_le_set_platform_scan_filter_data(adapter, client_if, action, filt_type,
4782                                 filt_index, company_id, company_id_mask,
4783                                 uuid_len, p_uuid, uuid_mask_len, p_uuid_mask,
4784                                 string, addr_type, data_len, p_data, mask_len, p_mask);
4785 #endif
4786         if (!err)
4787                 return btd_error_failed(msg, "Failed to add/remove filter");
4788
4789         return dbus_message_new_method_return(msg);
4790 }
4791
4792 static DBusMessage *adapter_le_scan_filter_clear(DBusConnection *conn,
4793                                                 DBusMessage *msg, void *data)
4794 {
4795         struct btd_adapter *adapter = data;
4796         dbus_int32_t client_if = 0;
4797         dbus_int32_t filt_index = 0;
4798         gboolean err;
4799 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4800         dbus_bool_t ctlr_filter_support = TRUE;
4801 #endif
4802
4803         DBG("adapter_le_scan_filter_clear");
4804
4805         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4806                 return btd_error_not_ready(msg);
4807
4808         if (adapter_le_get_scan_filter_size() == 0)
4809 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4810                 return btd_error_not_supported(msg);
4811 #else
4812                 ctlr_filter_support = FALSE;
4813 #endif
4814
4815         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4816                                                 DBUS_TYPE_INT32, &filt_index,
4817                                                 DBUS_TYPE_INVALID))
4818                 return btd_error_invalid_args(msg);
4819
4820 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4821         if (ctlr_filter_support)
4822 #endif
4823         err = adapter_le_clear_scan_filter_data(client_if, filt_index);
4824 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4825         else
4826                 err = adapter_le_clear_platform_scan_filter_data(adapter, filt_index);
4827 #endif
4828
4829         if (!err)
4830                 return btd_error_failed(msg, "Failed to clear filter");
4831
4832         return dbus_message_new_method_return(msg);
4833 }
4834
4835
4836 static DBusMessage *adapter_le_scan_filter_enable(DBusConnection *conn,
4837                                                 DBusMessage *msg, void *data)
4838 {
4839         struct btd_adapter *adapter = data;
4840         dbus_bool_t enable = FALSE;
4841         dbus_int32_t client_if = 0;
4842         gboolean err;
4843 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4844         dbus_bool_t ctlr_filter_support = TRUE;
4845 #endif
4846
4847         DBG("adapter_le_scan_filter_enable");
4848
4849         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4850                 return btd_error_not_ready(msg);
4851
4852 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4853         /* if controller does not support vendor specific scan filtering feature
4854          * then enable platform supported scan filtering functionalites.
4855          */
4856 #endif
4857         if (adapter_le_get_scan_filter_size() == 0)
4858 #ifndef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4859                 return btd_error_not_supported(msg);
4860 #else
4861                 ctlr_filter_support = FALSE;
4862 #endif
4863
4864         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &client_if,
4865                                                 DBUS_TYPE_BOOLEAN, &enable,
4866                                                 DBUS_TYPE_INVALID))
4867                 return btd_error_invalid_args(msg);
4868
4869 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4870         if (ctlr_filter_support)
4871 #endif
4872         err = adapter_le_enable_scan_filtering(enable);
4873 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
4874         else
4875                 err = adapter_le_enable_platform_scan_filtering(adapter, enable);
4876 #endif
4877
4878         if (!err)
4879                 return btd_error_failed(msg, "Failed to enable scan filtering");
4880
4881         return dbus_message_new_method_return(msg);
4882 }
4883
4884 static DBusMessage *adapter_le_set_scan_params(DBusConnection *conn,
4885                                                 DBusMessage *msg, void *data)
4886 {
4887         struct btd_adapter *adapter = data;
4888         struct mgmt_cp_le_set_scan_params cp;
4889         uint32_t type;
4890         uint32_t interval;
4891         uint32_t window;
4892
4893         DBG("Set scan parameters");
4894
4895         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4896                 return btd_error_not_ready(msg);
4897
4898         if (!dbus_message_get_args(msg, NULL,
4899                                 DBUS_TYPE_UINT32, &type,
4900                                 DBUS_TYPE_UINT32, &interval,
4901                                 DBUS_TYPE_UINT32, &window,
4902                                 DBUS_TYPE_INVALID))
4903                 return btd_error_invalid_args(msg);
4904
4905         DBG("scan type %x, interval %x, window %x",
4906                                 type, interval, window);
4907         memset(&cp, 0, sizeof(cp));
4908
4909         cp.type = type;
4910         cp.interval = interval;
4911         cp.window = window;
4912         adapter->scan_type = type;
4913
4914         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_SCAN_PARAMS,
4915                                         adapter->dev_id, sizeof(cp), &cp,
4916                                         NULL, NULL, NULL) > 0)
4917                 return dbus_message_new_method_return(msg);
4918
4919         return btd_error_failed(msg, "set scan parameters failed");
4920 }
4921
4922 static DBusMessage *adapter_set_scan_rsp_data(DBusConnection *conn,
4923                                                 DBusMessage *msg, void *data)
4924 {
4925         struct btd_adapter *adapter = data;
4926         struct mgmt_cp_set_scan_rsp_data cp;
4927         uint8_t *value;
4928         int32_t len = 0;
4929         dbus_int32_t slot_id;
4930         uint8_t *adv_data = NULL;
4931         int adv_len = 0;
4932
4933         char *adapter_name = adapter->name;
4934         char le_name[MAX_NAME_LENGTH + 1] = { 0 };
4935
4936         DBG("Set scan response data");
4937
4938         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
4939                 return btd_error_not_ready(msg);
4940
4941         if (!dbus_message_get_args(msg, NULL,
4942                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
4943                         DBUS_TYPE_INT32, &slot_id,
4944                         DBUS_TYPE_INVALID))
4945                 return btd_error_invalid_args(msg);
4946
4947         if (len > SCAN_RESPONSE_DATA_LENGTH_MAX)
4948                 return btd_error_invalid_args(msg);
4949
4950         if (adapter->le_static_addr.b[5] != 0) {
4951                 char *ptr = NULL;
4952
4953                 g_strlcpy(le_name, adapter_name,
4954                                 sizeof(le_name) - LE_BEARER_POSTFIX_LEN);
4955                 if (!g_utf8_validate(le_name, -1, (const char **)&ptr))
4956                         *ptr = '\0';
4957
4958                 g_strlcat(le_name, LE_BEARER_POSTFIX, sizeof(le_name));
4959                 adapter_name = le_name;
4960         }
4961
4962         adapter_le_set_missed_adv_data(value, len, TRUE,
4963                         adapter_name, adapter->adv_tx_power, &adv_data, &adv_len, adapter);
4964
4965         if (adapter_le_is_supported_multi_advertising() && slot_id > 0) {
4966                 if (adapter_le_set_multi_adv_data(slot_id, TRUE, adv_len, (uint8_t *)adv_data)) {
4967                         g_free(adv_data);
4968                         return dbus_message_new_method_return(msg);
4969                 } else {
4970                         g_free(adv_data);
4971                         return btd_error_failed(msg, "set advertising data failed");
4972                 }
4973         } else {
4974                 memcpy(&cp, adv_data, adv_len);
4975
4976                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_SCAN_RSP_DATA,
4977                                                 adapter->dev_id, adv_len, &cp,
4978                                                 NULL, NULL, NULL) > 0) {
4979                         g_free(adv_data);
4980                         return dbus_message_new_method_return(msg);
4981                 }
4982
4983                 g_free(adv_data);
4984                 return btd_error_failed(msg, "set scan reponse data failed");
4985         }
4986 }
4987
4988 static DBusMessage *adapter_add_device_white_list(DBusConnection *conn,
4989                                         DBusMessage *msg, void *data)
4990 {
4991         struct btd_adapter *adapter = data;
4992         struct mgmt_cp_add_dev_white_list cp;
4993         const gchar *address;
4994         bdaddr_t bdaddr;
4995         dbus_uint32_t address_type;
4996         struct btd_device *dev;
4997
4998         DBG("Add device whie list");
4999         if (dbus_message_get_args(msg, NULL,
5000                                         DBUS_TYPE_STRING, &address,
5001                                         DBUS_TYPE_UINT32, &address_type,
5002                                         DBUS_TYPE_INVALID) == FALSE)
5003                 return btd_error_invalid_args(msg);
5004
5005         if (bachk(address) < 0)
5006                 return btd_error_invalid_args(msg);
5007
5008         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5009                 return btd_error_not_ready(msg);
5010
5011         DBG("addr %s, type %d", address, address_type);
5012         str2ba(address, &bdaddr);
5013
5014         dev = btd_adapter_find_device(adapter, &bdaddr,
5015                         address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5016         if (dev && device_get_rpa_exist(dev) == true) {
5017                 if (adapter_le_is_supported_offloading() == FALSE) {
5018                         error("Spec based command is not supported yet");
5019                         return btd_error_not_supported(msg);
5020                 }
5021
5022                 /* Add IRK value to list */
5023                 if (adapter_le_add_irk_to_list(device_get_irk_value(dev),
5024                                         device_get_address(dev),
5025                                         btd_device_get_bdaddr_type(dev))) {
5026                         return dbus_message_new_method_return(msg);
5027                 } else {
5028                         return btd_error_failed(msg, "Add LE IRK to list failed");
5029                 }
5030         }
5031
5032         memset(&cp, 0, sizeof(cp));
5033
5034         cp.bdaddr_type = address_type;
5035         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5036
5037         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEV_WHITE_LIST,
5038                                         adapter->dev_id, sizeof(cp), &cp,
5039                                         NULL, NULL, NULL) > 0)
5040                 return dbus_message_new_method_return(msg);
5041
5042         return btd_error_failed(msg, "add device white list failed");
5043 }
5044
5045 static DBusMessage *adapter_remove_device_white_list(DBusConnection *conn,
5046                                         DBusMessage *msg, void *data)
5047 {
5048         struct btd_adapter *adapter = data;
5049         struct mgmt_cp_remove_dev_white_list cp;
5050         const gchar *address;
5051         bdaddr_t bdaddr;
5052         dbus_uint32_t address_type;
5053         struct btd_device *dev;
5054
5055         DBG("Remove device whie list");
5056
5057         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5058                 return btd_error_not_ready(msg);
5059
5060         if (dbus_message_get_args(msg, NULL,
5061                                         DBUS_TYPE_STRING, &address,
5062                                         DBUS_TYPE_UINT32, &address_type,
5063                                         DBUS_TYPE_INVALID) == FALSE)
5064                 return btd_error_invalid_args(msg);
5065
5066         if (bachk(address) < 0)
5067                 return btd_error_invalid_args(msg);
5068
5069         DBG("addr %s, type %d", address, address_type);
5070         str2ba(address, &bdaddr);
5071
5072         dev = btd_adapter_find_device(adapter, &bdaddr,
5073                         address_type ? BDADDR_LE_RANDOM : BDADDR_LE_PUBLIC);
5074         if (dev && device_get_rpa_exist(dev) == true) {
5075                 if (adapter_le_is_supported_offloading() == FALSE) {
5076                         error("Spec based command is not supported yet");
5077                         return btd_error_not_supported(msg);
5078                 }
5079
5080                 /* Remove IRK value to list */
5081                 if (adapter_le_remove_irk_to_list(device_get_address(dev),
5082                                         btd_device_get_bdaddr_type(dev))) {
5083                         return dbus_message_new_method_return(msg);
5084                 } else {
5085                         return btd_error_failed(msg, "Remove IRK is failed");
5086                 }
5087         }
5088
5089         memset(&cp, 0, sizeof(cp));
5090
5091         cp.bdaddr_type = address_type;
5092         memcpy(&cp.bdaddr, &bdaddr, sizeof(bdaddr_t));
5093
5094         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEV_FROM_WHITE_LIST,
5095                                         adapter->dev_id, sizeof(cp), &cp,
5096                                         NULL, NULL, NULL) > 0)
5097                 return dbus_message_new_method_return(msg);
5098
5099         return btd_error_failed(msg, "remove device white list failed");
5100 }
5101
5102 static DBusMessage *adapter_clear_device_white_list(DBusConnection *conn,
5103                                         DBusMessage *msg, void *data)
5104 {
5105         struct btd_adapter *adapter = data;
5106
5107         DBG("Clear device whie list");
5108
5109         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5110                 return btd_error_not_ready(msg);
5111
5112         if (mgmt_send(adapter->mgmt, MGMT_OP_CLEAR_DEV_WHITE_LIST,
5113                                         adapter->dev_id, 0, NULL,
5114                                         NULL, NULL, NULL) > 0)
5115                 return dbus_message_new_method_return(msg);
5116
5117         return btd_error_failed(msg, "clear white list failed");
5118 }
5119
5120 static DBusMessage *adapter_set_le_privacy(DBusConnection *conn,
5121                                         DBusMessage *msg, void *data)
5122 {
5123         struct btd_adapter *adapter = data;
5124         dbus_bool_t err;
5125         dbus_bool_t enable_privacy = FALSE;
5126
5127         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
5128                 return btd_error_not_supported(msg);
5129
5130         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN,
5131                                 &enable_privacy, DBUS_TYPE_INVALID))
5132                 return btd_error_invalid_args(msg);
5133
5134         if (enable_privacy) {
5135                 if (adapter->current_settings & MGMT_SETTING_PRIVACY)
5136                         return btd_error_already_exists(msg);
5137         } else {
5138                 if (!(adapter->current_settings & MGMT_SETTING_PRIVACY))
5139                         return btd_error_already_exists(msg);
5140         }
5141
5142         err = set_privacy(adapter, enable_privacy);
5143
5144         if (!err) {
5145                 return btd_error_failed(msg, "Set Le Privacy failed");
5146         } else {
5147                 if (enable_privacy)
5148                         adapter->current_settings = adapter->current_settings | MGMT_SETTING_PRIVACY;
5149                 else
5150                         adapter->current_settings = adapter->current_settings & ~(SETTING_PRIVACY_MASK);
5151         }
5152
5153         return dbus_message_new_method_return(msg);
5154 }
5155
5156 static void init_le_static_address(struct btd_adapter *adapter)
5157 {
5158         int fd;
5159         int ret;
5160         char address[18];
5161         char dirname[PATH_MAX];
5162         int i;
5163         bdaddr_t le_static_addr;
5164
5165         le_static_addr.b[5] = adapter->bdaddr.b[5] | 0xc0;
5166         for (i = 0; i < 5; i++) {
5167                 le_static_addr.b[i] =
5168                         (adapter->bdaddr.b[i] & 0x7f) << 1 |
5169                         (adapter->bdaddr.b[i] & 0x80) >> 7;
5170         }
5171
5172         /*
5173          * < How to get Public address from above static address >
5174          *
5175          * for (i = 0; i < 5; i++) {
5176          *      bredr_addr.b[i] =
5177          *              (adapter->le_static_addr.b[i] & 0xfe) >> 1 |
5178          *              (adapter->le_static_addr.b[i] & 0x01) << 7;
5179          * }
5180          * bredr_addr.b[5] = {the value from advertising data}
5181          */
5182
5183         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5184         fd = open(dirname, O_WRONLY | O_CREAT, 0644);
5185
5186         if (fd >= 0) {
5187                 ba2str(&le_static_addr, address);
5188                 DBG("LE static random : %s", address);
5189                 ret = write(fd, address, strlen(address));
5190                 if (ret < 0) {
5191                         error("Cannot save LE address : %s",
5192                                         strerror(errno));
5193                 }
5194
5195                 ret = fdatasync(fd);
5196                 if (ret < 0)
5197                         error("sync failed : %s", strerror(errno));
5198
5199                 close(fd);
5200         } else {
5201                 error("Cannot save LE address");
5202         }
5203 }
5204
5205 static void set_le_static_address(struct btd_adapter *adapter)
5206 {
5207         int fd;
5208         int ret;
5209         char address[18];
5210         char dirname[PATH_MAX];
5211
5212         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s", "le_static_addr");
5213         if (access(dirname, F_OK) < 0)
5214                 init_le_static_address(adapter);
5215
5216         fd = open(dirname, O_RDONLY);
5217         if (fd >= 0) {
5218                 ret = read(fd, address, sizeof(address));
5219                 if (ret >= 17) {
5220                         /* xx:xx:xx:xx:xx:xx */
5221                         address[17] = '\0';
5222                         DBG("LE static random : %s", address);
5223                         str2ba(address, &adapter->le_static_addr);
5224                         adapter->le_static_addr.b[5] |= 0xc0;
5225                 } else
5226                         error("Invalid LE address");
5227                 close(fd);
5228         } else {
5229                 error("Cannot get LE address");
5230         }
5231
5232         return;
5233 }
5234
5235 static void set_le_static_address_complete(uint8_t status, uint16_t length,
5236                                         const void *param, void *user_data)
5237 {
5238         struct btd_adapter *adapter = user_data;
5239
5240         DBG("index %u status 0x%02x", adapter->dev_id, status);
5241
5242         if (status != MGMT_STATUS_SUCCESS) {
5243                 error("Failed to set static address for index %u: %s (0x%02x)",
5244                                 adapter->dev_id, mgmt_errstr(status), status);
5245                 if (adapter->le_static_addr.b[5] != 0)
5246                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5247                 else
5248                         set_le_static_address(adapter);
5249                 return;
5250         }
5251
5252         return;
5253 }
5254
5255 static DBusMessage *adapter_set_le_static_address(DBusConnection *conn,
5256                                         DBusMessage *msg, void *data)
5257 {
5258         struct btd_adapter *adapter = data;
5259         dbus_bool_t is_enable = FALSE;
5260         struct mgmt_cp_set_static_address cp;
5261
5262         if (!(adapter->supported_settings & MGMT_OP_SET_STATIC_ADDRESS)) {
5263                 error("LE static address is not supported");
5264                 return btd_error_not_supported(msg);
5265         }
5266
5267         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_BOOLEAN, &is_enable,
5268                                 DBUS_TYPE_INVALID)) {
5269                 error("Invalid arguments");
5270                 return btd_error_invalid_args(msg);
5271         }
5272
5273         memset(&cp, 0x00, sizeof(cp));
5274         if (is_enable)  {
5275                 if (adapter->le_static_addr.b[5] != 0) {
5276                         DBG("LE static address is already configured");
5277                         return dbus_message_new_method_return(msg);
5278                 }
5279                 set_le_static_address(adapter);
5280                 bacpy(&cp.bdaddr, &adapter->le_static_addr);
5281         } else {
5282                 if (adapter->le_static_addr.b[5] == 0) {
5283                         DBG("LE static address is not configured");
5284                         return dbus_message_new_method_return(msg);
5285                 }
5286                 bacpy(&adapter->le_static_addr, BDADDR_ANY);
5287         }
5288         DBG("Set static random address : %d", is_enable);
5289
5290         if (mgmt_send(mgmt_master, MGMT_OP_SET_STATIC_ADDRESS, adapter->dev_id,
5291                         sizeof(cp), &cp,
5292                         set_le_static_address_complete, adapter, NULL) <= 0) {
5293                 error("Failed to set static address : %d", is_enable);
5294                 if (is_enable)
5295                         bacpy(&adapter->le_static_addr, BDADDR_ANY);
5296                 else
5297                         set_le_static_address(adapter);
5298                 return btd_error_failed(msg, "Unable to set static address");
5299         }
5300
5301         return dbus_message_new_method_return(msg);
5302 }
5303
5304 static DBusMessage *adapter_enable_rssi(DBusConnection *conn,
5305                                                 DBusMessage *msg, void *data)
5306 {
5307         struct btd_adapter *adapter = data;
5308         struct mgmt_cp_set_enable_rssi cp;
5309         struct mgmt_cp_disable_rssi cp_dis;
5310         bdaddr_t bt_addr = { { 0, } };
5311         const gchar *address = NULL;
5312
5313         const char *sender = dbus_message_get_sender(msg);
5314         dbus_int32_t link_type;
5315         dbus_int32_t low_threshold;
5316         dbus_int32_t in_range_threshold;
5317         dbus_int32_t high_threshold;
5318
5319         DBG("Enable RSSI called");
5320         DBG("sender %s", sender);
5321         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5322                 return btd_error_not_ready(msg);
5323
5324         if (!dbus_message_get_args(msg, NULL,
5325                                 DBUS_TYPE_STRING, &address,
5326                                 DBUS_TYPE_INT32, &link_type,
5327                                 DBUS_TYPE_INT32, &low_threshold,
5328                                 DBUS_TYPE_INT32, &in_range_threshold,
5329                                 DBUS_TYPE_INT32, &high_threshold,
5330                                 DBUS_TYPE_INVALID))
5331                 return btd_error_invalid_args(msg);
5332
5333         DBG("Enable RSSI: [%s %d %d %d %d]", address, link_type,
5334                         low_threshold, in_range_threshold, high_threshold);
5335
5336         DBG("BT address [%s]", address);
5337         memset(&bt_addr, 0, sizeof(bdaddr_t));
5338         str2ba(address, &bt_addr);
5339         memset(&cp, 0, sizeof(struct mgmt_cp_set_enable_rssi));
5340         memset(&cp_dis, 0, sizeof(struct mgmt_cp_disable_rssi));
5341
5342         if (bachk(address) < 0)
5343                 return btd_error_invalid_args(msg);
5344
5345 //      if (!btd_adapter_find_device(adapter, address))
5346 //              return btd_error_not_found(msg);
5347
5348         if (low_threshold == 0 && in_range_threshold == 0 && high_threshold == 0) {
5349                 cp_dis.bdaddr = bt_addr;
5350                 cp_dis.link_type = link_type;
5351                 DBG("Disable Request");
5352                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_DISABLE,
5353                                         adapter->dev_id, sizeof(cp_dis), &cp_dis,
5354                                         NULL, NULL, NULL) > 0)
5355                                         return dbus_message_new_method_return(msg);
5356         } else {
5357                 cp.low_th = low_threshold;
5358                 cp.in_range_th = in_range_threshold;
5359                 cp.high_th = high_threshold;
5360                 cp.bdaddr = bt_addr;
5361                 cp.link_type = link_type;
5362                 DBG("Enable Request");
5363                 if (mgmt_send(adapter->mgmt, MGMT_OP_SET_RSSI_ENABLE,
5364                                         adapter->dev_id, sizeof(cp), &cp,
5365                                         NULL, NULL, NULL) > 0)
5366                         return dbus_message_new_method_return(msg);
5367         }
5368         return btd_error_failed(msg, "Enable/Disable RSSI Failed");
5369 }
5370
5371 static DBusMessage *adapter_get_rssi(DBusConnection *conn,
5372                                                 DBusMessage *msg, void *data)
5373 {
5374         struct btd_adapter *adapter = data;
5375         struct mgmt_cp_get_raw_rssi cp;
5376         bdaddr_t bt_addr;
5377         const gchar *address = NULL;
5378         dbus_int32_t link_type;
5379         const char *sender = dbus_message_get_sender(msg);
5380
5381         DBG("Get RSSI called");
5382         DBG("sender %s", sender);
5383         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5384                 return btd_error_not_ready(msg);
5385
5386         if (!dbus_message_get_args(msg, NULL,
5387                                 DBUS_TYPE_STRING, &address,
5388                                 DBUS_TYPE_INT32, &link_type,
5389                                 DBUS_TYPE_INVALID))
5390                 return btd_error_invalid_args(msg);
5391
5392         DBG("BT address [%s] link type [%d]", address, link_type);
5393         memset(&bt_addr, 0, sizeof(bdaddr_t));
5394         str2ba(address, &bt_addr);
5395         memset(&cp, 0, sizeof(struct mgmt_cp_get_raw_rssi));
5396
5397         if (bachk(address) < 0)
5398                 return btd_error_invalid_args(msg);
5399
5400 //      if (!btd_adapter_find_device(adapter, address))
5401 //              return btd_error_not_found(msg);
5402
5403         memcpy(&(cp.bt_address), &bt_addr, sizeof(bdaddr_t));
5404         cp.link_type = link_type;
5405         DBG("RAW RSSI Request");
5406         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_RAW_RSSI,
5407                                         adapter->dev_id, sizeof(cp), &cp,
5408                                         NULL, NULL, NULL) > 0)
5409                         return dbus_message_new_method_return(msg);
5410
5411         return btd_error_failed(msg, "Get Raw RSSI Failed");
5412 }
5413
5414 #if !defined(__SPRD_PATCH__)
5415 static void get_adv_tx_power_complete(uint8_t status, uint16_t length,
5416                                         const void *param, void *user_data)
5417 {
5418         struct btd_adapter *adapter = user_data;
5419         const struct mgmt_rp_get_adv_tx_power *rp = param;
5420
5421         if (!rp) {
5422                 error("Error ocurred in Getting adv tx power, rp is NULL");
5423                 return;
5424         }
5425
5426         if (status != MGMT_STATUS_SUCCESS) {
5427                 error("Failed to get adv tx power: %s (0x%02x)",
5428                                                 mgmt_errstr(status), status);
5429                 return;
5430         }
5431
5432         if (length < sizeof(*rp)) {
5433                 error("Wrong size of get adv tx power");
5434                 return;
5435         }
5436
5437         adapter->adv_tx_power = rp->adv_tx_power;
5438         return;
5439 }
5440
5441 static  void adapter_get_adv_tx_power(void *data)
5442 {
5443         struct btd_adapter *adapter = data;
5444
5445         mgmt_send(adapter->mgmt, MGMT_OP_GET_ADV_TX_POWER,
5446                                         adapter->dev_id, 0, NULL,
5447                                         get_adv_tx_power_complete, adapter, NULL);
5448         return;
5449 }
5450 #endif
5451
5452 static DBusMessage *set_wbs_parameters(DBusConnection *conn,
5453                                 DBusMessage *msg, void *data)
5454 {
5455         struct btd_adapter *adapter = data;
5456         const gchar *role = NULL;
5457         const gchar *address = NULL;
5458         struct mgmt_cp_set_voice_setting cp;
5459         bdaddr_t bt_addr = { { 0, } };
5460
5461         DBG("+");
5462
5463         if (!dbus_message_get_args(msg, NULL,
5464                                 DBUS_TYPE_STRING, &role,
5465                                 DBUS_TYPE_STRING, &address,
5466                                 DBUS_TYPE_INVALID)) {
5467                 return btd_error_invalid_args(msg);
5468         }
5469
5470         DBG("Role = %s", role);
5471         DBG("Address = %s", address);
5472
5473         memset(&cp, 0, sizeof(cp));
5474
5475         cp.voice_setting = BT_VOICE_TRANSPARENT | BT_VOICE_CVSD_16BIT;
5476
5477         if (g_strcmp0(role, "Handsfree") == 0)
5478                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5479         else if (g_strcmp0(role, "Gateway") == 0)
5480                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5481
5482         str2ba(address, &bt_addr);
5483         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5484
5485         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5486                                 adapter->dev_id, sizeof(cp), &cp,
5487                                 NULL, NULL, NULL) == 0)
5488                 error("mgmt_send failed for voice setting");
5489
5490         DBG("-");
5491         return dbus_message_new_method_return(msg);
5492 }
5493
5494 static DBusMessage *set_nb_parameters(DBusConnection *conn,
5495                                 DBusMessage *msg, void *data)
5496 {
5497         struct btd_adapter *adapter = data;
5498         const gchar *role;
5499         const gchar *address = NULL;
5500         struct mgmt_cp_set_voice_setting cp;
5501         bdaddr_t bt_addr = { { 0, } };
5502
5503         DBG("+");
5504
5505         if (!dbus_message_get_args(msg, NULL,
5506                                 DBUS_TYPE_STRING, &role,
5507                                 DBUS_TYPE_STRING, &address,
5508                                 DBUS_TYPE_INVALID)) {
5509                 return btd_error_invalid_args(msg);
5510         }
5511
5512         DBG("Role = %s", role);
5513         DBG("Address = %s", address);
5514
5515         memset(&cp, 0, sizeof(cp));
5516
5517         cp.voice_setting = BT_VOICE_CVSD_16BIT;
5518
5519         if (g_strcmp0(role, "Handsfree") == 0)
5520                 cp.sco_role = MGMT_SCO_ROLE_HANDSFREE;
5521         else if (g_strcmp0(role, "Gateway") == 0)
5522                 cp.sco_role = MGMT_SCO_ROLE_AUDIO_GATEWAY;
5523
5524         str2ba(address, &bt_addr);
5525         memcpy(&(cp.bdaddr), &bt_addr, sizeof(bdaddr_t));
5526
5527         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_VOICE_SETTING,
5528                                 adapter->dev_id, sizeof(cp), &cp,
5529                                 NULL, NULL, NULL) == 0)
5530                 error("mgmt_send failed for voice setting");
5531
5532         DBG("-");
5533
5534         return dbus_message_new_method_return(msg);
5535 }
5536
5537 void btd_adapter_set_read_le_data_length_handler(
5538                         struct btd_adapter *adapter,
5539                         struct le_data_length_read_handler *handler)
5540 {
5541         adapter->read_handler = handler;
5542 }
5543
5544 static void le_read_maximum_data_length_return_param_complete(
5545                         uint8_t status, uint16_t length,
5546                         const void *param, void *user_data)
5547 {
5548         struct btd_adapter *adapter = user_data;
5549         const struct mgmt_rp_le_read_maximum_data_length *rp = param;
5550         uint16_t max_tx_octects = 0;
5551         uint16_t max_tx_time = 0;
5552         uint16_t max_rx_octects = 0;
5553         uint16_t max_rx_time = 0;
5554         int err = 0;
5555
5556         if (!rp) {
5557                 error("Error ocurred in Reading maximum data length, rp is NULL");
5558                 err = -EIO;
5559                 goto done;
5560         }
5561
5562         if (status != MGMT_STATUS_SUCCESS) {
5563                 error("le read maximum data length failed: %s (0x%02x)",
5564                         mgmt_errstr(status), status);
5565                 err = -EIO;
5566                 goto done;
5567         }
5568
5569         if (length < sizeof(*rp)) {
5570                 error("Too small le read maximum data length response");
5571                 err = -EIO;
5572                 goto done;
5573         } else {
5574                 max_tx_octects = rp->max_tx_octets;
5575                 max_tx_time =rp->max_tx_time;
5576                 max_rx_octects = rp->max_rx_octets;
5577                 max_rx_time = rp->max_rx_time;
5578         }
5579
5580 done:
5581         if (!adapter->read_handler ||
5582                 !adapter->read_handler->read_callback) {
5583                 g_free(adapter->read_handler);
5584                 return;
5585         }
5586
5587         adapter->read_handler->read_callback(adapter, err,
5588                         max_tx_octects, max_tx_time,
5589                         max_rx_octects, max_rx_time,
5590                         adapter->read_handler->user_data);
5591
5592         g_free(adapter->read_handler);
5593         adapter->read_handler = NULL;
5594 }
5595
5596 int btd_adapter_le_read_maximum_data_length(
5597         struct btd_adapter *adapter)
5598 {
5599         if (mgmt_send(adapter->mgmt,
5600                          MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
5601                          adapter->dev_id, 0, NULL,
5602                          le_read_maximum_data_length_return_param_complete,
5603                          adapter, NULL) > 0)
5604                 return 0;
5605
5606         return -EIO;
5607 }
5608
5609 static gint read_request_cmp(gconstpointer a, gconstpointer b)
5610 {
5611         const struct le_data_length_read_request *data = a;
5612         const struct btd_adapter *adapter = b;
5613
5614         return data->adapter !=  adapter;
5615 }
5616
5617 static struct le_data_length_read_request *find_read_le_data_length_request(
5618         struct btd_adapter *adapter)
5619 {
5620         GSList *match;
5621
5622         match = g_slist_find_custom(read_requests, adapter, read_request_cmp);
5623
5624         if (match)
5625                 return match->data;
5626
5627         return NULL;
5628 }
5629
5630 static void le_read_data_length_complete(
5631                         struct btd_adapter *adapter,
5632                         int err,
5633                         uint16_t max_tx_octects, uint16_t max_tx_time,
5634                         uint16_t max_rx_octects, uint16_t max_rx_time,
5635                         void *user_data)
5636 {
5637         DBusMessage *reply;
5638         struct le_data_length_read_request *read_request;
5639
5640         read_request = find_read_le_data_length_request(adapter);
5641
5642         if (!read_request)
5643                 return;
5644
5645         if (err) {
5646                 DBG("Failed to read max data length. errno[%d]", err);
5647                 reply = btd_error_failed(read_request->msg,
5648                                         "Failed to read max data length");
5649         } else {
5650                 reply = g_dbus_create_reply(read_request->msg,
5651                                         DBUS_TYPE_UINT16, &max_tx_octects,
5652                                         DBUS_TYPE_UINT16, &max_tx_time,
5653                                         DBUS_TYPE_UINT16, &max_rx_octects,
5654                                         DBUS_TYPE_UINT16, &max_rx_time,
5655                                         DBUS_TYPE_INVALID);
5656
5657                 if (!reply) {
5658                         reply = btd_error_failed(read_request->msg,
5659                                                 "Failed to create reply.");
5660                 }
5661         }
5662
5663         read_requests = g_slist_remove(read_requests, read_request);
5664         dbus_message_unref(read_request->msg);
5665         g_free(read_request);
5666
5667         if (!g_dbus_send_message(dbus_conn, reply))
5668                 error("D-Bus send failed");
5669 }
5670
5671 static DBusMessage *le_read_maximum_data_length(
5672                         DBusConnection *conn, DBusMessage *msg,
5673                         void *user_data)
5674 {
5675         struct btd_adapter *adapter = user_data;
5676         struct le_data_length_read_request *read_request;
5677         struct le_data_length_read_handler *handler;
5678
5679         if (find_read_le_data_length_request(adapter))
5680                 return btd_error_in_progress(msg);
5681
5682         if (btd_adapter_le_read_maximum_data_length(adapter))
5683                 return btd_error_failed(msg, "Unable to read maximum le data length");
5684
5685         read_request = g_new(struct le_data_length_read_request, 1);
5686
5687         read_request->msg = dbus_message_ref(msg);
5688         read_request->adapter = adapter;
5689
5690         read_requests = g_slist_append(read_requests, read_request);
5691
5692         handler = g_new0(struct le_data_length_read_handler, 1);
5693
5694         handler->read_callback =
5695                 (read_max_data_length_cb_t)le_read_data_length_complete;
5696
5697         btd_adapter_set_read_le_data_length_handler(
5698                         read_request->adapter, handler);
5699
5700         return NULL;
5701
5702 }
5703
5704 void le_write_host_suggested_data_length_return_param_complete(
5705                         uint8_t status, uint16_t length,
5706                         const void *param, void *user_data)
5707 {
5708         if (status != MGMT_STATUS_SUCCESS) {
5709                 error("le write host suggested data length failed: %s (0x%02x)",
5710                         mgmt_errstr(status), status);
5711         }
5712
5713         return;
5714 }
5715
5716 static DBusMessage *le_write_host_suggested_default_data_length(
5717                         DBusConnection *conn, DBusMessage *msg,
5718                         void *user_data)
5719 {
5720         struct btd_adapter *adapter = user_data;
5721         struct mgmt_cp_le_write_host_suggested_data_length cp;
5722         dbus_uint16_t def_tx_Octets;
5723         dbus_uint16_t def_tx_time;
5724
5725         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5726                 return btd_error_not_ready(msg);
5727
5728         if (!dbus_message_get_args(msg, NULL,
5729                                         DBUS_TYPE_UINT16, &def_tx_Octets,
5730                                         DBUS_TYPE_UINT16, &def_tx_time,
5731                                         DBUS_TYPE_INVALID))
5732                 return btd_error_invalid_args(msg);
5733
5734         memset(&cp, 0, sizeof(cp));
5735         cp.def_tx_octets = def_tx_Octets;
5736         cp.def_tx_time = def_tx_time;
5737
5738         if (mgmt_send(adapter->mgmt,
5739                          MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
5740                          adapter->dev_id, sizeof(cp), &cp,
5741                          le_write_host_suggested_data_length_return_param_complete,
5742                          adapter, NULL) > 0)
5743                 return dbus_message_new_method_return(msg);
5744
5745         return btd_error_failed(msg, "Unable to write host suggested le data length values");
5746 }
5747
5748 static void le_read_suggested_default_data_length_return_param_complete(
5749                         uint8_t status, uint16_t length,
5750                         const void *param, void *user_data)
5751 {
5752         struct btd_adapter *adapter = user_data;
5753         const struct mgmt_rp_le_read_host_suggested_data_length *rp = param;
5754         uint16_t def_tx_octects, def_tx_time;
5755
5756         if (!rp) {
5757                 error("Error ocurred in Reading suggested data length, rp is NULL");
5758                 if (adapter->def_read_handler)
5759                         g_free(adapter->def_read_handler->user_data);
5760
5761                 g_free(adapter->def_read_handler);
5762                 return;
5763         }
5764
5765         if (status != MGMT_STATUS_SUCCESS) {
5766                 error("Read host suggested def le data length values failed: %s (0x%02x)",
5767                         mgmt_errstr(status), status);
5768                 def_tx_octects = 0;
5769                 def_tx_time =0;
5770
5771                 if (adapter->def_read_handler)
5772                         g_free(adapter->def_read_handler->user_data);
5773
5774                 g_free(adapter->def_read_handler);
5775                 return;
5776         }
5777
5778         if (length < sizeof(*rp)) {
5779                 goto done;
5780         } else {
5781                 def_tx_octects = rp->def_tx_octets;
5782                 def_tx_time =rp->def_tx_time;
5783                 DBG("retrieving host suggested data length values %d %d", def_tx_octects, def_tx_time);
5784         }
5785
5786         if (!adapter->def_read_handler)
5787                 return;
5788
5789         if(!adapter->def_read_handler->read_callback) {
5790                 goto done;
5791         }
5792
5793         adapter->def_read_handler->read_callback(adapter,
5794                         def_tx_octects, def_tx_time,
5795                         adapter->def_read_handler->user_data);
5796 done:
5797         if (adapter->def_read_handler)
5798                 g_free(adapter->def_read_handler->user_data);
5799
5800         g_free(adapter->def_read_handler);
5801         adapter->def_read_handler = NULL;
5802 }
5803
5804 int btd_adapter_le_read_suggested_default_data_length(
5805         struct btd_adapter *adapter)
5806 {
5807         if (mgmt_send(adapter->mgmt,
5808                          MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
5809                          adapter->dev_id, 0, NULL,
5810                          le_read_suggested_default_data_length_return_param_complete,
5811                          adapter, NULL) > 0) {
5812                 return 0;
5813         }
5814
5815         return -EIO;
5816 }
5817
5818 static void le_read_host_suggested_default_length_complete(
5819                         struct btd_adapter *adapter,
5820                         uint16_t def_tx_octects, uint16_t def_tx_time,
5821                         void *user_data)
5822 {
5823         DBusMessage *reply;
5824         struct le_data_length_read_request *read_request;
5825
5826         read_request = find_read_le_data_length_request(adapter);
5827         if (!read_request)
5828                 return;
5829
5830         reply = g_dbus_create_reply(read_request->msg,
5831                         DBUS_TYPE_UINT16, &def_tx_octects,
5832                         DBUS_TYPE_UINT16, &def_tx_time,
5833                         DBUS_TYPE_INVALID);
5834
5835         if (!reply) {
5836                 btd_error_failed(read_request->msg,
5837                         "Failed to read host suggested def data length values");
5838                 return;
5839         }
5840
5841         read_requests = g_slist_remove(read_requests, read_request);
5842         dbus_message_unref(read_request->msg);
5843         g_free(read_request);
5844
5845         if (!g_dbus_send_message(dbus_conn, reply))
5846                 error("D-Bus send failed");
5847 }
5848
5849 static DBusMessage *le_read_host_suggested_default_data_length(
5850                         DBusConnection *conn, DBusMessage *msg,
5851                         void *user_data)
5852 {
5853         struct btd_adapter *adapter = user_data;
5854         struct le_data_length_read_request *read_request;
5855         struct le_data_length_read_default_data_length_handler *handler;
5856
5857         if (find_read_le_data_length_request(adapter))
5858                 return btd_error_in_progress(msg);
5859
5860         if (btd_adapter_le_read_suggested_default_data_length(adapter))
5861                 return btd_error_failed(msg, "Unable to read host suggested def data length");
5862
5863         read_request = g_new(struct le_data_length_read_request, 1);
5864
5865         read_request->msg = dbus_message_ref(msg);
5866         read_request->adapter = adapter;
5867
5868         read_requests = g_slist_append(read_requests, read_request);
5869
5870         handler = g_new0(struct le_data_length_read_default_data_length_handler, 1);
5871
5872         handler->read_callback =
5873                 (read_host_suggested_default_data_length_cb_t)le_read_host_suggested_default_length_complete;
5874
5875         read_request->adapter->def_read_handler = handler;
5876
5877         return NULL;
5878 }
5879
5880 static void get_le_batching_available_pkts_complete(
5881                         uint8_t status, uint16_t length,
5882                         const void *param, void *user_data)
5883 {
5884         const struct mgmt_rp_get_le_batching_buffer *rp = param;
5885         struct le_batching_request *request =
5886                 (struct le_batching_request*)user_data;
5887         DBusMessage *reply;
5888
5889         if (status != MGMT_STATUS_SUCCESS) {
5890                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
5891                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
5892                         reply = btd_error_not_supported(request->msg);
5893                 else
5894                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
5895                 goto done;
5896         }
5897
5898         if (length < sizeof(*rp)) {
5899                 reply = btd_error_failed(request->msg,
5900                         "Wrong size of get le batching buffer");
5901                 goto done;
5902         }
5903
5904         DBG("LE Batching buffer: [%u]", rp->buffer);
5905         request->adapter->le_batching_available_pkts = rp->buffer;
5906         reply = g_dbus_create_reply(request->msg,
5907                                 DBUS_TYPE_UINT32, &rp->buffer,
5908                                 DBUS_TYPE_INVALID);
5909         if (!reply)
5910                 reply = btd_error_failed(request->msg,
5911                                         "Failed to create reply.");
5912
5913 done:
5914         if (!g_dbus_send_message(dbus_conn, reply))
5915                 error("D-Bus send failed");
5916
5917         dbus_message_unref(request->msg);
5918         g_free(request);
5919 }
5920
5921 static DBusMessage *adapter_get_le_batching_available_pkts(DBusConnection *conn,
5922                                                 DBusMessage *msg, void *data)
5923 {
5924         struct btd_adapter *adapter = data;
5925         struct le_batching_request *request;
5926         DBusMessage *reply;
5927         dbus_uint32_t val;
5928
5929         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
5930                 return btd_error_not_ready(msg);
5931
5932         if (adapter->le_batching_available_pkts < 0)
5933                 return btd_error_not_supported(msg);
5934
5935         if (adapter->le_batching_available_pkts > 0) {
5936                 reply = dbus_message_new_method_return(msg);
5937                 if (!reply)
5938                         return NULL;
5939
5940                 val = adapter->le_batching_available_pkts;
5941                 dbus_message_append_args(reply, DBUS_TYPE_UINT32, &val,
5942                                                                 DBUS_TYPE_INVALID);
5943                 DBG("LE Batching buffer: [%u]", val);
5944                 return reply;
5945         }
5946
5947         request = g_new(struct le_batching_request, 1);
5948
5949         request->msg = dbus_message_ref(msg);
5950         request->adapter = adapter;
5951
5952         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_LE_BATCHING_BUFFER,
5953                                 adapter->dev_id, 0, NULL,
5954                                 get_le_batching_available_pkts_complete, request, NULL) == 0) {
5955                 dbus_message_unref(request->msg);
5956                 g_free(request);
5957                 return btd_error_failed(msg, "Unable to get le batching buffer");
5958         }
5959
5960         return NULL;
5961 }
5962
5963 static void set_le_batching_enable_complete(
5964                         uint8_t status, uint16_t length,
5965                         const void *param, void *user_data)
5966 {
5967         const struct mgmt_rp_set_le_batching_enable *rp = param;
5968         struct le_batching_request *request =
5969                 (struct le_batching_request*)user_data;
5970         DBusMessage *reply;
5971
5972         DBG("");
5973         if (status != MGMT_STATUS_SUCCESS) {
5974                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
5975                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
5976                         reply = btd_error_not_supported(request->msg);
5977                 else
5978                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
5979                 goto done;
5980         }
5981
5982         if (length < sizeof(*rp)) {
5983                 reply = btd_error_failed(request->msg,
5984                         "Wrong size of set le batching enable");
5985                 goto done;
5986         }
5987
5988         reply = g_dbus_create_reply(request->msg,
5989                                 DBUS_TYPE_INVALID);
5990         if (!reply)
5991                 reply = btd_error_failed(request->msg,
5992                                         "Failed to create reply.");
5993
5994 done:
5995         if (!g_dbus_send_message(dbus_conn, reply))
5996                 error("D-Bus send failed");
5997
5998         dbus_message_unref(request->msg);
5999         g_free(request);
6000 }
6001
6002 static void set_le_batching_param_complete(
6003                         uint8_t status, uint16_t length,
6004                         const void *param, void *user_data)
6005 {
6006         const struct mgmt_rp_set_le_batching_param *rp = param;
6007         struct mgmt_cp_set_le_batching_enable cp;
6008         struct le_batching_set_param_request *request =
6009                 (struct le_batching_set_param_request*)user_data;
6010         DBusMessage *reply;
6011
6012         if (status != MGMT_STATUS_SUCCESS) {
6013                 error("mgmt fail: %s (0x%02x)", mgmt_errstr(status), status);
6014                 if (status == MGMT_STATUS_UNKNOWN_COMMAND)
6015                         reply = btd_error_not_supported(request->msg);
6016                 else
6017                         reply = btd_error_failed(request->msg, mgmt_errstr(status));
6018                 goto done;
6019         }
6020
6021         if (length < sizeof(*rp)) {
6022                 reply = btd_error_failed(request->msg,
6023                         "Wrong size of set le batching param");
6024                 goto done;
6025         }
6026
6027         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6028         cp.bdaddr = request->bdaddr;
6029         cp.enable = 1;
6030         if (mgmt_send(request->adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6031                         request->adapter->dev_id, sizeof(cp), &cp,
6032                         set_le_batching_enable_complete, request, NULL) == 0) {
6033                 reply = btd_error_failed(request->msg, "Unable to set le batching enable");
6034                 goto done;
6035         }
6036
6037         return;
6038 done:
6039         if (!g_dbus_send_message(dbus_conn, reply))
6040                 error("D-Bus send failed");
6041
6042         dbus_message_unref(request->msg);
6043         g_free(request);
6044 }
6045
6046 static DBusMessage *adapter_enable_le_batching(DBusConnection *conn,
6047                                                 DBusMessage *msg, void *data)
6048 {
6049         struct btd_adapter *adapter = data;
6050         struct mgmt_cp_set_le_batching_param cp;
6051         struct le_batching_set_param_request *request;
6052         bdaddr_t bt_addr = { { 0, } };
6053         const gchar *address = NULL;
6054         dbus_int32_t packet_threshold;
6055         dbus_int32_t timeout;
6056
6057         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6058                 return btd_error_not_ready(msg);
6059
6060         if (!dbus_message_get_args(msg, NULL,
6061                                 DBUS_TYPE_STRING, &address,
6062                                 DBUS_TYPE_INT32, &packet_threshold,
6063                                 DBUS_TYPE_INT32, &timeout,
6064                                 DBUS_TYPE_INVALID))
6065                 return btd_error_invalid_args(msg);
6066
6067         if (packet_threshold < 0 || packet_threshold > 0x7fff ||
6068                 timeout < 0 || timeout > 0x7fff)
6069                 return btd_error_invalid_args(msg);
6070
6071         DBG("Set LE batching param: [%s %d %d]", address,
6072                         packet_threshold, timeout);
6073
6074         memset(&bt_addr, 0, sizeof(bdaddr_t));
6075         str2ba(address, &bt_addr);
6076         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_param));
6077
6078         if (bachk(address) < 0)
6079                 return btd_error_invalid_args(msg);
6080
6081         cp.bdaddr = bt_addr;
6082         cp.pkt_th = packet_threshold;
6083         /* 1sec = 100 */
6084         cp.timeout = timeout * 100;
6085
6086         request = g_new(struct le_batching_set_param_request, 1);
6087         request->msg = dbus_message_ref(msg);
6088         request->adapter = adapter;
6089         request->bdaddr = bt_addr;
6090         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_PARAM,
6091                         adapter->dev_id, sizeof(cp), &cp,
6092                         set_le_batching_param_complete, request, NULL) == 0) {
6093                 dbus_message_unref(request->msg);
6094                 g_free(request);
6095                 return btd_error_failed(msg, "Unable to set le batching param");
6096         }
6097
6098         return NULL;
6099 }
6100
6101 static DBusMessage *adapter_disable_le_batching(DBusConnection *conn,
6102                                                 DBusMessage *msg, void *data)
6103 {
6104         struct btd_adapter *adapter = data;
6105         struct le_batching_request *request;
6106         struct mgmt_cp_set_le_batching_enable cp;
6107         bdaddr_t bt_addr = { { 0, } };
6108         const gchar *address = NULL;
6109
6110         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6111                 return btd_error_not_ready(msg);
6112
6113         if (!dbus_message_get_args(msg, NULL,
6114                                 DBUS_TYPE_STRING, &address,
6115                                 DBUS_TYPE_INVALID))
6116                 return btd_error_invalid_args(msg);
6117
6118         DBG("Disable LE Batching: [%s]", address);
6119
6120         memset(&bt_addr, 0, sizeof(bdaddr_t));
6121         str2ba(address, &bt_addr);
6122         memset(&cp, 0, sizeof(struct mgmt_cp_set_le_batching_enable));
6123
6124         if (bachk(address) < 0)
6125                 return btd_error_invalid_args(msg);
6126
6127         cp.bdaddr = bt_addr;
6128         cp.enable = 0;
6129
6130         request = g_new(struct le_batching_request, 1);
6131         request->msg = dbus_message_ref(msg);
6132         request->adapter = adapter;
6133         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_LE_BATCHING_ENABLE,
6134                         adapter->dev_id, sizeof(cp), &cp,
6135                         set_le_batching_enable_complete, request, NULL) == 0) {
6136                 dbus_message_unref(request->msg);
6137                 g_free(request);
6138                 return btd_error_failed(msg, "Unable to set le batching enable");
6139         }
6140
6141         return NULL;
6142 }
6143
6144 void le_set_data_length_return_param_complete(
6145                         uint8_t status, uint16_t length,
6146                         const void *param, void *user_data)
6147 {
6148         if (status != MGMT_STATUS_SUCCESS) {
6149                 error("le_set_data_length failed: %s (0x%02x)",
6150                         mgmt_errstr(status), status);
6151         }
6152
6153         return;
6154 }
6155
6156 int btd_adapter_le_set_data_length(struct btd_adapter *adapter, bdaddr_t *bdaddr,
6157                                 uint16_t max_tx_octets, uint16_t max_tx_time)
6158 {
6159         struct mgmt_cp_le_set_data_length cp;
6160
6161         memset(&cp, 0, sizeof(cp));
6162
6163         bacpy(&cp.bdaddr, bdaddr);
6164
6165         cp.max_tx_octets = max_tx_octets;
6166         cp.max_tx_time = max_tx_time;
6167
6168         if (mgmt_send(adapter->mgmt, MGMT_OP_LE_SET_DATA_LENGTH,
6169                         adapter->dev_id, sizeof(cp), &cp,
6170                         le_set_data_length_return_param_complete,
6171                         adapter, NULL) > 0)
6172                 return 0;
6173
6174         return -EIO;
6175 }
6176
6177 static DBusMessage *adapter_set_manufacturer_data(DBusConnection *conn,
6178                                                 DBusMessage *msg, void *data)
6179 {
6180         struct btd_adapter *adapter = data;
6181         struct mgmt_cp_set_manufacturer_data cp;
6182         uint8_t *value;
6183         int32_t len = 0;
6184
6185         DBG("Set manufacturer data");
6186
6187         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6188                 return btd_error_not_ready(msg);
6189
6190         if (!dbus_message_get_args(msg, NULL,
6191                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &value, &len,
6192                         DBUS_TYPE_INVALID))
6193                 return btd_error_invalid_args(msg);
6194
6195         if (len > EIR_MANUFACTURER_DATA_LENGTH_MAX)
6196                 return btd_error_invalid_args(msg);
6197
6198         memcpy(&cp, value, len);
6199
6200         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_MANUFACTURER_DATA,
6201                                         adapter->dev_id, EIR_MANUFACTURER_DATA_LENGTH_MAX,
6202                                         &cp, NULL, NULL, NULL) > 0)
6203                 return dbus_message_new_method_return(msg);
6204
6205         return btd_error_failed(msg, "Set manufacturer data failed");
6206 }
6207
6208 static DBusMessage *adapter_get_energy_info(DBusConnection *conn,
6209                                                 DBusMessage *msg, void *user_data)
6210 {
6211         DBusMessage *reply;
6212         uint32_t tx_time = 0;
6213         uint32_t rx_time = 0;
6214         uint32_t idle_time = 0;
6215         uint32_t energy_used = 0;
6216
6217         if (adapter_le_get_energy_info(&tx_time, &rx_time,
6218                                         &idle_time, &energy_used) == FALSE) {
6219                 error("Fail to send vcs for getting energy info");
6220                 reply = btd_error_not_supported(msg);
6221                 goto done;
6222         }
6223
6224         reply = g_dbus_create_reply(msg,
6225                                 DBUS_TYPE_UINT32, &tx_time,
6226                                 DBUS_TYPE_UINT32, &rx_time,
6227                                 DBUS_TYPE_UINT32, &idle_time,
6228                                 DBUS_TYPE_UINT32, &energy_used,
6229                                 DBUS_TYPE_INVALID);
6230
6231         if (!reply)
6232                 reply = btd_error_failed(msg,
6233                                         "Failed to create reply.");
6234
6235 done:
6236         return reply;
6237 }
6238
6239
6240 #endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
6241
6242 static DBusMessage *start_discovery(DBusConnection *conn,
6243                                         DBusMessage *msg, void *user_data)
6244 {
6245         struct btd_adapter *adapter = user_data;
6246         const char *sender = dbus_message_get_sender(msg);
6247         struct watch_client *client;
6248         bool is_discovering;
6249         int err;
6250
6251         DBG("sender %s", sender);
6252
6253         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6254                 return btd_error_not_ready(msg);
6255
6256         is_discovering = get_discovery_client(adapter, sender, &client);
6257
6258         /*
6259          * Every client can only start one discovery, if the client
6260          * already started a discovery then return an error.
6261          */
6262         if (is_discovering)
6263                 return btd_error_busy(msg);
6264
6265         /*
6266          * If there was pre-set filter, just reconnect it to discovery_list,
6267          * and trigger scan.
6268          */
6269         if (client) {
6270                 if (client->msg)
6271                         return btd_error_busy(msg);
6272
6273                 adapter->set_filter_list = g_slist_remove(
6274                                              adapter->set_filter_list, client);
6275                 adapter->discovery_list = g_slist_prepend(
6276                                               adapter->discovery_list, client);
6277
6278                 goto done;
6279         }
6280
6281         client = g_new0(struct watch_client, 1);
6282
6283         client->adapter = adapter;
6284         client->owner = g_strdup(sender);
6285         client->discovery_filter = NULL;
6286         client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6287                                                 discovery_disconnect, client,
6288                                                 NULL);
6289         adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
6290                                                                 client);
6291
6292 done:
6293         /*
6294          * Just trigger the discovery here. In case an already running
6295          * discovery in idle phase exists, it will be restarted right
6296          * away.
6297          */
6298         err = update_discovery_filter(adapter);
6299         if (!err)
6300                 return dbus_message_new_method_return(msg);
6301
6302         /* If the discovery has to be started wait it complete to reply */
6303         if (err == -EINPROGRESS) {
6304                 client->msg = dbus_message_ref(msg);
6305                 return NULL;
6306         }
6307
6308         return btd_error_failed(msg, strerror(-err));
6309 }
6310
6311 static bool parse_uuids(DBusMessageIter *value, struct discovery_filter *filter)
6312 {
6313         DBusMessageIter arriter;
6314
6315         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_ARRAY)
6316                 return false;
6317
6318         dbus_message_iter_recurse(value, &arriter);
6319         while (dbus_message_iter_get_arg_type(&arriter) != DBUS_TYPE_INVALID) {
6320                 bt_uuid_t uuid, u128;
6321                 char uuidstr[MAX_LEN_UUID_STR + 1];
6322                 char *uuid_param;
6323
6324                 if (dbus_message_iter_get_arg_type(&arriter) !=
6325                                                 DBUS_TYPE_STRING)
6326                         return false;
6327
6328                 dbus_message_iter_get_basic(&arriter, &uuid_param);
6329
6330                 if (bt_string_to_uuid(&uuid, uuid_param))
6331                         return false;
6332
6333                 bt_uuid_to_uuid128(&uuid, &u128);
6334                 bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
6335
6336                 filter->uuids = g_slist_prepend(filter->uuids, g_strdup(uuidstr));
6337
6338                 dbus_message_iter_next(&arriter);
6339         }
6340
6341         return true;
6342 }
6343
6344 static bool parse_rssi(DBusMessageIter *value, struct discovery_filter *filter)
6345 {
6346         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_INT16)
6347                 return false;
6348
6349         dbus_message_iter_get_basic(value, &filter->rssi);
6350         /* -127 <= RSSI <= +20 (spec V4.2 [Vol 2, Part E] 7.7.65.2) */
6351         if (filter->rssi > 20 || filter->rssi < -127)
6352                 return false;
6353
6354         return true;
6355 }
6356
6357 static bool parse_pathloss(DBusMessageIter *value,
6358                                 struct discovery_filter *filter)
6359 {
6360         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT16)
6361                 return false;
6362
6363         dbus_message_iter_get_basic(value, &filter->pathloss);
6364         /* pathloss filter must be smaller that PATHLOSS_MAX */
6365         if (filter->pathloss > PATHLOSS_MAX)
6366                 return false;
6367
6368         return true;
6369 }
6370
6371 static bool parse_transport(DBusMessageIter *value,
6372                                         struct discovery_filter *filter)
6373 {
6374         char *transport_str;
6375
6376         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING)
6377                 return false;
6378
6379         dbus_message_iter_get_basic(value, &transport_str);
6380
6381         if (!strcmp(transport_str, "bredr"))
6382                 filter->type = SCAN_TYPE_BREDR;
6383         else if (!strcmp(transport_str, "le"))
6384                 filter->type = SCAN_TYPE_LE;
6385         else if (strcmp(transport_str, "auto"))
6386                 return false;
6387
6388         return true;
6389 }
6390
6391 static bool parse_duplicate_data(DBusMessageIter *value,
6392                                         struct discovery_filter *filter)
6393 {
6394         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6395                 return false;
6396
6397         dbus_message_iter_get_basic(value, &filter->duplicate);
6398
6399         return true;
6400 }
6401
6402 static bool parse_discoverable(DBusMessageIter *value,
6403                                         struct discovery_filter *filter)
6404 {
6405         if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
6406                 return false;
6407
6408         dbus_message_iter_get_basic(value, &filter->discoverable);
6409
6410         return true;
6411 }
6412
6413 struct filter_parser {
6414         const char *name;
6415         bool (*func)(DBusMessageIter *iter, struct discovery_filter *filter);
6416 } parsers[] = {
6417         { "UUIDs", parse_uuids },
6418         { "RSSI", parse_rssi },
6419         { "Pathloss", parse_pathloss },
6420         { "Transport", parse_transport },
6421         { "DuplicateData", parse_duplicate_data },
6422         { "Discoverable", parse_discoverable },
6423         { }
6424 };
6425
6426 static bool parse_discovery_filter_entry(char *key, DBusMessageIter *value,
6427                                                 struct discovery_filter *filter)
6428 {
6429         struct filter_parser *parser;
6430
6431         for (parser = parsers; parser && parser->name; parser++) {
6432                 if (!strcmp(parser->name, key))
6433                         return parser->func(value, filter);
6434         }
6435
6436         DBG("Unknown key parameter: %s!\n", key);
6437         return false;
6438 }
6439
6440 /*
6441  * This method is responsible for parsing parameters to SetDiscoveryFilter. If
6442  * filter in msg was empty, sets *filter to NULL. If whole parsing was
6443  * successful, sets *filter to proper value.
6444  * Returns false on any error, and true on success.
6445  */
6446 static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
6447                                         struct discovery_filter **filter,
6448                                         DBusMessage *msg)
6449 {
6450         DBusMessageIter iter, subiter, dictiter, variantiter;
6451         bool is_empty = true;
6452
6453         *filter = g_try_malloc(sizeof(**filter));
6454         if (!*filter)
6455                 return false;
6456
6457         (*filter)->uuids = NULL;
6458         (*filter)->pathloss = DISTANCE_VAL_INVALID;
6459         (*filter)->rssi = DISTANCE_VAL_INVALID;
6460         (*filter)->type = get_scan_type(adapter);
6461         (*filter)->duplicate = false;
6462         (*filter)->discoverable = false;
6463
6464         dbus_message_iter_init(msg, &iter);
6465         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
6466             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
6467                 goto invalid_args;
6468
6469         dbus_message_iter_recurse(&iter, &subiter);
6470         do {
6471                 int type = dbus_message_iter_get_arg_type(&subiter);
6472                 char *key;
6473
6474                 if (type == DBUS_TYPE_INVALID)
6475                         break;
6476
6477                 is_empty = false;
6478                 dbus_message_iter_recurse(&subiter, &dictiter);
6479
6480                 dbus_message_iter_get_basic(&dictiter, &key);
6481                 if (!dbus_message_iter_next(&dictiter))
6482                         goto invalid_args;
6483
6484                 if (dbus_message_iter_get_arg_type(&dictiter) !=
6485                                                              DBUS_TYPE_VARIANT)
6486                         goto invalid_args;
6487
6488                 dbus_message_iter_recurse(&dictiter, &variantiter);
6489
6490                 if (!parse_discovery_filter_entry(key, &variantiter, *filter))
6491                         goto invalid_args;
6492
6493                 dbus_message_iter_next(&subiter);
6494         } while (true);
6495
6496         if (is_empty) {
6497                 g_free(*filter);
6498                 *filter = NULL;
6499                 return true;
6500         }
6501
6502         /* only pathlos or rssi can be set, never both */
6503         if ((*filter)->pathloss != DISTANCE_VAL_INVALID &&
6504             (*filter)->rssi != DISTANCE_VAL_INVALID)
6505                 goto invalid_args;
6506
6507         DBG("filtered discovery params: transport: %d rssi: %d pathloss: %d "
6508                 " duplicate data: %s discoverable %s", (*filter)->type,
6509                 (*filter)->rssi, (*filter)->pathloss,
6510                 (*filter)->duplicate ? "true" : "false",
6511                 (*filter)->discoverable ? "true" : "false");
6512
6513         return true;
6514
6515 invalid_args:
6516         g_slist_free_full((*filter)->uuids, g_free);
6517         g_free(*filter);
6518         *filter = NULL;
6519         return false;
6520 }
6521
6522 static DBusMessage *set_discovery_filter(DBusConnection *conn,
6523                                         DBusMessage *msg, void *user_data)
6524 {
6525         struct btd_adapter *adapter = user_data;
6526         struct watch_client *client;
6527         struct discovery_filter *discovery_filter;
6528         const char *sender = dbus_message_get_sender(msg);
6529         bool is_discovering;
6530
6531         DBG("sender %s", sender);
6532
6533         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6534                 return btd_error_not_ready(msg);
6535
6536         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 8))
6537                 return btd_error_not_supported(msg);
6538
6539         /* parse parameters */
6540         if (!parse_discovery_filter_dict(adapter, &discovery_filter, msg))
6541                 return btd_error_invalid_args(msg);
6542
6543         is_discovering = get_discovery_client(adapter, sender, &client);
6544
6545         if (client) {
6546                 free_discovery_filter(client->discovery_filter);
6547                 client->discovery_filter = discovery_filter;
6548
6549                 if (is_discovering)
6550                         update_discovery_filter(adapter);
6551
6552                 if (discovery_filter || is_discovering)
6553                         return dbus_message_new_method_return(msg);
6554
6555                 /* Removing pre-set filter */
6556                 adapter->set_filter_list = g_slist_remove(
6557                                               adapter->set_filter_list,
6558                                               client);
6559                 discovery_free(client);
6560                 DBG("successfully cleared pre-set filter");
6561         } else if (discovery_filter) {
6562                 /* Client pre-setting his filter for first time */
6563                 client = g_new0(struct watch_client, 1);
6564                 client->adapter = adapter;
6565                 client->owner = g_strdup(sender);
6566                 client->discovery_filter = discovery_filter;
6567                 client->watch = g_dbus_add_disconnect_watch(dbus_conn, sender,
6568                                                 discovery_disconnect, client,
6569                                                 NULL);
6570                 adapter->set_filter_list = g_slist_prepend(
6571                                              adapter->set_filter_list, client);
6572
6573                 DBG("successfully pre-set filter");
6574         }
6575
6576         return dbus_message_new_method_return(msg);
6577 }
6578
6579 static DBusMessage *stop_discovery(DBusConnection *conn,
6580                                         DBusMessage *msg, void *user_data)
6581 {
6582         struct btd_adapter *adapter = user_data;
6583         const char *sender = dbus_message_get_sender(msg);
6584         struct watch_client *client;
6585         GSList *list;
6586         int err;
6587
6588         DBG("sender %s", sender);
6589
6590         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
6591                 return btd_error_not_ready(msg);
6592
6593         list = g_slist_find_custom(adapter->discovery_list, sender,
6594                         compare_sender);
6595         if (!list)
6596                 return btd_error_failed(msg, "No discovery started");
6597
6598         client = list->data;
6599
6600         if (client->msg)
6601                 return btd_error_busy(msg);
6602
6603         err = discovery_stop(client, false);
6604         switch (err) {
6605                 case 0:
6606                         return dbus_message_new_method_return(msg);
6607                 case -EINPROGRESS:
6608                         client->msg = dbus_message_ref(msg);
6609                         return NULL;
6610                 default:
6611                         return btd_error_failed(msg, strerror(-err));
6612         }
6613 }
6614
6615 static gboolean property_get_address(const GDBusPropertyTable *property,
6616                                         DBusMessageIter *iter, void *user_data)
6617 {
6618         struct btd_adapter *adapter = user_data;
6619         char addr[18];
6620         const char *str = addr;
6621
6622         ba2str(&adapter->bdaddr, addr);
6623
6624         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6625
6626         return TRUE;
6627 }
6628
6629 static gboolean property_get_address_type(const GDBusPropertyTable *property,
6630                                         DBusMessageIter *iter, void *user_data)
6631 {
6632         struct btd_adapter *adapter = user_data;
6633         const char *str;
6634
6635         if ((adapter->current_settings & MGMT_SETTING_LE) &&
6636                                 (adapter->bdaddr_type == BDADDR_LE_RANDOM))
6637                 str = "random";
6638         else
6639                 str = "public";
6640
6641         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6642
6643         return TRUE;
6644 }
6645
6646 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
6647 static gboolean property_get_le_address(const GDBusPropertyTable *property,
6648                                         DBusMessageIter *iter, void *user_data)
6649 {
6650         struct btd_adapter *adapter = user_data;
6651         DBusMessageIter entry;
6652         char addr[18];
6653         const char *str = addr;
6654         char *type = NULL;
6655
6656         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
6657                                         DBUS_TYPE_STRING_AS_STRING, &entry);
6658
6659         if (adapter->le_static_addr.b[5] != 0) {
6660                 ba2str(&adapter->le_static_addr, addr);
6661                 type = g_strdup_printf("%d", BDADDR_LE_RANDOM);
6662         } else {
6663                 ba2str(&adapter->bdaddr, addr);
6664                 type = g_strdup_printf("%d", BDADDR_LE_PUBLIC);
6665         }
6666
6667         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &type);
6668         g_free((void *)type);
6669
6670         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
6671
6672         dbus_message_iter_close_container(iter, &entry);
6673
6674         return TRUE;
6675 }
6676 #endif
6677
6678 static gboolean property_get_name(const GDBusPropertyTable *property,
6679                                         DBusMessageIter *iter, void *user_data)
6680 {
6681         struct btd_adapter *adapter = user_data;
6682         const char *str = adapter->system_name ? : "";
6683
6684         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6685
6686         return TRUE;
6687 }
6688
6689 static gboolean property_get_alias(const GDBusPropertyTable *property,
6690                                         DBusMessageIter *iter, void *user_data)
6691 {
6692         struct btd_adapter *adapter = user_data;
6693         const char *str;
6694
6695         if (adapter->current_alias)
6696                 str = adapter->current_alias;
6697         else if (adapter->stored_alias)
6698                 str = adapter->stored_alias;
6699         else
6700                 str = adapter->system_name ? : "";
6701
6702         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
6703
6704         return TRUE;
6705 }
6706
6707 static void property_set_alias(const GDBusPropertyTable *property,
6708                                 DBusMessageIter *iter,
6709                                 GDBusPendingPropertySet id, void *user_data)
6710 {
6711         struct btd_adapter *adapter = user_data;
6712         const char *name;
6713         int ret;
6714
6715         dbus_message_iter_get_basic(iter, &name);
6716
6717         if (g_str_equal(name, "")  == TRUE) {
6718                 if (adapter->stored_alias == NULL) {
6719                         /* no alias set, nothing to restore */
6720                         g_dbus_pending_property_success(id);
6721                         return;
6722                 }
6723
6724                 /* restore to system name */
6725                 ret = set_name(adapter, adapter->system_name);
6726         } else {
6727                 if (g_strcmp0(adapter->stored_alias, name) == 0) {
6728                         /* alias already set, nothing to do */
6729                         g_dbus_pending_property_success(id);
6730                         return;
6731                 }
6732
6733                 /* set to alias */
6734                 ret = set_name(adapter, name);
6735         }
6736
6737         if (ret >= 0) {
6738                 g_free(adapter->stored_alias);
6739
6740                 if (g_str_equal(name, "")  == TRUE)
6741                         adapter->stored_alias = NULL;
6742                 else
6743                         adapter->stored_alias = g_strdup(name);
6744
6745                 store_adapter_info(adapter);
6746
6747                 g_dbus_pending_property_success(id);
6748                 return;
6749         }
6750
6751         if (ret == -EINVAL)
6752                 g_dbus_pending_property_error(id,
6753                                         ERROR_INTERFACE ".InvalidArguments",
6754                                         "Invalid arguments in method call");
6755         else
6756                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
6757                                                         strerror(-ret));
6758 }
6759
6760 static gboolean property_get_class(const GDBusPropertyTable *property,
6761                                         DBusMessageIter *iter, void *user_data)
6762 {
6763         struct btd_adapter *adapter = user_data;
6764         dbus_uint32_t val = adapter->dev_class;
6765
6766         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
6767
6768         return TRUE;
6769 }
6770
6771 static gboolean property_get_a2dp_role(const GDBusPropertyTable *property,
6772                                         DBusMessageIter *iter, void *user_data)
6773 {
6774         struct btd_adapter *adapter = user_data;
6775         dbus_uint32_t val = adapter->a2dp_role;
6776
6777         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val);
6778
6779         return TRUE;
6780 }
6781
6782 static gboolean property_get_mode(struct btd_adapter *adapter,
6783                                 uint32_t setting, DBusMessageIter *iter)
6784 {
6785         dbus_bool_t enable;
6786
6787         enable = (adapter->current_settings & setting) ? TRUE : FALSE;
6788
6789         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
6790
6791         return TRUE;
6792 }
6793
6794 struct property_set_data {
6795         struct btd_adapter *adapter;
6796         GDBusPendingPropertySet id;
6797 };
6798
6799 static void property_set_mode_complete(uint8_t status, uint16_t length,
6800                                         const void *param, void *user_data)
6801 {
6802         struct property_set_data *data = user_data;
6803         struct btd_adapter *adapter = data->adapter;
6804
6805         DBG("%s (0x%02x)", mgmt_errstr(status), status);
6806
6807         if (status != MGMT_STATUS_SUCCESS) {
6808                 const char *dbus_err;
6809
6810                 btd_error(adapter->dev_id, "Failed to set mode: %s (0x%02x)",
6811                                                 mgmt_errstr(status), status);
6812
6813                 if (status == MGMT_STATUS_RFKILLED)
6814                         dbus_err = ERROR_INTERFACE ".Blocked";
6815                 else
6816                         dbus_err = ERROR_INTERFACE ".Failed";
6817
6818                 g_dbus_pending_property_error(data->id, dbus_err,
6819                                                         mgmt_errstr(status));
6820                 return;
6821         }
6822
6823         g_dbus_pending_property_success(data->id);
6824
6825         /*
6826          * The parameters are identical and also the task that is
6827          * required in both cases. So it is safe to just call the
6828          * event handling functions here.
6829          */
6830         new_settings_callback(adapter->dev_id, length, param, adapter);
6831 }
6832
6833 static void clear_discoverable(struct btd_adapter *adapter)
6834 {
6835         if (!kernel_conn_control)
6836                 return;
6837
6838         if (!(adapter->current_settings & MGMT_SETTING_DISCOVERABLE))
6839                 return;
6840
6841         /* If no timeout is set do nothing as both connectable and discoverable
6842          * flags are persistent on power toggle.
6843          */
6844         if (!adapter->discoverable_timeout)
6845                 return;
6846
6847         /* If timeout was set kernel clears discoverable on its own when
6848          * powering off controller. This would leave connectable flag set
6849          * after power on.
6850          *
6851          * With kernel control clearing connectable clear also discoverable
6852          * flag so we need to clear connectable.
6853          */
6854         set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
6855 }
6856
6857 static void property_set_mode(struct btd_adapter *adapter, uint32_t setting,
6858                                                 DBusMessageIter *value,
6859                                                 GDBusPendingPropertySet id)
6860 {
6861         struct property_set_data *data;
6862         struct mgmt_cp_set_discoverable cp;
6863         void *param;
6864         dbus_bool_t enable, current_enable;
6865         uint16_t opcode, len;
6866         uint8_t mode;
6867
6868         dbus_message_iter_get_basic(value, &enable);
6869
6870         if (adapter->current_settings & setting)
6871                 current_enable = TRUE;
6872         else
6873                 current_enable = FALSE;
6874
6875         if (enable == current_enable || adapter->pending_settings & setting) {
6876                 g_dbus_pending_property_success(id);
6877                 return;
6878         }
6879
6880         mode = (enable == TRUE) ? 0x01 : 0x00;
6881
6882         adapter->pending_settings |= setting;
6883
6884         switch (setting) {
6885         case MGMT_SETTING_POWERED:
6886                 opcode = MGMT_OP_SET_POWERED;
6887                 param = &mode;
6888                 len = sizeof(mode);
6889
6890                 if (!mode)
6891                         clear_discoverable(adapter);
6892
6893                 break;
6894         case MGMT_SETTING_DISCOVERABLE:
6895 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
6896                 if (kernel_conn_control) {
6897                         if (mode) {
6898                                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
6899                                                                         mode);
6900                         } else {
6901                                 opcode = MGMT_OP_SET_CONNECTABLE;
6902                                 param = &mode;
6903                                 len = sizeof(mode);
6904                                 break;
6905                         }
6906                 }
6907 #endif
6908
6909                 memset(&cp, 0, sizeof(cp));
6910                 cp.val = mode;
6911                 if (cp.val)
6912                         cp.timeout = htobs(adapter->discoverable_timeout);
6913
6914                 opcode = MGMT_OP_SET_DISCOVERABLE;
6915                 param = &cp;
6916                 len = sizeof(cp);
6917                 break;
6918         case MGMT_SETTING_BONDABLE:
6919                 opcode = MGMT_OP_SET_BONDABLE;
6920                 param = &mode;
6921                 len = sizeof(mode);
6922                 break;
6923 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
6924         case MGMT_SETTING_CONNECTABLE:
6925                 opcode = MGMT_OP_SET_CONNECTABLE;
6926                 param = &mode;
6927                 len = sizeof(mode);
6928                 break;
6929 #endif
6930         default:
6931                 goto failed;
6932         }
6933
6934         DBG("sending %s command for index %u", mgmt_opstr(opcode),
6935                                                         adapter->dev_id);
6936
6937         data = g_try_new0(struct property_set_data, 1);
6938         if (!data)
6939                 goto failed;
6940
6941         data->adapter = adapter;
6942         data->id = id;
6943
6944 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
6945         /*
6946          * Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
6947          */
6948         if (mgmt_send_nowait(adapter->mgmt, opcode, adapter->dev_id, len, param,
6949                                 property_set_mode_complete, data, g_free) > 0)
6950 #else
6951         if (mgmt_send(adapter->mgmt, opcode, adapter->dev_id, len, param,
6952                         property_set_mode_complete, data, g_free) > 0)
6953 #endif
6954                 return;
6955
6956         g_free(data);
6957
6958 failed:
6959         btd_error(adapter->dev_id, "Failed to set mode for index %u",
6960                                                         adapter->dev_id);
6961
6962         g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed", NULL);
6963 }
6964
6965 static gboolean property_get_powered(const GDBusPropertyTable *property,
6966                                         DBusMessageIter *iter, void *user_data)
6967 {
6968         struct btd_adapter *adapter = user_data;
6969
6970         return property_get_mode(adapter, MGMT_SETTING_POWERED, iter);
6971 }
6972
6973 static void property_set_powered(const GDBusPropertyTable *property,
6974                                 DBusMessageIter *iter,
6975                                 GDBusPendingPropertySet id, void *user_data)
6976 {
6977         struct btd_adapter *adapter = user_data;
6978
6979         if (powering_down) {
6980                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
6981                                                         "Powering down");
6982                 return;
6983         }
6984
6985         property_set_mode(adapter, MGMT_SETTING_POWERED, iter, id);
6986 }
6987
6988 static gboolean property_get_discoverable(const GDBusPropertyTable *property,
6989                                         DBusMessageIter *iter, void *user_data)
6990 {
6991         struct btd_adapter *adapter = user_data;
6992
6993         return property_get_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter);
6994 }
6995
6996 static void property_set_discoverable(const GDBusPropertyTable *property,
6997                                 DBusMessageIter *iter,
6998                                 GDBusPendingPropertySet id, void *user_data)
6999 {
7000         struct btd_adapter *adapter = user_data;
7001
7002         if (adapter->discoverable_timeout > 0 &&
7003                         !(adapter->current_settings & MGMT_SETTING_POWERED)) {
7004                 g_dbus_pending_property_error(id, ERROR_INTERFACE ".Failed",
7005                                                                 "Not Powered");
7006                 return;
7007         }
7008
7009         /* Reset discovery_discoverable as Discoverable takes precedence */
7010         adapter->discovery_discoverable = false;
7011
7012         property_set_mode(adapter, MGMT_SETTING_DISCOVERABLE, iter, id);
7013 }
7014
7015 static gboolean property_get_discoverable_timeout(
7016                                         const GDBusPropertyTable *property,
7017                                         DBusMessageIter *iter, void *user_data)
7018 {
7019         struct btd_adapter *adapter = user_data;
7020         dbus_uint32_t value = adapter->discoverable_timeout;
7021
7022         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7023
7024         return TRUE;
7025 }
7026
7027 static void property_set_discoverable_timeout(
7028                                 const GDBusPropertyTable *property,
7029                                 DBusMessageIter *iter,
7030                                 GDBusPendingPropertySet id, void *user_data)
7031 {
7032         struct btd_adapter *adapter = user_data;
7033         bool enabled;
7034         dbus_uint32_t value;
7035
7036         dbus_message_iter_get_basic(iter, &value);
7037
7038         adapter->discoverable_timeout = value;
7039
7040         g_dbus_pending_property_success(id);
7041
7042         store_adapter_info(adapter);
7043
7044         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7045                                 ADAPTER_INTERFACE, "DiscoverableTimeout");
7046
7047         if (adapter->pending_settings & MGMT_SETTING_DISCOVERABLE) {
7048                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7049                         enabled = false;
7050                 else
7051                         enabled = true;
7052         } else {
7053                 if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
7054                         enabled = true;
7055                 else
7056                         enabled = false;
7057         }
7058
7059         if (enabled)
7060                 set_discoverable(adapter, 0x01, adapter->discoverable_timeout);
7061 }
7062
7063 static gboolean property_get_pairable(const GDBusPropertyTable *property,
7064                                         DBusMessageIter *iter, void *user_data)
7065 {
7066         struct btd_adapter *adapter = user_data;
7067
7068         return property_get_mode(adapter, MGMT_SETTING_BONDABLE, iter);
7069 }
7070
7071 static void property_set_pairable(const GDBusPropertyTable *property,
7072                                 DBusMessageIter *iter,
7073                                 GDBusPendingPropertySet id, void *user_data)
7074 {
7075         struct btd_adapter *adapter = user_data;
7076
7077         property_set_mode(adapter, MGMT_SETTING_BONDABLE, iter, id);
7078 }
7079
7080 static gboolean property_get_pairable_timeout(
7081                                         const GDBusPropertyTable *property,
7082                                         DBusMessageIter *iter, void *user_data)
7083 {
7084         struct btd_adapter *adapter = user_data;
7085         dbus_uint32_t value = adapter->pairable_timeout;
7086
7087         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &value);
7088
7089         return TRUE;
7090 }
7091
7092 static void property_set_pairable_timeout(const GDBusPropertyTable *property,
7093                                 DBusMessageIter *iter,
7094                                 GDBusPendingPropertySet id, void *user_data)
7095 {
7096         struct btd_adapter *adapter = user_data;
7097         dbus_uint32_t value;
7098
7099         dbus_message_iter_get_basic(iter, &value);
7100
7101         adapter->pairable_timeout = value;
7102
7103         g_dbus_pending_property_success(id);
7104
7105         store_adapter_info(adapter);
7106
7107         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7108                                         ADAPTER_INTERFACE, "PairableTimeout");
7109
7110         trigger_pairable_timeout(adapter);
7111 }
7112
7113 static gboolean property_get_discovering(const GDBusPropertyTable *property,
7114                                         DBusMessageIter *iter, void *user_data)
7115 {
7116         struct btd_adapter *adapter = user_data;
7117         dbus_bool_t discovering = adapter->discovering;
7118
7119         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7120
7121         return TRUE;
7122 }
7123
7124 static void add_gatt_uuid(struct gatt_db_attribute *attrib, void *user_data)
7125 {
7126         GHashTable *uuids = user_data;
7127         bt_uuid_t uuid, u128;
7128         char uuidstr[MAX_LEN_UUID_STR + 1];
7129
7130         if (!gatt_db_service_get_active(attrib))
7131                 return;
7132
7133         if (!gatt_db_attribute_get_service_uuid(attrib, &uuid))
7134                 return;
7135
7136         bt_uuid_to_uuid128(&uuid, &u128);
7137         bt_uuid_to_string(&u128, uuidstr, sizeof(uuidstr));
7138
7139         g_hash_table_add(uuids, strdup(uuidstr));
7140 }
7141
7142 static void iter_append_uuid(gpointer key, gpointer value, gpointer user_data)
7143 {
7144         DBusMessageIter *iter = user_data;
7145         const char *uuid = key;
7146
7147         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
7148 }
7149
7150 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7151 static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
7152                                         DBusMessageIter *iter, void *user_data)
7153 {
7154         struct btd_adapter *adapter = user_data;
7155         dbus_bool_t discovering = adapter->le_discovering;
7156
7157         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &discovering);
7158
7159         return TRUE;
7160 }
7161
7162 static gboolean property_get_connectable(const GDBusPropertyTable *property,
7163                                         DBusMessageIter *iter, void *user_data)
7164 {
7165         struct btd_adapter *adapter = user_data;
7166
7167         return property_get_mode(adapter, MGMT_SETTING_CONNECTABLE, iter);
7168 }
7169
7170 static void property_set_connectable(const GDBusPropertyTable *property,
7171                                 DBusMessageIter *iter,
7172                                 GDBusPendingPropertySet id, void *user_data)
7173 {
7174         struct btd_adapter *adapter = user_data;
7175
7176         property_set_mode(adapter, MGMT_SETTING_CONNECTABLE, iter, id);
7177 }
7178
7179 static gboolean property_get_version(const GDBusPropertyTable *property,
7180                                         DBusMessageIter *iter, void *user_data)
7181 {
7182         struct btd_adapter *adapter = user_data;
7183         const char *str = adapter->version ? : "";
7184
7185         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7186
7187         return TRUE;
7188 }
7189
7190 static gboolean property_get_supported_le_features(
7191                                         const GDBusPropertyTable *property,
7192                                         DBusMessageIter *iter, void *user_data)
7193 {
7194         const char *str, *val;
7195         int value;
7196         DBusMessageIter entry;
7197         struct btd_adapter *adapter = user_data;
7198
7199         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7200                         DBUS_TYPE_STRING_AS_STRING, &entry);
7201
7202         value = adapter_le_get_max_adv_instance();
7203         if (value > 0) {
7204                 str = g_strdup("adv_inst_max");
7205                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7206
7207                 val = g_strdup_printf("%d", value);
7208                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7209
7210                 g_free((void *)str);
7211                 g_free((void *)val);
7212         }
7213
7214         value = adapter_le_is_supported_offloading();
7215         if (value > 0) {
7216                 str = g_strdup("rpa_offloading");
7217                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7218
7219                 val = g_strdup_printf("%d", value);
7220                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7221
7222                 g_free((void *)str);
7223                 g_free((void *)val);
7224         }
7225
7226         value = adapter_le_get_scan_filter_size();
7227 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
7228         if (value <= 0)
7229                 value = SCAN_FILTER_SLOTS_MAX;
7230 #endif
7231         if (value > 0) {
7232                 str = g_strdup("max_filter");
7233                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7234
7235                 val = g_strdup_printf("%d", value);
7236                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7237
7238                 g_free((void *)str);
7239                 g_free((void *)val);
7240         }
7241
7242         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
7243                 /* 2M PHY Support */
7244                 str = g_strdup("2m_phy");
7245                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7246
7247                 if (adapter->le_2m_phy_supported)
7248                         val = g_strdup("true");
7249                 else
7250                         val = g_strdup("false");
7251
7252                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7253
7254                 g_free((void *)str);
7255                 g_free((void *)val);
7256
7257                 /* CODED PHY Support */
7258                 str = g_strdup("coded_phy");
7259                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &str);
7260
7261                 if (adapter->le_coded_phy_supported)
7262                         val = g_strdup("true");
7263                 else
7264                         val = g_strdup("false");
7265
7266                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &val);
7267
7268                 g_free((void *)str);
7269                 g_free((void *)val);
7270         }
7271
7272         dbus_message_iter_close_container(iter, &entry);
7273
7274         return TRUE;
7275 }
7276
7277 static gboolean property_get_ipsp_init_state(
7278                                         const GDBusPropertyTable *property,
7279                                         DBusMessageIter *iter, void *data)
7280 {
7281         struct btd_adapter *adapter = data;
7282         dbus_bool_t ipsp_initialized;
7283
7284         if (adapter->ipsp_intialized)
7285                 ipsp_initialized = TRUE;
7286         else
7287                 ipsp_initialized = FALSE;
7288
7289         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
7290                                         &ipsp_initialized);
7291
7292         return TRUE;
7293 }
7294 #endif
7295
7296 static gboolean property_get_uuids(const GDBusPropertyTable *property,
7297                                         DBusMessageIter *iter, void *user_data)
7298 {
7299         struct btd_adapter *adapter = user_data;
7300         DBusMessageIter entry;
7301         sdp_list_t *l;
7302         struct gatt_db *db;
7303         GHashTable *uuids;
7304
7305         uuids = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
7306         if (!uuids)
7307                 return FALSE;
7308
7309         /* SDP records */
7310         for (l = adapter->services; l != NULL; l = l->next) {
7311                 sdp_record_t *rec = l->data;
7312                 char *uuid;
7313
7314                 uuid = bt_uuid2string(&rec->svclass);
7315                 if (uuid == NULL)
7316                         continue;
7317
7318                 g_hash_table_add(uuids, uuid);
7319         }
7320
7321         /* GATT services */
7322         db = btd_gatt_database_get_db(adapter->database);
7323         if (db)
7324                 gatt_db_foreach_service(db, NULL, add_gatt_uuid, uuids);
7325
7326         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
7327                                         DBUS_TYPE_STRING_AS_STRING, &entry);
7328         g_hash_table_foreach(uuids, iter_append_uuid, &entry);
7329         dbus_message_iter_close_container(iter, &entry);
7330
7331         g_hash_table_destroy(uuids);
7332
7333         return TRUE;
7334 }
7335
7336 static gboolean property_exists_modalias(const GDBusPropertyTable *property,
7337                                                         void *user_data)
7338 {
7339         struct btd_adapter *adapter = user_data;
7340
7341         return adapter->modalias ? TRUE : FALSE;
7342 }
7343
7344 static gboolean property_get_modalias(const GDBusPropertyTable *property,
7345                                         DBusMessageIter *iter, void *user_data)
7346 {
7347         struct btd_adapter *adapter = user_data;
7348         const char *str = adapter->modalias ? : "";
7349
7350         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
7351
7352         return TRUE;
7353 }
7354
7355 static int device_path_cmp(gconstpointer a, gconstpointer b)
7356 {
7357         const struct btd_device *device = a;
7358         const char *path = b;
7359         const char *dev_path = device_get_path(device);
7360
7361         return strcasecmp(dev_path, path);
7362 }
7363
7364 static DBusMessage *remove_device(DBusConnection *conn,
7365                                         DBusMessage *msg, void *user_data)
7366 {
7367         struct btd_adapter *adapter = user_data;
7368         struct btd_device *device;
7369         const char *path;
7370         GSList *list;
7371
7372         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
7373                                                 DBUS_TYPE_INVALID) == FALSE)
7374                 return btd_error_invalid_args(msg);
7375
7376         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7377         if (!list)
7378                 return btd_error_does_not_exist(msg);
7379
7380         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7381                 return btd_error_not_ready(msg);
7382
7383         device = list->data;
7384
7385         btd_device_set_temporary(device, true);
7386
7387         if (!btd_device_is_connected(device)) {
7388                 btd_adapter_remove_device(adapter, device);
7389                 return dbus_message_new_method_return(msg);
7390         }
7391
7392         device_request_disconnect(device, msg);
7393
7394         return NULL;
7395 }
7396
7397 static DBusMessage *get_discovery_filters(DBusConnection *conn,
7398                                         DBusMessage *msg, void *user_data)
7399 {
7400         DBusMessage *reply;
7401         DBusMessageIter iter, array;
7402         struct filter_parser *parser;
7403
7404         reply = dbus_message_new_method_return(msg);
7405
7406         dbus_message_iter_init_append(reply, &iter);
7407
7408         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
7409                                         DBUS_TYPE_STRING_AS_STRING, &array);
7410
7411         for (parser = parsers; parser && parser->name; parser++) {
7412                 dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
7413                                                         &parser->name);
7414         }
7415
7416         dbus_message_iter_close_container(&iter, &array);
7417
7418         return reply;
7419 }
7420
7421 struct device_connect_data {
7422         struct btd_adapter *adapter;
7423         bdaddr_t dst;
7424         uint8_t dst_type;
7425         DBusMessage *msg;
7426 };
7427
7428 static void device_browse_cb(struct btd_device *dev, int err, void *user_data)
7429 {
7430         DBG("err %d (%s)", err, strerror(-err));
7431
7432         if (!err)
7433                 btd_device_connect_services(dev, NULL);
7434 }
7435
7436 static void device_connect_cb(GIOChannel *io, GError *gerr, gpointer user_data)
7437 {
7438         struct device_connect_data *data = user_data;
7439         struct btd_adapter *adapter = data->adapter;
7440         struct btd_device *device;
7441         const char *path;
7442
7443         DBG("%s", gerr ? gerr->message : "");
7444
7445         if (gerr)
7446                 goto failed;
7447
7448         /* object might already exist due to mgmt socket event */
7449         device = btd_adapter_get_device(adapter, &data->dst, data->dst_type);
7450         if (!device)
7451                 goto failed;
7452
7453         path = device_get_path(device);
7454
7455         g_dbus_send_reply(dbus_conn, data->msg, DBUS_TYPE_OBJECT_PATH, &path,
7456                                                         DBUS_TYPE_INVALID);
7457
7458         /* continue with service discovery and connection */
7459         btd_device_set_temporary(device, false);
7460         device_update_last_seen(device, data->dst_type);
7461
7462         if (data->dst_type != BDADDR_BREDR){
7463                 g_io_channel_set_close_on_unref(io, FALSE);
7464                 device_attach_att(device, io);
7465         }
7466
7467         device_discover_services(device);
7468         device_wait_for_svc_complete(device, device_browse_cb, NULL);
7469
7470         g_io_channel_unref(io);
7471         dbus_message_unref(data->msg);
7472         free(data);
7473         return;
7474
7475 failed:
7476         g_dbus_send_error(dbus_conn, data->msg, "org.bluez.Failed", NULL);
7477         g_io_channel_unref(io);
7478         dbus_message_unref(data->msg);
7479         free(data);
7480 }
7481
7482 static void device_connect(struct btd_adapter *adapter, const bdaddr_t *dst,
7483                                         uint8_t dst_type, DBusMessage *msg)
7484 {
7485         struct device_connect_data *data;
7486         GIOChannel *io;
7487
7488         data = new0(struct device_connect_data, 1);
7489         data->adapter = adapter;
7490         bacpy(&data->dst, dst);
7491         data->dst_type = dst_type;
7492         data->msg = dbus_message_ref(msg);
7493
7494         if (dst_type == BDADDR_BREDR)
7495                 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
7496                                 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
7497                                 BT_IO_OPT_SOURCE_TYPE, BDADDR_BREDR,
7498                                 BT_IO_OPT_DEST_BDADDR, dst,
7499                                 BT_IO_OPT_DEST_TYPE, BDADDR_BREDR,
7500                                 BT_IO_OPT_PSM, SDP_PSM,
7501                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
7502                                 BT_IO_OPT_INVALID);
7503         else
7504                 io = bt_io_connect(device_connect_cb, data, NULL, NULL,
7505                                 BT_IO_OPT_SOURCE_BDADDR, &adapter->bdaddr,
7506                                 BT_IO_OPT_SOURCE_TYPE, adapter->bdaddr_type,
7507                                 BT_IO_OPT_DEST_BDADDR, dst,
7508                                 BT_IO_OPT_DEST_TYPE, dst_type,
7509                                 BT_IO_OPT_CID, ATT_CID,
7510                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW,
7511                                 BT_IO_OPT_INVALID);
7512
7513         if (!io) {
7514                 g_dbus_send_message(dbus_conn,
7515                                 btd_error_failed(msg, "Connect failed"));
7516                 dbus_message_unref(data->msg);
7517                 free(data);
7518         }
7519 }
7520
7521 static DBusMessage *connect_device(DBusConnection *conn,
7522                                         DBusMessage *msg, void *user_data)
7523 {
7524         struct btd_adapter *adapter = user_data;
7525         DBusMessageIter iter, subiter, dictiter, value;
7526         uint8_t addr_type = BDADDR_BREDR;
7527         bdaddr_t addr = *BDADDR_ANY;
7528
7529         DBG("sender %s", dbus_message_get_sender(msg));
7530
7531         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7532                 return btd_error_not_ready(msg);
7533
7534         dbus_message_iter_init(msg, &iter);
7535         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
7536             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)
7537                 return btd_error_invalid_args(msg);
7538
7539         dbus_message_iter_recurse(&iter, &subiter);
7540         while (true) {
7541                 int type = dbus_message_iter_get_arg_type(&subiter);
7542                 char *key;
7543                 char *str;
7544
7545                 if (type == DBUS_TYPE_INVALID)
7546                         break;
7547
7548                 dbus_message_iter_recurse(&subiter, &dictiter);
7549
7550                 dbus_message_iter_get_basic(&dictiter, &key);
7551                 if (!dbus_message_iter_next(&dictiter))
7552                         return btd_error_invalid_args(msg);
7553
7554                 if (dbus_message_iter_get_arg_type(&dictiter) !=
7555                                                         DBUS_TYPE_VARIANT)
7556                         return btd_error_invalid_args(msg);
7557
7558                 dbus_message_iter_recurse(&dictiter, &value);
7559
7560                 if (!strcmp(key, "Address")) {
7561                         if (dbus_message_iter_get_arg_type(&value) !=
7562                                                         DBUS_TYPE_STRING)
7563                                 return btd_error_invalid_args(msg);
7564
7565                         dbus_message_iter_get_basic(&value, &str);
7566
7567                         if (str2ba(str, &addr) < 0 )
7568                                 return btd_error_invalid_args(msg);
7569                 } else if (!strcmp(key, "AddressType")) {
7570                         if (dbus_message_iter_get_arg_type(&value) !=
7571                                                         DBUS_TYPE_STRING)
7572                                 return btd_error_invalid_args(msg);
7573
7574                         dbus_message_iter_get_basic(&value, &str);
7575
7576
7577                         if (!strcmp(str, "public"))
7578                                 addr_type = BDADDR_LE_PUBLIC;
7579                         else if (!strcmp(str, "random"))
7580                                 addr_type = BDADDR_LE_RANDOM;
7581                         else
7582                                 return btd_error_invalid_args(msg);
7583                 } else {
7584                         return btd_error_invalid_args(msg);
7585                 }
7586
7587                 dbus_message_iter_next(&subiter);
7588         }
7589
7590         if (!bacmp(&addr, BDADDR_ANY))
7591                 return btd_error_invalid_args(msg);
7592
7593         if (btd_adapter_find_device(adapter, &addr, addr_type))
7594                 return btd_error_already_exists(msg);
7595
7596         device_connect(adapter, &addr, addr_type, msg);
7597         return NULL;
7598 }
7599
7600
7601 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7602 static DBusMessage *adapter_unpair_device(DBusConnection *conn,
7603                                         DBusMessage *msg, void *user_data)
7604 {
7605         DBG("+");
7606         struct btd_adapter *adapter = user_data;
7607         struct btd_device *device;
7608         const char *path;
7609         GSList *list;
7610
7611         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
7612                                                 DBUS_TYPE_INVALID) == FALSE)
7613                 return btd_error_invalid_args(msg);
7614
7615         list = g_slist_find_custom(adapter->devices, path, device_path_cmp);
7616         if (!list)
7617                 return btd_error_does_not_exist(msg);
7618
7619         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7620                 return btd_error_not_ready(msg);
7621
7622         device = list->data;
7623
7624         btd_device_set_temporary(device, TRUE);
7625
7626         if (!btd_device_is_connected(device)) {
7627                 btd_adapter_unpair_device(adapter, device);
7628                 return dbus_message_new_method_return(msg);
7629         }
7630
7631         device_request_disconnect(device, msg);
7632
7633         DBG("-");
7634         return NULL;
7635 }
7636
7637 static DBusMessage *create_device(DBusConnection *conn,
7638                                         DBusMessage *msg, void *data)
7639 {
7640         struct btd_adapter *adapter = data;
7641         const gchar *address;
7642         bdaddr_t addr;
7643         DBG("+");
7644
7645         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
7646                                                 DBUS_TYPE_INVALID) == FALSE)
7647                 return btd_error_invalid_args(msg);
7648
7649         if (bachk(address) < 0)
7650                 return btd_error_invalid_args(msg);
7651
7652         DBG("%s", address);
7653
7654         str2ba(address, &addr);
7655         btd_adapter_get_device(adapter, &addr, BDADDR_BREDR);
7656
7657         DBG("-");
7658         return dbus_message_new_method_return(msg);
7659 }
7660
7661 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
7662                                         void *data)
7663 {
7664         struct btd_adapter *adapter = data;
7665         struct btd_device *device;
7666         DBusMessage *reply;
7667         const gchar *address;
7668         GSList *l;
7669         const gchar *dev_path;
7670
7671         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
7672                                 DBUS_TYPE_INVALID))
7673                 return btd_error_invalid_args(msg);
7674
7675         l = g_slist_find_custom(adapter->devices, address, device_rpa_cmp);
7676         if (!l)
7677                 l = g_slist_find_custom(adapter->devices, address,
7678                                                         device_address_cmp);
7679         if (!l)
7680                 return btd_error_does_not_exist(msg);
7681
7682         device = l->data;
7683
7684         reply = dbus_message_new_method_return(msg);
7685         if (!reply)
7686                 return NULL;
7687
7688         dev_path = device_get_path(device);
7689
7690         dbus_message_append_args(reply,
7691                         DBUS_TYPE_OBJECT_PATH, &dev_path,
7692                         DBUS_TYPE_INVALID);
7693
7694         return reply;
7695 }
7696
7697 static gboolean adapter_ipsp_connected(struct btd_adapter *adapter)
7698 {
7699         GSList *l, *next;
7700
7701         DBG("%s", adapter->path);
7702
7703         for (l = adapter->connections; l != NULL; l = next) {
7704                 struct btd_device *dev = l->data;
7705
7706                 next = g_slist_next(l);
7707
7708                 if (device_is_ipsp_connected(dev))
7709                         return TRUE;
7710         }
7711
7712         return FALSE;
7713 }
7714
7715 static void adapter_set_ipsp_init_state(struct btd_adapter *adapter, gboolean initialized)
7716 {
7717         if (adapter->ipsp_intialized == initialized)
7718                 return;
7719
7720         adapter->ipsp_intialized = initialized;
7721
7722         g_dbus_emit_property_changed(dbus_conn, adapter->path,
7723                                                 ADAPTER_INTERFACE, "IpspInitStateChanged");
7724 }
7725
7726 static void deinitialize_6lowpan_complete(uint8_t status, uint16_t length,
7727         const void *param, void *user_data)
7728 {
7729         struct btd_adapter *adapter = user_data;
7730         bool initialized = FALSE;
7731
7732         if (status != MGMT_STATUS_SUCCESS)
7733                 error("De-Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
7734                         adapter->dev_id, mgmt_errstr(status), status);
7735         else {
7736                 adapter_set_ipsp_init_state(adapter, initialized);
7737                 DBG("De-Initialize BT 6lowpan successfully for hci%u",
7738                         adapter->dev_id);
7739         }
7740 }
7741
7742 static bool deinitialize_6lowpan(struct btd_adapter *adapter)
7743 {
7744         struct mgmt_cp_enable_6lowpan cp;
7745
7746         memset(&cp, 0, sizeof(cp));
7747
7748         cp.enable_6lowpan = DEINIT_6LOWPAN;
7749         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
7750                         adapter->dev_id, sizeof(cp), &cp,
7751                         deinitialize_6lowpan_complete, adapter, NULL) > 0)
7752                 return true;
7753
7754         error("Failed to de-initialize BT 6Lowpan for index %u",
7755                 adapter->dev_id);
7756         return false;
7757 }
7758
7759 static void initialize_6lowpan_complete(uint8_t status, uint16_t length,
7760         const void *param, void *user_data)
7761 {
7762         struct btd_adapter *adapter = user_data;
7763         bool initialized = TRUE;
7764
7765         if (status != MGMT_STATUS_SUCCESS)
7766                 error("Initialize BT 6lowpan failed for hci%u: %s (0x%02x)",
7767                         adapter->dev_id, mgmt_errstr(status), status);
7768         else {
7769                 adapter_set_ipsp_init_state(adapter, initialized);
7770                 DBG("Initialize BT 6lowpan successfully for hci%u",
7771                         adapter->dev_id);
7772         }
7773 }
7774
7775 static bool initialize_6lowpan(struct btd_adapter *adapter)
7776 {
7777         struct mgmt_cp_enable_6lowpan cp;
7778
7779         memset(&cp, 0, sizeof(cp));
7780
7781         cp.enable_6lowpan = INIT_6LOWPAN;
7782         if (mgmt_send(adapter->mgmt, MGMT_OP_ENABLE_6LOWPAN,
7783                         adapter->dev_id, sizeof(cp), &cp,
7784                         initialize_6lowpan_complete, adapter, NULL) > 0)
7785                 return true;
7786
7787         error("Failed to initialize BT 6Lowpan for index %u",
7788                 adapter->dev_id);
7789         return false;
7790 }
7791
7792 static DBusMessage *adapter_initialize_ipsp(DBusConnection *conn,
7793                                         DBusMessage *msg, void *data)
7794 {
7795         struct btd_adapter *adapter = data;
7796         dbus_bool_t err;
7797
7798         DBG("Initialize IPSP");
7799
7800         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7801                 return btd_error_not_ready(msg);
7802
7803         if (adapter->ipsp_intialized)
7804                 return btd_error_already_exists(msg);
7805
7806         /* Enable BT 6lowpan in kernel */
7807         err = initialize_6lowpan(adapter);
7808
7809         if (!err)
7810                 return btd_error_failed(msg, "Failed to initialize BT 6lowpan");
7811
7812         return dbus_message_new_method_return(msg);
7813 }
7814
7815 static DBusMessage *adapter_deinitialize_ipsp(DBusConnection *conn,
7816                                         DBusMessage *msg, void *data)
7817 {
7818         struct btd_adapter *adapter = data;
7819         dbus_bool_t err;
7820
7821         DBG("De-initialize IPSP");
7822
7823         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
7824                 return btd_error_not_ready(msg);
7825
7826         if (!adapter->ipsp_intialized)
7827                 return btd_error_not_permitted(msg, "IPSP not initialized");
7828
7829         if (adapter_ipsp_connected(adapter))
7830                 return btd_error_not_permitted(msg, "IPSP Client device found connected");
7831
7832         /* Disable BT 6lowpan in kernel */
7833         err = deinitialize_6lowpan(adapter);
7834
7835         if (!err)
7836                 return btd_error_failed(msg, "Failed to deinitialize BT 6lowpan");
7837
7838         return dbus_message_new_method_return(msg);
7839 }
7840 #endif
7841
7842 static const GDBusMethodTable adapter_methods[] = {
7843         { GDBUS_ASYNC_METHOD("StartDiscovery", NULL, NULL, start_discovery) },
7844         { GDBUS_METHOD("SetDiscoveryFilter",
7845                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
7846                                 set_discovery_filter) },
7847         { GDBUS_ASYNC_METHOD("StopDiscovery", NULL, NULL, stop_discovery) },
7848 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7849         { GDBUS_METHOD("StartCustomDiscovery",
7850                         GDBUS_ARGS({ "type", "s" }), NULL,
7851                         adapter_start_custom_discovery) },
7852         { GDBUS_METHOD("StartLEDiscovery", NULL, NULL,
7853                         adapter_start_le_discovery) },
7854         { GDBUS_ASYNC_METHOD("StopLEDiscovery", NULL, NULL,
7855                         adapter_stop_le_discovery) },
7856         { GDBUS_METHOD("SetAdvertising",
7857                         GDBUS_ARGS({ "enable", "b" },
7858                                 { "slot_id", "i" }), NULL,
7859                         adapter_set_advertising) },
7860         { GDBUS_METHOD("SetAdvertisingParameters",
7861                         GDBUS_ARGS({ "interval_min", "u" },
7862                                 { "interval_max", "u" },
7863                                 { "filter_policy", "u" },
7864                                 { "type", "u" },
7865                                 { "tx_power_level", "i" },
7866                                 { "slot_id", "i" }), NULL,
7867                         adapter_set_advertising_params) },
7868         { GDBUS_METHOD("SetAdvertisingData",
7869                         GDBUS_ARGS({ "value", "ay" },
7870                                 { "slot_id", "i" }), NULL,
7871                         adapter_set_advertising_data) },
7872         { GDBUS_METHOD("SetScanParameters",
7873                         GDBUS_ARGS({ "type", "u" },
7874                                 { "interval", "u" },
7875                                 { "window", "u" }), NULL,
7876                         adapter_le_set_scan_params) },
7877         { GDBUS_ASYNC_METHOD("scan_filter_param_setup",
7878                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
7879                                 { "filt_index", "i" }, { "feat_seln", "i"},
7880                                 { "list_logic_type", "i" }, { "filt_logic_type", "i"},
7881                                 { "rssi_high_thres", "i" }, { "rssi_low_thres", "i"},
7882                                 { "dely_mode", "i" }, { "found_timeout", "i"},
7883                                 { "lost_timeout", "i" }, { "found_timeout_cnt", "i"}), NULL,
7884                         adapter_le_scan_filter_param_setup) },
7885         { GDBUS_ASYNC_METHOD("scan_filter_add_remove",
7886                         GDBUS_ARGS({ "client_if", "i" }, { "action", "i" },
7887                                 { "filt_type", "i" }, { "filt_index", "i"},
7888                                 { "company_id", "i" }, { "company_id_mask", "i"},
7889                                 { "p_uuid", "ay" }, { "p_uuid_mask", "ay" },
7890                                 { "string", "s" }, { "address_type", "u" },
7891                                 /*{ "data_len", "i" },*/ { "p_data", "ay" },
7892                                 /*{ "mask_len", "i" },*/ { "p_mask", "ay" }), NULL,
7893                         adapter_le_scan_filter_add_remove) },
7894         { GDBUS_ASYNC_METHOD("scan_filter_clear",
7895                         GDBUS_ARGS({ "client_if", "i" }, { "filt_index", "i" }), NULL,
7896                         adapter_le_scan_filter_clear) },
7897         { GDBUS_ASYNC_METHOD("scan_filter_enable",
7898                         GDBUS_ARGS({ "client_if", "i" }, { "enable", "b" }), NULL,
7899                         adapter_le_scan_filter_enable) },
7900         { GDBUS_METHOD("InitializeIpsp",
7901                         NULL, NULL,
7902                         adapter_initialize_ipsp) },
7903         { GDBUS_METHOD("DeinitializeIpsp",
7904                         NULL, NULL,
7905                         adapter_deinitialize_ipsp) },
7906         { GDBUS_METHOD("SetScanRespData",
7907                         GDBUS_ARGS({ "value", "ay" },
7908                                 { "slot_id", "i" }), NULL,
7909                         adapter_set_scan_rsp_data) },
7910         { GDBUS_METHOD("AddDeviceWhiteList",
7911                         GDBUS_ARGS({ "address", "s" },
7912                                 { "address_type", "u" }), NULL,
7913                         adapter_add_device_white_list) },
7914         { GDBUS_METHOD("RemoveDeviceWhiteList",
7915                         GDBUS_ARGS({ "address", "s" },
7916                                 { "address_type", "u" }), NULL,
7917                         adapter_remove_device_white_list) },
7918         { GDBUS_METHOD("ClearDeviceWhiteList",
7919                         NULL, NULL,
7920                         adapter_clear_device_white_list) },
7921         { GDBUS_METHOD("SetLePrivacy",
7922                         GDBUS_ARGS({ "enable", "b" }), NULL,
7923                         adapter_set_le_privacy) },
7924         { GDBUS_METHOD("SetLeStaticRandomAddress",
7925                         GDBUS_ARGS({ "enable", "b" }), NULL,
7926                         adapter_set_le_static_address) },
7927         { GDBUS_ASYNC_METHOD("EnableRssi",
7928                         GDBUS_ARGS({ "bt_address", "s" },
7929                                 { "link_type", "i" },
7930                                 { "low_th", "i" },
7931                                 { "in_range_th", "i" },
7932                                 { "high_th", "i"}),
7933                         NULL,
7934                         adapter_enable_rssi) },
7935         { GDBUS_ASYNC_METHOD("GetRssiStrength",
7936                         GDBUS_ARGS({ "bt_address", "s" }, { "link_type", "i" }),
7937                         NULL,
7938                         adapter_get_rssi) },
7939         { GDBUS_ASYNC_METHOD("UnpairDevice",
7940                         GDBUS_ARGS({ "device", "o" }), NULL, adapter_unpair_device) },
7941         { GDBUS_METHOD("FindDevice",
7942                         GDBUS_ARGS({ "address", "s" }),
7943                         GDBUS_ARGS({ "device", "o" }),
7944                         find_device) },
7945         { GDBUS_METHOD("SetWbsParameters",
7946                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
7947                         NULL,
7948                         set_wbs_parameters) },
7949         { GDBUS_METHOD("SetNbParameters",
7950                         GDBUS_ARGS({ "role", "s" }, { "bt_address", "s" }),
7951                         NULL,
7952                         set_nb_parameters) },
7953         { GDBUS_METHOD("SetManufacturerData",
7954                         GDBUS_ARGS({ "value", "ay" }), NULL,
7955                         adapter_set_manufacturer_data) },
7956         { GDBUS_ASYNC_METHOD("CreateDevice",
7957                         GDBUS_ARGS({ "address", "s" }), NULL,
7958                         create_device) },
7959         { GDBUS_METHOD("GetEnergyInfo",
7960                         NULL,
7961                         GDBUS_ARGS({ "tx_time", "u" },
7962                                 { "rx_time", "u" },
7963                                 { "idle_time", "u" },
7964                                 { "energy_used", "u" }),
7965                         adapter_get_energy_info) },
7966 #endif
7967         { GDBUS_ASYNC_METHOD("RemoveDevice",
7968                         GDBUS_ARGS({ "device", "o" }), NULL, remove_device) },
7969 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
7970         { GDBUS_ASYNC_METHOD("LEReadMaximumDataLength", NULL,
7971                         GDBUS_ARGS({"maxTxOctets", "q" }, { "maxTxTime", "q" },
7972                                 {"maxRxOctets", "q" }, { "maxRxTime", "q" }),
7973                         le_read_maximum_data_length)},
7974         { GDBUS_ASYNC_METHOD("LEWriteHostSuggestedDataLength",
7975                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }), NULL,
7976                         le_write_host_suggested_default_data_length)},
7977         { GDBUS_ASYNC_METHOD("LEReadHostSuggestedDataLength", NULL,
7978                         GDBUS_ARGS({"def_tx_octets", "q" }, { "def_tx_time", "q" }),
7979                         le_read_host_suggested_default_data_length)},
7980         { GDBUS_ASYNC_METHOD("GetLeBatchingAvailablePkts",
7981                         NULL,
7982                         GDBUS_ARGS({ "AvailablePkts", "u" }),
7983                         adapter_get_le_batching_available_pkts) },
7984         { GDBUS_ASYNC_METHOD("EnableLeBatching",
7985                         GDBUS_ARGS({ "bt_address", "s" },
7986                                 { "packet_threshold", "i" },
7987                                 { "timeout", "i"}),
7988                         NULL,
7989                         adapter_enable_le_batching) },
7990         { GDBUS_ASYNC_METHOD("DisableLeBatching",
7991                         GDBUS_ARGS({ "bt_address", "s" }),
7992                         NULL,
7993                         adapter_disable_le_batching) },
7994 #endif
7995         { GDBUS_METHOD("GetDiscoveryFilters", NULL,
7996                         GDBUS_ARGS({ "filters", "as" }),
7997                         get_discovery_filters) },
7998         { GDBUS_EXPERIMENTAL_ASYNC_METHOD("ConnectDevice",
7999                                 GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
8000                                 connect_device) },
8001         { }
8002 };
8003
8004 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8005 static const GDBusSignalTable adapter_signals[] = {
8006         { GDBUS_SIGNAL("AdvertisingEnabled",
8007                         GDBUS_ARGS({ "slot_id", "i" },
8008                                         { "enabled", "b"})) },
8009         { GDBUS_SIGNAL("RssiEnabled",
8010                         GDBUS_ARGS({"address","s"},
8011                                         { "link_type", "i" },
8012                                         { "enabled", "b"})) },
8013         { GDBUS_SIGNAL("RssiAlert",
8014                         GDBUS_ARGS({"address","s"},
8015                                         { "link_type", "i" },
8016                                         { "alert_type", "i" },
8017                                         { "rssi_dbm", "i"})) },
8018         { GDBUS_SIGNAL("RawRssi",
8019                         GDBUS_ARGS({"address","s"},
8020                                         { "link_type", "i" },
8021                                         { "rssi_dbm", "i"})) },
8022         { GDBUS_SIGNAL("HardwareError", NULL) },
8023         { GDBUS_SIGNAL("TxTimeoutError", NULL) },
8024         { }
8025 };
8026 #endif
8027
8028 static const GDBusPropertyTable adapter_properties[] = {
8029         { "Address", "s", property_get_address },
8030         { "AddressType", "s", property_get_address_type },
8031         { "Name", "s", property_get_name },
8032         { "Alias", "s", property_get_alias, property_set_alias },
8033         { "Class", "u", property_get_class },
8034         { "Powered", "b", property_get_powered, property_set_powered },
8035         { "Discoverable", "b", property_get_discoverable,
8036                                         property_set_discoverable },
8037         { "DiscoverableTimeout", "u", property_get_discoverable_timeout,
8038                                         property_set_discoverable_timeout },
8039         { "Pairable", "b", property_get_pairable, property_set_pairable },
8040         { "PairableTimeout", "u", property_get_pairable_timeout,
8041                                         property_set_pairable_timeout },
8042         { "Discovering", "b", property_get_discovering },
8043 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8044         { "LEDiscovering", "b", property_get_le_discovering },
8045 #endif
8046         { "UUIDs", "as", property_get_uuids },
8047         { "Modalias", "s", property_get_modalias, NULL,
8048                                         property_exists_modalias },
8049 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8050         { "Connectable", "b", property_get_connectable,
8051                                         property_set_connectable },
8052         { "Version", "s", property_get_version },
8053         { "SupportedLEFeatures", "as", property_get_supported_le_features},
8054         { "IpspInitStateChanged", "b", property_get_ipsp_init_state},
8055         { "LEAddress", "as", property_get_le_address },
8056         { "A2dpRole", "u", property_get_a2dp_role },
8057 #endif
8058
8059         { }
8060 };
8061
8062 static int str2buf(const char *str, uint8_t *buf, size_t blen)
8063 {
8064         int i, dlen;
8065
8066         if (str == NULL)
8067                 return -EINVAL;
8068
8069         memset(buf, 0, blen);
8070
8071         dlen = MIN((strlen(str) / 2), blen);
8072
8073         for (i = 0; i < dlen; i++)
8074                 sscanf(str + (i * 2), "%02hhX", &buf[i]);
8075
8076         return 0;
8077 }
8078
8079 static struct link_key_info *get_key_info(GKeyFile *key_file, const char *peer)
8080 {
8081         struct link_key_info *info = NULL;
8082         char *str;
8083
8084         str = g_key_file_get_string(key_file, "LinkKey", "Key", NULL);
8085         if (!str || strlen(str) < 32)
8086                 goto failed;
8087
8088         info = g_new0(struct link_key_info, 1);
8089
8090         str2ba(peer, &info->bdaddr);
8091
8092         if (!strncmp(str, "0x", 2))
8093                 str2buf(&str[2], info->key, sizeof(info->key));
8094         else
8095                 str2buf(&str[0], info->key, sizeof(info->key));
8096
8097         info->type = g_key_file_get_integer(key_file, "LinkKey", "Type", NULL);
8098         info->pin_len = g_key_file_get_integer(key_file, "LinkKey", "PINLength",
8099                                                 NULL);
8100
8101 failed:
8102         g_free(str);
8103
8104         return info;
8105 }
8106
8107 static struct smp_ltk_info *get_ltk(GKeyFile *key_file, const char *peer,
8108                                         uint8_t peer_type, const char *group)
8109 {
8110         struct smp_ltk_info *ltk = NULL;
8111         GError *gerr = NULL;
8112         bool master;
8113         char *key;
8114         char *rand = NULL;
8115
8116         key = g_key_file_get_string(key_file, group, "Key", NULL);
8117         if (!key || strlen(key) < 32)
8118                 goto failed;
8119
8120         rand = g_key_file_get_string(key_file, group, "Rand", NULL);
8121         if (!rand)
8122                 goto failed;
8123
8124         ltk = g_new0(struct smp_ltk_info, 1);
8125
8126         /* Default to assuming a master key */
8127         ltk->master = true;
8128
8129         str2ba(peer, &ltk->bdaddr);
8130         ltk->bdaddr_type = peer_type;
8131
8132         /*
8133          * Long term keys should respond to an identity address which can
8134          * either be a public address or a random static address. Keys
8135          * stored for resolvable random and unresolvable random addresses
8136          * are ignored.
8137          *
8138          * This is an extra sanity check for older kernel versions or older
8139          * daemons that might have been instructed to store long term keys
8140          * for these temporary addresses.
8141          */
8142         if (ltk->bdaddr_type == BDADDR_LE_RANDOM &&
8143                                         (ltk->bdaddr.b[5] & 0xc0) != 0xc0) {
8144                 g_free(ltk);
8145                 ltk = NULL;
8146                 goto failed;
8147         }
8148
8149         if (!strncmp(key, "0x", 2))
8150                 str2buf(&key[2], ltk->val, sizeof(ltk->val));
8151         else
8152                 str2buf(&key[0], ltk->val, sizeof(ltk->val));
8153
8154         if (!strncmp(rand, "0x", 2)) {
8155                 uint64_t rand_le;
8156                 str2buf(&rand[2], (uint8_t *) &rand_le, sizeof(rand_le));
8157                 ltk->rand = le64_to_cpu(rand_le);
8158         } else {
8159                 sscanf(rand, "%" PRIu64, &ltk->rand);
8160         }
8161
8162         ltk->authenticated = g_key_file_get_integer(key_file, group,
8163                                                         "Authenticated", NULL);
8164         ltk->enc_size = g_key_file_get_integer(key_file, group, "EncSize",
8165                                                                         NULL);
8166         ltk->ediv = g_key_file_get_integer(key_file, group, "EDiv", NULL);
8167
8168         master = g_key_file_get_boolean(key_file, group, "Master", &gerr);
8169         if (gerr)
8170                 g_error_free(gerr);
8171         else
8172                 ltk->master = master;
8173
8174 failed:
8175         g_free(key);
8176         g_free(rand);
8177
8178         return ltk;
8179 }
8180
8181 static struct smp_ltk_info *get_ltk_info(GKeyFile *key_file, const char *peer,
8182                                                         uint8_t bdaddr_type)
8183 {
8184         DBG("%s", peer);
8185
8186         return get_ltk(key_file, peer, bdaddr_type, "LongTermKey");
8187 }
8188
8189 static struct smp_ltk_info *get_slave_ltk_info(GKeyFile *key_file,
8190                                                         const char *peer,
8191                                                         uint8_t bdaddr_type)
8192 {
8193         struct smp_ltk_info *ltk;
8194
8195         DBG("%s", peer);
8196
8197         ltk = get_ltk(key_file, peer, bdaddr_type, "SlaveLongTermKey");
8198         if (ltk)
8199                 ltk->master = false;
8200
8201         return ltk;
8202 }
8203
8204 static struct irk_info *get_irk_info(GKeyFile *key_file, const char *peer,
8205                                                         uint8_t bdaddr_type)
8206 {
8207         struct irk_info *irk = NULL;
8208         char *str;
8209
8210         str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
8211 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8212         if (!str)
8213                 return NULL;
8214         if (strlen(str) < 32) {
8215                 g_free(str);
8216                 return NULL;
8217         }
8218 #else
8219         if (!str || strlen(str) < 32)
8220                 goto failed;
8221 #endif
8222
8223         irk = g_new0(struct irk_info, 1);
8224
8225         str2ba(peer, &irk->bdaddr);
8226         irk->bdaddr_type = bdaddr_type;
8227
8228         if (!strncmp(str, "0x", 2))
8229                 str2buf(&str[2], irk->val, sizeof(irk->val));
8230         else
8231                 str2buf(&str[0], irk->val, sizeof(irk->val));
8232 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
8233 failed:
8234 #endif
8235         g_free(str);
8236
8237         return irk;
8238 }
8239
8240 static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
8241                                                         uint8_t bdaddr_type)
8242 {
8243         struct conn_param *param;
8244
8245         if (!g_key_file_has_group(key_file, "ConnectionParameters"))
8246                 return NULL;
8247
8248         param = g_new0(struct conn_param, 1);
8249
8250         param->min_interval = g_key_file_get_integer(key_file,
8251                                                         "ConnectionParameters",
8252                                                         "MinInterval", NULL);
8253         param->max_interval = g_key_file_get_integer(key_file,
8254                                                         "ConnectionParameters",
8255                                                         "MaxInterval", NULL);
8256         param->latency = g_key_file_get_integer(key_file,
8257                                                         "ConnectionParameters",
8258                                                         "Latency", NULL);
8259         param->timeout = g_key_file_get_integer(key_file,
8260                                                         "ConnectionParameters",
8261                                                         "Timeout", NULL);
8262         str2ba(peer, &param->bdaddr);
8263         param->bdaddr_type = bdaddr_type;
8264
8265         return param;
8266 }
8267
8268 #if 0
8269 static int generate_and_write_irk(uint8_t *irk, GKeyFile *key_file,
8270                                                         const char *filename)
8271 {
8272         struct bt_crypto *crypto;
8273         char str_irk_out[33];
8274         gsize length = 0;
8275         char *str;
8276         int i;
8277
8278         crypto = bt_crypto_new();
8279         if (!crypto) {
8280                 error("Failed to open crypto");
8281                 return -1;
8282         }
8283
8284         if (!bt_crypto_random_bytes(crypto, irk, 16)) {
8285                 error("Failed to generate IRK");
8286                 bt_crypto_unref(crypto);
8287                 return -1;
8288         }
8289
8290         bt_crypto_unref(crypto);
8291
8292         for (i = 0; i < 16; i++)
8293                 sprintf(str_irk_out + (i * 2), "%02x", irk[i]);
8294
8295         str_irk_out[32] = '\0';
8296         info("Generated IRK successfully");
8297
8298         g_key_file_set_string(key_file, "General", "IdentityResolvingKey",
8299                                                                 str_irk_out);
8300         str = g_key_file_to_data(key_file, &length, NULL);
8301         g_file_set_contents(filename, str, length, NULL);
8302         g_free(str);
8303         DBG("Generated IRK written to file");
8304         return 0;
8305 }
8306
8307 static int load_irk(struct btd_adapter *adapter, uint8_t *irk)
8308 {
8309         char filename[PATH_MAX];
8310         GKeyFile *key_file;
8311         char *str_irk;
8312         int ret;
8313
8314         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/identity",
8315                                         btd_adapter_get_storage_dir(adapter));
8316
8317         key_file = g_key_file_new();
8318         g_key_file_load_from_file(key_file, filename, 0, NULL);
8319
8320         str_irk = g_key_file_get_string(key_file, "General",
8321                                                 "IdentityResolvingKey", NULL);
8322         if (!str_irk) {
8323                 info("No IRK stored");
8324                 ret = generate_and_write_irk(irk, key_file, filename);
8325                 g_key_file_free(key_file);
8326                 return ret;
8327         }
8328
8329         g_key_file_free(key_file);
8330
8331         if (strlen(str_irk) != 32 || str2buf(str_irk, irk, 16)) {
8332                 /* TODO re-create new IRK here? */
8333                 error("Invalid IRK format, disabling privacy");
8334                 g_free(str_irk);
8335                 return -1;
8336         }
8337
8338         g_free(str_irk);
8339         DBG("Successfully read IRK from file");
8340         return 0;
8341 }
8342
8343 static void set_privacy_complete(uint8_t status, uint16_t length,
8344                                         const void *param, void *user_data)
8345 {
8346         struct btd_adapter *adapter = user_data;
8347
8348         if (status != MGMT_STATUS_SUCCESS) {
8349                 btd_error(adapter->dev_id, "Failed to set privacy: %s (0x%02x)",
8350                                                 mgmt_errstr(status), status);
8351                 return;
8352         }
8353
8354         DBG("Successfuly set privacy for index %u", adapter->dev_id);
8355 }
8356
8357 static int set_privacy(struct btd_adapter *adapter, uint8_t privacy)
8358 {
8359         struct mgmt_cp_set_privacy cp;
8360
8361         memset(&cp, 0, sizeof(cp));
8362
8363         if (privacy) {
8364                 uint8_t irk[16];
8365
8366                 if (load_irk(adapter, irk) == 0) {
8367                         cp.privacy = privacy;
8368                         memcpy(cp.irk, irk, 16);
8369                 }
8370         }
8371
8372         DBG("sending set privacy command for index %u", adapter->dev_id);
8373         DBG("setting privacy mode 0x%02x for index %u", cp.privacy,
8374                                                         adapter->dev_id);
8375
8376         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
8377                                 adapter->dev_id, sizeof(cp), &cp,
8378                                 set_privacy_complete, adapter, NULL) > 0)
8379                 return 0;
8380
8381         btd_error(adapter->dev_id, "Failed to set privacy for index %u",
8382                                                         adapter->dev_id);
8383
8384         return -1;
8385 }
8386 #endif
8387
8388 static void load_link_keys_complete(uint8_t status, uint16_t length,
8389                                         const void *param, void *user_data)
8390 {
8391         struct btd_adapter *adapter = user_data;
8392
8393         if (status != MGMT_STATUS_SUCCESS) {
8394                 btd_error(adapter->dev_id,
8395                         "Failed to load link keys for hci%u: %s (0x%02x)",
8396                                 adapter->dev_id, mgmt_errstr(status), status);
8397                 return;
8398         }
8399
8400         DBG("link keys loaded for hci%u", adapter->dev_id);
8401 }
8402
8403 static void load_link_keys(struct btd_adapter *adapter, GSList *keys,
8404                                                         bool debug_keys)
8405 {
8406         struct mgmt_cp_load_link_keys *cp;
8407         struct mgmt_link_key_info *key;
8408         size_t key_count, cp_size;
8409         unsigned int id;
8410         GSList *l;
8411
8412         /*
8413          * If the controller does not support BR/EDR operation,
8414          * there is no point in trying to load the link keys into
8415          * the kernel.
8416          *
8417          * This is an optimization for Low Energy only controllers.
8418          */
8419         if (!(adapter->supported_settings & MGMT_SETTING_BREDR))
8420                 return;
8421
8422         key_count = g_slist_length(keys);
8423
8424         DBG("hci%u keys %zu debug_keys %d", adapter->dev_id, key_count,
8425                                                                 debug_keys);
8426
8427         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
8428
8429         cp = g_try_malloc0(cp_size);
8430         if (cp == NULL) {
8431                 btd_error(adapter->dev_id, "No memory for link keys for hci%u",
8432                                                         adapter->dev_id);
8433                 return;
8434         }
8435
8436         /*
8437          * Even if the list of stored keys is empty, it is important to
8438          * load an empty list into the kernel. That way it is ensured
8439          * that no old keys from a previous daemon are present.
8440          *
8441          * In addition it is also the only way to toggle the different
8442          * behavior for debug keys.
8443          */
8444         cp->debug_keys = debug_keys;
8445         cp->key_count = htobs(key_count);
8446
8447         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
8448                 struct link_key_info *info = l->data;
8449
8450                 bacpy(&key->addr.bdaddr, &info->bdaddr);
8451                 key->addr.type = BDADDR_BREDR;
8452                 key->type = info->type;
8453                 memcpy(key->val, info->key, 16);
8454                 key->pin_len = info->pin_len;
8455         }
8456
8457         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_LINK_KEYS,
8458                                 adapter->dev_id, cp_size, cp,
8459                                 load_link_keys_complete, adapter, NULL);
8460
8461         g_free(cp);
8462
8463         if (id == 0)
8464                 btd_error(adapter->dev_id, "Failed to load link keys for hci%u",
8465                                                         adapter->dev_id);
8466 }
8467
8468 static gboolean load_ltks_timeout(gpointer user_data)
8469 {
8470         struct btd_adapter *adapter = user_data;
8471
8472         btd_error(adapter->dev_id, "Loading LTKs timed out for hci%u",
8473                                                         adapter->dev_id);
8474
8475         adapter->load_ltks_timeout = 0;
8476
8477         mgmt_cancel(adapter->mgmt, adapter->load_ltks_id);
8478         adapter->load_ltks_id = 0;
8479
8480         return FALSE;
8481 }
8482
8483 static void load_ltks_complete(uint8_t status, uint16_t length,
8484                                         const void *param, void *user_data)
8485 {
8486         struct btd_adapter *adapter = user_data;
8487
8488         if (status != MGMT_STATUS_SUCCESS) {
8489                 btd_error(adapter->dev_id,
8490                                 "Failed to load LTKs for hci%u: %s (0x%02x)",
8491                                 adapter->dev_id, mgmt_errstr(status), status);
8492         }
8493
8494         adapter->load_ltks_id = 0;
8495
8496         g_source_remove(adapter->load_ltks_timeout);
8497         adapter->load_ltks_timeout = 0;
8498
8499         DBG("LTKs loaded for hci%u", adapter->dev_id);
8500 }
8501
8502 static void load_ltks(struct btd_adapter *adapter, GSList *keys)
8503 {
8504         struct mgmt_cp_load_long_term_keys *cp;
8505         struct mgmt_ltk_info *key;
8506         size_t key_count, cp_size;
8507         GSList *l;
8508
8509         /*
8510          * If the controller does not support Low Energy operation,
8511          * there is no point in trying to load the long term keys
8512          * into the kernel.
8513          *
8514          * While there is no harm in loading keys into the kernel,
8515          * this is an optimization to avoid a confusing warning
8516          * message when the loading of the keys timed out due to
8517          * a kernel bug (see comment below).
8518          */
8519         if (!(adapter->supported_settings & MGMT_SETTING_LE))
8520                 return;
8521
8522         key_count = g_slist_length(keys);
8523
8524         DBG("hci%u keys %zu", adapter->dev_id, key_count);
8525
8526         cp_size = sizeof(*cp) + (key_count * sizeof(*key));
8527
8528         cp = g_try_malloc0(cp_size);
8529         if (cp == NULL) {
8530                 btd_error(adapter->dev_id, "No memory for LTKs for hci%u",
8531                                                         adapter->dev_id);
8532                 return;
8533         }
8534
8535         /*
8536          * Even if the list of stored keys is empty, it is important to
8537          * load an empty list into the kernel. That way it is ensured
8538          * that no old keys from a previous daemon are present.
8539          */
8540         cp->key_count = htobs(key_count);
8541
8542         for (l = keys, key = cp->keys; l != NULL; l = g_slist_next(l), key++) {
8543                 struct smp_ltk_info *info = l->data;
8544
8545                 bacpy(&key->addr.bdaddr, &info->bdaddr);
8546                 key->addr.type = info->bdaddr_type;
8547                 memcpy(key->val, info->val, sizeof(info->val));
8548                 key->rand = cpu_to_le64(info->rand);
8549                 key->ediv = cpu_to_le16(info->ediv);
8550                 key->type = info->authenticated;
8551                 key->master = info->master;
8552                 key->enc_size = info->enc_size;
8553         }
8554
8555         adapter->load_ltks_id = mgmt_send(adapter->mgmt,
8556                                         MGMT_OP_LOAD_LONG_TERM_KEYS,
8557                                         adapter->dev_id, cp_size, cp,
8558                                         load_ltks_complete, adapter, NULL);
8559
8560         g_free(cp);
8561
8562         if (adapter->load_ltks_id == 0) {
8563                 btd_error(adapter->dev_id, "Failed to load LTKs for hci%u",
8564                                                         adapter->dev_id);
8565                 return;
8566         }
8567
8568         /*
8569          * This timeout handling is needed since the kernel is stupid
8570          * and forgets to send a command complete response. However in
8571          * case of failures it does send a command status.
8572          */
8573         adapter->load_ltks_timeout = g_timeout_add_seconds(2,
8574                                                 load_ltks_timeout, adapter);
8575 }
8576
8577 static void load_irks_complete(uint8_t status, uint16_t length,
8578                                         const void *param, void *user_data)
8579 {
8580         struct btd_adapter *adapter = user_data;
8581
8582         if (status == MGMT_STATUS_UNKNOWN_COMMAND) {
8583                 btd_info(adapter->dev_id,
8584                         "Load IRKs failed: Kernel doesn't support LE Privacy");
8585                 return;
8586         }
8587
8588         if (status != MGMT_STATUS_SUCCESS) {
8589                 btd_error(adapter->dev_id,
8590                                 "Failed to load IRKs for hci%u: %s (0x%02x)",
8591                                 adapter->dev_id, mgmt_errstr(status), status);
8592                 return;
8593         }
8594
8595         DBG("IRKs loaded for hci%u", adapter->dev_id);
8596 }
8597
8598 static void load_irks(struct btd_adapter *adapter, GSList *irks)
8599 {
8600         struct mgmt_cp_load_irks *cp;
8601         struct mgmt_irk_info *irk;
8602         size_t irk_count, cp_size;
8603         unsigned int id;
8604         GSList *l;
8605
8606         /*
8607          * If the controller does not support LE Privacy operation,
8608          * there is no support for loading identity resolving keys
8609          * into the kernel.
8610          */
8611         if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
8612                 return;
8613
8614         irk_count = g_slist_length(irks);
8615
8616         DBG("hci%u irks %zu", adapter->dev_id, irk_count);
8617
8618         cp_size = sizeof(*cp) + (irk_count * sizeof(*irk));
8619
8620         cp = g_try_malloc0(cp_size);
8621         if (cp == NULL) {
8622                 btd_error(adapter->dev_id, "No memory for IRKs for hci%u",
8623                                                         adapter->dev_id);
8624                 return;
8625         }
8626
8627         /*
8628          * Even if the list of stored keys is empty, it is important to
8629          * load an empty list into the kernel. That way we tell the
8630          * kernel that we are able to handle New IRK events.
8631          */
8632         cp->irk_count = htobs(irk_count);
8633
8634         for (l = irks, irk = cp->irks; l != NULL; l = g_slist_next(l), irk++) {
8635                 struct irk_info *info = l->data;
8636
8637                 bacpy(&irk->addr.bdaddr, &info->bdaddr);
8638                 irk->addr.type = info->bdaddr_type;
8639                 memcpy(irk->val, info->val, sizeof(irk->val));
8640         }
8641
8642         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_IRKS, adapter->dev_id,
8643                         cp_size, cp, load_irks_complete, adapter, NULL);
8644
8645         g_free(cp);
8646
8647         if (id == 0)
8648                 btd_error(adapter->dev_id, "Failed to IRKs for hci%u",
8649                                                         adapter->dev_id);
8650 }
8651
8652 static void load_conn_params_complete(uint8_t status, uint16_t length,
8653                                         const void *param, void *user_data)
8654 {
8655         struct btd_adapter *adapter = user_data;
8656
8657         if (status != MGMT_STATUS_SUCCESS) {
8658                 btd_error(adapter->dev_id,
8659                         "hci%u Load Connection Parameters failed: %s (0x%02x)",
8660                                 adapter->dev_id, mgmt_errstr(status), status);
8661                 return;
8662         }
8663
8664         DBG("Connection Parameters loaded for hci%u", adapter->dev_id);
8665 }
8666
8667 static void load_conn_params(struct btd_adapter *adapter, GSList *params)
8668 {
8669         struct mgmt_cp_load_conn_param *cp;
8670         struct mgmt_conn_param *param;
8671         size_t param_count, cp_size;
8672         unsigned int id;
8673         GSList *l;
8674
8675         /*
8676          * If the controller does not support Low Energy operation,
8677          * there is no point in trying to load the connection
8678          * parameters into the kernel.
8679          */
8680         if (!(adapter->supported_settings & MGMT_SETTING_LE))
8681                 return;
8682
8683         param_count = g_slist_length(params);
8684
8685         DBG("hci%u conn params %zu", adapter->dev_id, param_count);
8686
8687         cp_size = sizeof(*cp) + (param_count * sizeof(*param));
8688
8689         cp = g_try_malloc0(cp_size);
8690         if (cp == NULL) {
8691                 btd_error(adapter->dev_id,
8692                         "Failed to allocate memory for connection parameters");
8693                 return;
8694         }
8695
8696         cp->param_count = htobs(param_count);
8697
8698         for (l = params, param = cp->params; l; l = g_slist_next(l), param++) {
8699                 struct conn_param *info = l->data;
8700
8701                 bacpy(&param->addr.bdaddr, &info->bdaddr);
8702                 param->addr.type = info->bdaddr_type;
8703                 param->min_interval = htobs(info->min_interval);
8704                 param->max_interval = htobs(info->max_interval);
8705                 param->latency = htobs(info->latency);
8706                 param->timeout = htobs(info->timeout);
8707         }
8708
8709         id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_PARAM, adapter->dev_id,
8710                         cp_size, cp, load_conn_params_complete, adapter, NULL);
8711
8712         g_free(cp);
8713
8714         if (id == 0)
8715                 btd_error(adapter->dev_id, "Load connection parameters failed");
8716 }
8717
8718 static uint8_t get_le_addr_type(GKeyFile *keyfile)
8719 {
8720         uint8_t addr_type;
8721         char *type;
8722
8723         type = g_key_file_get_string(keyfile, "General", "AddressType", NULL);
8724         if (!type)
8725                 return BDADDR_LE_PUBLIC;
8726
8727         if (g_str_equal(type, "public"))
8728                 addr_type = BDADDR_LE_PUBLIC;
8729         else if (g_str_equal(type, "static"))
8730                 addr_type = BDADDR_LE_RANDOM;
8731         else
8732                 addr_type = BDADDR_LE_PUBLIC;
8733
8734         g_free(type);
8735
8736         return addr_type;
8737 }
8738
8739 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8740 static uint8_t get_addr_type(GKeyFile *keyfile)
8741 {
8742         char **techno, **t;
8743         char *str;
8744         uint8_t bdaddr_type = BDADDR_BREDR;
8745         bool le = false;
8746
8747         /* Load device technology */
8748         techno = g_key_file_get_string_list(keyfile, "General",
8749                                         "SupportedTechnologies", NULL, NULL);
8750         if (!techno)
8751                 return 0xff;
8752
8753         for (t = techno; *t; t++) {
8754                 if (g_str_equal(*t, "LE"))
8755                         le = true;
8756         }
8757
8758         if (!le) {
8759                 bdaddr_type = BDADDR_BREDR;
8760         } else {
8761                 str = g_key_file_get_string(keyfile, "General",
8762                                                 "AddressType", NULL);
8763
8764                 if (str && g_str_equal(str, "public"))
8765                         bdaddr_type = BDADDR_LE_PUBLIC;
8766                 else if (str && g_str_equal(str, "static"))
8767                         bdaddr_type = BDADDR_LE_RANDOM;
8768                 else
8769                         error("Unknown LE device technology");
8770
8771                 g_free(str);
8772         }
8773
8774         g_strfreev(techno);
8775
8776         return bdaddr_type;
8777 }
8778 #endif
8779
8780 static void probe_devices(void *user_data)
8781 {
8782         struct btd_device *device = user_data;
8783
8784         device_probe_profiles(device, btd_device_get_uuids(device));
8785 }
8786
8787 static void load_devices(struct btd_adapter *adapter)
8788 {
8789         char dirname[PATH_MAX];
8790         GSList *keys = NULL;
8791         GSList *ltks = NULL;
8792         GSList *irks = NULL;
8793         GSList *params = NULL;
8794         GSList *added_devices = NULL;
8795         DIR *dir;
8796         struct dirent *entry;
8797
8798         snprintf(dirname, PATH_MAX, STORAGEDIR "/%s",
8799                                         btd_adapter_get_storage_dir(adapter));
8800
8801         dir = opendir(dirname);
8802         if (!dir) {
8803                 btd_error(adapter->dev_id,
8804                                 "Unable to open adapter storage directory: %s",
8805                                                                 dirname);
8806                 return;
8807         }
8808
8809         while ((entry = readdir(dir)) != NULL) {
8810                 struct btd_device *device;
8811                 char filename[PATH_MAX];
8812                 GKeyFile *key_file;
8813 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8814                 struct link_key_info *key_info = NULL;
8815                 struct smp_ltk_info *ltk_info = NULL;
8816                 struct smp_ltk_info *slave_ltk_info = NULL;
8817                 GSList *list = NULL;
8818                 struct device_addr_type addr;
8819 #else
8820                 struct link_key_info *key_info;
8821                 struct smp_ltk_info *ltk_info;
8822                 struct smp_ltk_info *slave_ltk_info;
8823                 GSList *list;
8824 #endif
8825                 struct irk_info *irk_info;
8826                 struct conn_param *param;
8827                 uint8_t bdaddr_type;
8828
8829                 if (entry->d_type == DT_UNKNOWN)
8830                         entry->d_type = util_get_dt(dirname, entry->d_name);
8831
8832                 if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
8833                         continue;
8834
8835 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8836 {
8837                 bdaddr_t bdaddr;
8838
8839                 str2ba(entry->d_name, &bdaddr);
8840
8841                 if (!bacmp(&bdaddr, BDADDR_ANY)) {
8842                         error("No Bluetooth address");
8843                         continue;
8844                 }
8845 }
8846 #endif
8847                 snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
8848                                         btd_adapter_get_storage_dir(adapter),
8849                                         entry->d_name);
8850
8851                 key_file = g_key_file_new();
8852                 g_key_file_load_from_file(key_file, filename, 0, NULL);
8853
8854                 key_info = get_key_info(key_file, entry->d_name);
8855                 if (key_info)
8856                         keys = g_slist_append(keys, key_info);
8857
8858                 bdaddr_type = get_le_addr_type(key_file);
8859
8860                 ltk_info = get_ltk_info(key_file, entry->d_name, bdaddr_type);
8861                 if (ltk_info)
8862                         ltks = g_slist_append(ltks, ltk_info);
8863
8864                 slave_ltk_info = get_slave_ltk_info(key_file, entry->d_name,
8865                                                                 bdaddr_type);
8866                 if (slave_ltk_info)
8867                         ltks = g_slist_append(ltks, slave_ltk_info);
8868
8869                 irk_info = get_irk_info(key_file, entry->d_name, bdaddr_type);
8870                 if (irk_info)
8871                         irks = g_slist_append(irks, irk_info);
8872
8873                 param = get_conn_param(key_file, entry->d_name, bdaddr_type);
8874                 if (param)
8875                         params = g_slist_append(params, param);
8876
8877 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8878                 str2ba(entry->d_name, &addr.bdaddr);
8879                 addr.bdaddr_type = get_addr_type(key_file);
8880                 if (addr.bdaddr_type == 0xff) {
8881                         error("No SupportedTechnologies. Skipping");
8882                         goto free;
8883                 }
8884
8885                 list = g_slist_find_custom(adapter->devices, &addr,
8886                                                 device_addr_type_strict_cmp);
8887 #else
8888                 list = g_slist_find_custom(adapter->devices, entry->d_name,
8889                                                         device_address_cmp);
8890 #endif
8891                 if (list) {
8892 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8893                         DBG("Skip already loaded device [%s] [%d]",
8894                                         entry->d_name, addr.bdaddr_type);
8895 #endif
8896                         device = list->data;
8897                         goto device_exist;
8898                 }
8899
8900                 device = device_create_from_storage(adapter, entry->d_name,
8901                                                         key_file);
8902                 if (!device)
8903                         goto free;
8904
8905 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
8906 {
8907                 char idaddr[18];
8908
8909                 /*
8910                  * After loading IRK information from file,
8911                  * store it into device->bdaddr.
8912                  * RPA is stored in device->rpa_addr
8913                  */
8914                 ba2str(device_get_address(device), idaddr);
8915
8916                 DBG("irk address: %s, rpa_exist %d",
8917                                 idaddr, device_get_rpa_exist(device));
8918
8919                 if (device_get_rpa_exist(device) == true) {
8920                         if (key_info)
8921                                 str2ba(idaddr, &key_info->bdaddr);
8922
8923                         if (ltk_info) {
8924                                 ltks = g_slist_remove(ltks, ltk_info);
8925                                 ltk_info = get_ltk_info(key_file,
8926                                                 idaddr, bdaddr_type);
8927                                 if (ltk_info)
8928                                         ltks = g_slist_append(ltks, ltk_info);
8929                         }
8930
8931                         if (slave_ltk_info) {
8932                                 ltks = g_slist_remove(ltks, slave_ltk_info);
8933                                 slave_ltk_info = get_slave_ltk_info(key_file,
8934                                                 idaddr, bdaddr_type);
8935                                 if (slave_ltk_info)
8936                                         ltks = g_slist_append(ltks, slave_ltk_info);
8937                         }
8938
8939                         if (irk_info) {
8940                                 str2ba(idaddr, &irk_info->bdaddr);
8941                                 device_set_irk_value(device, irk_info->val);
8942                         }
8943
8944                         if (param)
8945                                 str2ba(idaddr, &param->bdaddr);
8946                 }
8947 }
8948 #endif
8949
8950                 btd_device_set_temporary(device, false);
8951                 adapter->devices = g_slist_append(adapter->devices, device);
8952
8953                 /* TODO: register services from pre-loaded list of primaries */
8954
8955                 added_devices = g_slist_append(added_devices, device);
8956
8957 device_exist:
8958                 if (key_info) {
8959                         device_set_paired(device, BDADDR_BREDR);
8960                         device_set_bonded(device, BDADDR_BREDR);
8961                 }
8962
8963                 if (ltk_info || slave_ltk_info) {
8964                         device_set_paired(device, bdaddr_type);
8965                         device_set_bonded(device, bdaddr_type);
8966
8967                         if (ltk_info)
8968                                 device_set_ltk_enc_size(device,
8969                                                         ltk_info->enc_size);
8970                         else if (slave_ltk_info)
8971                                 device_set_ltk_enc_size(device,
8972                                                 slave_ltk_info->enc_size);
8973                 }
8974
8975 free:
8976                 g_key_file_free(key_file);
8977         }
8978
8979         closedir(dir);
8980
8981         load_link_keys(adapter, keys, main_opts.debug_keys);
8982         g_slist_free_full(keys, g_free);
8983
8984         load_ltks(adapter, ltks);
8985         g_slist_free_full(ltks, g_free);
8986         load_irks(adapter, irks);
8987         g_slist_free_full(irks, g_free);
8988         load_conn_params(adapter, params);
8989         g_slist_free_full(params, g_free);
8990
8991         g_slist_free_full(added_devices, probe_devices);
8992 }
8993
8994 int btd_adapter_block_address(struct btd_adapter *adapter,
8995                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
8996 {
8997         struct mgmt_cp_block_device cp;
8998         char addr[18];
8999
9000         ba2str(bdaddr, addr);
9001         DBG("hci%u %s", adapter->dev_id, addr);
9002
9003         memset(&cp, 0, sizeof(cp));
9004         bacpy(&cp.addr.bdaddr, bdaddr);
9005         cp.addr.type = bdaddr_type;
9006
9007         if (mgmt_send(adapter->mgmt, MGMT_OP_BLOCK_DEVICE,
9008                                 adapter->dev_id, sizeof(cp), &cp,
9009                                 NULL, NULL, NULL) > 0)
9010                 return 0;
9011
9012         return -EIO;
9013 }
9014
9015 int btd_adapter_unblock_address(struct btd_adapter *adapter,
9016                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
9017 {
9018         struct mgmt_cp_unblock_device cp;
9019         char addr[18];
9020
9021         ba2str(bdaddr, addr);
9022         DBG("hci%u %s", adapter->dev_id, addr);
9023
9024         memset(&cp, 0, sizeof(cp));
9025         bacpy(&cp.addr.bdaddr, bdaddr);
9026         cp.addr.type = bdaddr_type;
9027
9028         if (mgmt_send(adapter->mgmt, MGMT_OP_UNBLOCK_DEVICE,
9029                                 adapter->dev_id, sizeof(cp), &cp,
9030                                 NULL, NULL, NULL) > 0)
9031                 return 0;
9032
9033         return -EIO;
9034 }
9035
9036 static int clear_blocked(struct btd_adapter *adapter)
9037 {
9038         return btd_adapter_unblock_address(adapter, BDADDR_ANY, 0);
9039 }
9040
9041 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
9042 {
9043         struct btd_adapter_driver *driver = user_data;
9044         int err;
9045
9046         if (driver->probe == NULL)
9047                 return;
9048
9049         err = driver->probe(adapter);
9050         if (err < 0) {
9051                 btd_error(adapter->dev_id, "%s: %s (%d)", driver->name,
9052                                                         strerror(-err), -err);
9053                 return;
9054         }
9055
9056         adapter->drivers = g_slist_prepend(adapter->drivers, driver);
9057 }
9058
9059 static void load_drivers(struct btd_adapter *adapter)
9060 {
9061         GSList *l;
9062
9063         for (l = adapter_drivers; l; l = l->next)
9064                 probe_driver(adapter, l->data);
9065 }
9066
9067 static void probe_profile(struct btd_profile *profile, void *data)
9068 {
9069         struct btd_adapter *adapter = data;
9070         int err;
9071
9072         if (profile->adapter_probe == NULL)
9073                 return;
9074
9075         err = profile->adapter_probe(profile, adapter);
9076         if (err < 0) {
9077                 btd_error(adapter->dev_id, "%s: %s (%d)", profile->name,
9078                                                         strerror(-err), -err);
9079                 return;
9080         }
9081
9082         adapter->profiles = g_slist_prepend(adapter->profiles, profile);
9083 }
9084
9085 void adapter_add_profile(struct btd_adapter *adapter, gpointer p)
9086 {
9087         struct btd_profile *profile = p;
9088
9089         if (!adapter->initialized)
9090                 return;
9091
9092         probe_profile(profile, adapter);
9093
9094         g_slist_foreach(adapter->devices, device_probe_profile, profile);
9095 }
9096
9097 void adapter_remove_profile(struct btd_adapter *adapter, gpointer p)
9098 {
9099         struct btd_profile *profile = p;
9100
9101         if (!adapter->initialized)
9102                 return;
9103
9104         if (profile->device_remove)
9105                 g_slist_foreach(adapter->devices, device_remove_profile, p);
9106
9107         adapter->profiles = g_slist_remove(adapter->profiles, profile);
9108
9109         if (profile->adapter_remove)
9110                 profile->adapter_remove(profile, adapter);
9111 }
9112
9113 static void adapter_add_connection(struct btd_adapter *adapter,
9114                                                 struct btd_device *device,
9115                                                 uint8_t bdaddr_type)
9116 {
9117         device_add_connection(device, bdaddr_type);
9118
9119         if (g_slist_find(adapter->connections, device)) {
9120                 btd_error(adapter->dev_id,
9121                                 "Device is already marked as connected");
9122                 return;
9123         }
9124
9125         adapter->connections = g_slist_append(adapter->connections, device);
9126 }
9127
9128 static void get_connections_complete(uint8_t status, uint16_t length,
9129                                         const void *param, void *user_data)
9130 {
9131         struct btd_adapter *adapter = user_data;
9132         const struct mgmt_rp_get_connections *rp = param;
9133         uint16_t i, conn_count;
9134
9135         if (status != MGMT_STATUS_SUCCESS) {
9136                 btd_error(adapter->dev_id,
9137                                 "Failed to get connections: %s (0x%02x)",
9138                                                 mgmt_errstr(status), status);
9139                 return;
9140         }
9141
9142         if (length < sizeof(*rp)) {
9143                 btd_error(adapter->dev_id,
9144                                 "Wrong size of get connections response");
9145                 return;
9146         }
9147
9148         conn_count = btohs(rp->conn_count);
9149
9150         DBG("Connection count: %d", conn_count);
9151
9152         if (conn_count * sizeof(struct mgmt_addr_info) +
9153                                                 sizeof(*rp) != length) {
9154                 btd_error(adapter->dev_id,
9155                         "Incorrect packet size for get connections response");
9156                 return;
9157         }
9158
9159         for (i = 0; i < conn_count; i++) {
9160                 const struct mgmt_addr_info *addr = &rp->addr[i];
9161                 struct btd_device *device;
9162                 char address[18];
9163
9164                 ba2str(&addr->bdaddr, address);
9165                 DBG("Adding existing connection to %s", address);
9166
9167                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
9168                                                                 addr->type);
9169                 if (device)
9170                         adapter_add_connection(adapter, device, addr->type);
9171         }
9172 }
9173
9174 static void load_connections(struct btd_adapter *adapter)
9175 {
9176         DBG("sending get connections command for index %u", adapter->dev_id);
9177
9178         if (mgmt_send(adapter->mgmt, MGMT_OP_GET_CONNECTIONS,
9179                                 adapter->dev_id, 0, NULL,
9180                                 get_connections_complete, adapter, NULL) > 0)
9181                 return;
9182
9183         btd_error(adapter->dev_id, "Failed to get connections for index %u",
9184                                                         adapter->dev_id);
9185 }
9186
9187 bool btd_adapter_get_pairable(struct btd_adapter *adapter)
9188 {
9189         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
9190                 return true;
9191
9192         return false;
9193 }
9194
9195 bool btd_adapter_get_powered(struct btd_adapter *adapter)
9196 {
9197         if (adapter->current_settings & MGMT_SETTING_POWERED)
9198                 return true;
9199
9200         return false;
9201 }
9202
9203 bool btd_adapter_get_connectable(struct btd_adapter *adapter)
9204 {
9205         if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
9206                 return true;
9207
9208         return false;
9209 }
9210
9211 bool btd_adapter_get_discoverable(struct btd_adapter *adapter)
9212 {
9213         if (adapter->current_settings & MGMT_SETTING_DISCOVERABLE)
9214                 return true;
9215
9216         return false;
9217 }
9218
9219 bool btd_adapter_get_bredr(struct btd_adapter *adapter)
9220 {
9221         if (adapter->current_settings & MGMT_SETTING_BREDR)
9222                 return true;
9223
9224         return false;
9225 }
9226
9227 struct btd_gatt_database *btd_adapter_get_database(struct btd_adapter *adapter)
9228 {
9229         if (!adapter)
9230                 return NULL;
9231
9232         return adapter->database;
9233 }
9234
9235 uint32_t btd_adapter_get_class(struct btd_adapter *adapter)
9236 {
9237         return adapter->dev_class;
9238 }
9239
9240 const char *btd_adapter_get_name(struct btd_adapter *adapter)
9241 {
9242         if (adapter->stored_alias)
9243                 return adapter->stored_alias;
9244
9245         if (adapter->system_name)
9246                 return adapter->system_name;
9247
9248         return NULL;
9249 }
9250
9251 int adapter_connect_list_add(struct btd_adapter *adapter,
9252                                         struct btd_device *device)
9253 {
9254         /*
9255          * If the adapter->connect_le device is getting added back to
9256          * the connect list it probably means that the connect attempt
9257          * failed and hence we should clear this pointer
9258          */
9259         if (device == adapter->connect_le)
9260                 adapter->connect_le = NULL;
9261
9262         /*
9263          * If kernel background scanning is supported then the
9264          * adapter_auto_connect_add() function is used to maintain what to
9265          * connect.
9266          */
9267         if (kernel_conn_control)
9268                 return 0;
9269
9270         if (g_slist_find(adapter->connect_list, device)) {
9271                 DBG("ignoring already added device %s",
9272                                                 device_get_path(device));
9273                 goto done;
9274         }
9275
9276         if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
9277                 btd_error(adapter->dev_id,
9278                         "Can't add %s to non-LE capable adapter connect list",
9279                                                 device_get_path(device));
9280                 return -ENOTSUP;
9281         }
9282
9283         adapter->connect_list = g_slist_append(adapter->connect_list, device);
9284         DBG("%s added to %s's connect_list", device_get_path(device),
9285                                                         adapter->system_name);
9286
9287 done:
9288         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
9289                 return 0;
9290
9291         trigger_passive_scanning(adapter);
9292
9293         return 0;
9294 }
9295
9296 void adapter_connect_list_remove(struct btd_adapter *adapter,
9297                                         struct btd_device *device)
9298 {
9299         /*
9300          * If the adapter->connect_le device is being removed from the
9301          * connect list it means the connection was successful and hence
9302          * the pointer should be cleared
9303          */
9304         if (device == adapter->connect_le)
9305                 adapter->connect_le = NULL;
9306
9307         if (kernel_conn_control)
9308                 return;
9309
9310         if (!g_slist_find(adapter->connect_list, device)) {
9311                 DBG("device %s is not on the list, ignoring",
9312                                                 device_get_path(device));
9313                 return;
9314         }
9315
9316         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
9317         DBG("%s removed from %s's connect_list", device_get_path(device),
9318                                                         adapter->system_name);
9319
9320         if (!adapter->connect_list) {
9321                 stop_passive_scanning(adapter);
9322                 return;
9323         }
9324
9325         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
9326                 return;
9327
9328         trigger_passive_scanning(adapter);
9329 }
9330
9331 static void add_whitelist_complete(uint8_t status, uint16_t length,
9332                                         const void *param, void *user_data)
9333 {
9334         const struct mgmt_rp_add_device *rp = param;
9335         struct btd_adapter *adapter = user_data;
9336         struct btd_device *dev;
9337         char addr[18];
9338
9339         if (length < sizeof(*rp)) {
9340                 btd_error(adapter->dev_id,
9341                                 "Too small Add Device complete event");
9342                 return;
9343         }
9344
9345         ba2str(&rp->addr.bdaddr, addr);
9346
9347         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
9348                                                         rp->addr.type);
9349         if (!dev) {
9350                 btd_error(adapter->dev_id,
9351                         "Add Device complete for unknown device %s", addr);
9352                 return;
9353         }
9354
9355         if (status != MGMT_STATUS_SUCCESS) {
9356                 btd_error(adapter->dev_id,
9357                                         "Failed to add device %s: %s (0x%02x)",
9358                                         addr, mgmt_errstr(status), status);
9359                 return;
9360         }
9361
9362         DBG("%s added to kernel whitelist", addr);
9363 }
9364
9365 void adapter_whitelist_add(struct btd_adapter *adapter, struct btd_device *dev)
9366 {
9367         struct mgmt_cp_add_device cp;
9368
9369         if (!kernel_conn_control)
9370                 return;
9371
9372         memset(&cp, 0, sizeof(cp));
9373         bacpy(&cp.addr.bdaddr, device_get_address(dev));
9374         cp.addr.type = BDADDR_BREDR;
9375         cp.action = 0x01;
9376
9377         mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
9378                                 adapter->dev_id, sizeof(cp), &cp,
9379                                 add_whitelist_complete, adapter, NULL);
9380 }
9381
9382 static void remove_whitelist_complete(uint8_t status, uint16_t length,
9383                                         const void *param, void *user_data)
9384 {
9385         const struct mgmt_rp_remove_device *rp = param;
9386         char addr[18];
9387
9388         if (length < sizeof(*rp)) {
9389                 error("Too small Remove Device complete event");
9390                 return;
9391         }
9392
9393         ba2str(&rp->addr.bdaddr, addr);
9394
9395         if (status != MGMT_STATUS_SUCCESS) {
9396                 error("Failed to remove device %s: %s (0x%02x)",
9397                                         addr, mgmt_errstr(status), status);
9398                 return;
9399         }
9400
9401         DBG("%s removed from kernel whitelist", addr);
9402 }
9403
9404 void adapter_whitelist_remove(struct btd_adapter *adapter, struct btd_device *dev)
9405 {
9406         struct mgmt_cp_remove_device cp;
9407
9408         if (!kernel_conn_control)
9409                 return;
9410
9411         memset(&cp, 0, sizeof(cp));
9412         bacpy(&cp.addr.bdaddr, device_get_address(dev));
9413         cp.addr.type = BDADDR_BREDR;
9414
9415         mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
9416                                 adapter->dev_id, sizeof(cp), &cp,
9417                                 remove_whitelist_complete, adapter, NULL);
9418 }
9419
9420 static void add_device_complete(uint8_t status, uint16_t length,
9421                                         const void *param, void *user_data)
9422 {
9423         const struct mgmt_rp_add_device *rp = param;
9424         struct btd_adapter *adapter = user_data;
9425         struct btd_device *dev;
9426         char addr[18];
9427
9428         if (length < sizeof(*rp)) {
9429                 btd_error(adapter->dev_id,
9430                                 "Too small Add Device complete event");
9431                 return;
9432         }
9433
9434         ba2str(&rp->addr.bdaddr, addr);
9435
9436         dev = btd_adapter_find_device(adapter, &rp->addr.bdaddr,
9437                                                         rp->addr.type);
9438         if (!dev) {
9439                 btd_error(adapter->dev_id,
9440                         "Add Device complete for unknown device %s", addr);
9441                 return;
9442         }
9443
9444         if (status != MGMT_STATUS_SUCCESS) {
9445                 btd_error(adapter->dev_id,
9446                         "Failed to add device %s (%u): %s (0x%02x)",
9447                         addr, rp->addr.type, mgmt_errstr(status), status);
9448                 adapter->connect_list = g_slist_remove(adapter->connect_list,
9449                                                                         dev);
9450                 return;
9451         }
9452
9453         DBG("%s (%u) added to kernel connect list", addr, rp->addr.type);
9454 }
9455
9456 void adapter_auto_connect_add(struct btd_adapter *adapter,
9457                                         struct btd_device *device)
9458 {
9459         struct mgmt_cp_add_device cp;
9460         const bdaddr_t *bdaddr;
9461         uint8_t bdaddr_type;
9462         unsigned int id;
9463
9464         if (!kernel_conn_control)
9465                 return;
9466
9467         if (g_slist_find(adapter->connect_list, device)) {
9468                 DBG("ignoring already added device %s",
9469                                                 device_get_path(device));
9470                 return;
9471         }
9472
9473         bdaddr = device_get_address(device);
9474         bdaddr_type = btd_device_get_bdaddr_type(device);
9475
9476         if (bdaddr_type == BDADDR_BREDR) {
9477                 DBG("auto-connection feature is not avaiable for BR/EDR");
9478                 return;
9479         }
9480
9481         memset(&cp, 0, sizeof(cp));
9482         bacpy(&cp.addr.bdaddr, bdaddr);
9483         cp.addr.type = bdaddr_type;
9484         cp.action = 0x02;
9485
9486         id = mgmt_send(adapter->mgmt, MGMT_OP_ADD_DEVICE,
9487                         adapter->dev_id, sizeof(cp), &cp, add_device_complete,
9488                         adapter, NULL);
9489         if (id == 0)
9490                 return;
9491
9492         adapter->connect_list = g_slist_append(adapter->connect_list, device);
9493 }
9494
9495 static void remove_device_complete(uint8_t status, uint16_t length,
9496                                         const void *param, void *user_data)
9497 {
9498         const struct mgmt_rp_remove_device *rp = param;
9499         char addr[18];
9500
9501         if (length < sizeof(*rp)) {
9502                 error("Too small Remove Device complete event");
9503                 return;
9504         }
9505
9506         ba2str(&rp->addr.bdaddr, addr);
9507
9508         if (status != MGMT_STATUS_SUCCESS) {
9509                 error("Failed to remove device %s (%u): %s (0x%02x)",
9510                         addr, rp->addr.type, mgmt_errstr(status), status);
9511                 return;
9512         }
9513
9514         DBG("%s (%u) removed from kernel connect list", addr, rp->addr.type);
9515 }
9516
9517 void adapter_auto_connect_remove(struct btd_adapter *adapter,
9518                                         struct btd_device *device)
9519 {
9520         struct mgmt_cp_remove_device cp;
9521         const bdaddr_t *bdaddr;
9522         uint8_t bdaddr_type;
9523         unsigned int id;
9524
9525         if (!kernel_conn_control)
9526                 return;
9527
9528         if (!g_slist_find(adapter->connect_list, device)) {
9529                 DBG("ignoring not added device %s", device_get_path(device));
9530                 return;
9531         }
9532
9533         bdaddr = device_get_address(device);
9534         bdaddr_type = btd_device_get_bdaddr_type(device);
9535
9536         if (bdaddr_type == BDADDR_BREDR) {
9537                 DBG("auto-connection feature is not avaiable for BR/EDR");
9538                 return;
9539         }
9540
9541         memset(&cp, 0, sizeof(cp));
9542         bacpy(&cp.addr.bdaddr, bdaddr);
9543         cp.addr.type = bdaddr_type;
9544
9545         id = mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
9546                         adapter->dev_id, sizeof(cp), &cp,
9547                         remove_device_complete, adapter, NULL);
9548         if (id == 0)
9549                 return;
9550
9551         adapter->connect_list = g_slist_remove(adapter->connect_list, device);
9552 }
9553
9554 #if defined (TIZEN_FEATURE_BLUEZ_MODIFY)
9555 static void get_phy_configuration_resp(uint8_t status, uint16_t len, const void *param,
9556                                                         void *user_data)
9557 {
9558         uint32_t supported_phys;
9559         uint32_t configurable_phys;
9560         uint32_t selected_phys;
9561
9562         const struct mgmt_rp_get_phy_confguration *rp = param;
9563         struct btd_adapter *adapter = user_data;
9564
9565         if (status != MGMT_STATUS_SUCCESS) {
9566                 error("Get PHY Configuration failed with status 0x%02x (%s)",
9567                                 status, mgmt_errstr(status));
9568                 return;
9569         }
9570
9571         if (len < sizeof(*rp)) {
9572                 error("Too small get-phy reply (%u bytes)", len);
9573                 return;
9574         }
9575
9576         supported_phys = get_le32(&rp->supported_phys);
9577         configurable_phys = get_le32(&rp-> configurable_phys);
9578         selected_phys = get_le16(&rp->selected_phys);
9579
9580         DBG("Supported phys: [0x%x]", supported_phys);
9581         DBG("Configurable phys: [0x%x]", configurable_phys);
9582         DBG("Selected phys: [0x%x]", selected_phys);
9583
9584         if (adapter->supported_settings & MGMT_SETTING_LE) {
9585                 if ((supported_phys & MGMT_PHY_LE_2M_TX) &&
9586                                 (supported_phys & MGMT_PHY_LE_2M_RX)) {
9587                         DBG("Adapter supports LE 2M PHY");
9588                         adapter->le_2m_phy_supported = TRUE;
9589                 } else
9590                         DBG("Adapter does not support LE 2M PHY");
9591
9592                 if ((supported_phys & MGMT_PHY_LE_CODED_TX) &&
9593                                 (supported_phys & MGMT_PHY_LE_CODED_RX)) {
9594                         adapter->le_coded_phy_supported = TRUE;
9595                         DBG("Adapter supports LE CODED PHY");
9596                 } else
9597                         DBG("Adapter does not support LE CODED PHY");
9598         }
9599
9600         /* Emit Property Changed Signal */
9601          g_dbus_emit_property_changed(dbus_conn, adapter->path,
9602                         ADAPTER_INTERFACE, "SupportedLEFeatures");
9603
9604 }
9605 #endif
9606
9607 static void adapter_start(struct btd_adapter *adapter)
9608 {
9609
9610 #if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__SPRD_PATCH__)
9611         if (adapter_le_read_ble_feature_info())
9612                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
9613                         ADAPTER_INTERFACE, "SupportedLEFeatures");
9614 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
9615         else
9616                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
9617                         ADAPTER_INTERFACE, "SupportedLEFeatures");
9618 #endif
9619
9620         adapter_get_adv_tx_power(adapter);
9621
9622         /* By default enable offloading for testing, this should be modified */
9623         if (adapter_le_is_supported_offloading())
9624                 adapter_le_enable_offloading(TRUE);
9625 #endif
9626
9627 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
9628         g_dbus_emit_property_changed(dbus_conn, adapter->path,
9629                                                 ADAPTER_INTERFACE, "Powered");
9630 #else
9631         g_dbus_emit_property_changed_full(dbus_conn, adapter->path,
9632                                                 ADAPTER_INTERFACE, "Powered", 1);
9633 #endif
9634
9635         DBG("adapter %s has been enabled", adapter->path);
9636
9637         trigger_passive_scanning(adapter);
9638 }
9639
9640 static void reply_pending_requests(struct btd_adapter *adapter)
9641 {
9642         GSList *l;
9643
9644         if (!adapter)
9645                 return;
9646
9647         /* pending bonding */
9648         for (l = adapter->devices; l; l = l->next) {
9649                 struct btd_device *device = l->data;
9650
9651                 if (device_is_bonding(device, NULL))
9652                         device_bonding_failed(device,
9653                                                 HCI_OE_USER_ENDED_CONNECTION);
9654         }
9655 }
9656
9657 static void remove_driver(gpointer data, gpointer user_data)
9658 {
9659         struct btd_adapter_driver *driver = data;
9660         struct btd_adapter *adapter = user_data;
9661
9662         if (driver->remove)
9663                 driver->remove(adapter);
9664 }
9665
9666 static void remove_profile(gpointer data, gpointer user_data)
9667 {
9668         struct btd_profile *profile = data;
9669         struct btd_adapter *adapter = user_data;
9670
9671         if (profile->adapter_remove)
9672                 profile->adapter_remove(profile, adapter);
9673 }
9674
9675 static void unload_drivers(struct btd_adapter *adapter)
9676 {
9677         g_slist_foreach(adapter->drivers, remove_driver, adapter);
9678         g_slist_free(adapter->drivers);
9679         adapter->drivers = NULL;
9680
9681         g_slist_foreach(adapter->profiles, remove_profile, adapter);
9682         g_slist_free(adapter->profiles);
9683         adapter->profiles = NULL;
9684 }
9685
9686 static void free_service_auth(gpointer data, gpointer user_data)
9687 {
9688         struct service_auth *auth = data;
9689
9690         g_free(auth);
9691 }
9692
9693 static void adapter_free(gpointer user_data)
9694 {
9695         struct btd_adapter *adapter = user_data;
9696
9697         DBG("%p", adapter);
9698
9699         if (adapter->pairable_timeout_id > 0) {
9700                 g_source_remove(adapter->pairable_timeout_id);
9701                 adapter->pairable_timeout_id = 0;
9702         }
9703
9704         if (adapter->passive_scan_timeout > 0) {
9705                 g_source_remove(adapter->passive_scan_timeout);
9706                 adapter->passive_scan_timeout = 0;
9707         }
9708
9709         if (adapter->load_ltks_timeout > 0)
9710                 g_source_remove(adapter->load_ltks_timeout);
9711
9712         if (adapter->confirm_name_timeout > 0)
9713                 g_source_remove(adapter->confirm_name_timeout);
9714
9715         if (adapter->pair_device_timeout > 0)
9716                 g_source_remove(adapter->pair_device_timeout);
9717
9718         if (adapter->auth_idle_id)
9719                 g_source_remove(adapter->auth_idle_id);
9720
9721         g_queue_foreach(adapter->auths, free_service_auth, NULL);
9722         g_queue_free(adapter->auths);
9723
9724         /*
9725          * Unregister all handlers for this specific index since
9726          * the adapter bound to them is no longer valid.
9727          *
9728          * This also avoids having multiple instances of the same
9729          * handler in case indexes got removed and re-added.
9730          */
9731         mgmt_unregister_index(adapter->mgmt, adapter->dev_id);
9732
9733         /*
9734          * Cancel all pending commands for this specific index
9735          * since the adapter bound to them is no longer valid.
9736          */
9737         mgmt_cancel_index(adapter->mgmt, adapter->dev_id);
9738
9739         mgmt_unref(adapter->mgmt);
9740
9741         sdp_list_free(adapter->services, NULL);
9742
9743         g_slist_free(adapter->connections);
9744
9745         g_free(adapter->path);
9746         g_free(adapter->name);
9747         g_free(adapter->short_name);
9748         g_free(adapter->system_name);
9749         g_free(adapter->stored_alias);
9750         g_free(adapter->current_alias);
9751         free(adapter->modalias);
9752         g_free(adapter);
9753 }
9754
9755 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
9756 {
9757         __sync_fetch_and_add(&adapter->ref_count, 1);
9758
9759         return adapter;
9760 }
9761
9762 void btd_adapter_unref(struct btd_adapter *adapter)
9763 {
9764         if (__sync_sub_and_fetch(&adapter->ref_count, 1))
9765                 return;
9766
9767         if (!adapter->path) {
9768                 DBG("Freeing adapter %u", adapter->dev_id);
9769
9770                 adapter_free(adapter);
9771                 return;
9772         }
9773
9774         DBG("Freeing adapter %s", adapter->path);
9775
9776         g_dbus_unregister_interface(dbus_conn, adapter->path,
9777                                                 ADAPTER_INTERFACE);
9778 }
9779
9780 static void convert_names_entry(char *key, char *value, void *user_data)
9781 {
9782         char *address = user_data;
9783         char *str = key;
9784         char filename[PATH_MAX];
9785         GKeyFile *key_file;
9786         char *data;
9787         gsize length = 0;
9788
9789         if (strchr(key, '#'))
9790                 str[17] = '\0';
9791
9792         if (bachk(str) != 0)
9793                 return;
9794
9795         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/cache/%s", address, str);
9796         create_file(filename, S_IRUSR | S_IWUSR);
9797
9798         key_file = g_key_file_new();
9799         g_key_file_load_from_file(key_file, filename, 0, NULL);
9800         g_key_file_set_string(key_file, "General", "Name", value);
9801
9802         data = g_key_file_to_data(key_file, &length, NULL);
9803         g_file_set_contents(filename, data, length, NULL);
9804         g_free(data);
9805
9806         g_key_file_free(key_file);
9807 }
9808
9809 struct device_converter {
9810         char *address;
9811         void (*cb)(GKeyFile *key_file, void *value);
9812         gboolean force;
9813 };
9814
9815 static void set_device_type(GKeyFile *key_file, char type)
9816 {
9817         char *techno;
9818         char *addr_type = NULL;
9819         char *str;
9820
9821         switch (type) {
9822         case BDADDR_BREDR:
9823                 techno = "BR/EDR";
9824                 break;
9825         case BDADDR_LE_PUBLIC:
9826                 techno = "LE";
9827                 addr_type = "public";
9828                 break;
9829         case BDADDR_LE_RANDOM:
9830                 techno = "LE";
9831                 addr_type = "static";
9832                 break;
9833         default:
9834                 return;
9835         }
9836
9837         str = g_key_file_get_string(key_file, "General",
9838                                         "SupportedTechnologies", NULL);
9839         if (!str)
9840                 g_key_file_set_string(key_file, "General",
9841                                         "SupportedTechnologies", techno);
9842         else if (!strstr(str, techno))
9843                 g_key_file_set_string(key_file, "General",
9844                                         "SupportedTechnologies", "BR/EDR;LE");
9845
9846         g_free(str);
9847
9848         if (addr_type)
9849                 g_key_file_set_string(key_file, "General", "AddressType",
9850                                         addr_type);
9851 }
9852
9853 static void convert_aliases_entry(GKeyFile *key_file, void *value)
9854 {
9855         g_key_file_set_string(key_file, "General", "Alias", value);
9856 }
9857
9858 static void convert_trusts_entry(GKeyFile *key_file, void *value)
9859 {
9860         g_key_file_set_boolean(key_file, "General", "Trusted", TRUE);
9861 }
9862
9863 static void convert_classes_entry(GKeyFile *key_file, void *value)
9864 {
9865         g_key_file_set_string(key_file, "General", "Class", value);
9866 }
9867
9868 static void convert_blocked_entry(GKeyFile *key_file, void *value)
9869 {
9870         g_key_file_set_boolean(key_file, "General", "Blocked", TRUE);
9871 }
9872
9873 static void convert_did_entry(GKeyFile *key_file, void *value)
9874 {
9875         char *vendor_str, *product_str, *version_str;
9876         uint16_t val;
9877
9878         vendor_str = strchr(value, ' ');
9879         if (!vendor_str)
9880                 return;
9881
9882         *(vendor_str++) = 0;
9883
9884         if (g_str_equal(value, "FFFF"))
9885                 return;
9886
9887         product_str = strchr(vendor_str, ' ');
9888         if (!product_str)
9889                 return;
9890
9891         *(product_str++) = 0;
9892
9893         version_str = strchr(product_str, ' ');
9894         if (!version_str)
9895                 return;
9896
9897         *(version_str++) = 0;
9898
9899         val = (uint16_t) strtol(value, NULL, 16);
9900         g_key_file_set_integer(key_file, "DeviceID", "Source", val);
9901
9902         val = (uint16_t) strtol(vendor_str, NULL, 16);
9903         g_key_file_set_integer(key_file, "DeviceID", "Vendor", val);
9904
9905         val = (uint16_t) strtol(product_str, NULL, 16);
9906         g_key_file_set_integer(key_file, "DeviceID", "Product", val);
9907
9908         val = (uint16_t) strtol(version_str, NULL, 16);
9909         g_key_file_set_integer(key_file, "DeviceID", "Version", val);
9910 }
9911
9912 static void convert_linkkey_entry(GKeyFile *key_file, void *value)
9913 {
9914         char *type_str, *length_str, *str;
9915         int val;
9916
9917         type_str = strchr(value, ' ');
9918         if (!type_str)
9919                 return;
9920
9921         *(type_str++) = 0;
9922
9923         length_str = strchr(type_str, ' ');
9924         if (!length_str)
9925                 return;
9926
9927         *(length_str++) = 0;
9928
9929         str = g_strconcat("0x", value, NULL);
9930         g_key_file_set_string(key_file, "LinkKey", "Key", str);
9931         g_free(str);
9932
9933         val = strtol(type_str, NULL, 16);
9934         g_key_file_set_integer(key_file, "LinkKey", "Type", val);
9935
9936         val = strtol(length_str, NULL, 16);
9937         g_key_file_set_integer(key_file, "LinkKey", "PINLength", val);
9938 }
9939
9940 static void convert_ltk_entry(GKeyFile *key_file, void *value)
9941 {
9942         char *auth_str, *rand_str, *str;
9943         int i, ret;
9944         unsigned char auth, master, enc_size;
9945         unsigned short ediv;
9946
9947         auth_str = strchr(value, ' ');
9948         if (!auth_str)
9949                 return;
9950
9951         *(auth_str++) = 0;
9952
9953         for (i = 0, rand_str = auth_str; i < 4; i++) {
9954                 rand_str = strchr(rand_str, ' ');
9955                 if (!rand_str || rand_str[1] == '\0')
9956                         return;
9957
9958                 rand_str++;
9959         }
9960
9961         ret = sscanf(auth_str, " %hhd %hhd %hhd %hd", &auth, &master,
9962                                                         &enc_size, &ediv);
9963         if (ret < 4)
9964                 return;
9965
9966         str = g_strconcat("0x", value, NULL);
9967         g_key_file_set_string(key_file, "LongTermKey", "Key", str);
9968         g_free(str);
9969
9970         g_key_file_set_integer(key_file, "LongTermKey", "Authenticated", auth);
9971         g_key_file_set_integer(key_file, "LongTermKey", "Master", master);
9972         g_key_file_set_integer(key_file, "LongTermKey", "EncSize", enc_size);
9973         g_key_file_set_integer(key_file, "LongTermKey", "EDiv", ediv);
9974
9975         str = g_strconcat("0x", rand_str, NULL);
9976         g_key_file_set_string(key_file, "LongTermKey", "Rand", str);
9977         g_free(str);
9978 }
9979
9980 static void convert_profiles_entry(GKeyFile *key_file, void *value)
9981 {
9982         g_strdelimit(value, " ", ';');
9983         g_key_file_set_string(key_file, "General", "Services", value);
9984 }
9985
9986 static void convert_appearances_entry(GKeyFile *key_file, void *value)
9987 {
9988         g_key_file_set_string(key_file, "General", "Appearance", value);
9989 }
9990
9991 static void convert_entry(char *key, char *value, void *user_data)
9992 {
9993         struct device_converter *converter = user_data;
9994         char type = BDADDR_BREDR;
9995         char filename[PATH_MAX];
9996         GKeyFile *key_file;
9997         char *data;
9998         gsize length = 0;
9999
10000         if (strchr(key, '#')) {
10001                 key[17] = '\0';
10002                 type = key[18] - '0';
10003         }
10004
10005         if (bachk(key) != 0)
10006                 return;
10007
10008         if (converter->force == FALSE) {
10009                 struct stat st;
10010                 int err;
10011
10012                 snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s",
10013                                 converter->address, key);
10014
10015                 err = stat(filename, &st);
10016                 if (err || !S_ISDIR(st.st_mode))
10017                         return;
10018         }
10019
10020         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
10021                         converter->address, key);
10022
10023         key_file = g_key_file_new();
10024         g_key_file_load_from_file(key_file, filename, 0, NULL);
10025
10026         set_device_type(key_file, type);
10027
10028         converter->cb(key_file, value);
10029
10030         data = g_key_file_to_data(key_file, &length, NULL);
10031         if (length > 0) {
10032                 create_file(filename, S_IRUSR | S_IWUSR);
10033                 g_file_set_contents(filename, data, length, NULL);
10034         }
10035
10036         g_free(data);
10037
10038         g_key_file_free(key_file);
10039 }
10040
10041 static void convert_file(char *file, char *address,
10042                                 void (*cb)(GKeyFile *key_file, void *value),
10043                                 gboolean force)
10044 {
10045         char filename[PATH_MAX];
10046         struct device_converter converter;
10047
10048         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", address, file);
10049
10050         converter.address = address;
10051         converter.cb = cb;
10052         converter.force = force;
10053
10054         textfile_foreach(filename, convert_entry, &converter);
10055 }
10056
10057 static gboolean record_has_uuid(const sdp_record_t *rec,
10058                                 const char *profile_uuid)
10059 {
10060         sdp_list_t *pat;
10061
10062         for (pat = rec->pattern; pat != NULL; pat = pat->next) {
10063                 char *uuid;
10064                 int ret;
10065
10066                 uuid = bt_uuid2string(pat->data);
10067                 if (!uuid)
10068                         continue;
10069
10070                 ret = strcasecmp(uuid, profile_uuid);
10071
10072                 free(uuid);
10073
10074                 if (ret == 0)
10075                         return TRUE;
10076         }
10077
10078         return FALSE;
10079 }
10080
10081 static void store_attribute_uuid(GKeyFile *key_file, uint16_t start,
10082                                         uint16_t end, char *att_uuid,
10083                                         uuid_t uuid)
10084 {
10085         char handle[6], uuid_str[33];
10086         int i;
10087
10088         switch (uuid.type) {
10089         case SDP_UUID16:
10090                 sprintf(uuid_str, "%4.4X", uuid.value.uuid16);
10091                 break;
10092         case SDP_UUID32:
10093                 sprintf(uuid_str, "%8.8X", uuid.value.uuid32);
10094                 break;
10095         case SDP_UUID128:
10096                 for (i = 0; i < 16; i++)
10097                         sprintf(uuid_str + (i * 2), "%2.2X",
10098                                         uuid.value.uuid128.data[i]);
10099                 break;
10100         default:
10101                 uuid_str[0] = '\0';
10102         }
10103
10104         sprintf(handle, "%hu", start);
10105         g_key_file_set_string(key_file, handle, "UUID", att_uuid);
10106         g_key_file_set_string(key_file, handle, "Value", uuid_str);
10107         g_key_file_set_integer(key_file, handle, "EndGroupHandle", end);
10108 }
10109
10110 static void store_sdp_record(char *local, char *peer, int handle, char *value)
10111 {
10112         char filename[PATH_MAX];
10113         GKeyFile *key_file;
10114         char handle_str[11];
10115         char *data;
10116         gsize length = 0;
10117
10118         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/cache/%s", local, peer);
10119
10120         key_file = g_key_file_new();
10121         g_key_file_load_from_file(key_file, filename, 0, NULL);
10122
10123         sprintf(handle_str, "0x%8.8X", handle);
10124         g_key_file_set_string(key_file, "ServiceRecords", handle_str, value);
10125
10126         data = g_key_file_to_data(key_file, &length, NULL);
10127         if (length > 0) {
10128                 create_file(filename, S_IRUSR | S_IWUSR);
10129                 g_file_set_contents(filename, data, length, NULL);
10130         }
10131
10132         g_free(data);
10133
10134         g_key_file_free(key_file);
10135 }
10136
10137 static void convert_sdp_entry(char *key, char *value, void *user_data)
10138 {
10139         char *src_addr = user_data;
10140         char dst_addr[18];
10141         char type = BDADDR_BREDR;
10142         int handle, ret;
10143         char filename[PATH_MAX];
10144         GKeyFile *key_file;
10145         struct stat st;
10146         sdp_record_t *rec;
10147         uuid_t uuid;
10148         char *att_uuid, *prim_uuid;
10149         uint16_t start = 0, end = 0, psm = 0;
10150         int err;
10151         char *data;
10152         gsize length = 0;
10153
10154         ret = sscanf(key, "%17s#%hhu#%08X", dst_addr, &type, &handle);
10155         if (ret < 3) {
10156                 ret = sscanf(key, "%17s#%08X", dst_addr, &handle);
10157                 if (ret < 2)
10158                         return;
10159         }
10160
10161         if (bachk(dst_addr) != 0)
10162                 return;
10163
10164         /* Check if the device directory has been created as records should
10165          * only be converted for known devices */
10166         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
10167
10168         err = stat(filename, &st);
10169         if (err || !S_ISDIR(st.st_mode))
10170                 return;
10171
10172         /* store device records in cache */
10173         store_sdp_record(src_addr, dst_addr, handle, value);
10174
10175         /* Retrieve device record and check if there is an
10176          * attribute entry in it */
10177         sdp_uuid16_create(&uuid, ATT_UUID);
10178         att_uuid = bt_uuid2string(&uuid);
10179
10180         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
10181         prim_uuid = bt_uuid2string(&uuid);
10182
10183         rec = record_from_string(value);
10184
10185         if (record_has_uuid(rec, att_uuid))
10186                 goto failed;
10187
10188         /* TODO: Do this through btd_gatt_database */
10189         if (!gatt_parse_record(rec, &uuid, &psm, &start, &end))
10190                 goto failed;
10191
10192         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/attributes", src_addr,
10193                                                                 dst_addr);
10194
10195         key_file = g_key_file_new();
10196         g_key_file_load_from_file(key_file, filename, 0, NULL);
10197
10198         store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
10199
10200         data = g_key_file_to_data(key_file, &length, NULL);
10201         if (length > 0) {
10202                 create_file(filename, S_IRUSR | S_IWUSR);
10203                 g_file_set_contents(filename, data, length, NULL);
10204         }
10205
10206         g_free(data);
10207         g_key_file_free(key_file);
10208
10209 failed:
10210         sdp_record_free(rec);
10211         free(prim_uuid);
10212         free(att_uuid);
10213 }
10214
10215 static void convert_primaries_entry(char *key, char *value, void *user_data)
10216 {
10217         char *address = user_data;
10218         int device_type = -1;
10219         uuid_t uuid;
10220         char **services, **service, *prim_uuid;
10221         char filename[PATH_MAX];
10222         GKeyFile *key_file;
10223         int ret;
10224         uint16_t start, end;
10225         char uuid_str[MAX_LEN_UUID_STR + 1];
10226         char *data;
10227         gsize length = 0;
10228
10229         if (strchr(key, '#')) {
10230                 key[17] = '\0';
10231                 device_type = key[18] - '0';
10232         }
10233
10234         if (bachk(key) != 0)
10235                 return;
10236
10237         services = g_strsplit(value, " ", 0);
10238         if (services == NULL)
10239                 return;
10240
10241         sdp_uuid16_create(&uuid, GATT_PRIM_SVC_UUID);
10242         prim_uuid = bt_uuid2string(&uuid);
10243
10244         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/attributes", address,
10245                                                                         key);
10246         key_file = g_key_file_new();
10247         g_key_file_load_from_file(key_file, filename, 0, NULL);
10248
10249         for (service = services; *service; service++) {
10250                 ret = sscanf(*service, "%04hX#%04hX#%s", &start, &end,
10251                                                                 uuid_str);
10252                 if (ret < 3)
10253                         continue;
10254
10255                 bt_string2uuid(&uuid, uuid_str);
10256                 sdp_uuid128_to_uuid(&uuid);
10257
10258                 store_attribute_uuid(key_file, start, end, prim_uuid, uuid);
10259         }
10260
10261         g_strfreev(services);
10262
10263         data = g_key_file_to_data(key_file, &length, NULL);
10264         if (length == 0)
10265                 goto end;
10266
10267         create_file(filename, S_IRUSR | S_IWUSR);
10268         g_file_set_contents(filename, data, length, NULL);
10269
10270         if (device_type < 0)
10271                 goto end;
10272
10273         g_free(data);
10274         g_key_file_free(key_file);
10275
10276         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info", address, key);
10277
10278         key_file = g_key_file_new();
10279         g_key_file_load_from_file(key_file, filename, 0, NULL);
10280         set_device_type(key_file, device_type);
10281
10282         data = g_key_file_to_data(key_file, &length, NULL);
10283         if (length > 0) {
10284                 create_file(filename, S_IRUSR | S_IWUSR);
10285                 g_file_set_contents(filename, data, length, NULL);
10286         }
10287
10288 end:
10289         g_free(data);
10290         free(prim_uuid);
10291         g_key_file_free(key_file);
10292 }
10293
10294 static void convert_ccc_entry(char *key, char *value, void *user_data)
10295 {
10296         char *src_addr = user_data;
10297         char dst_addr[18];
10298         char type = BDADDR_BREDR;
10299         uint16_t handle;
10300         int ret, err;
10301         char filename[PATH_MAX];
10302         GKeyFile *key_file;
10303         struct stat st;
10304         char group[6];
10305         char *data;
10306         gsize length = 0;
10307
10308         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
10309         if (ret < 3)
10310                 return;
10311
10312         if (bachk(dst_addr) != 0)
10313                 return;
10314
10315         /* Check if the device directory has been created as records should
10316          * only be converted for known devices */
10317         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
10318
10319         err = stat(filename, &st);
10320         if (err || !S_ISDIR(st.st_mode))
10321                 return;
10322
10323         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/ccc", src_addr,
10324                                                                 dst_addr);
10325         key_file = g_key_file_new();
10326         g_key_file_load_from_file(key_file, filename, 0, NULL);
10327
10328         sprintf(group, "%hu", handle);
10329         g_key_file_set_string(key_file, group, "Value", value);
10330
10331         data = g_key_file_to_data(key_file, &length, NULL);
10332         if (length > 0) {
10333                 create_file(filename, S_IRUSR | S_IWUSR);
10334                 g_file_set_contents(filename, data, length, NULL);
10335         }
10336
10337         g_free(data);
10338         g_key_file_free(key_file);
10339 }
10340
10341 static void convert_gatt_entry(char *key, char *value, void *user_data)
10342 {
10343         char *src_addr = user_data;
10344         char dst_addr[18];
10345         char type = BDADDR_BREDR;
10346         uint16_t handle;
10347         int ret, err;
10348         char filename[PATH_MAX];
10349         GKeyFile *key_file;
10350         struct stat st;
10351         char group[6];
10352         char *data;
10353         gsize length = 0;
10354
10355         ret = sscanf(key, "%17s#%hhu#%04hX", dst_addr, &type, &handle);
10356         if (ret < 3)
10357                 return;
10358
10359         if (bachk(dst_addr) != 0)
10360                 return;
10361
10362         /* Check if the device directory has been created as records should
10363          * only be converted for known devices */
10364         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, dst_addr);
10365
10366         err = stat(filename, &st);
10367         if (err || !S_ISDIR(st.st_mode))
10368                 return;
10369
10370         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/gatt", src_addr,
10371                                                                 dst_addr);
10372         key_file = g_key_file_new();
10373         g_key_file_load_from_file(key_file, filename, 0, NULL);
10374
10375         sprintf(group, "%hu", handle);
10376         g_key_file_set_string(key_file, group, "Value", value);
10377
10378         data = g_key_file_to_data(key_file, &length, NULL);
10379         if (length > 0) {
10380                 create_file(filename, S_IRUSR | S_IWUSR);
10381                 g_file_set_contents(filename, data, length, NULL);
10382         }
10383
10384         g_free(data);
10385         g_key_file_free(key_file);
10386 }
10387
10388 static void convert_proximity_entry(char *key, char *value, void *user_data)
10389 {
10390         char *src_addr = user_data;
10391         char *alert;
10392         char filename[PATH_MAX];
10393         GKeyFile *key_file;
10394         struct stat st;
10395         int err;
10396         char *data;
10397         gsize length = 0;
10398
10399         if (!strchr(key, '#'))
10400                 return;
10401
10402         key[17] = '\0';
10403         alert = &key[18];
10404
10405         if (bachk(key) != 0)
10406                 return;
10407
10408         /* Check if the device directory has been created as records should
10409          * only be converted for known devices */
10410         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s", src_addr, key);
10411
10412         err = stat(filename, &st);
10413         if (err || !S_ISDIR(st.st_mode))
10414                 return;
10415
10416         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/proximity", src_addr,
10417                                                                         key);
10418         key_file = g_key_file_new();
10419         g_key_file_load_from_file(key_file, filename, 0, NULL);
10420
10421         g_key_file_set_string(key_file, alert, "Level", value);
10422
10423         data = g_key_file_to_data(key_file, &length, NULL);
10424         if (length > 0) {
10425                 create_file(filename, S_IRUSR | S_IWUSR);
10426                 g_file_set_contents(filename, data, length, NULL);
10427         }
10428
10429         g_free(data);
10430         g_key_file_free(key_file);
10431 }
10432
10433 static void convert_device_storage(struct btd_adapter *adapter)
10434 {
10435         char filename[PATH_MAX];
10436         char address[18];
10437
10438         ba2str(&adapter->bdaddr, address);
10439
10440         /* Convert device's name cache */
10441         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/names", address);
10442         textfile_foreach(filename, convert_names_entry, address);
10443
10444         /* Convert aliases */
10445         convert_file("aliases", address, convert_aliases_entry, TRUE);
10446
10447         /* Convert trusts */
10448         convert_file("trusts", address, convert_trusts_entry, TRUE);
10449
10450         /* Convert blocked */
10451         convert_file("blocked", address, convert_blocked_entry, TRUE);
10452
10453         /* Convert profiles */
10454         convert_file("profiles", address, convert_profiles_entry, TRUE);
10455
10456         /* Convert primaries */
10457         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/primaries", address);
10458         textfile_foreach(filename, convert_primaries_entry, address);
10459
10460         /* Convert linkkeys */
10461         convert_file("linkkeys", address, convert_linkkey_entry, TRUE);
10462
10463         /* Convert longtermkeys */
10464         convert_file("longtermkeys", address, convert_ltk_entry, TRUE);
10465
10466         /* Convert classes */
10467         convert_file("classes", address, convert_classes_entry, FALSE);
10468
10469         /* Convert device ids */
10470         convert_file("did", address, convert_did_entry, FALSE);
10471
10472         /* Convert sdp */
10473         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/sdp", address);
10474         textfile_foreach(filename, convert_sdp_entry, address);
10475
10476         /* Convert ccc */
10477         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/ccc", address);
10478         textfile_foreach(filename, convert_ccc_entry, address);
10479
10480         /* Convert appearances */
10481         convert_file("appearances", address, convert_appearances_entry, FALSE);
10482
10483         /* Convert gatt */
10484         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/gatt", address);
10485         textfile_foreach(filename, convert_gatt_entry, address);
10486
10487         /* Convert proximity */
10488         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/proximity", address);
10489         textfile_foreach(filename, convert_proximity_entry, address);
10490 }
10491
10492 static void convert_config(struct btd_adapter *adapter, const char *filename,
10493                                                         GKeyFile *key_file)
10494 {
10495         char address[18];
10496         char str[MAX_NAME_LENGTH + 1];
10497         char config_path[PATH_MAX];
10498         int timeout;
10499         uint8_t mode;
10500         char *data;
10501         gsize length = 0;
10502
10503         ba2str(&adapter->bdaddr, address);
10504         snprintf(config_path, PATH_MAX, STORAGEDIR "/%s/config", address);
10505
10506         if (read_pairable_timeout(address, &timeout) == 0)
10507                 g_key_file_set_integer(key_file, "General",
10508                                                 "PairableTimeout", timeout);
10509
10510         if (read_discoverable_timeout(address, &timeout) == 0)
10511                 g_key_file_set_integer(key_file, "General",
10512                                                 "DiscoverableTimeout", timeout);
10513
10514         if (read_on_mode(address, str, sizeof(str)) == 0) {
10515                 mode = get_mode(str);
10516                 g_key_file_set_boolean(key_file, "General", "Discoverable",
10517                                         mode == MODE_DISCOVERABLE);
10518         }
10519
10520         if (read_local_name(&adapter->bdaddr, str) == 0)
10521                 g_key_file_set_string(key_file, "General", "Alias", str);
10522
10523         create_file(filename, S_IRUSR | S_IWUSR);
10524
10525         data = g_key_file_to_data(key_file, &length, NULL);
10526         g_file_set_contents(filename, data, length, NULL);
10527         g_free(data);
10528 }
10529
10530 static void fix_storage(struct btd_adapter *adapter)
10531 {
10532         char filename[PATH_MAX];
10533         char address[18];
10534         char *converted;
10535
10536         ba2str(&adapter->bdaddr, address);
10537
10538         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/config", address);
10539         converted = textfile_get(filename, "converted");
10540         if (!converted)
10541                 return;
10542
10543         free(converted);
10544
10545         textfile_del(filename, "converted");
10546
10547         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/names", address);
10548         textfile_del(filename, "converted");
10549
10550         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/aliases", address);
10551         textfile_del(filename, "converted");
10552
10553         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/trusts", address);
10554         textfile_del(filename, "converted");
10555
10556         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/blocked", address);
10557         textfile_del(filename, "converted");
10558
10559         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/profiles", address);
10560         textfile_del(filename, "converted");
10561
10562         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/primaries", address);
10563         textfile_del(filename, "converted");
10564
10565         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/linkkeys", address);
10566         textfile_del(filename, "converted");
10567
10568         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/longtermkeys", address);
10569         textfile_del(filename, "converted");
10570
10571         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/classes", address);
10572         textfile_del(filename, "converted");
10573
10574         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/did", address);
10575         textfile_del(filename, "converted");
10576
10577         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/sdp", address);
10578         textfile_del(filename, "converted");
10579
10580         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/ccc", address);
10581         textfile_del(filename, "converted");
10582
10583         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/appearances", address);
10584         textfile_del(filename, "converted");
10585
10586         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/gatt", address);
10587         textfile_del(filename, "converted");
10588
10589         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/proximity", address);
10590         textfile_del(filename, "converted");
10591 }
10592
10593 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10594 static bool is_tempfile(const char *filename)
10595 {
10596         char *p;
10597         int i;
10598
10599         /* tempfile has ^[A-Z0-9]{6}$ suffix (e.g. "settings.1LS4BZ") */
10600         p = strrchr(filename, '.');
10601         if (p == NULL)
10602                 return false;
10603
10604         if (strlen(++p) != 6)
10605                 return false;
10606
10607         for (i = 0; i < 6; i++) {
10608                 if (isdigit(p[i]) || isupper(p[i]))
10609                         continue;
10610                 else
10611                         return false;
10612         }
10613         return true;
10614 }
10615
10616 static void delete_tempfiles(const char *dirname)
10617 {
10618         DIR *dir;
10619         struct dirent *entry;
10620         char filename[PATH_MAX];
10621
10622         dir = opendir(dirname);
10623         if (dir == NULL)
10624                 return;
10625
10626         while ((entry = readdir(dir)) != NULL) {
10627                 if (g_str_equal(entry->d_name, ".") || g_str_equal(entry->d_name, ".."))
10628                         continue;
10629
10630                 if (entry->d_type == DT_UNKNOWN)
10631                         entry->d_type = util_get_dt(dirname, entry->d_name);
10632
10633                 snprintf(filename, PATH_MAX, "%s/%s", dirname, entry->d_name);
10634
10635                 if (entry->d_type == DT_DIR) {
10636                         delete_tempfiles(filename);
10637                 } else if (entry->d_type == DT_REG && is_tempfile(entry->d_name)) {
10638                         unlink(filename);
10639                 }
10640         }
10641         closedir(dir);
10642 }
10643 #endif
10644
10645 static void load_config(struct btd_adapter *adapter)
10646 {
10647         GKeyFile *key_file;
10648         char filename[PATH_MAX];
10649         struct stat st;
10650         GError *gerr = NULL;
10651 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10652         char *str;
10653 #endif
10654
10655         key_file = g_key_file_new();
10656
10657         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/settings",
10658                                         btd_adapter_get_storage_dir(adapter));
10659
10660         if (stat(filename, &st) < 0) {
10661                 convert_config(adapter, filename, key_file);
10662                 convert_device_storage(adapter);
10663         }
10664
10665         g_key_file_load_from_file(key_file, filename, 0, NULL);
10666
10667         /* Get alias */
10668         adapter->stored_alias = g_key_file_get_string(key_file, "General",
10669                                                                 "Alias", NULL);
10670         if (!adapter->stored_alias) {
10671                 /* fallback */
10672                 adapter->stored_alias = g_key_file_get_string(key_file,
10673                                                 "General", "Name", NULL);
10674         }
10675
10676         /* Get pairable timeout */
10677         adapter->pairable_timeout = g_key_file_get_integer(key_file, "General",
10678                                                 "PairableTimeout", &gerr);
10679         if (gerr) {
10680                 adapter->pairable_timeout = main_opts.pairto;
10681                 g_error_free(gerr);
10682                 gerr = NULL;
10683         }
10684
10685         /* Get discoverable mode */
10686         adapter->stored_discoverable = g_key_file_get_boolean(key_file,
10687                                         "General", "Discoverable", &gerr);
10688         if (gerr) {
10689                 adapter->stored_discoverable = false;
10690                 g_error_free(gerr);
10691                 gerr = NULL;
10692         }
10693
10694         /* Get discoverable timeout */
10695         adapter->discoverable_timeout = g_key_file_get_integer(key_file,
10696                                 "General", "DiscoverableTimeout", &gerr);
10697         if (gerr) {
10698                 adapter->discoverable_timeout = main_opts.discovto;
10699                 g_error_free(gerr);
10700                 gerr = NULL;
10701         }
10702
10703 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10704         /* Get A2DP Role */
10705         str = g_key_file_get_string(key_file, "General", "DefaultA2DPRole", &gerr);
10706         if (gerr || !str) {
10707                 if (main_opts.default_a2dp_role_sink) {
10708                         DBG("Default A2DP role is sink");
10709                         adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
10710                 } else {
10711                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
10712                 }
10713                 g_error_free(gerr);
10714                 gerr = NULL;
10715         } else {
10716                 if (g_strcmp0(str, "sink") == 0)
10717                         adapter->a2dp_role = BLUETOOTH_A2DP_SINK_ROLE;
10718                 else if (g_strcmp0(str, "source") == 0)
10719                         adapter->a2dp_role = BLUETOOTH_A2DP_SOURCE_ROLE;
10720         }
10721 #endif
10722
10723         g_key_file_free(key_file);
10724 }
10725
10726 static struct btd_adapter *btd_adapter_new(uint16_t index)
10727 {
10728         struct btd_adapter *adapter;
10729 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10730 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
10731         DBusConnection *conn = btd_get_dbus_connection();
10732         DBusMessage *msg = NULL;
10733         DBusMessage *reply = NULL;
10734         int charging_state = 0;
10735 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
10736 #endif
10737
10738         adapter = g_try_new0(struct btd_adapter, 1);
10739         if (!adapter)
10740                 return NULL;
10741
10742         adapter->dev_id = index;
10743         adapter->mgmt = mgmt_ref(mgmt_master);
10744         adapter->pincode_requested = false;
10745
10746         /*
10747          * Setup default configuration values. These are either adapter
10748          * defaults or from a system wide configuration file.
10749          *
10750          * Some value might be overwritten later on by adapter specific
10751          * configuration. This is to make sure that sane defaults are
10752          * always present.
10753          */
10754         adapter->system_name = g_strdup(main_opts.name);
10755         adapter->major_class = (main_opts.class & 0x001f00) >> 8;
10756         adapter->minor_class = (main_opts.class & 0x0000fc) >> 2;
10757         adapter->modalias = bt_modalias(main_opts.did_source,
10758                                                 main_opts.did_vendor,
10759                                                 main_opts.did_product,
10760                                                 main_opts.did_version);
10761         adapter->discoverable_timeout = main_opts.discovto;
10762         adapter->pairable_timeout = main_opts.pairto;
10763 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10764         adapter->advertising = FALSE;
10765 #endif
10766
10767         DBG("System name: %s", adapter->system_name);
10768         DBG("Major class: %u", adapter->major_class);
10769         DBG("Minor class: %u", adapter->minor_class);
10770         DBG("Modalias: %s", adapter->modalias);
10771         DBG("Discoverable timeout: %u seconds", adapter->discoverable_timeout);
10772         DBG("Pairable timeout: %u seconds", adapter->pairable_timeout);
10773         adapter->auths = g_queue_new();
10774
10775 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10776 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
10777         adapter->charging_watch = g_dbus_add_signal_watch(conn, DEVICED_DEST,
10778                         DEVICED_BATT_OBJECT_PATH,
10779                         DEVICED_BATT_INTERFACE, "ChargerType",
10780                         charging_state_changed, adapter, NULL);
10781         if (adapter->charging_watch == 0)
10782                 error("Cannot add signal watch for ChargerType");
10783
10784         msg = dbus_message_new_method_call(DEVICED_DEST,
10785                         DEVICED_BATT_OBJECT_PATH,
10786                         DEVICED_BATT_INTERFACE, "ChargerType");
10787         if (msg) {
10788                 reply = dbus_connection_send_with_reply_and_block(conn,
10789                                 msg, 1000, NULL);
10790                 if (reply) {
10791                         if (dbus_message_get_args(reply, NULL,
10792                                         DBUS_TYPE_INT32, &charging_state,
10793                                         DBUS_TYPE_INVALID) == TRUE) {
10794                                 set_charging_state(adapter, charging_state);
10795                         }
10796                         dbus_message_unref(reply);
10797                 } else {
10798                         error("Reply is NULL");
10799                 }
10800                 dbus_message_unref(msg);
10801         } else {
10802                 error("Unable to create dbus message for charging state");
10803         }
10804 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
10805 #endif
10806
10807         return btd_adapter_ref(adapter);
10808 }
10809
10810 static void adapter_remove(struct btd_adapter *adapter)
10811 {
10812         GSList *l;
10813 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
10814         struct gatt_db *db;
10815 #endif
10816
10817         DBG("Removing adapter %s", adapter->path);
10818
10819 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10820 #ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
10821         if (adapter->charging_watch > 0) {
10822                 g_dbus_remove_watch(btd_get_dbus_connection(),
10823                                 adapter->charging_watch);
10824                 adapter->charging_watch = 0;
10825         }
10826
10827         if (adapter->charging_timeout) {
10828                 g_source_remove(adapter->charging_timeout);
10829                 adapter->charging_timeout = 0;
10830         }
10831 #endif  /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
10832 #endif
10833
10834         if (adapter->discovery_idle_timeout > 0) {
10835                 g_source_remove(adapter->discovery_idle_timeout);
10836                 adapter->discovery_idle_timeout = 0;
10837         }
10838
10839         if (adapter->temp_devices_timeout > 0) {
10840                 g_source_remove(adapter->temp_devices_timeout);
10841                 adapter->temp_devices_timeout = 0;
10842         }
10843
10844         discovery_cleanup(adapter);
10845
10846         g_slist_free(adapter->connect_list);
10847         adapter->connect_list = NULL;
10848
10849         for (l = adapter->devices; l; l = l->next)
10850                 device_remove(l->data, FALSE);
10851
10852         g_slist_free(adapter->devices);
10853         adapter->devices = NULL;
10854
10855         discovery_cleanup(adapter);
10856
10857         unload_drivers(adapter);
10858
10859 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
10860         db = btd_gatt_database_get_db(adapter->database);
10861         gatt_db_unregister(db, adapter->db_id);
10862         adapter->db_id = 0;
10863
10864         btd_gatt_database_destroy(adapter->database);
10865         adapter->database = NULL;
10866 #else
10867         btd_adapter_gatt_server_stop(adapter);
10868 #endif
10869         btd_adv_manager_destroy(adapter->adv_manager);
10870         adapter->adv_manager = NULL;
10871
10872         g_slist_free(adapter->pin_callbacks);
10873         adapter->pin_callbacks = NULL;
10874
10875         g_slist_free(adapter->msd_callbacks);
10876         adapter->msd_callbacks = NULL;
10877 }
10878
10879 const char *adapter_get_path(struct btd_adapter *adapter)
10880 {
10881         if (!adapter)
10882                 return NULL;
10883
10884         return adapter->path;
10885 }
10886
10887 const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter)
10888 {
10889         return &adapter->bdaddr;
10890 }
10891
10892 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
10893 const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter)
10894 {
10895         if (adapter->current_settings & MGMT_SETTING_PRIVACY)
10896                 return &adapter->rpa;
10897         else if (adapter->le_static_addr.b[5] != 0)
10898                 return &adapter->le_static_addr;
10899         else
10900                 return &adapter->bdaddr;
10901 }
10902
10903 uint8_t btd_adapter_get_le_address_type(struct btd_adapter * adapter)
10904 {
10905         if (adapter->current_settings & MGMT_SETTING_PRIVACY ||
10906                                 adapter->le_static_addr.b[5] != 0)
10907                         return BDADDR_LE_RANDOM;
10908                 else
10909                         return BDADDR_LE_PUBLIC;
10910 }
10911 #endif
10912
10913 static gboolean confirm_name_timeout(gpointer user_data)
10914 {
10915         struct btd_adapter *adapter = user_data;
10916
10917         btd_error(adapter->dev_id, "Confirm name timed out for hci%u",
10918                                                         adapter->dev_id);
10919
10920         adapter->confirm_name_timeout = 0;
10921
10922         mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
10923         adapter->confirm_name_id = 0;
10924
10925         return FALSE;
10926 }
10927
10928 static void confirm_name_complete(uint8_t status, uint16_t length,
10929                                         const void *param, void *user_data)
10930 {
10931         struct btd_adapter *adapter = user_data;
10932
10933         if (status != MGMT_STATUS_SUCCESS) {
10934                 btd_error(adapter->dev_id,
10935                                 "Failed to confirm name for hci%u: %s (0x%02x)",
10936                                 adapter->dev_id, mgmt_errstr(status), status);
10937         }
10938
10939         adapter->confirm_name_id = 0;
10940
10941         g_source_remove(adapter->confirm_name_timeout);
10942         adapter->confirm_name_timeout = 0;
10943
10944         DBG("Confirm name complete for hci%u", adapter->dev_id);
10945 }
10946
10947 static void confirm_name(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
10948                                         uint8_t bdaddr_type, bool name_known)
10949 {
10950         struct mgmt_cp_confirm_name cp;
10951         char addr[18];
10952
10953         ba2str(bdaddr, addr);
10954         DBG("hci%d bdaddr %s name_known %u", adapter->dev_id, addr,
10955                                                                 name_known);
10956
10957         /*
10958          * If the kernel does not answer the confirm name command with
10959          * a command complete or command status in time, this might
10960          * race against another device found event that also requires
10961          * to confirm the name. If there is a pending command, just
10962          * cancel it to be safe here.
10963          */
10964         if (adapter->confirm_name_id > 0) {
10965                 btd_warn(adapter->dev_id,
10966                                 "Found pending confirm name for hci%u",
10967                                                         adapter->dev_id);
10968                 mgmt_cancel(adapter->mgmt, adapter->confirm_name_id);
10969         }
10970
10971         if (adapter->confirm_name_timeout > 0) {
10972                 g_source_remove(adapter->confirm_name_timeout);
10973                 adapter->confirm_name_timeout = 0;
10974         }
10975
10976         memset(&cp, 0, sizeof(cp));
10977         bacpy(&cp.addr.bdaddr, bdaddr);
10978         cp.addr.type = bdaddr_type;
10979         cp.name_known = name_known;
10980
10981         adapter->confirm_name_id = mgmt_reply(adapter->mgmt,
10982                                         MGMT_OP_CONFIRM_NAME,
10983                                         adapter->dev_id, sizeof(cp), &cp,
10984                                         confirm_name_complete, adapter, NULL);
10985
10986         if (adapter->confirm_name_id == 0) {
10987                 btd_error(adapter->dev_id, "Failed to confirm name for hci%u",
10988                                                         adapter->dev_id);
10989                 return;
10990         }
10991
10992         /*
10993          * This timeout handling is needed since the kernel is stupid
10994          * and forgets to send a command complete response. However in
10995          * case of failures it does send a command status.
10996          */
10997         adapter->confirm_name_timeout = g_timeout_add_seconds(2,
10998                                                 confirm_name_timeout, adapter);
10999 }
11000
11001 static void adapter_msd_notify(struct btd_adapter *adapter,
11002                                                         struct btd_device *dev,
11003                                                         GSList *msd_list)
11004 {
11005         GSList *cb_l, *cb_next;
11006         GSList *msd_l, *msd_next;
11007
11008         for (cb_l = adapter->msd_callbacks; cb_l != NULL; cb_l = cb_next) {
11009                 btd_msd_cb_t cb = cb_l->data;
11010
11011                 cb_next = g_slist_next(cb_l);
11012
11013                 for (msd_l = msd_list; msd_l != NULL; msd_l = msd_next) {
11014                         const struct eir_msd *msd = msd_l->data;
11015
11016                         msd_next = g_slist_next(msd_l);
11017
11018                         cb(adapter, dev, msd->company, msd->data,
11019                                                                 msd->data_len);
11020                 }
11021         }
11022 }
11023
11024 static bool is_filter_match(GSList *discovery_filter, struct eir_data *eir_data,
11025                                                                 int8_t rssi)
11026 {
11027         GSList *l, *m;
11028         bool got_match = false;
11029
11030         for (l = discovery_filter; l != NULL && got_match != true;
11031                                                         l = g_slist_next(l)) {
11032                 struct watch_client *client = l->data;
11033                 struct discovery_filter *item = client->discovery_filter;
11034
11035                 /*
11036                  * If one of currently running scans is regular scan, then
11037                  * return all devices as matches
11038                  */
11039                 if (!item) {
11040                         got_match = true;
11041                         continue;
11042                 }
11043
11044                 /* if someone started discovery with empty uuids, he wants all
11045                  * devices in given proximity.
11046                  */
11047                 if (!item->uuids)
11048                         got_match = true;
11049                 else {
11050                         for (m = item->uuids; m != NULL && got_match != true;
11051                                                         m = g_slist_next(m)) {
11052                                 /* m->data contains string representation of
11053                                  * uuid.
11054                                  */
11055                                 if (g_slist_find_custom(eir_data->services,
11056                                                         m->data,
11057                                                         g_strcmp) != NULL)
11058                                         got_match = true;
11059                         }
11060                 }
11061
11062                 if (got_match) {
11063                         /* we have service match, check proximity */
11064                         if (item->rssi == DISTANCE_VAL_INVALID ||
11065                             item->rssi <= rssi ||
11066                             item->pathloss == DISTANCE_VAL_INVALID ||
11067                             (eir_data->tx_power != 127 &&
11068                              eir_data->tx_power - rssi <= item->pathloss))
11069                                 return true;
11070
11071                         got_match = false;
11072                 }
11073         }
11074
11075         return got_match;
11076 }
11077
11078 static void filter_duplicate_data(void *data, void *user_data)
11079 {
11080         struct watch_client *client = data;
11081         bool *duplicate = user_data;
11082
11083         if (*duplicate || !client->discovery_filter)
11084                 return;
11085
11086         *duplicate = client->discovery_filter->duplicate;
11087 }
11088
11089 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11090 static void update_found_devices(struct btd_adapter *adapter,
11091                                         const bdaddr_t *bdaddr,
11092                                         uint8_t bdaddr_type, int8_t rssi,
11093                                         bool confirm, bool legacy, uint8_t adv_type,
11094                                         const uint8_t *data, uint8_t data_len)
11095 #else
11096 static void update_found_devices(struct btd_adapter *adapter,
11097                                         const bdaddr_t *bdaddr,
11098                                         uint8_t bdaddr_type, int8_t rssi,
11099                                         bool confirm, bool legacy,
11100                                         bool not_connectable,
11101                                         const uint8_t *data, uint8_t data_len)
11102 #endif
11103 {
11104         struct btd_device *dev;
11105         struct eir_data eir_data;
11106 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11107         bool name_known, discoverable;
11108 #else
11109         bool name_known;
11110 #endif
11111 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
11112         uint8_t allow_report;
11113 #endif
11114         char addr[18];
11115         bool duplicate = false;
11116
11117         memset(&eir_data, 0, sizeof(eir_data));
11118         eir_parse(&eir_data, data, data_len);
11119 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11120         if (bdaddr_type == BDADDR_BREDR || adapter->filtered_discovery)
11121                 discoverable = true;
11122         else
11123                 discoverable = eir_data.flags & (EIR_LIM_DISC | EIR_GEN_DISC);
11124 #endif
11125         ba2str(bdaddr, addr);
11126
11127 #ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
11128         /* Check if the any filter policy */
11129         allow_report = validate_for_filter_policy(adapter, &eir_data, addr);
11130         if (allow_report == NONE_REPORT &&
11131                 ((adapter->scan_type == LE_ACTIVE_SCAN && adv_type == ADV_TYPE_SCAN_RESPONSE) ||
11132                 adapter->scan_type == LE_PASSIVE_SCAN)) {
11133                 eir_data_free(&eir_data);
11134                 return;
11135         }
11136 #endif
11137         dev = btd_adapter_find_device(adapter, bdaddr, bdaddr_type);
11138         if (!dev) {
11139                 /*
11140                  * If no client has requested discovery or the device is
11141                  * not marked as discoverable, then do not create new
11142                  * device objects.
11143                  */
11144 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11145                 /*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
11146                         adapter->le_discovery_list, discoverable);*/
11147                 if ((adapter->discovery_list == NULL &&
11148                                 adapter->le_discovery_list == NULL)) {
11149                         DBG("discovery list is NULL");
11150                         eir_data_free(&eir_data);
11151                         return;
11152                 }
11153 #else
11154                 if (!adapter->discovery_list || !discoverable) {
11155                         eir_data_free(&eir_data);
11156                         return;
11157                 }
11158 #endif
11159
11160                 dev = adapter_create_device(adapter, bdaddr, bdaddr_type);
11161         }
11162
11163         if (!dev) {
11164                 btd_error(adapter->dev_id,
11165                         "Unable to create object for found device %s", addr);
11166                 eir_data_free(&eir_data);
11167                 return;
11168         }
11169
11170 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11171         if (device_get_rpa_exist(dev) == true)
11172                 bdaddr_type = BDADDR_LE_RANDOM;
11173 #endif
11174
11175         device_update_last_seen(dev, bdaddr_type);
11176
11177         /*
11178          * FIXME: We need to check for non-zero flags first because
11179          * older kernels send separate adv_ind and scan_rsp. Newer
11180          * kernels send them merged, so once we know which mgmt version
11181          * supports this we can make the non-zero check conditional.
11182          */
11183 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11184         if (bdaddr_type == BDADDR_LE_PUBLIC && eir_data.flags &&
11185                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
11186                 device_set_bredr_support(dev);
11187                 /* Update last seen for BR/EDR in case its flag is set */
11188                 device_update_last_seen(dev, BDADDR_BREDR);
11189         }
11190 #else
11191         if (bdaddr_type != BDADDR_BREDR && eir_data.flags &&
11192                                         !(eir_data.flags & EIR_BREDR_UNSUP)) {
11193                 device_set_bredr_support(dev);
11194                 /* Update last seen for BR/EDR in case its flag is set */
11195                 device_update_last_seen(dev, BDADDR_BREDR);
11196         }
11197 #endif
11198
11199         if (eir_data.name != NULL && eir_data.name_complete)
11200                 device_store_cached_name(dev, eir_data.name);
11201
11202         /*
11203          * Only skip devices that are not connected, are temporary and there
11204          * is no active discovery session ongoing.
11205          */
11206 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11207         if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
11208                         adapter->le_discovery_list == NULL) {
11209                 DBG("discovery list is NULL");
11210                 eir_data_free(&eir_data);
11211                 return;
11212         }
11213
11214         device_set_last_addr_type(dev, bdaddr_type);
11215         device_set_ipsp_connected(dev, FALSE, NULL);
11216 #else
11217         if (!btd_device_is_connected(dev) && (device_is_temporary(dev) &&
11218                                                  !adapter->discovery_list)) {
11219                 eir_data_free(&eir_data);
11220                 return;
11221         }
11222 #endif
11223
11224 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11225         if (bdaddr_type == BDADDR_BREDR) {
11226 #endif
11227         if (adapter->filtered_discovery &&
11228             !is_filter_match(adapter->discovery_list, &eir_data, rssi)) {
11229                 eir_data_free(&eir_data);
11230                 return;
11231         }
11232
11233         device_set_legacy(dev, legacy);
11234
11235         if (adapter->filtered_discovery)
11236                 device_set_rssi_with_delta(dev, rssi, 0);
11237         else
11238                 device_set_rssi(dev, rssi);
11239
11240         if (eir_data.tx_power != 127)
11241                 device_set_tx_power(dev, eir_data.tx_power);
11242 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11243         }
11244 #endif
11245
11246         if (eir_data.appearance != 0)
11247                 device_set_appearance(dev, eir_data.appearance);
11248
11249         /* Report an unknown name to the kernel even if there is a short name
11250          * known, but still update the name with the known short name. */
11251 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11252         if (eir_data.name_complete)
11253                 name_known = device_name_known(dev);
11254         else
11255                 name_known = false;
11256 #else
11257         name_known = device_name_known(dev);
11258 #endif
11259
11260         if (eir_data.name && (eir_data.name_complete || !name_known))
11261                 btd_device_device_set_name(dev, eir_data.name);
11262
11263         if (eir_data.class != 0)
11264                 device_set_class(dev, eir_data.class);
11265
11266         if (eir_data.did_source || eir_data.did_vendor ||
11267                         eir_data.did_product || eir_data.did_version)
11268                 btd_device_set_pnpid(dev, eir_data.did_source,
11269                                                         eir_data.did_vendor,
11270                                                         eir_data.did_product,
11271                                                         eir_data.did_version);
11272
11273         device_add_eir_uuids(dev, eir_data.services);
11274
11275         if (adapter->discovery_list)
11276                 g_slist_foreach(adapter->discovery_list, filter_duplicate_data,
11277                                                                 &duplicate);
11278 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11279         if (eir_data.flags != 0)
11280                 device_set_remote_feature_flag(dev, eir_data.flags);
11281
11282         if (bdaddr_type == BDADDR_BREDR)
11283                 device_set_manufacturer_info(dev, &eir_data);
11284         else {
11285                 /* if the application has registered for iBeacon report,
11286                  * then send ibeacon report along with advertisement report */
11287                 device_set_adv_report_info(dev, (void*)data, data_len, adv_type, rssi);
11288         }
11289 #endif
11290
11291         if (eir_data.msd_list) {
11292                 device_set_manufacturer_data(dev, eir_data.msd_list, duplicate);
11293                 adapter_msd_notify(adapter, dev, eir_data.msd_list);
11294         }
11295
11296         if (eir_data.sd_list)
11297                 device_set_service_data(dev, eir_data.sd_list, duplicate);
11298
11299         if (eir_data.data_list)
11300                 device_set_data(dev, eir_data.data_list, duplicate);
11301
11302 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11303         if (bdaddr_type != BDADDR_BREDR && adv_type != ADV_TYPE_SCAN_RESPONSE) {
11304                 device_set_flags(dev, eir_data.flags);
11305                 device_set_le_connectable(dev, adv_type);
11306         }
11307 #else
11308         if (bdaddr_type != BDADDR_BREDR)
11309                 device_set_flags(dev, eir_data.flags);
11310 #endif
11311
11312         eir_data_free(&eir_data);
11313
11314         /*
11315          * Only if at least one client has requested discovery, maintain
11316          * list of found devices and name confirming for legacy devices.
11317          * Otherwise, this is an event from passive discovery and we
11318          * should check if the device needs connecting to.
11319          */
11320 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11321         if (!adapter->discovery_list && !adapter->le_discovery_list)
11322 #else
11323         if (!adapter->discovery_list)
11324 #endif
11325                 goto connect_le;
11326
11327         if (g_slist_find(adapter->discovery_found, dev))
11328                 return;
11329
11330         if (confirm)
11331                 confirm_name(adapter, bdaddr, bdaddr_type, name_known);
11332
11333         adapter->discovery_found = g_slist_prepend(adapter->discovery_found,
11334                                                                         dev);
11335
11336         return;
11337
11338 connect_le:
11339 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11340         /* Ignore non-connectable events */
11341         if (not_connectable)
11342                 return;
11343 #endif
11344
11345         /*
11346          * If we're in the process of stopping passive scanning and
11347          * connecting another (or maybe even the same) LE device just
11348          * ignore this one.
11349          */
11350         if (adapter->connect_le)
11351                 return;
11352
11353         /*
11354          * If kernel background scan is used then the kernel is
11355          * responsible for connecting.
11356          */
11357         if (kernel_conn_control)
11358                 return;
11359
11360         /*
11361          * If this is an LE device that's not connected and part of the
11362          * connect_list stop passive scanning so that a connection
11363          * attempt to it can be made
11364          */
11365         if (bdaddr_type != BDADDR_BREDR && !btd_device_is_connected(dev) &&
11366                                 g_slist_find(adapter->connect_list, dev)) {
11367                 adapter->connect_le = dev;
11368                 stop_passive_scanning(adapter);
11369         }
11370 }
11371
11372 static void device_found_callback(uint16_t index, uint16_t length,
11373                                         const void *param, void *user_data)
11374 {
11375         const struct mgmt_ev_device_found *ev = param;
11376         struct btd_adapter *adapter = user_data;
11377         const uint8_t *eir;
11378         uint16_t eir_len;
11379         uint32_t flags;
11380         bool confirm_name;
11381         bool legacy;
11382         char addr[18];
11383
11384         if (length < sizeof(*ev)) {
11385                 btd_error(adapter->dev_id,
11386                         "Too short device found event (%u bytes)", length);
11387                 return;
11388         }
11389
11390         eir_len = btohs(ev->eir_len);
11391         if (length != sizeof(*ev) + eir_len) {
11392                 btd_error(adapter->dev_id,
11393                                 "Device found event size mismatch (%u != %zu)",
11394                                         length, sizeof(*ev) + eir_len);
11395                 return;
11396         }
11397
11398         if (eir_len == 0)
11399                 eir = NULL;
11400         else
11401                 eir = ev->eir;
11402
11403         flags = btohl(ev->flags);
11404
11405         ba2str(&ev->addr.bdaddr, addr);
11406         DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
11407                         index, addr, ev->rssi, flags, eir_len);
11408
11409         confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
11410         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
11411
11412 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11413         update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
11414                                         ev->rssi, confirm_name, legacy, 0,
11415                                         eir, eir_len);
11416 #else
11417         update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
11418                                         ev->rssi, confirm_name, legacy,
11419                                         flags & MGMT_DEV_FOUND_NOT_CONNECTABLE,
11420                                         eir, eir_len);
11421 #endif
11422 }
11423
11424 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11425 static void le_device_found_callback(uint16_t index, uint16_t length,
11426                                         const void *param, void *user_data)
11427 {
11428         const struct mgmt_ev_le_device_found *ev = param;
11429         struct btd_adapter *adapter = user_data;
11430         const uint8_t *eir;
11431         uint16_t eir_len;
11432         uint32_t flags;
11433         bool confirm_name;
11434         bool legacy;
11435         char addr[18];
11436
11437         if (length < sizeof(*ev)) {
11438                 error("Too short device found event (%u bytes)", length);
11439                 return;
11440         }
11441
11442         eir_len = btohs(ev->eir_len);
11443         if (length != sizeof(*ev) + eir_len) {
11444                 error("Device found event size mismatch (%u != %zu)",
11445                                         length, sizeof(*ev) + eir_len);
11446                 return;
11447         }
11448
11449         if (eir_len == 0)
11450                 eir = NULL;
11451         else
11452                 eir = ev->eir;
11453
11454         flags = btohl(ev->flags);
11455
11456         ba2str(&ev->addr.bdaddr, addr);
11457         /*DBG("hci%u addr %s, rssi %d flags 0x%04x eir_len %u",
11458                         index, addr, ev->rssi, flags, eir_len);*/
11459
11460         confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
11461         legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
11462
11463         /*DBG("hci%u addr %s, addr_type %d rssi %d flags 0x%04x eir_len %u confirm_name %d legacy %d, adv_type %02x",
11464                         index, addr, ev->addr.type, ev->rssi, flags, eir_len, confirm_name, legacy, ev->adv_type);*/
11465
11466         update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
11467                                         ev->rssi, confirm_name, legacy, ev->adv_type,
11468                                         eir, eir_len);
11469 }
11470 #endif
11471
11472 struct agent *adapter_get_agent(struct btd_adapter *adapter)
11473 {
11474         return agent_get(NULL);
11475 }
11476
11477 static void adapter_remove_connection(struct btd_adapter *adapter,
11478                                                 struct btd_device *device,
11479                                                 uint8_t bdaddr_type)
11480 {
11481         DBG("");
11482
11483         if (!g_slist_find(adapter->connections, device)) {
11484                 btd_error(adapter->dev_id, "No matching connection for device");
11485                 return;
11486         }
11487
11488         device_remove_connection(device, bdaddr_type);
11489
11490 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11491         if (device_is_authenticating(device, bdaddr_type))
11492 #else
11493         if (device_is_authenticating(device))
11494 #endif
11495                 device_cancel_authentication(device, TRUE);
11496
11497         /* If another bearer is still connected */
11498         if (btd_device_is_connected(device))
11499                 return;
11500
11501         adapter->connections = g_slist_remove(adapter->connections, device);
11502 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11503         DBG("isPaired %d, isBonded %d", device_is_paired(device, bdaddr_type),
11504                         device_is_bonded(device, bdaddr_type));
11505         if ((device_is_temporary(device) && !device_is_retrying(device)) ||
11506                         (!device_is_bonded(device, bdaddr_type))) {
11507 #else
11508         if (device_is_temporary(device) && !device_is_retrying(device)) {
11509 #endif
11510                 const char *path = device_get_path(device);
11511
11512                 DBG("Removing temporary device %s", path);
11513 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11514                 /* device_is_paired is added incase of tempoary bonded
11515                  * oop file transfer in that device is not bonded it's paired.
11516                  */
11517                 if (!(device_is_bonded(device, bdaddr_type) ||
11518                                 device_is_paired(device, bdaddr_type))) {
11519                         DBG("addr type %d, bonded", bdaddr_type);
11520                         return;
11521                 }
11522
11523                 btd_adapter_unpair_device(adapter, device);
11524 #else
11525                 btd_adapter_remove_device(adapter, device);
11526 #endif
11527         }
11528 }
11529
11530 static void adapter_stop(struct btd_adapter *adapter)
11531 {
11532         /* check pending requests */
11533         reply_pending_requests(adapter);
11534
11535         cancel_passive_scanning(adapter);
11536
11537         g_slist_free_full(adapter->set_filter_list, discovery_free);
11538         adapter->set_filter_list = NULL;
11539
11540         g_slist_free_full(adapter->discovery_list, discovery_free);
11541         adapter->discovery_list = NULL;
11542
11543         discovery_cleanup(adapter);
11544
11545         adapter->filtered_discovery = false;
11546         adapter->no_scan_restart_delay = false;
11547         g_free(adapter->current_discovery_filter);
11548         adapter->current_discovery_filter = NULL;
11549
11550         adapter->discovering = false;
11551
11552         while (adapter->connections) {
11553                 struct btd_device *device = adapter->connections->data;
11554                 uint8_t addr_type = btd_device_get_bdaddr_type(device);
11555
11556                 adapter_remove_connection(adapter, device, BDADDR_BREDR);
11557                 if (addr_type != BDADDR_BREDR)
11558                         adapter_remove_connection(adapter, device, addr_type);
11559         }
11560
11561         g_dbus_emit_property_changed(dbus_conn, adapter->path,
11562                                         ADAPTER_INTERFACE, "Discovering");
11563 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11564         g_dbus_emit_property_changed(dbus_conn, adapter->path,
11565                                                 ADAPTER_INTERFACE, "LEDiscovering");
11566 #endif
11567
11568         if (adapter->dev_class) {
11569                 /* the kernel should reset the class of device when powering
11570                  * down, but it does not. So force it here ... */
11571                 adapter->dev_class = 0;
11572                 g_dbus_emit_property_changed(dbus_conn, adapter->path,
11573                                                 ADAPTER_INTERFACE, "Class");
11574         }
11575
11576 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11577         advertiser_cleanup(adapter);
11578 #endif
11579         g_dbus_emit_property_changed(dbus_conn, adapter->path,
11580                                                 ADAPTER_INTERFACE, "Powered");
11581
11582         DBG("adapter %s has been disabled", adapter->path);
11583 }
11584
11585 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
11586 {
11587         adapter_drivers = g_slist_append(adapter_drivers, driver);
11588
11589         if (driver->probe == NULL)
11590                 return 0;
11591
11592         adapter_foreach(probe_driver, driver);
11593
11594         return 0;
11595 }
11596
11597 static void unload_driver(struct btd_adapter *adapter, gpointer data)
11598 {
11599         struct btd_adapter_driver *driver = data;
11600
11601         if (driver->remove)
11602                 driver->remove(adapter);
11603
11604         adapter->drivers = g_slist_remove(adapter->drivers, data);
11605 }
11606
11607 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
11608 {
11609         adapter_drivers = g_slist_remove(adapter_drivers, driver);
11610
11611         adapter_foreach(unload_driver, driver);
11612 }
11613
11614 static void agent_auth_cb(struct agent *agent, DBusError *derr,
11615                                                         void *user_data)
11616 {
11617         struct btd_adapter *adapter = user_data;
11618         struct service_auth *auth = g_queue_pop_head(adapter->auths);
11619
11620         if (!auth) {
11621                 DBG("No pending authorization");
11622                 return;
11623         }
11624
11625         auth->cb(derr, auth->user_data);
11626
11627         if (auth->agent)
11628                 agent_unref(auth->agent);
11629
11630         g_free(auth);
11631
11632         /* Stop processing if queue is empty */
11633         if (g_queue_is_empty(adapter->auths)) {
11634                 if (adapter->auth_idle_id > 0)
11635                         g_source_remove(adapter->auth_idle_id);
11636                 return;
11637         }
11638
11639         if (adapter->auth_idle_id > 0)
11640                 return;
11641
11642         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
11643 }
11644
11645 static gboolean process_auth_queue(gpointer user_data)
11646 {
11647         struct btd_adapter *adapter = user_data;
11648         DBusError err;
11649
11650         adapter->auth_idle_id = 0;
11651
11652         dbus_error_init(&err);
11653         dbus_set_error_const(&err, ERROR_INTERFACE ".Rejected", NULL);
11654
11655         while (!g_queue_is_empty(adapter->auths)) {
11656                 struct service_auth *auth = adapter->auths->head->data;
11657                 struct btd_device *device = auth->device;
11658                 const char *dev_path;
11659
11660                 /* Wait services to be resolved before asking authorization */
11661                 if (auth->svc_id > 0) {
11662 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11663                         DBG("Wait services to be resolved before asking authorization");
11664 #endif
11665                         return FALSE;
11666                 }
11667
11668 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
11669                 if (device_is_trusted(device) == TRUE) {
11670 #else
11671                 if (device_is_trusted(device) == TRUE
11672                                 || device_is_profile_trusted(device, auth->uuid)
11673                                 || main_opts.pin_code) {
11674                         /* In headless device(pin_code is existing),
11675                            no need to request to agent */
11676 #endif
11677                         auth->cb(NULL, auth->user_data);
11678                         goto next;
11679                 }
11680
11681 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
11682                 /* If Profile is Blocked, Simply reject Authorization*/
11683                 if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
11684                         auth->cb(&err, auth->user_data);
11685                         goto next;
11686                 }
11687 #endif
11688
11689                 /* If agent is set authorization is already ongoing */
11690                 if (auth->agent)
11691                         return FALSE;
11692
11693                 auth->agent = agent_get(NULL);
11694                 if (auth->agent == NULL) {
11695                         btd_warn(adapter->dev_id,
11696                                         "Authentication attempt without agent");
11697                         auth->cb(&err, auth->user_data);
11698                         goto next;
11699                 }
11700
11701                 dev_path = device_get_path(device);
11702
11703                 if (agent_authorize_service(auth->agent, dev_path, auth->uuid,
11704                                         agent_auth_cb, adapter, NULL) < 0) {
11705                         auth->cb(&err, auth->user_data);
11706                         goto next;
11707                 }
11708
11709                 break;
11710
11711 next:
11712                 if (auth->agent)
11713                         agent_unref(auth->agent);
11714
11715                 g_free(auth);
11716
11717                 g_queue_pop_head(adapter->auths);
11718         }
11719
11720         dbus_error_free(&err);
11721
11722         return FALSE;
11723 }
11724
11725 static void svc_complete(struct btd_device *dev, int err, void *user_data)
11726 {
11727         struct service_auth *auth = user_data;
11728         struct btd_adapter *adapter = auth->adapter;
11729
11730         auth->svc_id = 0;
11731
11732         if (adapter->auth_idle_id != 0)
11733                 return;
11734
11735         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
11736 }
11737
11738 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
11739                                         const char *uuid,
11740                                         adapter_authorize_type check_for_connection,
11741                                         service_auth_cb cb, void *user_data)
11742 {
11743         struct service_auth *auth;
11744         struct btd_device *device;
11745         static guint id = 0;
11746
11747         device = btd_adapter_find_device(adapter, dst, BDADDR_BREDR);
11748         if (!device)
11749                 return 0;
11750
11751         if (device_is_disconnecting(device)) {
11752                 DBG("Authorization request while disconnecting");
11753                 return 0;
11754         }
11755
11756         /* Device connected? */
11757         if (check_for_connection && !g_slist_find(adapter->connections, device))
11758                 btd_error(adapter->dev_id,
11759                         "Authorization request for non-connected device!?");
11760
11761         auth = g_try_new0(struct service_auth, 1);
11762         if (!auth)
11763                 return 0;
11764
11765         auth->cb = cb;
11766         auth->user_data = user_data;
11767         auth->uuid = uuid;
11768         auth->device = device;
11769         auth->adapter = adapter;
11770         auth->id = ++id;
11771         if (check_for_connection)
11772                 auth->svc_id = device_wait_for_svc_complete(device, svc_complete, auth);
11773         else {
11774                 if (adapter->auth_idle_id == 0)
11775                         adapter->auth_idle_id = g_idle_add(process_auth_queue, adapter);
11776         }
11777
11778         g_queue_push_tail(adapter->auths, auth);
11779
11780         return auth->id;
11781 }
11782
11783 guint btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
11784                                         const char *uuid, service_auth_cb cb,
11785                                         void *user_data)
11786 {
11787         struct btd_adapter *adapter;
11788         GSList *l;
11789
11790         if (bacmp(src, BDADDR_ANY) != 0) {
11791                 adapter = adapter_find(src);
11792                 if (!adapter)
11793                         return 0;
11794
11795                 return adapter_authorize(adapter, dst, uuid,
11796                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
11797         }
11798
11799         for (l = adapters; l != NULL; l = g_slist_next(l)) {
11800                 guint id;
11801
11802                 adapter = l->data;
11803
11804                 id = adapter_authorize(adapter, dst, uuid,
11805                                 ADAPTER_AUTHORIZE_CHECK_CONNECTED, cb, user_data);
11806                 if (id != 0)
11807                         return id;
11808         }
11809
11810         return 0;
11811 }
11812
11813 guint btd_request_authorization_cable_configured(const bdaddr_t *src, const bdaddr_t *dst,
11814                                                 const char *uuid, service_auth_cb cb,
11815                                                 void *user_data)
11816 {
11817         struct btd_adapter *adapter;
11818
11819         if (bacmp(src, BDADDR_ANY) == 0)
11820                 return 0;
11821
11822         adapter = adapter_find(src);
11823         if (!adapter)
11824                 return 0;
11825
11826         return adapter_authorize(adapter, dst, uuid,
11827                         ADAPTER_AUTHORIZE_DISCONNECTED, cb, user_data);
11828 }
11829
11830 static struct service_auth *find_authorization(guint id)
11831 {
11832         GSList *l;
11833         GList *l2;
11834
11835         for (l = adapters; l != NULL; l = g_slist_next(l)) {
11836                 struct btd_adapter *adapter = l->data;
11837
11838                 for (l2 = adapter->auths->head; l2 != NULL; l2 = l2->next) {
11839                         struct service_auth *auth = l2->data;
11840
11841                         if (auth->id == id)
11842                                 return auth;
11843                 }
11844         }
11845
11846         return NULL;
11847 }
11848
11849 int btd_cancel_authorization(guint id)
11850 {
11851         struct service_auth *auth;
11852
11853         auth = find_authorization(id);
11854         if (auth == NULL)
11855                 return -EPERM;
11856
11857         if (auth->svc_id > 0)
11858                 device_remove_svc_complete_callback(auth->device,
11859                                                                 auth->svc_id);
11860
11861         g_queue_remove(auth->adapter->auths, auth);
11862
11863         if (auth->agent) {
11864                 agent_cancel(auth->agent);
11865                 agent_unref(auth->agent);
11866         }
11867
11868         g_free(auth);
11869
11870         return 0;
11871 }
11872
11873 int btd_adapter_restore_powered(struct btd_adapter *adapter)
11874 {
11875         if (adapter->current_settings & MGMT_SETTING_POWERED)
11876                 return 0;
11877
11878         set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
11879
11880         return 0;
11881 }
11882
11883 void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
11884                                                         btd_adapter_pin_cb_t cb)
11885 {
11886         adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
11887 }
11888
11889 void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
11890                                                         btd_adapter_pin_cb_t cb)
11891 {
11892         adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
11893 }
11894
11895 void btd_adapter_unregister_msd_cb(struct btd_adapter *adapter,
11896                                                         btd_msd_cb_t cb)
11897 {
11898         adapter->msd_callbacks = g_slist_remove(adapter->msd_callbacks, cb);
11899 }
11900
11901 void btd_adapter_register_msd_cb(struct btd_adapter *adapter,
11902                                                         btd_msd_cb_t cb)
11903 {
11904         adapter->msd_callbacks = g_slist_prepend(adapter->msd_callbacks, cb);
11905 }
11906
11907 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
11908                                                         gboolean enable)
11909 {
11910         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
11911                 return -EINVAL;
11912
11913         set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, enable ? 0x01 : 0x00);
11914
11915         return 0;
11916 }
11917
11918 int btd_adapter_read_clock(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
11919                                 int which, int timeout, uint32_t *clock,
11920                                 uint16_t *accuracy)
11921 {
11922         if (!(adapter->current_settings & MGMT_SETTING_POWERED))
11923                 return -EINVAL;
11924
11925         return -ENOSYS;
11926 }
11927
11928 int btd_adapter_remove_bonding(struct btd_adapter *adapter,
11929                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
11930 {
11931         struct mgmt_cp_unpair_device cp;
11932
11933         memset(&cp, 0, sizeof(cp));
11934         bacpy(&cp.addr.bdaddr, bdaddr);
11935         cp.addr.type = bdaddr_type;
11936         cp.disconnect = 1;
11937
11938         if (mgmt_send(adapter->mgmt, MGMT_OP_UNPAIR_DEVICE,
11939                                 adapter->dev_id, sizeof(cp), &cp,
11940                                 NULL, NULL, NULL) > 0)
11941                 return 0;
11942
11943         return -EIO;
11944 }
11945
11946 static void pincode_reply_complete(uint8_t status, uint16_t length,
11947                                         const void *param, void *user_data)
11948 {
11949         struct btd_device *device = user_data;
11950
11951         /* If the MGMT_OP_PIN_CODE_REPLY command is acknowledged, move the
11952          * starting time to that point. This give a better sense of time
11953          * evaluating the pincode. */
11954         device_bonding_restart_timer(device);
11955 }
11956
11957 int btd_adapter_pincode_reply(struct btd_adapter *adapter,
11958                                         const bdaddr_t *bdaddr,
11959                                         const char *pin, size_t pin_len)
11960 {
11961         struct btd_device *device;
11962         unsigned int id;
11963         char addr[18];
11964
11965         ba2str(bdaddr, addr);
11966         DBG("hci%u addr %s pinlen %zu", adapter->dev_id, addr, pin_len);
11967
11968         if (pin == NULL) {
11969                 struct mgmt_cp_pin_code_neg_reply cp;
11970
11971                 memset(&cp, 0, sizeof(cp));
11972                 bacpy(&cp.addr.bdaddr, bdaddr);
11973                 cp.addr.type = BDADDR_BREDR;
11974
11975                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
11976                                         adapter->dev_id, sizeof(cp), &cp,
11977                                         NULL, NULL, NULL);
11978         } else {
11979                 struct mgmt_cp_pin_code_reply cp;
11980
11981                 if (pin_len > 16)
11982                         return -EINVAL;
11983
11984                 memset(&cp, 0, sizeof(cp));
11985                 bacpy(&cp.addr.bdaddr, bdaddr);
11986                 cp.addr.type = BDADDR_BREDR;
11987                 cp.pin_len = pin_len;
11988                 memcpy(cp.pin_code, pin, pin_len);
11989
11990                 /* Since a pincode was requested, update the starting time to
11991                  * the point where the pincode is provided. */
11992                 device = btd_adapter_find_device(adapter, bdaddr, BDADDR_BREDR);
11993                 device_bonding_restart_timer(device);
11994
11995                 id = mgmt_reply(adapter->mgmt, MGMT_OP_PIN_CODE_REPLY,
11996                                         adapter->dev_id, sizeof(cp), &cp,
11997                                         pincode_reply_complete, device, NULL);
11998         }
11999
12000         if (id == 0)
12001                 return -EIO;
12002
12003         return 0;
12004 }
12005
12006 int btd_adapter_confirm_reply(struct btd_adapter *adapter,
12007                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
12008                                 gboolean success)
12009 {
12010         struct mgmt_cp_user_confirm_reply cp;
12011         uint16_t opcode;
12012         char addr[18];
12013
12014         ba2str(bdaddr, addr);
12015         DBG("hci%u addr %s success %d", adapter->dev_id, addr, success);
12016
12017         if (success)
12018                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
12019         else
12020                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
12021
12022         memset(&cp, 0, sizeof(cp));
12023         bacpy(&cp.addr.bdaddr, bdaddr);
12024         cp.addr.type = bdaddr_type;
12025
12026         if (mgmt_reply(adapter->mgmt, opcode, adapter->dev_id, sizeof(cp), &cp,
12027                                                         NULL, NULL, NULL) > 0)
12028                 return 0;
12029
12030         return -EIO;
12031 }
12032
12033 static void user_confirm_request_callback(uint16_t index, uint16_t length,
12034                                         const void *param, void *user_data)
12035 {
12036         const struct mgmt_ev_user_confirm_request *ev = param;
12037         struct btd_adapter *adapter = user_data;
12038         struct btd_device *device;
12039         char addr[18];
12040         int err;
12041
12042         if (length < sizeof(*ev)) {
12043                 btd_error(adapter->dev_id,
12044                                 "Too small user confirm request event");
12045                 return;
12046         }
12047
12048         ba2str(&ev->addr.bdaddr, addr);
12049         DBG("hci%u %s confirm_hint %u", adapter->dev_id, addr,
12050                                                         ev->confirm_hint);
12051         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
12052                                                                 ev->addr.type);
12053         if (!device) {
12054                 btd_error(adapter->dev_id,
12055                                 "Unable to get device object for %s", addr);
12056                 return;
12057         }
12058
12059 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12060         device_set_auth_addr_type(device, ev->addr.type);
12061 #endif
12062         err = device_confirm_passkey(device, ev->addr.type, btohl(ev->value),
12063                                                         ev->confirm_hint);
12064         if (err < 0) {
12065                 btd_error(adapter->dev_id,
12066                                 "device_confirm_passkey: %s", strerror(-err));
12067                 btd_adapter_confirm_reply(adapter, &ev->addr.bdaddr,
12068                                                         ev->addr.type, FALSE);
12069         }
12070 }
12071
12072 int btd_adapter_passkey_reply(struct btd_adapter *adapter,
12073                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
12074                                 uint32_t passkey)
12075 {
12076         unsigned int id;
12077         char addr[18];
12078
12079         ba2str(bdaddr, addr);
12080         DBG("hci%u addr %s passkey %06u", adapter->dev_id, addr, passkey);
12081
12082         if (passkey == INVALID_PASSKEY) {
12083                 struct mgmt_cp_user_passkey_neg_reply cp;
12084
12085                 memset(&cp, 0, sizeof(cp));
12086                 bacpy(&cp.addr.bdaddr, bdaddr);
12087                 cp.addr.type = bdaddr_type;
12088
12089                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
12090                                         adapter->dev_id, sizeof(cp), &cp,
12091                                         NULL, NULL, NULL);
12092         } else {
12093                 struct mgmt_cp_user_passkey_reply cp;
12094
12095                 memset(&cp, 0, sizeof(cp));
12096                 bacpy(&cp.addr.bdaddr, bdaddr);
12097                 cp.addr.type = bdaddr_type;
12098                 cp.passkey = htobl(passkey);
12099
12100                 id = mgmt_reply(adapter->mgmt, MGMT_OP_USER_PASSKEY_REPLY,
12101                                         adapter->dev_id, sizeof(cp), &cp,
12102                                         NULL, NULL, NULL);
12103         }
12104
12105         if (id == 0)
12106                 return -EIO;
12107
12108         return 0;
12109 }
12110
12111 static void user_passkey_request_callback(uint16_t index, uint16_t length,
12112                                         const void *param, void *user_data)
12113 {
12114         const struct mgmt_ev_user_passkey_request *ev = param;
12115         struct btd_adapter *adapter = user_data;
12116         struct btd_device *device;
12117         char addr[18];
12118         int err;
12119
12120         if (length < sizeof(*ev)) {
12121                 btd_error(adapter->dev_id, "Too small passkey request event");
12122                 return;
12123         }
12124
12125         ba2str(&ev->addr.bdaddr, addr);
12126         DBG("hci%u %s", index, addr);
12127
12128         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
12129                                                                 ev->addr.type);
12130         if (!device) {
12131                 btd_error(adapter->dev_id,
12132                                 "Unable to get device object for %s", addr);
12133                 return;
12134         }
12135
12136 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12137         device_set_auth_addr_type(device, ev->addr.type);
12138 #endif
12139         err = device_request_passkey(device, ev->addr.type);
12140         if (err < 0) {
12141                 btd_error(adapter->dev_id,
12142                                 "device_request_passkey: %s", strerror(-err));
12143                 btd_adapter_passkey_reply(adapter, &ev->addr.bdaddr,
12144                                         ev->addr.type, INVALID_PASSKEY);
12145         }
12146 }
12147
12148 static void user_passkey_notify_callback(uint16_t index, uint16_t length,
12149                                         const void *param, void *user_data)
12150 {
12151         const struct mgmt_ev_passkey_notify *ev = param;
12152         struct btd_adapter *adapter = user_data;
12153         struct btd_device *device;
12154         uint32_t passkey;
12155         char addr[18];
12156         int err;
12157
12158         if (length < sizeof(*ev)) {
12159                 btd_error(adapter->dev_id, "Too small passkey notify event");
12160                 return;
12161         }
12162
12163         ba2str(&ev->addr.bdaddr, addr);
12164         DBG("hci%u %s", index, addr);
12165
12166         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
12167                                                                 ev->addr.type);
12168         if (!device) {
12169                 btd_error(adapter->dev_id,
12170                                 "Unable to get device object for %s", addr);
12171                 return;
12172         }
12173
12174         passkey = get_le32(&ev->passkey);
12175
12176         DBG("passkey %06u entered %u", passkey, ev->entered);
12177
12178         err = device_notify_passkey(device, ev->addr.type, passkey,
12179                                                                 ev->entered);
12180         if (err < 0)
12181                 btd_error(adapter->dev_id,
12182                                 "device_notify_passkey: %s", strerror(-err));
12183 }
12184
12185 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12186 static void rssi_alert_callback(uint16_t index, uint16_t length,
12187                                         const void *param, void *user_data)
12188 {
12189         const struct mgmt_ev_vendor_specific_rssi_alert *ev = param;
12190         struct btd_adapter *adapter = user_data;
12191         char addr[18];
12192         char *bt_addr =  NULL;
12193         int link_type = -1;
12194         int alert_type = -1;
12195         int rssi_dbm = 0;
12196
12197         if (length < sizeof(*ev)) {
12198                 error("Too small rssi alert event");
12199                 return;
12200         }
12201
12202         ba2str(&ev->bdaddr, addr);
12203         DBG("hci%u %s %d", index, addr, ev->link_type);
12204         DBG("RSSI Alert Params [%d %d]", ev->alert_type, ev->rssi_dbm);
12205
12206         bt_addr = (char *)&addr;
12207         link_type = ev->link_type;
12208         alert_type = ev->alert_type;
12209         rssi_dbm = ev->rssi_dbm;
12210         g_dbus_emit_signal(dbus_conn, adapter->path,
12211                         ADAPTER_INTERFACE, "RssiAlert",
12212                         DBUS_TYPE_STRING, &bt_addr,
12213                         DBUS_TYPE_INT32, &link_type,
12214                         DBUS_TYPE_INT32, &alert_type,
12215                         DBUS_TYPE_INT32, &rssi_dbm,
12216                         DBUS_TYPE_INVALID);
12217 }
12218
12219 static void get_raw_rssi_callback(uint16_t index, uint16_t length,
12220                                         const void *param, void *user_data)
12221 {
12222         const struct mgmt_cc_rp_get_raw_rssi *ev = param;
12223         struct btd_adapter *adapter = user_data;
12224         char addr[18];
12225         char *bt_addr =  NULL;
12226         int link_type = -1;
12227         int rssi_dbm = 0;
12228
12229         if (length < sizeof(*ev)) {
12230                 error("Too small raw RSSI event");
12231                 return;
12232         }
12233
12234         ba2str(&ev->bt_address, addr);
12235         DBG("hci%u %s", index, addr);
12236         DBG("Raw RSSI Params [%d %d]", ev->link_type, ev->rssi_dbm);
12237
12238         bt_addr = (char *)&addr;
12239         link_type = ev->link_type;
12240         rssi_dbm = ev->rssi_dbm;
12241
12242         g_dbus_emit_signal(dbus_conn, adapter->path,
12243                         ADAPTER_INTERFACE, "RawRssi",
12244                         DBUS_TYPE_STRING, &bt_addr,
12245                         DBUS_TYPE_INT32, &link_type,
12246                         DBUS_TYPE_INT32, &rssi_dbm,
12247                         DBUS_TYPE_INVALID);
12248 }
12249
12250 static void rssi_enabled_callback(uint16_t index, uint16_t length,
12251                                         const void *param, void *user_data)
12252 {
12253         const struct mgmt_cc_rsp_enable_rssi *ev = param;
12254         struct btd_adapter *adapter = user_data;
12255         char addr[18];
12256         char *bt_addr =  NULL;
12257         int enabled = TRUE;
12258         int link_type = -1;
12259
12260         if (length < sizeof(*ev)) {
12261                 error("Too small rssi enabled event");
12262                 return;
12263         }
12264
12265         ba2str(&ev->bt_address, addr);
12266         DBG("hci%u %s %d", index, addr, ev->link_type);
12267         DBG("RSSI Enabled [%d %d]", ev->le_ext_opcode, ev->status);
12268
12269         bt_addr = (char *)&addr;
12270         link_type = ev->link_type;
12271
12272         g_dbus_emit_signal(dbus_conn, adapter->path,
12273                         ADAPTER_INTERFACE, "RssiEnabled",
12274                         DBUS_TYPE_STRING, &bt_addr,
12275                         DBUS_TYPE_INT32, &link_type,
12276                         DBUS_TYPE_BOOLEAN, &enabled,
12277                         DBUS_TYPE_INVALID);
12278 }
12279
12280 static void rssi_disabled_callback(uint16_t index, uint16_t length,
12281                                         const void *param, void *user_data)
12282 {
12283         const struct mgmt_cc_rp_disable_rssi *ev = param;
12284         struct btd_adapter *adapter = user_data;
12285         char addr[18];
12286         char *bt_addr =  NULL;
12287         int disabled = FALSE;
12288         int link_type = -1;
12289
12290         if (length < sizeof(*ev)) {
12291                 error("Too small RSSI disabled event");
12292                 return;
12293         }
12294
12295         ba2str(&ev->bt_address, addr);
12296         DBG("hci%u %s %d", index, addr, ev->link_type);
12297         DBG("RSSI Disabled Params [%d %d]", ev->le_ext_opcode, ev->status);
12298
12299         bt_addr = (char *)&addr;
12300         link_type = ev->link_type;
12301
12302         g_dbus_emit_signal(dbus_conn, adapter->path,
12303                         ADAPTER_INTERFACE, "RssiEnabled",
12304                         DBUS_TYPE_STRING, &bt_addr,
12305                         DBUS_TYPE_INT32, &link_type,
12306                         DBUS_TYPE_BOOLEAN, &disabled,
12307                         DBUS_TYPE_INVALID);
12308 }
12309
12310 void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver)
12311 {
12312         char *ver;
12313
12314         switch (hci_ver) {
12315         case 0:
12316                 ver = "Bluetooth 1.0b";
12317                 break;
12318         case 1:
12319                 ver = "Bluetooth 1.1";
12320                 break;
12321         case 2:
12322                 ver = "Bluetooth 1.2";
12323                 break;
12324         case 3:
12325                 ver = "Bluetooth 2.0 + EDR";
12326                 break;
12327         case 4:
12328                 ver = "Bluetooth 2.1 + EDR";
12329                 break;
12330         case 5:
12331                 ver = "Bluetooth 3.0 + HS";
12332                 break;
12333         case 6:
12334                 ver = "Bluetooth 4.0";
12335                 break;
12336         case 7:
12337                 ver = "Bluetooth 4.1";
12338                 break;
12339         default:
12340                 ver = "Unknown";
12341                 break;
12342         }
12343
12344         if (adapter->version)
12345                 g_free(adapter->version);
12346
12347         adapter->version = g_strdup(ver);
12348 }
12349
12350 static void hardware_error_callback(uint16_t index, uint16_t length,
12351                 const void *param, void *user_data)
12352 {
12353         const struct mgmt_ev_hardware_error *ev = param;
12354         struct btd_adapter *adapter = user_data;
12355
12356         if (length < sizeof(*ev)) {
12357                 error("Too small Hardware error event");
12358                 return;
12359         }
12360
12361         error("Hardware error occurred : %d", ev->error_code);
12362         g_dbus_emit_signal(dbus_conn, adapter->path,
12363                         ADAPTER_INTERFACE, "HardwareError",
12364                         DBUS_TYPE_INVALID);
12365 }
12366
12367 static void tx_timeout_error_callback(uint16_t index, uint16_t length,
12368                 const void *param, void *user_data)
12369 {
12370         struct btd_adapter *adapter = user_data;
12371
12372         error("Tx Timeout error occurred");
12373         g_dbus_emit_signal(dbus_conn, adapter->path,
12374                         ADAPTER_INTERFACE, "TxTimeoutError",
12375                         DBUS_TYPE_INVALID);
12376 }
12377
12378 static void device_name_update_callback(uint16_t index, uint16_t length,
12379                 const void *param, void *user_data)
12380 {
12381         const struct mgmt_ev_device_name_update *ev = param;
12382         struct btd_adapter *adapter = user_data;
12383         struct btd_device *device;
12384         char addr[18];
12385         const uint8_t *eir_name;
12386         struct eir_data eir_data;
12387
12388         if (length < sizeof(*ev)) {
12389                 error("Name update error event");
12390                 return;
12391         }
12392
12393         ba2str(&ev->addr.bdaddr, addr);
12394         DBG("hci%u %s", index, addr);
12395
12396         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
12397                                                                 ev->addr.type);
12398         if (!device) {
12399                 error("Unable to get device object for %s", addr);
12400                 return;
12401         }
12402
12403         if (ev->eir_len == 0)
12404                 return;
12405
12406         eir_name = ev->eir;
12407
12408         memset(&eir_data, 0, sizeof(eir_data));
12409         eir_parse(&eir_data, eir_name, ev->eir_len);
12410
12411         if (eir_data.name)
12412                 btd_device_device_set_name(device, eir_data.name);
12413
12414         eir_data_free(&eir_data);
12415 }
12416
12417 struct multi_adv_data {
12418         struct btd_adapter *adapter;
12419         uint8_t slot_id;
12420 };
12421
12422 static gboolean multi_adv_start_timeout_cb(gpointer user_data)
12423 {
12424         struct multi_adv_data *data = user_data;
12425         struct btd_adapter *adapter = data->adapter;
12426         dbus_bool_t err;
12427
12428         adapter->adv_restart_timeout = 0;
12429
12430         err = adapter_le_enable_multi_adv(adapter, TRUE, data->slot_id);
12431         if (!err)
12432                 advertising_state_changed(adapter, data->slot_id, FALSE);
12433
12434         g_free(data);
12435         return FALSE;
12436 }
12437
12438 static void multi_adv_state_change_callback(uint16_t index, uint16_t length,
12439                                         const void *param, void *user_data)
12440 {
12441         const struct mgmt_ev_vendor_specific_multi_adv_state_changed *ev = param;
12442         struct btd_adapter *adapter = user_data;
12443         struct multi_adv_data *data;
12444
12445         if (length < sizeof(*ev)) {
12446                 error("Too small adv state change event");
12447                 return;
12448         }
12449
12450         DBG("adv id %d, state change reason %d, connection_handle %x",
12451                 ev->adv_instance, ev->state_change_reason, ev->connection_handle);
12452
12453         if ((ev->adv_instance > 0 && ev->adv_instance < adapter_le_get_max_adv_instance()) &&
12454                         ev->state_change_reason == 0) {
12455                 /* advertising is stopped by controller, it should be enabled again.
12456                 * If fails, state should be changed to FALSE */
12457                 data = g_new0(struct multi_adv_data, 1);
12458                 data->adapter = adapter;
12459                 data->slot_id = ev->adv_instance;
12460
12461                 adapter->adv_restart_timeout =
12462                         g_timeout_add(300, multi_adv_start_timeout_cb, data);
12463         }
12464 }
12465
12466 static void le_conn_update_completed_callback(uint16_t index, uint16_t length,
12467                                         const void *param, void *user_data)
12468 {
12469         const struct mgmt_ev_conn_updated *ev = param;
12470         struct btd_adapter *adapter = user_data;
12471         struct btd_device *device;
12472         char addr[18];
12473         GSList *list = NULL;
12474
12475         if (length < sizeof(*ev)) {
12476                 error("Too small le conn update completed event");
12477                 return;
12478         }
12479
12480         ba2str(&ev->addr.bdaddr, addr);
12481         if (ev->addr.type == BDADDR_LE_PUBLIC) {
12482                 /* Private Random Address */
12483                 list = g_slist_find_custom(adapter->devices, addr,
12484                                                 device_rpa_ida_cmp);
12485                 /* LE Public */
12486                 if (!list)
12487                         list = g_slist_find_custom(adapter->devices, addr,
12488                                                         device_address_cmp);
12489         } else if (ev->addr.type == BDADDR_LE_RANDOM) {
12490                 /* LE Static Random address */
12491                 list = g_slist_find_custom(adapter->devices, addr,
12492                                                         device_address_cmp);
12493         }
12494
12495         if (list) {
12496                 device = list->data;
12497                 device_print_addr(device);
12498
12499                 if (device_get_conn_update_state(device))
12500                         device_set_conn_update_state(device, false);
12501         }
12502 }
12503
12504 static void bt_6lowpan_conn_state_change_callback(uint16_t index, uint16_t length,
12505                                         const void *param, void *user_data)
12506 {
12507         const struct mgmt_ev_6lowpan_conn_state_changed *ev = param;
12508         struct btd_adapter *adapter = user_data;
12509         struct btd_device *device;
12510         char addr[18];
12511         gboolean connected = 0;
12512
12513         if (length < sizeof(*ev)) {
12514                 btd_error(adapter->dev_id,
12515                         "Too small device connected event");
12516                 return;
12517         }
12518
12519         ba2str(&ev->addr.bdaddr, addr);
12520
12521         DBG("hci%u device %s", index, addr);
12522
12523         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
12524                                                                 ev->addr.type);
12525         if (!device) {
12526                 btd_error(adapter->dev_id,
12527                         "Unable to get device object for %s", addr);
12528                 return;
12529         }
12530
12531         if (ev->connected)
12532                 connected = TRUE;
12533         else
12534                 connected = FALSE;
12535
12536         device_set_ipsp_connected(device, connected, ev->ifname);
12537 }
12538
12539 static void bt_le_data_length_changed_callback(uint16_t index, uint16_t length,
12540                                         const void *param, void *user_data)
12541 {
12542         const struct mgmt_ev_le_data_length_changed *ev = param;
12543         struct btd_adapter *adapter = user_data;
12544         struct btd_device *device;
12545         char addr[18];
12546
12547         if (length < sizeof(*ev)) {
12548                 btd_error(adapter->dev_id,
12549                         "Too small data length changed event");
12550                 return;
12551         }
12552
12553         ba2str(&ev->addr.bdaddr, addr);
12554
12555         DBG("hci%u device %s", index, addr);
12556
12557         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
12558                                                                 ev->addr.type);
12559         if (!device) {
12560                 btd_error(adapter->dev_id,
12561                         "Unable to get device object for %s", addr);
12562                 return;
12563         }
12564
12565         device_le_data_length_changed(device, ev->max_tx_octets, ev->max_tx_time,
12566                 ev->max_rx_octets, ev->max_rx_time);
12567 }
12568
12569 #endif
12570
12571 struct btd_adapter_pin_cb_iter *btd_adapter_pin_cb_iter_new(
12572                                                 struct btd_adapter *adapter)
12573 {
12574         struct btd_adapter_pin_cb_iter *iter =
12575                                 g_new0(struct btd_adapter_pin_cb_iter, 1);
12576
12577         iter->it = adapter->pin_callbacks;
12578         iter->attempt = 1;
12579
12580         return iter;
12581 }
12582
12583 void btd_adapter_pin_cb_iter_free(struct btd_adapter_pin_cb_iter *iter)
12584 {
12585         g_free(iter);
12586 }
12587
12588 bool btd_adapter_pin_cb_iter_end(struct btd_adapter_pin_cb_iter *iter)
12589 {
12590         return iter->it == NULL && iter->attempt == 0;
12591 }
12592
12593 static ssize_t btd_adapter_pin_cb_iter_next(
12594                                         struct btd_adapter_pin_cb_iter *iter,
12595                                         struct btd_adapter *adapter,
12596                                         struct btd_device *device,
12597                                         char *pin_buf, bool *display)
12598 {
12599         btd_adapter_pin_cb_t cb;
12600         ssize_t ret;
12601
12602         while (iter->it != NULL) {
12603                 cb = iter->it->data;
12604                 ret = cb(adapter, device, pin_buf, display, iter->attempt);
12605                 iter->attempt++;
12606                 if (ret > 0)
12607                         return ret;
12608                 iter->attempt = 1;
12609                 iter->it = g_slist_next(iter->it);
12610         }
12611         iter->attempt = 0;
12612
12613         return 0;
12614 }
12615
12616 static void pin_code_request_callback(uint16_t index, uint16_t length,
12617                                         const void *param, void *user_data)
12618 {
12619         const struct mgmt_ev_pin_code_request *ev = param;
12620         struct btd_adapter *adapter = user_data;
12621         struct btd_device *device;
12622         bool display = false;
12623         char pin[17];
12624         ssize_t pinlen;
12625         char addr[18];
12626         int err;
12627         struct btd_adapter_pin_cb_iter *iter;
12628
12629         if (length < sizeof(*ev)) {
12630                 btd_error(adapter->dev_id, "Too small PIN code request event");
12631                 return;
12632         }
12633
12634         ba2str(&ev->addr.bdaddr, addr);
12635
12636         DBG("hci%u %s", adapter->dev_id, addr);
12637
12638         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
12639                                                                 ev->addr.type);
12640         if (!device) {
12641                 btd_error(adapter->dev_id,
12642                                 "Unable to get device object for %s", addr);
12643                 return;
12644         }
12645
12646         /* Flag the request of a pincode to allow a bonding retry. */
12647         adapter->pincode_requested = true;
12648 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12649         btd_device_set_legacy_pairing(device, true);
12650 #endif
12651
12652         memset(pin, 0, sizeof(pin));
12653
12654         iter = device_bonding_iter(device);
12655         if (iter == NULL)
12656                 pinlen = 0;
12657         else
12658                 pinlen = btd_adapter_pin_cb_iter_next(iter, adapter, device,
12659                                                                 pin, &display);
12660
12661         if (pinlen > 0 && (!ev->secure || pinlen == 16)) {
12662                 if (display && device_is_bonding(device, NULL)) {
12663                         err = device_notify_pincode(device, ev->secure, pin);
12664                         if (err < 0) {
12665                                 btd_error(adapter->dev_id,
12666                                                 "device_notify_pin: %s",
12667                                                         strerror(-err));
12668                                 btd_adapter_pincode_reply(adapter,
12669                                                         &ev->addr.bdaddr,
12670                                                         NULL, 0);
12671                         }
12672                 } else {
12673                         btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
12674                                                                 pin, pinlen);
12675                 }
12676                 return;
12677         }
12678
12679 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12680         if (main_opts.pin_code) {
12681                 /* Because we can't receive user input on headless device,
12682                    no need to request pincode. Use the 'PinCode' in headless conf file */
12683                 DBG("Use configured PinCode in headless device");
12684                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr,
12685                                 main_opts.pin_code, strlen(main_opts.pin_code));
12686                 return;
12687         }
12688 #endif
12689
12690         err = device_request_pincode(device, ev->secure);
12691         if (err < 0) {
12692                 btd_error(adapter->dev_id, "device_request_pin: %s",
12693                                                         strerror(-err));
12694                 btd_adapter_pincode_reply(adapter, &ev->addr.bdaddr, NULL, 0);
12695         }
12696 }
12697
12698 int adapter_cancel_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12699                                                         uint8_t addr_type)
12700 {
12701         struct mgmt_addr_info cp;
12702         char addr[18];
12703
12704         ba2str(bdaddr, addr);
12705         DBG("hci%u bdaddr %s type %u", adapter->dev_id, addr, addr_type);
12706
12707         memset(&cp, 0, sizeof(cp));
12708         bacpy(&cp.bdaddr, bdaddr);
12709         cp.type = addr_type;
12710
12711         if (mgmt_reply(adapter->mgmt, MGMT_OP_CANCEL_PAIR_DEVICE,
12712                                 adapter->dev_id, sizeof(cp), &cp,
12713                                 NULL, NULL, NULL) > 0)
12714                 return 0;
12715
12716         return -EIO;
12717 }
12718
12719 static void check_oob_bonding_complete(struct btd_adapter *adapter,
12720                                         const bdaddr_t *bdaddr, uint8_t status)
12721 {
12722         if (!adapter->oob_handler || !adapter->oob_handler->bonding_cb)
12723                 return;
12724
12725         if (bacmp(bdaddr, &adapter->oob_handler->remote_addr) != 0)
12726                 return;
12727
12728         adapter->oob_handler->bonding_cb(adapter, bdaddr, status,
12729                                         adapter->oob_handler->user_data);
12730
12731         g_free(adapter->oob_handler);
12732         adapter->oob_handler = NULL;
12733 }
12734
12735 static void bonding_complete(struct btd_adapter *adapter,
12736                                         const bdaddr_t *bdaddr,
12737                                         uint8_t addr_type, uint8_t status)
12738 {
12739         struct btd_device *device;
12740
12741         if (status == 0)
12742                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
12743         else
12744                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
12745
12746         if (device != NULL)
12747                 device_bonding_complete(device, addr_type, status);
12748
12749 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12750         resume_discovery(adapter);
12751 #endif
12752         check_oob_bonding_complete(adapter, bdaddr, status);
12753 }
12754
12755 /* bonding_attempt_complete() handles the end of a "bonding attempt" checking if
12756  * it should begin a new attempt or complete the bonding.
12757  */
12758 static void bonding_attempt_complete(struct btd_adapter *adapter,
12759                                         const bdaddr_t *bdaddr,
12760                                         uint8_t addr_type, uint8_t status)
12761 {
12762         struct btd_device *device;
12763         char addr[18];
12764
12765         ba2str(bdaddr, addr);
12766         DBG("hci%u bdaddr %s type %u status 0x%x", adapter->dev_id, addr,
12767                                                         addr_type, status);
12768
12769         if (status == 0)
12770                 device = btd_adapter_get_device(adapter, bdaddr, addr_type);
12771         else
12772                 device = btd_adapter_find_device(adapter, bdaddr, addr_type);
12773
12774         if (status == MGMT_STATUS_AUTH_FAILED && adapter->pincode_requested) {
12775                 /* On faliure, issue a bonding_retry if possible. */
12776                 if (device != NULL) {
12777                         if (device_bonding_attempt_retry(device) == 0)
12778                                 return;
12779                 }
12780         }
12781
12782         /* Ignore disconnects during retry. */
12783         if (status == MGMT_STATUS_DISCONNECTED &&
12784                                         device && device_is_retrying(device))
12785                 return;
12786
12787         /* In any other case, finish the bonding. */
12788         bonding_complete(adapter, bdaddr, addr_type, status);
12789 }
12790
12791 struct pair_device_data {
12792         struct btd_adapter *adapter;
12793         bdaddr_t bdaddr;
12794         uint8_t addr_type;
12795 };
12796
12797 static void free_pair_device_data(void *user_data)
12798 {
12799         struct pair_device_data *data = user_data;
12800
12801         g_free(data);
12802 }
12803
12804 static gboolean pair_device_timeout(gpointer user_data)
12805 {
12806         struct pair_device_data *data = user_data;
12807         struct btd_adapter *adapter = data->adapter;
12808
12809         btd_error(adapter->dev_id, "Pair device timed out for hci%u",
12810                                                         adapter->dev_id);
12811
12812         adapter->pair_device_timeout = 0;
12813
12814         adapter_cancel_bonding(adapter, &data->bdaddr, data->addr_type);
12815
12816         return FALSE;
12817 }
12818
12819 static void pair_device_complete(uint8_t status, uint16_t length,
12820                                         const void *param, void *user_data)
12821 {
12822         const struct mgmt_rp_pair_device *rp = param;
12823         struct pair_device_data *data = user_data;
12824         struct btd_adapter *adapter = data->adapter;
12825
12826         DBG("%s (0x%02x)", mgmt_errstr(status), status);
12827
12828         adapter->pair_device_id = 0;
12829
12830         if (adapter->pair_device_timeout > 0) {
12831                 g_source_remove(adapter->pair_device_timeout);
12832                 adapter->pair_device_timeout = 0;
12833         }
12834
12835         /* Workaround for a kernel bug
12836          *
12837          * Broken kernels may reply to device pairing command with command
12838          * status instead of command complete event e.g. if adapter was not
12839          * powered.
12840          */
12841         if (status != MGMT_STATUS_SUCCESS && length < sizeof(*rp)) {
12842                 btd_error(adapter->dev_id, "Pair device failed: %s (0x%02x)",
12843                                                 mgmt_errstr(status), status);
12844
12845                 bonding_attempt_complete(adapter, &data->bdaddr,
12846                                                 data->addr_type, status);
12847                 return;
12848         }
12849
12850         if (length < sizeof(*rp)) {
12851                 btd_error(adapter->dev_id, "Too small pair device response");
12852                 return;
12853         }
12854
12855         bonding_attempt_complete(adapter, &rp->addr.bdaddr, rp->addr.type,
12856                                                                         status);
12857 }
12858
12859 int adapter_create_bonding(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12860                                         uint8_t addr_type, uint8_t io_cap)
12861 {
12862         if (adapter->pair_device_id > 0) {
12863                 btd_error(adapter->dev_id,
12864                         "Unable pair since another pairing is in progress");
12865                 return -EBUSY;
12866         }
12867
12868 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
12869         suspend_discovery(adapter);
12870 #endif
12871         return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
12872 }
12873
12874 /* Starts a new bonding attempt in a fresh new bonding_req or a retried one. */
12875 int adapter_bonding_attempt(struct btd_adapter *adapter, const bdaddr_t *bdaddr,
12876                                         uint8_t addr_type, uint8_t io_cap)
12877 {
12878         struct mgmt_cp_pair_device cp;
12879         char addr[18];
12880         struct pair_device_data *data;
12881         unsigned int id;
12882
12883         ba2str(bdaddr, addr);
12884         DBG("hci%u bdaddr %s type %d io_cap 0x%02x",
12885                                 adapter->dev_id, addr, addr_type, io_cap);
12886
12887         /* Reset the pincode_requested flag for a new bonding attempt. */
12888         adapter->pincode_requested = false;
12889
12890         memset(&cp, 0, sizeof(cp));
12891         bacpy(&cp.addr.bdaddr, bdaddr);
12892         cp.addr.type = addr_type;
12893         cp.io_cap = io_cap;
12894
12895         data = g_new0(struct pair_device_data, 1);
12896         data->adapter = adapter;
12897         bacpy(&data->bdaddr, bdaddr);
12898         data->addr_type = addr_type;
12899
12900         id = mgmt_send(adapter->mgmt, MGMT_OP_PAIR_DEVICE,
12901                                 adapter->dev_id, sizeof(cp), &cp,
12902                                 pair_device_complete, data,
12903                                 free_pair_device_data);
12904
12905         if (id == 0) {
12906                 btd_error(adapter->dev_id, "Failed to pair %s for hci%u",
12907                                                         addr, adapter->dev_id);
12908                 free_pair_device_data(data);
12909                 return -EIO;
12910         }
12911
12912         adapter->pair_device_id = id;
12913
12914         /* Due to a bug in the kernel it is possible that a LE pairing
12915          * request never times out. Therefore, add a timer to clean up
12916          * if no response arrives
12917          */
12918         adapter->pair_device_timeout = g_timeout_add_seconds(BONDING_TIMEOUT,
12919                                                 pair_device_timeout, data);
12920
12921         return 0;
12922 }
12923
12924 static void disconnect_notify(struct btd_device *dev, uint8_t reason)
12925 {
12926         GSList *l;
12927
12928         for (l = disconnect_list; l; l = g_slist_next(l)) {
12929                 btd_disconnect_cb disconnect_cb = l->data;
12930                 disconnect_cb(dev, reason);
12931         }
12932 }
12933
12934 static void dev_disconnected(struct btd_adapter *adapter,
12935                                         const struct mgmt_addr_info *addr,
12936                                         uint8_t reason)
12937 {
12938         struct btd_device *device;
12939         char dst[18];
12940 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12941         struct device_addr_type t_addr;
12942 #endif
12943
12944         ba2str(&addr->bdaddr, dst);
12945
12946         DBG("Device %s disconnected, reason %u", dst, reason);
12947
12948         device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
12949
12950 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
12951         if (device) {
12952                 device_get_tizen_addr(device, addr->type, &t_addr);
12953
12954                 device_set_disconnect_reason(device, reason);
12955                 adapter_remove_connection(adapter, device, t_addr.bdaddr_type);
12956                 disconnect_notify(device, reason);
12957                 if (device_is_bonded(device, t_addr.bdaddr_type)) {
12958                         DBG("addr type %d, bonded", t_addr.bdaddr_type);
12959                         return;
12960                 }
12961
12962                 bonding_attempt_complete(adapter, &t_addr.bdaddr,
12963                                 t_addr.bdaddr_type, MGMT_STATUS_DISCONNECTED);
12964                 return;
12965         }
12966 #else
12967         if (device) {
12968                 adapter_remove_connection(adapter, device, addr->type);
12969                 disconnect_notify(device, reason);
12970         }
12971 #endif
12972
12973         bonding_attempt_complete(adapter, &addr->bdaddr, addr->type,
12974                                                 MGMT_STATUS_DISCONNECTED);
12975 }
12976
12977 void btd_add_disconnect_cb(btd_disconnect_cb func)
12978 {
12979         disconnect_list = g_slist_append(disconnect_list, func);
12980 }
12981
12982 void btd_remove_disconnect_cb(btd_disconnect_cb func)
12983 {
12984         disconnect_list = g_slist_remove(disconnect_list, func);
12985 }
12986
12987 static void disconnect_complete(uint8_t status, uint16_t length,
12988                                         const void *param, void *user_data)
12989 {
12990         const struct mgmt_rp_disconnect *rp = param;
12991         struct btd_adapter *adapter = user_data;
12992
12993         if (status == MGMT_STATUS_NOT_CONNECTED) {
12994                 btd_warn(adapter->dev_id,
12995                                 "Disconnecting failed: already disconnected");
12996         } else if (status != MGMT_STATUS_SUCCESS) {
12997                 btd_error(adapter->dev_id,
12998                                 "Failed to disconnect device: %s (0x%02x)",
12999                                                 mgmt_errstr(status), status);
13000                 return;
13001         }
13002
13003         if (length < sizeof(*rp)) {
13004                 btd_error(adapter->dev_id,
13005                                 "Too small device disconnect response");
13006                 return;
13007         }
13008
13009 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13010         /* Use HCI error code instead of MGMT disconnection reason */
13011         dev_disconnected(adapter, &rp->addr, 0x16);
13012 #else
13013         dev_disconnected(adapter, &rp->addr, MGMT_DEV_DISCONN_LOCAL_HOST);
13014 #endif
13015 }
13016
13017 int btd_adapter_disconnect_device(struct btd_adapter *adapter,
13018                                                 const bdaddr_t *bdaddr,
13019                                                 uint8_t bdaddr_type)
13020
13021 {
13022         struct mgmt_cp_disconnect cp;
13023
13024         memset(&cp, 0, sizeof(cp));
13025         bacpy(&cp.addr.bdaddr, bdaddr);
13026         cp.addr.type = bdaddr_type;
13027
13028         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT,
13029                                 adapter->dev_id, sizeof(cp), &cp,
13030                                 disconnect_complete, adapter, NULL) > 0)
13031                 return 0;
13032
13033         return -EIO;
13034 }
13035
13036 static void auth_failed_callback(uint16_t index, uint16_t length,
13037                                         const void *param, void *user_data)
13038 {
13039         const struct mgmt_ev_auth_failed *ev = param;
13040         struct btd_adapter *adapter = user_data;
13041
13042         if (length < sizeof(*ev)) {
13043                 btd_error(adapter->dev_id, "Too small auth failed mgmt event");
13044                 return;
13045         }
13046
13047         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
13048                                                                 ev->status);
13049 }
13050
13051 static void store_link_key(struct btd_adapter *adapter,
13052                                 struct btd_device *device, const uint8_t *key,
13053                                 uint8_t type, uint8_t pin_length)
13054 {
13055         char device_addr[18];
13056         char filename[PATH_MAX];
13057         GKeyFile *key_file;
13058         gsize length = 0;
13059         char key_str[33];
13060         char *str;
13061         int i;
13062
13063         ba2str(device_get_address(device), device_addr);
13064
13065         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
13066                         btd_adapter_get_storage_dir(adapter), device_addr);
13067         key_file = g_key_file_new();
13068         g_key_file_load_from_file(key_file, filename, 0, NULL);
13069
13070         for (i = 0; i < 16; i++)
13071                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
13072
13073         g_key_file_set_string(key_file, "LinkKey", "Key", key_str);
13074
13075         g_key_file_set_integer(key_file, "LinkKey", "Type", type);
13076         g_key_file_set_integer(key_file, "LinkKey", "PINLength", pin_length);
13077
13078         create_file(filename, S_IRUSR | S_IWUSR);
13079
13080         str = g_key_file_to_data(key_file, &length, NULL);
13081         g_file_set_contents(filename, str, length, NULL);
13082         g_free(str);
13083
13084         g_key_file_free(key_file);
13085 }
13086
13087 static void new_link_key_callback(uint16_t index, uint16_t length,
13088                                         const void *param, void *user_data)
13089 {
13090         const struct mgmt_ev_new_link_key *ev = param;
13091         const struct mgmt_addr_info *addr = &ev->key.addr;
13092         struct btd_adapter *adapter = user_data;
13093         struct btd_device *device;
13094         char dst[18];
13095
13096         if (length < sizeof(*ev)) {
13097                 btd_error(adapter->dev_id, "Too small new link key event");
13098                 return;
13099         }
13100
13101         ba2str(&addr->bdaddr, dst);
13102
13103         DBG("hci%u new key for %s type %u pin_len %u store_hint %u",
13104                 adapter->dev_id, dst, ev->key.type, ev->key.pin_len,
13105                 ev->store_hint);
13106
13107         if (ev->key.pin_len > 16) {
13108                 btd_error(adapter->dev_id,
13109                                 "Invalid PIN length (%u) in new_key event",
13110                                                         ev->key.pin_len);
13111                 return;
13112         }
13113
13114         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
13115         if (!device) {
13116                 btd_error(adapter->dev_id,
13117                                 "Unable to get device object for %s", dst);
13118                 return;
13119         }
13120
13121         if (ev->store_hint) {
13122                 const struct mgmt_link_key_info *key = &ev->key;
13123
13124                 store_link_key(adapter, device, key->val, key->type,
13125                                                                 key->pin_len);
13126
13127                 device_set_bonded(device, BDADDR_BREDR);
13128 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13129         } else {
13130                 if (btd_adapter_get_a2dp_role(adapter) == BLUETOOTH_A2DP_SINK_ROLE) {
13131                         DBG("store_hint %d", ev->store_hint);
13132                         btd_device_set_temporary(device, false);
13133                 }
13134         }
13135 #else
13136         }
13137 #endif
13138
13139         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
13140 }
13141
13142 static void store_longtermkey(struct btd_adapter *adapter, const bdaddr_t *peer,
13143                                 uint8_t bdaddr_type, const unsigned char *key,
13144                                 uint8_t master, uint8_t authenticated,
13145                                 uint8_t enc_size, uint16_t ediv,
13146                                 uint64_t rand)
13147 {
13148         const char *group = master ? "LongTermKey" : "SlaveLongTermKey";
13149         char device_addr[18];
13150         char filename[PATH_MAX];
13151         GKeyFile *key_file;
13152         char key_str[33];
13153         gsize length = 0;
13154         char *str;
13155         int i;
13156
13157         if (master != 0x00 && master != 0x01) {
13158                 error("Unsupported LTK type %u", master);
13159                 return;
13160         }
13161
13162         ba2str(peer, device_addr);
13163
13164         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
13165                         btd_adapter_get_storage_dir(adapter), device_addr);
13166         key_file = g_key_file_new();
13167         g_key_file_load_from_file(key_file, filename, 0, NULL);
13168
13169         /* Old files may contain this so remove it in case it exists */
13170         g_key_file_remove_key(key_file, "LongTermKey", "Master", NULL);
13171
13172         for (i = 0; i < 16; i++)
13173                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
13174
13175         g_key_file_set_string(key_file, group, "Key", key_str);
13176
13177         g_key_file_set_integer(key_file, group, "Authenticated",
13178                         authenticated);
13179         g_key_file_set_integer(key_file, group, "EncSize", enc_size);
13180
13181         g_key_file_set_integer(key_file, group, "EDiv", ediv);
13182         g_key_file_set_uint64(key_file, group, "Rand", rand);
13183
13184         create_file(filename, S_IRUSR | S_IWUSR);
13185
13186         str = g_key_file_to_data(key_file, &length, NULL);
13187         g_file_set_contents(filename, str, length, NULL);
13188         g_free(str);
13189
13190         g_key_file_free(key_file);
13191 }
13192
13193 static void new_long_term_key_callback(uint16_t index, uint16_t length,
13194                                         const void *param, void *user_data)
13195 {
13196         const struct mgmt_ev_new_long_term_key *ev = param;
13197         const struct mgmt_addr_info *addr = &ev->key.addr;
13198         struct btd_adapter *adapter = user_data;
13199         struct btd_device *device;
13200         bool persistent;
13201         char dst[18];
13202 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13203         struct device_addr_type t_addr;
13204 #endif
13205
13206         if (length < sizeof(*ev)) {
13207                 btd_error(adapter->dev_id, "Too small long term key event");
13208                 return;
13209         }
13210
13211         ba2str(&addr->bdaddr, dst);
13212
13213         DBG("hci%u new LTK for %s type %u enc_size %u",
13214                 adapter->dev_id, dst, ev->key.type, ev->key.enc_size);
13215
13216         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
13217         if (!device) {
13218                 btd_error(adapter->dev_id,
13219                                 "Unable to get device object for %s", dst);
13220                 return;
13221         }
13222
13223         /*
13224          * Some older kernel versions set store_hint for long term keys
13225          * from resolvable and unresolvable random addresses, but there
13226          * is no point in storing these. Next time around the device
13227          * address will be invalid.
13228          *
13229          * So only for identity addresses (public and static random) use
13230          * the store_hint as an indication if the long term key should
13231          * be persistently stored.
13232          *
13233          */
13234         if (addr->type == BDADDR_LE_RANDOM &&
13235                                 (addr->bdaddr.b[5] & 0xc0) != 0xc0)
13236                 persistent = false;
13237         else
13238                 persistent = !!ev->store_hint;
13239
13240         if (persistent) {
13241                 const struct mgmt_ltk_info *key = &ev->key;
13242                 uint16_t ediv;
13243                 uint64_t rand;
13244
13245                 ediv = le16_to_cpu(key->ediv);
13246                 rand = le64_to_cpu(key->rand);
13247
13248 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13249                 device_get_tizen_addr(device, addr->type, &t_addr);
13250                 store_longtermkey(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
13251                                         key->val, key->master, key->type,
13252                                         key->enc_size, ediv, rand);
13253 #else
13254                 store_longtermkey(adapter, &key->addr.bdaddr,
13255                                         key->addr.type, key->val, key->master,
13256                                         key->type, key->enc_size, ediv, rand);
13257 #endif
13258
13259                 device_set_bonded(device, addr->type);
13260         }
13261
13262         device_set_ltk_enc_size(device, ev->key.enc_size);
13263
13264         bonding_complete(adapter, &addr->bdaddr, addr->type, 0);
13265 }
13266
13267 static void store_csrk(struct btd_adapter *adapter, const bdaddr_t *peer,
13268                                 uint8_t bdaddr_type, const unsigned char *key,
13269                                 uint32_t counter, uint8_t type)
13270 {
13271         const char *group;
13272         char device_addr[18];
13273         char filename[PATH_MAX];
13274         GKeyFile *key_file;
13275         char key_str[33];
13276         gsize length = 0;
13277         gboolean auth;
13278         char *str;
13279         int i;
13280
13281         switch (type) {
13282         case 0x00:
13283                 group = "LocalSignatureKey";
13284                 auth = FALSE;
13285                 break;
13286         case 0x01:
13287                 group = "RemoteSignatureKey";
13288                 auth = FALSE;
13289                 break;
13290         case 0x02:
13291                 group = "LocalSignatureKey";
13292                 auth = TRUE;
13293                 break;
13294         case 0x03:
13295                 group = "RemoteSignatureKey";
13296                 auth = TRUE;
13297                 break;
13298         default:
13299                 warn("Unsupported CSRK type %u", type);
13300                 return;
13301         }
13302
13303         ba2str(peer, device_addr);
13304
13305         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
13306                         btd_adapter_get_storage_dir(adapter), device_addr);
13307
13308         key_file = g_key_file_new();
13309         g_key_file_load_from_file(key_file, filename, 0, NULL);
13310
13311         for (i = 0; i < 16; i++)
13312                 sprintf(key_str + (i * 2), "%2.2X", key[i]);
13313
13314         g_key_file_set_string(key_file, group, "Key", key_str);
13315         g_key_file_set_integer(key_file, group, "Counter", counter);
13316         g_key_file_set_boolean(key_file, group, "Authenticated", auth);
13317
13318         create_file(filename, S_IRUSR | S_IWUSR);
13319
13320         str = g_key_file_to_data(key_file, &length, NULL);
13321         g_file_set_contents(filename, str, length, NULL);
13322         g_free(str);
13323
13324         g_key_file_free(key_file);
13325 }
13326
13327 static void new_csrk_callback(uint16_t index, uint16_t length,
13328                                         const void *param, void *user_data)
13329 {
13330         const struct mgmt_ev_new_csrk *ev = param;
13331         const struct mgmt_addr_info *addr = &ev->key.addr;
13332         const struct mgmt_csrk_info *key = &ev->key;
13333         struct btd_adapter *adapter = user_data;
13334         struct btd_device *device;
13335         char dst[18];
13336 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13337         struct device_addr_type t_addr;
13338 #endif
13339
13340         if (length < sizeof(*ev)) {
13341                 btd_error(adapter->dev_id, "Too small CSRK event");
13342                 return;
13343         }
13344
13345         ba2str(&addr->bdaddr, dst);
13346
13347         DBG("hci%u new CSRK for %s type %u", adapter->dev_id, dst,
13348                                                                 ev->key.type);
13349
13350         device = btd_adapter_get_device(adapter, &addr->bdaddr, addr->type);
13351         if (!device) {
13352                 btd_error(adapter->dev_id,
13353                                 "Unable to get device object for %s", dst);
13354                 return;
13355         }
13356
13357         if (!ev->store_hint)
13358                 return;
13359
13360 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13361         device_get_tizen_addr(device, addr->type, &t_addr);
13362         store_csrk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, key->val, 0,
13363                                                                 key->type);
13364 #else
13365         store_csrk(adapter, &key->addr.bdaddr, key->addr.type, key->val, 0,
13366                                                                 key->type);
13367 #endif
13368
13369         btd_device_set_temporary(device, false);
13370 }
13371
13372 static void store_irk(struct btd_adapter *adapter, const bdaddr_t *peer,
13373                                 uint8_t bdaddr_type, const unsigned char *key)
13374 {
13375         char device_addr[18];
13376         char filename[PATH_MAX];
13377         GKeyFile *key_file;
13378         char *store_data;
13379         char str[33];
13380         size_t length = 0;
13381         int i;
13382
13383         ba2str(peer, device_addr);
13384
13385         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
13386                         btd_adapter_get_storage_dir(adapter), device_addr);
13387         key_file = g_key_file_new();
13388         g_key_file_load_from_file(key_file, filename, 0, NULL);
13389
13390         for (i = 0; i < 16; i++)
13391                 sprintf(str + (i * 2), "%2.2X", key[i]);
13392
13393         g_key_file_set_string(key_file, "IdentityResolvingKey", "Key", str);
13394
13395         create_file(filename, S_IRUSR | S_IWUSR);
13396
13397         store_data = g_key_file_to_data(key_file, &length, NULL);
13398         g_file_set_contents(filename, store_data, length, NULL);
13399         g_free(store_data);
13400
13401         g_key_file_free(key_file);
13402 }
13403
13404 static void new_irk_callback(uint16_t index, uint16_t length,
13405                                         const void *param, void *user_data)
13406 {
13407         const struct mgmt_ev_new_irk *ev = param;
13408         const struct mgmt_addr_info *addr = &ev->key.addr;
13409         const struct mgmt_irk_info *irk = &ev->key;
13410         struct btd_adapter *adapter = user_data;
13411         struct btd_device *device, *duplicate;
13412         bool persistent;
13413         char dst[18], rpa[18];
13414 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13415         struct device_addr_type t_addr;
13416 #endif
13417
13418         if (length < sizeof(*ev)) {
13419                 btd_error(adapter->dev_id, "Too small New IRK event");
13420                 return;
13421         }
13422
13423         ba2str(&addr->bdaddr, dst);
13424         ba2str(&ev->rpa, rpa);
13425
13426         DBG("hci%u new IRK for %s RPA %s", adapter->dev_id, dst, rpa);
13427
13428         if (bacmp(&ev->rpa, BDADDR_ANY)) {
13429                 device = btd_adapter_get_device(adapter, &ev->rpa,
13430                                 BDADDR_LE_RANDOM);
13431 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
13432                 device = btd_adapter_get_device(adapter, &ev->rpa,
13433                                                         BDADDR_LE_RANDOM);
13434                 duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
13435                                                                 addr->type);
13436                 if (duplicate == device)
13437                         duplicate = NULL;
13438 #else
13439                 device_set_rpa(device, &ev->rpa);
13440                 duplicate = NULL;
13441 #endif
13442         } else {
13443                 device = btd_adapter_get_device(adapter, &addr->bdaddr,
13444                                                                 addr->type);
13445                 duplicate = NULL;
13446         }
13447
13448         if (!device) {
13449                 btd_error(adapter->dev_id,
13450                                 "Unable to get device object for %s", dst);
13451                 return;
13452         }
13453
13454         device_update_addr(device, &addr->bdaddr, addr->type);
13455
13456         if (duplicate)
13457                 device_merge_duplicate(device, duplicate);
13458
13459 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13460         device_set_irk_value(device, irk->val);
13461 #endif
13462
13463         persistent = !!ev->store_hint;
13464         if (!persistent)
13465                 return;
13466
13467 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13468         device_get_tizen_addr(device, addr->type, &t_addr);
13469         store_irk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, irk->val);
13470 #else
13471         store_irk(adapter, &addr->bdaddr, addr->type, irk->val);
13472 #endif
13473
13474         btd_device_set_temporary(device, false);
13475 }
13476
13477 static void store_conn_param(struct btd_adapter *adapter, const bdaddr_t *peer,
13478                                 uint8_t bdaddr_type, uint16_t min_interval,
13479                                 uint16_t max_interval, uint16_t latency,
13480                                 uint16_t timeout)
13481 {
13482         char device_addr[18];
13483         char filename[PATH_MAX];
13484         GKeyFile *key_file;
13485         char *store_data;
13486         size_t length = 0;
13487
13488         ba2str(peer, device_addr);
13489
13490         DBG("");
13491
13492         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
13493                         btd_adapter_get_storage_dir(adapter), device_addr);
13494         key_file = g_key_file_new();
13495         g_key_file_load_from_file(key_file, filename, 0, NULL);
13496
13497         g_key_file_set_integer(key_file, "ConnectionParameters",
13498                                                 "MinInterval", min_interval);
13499         g_key_file_set_integer(key_file, "ConnectionParameters",
13500                                                 "MaxInterval", max_interval);
13501         g_key_file_set_integer(key_file, "ConnectionParameters",
13502                                                 "Latency", latency);
13503         g_key_file_set_integer(key_file, "ConnectionParameters",
13504                                                 "Timeout", timeout);
13505
13506         create_file(filename, S_IRUSR | S_IWUSR);
13507
13508         store_data = g_key_file_to_data(key_file, &length, NULL);
13509         g_file_set_contents(filename, store_data, length, NULL);
13510         g_free(store_data);
13511
13512         g_key_file_free(key_file);
13513 }
13514
13515 static void new_conn_param(uint16_t index, uint16_t length,
13516                                         const void *param, void *user_data)
13517 {
13518         const struct mgmt_ev_new_conn_param *ev = param;
13519         struct btd_adapter *adapter = user_data;
13520         uint16_t min, max, latency, timeout;
13521         struct btd_device *dev;
13522         char dst[18];
13523 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13524         struct device_addr_type t_addr;
13525 #endif
13526
13527         if (length < sizeof(*ev)) {
13528                 btd_error(adapter->dev_id,
13529                                 "Too small New Connection Parameter event");
13530                 return;
13531         }
13532
13533         ba2str(&ev->addr.bdaddr, dst);
13534
13535         min = btohs(ev->min_interval);
13536         max = btohs(ev->max_interval);
13537         latency = btohs(ev->latency);
13538         timeout = btohs(ev->timeout);
13539
13540         DBG("hci%u %s (%u) min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
13541                 adapter->dev_id, dst, ev->addr.type, min, max, latency, timeout);
13542
13543         dev = btd_adapter_get_device(adapter, &ev->addr.bdaddr, ev->addr.type);
13544         if (!dev) {
13545                 btd_error(adapter->dev_id,
13546                                 "Unable to get device object for %s", dst);
13547                 return;
13548         }
13549
13550         if (!ev->store_hint)
13551                 return;
13552
13553 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13554         device_get_tizen_addr(dev, ev->addr.type, &t_addr);
13555         store_conn_param(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
13556                                         ev->min_interval, ev->max_interval,
13557                                         ev->latency, ev->timeout);
13558 #else
13559         store_conn_param(adapter, &ev->addr.bdaddr, ev->addr.type,
13560                                         ev->min_interval, ev->max_interval,
13561                                         ev->latency, ev->timeout);
13562 #endif
13563 }
13564
13565 int adapter_set_io_capability(struct btd_adapter *adapter, uint8_t io_cap)
13566 {
13567         struct mgmt_cp_set_io_capability cp;
13568
13569         if (!main_opts.pairable) {
13570                 if (io_cap == IO_CAPABILITY_INVALID) {
13571                         if (adapter->current_settings & MGMT_SETTING_BONDABLE)
13572                                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x00);
13573
13574                         return 0;
13575                 }
13576
13577                 if (!(adapter->current_settings & MGMT_SETTING_BONDABLE))
13578                         set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
13579         } else if (io_cap == IO_CAPABILITY_INVALID)
13580                 io_cap = IO_CAPABILITY_NOINPUTNOOUTPUT;
13581
13582         memset(&cp, 0, sizeof(cp));
13583         cp.io_capability = io_cap;
13584
13585         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IO_CAPABILITY,
13586                                 adapter->dev_id, sizeof(cp), &cp,
13587                                 NULL, NULL, NULL) > 0)
13588                 return 0;
13589
13590         return -EIO;
13591 }
13592
13593 int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
13594                                         const bdaddr_t *bdaddr,
13595                                         uint8_t *hash, uint8_t *randomizer)
13596 {
13597         struct mgmt_cp_add_remote_oob_data cp;
13598         char addr[18];
13599
13600         ba2str(bdaddr, addr);
13601         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
13602
13603         memset(&cp, 0, sizeof(cp));
13604         bacpy(&cp.addr.bdaddr, bdaddr);
13605         memcpy(cp.hash192, hash, 16);
13606
13607         if (randomizer)
13608                 memcpy(cp.rand192, randomizer, 16);
13609
13610         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
13611                                 adapter->dev_id, sizeof(cp), &cp,
13612                                 NULL, NULL, NULL) > 0)
13613                 return 0;
13614
13615         return -EIO;
13616 }
13617
13618 int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
13619                                                         const bdaddr_t *bdaddr)
13620 {
13621         struct mgmt_cp_remove_remote_oob_data cp;
13622         char addr[18];
13623
13624         ba2str(bdaddr, addr);
13625         DBG("hci%d bdaddr %s", adapter->dev_id, addr);
13626
13627         memset(&cp, 0, sizeof(cp));
13628         bacpy(&cp.addr.bdaddr, bdaddr);
13629
13630         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
13631                                 adapter->dev_id, sizeof(cp), &cp,
13632                                 NULL, NULL, NULL) > 0)
13633                 return 0;
13634
13635         return -EIO;
13636 }
13637
13638 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13639 int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
13640                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type,
13641                                 uint8_t *hash192, uint8_t *randomizer192,
13642                                 uint8_t *hash256, uint8_t *randomizer256)
13643 {
13644         struct mgmt_cp_add_remote_oob_data cp;
13645         char addr[18];
13646
13647         ba2str(bdaddr, addr);
13648         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
13649
13650         memset(&cp, 0, sizeof(cp));
13651         bacpy(&cp.addr.bdaddr, bdaddr);
13652         cp.addr.type = bdaddr_type;
13653
13654         if (hash192 && randomizer192) {
13655                 memcpy(cp.hash192, hash192, 16);
13656                 memcpy(cp.rand192, randomizer192, 16);
13657         }
13658
13659         if (hash256 && randomizer256) {
13660                 memcpy(cp.hash256, hash256, 16);
13661                 memcpy(cp.rand256, randomizer256, 16);
13662         }
13663
13664         if (mgmt_send(adapter->mgmt, MGMT_OP_ADD_REMOTE_OOB_DATA,
13665                                 adapter->dev_id, sizeof(cp), &cp,
13666                                 NULL, NULL, NULL) > 0)
13667                 return 0;
13668
13669         return -EIO;
13670 }
13671
13672 int btd_adapter_remove_remote_oob_ext_data(struct btd_adapter *adapter,
13673                                 const bdaddr_t *bdaddr, uint8_t bdaddr_type)
13674 {
13675         struct mgmt_cp_remove_remote_oob_data cp;
13676         char addr[18];
13677
13678         ba2str(bdaddr, addr);
13679         DBG("hci%d bdaddr %s type %d", adapter->dev_id, addr, bdaddr_type);
13680
13681         memset(&cp, 0, sizeof(cp));
13682         bacpy(&cp.addr.bdaddr, bdaddr);
13683         cp.addr.type = bdaddr_type;
13684
13685         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
13686                                 adapter->dev_id, sizeof(cp), &cp,
13687                                 NULL, NULL, NULL) > 0)
13688                 return 0;
13689
13690         return -EIO;
13691 }
13692 #endif
13693
13694 bool btd_adapter_ssp_enabled(struct btd_adapter *adapter)
13695 {
13696         if (adapter->current_settings & MGMT_SETTING_SSP)
13697                 return true;
13698
13699         return false;
13700 }
13701
13702 void btd_adapter_set_oob_handler(struct btd_adapter *adapter,
13703                                                 struct oob_handler *handler)
13704 {
13705         adapter->oob_handler = handler;
13706 }
13707
13708 gboolean btd_adapter_check_oob_handler(struct btd_adapter *adapter)
13709 {
13710         return adapter->oob_handler != NULL;
13711 }
13712
13713 static void read_local_oob_data_complete(uint8_t status, uint16_t length,
13714                                         const void *param, void *user_data)
13715 {
13716         const struct mgmt_rp_read_local_oob_data *rp = param;
13717         struct btd_adapter *adapter = user_data;
13718         const uint8_t *hash, *randomizer;
13719 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13720         const uint8_t *hash256 = NULL;
13721         const uint8_t *randomizer256 = NULL;
13722 #endif
13723
13724         if (status != MGMT_STATUS_SUCCESS) {
13725                 btd_error(adapter->dev_id,
13726                                 "Read local OOB data failed: %s (0x%02x)",
13727                                                 mgmt_errstr(status), status);
13728                 hash = NULL;
13729                 randomizer = NULL;
13730 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13731         } else if (length < 32) {
13732 #else
13733         } else if (length < sizeof(*rp)) {
13734 #endif
13735                 btd_error(adapter->dev_id,
13736                                 "Too small read local OOB data response");
13737                 return;
13738         } else {
13739                 hash = rp->hash192;
13740                 randomizer = rp->rand192;
13741 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13742                 if (length > 32) {
13743                         hash256 = rp->hash256;
13744                         randomizer256 = rp->rand256;
13745                 }
13746 #endif
13747         }
13748
13749         if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
13750                 return;
13751
13752 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13753         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
13754                                         hash256, randomizer256,
13755                                         adapter->oob_handler->user_data);
13756 #else
13757         adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
13758                                         adapter->oob_handler->user_data);
13759 #endif
13760
13761         g_free(adapter->oob_handler);
13762         adapter->oob_handler = NULL;
13763 }
13764
13765 int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
13766 {
13767         DBG("hci%u", adapter->dev_id);
13768
13769         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_DATA,
13770                         adapter->dev_id, 0, NULL, read_local_oob_data_complete,
13771                         adapter, NULL) > 0)
13772                 return 0;
13773
13774         return -EIO;
13775 }
13776
13777 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13778 static void le_read_local_oob_data_complete(uint8_t status, uint16_t length,
13779                                         const void *param, void *user_data)
13780 {
13781         const struct mgmt_rp_read_local_oob_ext_data *rp = param;
13782         struct btd_adapter *adapter = user_data;
13783
13784         if (status != MGMT_STATUS_SUCCESS) {
13785                 btd_error(adapter->dev_id, "LE Read local OOB data failed: %s (0x%02x)",
13786                                                 mgmt_errstr(status), status);
13787         } else if (length < sizeof(struct mgmt_rp_read_local_oob_ext_data)) {
13788                 btd_error(adapter->dev_id,
13789                                 "Too small read local OOB ext data response");
13790                 return;
13791         }
13792
13793         if (!adapter->oob_handler || !adapter->oob_handler->le_read_local_cb) {
13794                 btd_error(adapter->dev_id, "oob_handler is not valid : %p",
13795                                 adapter->oob_handler);
13796                 return;
13797         }
13798
13799         adapter->oob_handler->le_read_local_cb(adapter, rp->eir_len, rp->eir,
13800                         adapter->oob_handler->user_data);
13801
13802         g_free(adapter->oob_handler);
13803         adapter->oob_handler = NULL;
13804 }
13805
13806 int btd_adapter_le_read_local_oob_data(struct btd_adapter *adapter)
13807 {
13808         struct mgmt_cp_read_local_oob_ext_data cp;
13809
13810         DBG("hci%u", adapter->dev_id);
13811
13812         memset(&cp, 0, sizeof(cp));
13813         cp.type = (1 << BDADDR_LE_PUBLIC) | (1 << BDADDR_LE_RANDOM);
13814
13815         if (mgmt_send(adapter->mgmt, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
13816                         adapter->dev_id, sizeof(cp), &cp, le_read_local_oob_data_complete,
13817                         adapter, NULL) > 0)
13818                 return 0;
13819
13820         return -EIO;
13821 }
13822 #endif
13823
13824 void btd_adapter_for_each_device(struct btd_adapter *adapter,
13825                         void (*cb)(struct btd_device *device, void *data),
13826                         void *data)
13827 {
13828         g_slist_foreach(adapter->devices, (GFunc) cb, data);
13829 }
13830
13831 static int adapter_cmp(gconstpointer a, gconstpointer b)
13832 {
13833         struct btd_adapter *adapter = (struct btd_adapter *) a;
13834         const bdaddr_t *bdaddr = b;
13835
13836         return bacmp(&adapter->bdaddr, bdaddr);
13837 }
13838
13839 static int adapter_id_cmp(gconstpointer a, gconstpointer b)
13840 {
13841         struct btd_adapter *adapter = (struct btd_adapter *) a;
13842         uint16_t id = GPOINTER_TO_UINT(b);
13843
13844         return adapter->dev_id == id ? 0 : -1;
13845 }
13846
13847 struct btd_adapter *adapter_find(const bdaddr_t *sba)
13848 {
13849         GSList *match;
13850
13851         match = g_slist_find_custom(adapters, sba, adapter_cmp);
13852         if (!match)
13853                 return NULL;
13854
13855         return match->data;
13856 }
13857
13858 struct btd_adapter *adapter_find_by_id(int id)
13859 {
13860         GSList *match;
13861
13862         match = g_slist_find_custom(adapters, GINT_TO_POINTER(id),
13863                                                         adapter_id_cmp);
13864         if (!match)
13865                 return NULL;
13866
13867         return match->data;
13868 }
13869
13870 void adapter_foreach(adapter_cb func, gpointer user_data)
13871 {
13872         g_slist_foreach(adapters, (GFunc) func, user_data);
13873 }
13874
13875 static int set_did(struct btd_adapter *adapter, uint16_t vendor,
13876                         uint16_t product, uint16_t version, uint16_t source)
13877 {
13878         struct mgmt_cp_set_device_id cp;
13879
13880         DBG("hci%u source %x vendor %x product %x version %x",
13881                         adapter->dev_id, source, vendor, product, version);
13882
13883         memset(&cp, 0, sizeof(cp));
13884
13885         cp.source = htobs(source);
13886         cp.vendor = htobs(vendor);
13887         cp.product = htobs(product);
13888         cp.version = htobs(version);
13889
13890         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEVICE_ID,
13891                                 adapter->dev_id, sizeof(cp), &cp,
13892                                 NULL, NULL, NULL) > 0)
13893                 return 0;
13894
13895         return -EIO;
13896 }
13897
13898 static void services_modified(struct gatt_db_attribute *attrib, void *user_data)
13899 {
13900         struct btd_adapter *adapter = user_data;
13901
13902         g_dbus_emit_property_changed(dbus_conn, adapter->path,
13903                                                 ADAPTER_INTERFACE, "UUIDs");
13904 }
13905
13906 static int adapter_register(struct btd_adapter *adapter)
13907 {
13908         struct agent *agent;
13909         struct gatt_db *db;
13910 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13911         char address[18] = { 0 };
13912         char filename[PATH_MAX] = { 0 };
13913 #endif
13914
13915         if (powering_down)
13916                 return -EBUSY;
13917
13918         adapter->path = g_strdup_printf("/org/bluez/hci%d", adapter->dev_id);
13919
13920         if (!g_dbus_register_interface(dbus_conn,
13921                                         adapter->path, ADAPTER_INTERFACE,
13922 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13923                                         adapter_methods, adapter_signals,
13924 #else
13925                                         adapter_methods, NULL,
13926 #endif
13927                                         adapter_properties, adapter,
13928                                         adapter_free)) {
13929                 btd_error(adapter->dev_id,
13930                                 "Adapter interface init failed on path %s",
13931                                                         adapter->path);
13932                 g_free(adapter->path);
13933                 adapter->path = NULL;
13934                 return -EINVAL;
13935         }
13936
13937         if (adapters == NULL)
13938                 adapter->is_default = true;
13939
13940         adapters = g_slist_append(adapters, adapter);
13941
13942         agent = agent_get(NULL);
13943         if (agent) {
13944                 uint8_t io_cap = agent_get_io_capability(agent);
13945                 adapter_set_io_capability(adapter, io_cap);
13946                 agent_unref(agent);
13947         }
13948
13949         /* Don't start GATT database and advertising managers on
13950          * non-LE controllers.
13951          */
13952         if (!(adapter->supported_settings & MGMT_SETTING_LE) ||
13953                                         main_opts.mode == BT_MODE_BREDR)
13954                 goto load;
13955
13956         adapter->database = btd_gatt_database_new(adapter);
13957         if (!adapter->database) {
13958                 btd_error(adapter->dev_id,
13959                                 "Failed to create GATT database for adapter");
13960                 adapters = g_slist_remove(adapters, adapter);
13961                 return -EINVAL;
13962         }
13963
13964         adapter->adv_manager = btd_adv_manager_new(adapter, adapter->mgmt);
13965
13966         db = btd_gatt_database_get_db(adapter->database);
13967         adapter->db_id = gatt_db_register(db, services_modified,
13968                                                         services_modified,
13969                                                         adapter, NULL);
13970
13971 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13972         ba2str(&adapter->bdaddr, address);
13973         snprintf(filename, PATH_MAX, STORAGEDIR "/%s", address);
13974         delete_tempfiles(filename);
13975 #endif
13976
13977 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
13978         adapter_print_devices(adapter);
13979
13980         if (load_local_irk(adapter)) {
13981                 if (!(adapter->supported_settings & MGMT_SETTING_PRIVACY))
13982                         main_opts.le_privacy = false;
13983
13984                 /*
13985                  * Some Android devices don't consider the device as LE one,
13986                  * if the device doesn't distribute IRK when pairing.
13987                  * Because of this compatibility issue, set IRK
13988                  * even though privacy feature is disabled.
13989                  */
13990                 set_local_irk(adapter);
13991
13992                 if (main_opts.le_privacy) {
13993                         DBG("Enable LE Privacy feature");
13994                         set_privacy(adapter, true);
13995                 } else {
13996                         DBG("Disable LE Privacy feature");
13997                 }
13998         }
13999 #endif
14000
14001 load:
14002         load_config(adapter);
14003         fix_storage(adapter);
14004         load_drivers(adapter);
14005         btd_profile_foreach(probe_profile, adapter);
14006         clear_blocked(adapter);
14007         load_devices(adapter);
14008
14009         /* restore Service Changed CCC value for bonded devices */
14010         btd_gatt_database_restore_svc_chng_ccc(adapter->database);
14011
14012         /* retrieve the active connections: address the scenario where
14013          * the are active connections before the daemon've started */
14014         if (adapter->current_settings & MGMT_SETTING_POWERED)
14015                 load_connections(adapter);
14016
14017         adapter->initialized = TRUE;
14018
14019         if (main_opts.did_source) {
14020                 /* DeviceID record is added by sdpd-server before any other
14021                  * record is registered. */
14022                 adapter_service_insert(adapter, sdp_record_find(0x10000));
14023                 set_did(adapter, main_opts.did_vendor, main_opts.did_product,
14024                                 main_opts.did_version, main_opts.did_source);
14025         }
14026
14027         DBG("Adapter %s registered", adapter->path);
14028
14029         return 0;
14030 }
14031
14032 static int adapter_unregister(struct btd_adapter *adapter)
14033 {
14034         DBG("Unregister path: %s", adapter->path);
14035
14036         adapters = g_slist_remove(adapters, adapter);
14037
14038         if (adapter->is_default && adapters != NULL) {
14039                 struct btd_adapter *new_default;
14040
14041                 new_default = adapter_find_by_id(hci_get_route(NULL));
14042                 if (new_default == NULL)
14043                         new_default = adapters->data;
14044
14045                 new_default->is_default = true;
14046         }
14047
14048         adapter_list = g_list_remove(adapter_list, adapter);
14049
14050         adapter_remove(adapter);
14051         btd_adapter_unref(adapter);
14052
14053         return 0;
14054 }
14055
14056 static void disconnected_callback(uint16_t index, uint16_t length,
14057                                         const void *param, void *user_data)
14058 {
14059         const struct mgmt_ev_device_disconnected *ev = param;
14060         struct btd_adapter *adapter = user_data;
14061         uint8_t reason;
14062
14063         if (length < sizeof(struct mgmt_addr_info)) {
14064                 btd_error(adapter->dev_id,
14065                                 "Too small device disconnected event");
14066                 return;
14067         }
14068
14069         if (length < sizeof(*ev))
14070                 reason = MGMT_DEV_DISCONN_UNKNOWN;
14071         else
14072                 reason = ev->reason;
14073
14074         dev_disconnected(adapter, &ev->addr, reason);
14075 }
14076
14077 static void connected_callback(uint16_t index, uint16_t length,
14078                                         const void *param, void *user_data)
14079 {
14080         const struct mgmt_ev_device_connected *ev = param;
14081         struct btd_adapter *adapter = user_data;
14082         struct btd_device *device;
14083         struct eir_data eir_data;
14084         uint16_t eir_len;
14085         char addr[18];
14086         bool name_known;
14087
14088         if (length < sizeof(*ev)) {
14089                 btd_error(adapter->dev_id, "Too small device connected event");
14090                 return;
14091         }
14092
14093         eir_len = btohs(ev->eir_len);
14094         if (length < sizeof(*ev) + eir_len) {
14095                 btd_error(adapter->dev_id, "Too small device connected event");
14096                 return;
14097         }
14098
14099         ba2str(&ev->addr.bdaddr, addr);
14100
14101         DBG("hci%u device %s connected eir_len %u", index, addr, eir_len);
14102
14103         device = btd_adapter_get_device(adapter, &ev->addr.bdaddr,
14104                                                                 ev->addr.type);
14105         if (!device) {
14106                 btd_error(adapter->dev_id,
14107                                 "Unable to get device object for %s", addr);
14108                 return;
14109         }
14110
14111         memset(&eir_data, 0, sizeof(eir_data));
14112         if (eir_len > 0)
14113                 eir_parse(&eir_data, ev->eir, eir_len);
14114
14115         if (eir_data.class != 0)
14116                 device_set_class(device, eir_data.class);
14117
14118         adapter_add_connection(adapter, device, ev->addr.type);
14119
14120         name_known = device_name_known(device);
14121
14122         if (eir_data.name && (eir_data.name_complete || !name_known)) {
14123                 device_store_cached_name(device, eir_data.name);
14124                 btd_device_device_set_name(device, eir_data.name);
14125         }
14126
14127         if (eir_data.msd_list)
14128                 adapter_msd_notify(adapter, device, eir_data.msd_list);
14129
14130         eir_data_free(&eir_data);
14131 }
14132
14133 static void device_blocked_callback(uint16_t index, uint16_t length,
14134                                         const void *param, void *user_data)
14135 {
14136         const struct mgmt_ev_device_blocked *ev = param;
14137         struct btd_adapter *adapter = user_data;
14138         struct btd_device *device;
14139         char addr[18];
14140
14141         if (length < sizeof(*ev)) {
14142                 btd_error(adapter->dev_id, "Too small device blocked event");
14143                 return;
14144         }
14145
14146         ba2str(&ev->addr.bdaddr, addr);
14147         DBG("hci%u %s blocked", index, addr);
14148
14149         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
14150                                                                 ev->addr.type);
14151         if (device)
14152                 device_block(device, TRUE);
14153 }
14154
14155 static void device_unblocked_callback(uint16_t index, uint16_t length,
14156                                         const void *param, void *user_data)
14157 {
14158         const struct mgmt_ev_device_unblocked *ev = param;
14159         struct btd_adapter *adapter = user_data;
14160         struct btd_device *device;
14161         char addr[18];
14162
14163         if (length < sizeof(*ev)) {
14164                 btd_error(adapter->dev_id, "Too small device unblocked event");
14165                 return;
14166         }
14167
14168         ba2str(&ev->addr.bdaddr, addr);
14169         DBG("hci%u %s unblocked", index, addr);
14170
14171         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
14172                                                                 ev->addr.type);
14173         if (device)
14174                 device_unblock(device, FALSE, TRUE);
14175 }
14176
14177 static void conn_fail_notify(struct btd_device *dev, uint8_t status)
14178 {
14179         GSList *l;
14180
14181         for (l = conn_fail_list; l; l = g_slist_next(l)) {
14182                 btd_conn_fail_cb conn_fail_cb = l->data;
14183                 conn_fail_cb(dev, status);
14184         }
14185 }
14186
14187 void btd_add_conn_fail_cb(btd_conn_fail_cb func)
14188 {
14189         conn_fail_list = g_slist_append(conn_fail_list, func);
14190 }
14191
14192 void btd_remove_conn_fail_cb(btd_conn_fail_cb func)
14193 {
14194         conn_fail_list = g_slist_remove(conn_fail_list, func);
14195 }
14196
14197 static void connect_failed_callback(uint16_t index, uint16_t length,
14198                                         const void *param, void *user_data)
14199 {
14200         const struct mgmt_ev_connect_failed *ev = param;
14201         struct btd_adapter *adapter = user_data;
14202         struct btd_device *device;
14203         char addr[18];
14204
14205         if (length < sizeof(*ev)) {
14206                 btd_error(adapter->dev_id, "Too small connect failed event");
14207                 return;
14208         }
14209
14210         ba2str(&ev->addr.bdaddr, addr);
14211
14212         DBG("hci%u %s status %u", index, addr, ev->status);
14213
14214         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
14215                                                                 ev->addr.type);
14216         if (device) {
14217                 conn_fail_notify(device, ev->status);
14218
14219                 /* If the device is in a bonding process cancel any auth request
14220                  * sent to the agent before proceeding, but keep the bonding
14221                  * request structure. */
14222                 if (device_is_bonding(device, NULL))
14223                         device_cancel_authentication(device, FALSE);
14224         }
14225
14226         /* In the case of security mode 3 devices */
14227         bonding_attempt_complete(adapter, &ev->addr.bdaddr, ev->addr.type,
14228                                                                 ev->status);
14229
14230         /* If the device is scheduled to retry the bonding wait until the retry
14231          * happens. In other case, proceed with cancel the bondig.
14232          */
14233         if (device && device_is_bonding(device, NULL)
14234                                         && !device_is_retrying(device)) {
14235                 device_cancel_authentication(device, TRUE);
14236                 device_bonding_failed(device, ev->status);
14237         }
14238
14239 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
14240         /* In the case the bonding was canceled or did exists, remove the device
14241          * when it is temporary. */
14242         if (device && !device_is_bonding(device, NULL)
14243                                                 && device_is_temporary(device))
14244                 btd_adapter_remove_device(adapter, device);
14245 #endif
14246 }
14247
14248 static void remove_keys(struct btd_adapter *adapter,
14249                                         struct btd_device *device, uint8_t type)
14250 {
14251         char device_addr[18];
14252         char filename[PATH_MAX];
14253         GKeyFile *key_file;
14254         gsize length = 0;
14255         char *str;
14256
14257         ba2str(device_get_address(device), device_addr);
14258
14259 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14260         if (device_get_rpa_exist(device) == true)
14261                 ba2str(device_get_rpa(device), device_addr);
14262 #endif
14263
14264         snprintf(filename, PATH_MAX, STORAGEDIR "/%s/%s/info",
14265                         btd_adapter_get_storage_dir(adapter), device_addr);
14266         key_file = g_key_file_new();
14267         g_key_file_load_from_file(key_file, filename, 0, NULL);
14268
14269         if (type == BDADDR_BREDR) {
14270                 g_key_file_remove_group(key_file, "LinkKey", NULL);
14271         } else {
14272                 g_key_file_remove_group(key_file, "LongTermKey", NULL);
14273                 g_key_file_remove_group(key_file, "LocalSignatureKey", NULL);
14274                 g_key_file_remove_group(key_file, "RemoteSignatureKey", NULL);
14275                 g_key_file_remove_group(key_file, "IdentityResolvingKey", NULL);
14276         }
14277
14278         str = g_key_file_to_data(key_file, &length, NULL);
14279         g_file_set_contents(filename, str, length, NULL);
14280         g_free(str);
14281
14282         g_key_file_free(key_file);
14283 }
14284
14285 static void unpaired_callback(uint16_t index, uint16_t length,
14286                                         const void *param, void *user_data)
14287 {
14288         const struct mgmt_ev_device_unpaired *ev = param;
14289         struct btd_adapter *adapter = user_data;
14290         struct btd_device *device;
14291         char addr[18];
14292
14293         if (length < sizeof(*ev)) {
14294                 btd_error(adapter->dev_id, "Too small device unpaired event");
14295                 return;
14296         }
14297
14298         ba2str(&ev->addr.bdaddr, addr);
14299
14300         DBG("hci%u addr %s", index, addr);
14301
14302         device = btd_adapter_find_device(adapter, &ev->addr.bdaddr,
14303                                                                 ev->addr.type);
14304         if (!device) {
14305                 btd_warn(adapter->dev_id,
14306                         "No device object for unpaired device %s", addr);
14307                 return;
14308         }
14309
14310         remove_keys(adapter, device, ev->addr.type);
14311         device_set_unpaired(device, ev->addr.type);
14312 }
14313
14314 static void clear_devices_complete(uint8_t status, uint16_t length,
14315                                         const void *param, void *user_data)
14316 {
14317         if (status != MGMT_STATUS_SUCCESS) {
14318                 error("Failed to clear devices: %s (0x%02x)",
14319                                                 mgmt_errstr(status), status);
14320                 return;
14321         }
14322 }
14323
14324 static int clear_devices(struct btd_adapter *adapter)
14325 {
14326         struct mgmt_cp_remove_device cp;
14327
14328         if (!kernel_conn_control)
14329                 return 0;
14330
14331         memset(&cp, 0, sizeof(cp));
14332
14333         DBG("sending clear devices command for index %u", adapter->dev_id);
14334
14335         if (mgmt_send(adapter->mgmt, MGMT_OP_REMOVE_DEVICE,
14336                                 adapter->dev_id, sizeof(cp), &cp,
14337                                 clear_devices_complete, adapter, NULL) > 0)
14338                 return 0;
14339
14340         btd_error(adapter->dev_id, "Failed to clear devices for index %u",
14341                                                         adapter->dev_id);
14342
14343         return -EIO;
14344 }
14345
14346 static bool get_static_addr(struct btd_adapter *adapter)
14347 {
14348         struct bt_crypto *crypto;
14349         GKeyFile *file;
14350         char **addrs;
14351         char mfg[7];
14352         char *str;
14353         bool ret;
14354         gsize len, i;
14355
14356         snprintf(mfg, sizeof(mfg), "0x%04x", adapter->manufacturer);
14357
14358         file = g_key_file_new();
14359         g_key_file_load_from_file(file, STORAGEDIR "/addresses", 0, NULL);
14360         addrs = g_key_file_get_string_list(file, "Static", mfg, &len, NULL);
14361         if (addrs) {
14362                 for (i = 0; i < len; i++) {
14363                         bdaddr_t addr;
14364
14365                         str2ba(addrs[i], &addr);
14366                         if (adapter_find(&addr))
14367                                 continue;
14368
14369                         /* Usable address found in list */
14370                         bacpy(&adapter->bdaddr, &addr);
14371                         adapter->bdaddr_type = BDADDR_LE_RANDOM;
14372                         ret = true;
14373                         goto done;
14374                 }
14375
14376                 len++;
14377                 addrs = g_renew(char *, addrs, len + 1);
14378         } else {
14379                 len = 1;
14380                 addrs = g_new(char *, len + 1);
14381         }
14382
14383         /* Initialize slot for new address */
14384         addrs[len - 1] = g_malloc(18);
14385         addrs[len] = NULL;
14386
14387         crypto = bt_crypto_new();
14388         if (!crypto) {
14389                 error("Failed to open crypto");
14390                 ret = false;
14391                 goto done;
14392         }
14393
14394         ret = bt_crypto_random_bytes(crypto, &adapter->bdaddr,
14395                                                 sizeof(adapter->bdaddr));
14396         if (!ret) {
14397                 error("Failed to generate static address");
14398                 bt_crypto_unref(crypto);
14399                 goto done;
14400         }
14401
14402         bt_crypto_unref(crypto);
14403
14404         adapter->bdaddr.b[5] |= 0xc0;
14405         adapter->bdaddr_type = BDADDR_LE_RANDOM;
14406
14407         ba2str(&adapter->bdaddr, addrs[len - 1]);
14408
14409         g_key_file_set_string_list(file, "Static", mfg,
14410                                                 (const char **)addrs, len);
14411
14412         str = g_key_file_to_data(file, &len, NULL);
14413         g_file_set_contents(STORAGEDIR "/addresses", str, len, NULL);
14414         g_free(str);
14415
14416         ret = true;
14417
14418 done:
14419         g_key_file_free(file);
14420         g_strfreev(addrs);
14421
14422         return ret;
14423 }
14424
14425 static bool set_static_addr(struct btd_adapter *adapter)
14426 {
14427         struct mgmt_cp_set_static_address cp;
14428
14429         /* dual-mode adapters must have a public address */
14430         if (adapter->supported_settings & MGMT_SETTING_BREDR)
14431                 return false;
14432
14433         if (!(adapter->supported_settings & MGMT_SETTING_LE))
14434                 return false;
14435
14436         DBG("Setting static address");
14437
14438         if (!get_static_addr(adapter))
14439                 return false;
14440
14441         bacpy(&cp.bdaddr, &adapter->bdaddr);
14442         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STATIC_ADDRESS,
14443                                 adapter->dev_id, sizeof(cp), &cp,
14444                                 NULL, NULL, NULL) > 0) {
14445                 return true;
14446         }
14447
14448         return false;
14449 }
14450
14451 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14452 static uint8_t *generate_irk(void)
14453 {
14454         int fd;
14455         uint8_t *irk;
14456
14457         DBG("Generate IRK");
14458
14459         fd = open("/dev/urandom", O_RDONLY);
14460         if (fd < 0)
14461                 return NULL;
14462
14463         irk = g_malloc0(MGMT_IRK_SIZE);
14464         if (read(fd, irk, MGMT_IRK_SIZE) != MGMT_IRK_SIZE) {
14465                 error("Cannot read random bytes");
14466                 g_free(irk);
14467                 close(fd);
14468                 return NULL;
14469         }
14470         close(fd);
14471
14472         return irk;
14473 }
14474
14475 #define LOCAL_IRK_DIRNAME       "/csa/bluetooth"
14476 #define LOCAL_IRK_FILENAME      ".local_irk"
14477
14478 static bool store_local_irk(struct btd_adapter *adapter)
14479 {
14480         int fd;
14481         int ret;
14482
14483         if (adapter->local_irk == NULL) {
14484                 error("Local IRK is not proper");
14485                 return false;
14486         }
14487
14488         if (access(LOCAL_IRK_DIRNAME, F_OK) < 0) {
14489                 if (mkdir(LOCAL_IRK_DIRNAME, 0755) < 0) {
14490                         error("Cannot create a directory for local IRK : %s",
14491                                         strerror(errno));
14492                         return false;
14493                 }
14494         }
14495
14496         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME,
14497                         O_WRONLY | O_CREAT | O_TRUNC, 0644);
14498         if (fd < 0) {
14499                 error("Cannot open a file for local IRK : %s", strerror(errno));
14500                 return false;
14501         }
14502
14503         ret = write(fd, adapter->local_irk, MGMT_IRK_SIZE);
14504         if (ret != MGMT_IRK_SIZE) {
14505                 error("Cannot write local IRK [%d] : %s", ret, strerror(errno));
14506
14507                 close(fd);
14508                 unlink(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME);
14509                 return false;
14510         }
14511
14512         ret = fdatasync(fd);
14513         if (ret < 0)
14514                 error("sync failed : %s", strerror(errno));
14515
14516         close(fd);
14517         return true;
14518 }
14519
14520 static bool load_local_irk(struct btd_adapter *adapter)
14521 {
14522         int fd;
14523         int ret;
14524
14525         if (access(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, F_OK) < 0) {
14526                 adapter->local_irk = generate_irk();
14527                 if (store_local_irk(adapter) == false) {
14528                         error("Cannot store Local IRK");
14529                         g_free(adapter->local_irk);
14530                         return false;
14531                 }
14532
14533                 return true;
14534         }
14535
14536         if (adapter->local_irk) {
14537                 DBG("Local IRK is already loaded");
14538                 return true;
14539         }
14540
14541         fd = open(LOCAL_IRK_DIRNAME"/"LOCAL_IRK_FILENAME, O_RDONLY);
14542         if (fd < 0) {
14543                 error("Cannot open local IRK file : %s", strerror(errno));
14544                 return false;
14545         }
14546
14547         adapter->local_irk = g_malloc0(MGMT_IRK_SIZE);
14548
14549         ret = read(fd, adapter->local_irk, MGMT_IRK_SIZE);
14550         if (ret != MGMT_IRK_SIZE) {
14551                 error("Cannot read local IRK [%d] : %s", ret, strerror(errno));
14552                 g_free(adapter->local_irk);
14553                 close(fd);
14554                 return false;
14555         }
14556
14557         close(fd);
14558         return true;
14559 }
14560
14561 static void set_privacy_complete(uint8_t status, uint16_t length,
14562         const void *param, void *user_data)
14563 {
14564         struct btd_adapter *adapter = user_data;
14565
14566         if (status != MGMT_STATUS_SUCCESS)
14567                 error("Setting privacy failed for hci%u: %s (0x%02x)",
14568                         adapter->dev_id, mgmt_errstr(status), status);
14569         else
14570                 DBG("Privacy feature is set/unset successfully for hci%u",
14571                         adapter->dev_id);
14572 }
14573
14574 static bool set_privacy(struct btd_adapter *adapter, bool privacy)
14575 {
14576         struct mgmt_cp_set_privacy cp;
14577
14578         if (!adapter->local_irk) {
14579                 error("Local IRK is not available");
14580                 return false;
14581         }
14582
14583         memset(&cp, 0, sizeof(cp));
14584         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
14585
14586         if (privacy)
14587                 cp.privacy = 0x01;
14588
14589         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_PRIVACY,
14590                                 adapter->dev_id, sizeof(cp), &cp,
14591                                 set_privacy_complete, adapter, NULL) > 0)
14592                 return true;
14593
14594         error("Failed to set privacy and load local irk for index %u",
14595                         adapter->dev_id);
14596         return false;
14597 }
14598
14599 static void set_irk_complete(uint8_t status, uint16_t length,
14600                 const void *param, void *user_data)
14601 {
14602         struct btd_adapter *adapter = user_data;
14603
14604         if (status != MGMT_STATUS_SUCCESS)
14605                 error("Setting IRK is failed for hci%u: %s (0x%02x)",
14606                         adapter->dev_id, mgmt_errstr(status), status);
14607         else
14608                 DBG("Setting IRK is succeed for hci%u", adapter->dev_id);
14609 }
14610
14611 static bool set_local_irk(struct btd_adapter *adapter)
14612 {
14613         struct mgmt_cp_set_irk cp;
14614
14615         if (!adapter->local_irk) {
14616                 error("Local IRK is not available");
14617                 return false;
14618         }
14619
14620         memcpy(cp.irk, adapter->local_irk, MGMT_IRK_SIZE);
14621
14622         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_IRK,
14623                                 adapter->dev_id, sizeof(cp), &cp,
14624                                 set_irk_complete, adapter, NULL) > 0)
14625                 return true;
14626
14627         error("Failed to set irk %u", adapter->dev_id);
14628         return false;
14629 }
14630
14631 int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
14632                                                 const bdaddr_t *bdaddr,
14633                                                 uint8_t bdaddr_type)
14634
14635 {
14636         struct mgmt_cp_connect_6lowpan cp;
14637
14638         memset(&cp, 0, sizeof(cp));
14639         bacpy(&cp.addr.bdaddr, bdaddr);
14640         cp.addr.type = bdaddr_type;
14641
14642         if (mgmt_send(adapter->mgmt, MGMT_OP_CONNECT_6LOWPAN,
14643                                 adapter->dev_id, sizeof(cp), &cp,
14644                                 NULL, NULL, NULL) > 0)
14645                 return 0;
14646
14647         return -EIO;
14648 }
14649
14650 int btd_adapter_disconnect_ipsp(struct btd_adapter *adapter,
14651                                                 const bdaddr_t *bdaddr,
14652                                                 uint8_t bdaddr_type)
14653
14654 {
14655         struct mgmt_cp_disconnect_6lowpan cp;
14656
14657         memset(&cp, 0, sizeof(cp));
14658         bacpy(&cp.addr.bdaddr, bdaddr);
14659         cp.addr.type = bdaddr_type;
14660
14661         if (mgmt_send(adapter->mgmt, MGMT_OP_DISCONNECT_6LOWPAN,
14662                                 adapter->dev_id, sizeof(cp), &cp,
14663                                 NULL, NULL, NULL) > 0)
14664                 return 0;
14665
14666         return -EIO;
14667 }
14668
14669 uint8_t btd_adapter_get_rpa_res_support_value(
14670                 struct btd_adapter *adapter)
14671 {
14672         return adapter->central_rpa_res_support;
14673 }
14674
14675 static void set_dev_rpa_res_support_complete(uint8_t status,
14676                                         uint16_t length, const void *param,
14677                                         void *user_data)
14678 {
14679         if (status != MGMT_STATUS_SUCCESS)
14680                 error("Failed to set RPA resolution support of device : %s (0x%02x)",
14681                                                 mgmt_errstr(status), status);
14682         else
14683                 DBG("Set RPA resolution support successful");
14684 }
14685
14686 int btd_adapter_set_dev_rpa_res_support(struct btd_adapter *adapter,
14687                                         struct btd_device *device)
14688
14689 {
14690         struct mgmt_cp_set_dev_rpa_res_support cp;
14691
14692         DBG("btd_adapter_set_dev_rpa_res_support called");
14693
14694         memset(&cp, 0, sizeof(cp));
14695
14696         bacpy(&cp.addr.bdaddr, device_get_address(device));
14697         cp.addr.type = btd_device_get_bdaddr_type(device);
14698         cp.res_support = device_get_rpa_res_char_value(device);
14699
14700         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_DEV_RPA_RES_SUPPORT,
14701                                 adapter->dev_id, sizeof(cp), &cp,
14702                                 set_dev_rpa_res_support_complete, NULL, NULL) > 0)
14703                 return 0;
14704
14705         return -EIO;
14706 }
14707 #endif
14708
14709 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14710 static gboolean adapter_start_idle_cb(gpointer user_data)
14711 {
14712         struct btd_adapter *adapter = (struct btd_adapter*)user_data;
14713
14714         adapter_start(adapter);
14715
14716         return FALSE;
14717 }
14718 #endif
14719
14720 static void read_info_complete(uint8_t status, uint16_t length,
14721                                         const void *param, void *user_data)
14722 {
14723         struct btd_adapter *adapter = user_data;
14724         const struct mgmt_rp_read_info *rp = param;
14725         uint32_t missing_settings;
14726         int err;
14727
14728         DBG("index %u status 0x%02x", adapter->dev_id, status);
14729
14730         if (status != MGMT_STATUS_SUCCESS) {
14731                 btd_error(adapter->dev_id,
14732                                 "Failed to read info for index %u: %s (0x%02x)",
14733                                 adapter->dev_id, mgmt_errstr(status), status);
14734                 goto failed;
14735         }
14736
14737         if (length < sizeof(*rp)) {
14738                 btd_error(adapter->dev_id,
14739                                 "Too small read info complete response");
14740                 goto failed;
14741         }
14742
14743         /*
14744          * Store controller information for class of device, device
14745          * name, short name and settings.
14746          *
14747          * During the lifetime of the controller these will be updated by
14748          * events and the information is required to keep the current
14749          * state of the controller.
14750          */
14751         adapter->dev_class = rp->dev_class[0] | (rp->dev_class[1] << 8) |
14752                                                 (rp->dev_class[2] << 16);
14753         adapter->name = g_strdup((const char *) rp->name);
14754         adapter->short_name = g_strdup((const char *) rp->short_name);
14755
14756         adapter->manufacturer = btohs(rp->manufacturer);
14757
14758         adapter->supported_settings = btohl(rp->supported_settings);
14759         adapter->current_settings = btohl(rp->current_settings);
14760
14761 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14762         adapter_check_version(adapter, rp->version);
14763 #endif
14764         clear_uuids(adapter);
14765         clear_devices(adapter);
14766
14767         if (bacmp(&rp->bdaddr, BDADDR_ANY) == 0) {
14768                 if (!set_static_addr(adapter)) {
14769                         btd_error(adapter->dev_id,
14770                                         "No Bluetooth address for index %u",
14771                                         adapter->dev_id);
14772                         goto failed;
14773                 }
14774         } else {
14775                 bacpy(&adapter->bdaddr, &rp->bdaddr);
14776                 if (!(adapter->supported_settings & MGMT_SETTING_LE))
14777                         adapter->bdaddr_type = BDADDR_BREDR;
14778                 else
14779                         adapter->bdaddr_type = BDADDR_LE_PUBLIC;
14780         }
14781
14782         missing_settings = adapter->current_settings ^
14783                                                 adapter->supported_settings;
14784
14785 /* If adapter supports PHY CONFIGURATION SETTING, then read PHY configuration and save them */
14786 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14787         if (adapter->supported_settings & MGMT_SETTING_PHY_CONFIGURATION) {
14788                 if (mgmt_send(adapter->mgmt, MGMT_OP_GET_PHY_CONFIGURATION, adapter->dev_id, 0, NULL,
14789                                         get_phy_configuration_resp, adapter, NULL) == 0)
14790                         error("Unable to send %s cmd",
14791                                         mgmt_opstr(MGMT_OP_GET_PHY_CONFIGURATION));
14792         }
14793 #endif
14794         switch (main_opts.mode) {
14795         case BT_MODE_DUAL:
14796                 if (missing_settings & MGMT_SETTING_SSP) {
14797 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14798                         if (main_opts.pin_code || (main_opts.class & 0x1f00) >> 8 == 0x05)
14799                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
14800                         else
14801 #endif
14802                                 set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
14803                 }
14804                 if (missing_settings & MGMT_SETTING_LE)
14805                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
14806                 if (missing_settings & MGMT_SETTING_BREDR)
14807                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
14808                 break;
14809         case BT_MODE_BREDR:
14810                 if (!(adapter->supported_settings & MGMT_SETTING_BREDR)) {
14811                         btd_error(adapter->dev_id,
14812                                 "Ignoring adapter withouth BR/EDR support");
14813                         goto failed;
14814                 }
14815
14816 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14817                 if (main_opts.pin_code || (main_opts.class & 0x1f00) >> 8 == 0x05)
14818                         set_mode(adapter, MGMT_OP_SET_SSP, 0x00);
14819                 else
14820                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
14821 #else
14822                 if (missing_settings & MGMT_SETTING_SSP)
14823                         set_mode(adapter, MGMT_OP_SET_SSP, 0x01);
14824 #endif
14825                 if (missing_settings & MGMT_SETTING_BREDR)
14826                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x01);
14827                 if (adapter->current_settings & MGMT_SETTING_LE)
14828                         set_mode(adapter, MGMT_OP_SET_LE, 0x00);
14829                 break;
14830         case BT_MODE_LE:
14831                 if (!(adapter->supported_settings & MGMT_SETTING_LE)) {
14832                         btd_error(adapter->dev_id,
14833                                 "Ignoring adapter withouth LE support");
14834                         goto failed;
14835                 }
14836
14837                 if (missing_settings & MGMT_SETTING_LE)
14838                         set_mode(adapter, MGMT_OP_SET_LE, 0x01);
14839                 if (adapter->current_settings & MGMT_SETTING_BREDR)
14840                         set_mode(adapter, MGMT_OP_SET_BREDR, 0x00);
14841                 break;
14842         }
14843
14844         if (missing_settings & MGMT_SETTING_SECURE_CONN)
14845                 set_mode(adapter, MGMT_OP_SET_SECURE_CONN, 0x01);
14846
14847         if (adapter->supported_settings & MGMT_SETTING_PRIVACY)
14848                 set_privacy(adapter, main_opts.privacy);
14849
14850         if (main_opts.fast_conn &&
14851                         (missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
14852                 set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
14853
14854 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14855         /* Set the RPA resolution value to '1' if privacy is supported */
14856         if (main_opts.le_privacy &&
14857                         adapter->supported_settings & MGMT_SETTING_PRIVACY)
14858                 adapter->central_rpa_res_support = 0x01;
14859 #endif
14860
14861         err = adapter_register(adapter);
14862         if (err < 0) {
14863                 btd_error(adapter->dev_id, "Unable to register new adapter");
14864                 goto failed;
14865         }
14866
14867         /*
14868          * Register all event notification handlers for controller.
14869          *
14870          * The handlers are registered after a succcesful read of the
14871          * controller info. From now on they can track updates and
14872          * notifications.
14873          */
14874         mgmt_register(adapter->mgmt, MGMT_EV_NEW_SETTINGS, adapter->dev_id,
14875                                         new_settings_callback, adapter, NULL);
14876
14877         mgmt_register(adapter->mgmt, MGMT_EV_CLASS_OF_DEV_CHANGED,
14878                                                 adapter->dev_id,
14879                                                 dev_class_changed_callback,
14880                                                 adapter, NULL);
14881         mgmt_register(adapter->mgmt, MGMT_EV_LOCAL_NAME_CHANGED,
14882                                                 adapter->dev_id,
14883                                                 local_name_changed_callback,
14884                                                 adapter, NULL);
14885
14886         mgmt_register(adapter->mgmt, MGMT_EV_DISCOVERING,
14887                                                 adapter->dev_id,
14888                                                 discovering_callback,
14889                                                 adapter, NULL);
14890
14891         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_FOUND,
14892                                                 adapter->dev_id,
14893                                                 device_found_callback,
14894                                                 adapter, NULL);
14895
14896 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14897         mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
14898                                                 adapter->dev_id,
14899                                                 le_device_found_callback,
14900                                                 adapter, NULL);
14901 #endif
14902
14903         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_DISCONNECTED,
14904                                                 adapter->dev_id,
14905                                                 disconnected_callback,
14906                                                 adapter, NULL);
14907
14908         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_CONNECTED,
14909                                                 adapter->dev_id,
14910                                                 connected_callback,
14911                                                 adapter, NULL);
14912
14913         mgmt_register(adapter->mgmt, MGMT_EV_CONNECT_FAILED,
14914                                                 adapter->dev_id,
14915                                                 connect_failed_callback,
14916                                                 adapter, NULL);
14917
14918         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNPAIRED,
14919                                                 adapter->dev_id,
14920                                                 unpaired_callback,
14921                                                 adapter, NULL);
14922
14923         mgmt_register(adapter->mgmt, MGMT_EV_AUTH_FAILED,
14924                                                 adapter->dev_id,
14925                                                 auth_failed_callback,
14926                                                 adapter, NULL);
14927
14928         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LINK_KEY,
14929                                                 adapter->dev_id,
14930                                                 new_link_key_callback,
14931                                                 adapter, NULL);
14932
14933         mgmt_register(adapter->mgmt, MGMT_EV_NEW_LONG_TERM_KEY,
14934                                                 adapter->dev_id,
14935                                                 new_long_term_key_callback,
14936                                                 adapter, NULL);
14937
14938         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CSRK,
14939                                                 adapter->dev_id,
14940                                                 new_csrk_callback,
14941                                                 adapter, NULL);
14942
14943         mgmt_register(adapter->mgmt, MGMT_EV_NEW_IRK,
14944                                                 adapter->dev_id,
14945                                                 new_irk_callback,
14946                                                 adapter, NULL);
14947
14948         mgmt_register(adapter->mgmt, MGMT_EV_NEW_CONN_PARAM,
14949                                                 adapter->dev_id,
14950                                                 new_conn_param,
14951                                                 adapter, NULL);
14952
14953         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
14954                                                 adapter->dev_id,
14955                                                 device_blocked_callback,
14956                                                 adapter, NULL);
14957         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_UNBLOCKED,
14958                                                 adapter->dev_id,
14959                                                 device_unblocked_callback,
14960                                                 adapter, NULL);
14961
14962         mgmt_register(adapter->mgmt, MGMT_EV_PIN_CODE_REQUEST,
14963                                                 adapter->dev_id,
14964                                                 pin_code_request_callback,
14965                                                 adapter, NULL);
14966
14967         mgmt_register(adapter->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
14968                                                 adapter->dev_id,
14969                                                 user_confirm_request_callback,
14970                                                 adapter, NULL);
14971
14972         mgmt_register(adapter->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
14973                                                 adapter->dev_id,
14974                                                 user_passkey_request_callback,
14975                                                 adapter, NULL);
14976
14977         mgmt_register(adapter->mgmt, MGMT_EV_PASSKEY_NOTIFY,
14978                                                 adapter->dev_id,
14979                                                 user_passkey_notify_callback,
14980                                                 adapter, NULL);
14981
14982 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
14983         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
14984                                                 adapter->dev_id,
14985                                                 rssi_alert_callback,
14986                                                 adapter, NULL);
14987
14988         mgmt_register(adapter->mgmt, MGMT_EV_RAW_RSSI,
14989                                                 adapter->dev_id,
14990                                                 get_raw_rssi_callback,
14991                                                 adapter, NULL);
14992
14993         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ENABLED,
14994                                                         adapter->dev_id,
14995                                                         rssi_enabled_callback,
14996                                                         adapter, NULL);
14997
14998         mgmt_register(adapter->mgmt, MGMT_EV_RSSI_DISABLED,
14999                                                         adapter->dev_id,
15000                                                         rssi_disabled_callback,
15001                                                         adapter, NULL);
15002
15003         mgmt_register(adapter->mgmt, MGMT_EV_HARDWARE_ERROR,
15004                                                 adapter->dev_id,
15005                                                 hardware_error_callback,
15006                                                 adapter, NULL);
15007
15008         mgmt_register(adapter->mgmt, MGMT_EV_TX_TIMEOUT_ERROR,
15009                                                 adapter->dev_id,
15010                                                 tx_timeout_error_callback,
15011                                                 adapter, NULL);
15012
15013         mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_NAME_UPDATE,
15014                                         adapter->dev_id,
15015                                         device_name_update_callback,
15016                                         adapter, NULL);
15017
15018         mgmt_register(adapter->mgmt, MGMT_EV_MULTI_ADV_STATE_CHANGED,
15019                                         adapter->dev_id,
15020                                         multi_adv_state_change_callback,
15021                                         adapter, NULL);
15022
15023         mgmt_register(adapter->mgmt, MGMT_EV_6LOWPAN_CONN_STATE_CHANGED,
15024                                                 adapter->dev_id,
15025                                                 bt_6lowpan_conn_state_change_callback,
15026                                                 adapter, NULL);
15027
15028         mgmt_register(adapter->mgmt, MGMT_EV_LE_DATA_LENGTH_CHANGED,
15029                                                 adapter->dev_id,
15030                                                 bt_le_data_length_changed_callback,
15031                                                 adapter, NULL);
15032
15033         mgmt_register(adapter->mgmt, MGMT_EV_CONN_UPDATED,
15034                                         adapter->dev_id,
15035                                         le_conn_update_completed_callback,
15036                                         adapter, NULL);
15037
15038         mgmt_register(adapter->mgmt, MGMT_EV_RPA_CHANGED,
15039                                         adapter->dev_id,
15040                                         rpa_changed_callback,
15041                                         adapter, NULL);
15042 #endif
15043
15044         set_dev_class(adapter);
15045
15046         set_name(adapter, btd_adapter_get_name(adapter));
15047
15048         if (main_opts.pairable &&
15049                         !(adapter->current_settings & MGMT_SETTING_BONDABLE))
15050                 set_mode(adapter, MGMT_OP_SET_BONDABLE, 0x01);
15051
15052         if (!kernel_conn_control)
15053                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x01);
15054         else if (adapter->current_settings & MGMT_SETTING_CONNECTABLE)
15055                 set_mode(adapter, MGMT_OP_SET_CONNECTABLE, 0x00);
15056
15057         if (adapter->stored_discoverable && !adapter->discoverable_timeout)
15058                 set_discoverable(adapter, 0x01, 0);
15059
15060         if (adapter->current_settings & MGMT_SETTING_POWERED)
15061 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15062                 g_idle_add(adapter_start_idle_cb, adapter);
15063 #else
15064                 adapter_start(adapter);
15065 #endif
15066 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15067         else
15068                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
15069 #endif
15070
15071 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15072         init_le_static_address(adapter);
15073 #endif
15074
15075         return;
15076
15077 failed:
15078         /*
15079          * Remove adapter from list in case of a failure.
15080          *
15081          * Leaving an adapter structure around for a controller that can
15082          * not be initilized makes no sense at the moment.
15083          *
15084          * This is a simplification to avoid constant checks if the
15085          * adapter is ready to do anything.
15086          */
15087         adapter_list = g_list_remove(adapter_list, adapter);
15088
15089         btd_adapter_unref(adapter);
15090 }
15091
15092 static void index_added(uint16_t index, uint16_t length, const void *param,
15093                                                         void *user_data)
15094 {
15095         struct btd_adapter *adapter;
15096
15097         DBG("index %u", index);
15098
15099         adapter = btd_adapter_lookup(index);
15100         if (adapter) {
15101                 btd_warn(adapter->dev_id,
15102                         "Ignoring index added for an already existing adapter");
15103                 return;
15104         }
15105
15106         adapter = btd_adapter_new(index);
15107         if (!adapter) {
15108                 btd_error(index,
15109                         "Unable to create new adapter for index %u", index);
15110                 return;
15111         }
15112
15113         /*
15114          * Protect against potential two executions of read controller info.
15115          *
15116          * In case the start of the daemon and the action of adding a new
15117          * controller coincide this function might be called twice.
15118          *
15119          * To avoid the double execution of reading the controller info,
15120          * add the adapter already to the list. If an adapter is already
15121          * present, the second notification will cause a warning. If the
15122          * command fails the adapter is removed from the list again.
15123          */
15124         adapter_list = g_list_append(adapter_list, adapter);
15125
15126         DBG("sending read info command for index %u", index);
15127
15128         if (mgmt_send(mgmt_master, MGMT_OP_READ_INFO, index, 0, NULL,
15129                                         read_info_complete, adapter, NULL) > 0)
15130                 return;
15131
15132         btd_error(adapter->dev_id,
15133                         "Failed to read controller info for index %u", index);
15134
15135         adapter_list = g_list_remove(adapter_list, adapter);
15136
15137         btd_adapter_unref(adapter);
15138 }
15139
15140 static void index_removed(uint16_t index, uint16_t length, const void *param,
15141                                                         void *user_data)
15142 {
15143         struct btd_adapter *adapter;
15144
15145         DBG("index %u", index);
15146
15147         adapter = btd_adapter_lookup(index);
15148         if (!adapter) {
15149                 warn("Ignoring index removal for a non-existent adapter");
15150                 return;
15151         }
15152
15153         adapter_unregister(adapter);
15154 }
15155
15156 static void read_index_list_complete(uint8_t status, uint16_t length,
15157                                         const void *param, void *user_data)
15158 {
15159         const struct mgmt_rp_read_index_list *rp = param;
15160         uint16_t num;
15161         int i;
15162
15163         if (status != MGMT_STATUS_SUCCESS) {
15164                 error("Failed to read index list: %s (0x%02x)",
15165                                                 mgmt_errstr(status), status);
15166                 return;
15167         }
15168
15169         if (length < sizeof(*rp)) {
15170                 error("Wrong size of read index list response");
15171                 return;
15172         }
15173
15174         num = btohs(rp->num_controllers);
15175
15176         DBG("Number of controllers: %d", num);
15177
15178         if (num * sizeof(uint16_t) + sizeof(*rp) != length) {
15179                 error("Incorrect packet size for index list response");
15180                 return;
15181         }
15182
15183         for (i = 0; i < num; i++) {
15184                 uint16_t index;
15185
15186                 index = btohs(rp->index[i]);
15187
15188                 DBG("Found index %u", index);
15189
15190                 /*
15191                  * Pretend to be index added event notification.
15192                  *
15193                  * It is safe to just trigger the procedure for index
15194                  * added notification. It does check against itself.
15195                  */
15196                 index_added(index, 0, NULL, NULL);
15197         }
15198 }
15199
15200 static void read_commands_complete(uint8_t status, uint16_t length,
15201                                         const void *param, void *user_data)
15202 {
15203         const struct mgmt_rp_read_commands *rp = param;
15204         uint16_t num_commands, num_events;
15205         size_t expected_len;
15206         int i;
15207
15208         if (status != MGMT_STATUS_SUCCESS) {
15209                 error("Failed to read supported commands: %s (0x%02x)",
15210                                                 mgmt_errstr(status), status);
15211                 return;
15212         }
15213
15214         if (length < sizeof(*rp)) {
15215                 error("Wrong size of read commands response");
15216                 return;
15217         }
15218
15219         num_commands = btohs(rp->num_commands);
15220         num_events = btohs(rp->num_events);
15221
15222         DBG("Number of commands: %d", num_commands);
15223         DBG("Number of events: %d", num_events);
15224
15225         expected_len = sizeof(*rp) + num_commands * sizeof(uint16_t) +
15226                                                 num_events * sizeof(uint16_t);
15227
15228         if (length < expected_len) {
15229                 error("Too small reply for supported commands: (%u != %zu)",
15230                                                         length, expected_len);
15231                 return;
15232         }
15233
15234         for (i = 0; i < num_commands; i++) {
15235                 uint16_t op = get_le16(rp->opcodes + i);
15236
15237                 if (op == MGMT_OP_ADD_DEVICE) {
15238                         DBG("enabling kernel-side connection control");
15239                         kernel_conn_control = true;
15240                 }
15241         }
15242 }
15243
15244 static void read_version_complete(uint8_t status, uint16_t length,
15245                                         const void *param, void *user_data)
15246 {
15247         const struct mgmt_rp_read_version *rp = param;
15248
15249         if (status != MGMT_STATUS_SUCCESS) {
15250                 error("Failed to read version information: %s (0x%02x)",
15251                                                 mgmt_errstr(status), status);
15252                 return;
15253         }
15254
15255         if (length < sizeof(*rp)) {
15256                 error("Wrong size of read version response");
15257                 return;
15258         }
15259
15260         mgmt_version = rp->version;
15261         mgmt_revision = btohs(rp->revision);
15262
15263         info("Bluetooth management interface %u.%u initialized",
15264                                                 mgmt_version, mgmt_revision);
15265
15266         if (mgmt_version < 1) {
15267                 error("Version 1.0 or later of management interface required");
15268                 abort();
15269         }
15270
15271         DBG("sending read supported commands command");
15272
15273         /*
15274          * It is irrelevant if this command succeeds or fails. In case of
15275          * failure safe settings are assumed.
15276          */
15277         mgmt_send(mgmt_master, MGMT_OP_READ_COMMANDS,
15278                                 MGMT_INDEX_NONE, 0, NULL,
15279                                 read_commands_complete, NULL, NULL);
15280
15281         mgmt_register(mgmt_master, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
15282                                                 index_added, NULL, NULL);
15283         mgmt_register(mgmt_master, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
15284                                                 index_removed, NULL, NULL);
15285
15286         DBG("sending read index list command");
15287
15288         if (mgmt_send(mgmt_master, MGMT_OP_READ_INDEX_LIST,
15289                                 MGMT_INDEX_NONE, 0, NULL,
15290                                 read_index_list_complete, NULL, NULL) > 0)
15291                 return;
15292
15293         error("Failed to read controller index list");
15294 }
15295
15296 static void mgmt_debug(const char *str, void *user_data)
15297 {
15298         const char *prefix = user_data;
15299
15300         info("%s%s", prefix, str);
15301 }
15302
15303 int adapter_init(void)
15304 {
15305         dbus_conn = btd_get_dbus_connection();
15306
15307         mgmt_master = mgmt_new_default();
15308         if (!mgmt_master) {
15309                 error("Failed to access management interface");
15310                 return -EIO;
15311         }
15312
15313         if (getenv("MGMT_DEBUG"))
15314                 mgmt_set_debug(mgmt_master, mgmt_debug, "mgmt: ", NULL);
15315
15316         DBG("sending read version command");
15317
15318         if (mgmt_send(mgmt_master, MGMT_OP_READ_VERSION,
15319                                 MGMT_INDEX_NONE, 0, NULL,
15320                                 read_version_complete, NULL, NULL) > 0)
15321                 return 0;
15322
15323         error("Failed to read management version information");
15324
15325         return -EIO;
15326 }
15327
15328 void adapter_cleanup(void)
15329 {
15330         g_list_free(adapter_list);
15331
15332         while (adapters) {
15333                 struct btd_adapter *adapter = adapters->data;
15334
15335                 adapter_remove(adapter);
15336                 adapters = g_slist_remove(adapters, adapter);
15337                 btd_adapter_unref(adapter);
15338         }
15339
15340         /*
15341          * In case there is another reference active, clear out
15342          * registered handlers for index added and index removed.
15343          *
15344          * This is just an extra precaution to be safe, and in
15345          * reality should not make a difference.
15346          */
15347         mgmt_unregister_index(mgmt_master, MGMT_INDEX_NONE);
15348
15349         /*
15350          * In case there is another reference active, cancel
15351          * all pending global commands.
15352          *
15353          * This is just an extra precaution to avoid callbacks
15354          * that potentially then could leak memory or access
15355          * an invalid structure.
15356          */
15357         mgmt_cancel_index(mgmt_master, MGMT_INDEX_NONE);
15358
15359         mgmt_unref(mgmt_master);
15360         mgmt_master = NULL;
15361
15362         dbus_conn = NULL;
15363 }
15364
15365 void adapter_shutdown(void)
15366 {
15367         GList *list;
15368
15369         DBG("");
15370
15371         powering_down = true;
15372
15373         for (list = g_list_first(adapter_list); list;
15374                                                 list = g_list_next(list)) {
15375                 struct btd_adapter *adapter = list->data;
15376
15377                 if (!(adapter->current_settings & MGMT_SETTING_POWERED))
15378                         continue;
15379
15380                 clear_discoverable(adapter);
15381                 set_mode(adapter, MGMT_OP_SET_POWERED, 0x00);
15382
15383                 adapter_remaining++;
15384         }
15385
15386         if (!adapter_remaining)
15387                 btd_exit();
15388 }
15389
15390 /*
15391  * Check if workaround for broken ATT server socket behavior is needed
15392  * where we need to connect an ATT client socket before pairing to get
15393  * early access to the ATT channel.
15394  */
15395 bool btd_le_connect_before_pairing(void)
15396 {
15397         if (MGMT_VERSION(mgmt_version, mgmt_revision) < MGMT_VERSION(1, 4))
15398                 return true;
15399
15400         return false;
15401 }
15402
15403 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
15404 int btd_adapter_set_streaming_mode(struct btd_adapter *adapter,
15405                                    const bdaddr_t *bdaddr, gboolean enable)
15406 {
15407         struct mgmt_cp_set_streaming_mode cp;
15408         char addr[18];
15409
15410         ba2str(bdaddr, addr);
15411         DBG("hci%u device %s", adapter->dev_id, addr);
15412
15413         memset(&cp, 0, sizeof(cp));
15414
15415         cp.streaming_mode = enable ? 1 : 0;
15416         bacpy(&cp.bdaddr, bdaddr);
15417
15418         if (mgmt_send(adapter->mgmt, MGMT_OP_SET_STREAMING_MODE,
15419                                         adapter->dev_id, sizeof(cp), &cp,
15420                                         NULL, NULL, NULL) > 0)
15421                 return 0;
15422
15423         return -EIO;
15424 }
15425
15426 void adapter_send_event(const char *event)
15427 {
15428         struct btd_adapter *adapter = btd_adapter_get_default();
15429         if (adapter == NULL) {
15430                 error("adapter is NULL");
15431                 return;
15432         }
15433
15434         g_dbus_emit_signal(dbus_conn, adapter->path,
15435                         ADAPTER_INTERFACE, event,
15436                         DBUS_TYPE_INVALID);
15437 }
15438
15439 #endif