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 #define _GNU_SOURCE
  30 #include <stdio.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <sys/ioctl.h>
  35
  36 #include <bluetooth/bluetooth.h>
  37 #include <bluetooth/uuid.h>
  38 #include <bluetooth/sdp.h>
  39 #include <bluetooth/sdp_lib.h>
  40
  41 #include <glib.h>
  42 #include <dbus/dbus.h>
  43 #include <gdbus.h>
  44
  45 #include "log.h"
  46 #include "textfile.h"
  47
  48 #include "hcid.h"
  49 #include "sdpd.h"
  50 #include "adapter.h"
  51 #include "manager.h"
  52 #include "device.h"
  53 #include "dbus-common.h"
  54 #include "event.h"
  55 #include "error.h"
  56 #include "glib-helper.h"
  57 #include "agent.h"
  58 #include "storage.h"
  59 #include "attrib-server.h"
  60 #include "att.h"
  61
  62 /* Flags Descriptions */
  63 #define EIR_LIM_DISC                0x01 /* LE Limited Discoverable Mode */
  64 #define EIR_GEN_DISC                0x02 /* LE General Discoverable Mode */
  65 #define EIR_BREDR_UNSUP             0x04 /* BR/EDR Not Supported */
  66 #define EIR_SIM_CONTROLLER          0x08 /* Simultaneous LE and BR/EDR to Same
  67                                             Device Capable (Controller) */
  68 #define EIR_SIM_HOST                0x10 /* Simultaneous LE and BR/EDR to Same
  69                                             Device Capable (Host) */
  70
  71 #define ADV_TYPE_IND            0x00
  72 #define ADV_TYPE_DIRECT_IND     0x01
  73
  74 #define IO_CAPABILITY_DISPLAYONLY       0x00
  75 #define IO_CAPABILITY_DISPLAYYESNO      0x01
  76 #define IO_CAPABILITY_KEYBOARDONLY      0x02
  77 #define IO_CAPABILITY_NOINPUTNOOUTPUT   0x03
  78 #define IO_CAPABILITY_INVALID           0xFF
  79
  80 /* Limited Discoverable bit mask in CoD */
  81 #define LIMITED_BIT                     0x002000
  82 #define check_address(address) bachk(address)
  83
  84 static DBusConnection *connection = NULL;
  85 static GSList *adapter_drivers = NULL;
  86
  87 static GSList *ops_candidates = NULL;
  88
  89 const struct btd_adapter_ops *adapter_ops = NULL;
  90
  91 struct session_req {
  92         struct btd_adapter      *adapter;
  93         DBusConnection          *conn;          /* Connection reference */
  94         DBusMessage             *msg;           /* Unreplied message ref */
  95         char                    *owner;         /* Bus name of the owner */
  96         guint                   id;             /* Listener id */
  97         uint8_t                 mode;           /* Requested mode */
  98         int                     refcount;       /* Session refcount */
  99         gboolean                got_reply;      /* Agent reply received */
 100 };
 101
 102 struct service_auth {
 103         service_auth_cb cb;
 104         void *user_data;
 105         struct btd_device *device;
 106         struct btd_adapter *adapter;
 107 };
 108
 109 struct btd_adapter {
 110         uint16_t dev_id;
 111         int up;
 112         char *path;                     /* adapter object path */
 113         bdaddr_t bdaddr;                /* adapter Bluetooth Address */
 114         uint32_t dev_class;             /* Class of Device */
 115         guint discov_timeout_id;        /* discoverable timeout id */
 116         guint stop_discov_id;           /* stop inquiry/scanning id */
 117         uint32_t discov_timeout;        /* discoverable time(sec) */
 118         guint pairable_timeout_id;      /* pairable timeout id */
 119         uint32_t pairable_timeout;      /* pairable time(sec) */
 120         uint8_t scan_mode;              /* scan mode: SCAN_DISABLED, SCAN_PAGE,
 121                                          * SCAN_INQUIRY */
 122 #ifdef __TIZEN_PATCH__
 123         // Adding Limited state for setting limited discoverable mode
 124         gboolean limited;               /* limited discoverable state */
 125 #endif
 126         uint8_t mode;                   /* off, connectable, discoverable,
 127                                          * limited */
 128         uint8_t global_mode;            /* last valid global mode */
 129         struct session_req *pending_mode;
 130         int state;                      /* standard inq, periodic inq, name
 131                                          * resolving, suspended discovery */
 132         GSList *found_devices;
 133         GSList *oor_devices;            /* out of range device list */
 134         struct agent *agent;            /* For the new API */
 135         guint auth_idle_id;             /* Ongoing authorization */
 136         GSList *connections;            /* Connected devices */
 137         GSList *devices;                /* Devices structure pointers */
 138         GSList *mode_sessions;          /* Request Mode sessions */
 139         GSList *disc_sessions;          /* Discovery sessions */
 140         guint scheduler_id;             /* Scheduler handle */
 141         sdp_list_t *services;           /* Services associated to adapter */
 142
 143         struct hci_dev dev;             /* hci info */
 144         gboolean pairable;              /* pairable state */
 145         gboolean initialized;
 146
 147         gboolean off_requested;         /* DEVDOWN ioctl was called */
 148
 149         gint ref;
 150
 151         GSList *powered_callbacks;
 152
 153         gboolean name_stored;
 154
 155         GSList *loaded_drivers;
 156 };
 157
 158 static void adapter_set_pairable_timeout(struct btd_adapter *adapter,
 159                                         guint interval);
 160
 161 static int found_device_cmp(const struct remote_dev_info *d1,
 162                         const struct remote_dev_info *d2)
 163 {
 164         int ret;
 165
 166         if (bacmp(&d2->bdaddr, BDADDR_ANY)) {
 167                 ret = bacmp(&d1->bdaddr, &d2->bdaddr);
 168                 if (ret)
 169                         return ret;
 170         }
 171
 172         if (d2->name_status != NAME_ANY) {
 173                 ret = (d1->name_status - d2->name_status);
 174                 if (ret)
 175                         return ret;
 176         }
 177
 178         return 0;
 179 }
 180
 181 static void dev_info_free(struct remote_dev_info *dev)
 182 {
 183         g_free(dev->name);
 184         g_free(dev->alias);
 185         g_slist_foreach(dev->services, (GFunc) g_free, NULL);
 186         g_slist_free(dev->services);
 187         g_strfreev(dev->uuids);
 188         g_free(dev);
 189 }
 190
 191 /*
 192  * Device name expansion
 193  *   %d - device id
 194  */
 195 static char *expand_name(char *dst, int size, char *str, int dev_id)
 196 {
 197         register int sp, np, olen;
 198         char *opt, buf[10];
 199
 200         if (!str || !dst)
 201                 return NULL;
 202
 203         sp = np = 0;
 204         while (np < size - 1 && str[sp]) {
 205                 switch (str[sp]) {
 206                 case '%':
 207                         opt = NULL;
 208
 209                         switch (str[sp+1]) {
 210                         case 'd':
 211                                 sprintf(buf, "%d", dev_id);
 212                                 opt = buf;
 213                                 break;
 214
 215                         case 'h':
 216                                 opt = main_opts.host_name;
 217                                 break;
 218
 219                         case '%':
 220                                 dst[np++] = str[sp++];
 221                                 /* fall through */
 222                         default:
 223                                 sp++;
 224                                 continue;
 225                         }
 226
 227                         if (opt) {
 228                                 /* substitute */
 229                                 olen = strlen(opt);
 230                                 if (np + olen < size - 1)
 231                                         memcpy(dst + np, opt, olen);
 232                                 np += olen;
 233                         }
 234                         sp += 2;
 235                         continue;
 236
 237                 case '\\':
 238                         sp++;
 239                         /* fall through */
 240                 default:
 241                         dst[np++] = str[sp++];
 242                         break;
 243                 }
 244         }
 245         dst[np] = '\0';
 246         return dst;
 247 }
 248
 249 int btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
 250                                                                 uint8_t minor)
 251 {
 252         return adapter_ops->set_dev_class(adapter->dev_id, major, minor);
 253 }
 254
 255 static int pending_remote_name_cancel(struct btd_adapter *adapter)
 256 {
 257         struct remote_dev_info *dev, match;
 258         int err;
 259
 260         /* find the pending remote name request */
 261         memset(&match, 0, sizeof(struct remote_dev_info));
 262         bacpy(&match.bdaddr, BDADDR_ANY);
 263         match.name_status = NAME_REQUESTED;
 264
 265         dev = adapter_search_found_devices(adapter, &match);
 266         if (!dev) /* no pending request */
 267                 return -ENODATA;
 268
 269         err = adapter_ops->cancel_resolve_name(adapter->dev_id, &dev->bdaddr);
 270         if (err < 0)
 271                 error("Remote name cancel failed: %s(%d)",
 272                                                 strerror(errno), errno);
 273         return err;
 274 }
 275
 276 int adapter_resolve_names(struct btd_adapter *adapter)
 277 {
 278         struct remote_dev_info *dev, match;
 279         int err;
 280
 281         /* Do not attempt to resolve more names if on suspended state */
 282         if (adapter->state & STATE_SUSPENDED)
 283                 return 0;
 284
 285         memset(&match, 0, sizeof(struct remote_dev_info));
 286         bacpy(&match.bdaddr, BDADDR_ANY);
 287         match.name_status = NAME_REQUIRED;
 288
 289         dev = adapter_search_found_devices(adapter, &match);
 290         if (!dev)
 291                 return -ENODATA;
 292
 293         /* send at least one request or return failed if the list is empty */
 294         do {
 295                 /* flag to indicate the current remote name requested */
 296                 dev->name_status = NAME_REQUESTED;
 297
 298                 err = adapter_ops->resolve_name(adapter->dev_id, &dev->bdaddr);
 299
 300                 if (!err)
 301                         break;
 302
 303                 error("Unable to send HCI remote name req: %s (%d)",
 304                                                 strerror(errno), errno);
 305
 306                 /* if failed, request the next element */
 307                 /* remove the element from the list */
 308                 adapter_remove_found_device(adapter, &dev->bdaddr);
 309
 310                 /* get the next element */
 311                 dev = adapter_search_found_devices(adapter, &match);
 312         } while (dev);
 313
 314         return err;
 315 }
 316
 317 static const char *mode2str(uint8_t mode)
 318 {
 319         switch(mode) {
 320         case MODE_OFF:
 321                 return "off";
 322         case MODE_CONNECTABLE:
 323                 return "connectable";
 324         case MODE_DISCOVERABLE:
 325                 return "discoverable";
 326         default:
 327                 return "unknown";
 328         }
 329 }
 330
 331 static uint8_t get_mode(const bdaddr_t *bdaddr, const char *mode)
 332 {
 333         if (strcasecmp("off", mode) == 0)
 334                 return MODE_OFF;
 335         else if (strcasecmp("connectable", mode) == 0)
 336                 return MODE_CONNECTABLE;
 337         else if (strcasecmp("discoverable", mode) == 0)
 338                 return MODE_DISCOVERABLE;
 339         else if (strcasecmp("on", mode) == 0) {
 340                 char onmode[14], srcaddr[18];
 341
 342                 ba2str(bdaddr, srcaddr);
 343                 if (read_on_mode(srcaddr, onmode, sizeof(onmode)) < 0)
 344                         return MODE_CONNECTABLE;
 345
 346                 return get_mode(bdaddr, onmode);
 347         } else
 348                 return MODE_UNKNOWN;
 349 }
 350
 351 static void adapter_set_limited_discoverable(struct btd_adapter *adapter,
 352                                                         gboolean limited)
 353 {
 354         DBG("%s", limited ? "TRUE" : "FALSE");
 355
 356         adapter_ops->set_limited_discoverable(adapter->dev_id, limited);
 357 }
 358
 359 static void adapter_remove_discov_timeout(struct btd_adapter *adapter)
 360 {
 361         if (!adapter)
 362                 return;
 363
 364         if (adapter->discov_timeout_id == 0)
 365                 return;
 366
 367         g_source_remove(adapter->discov_timeout_id);
 368         adapter->discov_timeout_id = 0;
 369 }
 370
 371 static gboolean discov_timeout_handler(gpointer user_data)
 372 {
 373         struct btd_adapter *adapter = user_data;
 374
 375         adapter->discov_timeout_id = 0;
 376
 377         adapter_ops->set_discoverable(adapter->dev_id, FALSE);
 378
 379         return FALSE;
 380 }
 381
 382 static void adapter_set_discov_timeout(struct btd_adapter *adapter,
 383                                         guint interval)
 384 {
 385         if (adapter->discov_timeout_id) {
 386                 g_source_remove(adapter->discov_timeout_id);
 387                 adapter->discov_timeout_id = 0;
 388         }
 389
 390         if (interval == 0) {
 391                 adapter_set_limited_discoverable(adapter, FALSE);
 392                 return;
 393         }
 394
 395         /* Set limited discoverable if pairable and interval between 0 to 60
 396            sec */
 397         if (adapter->pairable && interval <= 60)
 398                 adapter_set_limited_discoverable(adapter, TRUE);
 399         else
 400                 adapter_set_limited_discoverable(adapter, FALSE);
 401
 402         adapter->discov_timeout_id = g_timeout_add_seconds(interval,
 403                                                         discov_timeout_handler,
 404                                                         adapter);
 405 }
 406
 407 static struct session_req *session_ref(struct session_req *req)
 408 {
 409         req->refcount++;
 410
 411         DBG("%p: ref=%d", req, req->refcount);
 412
 413         return req;
 414 }
 415
 416 static struct session_req *create_session(struct btd_adapter *adapter,
 417                                         DBusConnection *conn, DBusMessage *msg,
 418                                         uint8_t mode, GDBusWatchFunction cb)
 419 {
 420         const char *sender = dbus_message_get_sender(msg);
 421         struct session_req *req;
 422
 423         req = g_new0(struct session_req, 1);
 424         req->adapter = adapter;
 425         req->conn = dbus_connection_ref(conn);
 426         req->msg = dbus_message_ref(msg);
 427         req->mode = mode;
 428
 429         if (cb == NULL)
 430                 return session_ref(req);
 431
 432         req->owner = g_strdup(sender);
 433         req->id = g_dbus_add_disconnect_watch(conn, sender, cb, req, NULL);
 434
 435         info("%s session %p with %s activated",
 436                 req->mode ? "Mode" : "Discovery", req, sender);
 437
 438         return session_ref(req);
 439 }
 440
 441 static int adapter_set_mode(struct btd_adapter *adapter, uint8_t mode)
 442 {
 443         int err;
 444
 445         if (mode == MODE_CONNECTABLE)
 446                 err = adapter_ops->set_discoverable(adapter->dev_id, FALSE);
 447         else
 448                 err = adapter_ops->set_discoverable(adapter->dev_id, TRUE);
 449
 450         if (err < 0)
 451                 return err;
 452
 453         if (mode == MODE_CONNECTABLE)
 454                 return 0;
 455
 456         adapter_remove_discov_timeout(adapter);
 457
 458         if (adapter->discov_timeout)
 459                 adapter_set_discov_timeout(adapter, adapter->discov_timeout);
 460
 461         return 0;
 462 }
 463
 464 static struct session_req *find_session_by_msg(GSList *list, const DBusMessage *msg)
 465 {
 466         GSList *l;
 467
 468         for (l = list; l; l = l->next) {
 469                 struct session_req *req = l->data;
 470
 471                 if (req->msg == msg)
 472                         return req;
 473         }
 474
 475         return NULL;
 476 }
 477
 478 static int set_mode(struct btd_adapter *adapter, uint8_t new_mode,
 479                         DBusMessage *msg)
 480 {
 481         int err;
 482         const char *modestr;
 483         gboolean discoverable;
 484
 485         if (adapter->pending_mode != NULL)
 486                 return -EALREADY;
 487
 488         discoverable = new_mode == MODE_DISCOVERABLE;
 489
 490         if (!adapter->up && new_mode != MODE_OFF) {
 491                 err = adapter_ops->set_powered(adapter->dev_id, TRUE);
 492                 if (err < 0)
 493                         return err;
 494
 495                 goto done;
 496         }
 497
 498         if (adapter->up && new_mode == MODE_OFF) {
 499                 err = adapter_ops->set_powered(adapter->dev_id, FALSE);
 500                 if (err < 0)
 501                         return err;
 502
 503                 adapter->off_requested = TRUE;
 504
 505                 goto done;
 506         }
 507
 508         if (new_mode == adapter->mode)
 509                 return 0;
 510
 511         err = adapter_set_mode(adapter, new_mode);
 512
 513         if (err < 0)
 514                 return err;
 515
 516 done:
 517         modestr = mode2str(new_mode);
 518         write_device_mode(&adapter->bdaddr, modestr);
 519
 520         DBG("%s", modestr);
 521
 522         if (msg != NULL) {
 523                 struct session_req *req;
 524
 525                 req = find_session_by_msg(adapter->mode_sessions, msg);
 526                 if (req) {
 527                         adapter->pending_mode = req;
 528                         session_ref(req);
 529                 } else
 530                         /* Wait for mode change to reply */
 531                         adapter->pending_mode = create_session(adapter,
 532                                         connection, msg, new_mode, NULL);
 533         } else
 534                 /* Nothing to reply just write the new mode */
 535                 adapter->mode = new_mode;
 536
 537         return 0;
 538 }
 539
 540 static DBusMessage *set_discoverable(DBusConnection *conn, DBusMessage *msg,
 541                                 gboolean discoverable, void *data)
 542 {
 543         struct btd_adapter *adapter = data;
 544         uint8_t mode;
 545         int err;
 546
 547         mode = discoverable ? MODE_DISCOVERABLE : MODE_CONNECTABLE;
 548
 549         if (mode == adapter->mode) {
 550                 adapter->global_mode = mode;
 551                 return dbus_message_new_method_return(msg);
 552         }
 553
 554         err = set_mode(adapter, mode, msg);
 555         if (err < 0)
 556                 return btd_error_failed(msg, strerror(-err));
 557
 558         return NULL;
 559 }
 560
 561 static DBusMessage *set_powered(DBusConnection *conn, DBusMessage *msg,
 562                                 gboolean powered, void *data)
 563 {
 564         struct btd_adapter *adapter = data;
 565         uint8_t mode;
 566         int err;
 567
 568 #ifdef __TIZEN_PATCH__
 569         if (powered)
 570         {
 571                 mode = adapter->mode ? adapter->mode : get_mode(&adapter->bdaddr, "on");
 572
 573         }
 574         else
 575                 mode = MODE_OFF;
 576 #else
 577         mode = powered ? get_mode(&adapter->bdaddr, "on") : MODE_OFF;
 578 #endif
 579
 580         if (mode == adapter->mode) {
 581                 adapter->global_mode = mode;
 582                 return dbus_message_new_method_return(msg);
 583         }
 584
 585         err = set_mode(adapter, mode, msg);
 586         if (err < 0)
 587                 return btd_error_failed(msg, strerror(-err));
 588
 589         return NULL;
 590 }
 591
 592 void btd_adapter_pairable_changed(struct btd_adapter *adapter,
 593                                                         gboolean pairable)
 594 {
 595         adapter->pairable = pairable;
 596
 597         write_device_pairable(&adapter->bdaddr, pairable);
 598
 599         emit_property_changed(connection, adapter->path,
 600                                 ADAPTER_INTERFACE, "Pairable",
 601                                 DBUS_TYPE_BOOLEAN, &pairable);
 602
 603         if (pairable && adapter->pairable_timeout)
 604                 adapter_set_pairable_timeout(adapter,
 605                                                 adapter->pairable_timeout);
 606 }
 607
 608 static DBusMessage *set_pairable(DBusConnection *conn, DBusMessage *msg,
 609                                 gboolean pairable, void *data)
 610 {
 611         struct btd_adapter *adapter = data;
 612         int err;
 613
 614         if (adapter->scan_mode == SCAN_DISABLED)
 615                 return btd_error_not_ready(msg);
 616
 617         if (pairable == adapter->pairable)
 618                 goto done;
 619
 620         if (!(adapter->scan_mode & SCAN_INQUIRY))
 621                 goto store;
 622
 623 #ifndef __TIZEN_PATCH__
 624         err = set_mode(adapter, MODE_DISCOVERABLE, NULL);
 625         if (err < 0 && msg)
 626                 return btd_error_failed(msg, strerror(-err));
 627 #endif
 628
 629 store:
 630         adapter_ops->set_pairable(adapter->dev_id, pairable);
 631
 632 done:
 633         return msg ? dbus_message_new_method_return(msg) : NULL;
 634 }
 635
 636 static gboolean pairable_timeout_handler(void *data)
 637 {
 638         set_pairable(NULL, NULL, FALSE, data);
 639
 640         return FALSE;
 641 }
 642
 643 static void adapter_set_pairable_timeout(struct btd_adapter *adapter,
 644                                         guint interval)
 645 {
 646         if (adapter->pairable_timeout_id) {
 647                 g_source_remove(adapter->pairable_timeout_id);
 648                 adapter->pairable_timeout_id = 0;
 649         }
 650
 651         if (interval == 0)
 652                 return;
 653
 654         adapter->pairable_timeout_id = g_timeout_add_seconds(interval,
 655                                                 pairable_timeout_handler,
 656                                                 adapter);
 657 }
 658
 659 static struct session_req *find_session(GSList *list, const char *sender)
 660 {
 661         GSList *l;
 662
 663         for (l = list; l; l = l->next) {
 664                 struct session_req *req = l->data;
 665
 666                 if (g_str_equal(req->owner, sender))
 667                         return req;
 668         }
 669
 670         return NULL;
 671 }
 672
 673 static uint8_t get_needed_mode(struct btd_adapter *adapter, uint8_t mode)
 674 {
 675         GSList *l;
 676
 677         if (adapter->global_mode > mode)
 678                 mode = adapter->global_mode;
 679
 680         for (l = adapter->mode_sessions; l; l = l->next) {
 681                 struct session_req *req = l->data;
 682
 683                 if (req->mode > mode)
 684                         mode = req->mode;
 685         }
 686
 687         return mode;
 688 }
 689
 690 static GSList *remove_bredr(GSList *all)
 691 {
 692         GSList *l, *le;
 693
 694         for (l = all, le = NULL; l; l = l->next) {
 695                 struct remote_dev_info *dev = l->data;
 696                 if (dev->le == FALSE) {
 697                         dev_info_free(dev);
 698                         continue;
 699                 }
 700
 701                 le = g_slist_append(le, dev);
 702         }
 703
 704         g_slist_free(all);
 705
 706         return le;
 707 }
 708
 709 static void stop_discovery(struct btd_adapter *adapter, gboolean suspend)
 710 {
 711         pending_remote_name_cancel(adapter);
 712
 713         if (suspend == FALSE)
 714                 adapter->found_devices = remove_bredr(adapter->found_devices);
 715
 716         if (adapter->oor_devices) {
 717                 g_slist_free(adapter->oor_devices);
 718                 adapter->oor_devices = NULL;
 719         }
 720
 721         /* Reset if suspended, otherwise remove timer (software scheduler)
 722            or request inquiry to stop */
 723         if (adapter->state & STATE_SUSPENDED) {
 724                 adapter->state &= ~STATE_SUSPENDED;
 725                 return;
 726         }
 727
 728         if (adapter->scheduler_id) {
 729                 g_source_remove(adapter->scheduler_id);
 730                 adapter->scheduler_id = 0;
 731                 return;
 732         }
 733
 734         if (adapter->state & STATE_LE_SCAN)
 735                 adapter_ops->stop_scanning(adapter->dev_id);
 736         else
 737                 adapter_ops->stop_inquiry(adapter->dev_id);
 738 }
 739
 740 static void session_remove(struct session_req *req)
 741 {
 742         struct btd_adapter *adapter = req->adapter;
 743
 744         /* Ignore set_mode session */
 745         if (req->owner == NULL)
 746                 return;
 747
 748         DBG("%s session %p with %s deactivated",
 749                 req->mode ? "Mode" : "Discovery", req, req->owner);
 750
 751         if (req->mode) {
 752                 uint8_t mode;
 753
 754                 adapter->mode_sessions = g_slist_remove(adapter->mode_sessions,
 755                                                         req);
 756
 757                 mode = get_needed_mode(adapter, adapter->global_mode);
 758
 759                 if (mode == adapter->mode)
 760                         return;
 761
 762                 DBG("Switching to '%s' mode", mode2str(mode));
 763
 764                 set_mode(adapter, mode, NULL);
 765         } else {
 766                 adapter->disc_sessions = g_slist_remove(adapter->disc_sessions,
 767                                                         req);
 768
 769                 if (adapter->disc_sessions)
 770                         return;
 771
 772                 DBG("Stopping discovery");
 773
 774                 stop_discovery(adapter, FALSE);
 775         }
 776 }
 777
 778 static void session_free(struct session_req *req)
 779 {
 780         if (req->id)
 781                 g_dbus_remove_watch(req->conn, req->id);
 782
 783         session_remove(req);
 784
 785         if (req->msg) {
 786                 dbus_message_unref(req->msg);
 787                 if (!req->got_reply && req->mode && req->adapter->agent)
 788                         agent_cancel(req->adapter->agent);
 789         }
 790
 791         if (req->conn)
 792                 dbus_connection_unref(req->conn);
 793         g_free(req->owner);
 794         g_free(req);
 795 }
 796
 797 static void session_owner_exit(DBusConnection *conn, void *user_data)
 798 {
 799         struct session_req *req = user_data;
 800
 801         req->id = 0;
 802
 803         session_free(req);
 804 }
 805
 806 static void session_unref(struct session_req *req)
 807 {
 808         req->refcount--;
 809
 810         DBG("%p: ref=%d", req, req->refcount);
 811
 812         if (req->refcount)
 813                 return;
 814
 815         session_free(req);
 816 }
 817
 818 static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
 819 {
 820         struct session_req *req = data;
 821         int err;
 822         DBusMessage *reply;
 823
 824         req->got_reply = TRUE;
 825
 826         if (derr && dbus_error_is_set(derr)) {
 827                 reply = dbus_message_new_error(req->msg, derr->name,
 828                                                 derr->message);
 829                 g_dbus_send_message(req->conn, reply);
 830                 session_unref(req);
 831                 return;
 832         }
 833
 834         err = set_mode(req->adapter, req->mode, req->msg);
 835         if (err < 0)
 836                 reply = btd_error_failed(req->msg, strerror(-err));
 837         else if (!req->adapter->pending_mode)
 838                 reply = dbus_message_new_method_return(req->msg);
 839         else
 840                 reply = NULL;
 841
 842         if (reply) {
 843                 /*
 844                  * Send reply immediately only if there was an error changing
 845                  * mode, or change is not needed. Otherwise, reply is sent in
 846                  * set_mode_complete.
 847                  */
 848                 g_dbus_send_message(req->conn, reply);
 849
 850                 dbus_message_unref(req->msg);
 851                 req->msg = NULL;
 852         }
 853
 854         if (!find_session(req->adapter->mode_sessions, req->owner))
 855                 session_unref(req);
 856 }
 857
 858 static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
 859                                                         DBusMessage *msg,
 860                                                         uint32_t timeout,
 861                                                         void *data)
 862 {
 863         struct btd_adapter *adapter = data;
 864         const char *path;
 865
 866         if (adapter->discov_timeout == timeout && timeout == 0)
 867                 return dbus_message_new_method_return(msg);
 868
 869         if (adapter->scan_mode & SCAN_INQUIRY)
 870                 adapter_set_discov_timeout(adapter, timeout);
 871
 872         adapter->discov_timeout = timeout;
 873
 874         write_discoverable_timeout(&adapter->bdaddr, timeout);
 875
 876         path = dbus_message_get_path(msg);
 877
 878         emit_property_changed(conn, path,
 879                                 ADAPTER_INTERFACE, "DiscoverableTimeout",
 880                                 DBUS_TYPE_UINT32, &timeout);
 881
 882         return dbus_message_new_method_return(msg);
 883 }
 884
 885 static DBusMessage *set_pairable_timeout(DBusConnection *conn,
 886                                                 DBusMessage *msg,
 887                                                 uint32_t timeout,
 888                                                 void *data)
 889 {
 890         struct btd_adapter *adapter = data;
 891         const char *path;
 892
 893         if (adapter->pairable_timeout == timeout && timeout == 0)
 894                 return dbus_message_new_method_return(msg);
 895
 896         if (adapter->pairable)
 897                 adapter_set_pairable_timeout(adapter, timeout);
 898
 899         adapter->pairable_timeout = timeout;
 900
 901         write_pairable_timeout(&adapter->bdaddr, timeout);
 902
 903         path = dbus_message_get_path(msg);
 904
 905         emit_property_changed(conn, path,
 906                                 ADAPTER_INTERFACE, "PairableTimeout",
 907                                 DBUS_TYPE_UINT32, &timeout);
 908
 909         return dbus_message_new_method_return(msg);
 910 }
 911
 912 void btd_adapter_class_changed(struct btd_adapter *adapter, uint32_t new_class)
 913 {
 914         uint8_t class[3];
 915
 916         class[2] = (new_class >> 16) & 0xff;
 917         class[1] = (new_class >> 8) & 0xff;
 918         class[0] = new_class & 0xff;
 919
 920         write_local_class(&adapter->bdaddr, class);
 921
 922         adapter->dev_class = new_class;
 923
 924         if (main_opts.attrib_server) {
 925                 /* Removes service class */
 926                 class[1] = class[1] & 0x1f;
 927                 attrib_gap_set(GATT_CHARAC_APPEARANCE, class, 2);
 928         }
 929
 930         emit_property_changed(connection, adapter->path,
 931                                 ADAPTER_INTERFACE, "Class",
 932                                 DBUS_TYPE_UINT32, &new_class);
 933 }
 934
 935 void adapter_update_local_name(struct btd_adapter *adapter, const char *name)
 936 {
 937         struct hci_dev *dev = &adapter->dev;
 938
 939         if (strncmp(name, dev->name, MAX_NAME_LENGTH) == 0)
 940                 return;
 941
 942         strncpy(dev->name, name, MAX_NAME_LENGTH);
 943
 944         if (main_opts.attrib_server)
 945                 attrib_gap_set(GATT_CHARAC_DEVICE_NAME,
 946                         (const uint8_t *) dev->name, strlen(dev->name));
 947
 948         if (!adapter->name_stored) {
 949                 char *name_ptr = dev->name;
 950
 951                 write_local_name(&adapter->bdaddr, dev->name);
 952
 953                 if (connection)
 954                         emit_property_changed(connection, adapter->path,
 955                                                 ADAPTER_INTERFACE, "Name",
 956                                                 DBUS_TYPE_STRING, &name_ptr);
 957         }
 958
 959         adapter->name_stored = FALSE;
 960 }
 961
 962 static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
 963                                         const char *name, void *data)
 964 {
 965         struct btd_adapter *adapter = data;
 966         struct hci_dev *dev = &adapter->dev;
 967         char *name_ptr = dev->name;
 968
 969         if (!g_utf8_validate(name, -1, NULL)) {
 970                 error("Name change failed: supplied name isn't valid UTF-8");
 971                 return btd_error_invalid_args(msg);
 972         }
 973
 974         if (strncmp(name, dev->name, MAX_NAME_LENGTH) == 0)
 975                 goto done;
 976
 977         strncpy(dev->name, name, MAX_NAME_LENGTH);
 978         write_local_name(&adapter->bdaddr, name);
 979         emit_property_changed(connection, adapter->path,
 980                                         ADAPTER_INTERFACE, "Name",
 981                                         DBUS_TYPE_STRING, &name_ptr);
 982
 983         if (adapter->up) {
 984                 int err = adapter_ops->set_name(adapter->dev_id, name);
 985                 if (err < 0)
 986                         return btd_error_failed(msg, strerror(-err));
 987
 988                 adapter->name_stored = TRUE;
 989         }
 990
 991 done:
 992         return dbus_message_new_method_return(msg);
 993 }
 994
 995 struct btd_device *adapter_find_device(struct btd_adapter *adapter,
 996                                                         const char *dest)
 997 {
 998         struct btd_device *device;
 999         GSList *l;
1000
1001         if (!adapter)
1002                 return NULL;
1003
1004         l = g_slist_find_custom(adapter->devices, dest,
1005                                         (GCompareFunc) device_address_cmp);
1006         if (!l)
1007                 return NULL;
1008
1009         device = l->data;
1010
1011         return device;
1012 }
1013
1014 static void adapter_update_devices(struct btd_adapter *adapter)
1015 {
1016         char **devices;
1017         int i;
1018         GSList *l;
1019
1020         /* Devices */
1021         devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
1022         for (i = 0, l = adapter->devices; l; l = l->next, i++) {
1023                 struct btd_device *dev = l->data;
1024                 devices[i] = (char *) device_get_path(dev);
1025         }
1026
1027         emit_array_property_changed(connection, adapter->path,
1028                                         ADAPTER_INTERFACE, "Devices",
1029                                         DBUS_TYPE_OBJECT_PATH, &devices, i);
1030         g_free(devices);
1031 }
1032
1033 static void adapter_emit_uuids_updated(struct btd_adapter *adapter)
1034 {
1035         char **uuids;
1036         int i;
1037         sdp_list_t *list;
1038
1039         uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
1040
1041         for (i = 0, list = adapter->services; list; list = list->next) {
1042                 char *uuid;
1043                 sdp_record_t *rec = list->data;
1044
1045                 uuid = bt_uuid2string(&rec->svclass);
1046                 if (uuid)
1047                         uuids[i++] = uuid;
1048         }
1049
1050         emit_array_property_changed(connection, adapter->path,
1051                         ADAPTER_INTERFACE, "UUIDs", DBUS_TYPE_STRING, &uuids, i);
1052
1053         g_strfreev(uuids);
1054 }
1055
1056 static uint8_t get_uuid_mask(uuid_t *uuid)
1057 {
1058         if (uuid->type != SDP_UUID16)
1059                 return 0;
1060
1061         switch (uuid->value.uuid16) {
1062         case DIALUP_NET_SVCLASS_ID:
1063         case CIP_SVCLASS_ID:
1064                 return 0x42;    /* Telephony & Networking */
1065         case IRMC_SYNC_SVCLASS_ID:
1066         case OBEX_OBJPUSH_SVCLASS_ID:
1067         case OBEX_FILETRANS_SVCLASS_ID:
1068         case IRMC_SYNC_CMD_SVCLASS_ID:
1069         case PBAP_PSE_SVCLASS_ID:
1070                 return 0x10;    /* Object Transfer */
1071         case HEADSET_SVCLASS_ID:
1072         case HANDSFREE_SVCLASS_ID:
1073                 return 0x20;    /* Audio */
1074         case CORDLESS_TELEPHONY_SVCLASS_ID:
1075         case INTERCOM_SVCLASS_ID:
1076         case FAX_SVCLASS_ID:
1077         case SAP_SVCLASS_ID:
1078         /*
1079          * Setting the telephony bit for the handsfree audio gateway
1080          * role is not required by the HFP specification, but the
1081          * Nokia 616 carkit is just plain broken! It will refuse
1082          * pairing without this bit set.
1083          */
1084         case HANDSFREE_AGW_SVCLASS_ID:
1085                 return 0x40;    /* Telephony */
1086         case AUDIO_SOURCE_SVCLASS_ID:
1087         case VIDEO_SOURCE_SVCLASS_ID:
1088                 return 0x08;    /* Capturing */
1089         case AUDIO_SINK_SVCLASS_ID:
1090         case VIDEO_SINK_SVCLASS_ID:
1091                 return 0x04;    /* Rendering */
1092         case PANU_SVCLASS_ID:
1093         case NAP_SVCLASS_ID:
1094         case GN_SVCLASS_ID:
1095                 return 0x02;    /* Networking */
1096         default:
1097                 return 0;
1098         }
1099 }
1100
1101 static int uuid_cmp(const void *a, const void *b)
1102 {
1103         const sdp_record_t *rec = a;
1104         const uuid_t *uuid = b;
1105
1106         return sdp_uuid_cmp(&rec->svclass, uuid);
1107 }
1108
1109 void adapter_service_insert(struct btd_adapter *adapter, void *r)
1110 {
1111         sdp_record_t *rec = r;
1112         gboolean new_uuid;
1113
1114         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1115                 new_uuid = TRUE;
1116         else
1117                 new_uuid = FALSE;
1118
1119         adapter->services = sdp_list_insert_sorted(adapter->services, rec,
1120                                                                 record_sort);
1121
1122         if (new_uuid) {
1123                 uint8_t svc_hint = get_uuid_mask(&rec->svclass);
1124                 adapter_ops->add_uuid(adapter->dev_id, &rec->svclass, svc_hint);
1125         }
1126
1127         adapter_emit_uuids_updated(adapter);
1128 }
1129
1130 void adapter_service_remove(struct btd_adapter *adapter, void *r)
1131 {
1132         sdp_record_t *rec = r;
1133
1134         adapter->services = sdp_list_remove(adapter->services, rec);
1135
1136         if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
1137                 adapter_ops->remove_uuid(adapter->dev_id, &rec->svclass);
1138
1139         adapter_emit_uuids_updated(adapter);
1140 }
1141 #ifdef __TIZEN_PATCH__
1142 sdp_list_t *adapter_get_services(struct btd_adapter *adapter)
1143 {
1144         return adapter->services;
1145 }
1146
1147 #endif
1148 static struct btd_device *adapter_create_device(DBusConnection *conn,
1149                                                 struct btd_adapter *adapter,
1150                                                 const char *address,
1151                                                 device_type_t type)
1152 {
1153         struct btd_device *device;
1154         const char *path;
1155
1156         DBG("%s", address);
1157
1158         device = device_create(conn, adapter, address, type);
1159         if (!device)
1160                 return NULL;
1161
1162         device_set_temporary(device, TRUE);
1163
1164         adapter->devices = g_slist_append(adapter->devices, device);
1165
1166         path = device_get_path(device);
1167         g_dbus_emit_signal(conn, adapter->path,
1168                         ADAPTER_INTERFACE, "DeviceCreated",
1169                         DBUS_TYPE_OBJECT_PATH, &path,
1170                         DBUS_TYPE_INVALID);
1171
1172         adapter_update_devices(adapter);
1173
1174         return device;
1175 }
1176
1177 void adapter_remove_device(DBusConnection *conn, struct btd_adapter *adapter,
1178                                                 struct btd_device *device,
1179                                                 gboolean remove_storage)
1180 {
1181         const gchar *dev_path = device_get_path(device);
1182         struct agent *agent;
1183
1184         adapter->devices = g_slist_remove(adapter->devices, device);
1185         adapter->connections = g_slist_remove(adapter->connections, device);
1186
1187         adapter_update_devices(adapter);
1188
1189         g_dbus_emit_signal(conn, adapter->path,
1190                         ADAPTER_INTERFACE, "DeviceRemoved",
1191                         DBUS_TYPE_OBJECT_PATH, &dev_path,
1192                         DBUS_TYPE_INVALID);
1193
1194         agent = device_get_agent(device);
1195
1196         if (agent && device_is_authorizing(device))
1197                 agent_cancel(agent);
1198
1199         device_remove(device, remove_storage);
1200 }
1201
1202 struct btd_device *adapter_get_device(DBusConnection *conn,
1203                                                 struct btd_adapter *adapter,
1204                                                 const gchar *address)
1205 {
1206         struct btd_device *device;
1207
1208         DBG("%s", address);
1209
1210         if (!adapter)
1211                 return NULL;
1212
1213         device = adapter_find_device(adapter, address);
1214         if (device)
1215                 return device;
1216
1217         return adapter_create_device(conn, adapter, address,
1218                                                 DEVICE_TYPE_BREDR);
1219 }
1220
1221 static gboolean stop_scanning(gpointer user_data)
1222 {
1223         struct btd_adapter *adapter = user_data;
1224
1225         adapter_ops->stop_scanning(adapter->dev_id);
1226
1227         return FALSE;
1228 }
1229
1230 static int start_discovery(struct btd_adapter *adapter)
1231 {
1232         int err, type;
1233
1234         /* Do not start if suspended */
1235         if (adapter->state & STATE_SUSPENDED)
1236                 return 0;
1237
1238         /* Postpone discovery if still resolving names */
1239         if (adapter->state & STATE_RESOLVNAME)
1240                 return 1;
1241
1242         pending_remote_name_cancel(adapter);
1243
1244         type = adapter_get_discover_type(adapter) & ~DISC_RESOLVNAME;
1245
1246         switch (type) {
1247         case DISC_STDINQ:
1248         case DISC_INTERLEAVE:
1249                 err = adapter_ops->start_inquiry(adapter->dev_id,
1250                                                         0x08, FALSE);
1251                 break;
1252         case DISC_PINQ:
1253                 err = adapter_ops->start_inquiry(adapter->dev_id,
1254                                                         0x08, TRUE);
1255                 break;
1256         case DISC_LE:
1257                 err = adapter_ops->start_scanning(adapter->dev_id);
1258                 break;
1259         default:
1260                 err = -EINVAL;
1261         }
1262
1263         return err;
1264 }
1265
1266 static DBusMessage *adapter_start_discovery(DBusConnection *conn,
1267                                                 DBusMessage *msg, void *data)
1268 {
1269         struct session_req *req;
1270         struct btd_adapter *adapter = data;
1271         const char *sender = dbus_message_get_sender(msg);
1272         int err;
1273         info("adapter_start_discovery");
1274         if (!adapter->up)
1275                 return btd_error_not_ready(msg);
1276
1277         req = find_session(adapter->disc_sessions, sender);
1278         if (req) {
1279                 session_ref(req);
1280                 return dbus_message_new_method_return(msg);
1281         }
1282
1283         if (adapter->disc_sessions)
1284                 goto done;
1285
1286         g_slist_foreach(adapter->found_devices, (GFunc) dev_info_free, NULL);
1287         g_slist_free(adapter->found_devices);
1288         adapter->found_devices = NULL;
1289
1290         g_slist_free(adapter->oor_devices);
1291         adapter->oor_devices = NULL;
1292
1293         err = start_discovery(adapter);
1294         if (err < 0)
1295                 return btd_error_failed(msg, strerror(-err));
1296
1297 done:
1298         req = create_session(adapter, conn, msg, 0,
1299                                 session_owner_exit);
1300
1301         adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
1302
1303         return dbus_message_new_method_return(msg);
1304 }
1305
1306 static DBusMessage *adapter_stop_discovery(DBusConnection *conn,
1307                                                 DBusMessage *msg, void *data)
1308 {
1309         struct btd_adapter *adapter = data;
1310         struct session_req *req;
1311         const char *sender = dbus_message_get_sender(msg);
1312
1313         if (!adapter->up)
1314                 return btd_error_not_ready(msg);
1315
1316         req = find_session(adapter->disc_sessions, sender);
1317         if (!req)
1318                 return btd_error_failed(msg, "Invalid discovery session");
1319
1320         session_unref(req);
1321         info("Stopping discovery");
1322         return dbus_message_new_method_return(msg);
1323 }
1324
1325 struct remote_device_list_t {
1326         GSList *list;
1327         time_t time;
1328 };
1329
1330 static DBusMessage *get_properties(DBusConnection *conn,
1331                                         DBusMessage *msg, void *data)
1332 {
1333         struct btd_adapter *adapter = data;
1334         const char *property;
1335         DBusMessage *reply;
1336         DBusMessageIter iter;
1337         DBusMessageIter dict;
1338         char str[MAX_NAME_LENGTH + 1], srcaddr[18];
1339         gboolean value;
1340         char **devices, **uuids;
1341         int i;
1342         GSList *l;
1343         sdp_list_t *list;
1344         info("Get properties 1\n");
1345         ba2str(&adapter->bdaddr, srcaddr);
1346
1347         if (check_address(srcaddr) < 0)
1348                 return btd_error_invalid_args(msg);
1349
1350         reply = dbus_message_new_method_return(msg);
1351         if (!reply)
1352                 return NULL;
1353
1354         dbus_message_iter_init_append(reply, &iter);
1355
1356         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1357                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1358                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1359                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1360
1361         /* Address */
1362         property = srcaddr;
1363         dict_append_entry(&dict, "Address", DBUS_TYPE_STRING, &property);
1364
1365         /* Name */
1366         memset(str, 0, sizeof(str));
1367         strncpy(str, (char *) adapter->dev.name, MAX_NAME_LENGTH);
1368         property = str;
1369
1370         dict_append_entry(&dict, "Name", DBUS_TYPE_STRING, &property);
1371
1372         /* Class */
1373         dict_append_entry(&dict, "Class",
1374                                 DBUS_TYPE_UINT32, &adapter->dev_class);
1375
1376         /* Powered */
1377         value = (adapter->up && !adapter->off_requested) ? TRUE : FALSE;
1378         dict_append_entry(&dict, "Powered", DBUS_TYPE_BOOLEAN, &value);
1379
1380         /* Discoverable */
1381         value = adapter->scan_mode & SCAN_INQUIRY ? TRUE : FALSE;
1382         dict_append_entry(&dict, "Discoverable", DBUS_TYPE_BOOLEAN, &value);
1383 #ifdef __TIZEN_PATCH__
1384         // Adding limited property for setting limited discoverable mode
1385         /* Limited */
1386         dict_append_entry(&dict, "Limited", DBUS_TYPE_BOOLEAN,
1387                                 &adapter->limited);
1388 #endif
1389
1390         /* Pairable */
1391         dict_append_entry(&dict, "Pairable", DBUS_TYPE_BOOLEAN,
1392                                 &adapter->pairable);
1393
1394         /* DiscoverableTimeout */
1395         dict_append_entry(&dict, "DiscoverableTimeout",
1396                                 DBUS_TYPE_UINT32, &adapter->discov_timeout);
1397
1398         /* PairableTimeout */
1399         dict_append_entry(&dict, "PairableTimeout",
1400                                 DBUS_TYPE_UINT32, &adapter->pairable_timeout);
1401
1402
1403         if (adapter->state & (STATE_PINQ | STATE_STDINQ | STATE_LE_SCAN))
1404                 value = TRUE;
1405         else
1406                 value = FALSE;
1407
1408         /* Discovering */
1409         dict_append_entry(&dict, "Discovering", DBUS_TYPE_BOOLEAN, &value);
1410
1411         /* Devices */
1412         devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
1413         for (i = 0, l = adapter->devices; l; l = l->next, i++) {
1414                 struct btd_device *dev = l->data;
1415                 devices[i] = (char *) device_get_path(dev);
1416         }
1417         dict_append_array(&dict, "Devices", DBUS_TYPE_OBJECT_PATH,
1418                                                                 &devices, i);
1419         g_free(devices);
1420
1421         /* UUIDs */
1422         uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
1423
1424         for (i = 0, list = adapter->services; list; list = list->next) {
1425                 sdp_record_t *rec = list->data;
1426                 char *uuid;
1427
1428                 uuid = bt_uuid2string(&rec->svclass);
1429                 if (uuid)
1430                         uuids[i++] = uuid;
1431         }
1432
1433         dict_append_array(&dict, "UUIDs", DBUS_TYPE_STRING, &uuids, i);
1434
1435         g_strfreev(uuids);
1436
1437         dbus_message_iter_close_container(&iter, &dict);
1438
1439         return reply;
1440 }
1441
1442 static DBusMessage *set_property(DBusConnection *conn,
1443                                         DBusMessage *msg, void *data)
1444 {
1445         info(" set_property 1 \n");
1446         struct btd_adapter *adapter = data;
1447         DBusMessageIter iter;
1448         DBusMessageIter sub;
1449         const char *property;
1450         char srcaddr[18];
1451
1452         ba2str(&adapter->bdaddr, srcaddr);
1453
1454         if (!dbus_message_iter_init(msg, &iter))
1455                 return btd_error_invalid_args(msg);
1456
1457         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
1458                 return btd_error_invalid_args(msg);
1459
1460         dbus_message_iter_get_basic(&iter, &property);
1461         dbus_message_iter_next(&iter);
1462
1463         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1464                 return btd_error_invalid_args(msg);
1465         dbus_message_iter_recurse(&iter, &sub);
1466
1467         if (g_str_equal("Name", property)) {
1468                 const char *name;
1469
1470                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
1471                         return btd_error_invalid_args(msg);
1472                 dbus_message_iter_get_basic(&sub, &name);
1473
1474                 return set_name(conn, msg, name, data);
1475         } else if (g_str_equal("Powered", property)) {
1476                 gboolean powered;
1477
1478                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1479                         return btd_error_invalid_args(msg);
1480
1481                 dbus_message_iter_get_basic(&sub, &powered);
1482
1483                 return set_powered(conn, msg, powered, data);
1484         } else if (g_str_equal("Discoverable", property)) {
1485                 gboolean discoverable;
1486
1487                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1488                         return btd_error_invalid_args(msg);
1489
1490                 dbus_message_iter_get_basic(&sub, &discoverable);
1491
1492                 return set_discoverable(conn, msg, discoverable, data);
1493 #ifdef __TIZEN_PATCH__
1494         // Adding limited property for setting limited discoverable mode
1495         } else if (g_str_equal("Limited", property)) {
1496                 gboolean limited;
1497
1498                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1499                         return btd_error_invalid_args(msg);
1500
1501                 dbus_message_iter_get_basic(&sub, &limited);
1502
1503 ///             return set_limited(conn, msg, limited, data);
1504         return btd_error_invalid_args(msg);
1505 #endif
1506         } else if (g_str_equal("DiscoverableTimeout", property)) {
1507                 uint32_t timeout;
1508
1509                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1510                         return btd_error_invalid_args(msg);
1511
1512                 dbus_message_iter_get_basic(&sub, &timeout);
1513
1514                 return set_discoverable_timeout(conn, msg, timeout, data);
1515         } else if (g_str_equal("Pairable", property)) {
1516                 gboolean pairable;
1517
1518                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1519                         return btd_error_invalid_args(msg);
1520
1521                 dbus_message_iter_get_basic(&sub, &pairable);
1522
1523                 return set_pairable(conn, msg, pairable, data);
1524         } else if (g_str_equal("PairableTimeout", property)) {
1525                 uint32_t timeout;
1526
1527                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1528                         return btd_error_invalid_args(msg);
1529
1530                 dbus_message_iter_get_basic(&sub, &timeout);
1531
1532                 return set_pairable_timeout(conn, msg, timeout, data);
1533         }
1534
1535         return btd_error_invalid_args(msg);
1536 }
1537
1538 static DBusMessage *request_session(DBusConnection *conn,
1539                                         DBusMessage *msg, void *data)
1540 {
1541         struct btd_adapter *adapter = data;
1542         struct session_req *req;
1543         const char *sender = dbus_message_get_sender(msg);
1544         uint8_t new_mode;
1545         int err;
1546
1547         if (!adapter->agent)
1548                 return btd_error_agent_not_available(msg);
1549
1550         if (!adapter->mode_sessions)
1551                 adapter->global_mode = adapter->mode;
1552
1553         new_mode = get_mode(&adapter->bdaddr, "on");
1554
1555         req = find_session(adapter->mode_sessions, sender);
1556         if (req) {
1557                 session_ref(req);
1558                 return dbus_message_new_method_return(msg);
1559         } else {
1560                 req = create_session(adapter, conn, msg, new_mode,
1561                                         session_owner_exit);
1562                 adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
1563                                                         req);
1564         }
1565
1566         /* No need to change mode */
1567         if (adapter->mode >= new_mode)
1568                 return dbus_message_new_method_return(msg);
1569
1570         err = agent_confirm_mode_change(adapter->agent, mode2str(new_mode),
1571                                         confirm_mode_cb, req, NULL);
1572         if (err < 0) {
1573                 session_unref(req);
1574                 return btd_error_failed(msg, strerror(-err));
1575         }
1576
1577         return NULL;
1578 }
1579
1580 static DBusMessage *release_session(DBusConnection *conn,
1581                                         DBusMessage *msg, void *data)
1582 {
1583         struct btd_adapter *adapter = data;
1584         struct session_req *req;
1585         const char *sender = dbus_message_get_sender(msg);
1586
1587         req = find_session(adapter->mode_sessions, sender);
1588         if (!req)
1589                 return btd_error_failed(msg, "Invalid Session");
1590
1591         session_unref(req);
1592
1593         return dbus_message_new_method_return(msg);
1594 }
1595
1596 static DBusMessage *list_devices(DBusConnection *conn,
1597                                                 DBusMessage *msg, void *data)
1598 {
1599         struct btd_adapter *adapter = data;
1600         DBusMessage *reply;
1601         GSList *l;
1602         DBusMessageIter iter;
1603         DBusMessageIter array_iter;
1604         const gchar *dev_path;
1605
1606         if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
1607                 return btd_error_invalid_args(msg);
1608
1609         reply = dbus_message_new_method_return(msg);
1610         if (!reply)
1611                 return NULL;
1612
1613         dbus_message_iter_init_append(reply, &iter);
1614         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1615                                 DBUS_TYPE_OBJECT_PATH_AS_STRING, &array_iter);
1616
1617         for (l = adapter->devices; l; l = l->next) {
1618                 struct btd_device *device = l->data;
1619
1620                 dev_path = device_get_path(device);
1621
1622                 dbus_message_iter_append_basic(&array_iter,
1623                                 DBUS_TYPE_OBJECT_PATH, &dev_path);
1624         }
1625
1626         dbus_message_iter_close_container(&iter, &array_iter);
1627
1628         return reply;
1629 }
1630
1631 static DBusMessage *cancel_device_creation(DBusConnection *conn,
1632                                                 DBusMessage *msg, void *data)
1633 {
1634         struct btd_adapter *adapter = data;
1635         const gchar *address, *sender = dbus_message_get_sender(msg);
1636         struct btd_device *device;
1637
1638         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1639                                                 DBUS_TYPE_INVALID) == FALSE)
1640                 return btd_error_invalid_args(msg);
1641
1642         if (check_address(address) < 0)
1643                 return btd_error_invalid_args(msg);
1644
1645         device = adapter_find_device(adapter, address);
1646         if (!device || !device_is_creating(device, NULL))
1647                 return btd_error_does_not_exist(msg);
1648
1649         if (!device_is_creating(device, sender))
1650                 return btd_error_not_authorized(msg);
1651
1652         device_set_temporary(device, TRUE);
1653
1654         if (device_is_connected(device)) {
1655                 device_request_disconnect(device, msg);
1656                 return NULL;
1657         }
1658
1659         adapter_remove_device(conn, adapter, device, TRUE);
1660
1661         return dbus_message_new_method_return(msg);
1662 }
1663
1664 static device_type_t flags2type(uint8_t flags)
1665 {
1666         /* Inferring the remote type based on the EIR Flags field */
1667
1668         /* For LE only and dual mode the following flags must be zero */
1669         if (flags & (EIR_SIM_CONTROLLER | EIR_SIM_HOST))
1670                 return DEVICE_TYPE_UNKNOWN;
1671
1672         /* Limited or General discoverable mode bit must be enabled */
1673         if (!(flags & (EIR_LIM_DISC | EIR_GEN_DISC)))
1674                 return DEVICE_TYPE_UNKNOWN;
1675
1676         if (flags & EIR_BREDR_UNSUP)
1677                 return DEVICE_TYPE_LE;
1678         else
1679                 return DEVICE_TYPE_DUALMODE;
1680 }
1681
1682 static gboolean event_is_connectable(uint8_t type)
1683 {
1684         switch (type) {
1685         case ADV_TYPE_IND:
1686         case ADV_TYPE_DIRECT_IND:
1687                 return TRUE;
1688         default:
1689                 return FALSE;
1690         }
1691 }
1692
1693 static struct btd_device *create_device_internal(DBusConnection *conn,
1694                                                 struct btd_adapter *adapter,
1695                                                 const gchar *address,
1696                                                 gboolean force, int *err)
1697 {
1698         struct remote_dev_info *dev, match;
1699         struct btd_device *device;
1700         device_type_t type;
1701
1702         memset(&match, 0, sizeof(struct remote_dev_info));
1703         str2ba(address, &match.bdaddr);
1704         match.name_status = NAME_ANY;
1705
1706         dev = adapter_search_found_devices(adapter, &match);
1707         if (dev && dev->flags)
1708                 type = flags2type(dev->flags);
1709         else
1710                 type = DEVICE_TYPE_BREDR;
1711
1712         if (!force && type == DEVICE_TYPE_LE &&
1713                                         !event_is_connectable(dev->evt_type)) {
1714                 if (err)
1715                         *err = -ENOTCONN;
1716
1717                 return NULL;
1718         }
1719
1720         device = adapter_create_device(conn, adapter, address, type);
1721         if (!device && err)
1722                 *err = -ENOMEM;
1723
1724         return device;
1725 }
1726
1727 static DBusMessage *create_device(DBusConnection *conn,
1728                                         DBusMessage *msg, void *data)
1729 {
1730         struct btd_adapter *adapter = data;
1731         struct btd_device *device;
1732         const gchar *address;
1733         DBusMessage *reply;
1734         int err;
1735
1736         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1737                                                 DBUS_TYPE_INVALID) == FALSE)
1738                 return btd_error_invalid_args(msg);
1739
1740         if (check_address(address) < 0)
1741                 return btd_error_invalid_args(msg);
1742
1743         if (!adapter->up)
1744                 return btd_error_not_ready(msg);
1745
1746         if (adapter_find_device(adapter, address))
1747                 return btd_error_already_exists(msg);
1748
1749         DBG("%s", address);
1750
1751         device = create_device_internal(conn, adapter, address, TRUE, &err);
1752         if (!device)
1753                 goto failed;
1754
1755         if (device_get_type(device) != DEVICE_TYPE_LE)
1756                 err = device_browse_sdp(device, conn, msg, NULL, FALSE);
1757         else
1758                 err = device_browse_primary(device, conn, msg, FALSE);
1759
1760         if (err < 0) {
1761                 adapter_remove_device(conn, adapter, device, TRUE);
1762                 return btd_error_failed(msg, strerror(-err));
1763         }
1764
1765         return NULL;
1766
1767 failed:
1768         if (err == -ENOTCONN) {
1769                 /* Device is not connectable */
1770                 const char *path = device_get_path(device);
1771
1772                 reply = dbus_message_new_method_return(msg);
1773
1774                 dbus_message_append_args(reply,
1775                                 DBUS_TYPE_OBJECT_PATH, &path,
1776                                 DBUS_TYPE_INVALID);
1777         } else
1778                 reply = btd_error_failed(msg, strerror(-err));
1779
1780         return reply;
1781 }
1782
1783 static uint8_t parse_io_capability(const char *capability)
1784 {
1785         if (g_str_equal(capability, ""))
1786                 return IO_CAPABILITY_DISPLAYYESNO;
1787         if (g_str_equal(capability, "DisplayOnly"))
1788                 return IO_CAPABILITY_DISPLAYONLY;
1789         if (g_str_equal(capability, "DisplayYesNo"))
1790                 return IO_CAPABILITY_DISPLAYYESNO;
1791         if (g_str_equal(capability, "KeyboardOnly"))
1792                 return IO_CAPABILITY_KEYBOARDONLY;
1793         if (g_str_equal(capability, "NoInputNoOutput"))
1794                 return IO_CAPABILITY_NOINPUTNOOUTPUT;
1795         return IO_CAPABILITY_INVALID;
1796 }
1797 #ifdef __TIZEN_PATCH__
1798 DBusMessage *adapter_encrypt_link(DBusConnection *conn,
1799                                         DBusMessage *msg,
1800                                         const char *address,
1801                                         dbus_bool_t encrypt,
1802                                         void* data)
1803
1804 {
1805         struct btd_adapter *adapter = data;
1806         struct btd_device *device;
1807         char filename[PATH_MAX + 1];
1808         bdaddr_t bdaddr;
1809         struct hci_conn_info_req *cr;
1810         int opt, dd;
1811         int dev_id = 0;
1812
1813         DBG("handle_authenticate_link_request1");
1814          device = adapter_get_device(conn, adapter, address);
1815
1816         str2ba(address, &bdaddr);
1817         /* check if there is a pending discover: requested by D-Bus/non clients */
1818         if (0)//todo
1819
1820                 return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress", "Discover in progress");
1821
1822         pending_remote_name_cancel(adapter);
1823
1824         if (device_get_bonding(device))
1825                 return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress", "Bonding in progress");
1826
1827
1828         /*if (adapter_find_auth_request(adapter, &bdaddr))
1829                 return in_progress(msg, "Bonding in progress");*/
1830
1831         /* check if a link key already exists */
1832         create_name(filename, PATH_MAX, STORAGEDIR,address,
1833                         "linkkeys");
1834
1835         dd = hci_open_dev(dev_id);
1836         if (dd < 0) {
1837                 return g_dbus_create_error(msg,
1838                                 ERROR_INTERFACE ".Failed",
1839                                 "Device open failed");
1840         }
1841
1842         cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
1843         if (!cr) {
1844                 return NULL;
1845         }
1846
1847         bacpy(&cr->bdaddr, &bdaddr);
1848         cr->type = ACL_LINK;
1849         if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
1850                 free(cr);
1851                 return g_dbus_create_error(msg,
1852                                 ERROR_INTERFACE ".Failed",
1853                                 "Getting connection info failed");
1854         }
1855
1856 #if 0
1857         if (hci_authenticate_link(dd, htobs(cr->conn_info->handle), 25000) < 0) {
1858                 free(cr);
1859                 return g_dbus_create_error(msg,
1860                                 ERROR_INTERFACE ".Failed",
1861                                 "Authentication request failed");
1862         }
1863
1864 #endif
1865        info("Encrypt value   %d",encrypt);
1866         if (hci_encrypt_link(dd, htobs(cr->conn_info->handle), encrypt, 25000) < 0) {
1867                 free(cr);
1868                 return g_dbus_create_error(msg,
1869                                 ERROR_INTERFACE ".Failed",
1870                                 "Encryption request failed");
1871         }
1872
1873        DBG("handle_authenticate_link_request2");
1874         free(cr);
1875
1876         hci_close_dev(dd);
1877
1878         return dbus_message_new_method_return(msg);
1879
1880 }
1881 #endif
1882
1883
1884
1885
1886 #ifdef __TIZEN_PATCH__
1887 static DBusMessage *authenticate_link(DBusConnection *conn,
1888                                                 DBusMessage *msg, void *data)
1889 {
1890         struct btd_adapter *adapter = data;
1891         struct btd_device *device;
1892         const gchar *address, *agent_path, *capability, *sender;
1893         uint8_t cap;
1894        info("authenticate_link 1\n");
1895         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1896                                         DBUS_TYPE_OBJECT_PATH, &agent_path,
1897                                         DBUS_TYPE_STRING, &capability,
1898                                                 DBUS_TYPE_INVALID) == FALSE)
1899                 return btd_error_invalid_args(msg);
1900       info("authenticate_link 2\n");
1901         if (check_address(address) < 0)
1902                 return btd_error_invalid_args(msg);
1903        info("authenticate_link 3\n");
1904         sender = dbus_message_get_sender(msg);
1905         if (adapter->agent &&
1906                         agent_matches(adapter->agent, sender, agent_path)) {
1907                 error("Refusing adapter agent usage as device specific one");
1908                 return btd_error_invalid_args(msg);
1909         }
1910        info("authenticate_link 4\n");
1911         cap = parse_io_capability(capability);
1912         if (cap == IO_CAPABILITY_INVALID)
1913                 return btd_error_invalid_args(msg);
1914        info("authenticate_link 5\n");
1915         device = adapter_get_device(conn, adapter, address);
1916         if (!device)
1917                 return g_dbus_create_error(msg,
1918                                 ERROR_INTERFACE ".Failed",
1919                                 "Unable to create a new device object");
1920         info("authenticate_link 5\n");
1921         return device_jsr82_authenticate_link(device, conn, msg, agent_path, cap);
1922 }
1923 #endif
1924
1925 #ifdef __TIZEN_PATCH__
1926 static DBusMessage *encrypt_connection(DBusConnection *conn,
1927                                                 DBusMessage *msg, void *data)
1928 {
1929         struct btd_adapter *adapter = data;
1930         gboolean encrypt = FALSE;
1931         DBG("encrypt_link");
1932        info("encrypt_connection value  1   %d",encrypt);
1933         if (!adapter->up)
1934                 return btd_error_not_ready(msg);
1935         DBusMessageIter iter;
1936         DBusMessageIter sub;
1937         const char *address;
1938
1939
1940         if (!dbus_message_iter_init(msg, &iter))
1941                 return btd_error_invalid_args(msg);
1942
1943         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
1944                 return btd_error_invalid_args(msg);
1945
1946         dbus_message_iter_get_basic(&iter, &address);
1947         dbus_message_iter_next(&iter);
1948
1949         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1950                 return btd_error_invalid_args(msg);
1951         dbus_message_iter_recurse(&iter, &sub);
1952
1953         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1954                 return btd_error_invalid_args(msg);
1955
1956         dbus_message_iter_get_basic(&sub, &encrypt);
1957 /*      if (!dbus_message_get_args(msg, NULL,
1958                                 DBUS_TYPE_STRING, &address, DBUS_TYPE_BOOLEAN,&encrypt,
1959                                 DBUS_TYPE_INVALID))
1960                 return btd_error_invalid_args(msg);*/
1961
1962        info("encrypt_connection value  2   %d",encrypt);
1963         return adapter_encrypt_link(conn, msg, address, encrypt, data);
1964
1965 }
1966 #endif
1967 static DBusMessage *create_paired_device(DBusConnection *conn,
1968                                         DBusMessage *msg, void *data)
1969 {
1970         struct btd_adapter *adapter = data;
1971         struct btd_device *device;
1972         const gchar *address, *agent_path, *capability, *sender;
1973         uint8_t cap;
1974         int err;
1975
1976         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1977                                         DBUS_TYPE_OBJECT_PATH, &agent_path,
1978                                         DBUS_TYPE_STRING, &capability,
1979                                         DBUS_TYPE_INVALID) == FALSE)
1980                 return btd_error_invalid_args(msg);
1981
1982         if (check_address(address) < 0)
1983                 return btd_error_invalid_args(msg);
1984
1985         if (!adapter->up)
1986                 return btd_error_not_ready(msg);
1987
1988         sender = dbus_message_get_sender(msg);
1989         if (adapter->agent &&
1990                         agent_matches(adapter->agent, sender, agent_path)) {
1991                 error("Refusing adapter agent usage as device specific one");
1992                 return btd_error_invalid_args(msg);
1993         }
1994
1995         cap = parse_io_capability(capability);
1996         if (cap == IO_CAPABILITY_INVALID)
1997                 return btd_error_invalid_args(msg);
1998
1999         device = adapter_find_device(adapter, address);
2000         if (!device) {
2001                 device = create_device_internal(conn, adapter, address,
2002                                                                 FALSE, &err);
2003                 if (!device)
2004                         return btd_error_failed(msg, strerror(-err));
2005         }
2006
2007         if (device_get_type(device) != DEVICE_TYPE_LE)
2008                 return device_create_bonding(device, conn, msg,
2009                                                         agent_path, cap);
2010
2011         err = device_browse_primary(device, conn, msg, TRUE);
2012         if (err < 0)
2013                 return btd_error_failed(msg, strerror(-err));
2014
2015         return NULL;
2016 }
2017
2018 static gint device_path_cmp(struct btd_device *device, const gchar *path)
2019 {
2020         const gchar *dev_path = device_get_path(device);
2021
2022         return strcasecmp(dev_path, path);
2023 }
2024
2025 static DBusMessage *remove_device(DBusConnection *conn, DBusMessage *msg,
2026                                                                 void *data)
2027 {
2028         struct btd_adapter *adapter = data;
2029         struct btd_device *device;
2030         const char *path;
2031         GSList *l;
2032
2033         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2034                                                 DBUS_TYPE_INVALID) == FALSE)
2035                 return btd_error_invalid_args(msg);
2036
2037         l = g_slist_find_custom(adapter->devices,
2038                         path, (GCompareFunc) device_path_cmp);
2039         if (!l)
2040                 return btd_error_does_not_exist(msg);
2041
2042         device = l->data;
2043
2044         if (device_is_temporary(device) || device_is_busy(device))
2045                 return g_dbus_create_error(msg,
2046                                 ERROR_INTERFACE ".DoesNotExist",
2047                                 "Device creation in progress");
2048
2049         device_set_temporary(device, TRUE);
2050
2051         if (!device_is_connected(device)) {
2052                 adapter_remove_device(conn, adapter, device, TRUE);
2053                 return dbus_message_new_method_return(msg);
2054         }
2055
2056         device_request_disconnect(device, msg);
2057         return NULL;
2058 }
2059
2060 static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
2061                                                                 void *data)
2062 {
2063         struct btd_adapter *adapter = data;
2064         struct btd_device *device;
2065         DBusMessage *reply;
2066         const gchar *address;
2067         GSList *l;
2068         const gchar *dev_path;
2069
2070         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
2071                                                 DBUS_TYPE_INVALID))
2072                 return btd_error_invalid_args(msg);
2073
2074         l = g_slist_find_custom(adapter->devices,
2075                         address, (GCompareFunc) device_address_cmp);
2076         if (!l)
2077                 return btd_error_does_not_exist(msg);
2078
2079         device = l->data;
2080
2081         reply = dbus_message_new_method_return(msg);
2082         if (!reply)
2083                 return NULL;
2084
2085         dev_path = device_get_path(device);
2086
2087         dbus_message_append_args(reply,
2088                                 DBUS_TYPE_OBJECT_PATH, &dev_path,
2089                                 DBUS_TYPE_INVALID);
2090
2091         return reply;
2092 }
2093
2094 static void agent_removed(struct agent *agent, struct btd_adapter *adapter)
2095 {
2096         adapter_ops->set_io_capability(adapter->dev_id,
2097                                         IO_CAPABILITY_NOINPUTNOOUTPUT);
2098
2099         adapter->agent = NULL;
2100 }
2101
2102 static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg,
2103                                                                 void *data)
2104 {
2105         const char *path, *name, *capability;
2106         struct agent *agent;
2107         struct btd_adapter *adapter = data;
2108         uint8_t cap;
2109
2110         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2111                         DBUS_TYPE_STRING, &capability, DBUS_TYPE_INVALID))
2112                 return NULL;
2113
2114         if (adapter->agent)
2115                 return btd_error_already_exists(msg);
2116
2117         cap = parse_io_capability(capability);
2118         if (cap == IO_CAPABILITY_INVALID)
2119                 return btd_error_invalid_args(msg);
2120
2121         name = dbus_message_get_sender(msg);
2122
2123         agent = agent_create(adapter, name, path, cap,
2124                                 (agent_remove_cb) agent_removed, adapter);
2125         if (!agent)
2126                 return btd_error_failed(msg, "Failed to create a new agent");
2127
2128         adapter->agent = agent;
2129
2130         DBG("Agent registered for hci%d at %s:%s", adapter->dev_id, name,
2131                         path);
2132
2133         adapter_ops->set_io_capability(adapter->dev_id, cap);
2134
2135         return dbus_message_new_method_return(msg);
2136 }
2137
2138 static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg,
2139                                                                 void *data)
2140 {
2141         const char *path, *name;
2142         struct btd_adapter *adapter = data;
2143
2144         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2145                                                 DBUS_TYPE_INVALID))
2146                 return NULL;
2147
2148         name = dbus_message_get_sender(msg);
2149
2150         if (!adapter->agent || !agent_matches(adapter->agent, name, path))
2151                 return btd_error_does_not_exist(msg);
2152
2153         agent_free(adapter->agent);
2154         adapter->agent = NULL;
2155
2156         return dbus_message_new_method_return(msg);
2157 }
2158
2159 static GDBusMethodTable adapter_methods[] = {
2160         { "GetProperties",      "",     "a{sv}",get_properties          },
2161         { "SetProperty",        "sv",   "",     set_property,
2162                                                 G_DBUS_METHOD_FLAG_ASYNC},
2163         { "RequestSession",     "",     "",     request_session,
2164                                                 G_DBUS_METHOD_FLAG_ASYNC},
2165         { "ReleaseSession",     "",     "",     release_session         },
2166         { "StartDiscovery",     "",     "",     adapter_start_discovery },
2167         { "StopDiscovery",      "",     "",     adapter_stop_discovery,
2168                                                 G_DBUS_METHOD_FLAG_ASYNC},
2169         { "ListDevices",        "",     "ao",   list_devices,
2170                                                 G_DBUS_METHOD_FLAG_DEPRECATED},
2171         { "CreateDevice",       "s",    "o",    create_device,
2172                                                 G_DBUS_METHOD_FLAG_ASYNC},
2173         { "CreatePairedDevice", "sos",  "o",    create_paired_device,
2174                                                 G_DBUS_METHOD_FLAG_ASYNC},
2175         { "CancelDeviceCreation","s",   "",     cancel_device_creation,
2176                                                 G_DBUS_METHOD_FLAG_ASYNC},
2177         { "RemoveDevice",       "o",    "",     remove_device,
2178                                                 G_DBUS_METHOD_FLAG_ASYNC},
2179         { "FindDevice",         "s",    "o",    find_device             },
2180         { "RegisterAgent",      "os",   "",     register_agent          },
2181         { "UnregisterAgent",    "o",    "",     unregister_agent        },
2182
2183         #ifdef __TIZEN_PATCH__
2184         { "AuthenticateLink","sos",     "o",    authenticate_link, G_DBUS_METHOD_FLAG_ASYNC},
2185         { "EncryptLink","sv",   "",     encrypt_connection, G_DBUS_METHOD_FLAG_ASYNC},
2186         #endif
2187         { }
2188 };
2189
2190 static GDBusSignalTable adapter_signals[] = {
2191         { "PropertyChanged",            "sv"            },
2192         { "DeviceCreated",              "o"             },
2193         { "DeviceRemoved",              "o"             },
2194         { "DeviceFound",                "sa{sv}"        },
2195         { "DeviceDisappeared",          "s"             },
2196         { }
2197 };
2198
2199 static void create_stored_device_from_profiles(char *key, char *value,
2200                                                 void *user_data)
2201 {
2202         struct btd_adapter *adapter = user_data;
2203         GSList *uuids = bt_string2list(value);
2204         struct btd_device *device;
2205
2206         if (g_slist_find_custom(adapter->devices,
2207                                 key, (GCompareFunc) device_address_cmp))
2208                 return;
2209
2210         device = device_create(connection, adapter, key, DEVICE_TYPE_BREDR);
2211         if (!device)
2212                 return;
2213
2214         device_set_temporary(device, FALSE);
2215         adapter->devices = g_slist_append(adapter->devices, device);
2216
2217         device_probe_drivers(device, uuids);
2218
2219         g_slist_foreach(uuids, (GFunc) g_free, NULL);
2220         g_slist_free(uuids);
2221 }
2222
2223 struct adapter_keys {
2224         struct btd_adapter *adapter;
2225         GSList *keys;
2226 };
2227
2228 static struct link_key_info *get_key_info(const char *addr, const char *value)
2229 {
2230         struct link_key_info *info;
2231         char tmp[3];
2232         long int l;
2233         int i;
2234
2235         if (strlen(value) < 36) {
2236                 error("Unexpectedly short (%zu) link key line", strlen(value));
2237                 return NULL;
2238         }
2239
2240         info = g_new0(struct link_key_info, 1);
2241
2242         str2ba(addr, &info->bdaddr);
2243
2244         memset(tmp, 0, sizeof(tmp));
2245
2246         for (i = 0; i < 16; i++) {
2247                 memcpy(tmp, value + (i * 2), 2);
2248                 info->key[i] = (uint8_t) strtol(tmp, NULL, 16);
2249         }
2250
2251         memcpy(tmp, value + 33, 2);
2252         info->type = (uint8_t) strtol(tmp, NULL, 10);
2253
2254         memcpy(tmp, value + 35, 2);
2255         l = strtol(tmp, NULL, 10);
2256         if (l < 0)
2257                 l = 0;
2258         info->pin_len = l;
2259
2260         return info;
2261 }
2262
2263 static void create_stored_device_from_linkkeys(char *key, char *value,
2264                                                         void *user_data)
2265 {
2266         struct adapter_keys *keys = user_data;
2267         struct btd_adapter *adapter = keys->adapter;
2268         struct btd_device *device;
2269         struct link_key_info *info;
2270
2271         info = get_key_info(key, value);
2272         if (info)
2273                 keys->keys = g_slist_append(keys->keys, info);
2274
2275         if (g_slist_find_custom(adapter->devices, key,
2276                                         (GCompareFunc) device_address_cmp))
2277                 return;
2278
2279         device = device_create(connection, adapter, key, DEVICE_TYPE_BREDR);
2280         if (device) {
2281                 device_set_temporary(device, FALSE);
2282                 adapter->devices = g_slist_append(adapter->devices, device);
2283         }
2284 }
2285
2286 static void create_stored_device_from_blocked(char *key, char *value,
2287                                                         void *user_data)
2288 {
2289         struct btd_adapter *adapter = user_data;
2290         struct btd_device *device;
2291
2292         if (g_slist_find_custom(adapter->devices,
2293                                 key, (GCompareFunc) device_address_cmp))
2294                 return;
2295
2296         device = device_create(connection, adapter, key, DEVICE_TYPE_BREDR);
2297         if (device) {
2298                 device_set_temporary(device, FALSE);
2299                 adapter->devices = g_slist_append(adapter->devices, device);
2300         }
2301 }
2302
2303 static void create_stored_device_from_types(char *key, char *value,
2304                                                         void *user_data)
2305 {
2306         GSList *l;
2307         struct btd_adapter *adapter = user_data;
2308         struct btd_device *device;
2309         uint8_t type;
2310
2311         type = strtol(value, NULL, 16);
2312
2313         l = g_slist_find_custom(adapter->devices,
2314                                 key, (GCompareFunc) device_address_cmp);
2315         if (l) {
2316                 device = l->data;
2317                 device_set_type(device, type);
2318                 return;
2319         }
2320
2321         device = device_create(connection, adapter, key, type);
2322         if (device) {
2323                 device_set_temporary(device, FALSE);
2324                 adapter->devices = g_slist_append(adapter->devices, device);
2325         }
2326 }
2327
2328 static GSList *string_to_primary_list(char *str)
2329 {
2330         GSList *l = NULL;
2331         char **services;
2332         int i;
2333
2334         if (str == NULL)
2335                 return NULL;
2336
2337         services = g_strsplit(str, " ", 0);
2338         if (services == NULL)
2339                 return NULL;
2340
2341         for (i = 0; services[i]; i++) {
2342                 struct att_primary *prim;
2343                 int ret;
2344
2345                 prim = g_new0(struct att_primary, 1);
2346
2347                 ret = sscanf(services[i], "%04hX#%04hX#%s", &prim->start,
2348                                                         &prim->end, prim->uuid);
2349
2350                 if (ret < 3) {
2351                         g_free(prim);
2352                         continue;
2353                 }
2354
2355                 l = g_slist_append(l, prim);
2356         }
2357
2358         g_strfreev(services);
2359
2360         return l;
2361 }
2362
2363 static void create_stored_device_from_primary(char *key, char *value,
2364                                                         void *user_data)
2365 {
2366         struct btd_adapter *adapter = user_data;
2367         struct btd_device *device;
2368         GSList *services, *uuids, *l;
2369
2370         l = g_slist_find_custom(adapter->devices,
2371                                 key, (GCompareFunc) device_address_cmp);
2372         if (l)
2373                 device = l->data;
2374         else {
2375                 device = device_create(connection, adapter, key, DEVICE_TYPE_BREDR);
2376                 if (!device)
2377                         return;
2378
2379                 device_set_temporary(device, FALSE);
2380                 adapter->devices = g_slist_append(adapter->devices, device);
2381         }
2382
2383         services = string_to_primary_list(value);
2384         if (services == NULL)
2385                 return;
2386
2387         for (l = services, uuids = NULL; l; l = l->next) {
2388                 struct att_primary *prim = l->data;
2389                 uuids = g_slist_append(uuids, prim->uuid);
2390
2391                 device_add_primary(device, prim);
2392         }
2393
2394         device_probe_drivers(device, uuids);
2395
2396         g_slist_free(services);
2397         g_slist_free(uuids);
2398 }
2399
2400 static void load_devices(struct btd_adapter *adapter)
2401 {
2402         char filename[PATH_MAX + 1];
2403         char srcaddr[18];
2404         struct adapter_keys keys = { adapter, NULL };
2405         int err;
2406
2407         ba2str(&adapter->bdaddr, srcaddr);
2408
2409         create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "profiles");
2410         textfile_foreach(filename, create_stored_device_from_profiles,
2411                                                                 adapter);
2412
2413         create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "primary");
2414         textfile_foreach(filename, create_stored_device_from_primary,
2415                                                                 adapter);
2416
2417         create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "linkkeys");
2418         textfile_foreach(filename, create_stored_device_from_linkkeys, &keys);
2419
2420         err = adapter_ops->load_keys(adapter->dev_id, keys.keys,
2421                                                         main_opts.debug_keys);
2422         if (err < 0) {
2423                 error("Unable to load keys to adapter_ops: %s (%d)",
2424                                                         strerror(-err), -err);
2425                 g_slist_foreach(keys.keys, (GFunc) g_free, NULL);
2426                 g_slist_free(keys.keys);
2427         }
2428
2429         create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "blocked");
2430         textfile_foreach(filename, create_stored_device_from_blocked, adapter);
2431
2432         create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "types");
2433         textfile_foreach(filename, create_stored_device_from_types, adapter);
2434 }
2435
2436 int btd_adapter_block_address(struct btd_adapter *adapter, bdaddr_t *bdaddr)
2437 {
2438         return adapter_ops->block_device(adapter->dev_id, bdaddr);
2439 }
2440
2441 int btd_adapter_unblock_address(struct btd_adapter *adapter, bdaddr_t *bdaddr)
2442 {
2443         return adapter_ops->unblock_device(adapter->dev_id, bdaddr);
2444 }
2445
2446 static void clear_blocked(struct btd_adapter *adapter)
2447 {
2448         int err;
2449
2450         err = adapter_ops->unblock_device(adapter->dev_id, BDADDR_ANY);
2451         if (err < 0)
2452                 error("Clearing blocked list failed: %s (%d)",
2453                                                 strerror(-err), -err);
2454 }
2455
2456 static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
2457 {
2458         struct btd_adapter_driver *driver = user_data;
2459         int err;
2460
2461         if (!adapter->up)
2462                 return;
2463
2464         if (driver->probe == NULL)
2465                 return;
2466
2467         err = driver->probe(adapter);
2468         if (err < 0) {
2469                 error("%s: %s (%d)", driver->name, strerror(-err), -err);
2470                 return;
2471         }
2472
2473         adapter->loaded_drivers = g_slist_prepend(adapter->loaded_drivers,
2474                                                                         driver);
2475 }
2476
2477 static void load_drivers(struct btd_adapter *adapter)
2478 {
2479         GSList *l;
2480
2481         for (l = adapter_drivers; l; l = l->next)
2482                 probe_driver(adapter, l->data);
2483 }
2484
2485 static void load_connections(struct btd_adapter *adapter)
2486 {
2487         GSList *l, *conns;
2488         int err;
2489
2490         err = adapter_ops->get_conn_list(adapter->dev_id, &conns);
2491         if (err < 0) {
2492                 error("Unable to fetch existing connections: %s (%d)",
2493                                                         strerror(-err), -err);
2494                 return;
2495         }
2496
2497         for (l = conns; l != NULL; l = g_slist_next(l)) {
2498                 bdaddr_t *bdaddr = l->data;
2499                 struct btd_device *device;
2500                 char address[18];
2501
2502                 ba2str(bdaddr, address);
2503                 DBG("Adding existing connection to %s", address);
2504
2505                 device = adapter_get_device(connection, adapter, address);
2506                 if (device)
2507                         adapter_add_connection(adapter, device);
2508         }
2509
2510         g_slist_foreach(conns, (GFunc) g_free, NULL);
2511         g_slist_free(conns);
2512 }
2513
2514 static int get_discoverable_timeout(const char *src)
2515 {
2516         int timeout;
2517
2518         if (read_discoverable_timeout(src, &timeout) == 0)
2519                 return timeout;
2520
2521         return main_opts.discovto;
2522 }
2523
2524 static int get_pairable_timeout(const char *src)
2525 {
2526         int timeout;
2527
2528         if (read_pairable_timeout(src, &timeout) == 0)
2529                 return timeout;
2530
2531         return main_opts.pairto;
2532 }
2533
2534 static void call_adapter_powered_callbacks(struct btd_adapter *adapter,
2535                                                 gboolean powered)
2536 {
2537         GSList *l;
2538
2539         for (l = adapter->powered_callbacks; l; l = l->next) {
2540                 btd_adapter_powered_cb cb = l->data;
2541
2542                 cb(adapter, powered);
2543        }
2544 }
2545
2546 static void emit_device_disappeared(gpointer data, gpointer user_data)
2547 {
2548         struct remote_dev_info *dev = data;
2549         struct btd_adapter *adapter = user_data;
2550         char address[18];
2551         const char *paddr = address;
2552
2553         ba2str(&dev->bdaddr, address);
2554
2555         g_dbus_emit_signal(connection, adapter->path,
2556                         ADAPTER_INTERFACE, "DeviceDisappeared",
2557                         DBUS_TYPE_STRING, &paddr,
2558                         DBUS_TYPE_INVALID);
2559
2560         adapter->found_devices = g_slist_remove(adapter->found_devices, dev);
2561 }
2562
2563 static void update_oor_devices(struct btd_adapter *adapter)
2564 {
2565         g_slist_foreach(adapter->oor_devices, emit_device_disappeared, adapter);
2566         g_slist_foreach(adapter->oor_devices, (GFunc) dev_info_free, NULL);
2567         g_slist_free(adapter->oor_devices);
2568         adapter->oor_devices =  g_slist_copy(adapter->found_devices);
2569 }
2570
2571 static gboolean bredr_capable(struct btd_adapter *adapter)
2572 {
2573         struct hci_dev *dev = &adapter->dev;
2574
2575         return (dev->features[4] & LMP_NO_BREDR) == 0 ? TRUE : FALSE;
2576 }
2577
2578 static gboolean le_capable(struct btd_adapter *adapter)
2579 {
2580         struct hci_dev *dev = &adapter->dev;
2581
2582         return (dev->features[4] & LMP_LE &&
2583                         dev->extfeatures[0] & LMP_HOST_LE) ? TRUE : FALSE;
2584 }
2585
2586 int adapter_get_discover_type(struct btd_adapter *adapter)
2587 {
2588         gboolean le, bredr;
2589         int type;
2590
2591         le = le_capable(adapter);
2592         bredr = bredr_capable(adapter);
2593
2594         if (le)
2595                 type = bredr ? DISC_INTERLEAVE : DISC_LE;
2596         else
2597                 type = main_opts.discov_interval ? DISC_STDINQ :
2598                                                         DISC_PINQ;
2599
2600         if (main_opts.name_resolv)
2601                 type |= DISC_RESOLVNAME;
2602
2603         return type;
2604 }
2605
2606 void btd_adapter_get_mode(struct btd_adapter *adapter, uint8_t *mode,
2607                                         uint8_t *on_mode, gboolean *pairable)
2608 {
2609         char str[14], address[18];
2610
2611         ba2str(&adapter->bdaddr, address);
2612
2613         if (mode) {
2614                 if (main_opts.remember_powered == FALSE)
2615                         *mode = main_opts.mode;
2616                 else if (read_device_mode(address, str, sizeof(str)) < 0)
2617                         *mode = main_opts.mode;
2618                 else
2619                         *mode = get_mode(&adapter->bdaddr, str);
2620         }
2621
2622         if (on_mode) {
2623                 if (main_opts.remember_powered == FALSE) {
2624                         if (adapter->initialized)
2625                                 *on_mode = get_mode(&adapter->bdaddr, "on");
2626                         else {
2627                                 *on_mode = main_opts.mode;
2628                                 adapter->initialized = TRUE;
2629                         }
2630                 } else if (read_on_mode(address, str, sizeof(str)) < 0)
2631                         *on_mode = main_opts.mode;
2632                 else
2633                         *on_mode = get_mode(&adapter->bdaddr, str);
2634         }
2635
2636         if (pairable)
2637                 *pairable = adapter->pairable;
2638 }
2639
2640 void btd_adapter_start(struct btd_adapter *adapter)
2641 {
2642         char address[18];
2643         uint8_t cls[3];
2644         gboolean powered;
2645
2646         ba2str(&adapter->bdaddr, address);
2647
2648         adapter->dev_class = 0;
2649         adapter->off_requested = FALSE;
2650         adapter->up = TRUE;
2651         adapter->discov_timeout = get_discoverable_timeout(address);
2652         adapter->pairable_timeout = get_pairable_timeout(address);
2653         adapter->state = STATE_IDLE;
2654         adapter->mode = MODE_CONNECTABLE;
2655
2656         if (main_opts.le)
2657                 adapter_ops->enable_le(adapter->dev_id);
2658
2659         adapter_ops->set_name(adapter->dev_id, adapter->dev.name);
2660
2661         if (read_local_class(&adapter->bdaddr, cls) < 0) {
2662                 uint32_t class = htobl(main_opts.class);
2663                 memcpy(cls, &class, 3);
2664         }
2665
2666         btd_adapter_set_class(adapter, cls[1], cls[0]);
2667
2668         powered = TRUE;
2669         emit_property_changed(connection, adapter->path,
2670                                         ADAPTER_INTERFACE, "Powered",
2671                                         DBUS_TYPE_BOOLEAN, &powered);
2672
2673         call_adapter_powered_callbacks(adapter, TRUE);
2674
2675         adapter_ops->disable_cod_cache(adapter->dev_id);
2676
2677         info("Adapter %s has been enabled", adapter->path);
2678 }
2679
2680 static void reply_pending_requests(struct btd_adapter *adapter)
2681 {
2682         GSList *l;
2683
2684         if (!adapter)
2685                 return;
2686
2687         /* pending bonding */
2688         for (l = adapter->devices; l; l = l->next) {
2689                 struct btd_device *device = l->data;
2690
2691                 if (device_is_bonding(device, NULL))
2692                         device_cancel_bonding(device,
2693                                                 HCI_OE_USER_ENDED_CONNECTION);
2694         }
2695 }
2696
2697 static void remove_driver(gpointer data, gpointer user_data)
2698 {
2699         struct btd_adapter_driver *driver = data;
2700         struct btd_adapter *adapter = user_data;
2701
2702         if (driver->remove)
2703                 driver->remove(adapter);
2704 }
2705
2706 static void unload_drivers(struct btd_adapter *adapter)
2707 {
2708         g_slist_foreach(adapter->loaded_drivers, remove_driver, adapter);
2709         g_slist_free(adapter->loaded_drivers);
2710         adapter->loaded_drivers = NULL;
2711 }
2712
2713 static void set_mode_complete(struct btd_adapter *adapter)
2714 {
2715         struct session_req *pending;
2716         const char *modestr;
2717         int err;
2718
2719         DBG("");
2720
2721         if (adapter->pending_mode == NULL)
2722                 return;
2723
2724         pending = adapter->pending_mode;
2725         adapter->pending_mode = NULL;
2726
2727         err = (pending->mode != adapter->mode) ? -EINVAL : 0;
2728
2729         if (pending->msg != NULL) {
2730                 DBusMessage *msg = pending->msg;
2731                 DBusMessage *reply;
2732
2733                 if (err < 0)
2734                         reply = btd_error_failed(msg, strerror(-err));
2735                 else {
2736                         if (strcmp(dbus_message_get_member(msg),
2737                                                 "SetProperty") == 0)
2738                                 adapter->global_mode = adapter->mode;
2739                         reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2740                 }
2741
2742                 g_dbus_send_message(connection, reply);
2743         }
2744
2745         modestr = mode2str(adapter->mode);
2746
2747         DBG("%s", modestr);
2748
2749         /* restore if the mode doesn't matches the pending */
2750         if (err != 0) {
2751                 write_device_mode(&adapter->bdaddr, modestr);
2752                 error("unable to set mode: %s", mode2str(pending->mode));
2753         }
2754
2755         session_unref(pending);
2756 }
2757
2758 int btd_adapter_stop(struct btd_adapter *adapter)
2759 {
2760         gboolean powered, discoverable, pairable;
2761 #ifdef __TIZEN_PATCH__
2762         gboolean limited;
2763 #endif
2764
2765         /* cancel pending timeout */
2766         if (adapter->discov_timeout_id) {
2767                 g_source_remove(adapter->discov_timeout_id);
2768                 adapter->discov_timeout_id = 0;
2769         }
2770
2771         /* check pending requests */
2772         reply_pending_requests(adapter);
2773
2774         stop_discovery(adapter, FALSE);
2775
2776         if (adapter->disc_sessions) {
2777                 g_slist_foreach(adapter->disc_sessions, (GFunc) session_free,
2778                                 NULL);
2779                 g_slist_free(adapter->disc_sessions);
2780                 adapter->disc_sessions = NULL;
2781         }
2782
2783         while (adapter->connections) {
2784                 struct btd_device *device = adapter->connections->data;
2785                 adapter_remove_connection(adapter, device);
2786         }
2787
2788         if (adapter->scan_mode == (SCAN_PAGE | SCAN_INQUIRY)) {
2789                 discoverable = FALSE;
2790                 emit_property_changed(connection, adapter->path,
2791                                         ADAPTER_INTERFACE, "Discoverable",
2792                                         DBUS_TYPE_BOOLEAN, &discoverable);
2793         }
2794
2795         if ((adapter->scan_mode & SCAN_PAGE) && adapter->pairable == TRUE) {
2796                 pairable = FALSE;
2797                 emit_property_changed(connection, adapter->path,
2798                                         ADAPTER_INTERFACE, "Pairable",
2799                                         DBUS_TYPE_BOOLEAN, &pairable);
2800         }
2801
2802         powered = FALSE;
2803         emit_property_changed(connection, adapter->path, ADAPTER_INTERFACE,
2804                                 "Powered", DBUS_TYPE_BOOLEAN, &powered);
2805
2806         adapter->up = 0;
2807         adapter->scan_mode = SCAN_DISABLED;
2808         adapter->mode = MODE_OFF;
2809         adapter->state = STATE_IDLE;
2810         adapter->off_requested = FALSE;
2811         adapter->name_stored = FALSE;
2812
2813         call_adapter_powered_callbacks(adapter, FALSE);
2814
2815         info("Adapter %s has been disabled", adapter->path);
2816
2817         set_mode_complete(adapter);
2818
2819         return 0;
2820 }
2821
2822 int adapter_update_ssp_mode(struct btd_adapter *adapter, uint8_t mode)
2823 {
2824         struct hci_dev *dev = &adapter->dev;
2825
2826         dev->ssp_mode = mode;
2827
2828         return 0;
2829 }
2830
2831 static void adapter_free(gpointer user_data)
2832 {
2833         struct btd_adapter *adapter = user_data;
2834
2835         agent_free(adapter->agent);
2836         adapter->agent = NULL;
2837
2838         DBG("%p", adapter);
2839
2840         if (adapter->auth_idle_id)
2841                 g_source_remove(adapter->auth_idle_id);
2842
2843         sdp_list_free(adapter->services, NULL);
2844
2845         g_slist_foreach(adapter->found_devices, (GFunc) dev_info_free, NULL);
2846         g_slist_free(adapter->found_devices);
2847
2848         g_slist_free(adapter->oor_devices);
2849
2850         g_free(adapter->path);
2851         g_free(adapter);
2852 }
2853
2854 struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
2855 {
2856         adapter->ref++;
2857
2858         DBG("%p: ref=%d", adapter, adapter->ref);
2859
2860         return adapter;
2861 }
2862
2863 void btd_adapter_unref(struct btd_adapter *adapter)
2864 {
2865         gchar *path;
2866
2867         adapter->ref--;
2868
2869         DBG("%p: ref=%d", adapter, adapter->ref);
2870
2871         if (adapter->ref > 0)
2872                 return;
2873
2874         path = g_strdup(adapter->path);
2875
2876         g_dbus_unregister_interface(connection, path, ADAPTER_INTERFACE);
2877
2878         g_free(path);
2879 }
2880
2881 gboolean adapter_init(struct btd_adapter *adapter)
2882 {
2883         struct hci_version ver;
2884         struct hci_dev *dev;
2885         int err;
2886
2887         /* adapter_ops makes sure that newly registered adapters always
2888          * start off as powered */
2889         adapter->up = TRUE;
2890
2891         adapter_ops->read_bdaddr(adapter->dev_id, &adapter->bdaddr);
2892
2893         if (bacmp(&adapter->bdaddr, BDADDR_ANY) == 0) {
2894                 error("No address available for hci%d", adapter->dev_id);
2895                 return FALSE;
2896         }
2897
2898         err = adapter_ops->read_local_version(adapter->dev_id, &ver);
2899         if (err < 0) {
2900                 error("Can't read version info for hci%d: %s (%d)",
2901                                         adapter->dev_id, strerror(-err), -err);
2902                 return FALSE;
2903         }
2904
2905         dev = &adapter->dev;
2906
2907         dev->hci_rev = ver.hci_rev;
2908         dev->lmp_ver = ver.lmp_ver;
2909         dev->lmp_subver = ver.lmp_subver;
2910         dev->manufacturer = ver.manufacturer;
2911
2912         err = adapter_ops->read_local_features(adapter->dev_id, dev->features);
2913         if (err < 0) {
2914                 error("Can't read features for hci%d: %s (%d)",
2915                                         adapter->dev_id, strerror(-err), -err);
2916                 return FALSE;
2917         }
2918
2919         if (read_local_name(&adapter->bdaddr, adapter->dev.name) < 0)
2920                 expand_name(adapter->dev.name, MAX_NAME_LENGTH, main_opts.name,
2921                                                         adapter->dev_id);
2922
2923         if (main_opts.attrib_server)
2924                 attrib_gap_set(GATT_CHARAC_DEVICE_NAME,
2925                         (const uint8_t *) dev->name, strlen(dev->name));
2926
2927         sdp_init_services_list(&adapter->bdaddr);
2928         load_drivers(adapter);
2929         clear_blocked(adapter);
2930         load_devices(adapter);
2931
2932         /* Set pairable mode */
2933         if (read_device_pairable(&adapter->bdaddr, &adapter->pairable) < 0)
2934                 adapter->pairable = TRUE;
2935
2936         /* retrieve the active connections: address the scenario where
2937          * the are active connections before the daemon've started */
2938         load_connections(adapter);
2939
2940         return TRUE;
2941 }
2942
2943 struct btd_adapter *adapter_create(DBusConnection *conn, int id)
2944 {
2945         char path[MAX_PATH_LENGTH];
2946         struct btd_adapter *adapter;
2947         const char *base_path = manager_get_base_path();
2948
2949         if (!connection)
2950                 connection = conn;
2951
2952         adapter = g_try_new0(struct btd_adapter, 1);
2953         if (!adapter) {
2954                 error("adapter_create: failed to alloc memory for hci%d", id);
2955                 return NULL;
2956         }
2957
2958         adapter->dev_id = id;
2959
2960         snprintf(path, sizeof(path), "%s/hci%d", base_path, id);
2961         adapter->path = g_strdup(path);
2962
2963         if (!g_dbus_register_interface(conn, path, ADAPTER_INTERFACE,
2964                                         adapter_methods, adapter_signals, NULL,
2965                                         adapter, adapter_free)) {
2966                 error("Adapter interface init failed on path %s", path);
2967                 adapter_free(adapter);
2968                 return NULL;
2969         }
2970
2971         return btd_adapter_ref(adapter);
2972 }
2973
2974 void adapter_remove(struct btd_adapter *adapter)
2975 {
2976         GSList *l;
2977
2978         DBG("Removing adapter %s", adapter->path);
2979
2980         for (l = adapter->devices; l; l = l->next)
2981                 device_remove(l->data, FALSE);
2982         g_slist_free(adapter->devices);
2983
2984         unload_drivers(adapter);
2985
2986         /* Return adapter to down state if it was not up on init */
2987         adapter_ops->restore_powered(adapter->dev_id);
2988
2989         btd_adapter_unref(adapter);
2990 }
2991
2992 uint16_t adapter_get_dev_id(struct btd_adapter *adapter)
2993 {
2994         return adapter->dev_id;
2995 }
2996
2997 const gchar *adapter_get_path(struct btd_adapter *adapter)
2998 {
2999         if (!adapter)
3000                 return NULL;
3001
3002         return adapter->path;
3003 }
3004
3005 void adapter_get_address(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3006 {
3007         bacpy(bdaddr, &adapter->bdaddr);
3008 }
3009
3010 void adapter_set_state(struct btd_adapter *adapter, int state)
3011 {
3012         const char *path = adapter->path;
3013         gboolean discov_active;
3014         int previous, type;
3015
3016         if (adapter->state == state)
3017                 return;
3018
3019         previous = adapter->state;
3020         adapter->state = state;
3021
3022         type = adapter_get_discover_type(adapter);
3023
3024         switch (state) {
3025         case STATE_STDINQ:
3026         case STATE_PINQ:
3027                 discov_active = TRUE;
3028
3029                 /* Started a new session while resolving names ? */
3030                 if (previous & STATE_RESOLVNAME)
3031                         return;
3032                 break;
3033         case STATE_LE_SCAN:
3034                 /* Scanning enabled */
3035                 adapter->stop_discov_id = g_timeout_add(5120,
3036                                                 stop_scanning, adapter);
3037
3038                 /* For dual mode: don't send "Discovering = TRUE"  */
3039                 if (bredr_capable(adapter) == TRUE)
3040                         return;
3041
3042                 /* LE only */
3043                 discov_active = TRUE;
3044
3045                 break;
3046         case STATE_IDLE:
3047                 /*
3048                  * Interleave: from inquiry to scanning. Interleave is not
3049                  * applicable to requests triggered by external applications.
3050                  */
3051                 if (adapter->disc_sessions && (type & DISC_INTERLEAVE) &&
3052                                                 (previous & STATE_STDINQ)) {
3053                         adapter_ops->start_scanning(adapter->dev_id);
3054                         return;
3055                 }
3056                 /* BR/EDR only: inquiry finished */
3057                 discov_active = FALSE;
3058                 break;
3059         default:
3060                 discov_active = FALSE;
3061                 break;
3062         }
3063
3064         if (discov_active == FALSE) {
3065                 if (type & DISC_RESOLVNAME) {
3066                         if (adapter_resolve_names(adapter) == 0) {
3067                                 adapter->state |= STATE_RESOLVNAME;
3068                                 return;
3069                         }
3070                 }
3071
3072                 update_oor_devices(adapter);
3073         } else if (adapter->disc_sessions && main_opts.discov_interval)
3074                         adapter->scheduler_id = g_timeout_add_seconds(
3075                                                 main_opts.discov_interval,
3076                                                 (GSourceFunc) start_discovery,
3077                                                 adapter);
3078
3079         emit_property_changed(connection, path,
3080                                 ADAPTER_INTERFACE, "Discovering",
3081                                 DBUS_TYPE_BOOLEAN, &discov_active);
3082 }
3083
3084 int adapter_get_state(struct btd_adapter *adapter)
3085 {
3086         return adapter->state;
3087 }
3088
3089 struct remote_dev_info *adapter_search_found_devices(struct btd_adapter *adapter,
3090                                                 struct remote_dev_info *match)
3091 {
3092         GSList *l;
3093
3094         l = g_slist_find_custom(adapter->found_devices, match,
3095                                         (GCompareFunc) found_device_cmp);
3096         if (l)
3097                 return l->data;
3098
3099         return NULL;
3100 }
3101
3102 static int dev_rssi_cmp(struct remote_dev_info *d1, struct remote_dev_info *d2)
3103 {
3104         int rssi1, rssi2;
3105
3106         rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi;
3107         rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi;
3108
3109         return rssi1 - rssi2;
3110 }
3111
3112 static void append_dict_valist(DBusMessageIter *iter,
3113                                         const char *first_key,
3114                                         va_list var_args)
3115 {
3116         DBusMessageIter dict;
3117         const char *key;
3118         int type;
3119         int n_elements;
3120         void *val;
3121
3122         dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
3123                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
3124                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
3125                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
3126
3127         key = first_key;
3128         while (key) {
3129                 type = va_arg(var_args, int);
3130                 val = va_arg(var_args, void *);
3131                 if (type == DBUS_TYPE_ARRAY) {
3132                         n_elements = va_arg(var_args, int);
3133                         if (n_elements > 0)
3134                                 dict_append_array(&dict, key, DBUS_TYPE_STRING,
3135                                                 val, n_elements);
3136                 } else
3137                         dict_append_entry(&dict, key, type, val);
3138                 key = va_arg(var_args, char *);
3139         }
3140
3141         dbus_message_iter_close_container(iter, &dict);
3142 }
3143
3144 static void emit_device_found(const char *path, const char *address,
3145                                 const char *first_key, ...)
3146 {
3147         DBusMessage *signal;
3148         DBusMessageIter iter;
3149         va_list var_args;
3150
3151         signal = dbus_message_new_signal(path, ADAPTER_INTERFACE,
3152                                         "DeviceFound");
3153         if (!signal) {
3154                 error("Unable to allocate new %s.DeviceFound signal",
3155                                 ADAPTER_INTERFACE);
3156                 return;
3157         }
3158         dbus_message_iter_init_append(signal, &iter);
3159         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &address);
3160
3161         va_start(var_args, first_key);
3162         append_dict_valist(&iter, first_key, var_args);
3163         va_end(var_args);
3164
3165         g_dbus_send_message(connection, signal);
3166 }
3167
3168 static char **strlist2array(GSList *list)
3169 {
3170         GSList *l;
3171         unsigned int i, n;
3172         char **array;
3173
3174         if (list == NULL)
3175                 return NULL;
3176
3177         n = g_slist_length(list);
3178         array = g_new0(char *, n + 1);
3179
3180         for (l = list, i = 0; l; l = l->next, i++)
3181                 array[i] = g_strdup((const gchar *) l->data);
3182
3183         return array;
3184 }
3185
3186 void adapter_emit_device_found(struct btd_adapter *adapter,
3187                                                 struct remote_dev_info *dev)
3188 {
3189         struct btd_device *device;
3190         char peer_addr[18], local_addr[18];
3191         const char *icon, *paddr = peer_addr;
3192         dbus_bool_t paired = FALSE;
3193         dbus_int16_t rssi = dev->rssi;
3194         char *alias;
3195         size_t uuid_count;
3196
3197         ba2str(&dev->bdaddr, peer_addr);
3198         ba2str(&adapter->bdaddr, local_addr);
3199
3200         device = adapter_find_device(adapter, paddr);
3201         if (device)
3202                 paired = device_is_paired(device);
3203
3204         /* The uuids string array is updated only if necessary */
3205         uuid_count = g_slist_length(dev->services);
3206         if (dev->services && dev->uuid_count != uuid_count) {
3207                 g_strfreev(dev->uuids);
3208                 dev->uuids = strlist2array(dev->services);
3209                 dev->uuid_count = uuid_count;
3210         }
3211
3212         if (dev->le) {
3213                 gboolean broadcaster;
3214
3215                 if (dev->flags & (EIR_LIM_DISC | EIR_GEN_DISC))
3216                         broadcaster = FALSE;
3217                 else
3218                         broadcaster = TRUE;
3219
3220                 emit_device_found(adapter->path, paddr,
3221                                 "Address", DBUS_TYPE_STRING, &paddr,
3222                                 "RSSI", DBUS_TYPE_INT16, &rssi,
3223                                 "Name", DBUS_TYPE_STRING, &dev->name,
3224                                 "Paired", DBUS_TYPE_BOOLEAN, &paired,
3225                                 "Broadcaster", DBUS_TYPE_BOOLEAN, &broadcaster,
3226                                 "UUIDs", DBUS_TYPE_ARRAY, &dev->uuids, uuid_count,
3227                                 NULL);
3228                 return;
3229         }
3230
3231         icon = class_to_icon(dev->class);
3232
3233         if (!dev->alias) {
3234                 if (!dev->name) {
3235                         alias = g_strdup(peer_addr);
3236                         g_strdelimit(alias, ":", '-');
3237                 } else
3238                         alias = g_strdup(dev->name);
3239         } else
3240                 alias = g_strdup(dev->alias);
3241
3242         emit_device_found(adapter->path, paddr,
3243                         "Address", DBUS_TYPE_STRING, &paddr,
3244                         "Class", DBUS_TYPE_UINT32, &dev->class,
3245                         "Icon", DBUS_TYPE_STRING, &icon,
3246                         "RSSI", DBUS_TYPE_INT16, &rssi,
3247                         "Name", DBUS_TYPE_STRING, &dev->name,
3248                         "Alias", DBUS_TYPE_STRING, &alias,
3249                         "LegacyPairing", DBUS_TYPE_BOOLEAN, &dev->legacy,
3250                         "Paired", DBUS_TYPE_BOOLEAN, &paired,
3251                         "UUIDs", DBUS_TYPE_ARRAY, &dev->uuids, uuid_count,
3252                         NULL);
3253
3254         g_free(alias);
3255 }
3256
3257 static struct remote_dev_info *get_found_dev(struct btd_adapter *adapter,
3258                                                 const bdaddr_t *bdaddr,
3259                                                 gboolean *new_dev)
3260 {
3261         struct remote_dev_info *dev, match;
3262
3263         memset(&match, 0, sizeof(struct remote_dev_info));
3264         bacpy(&match.bdaddr, bdaddr);
3265         match.name_status = NAME_ANY;
3266
3267         dev = adapter_search_found_devices(adapter, &match);
3268         if (dev) {
3269                 *new_dev = FALSE;
3270                 /* Out of range list update */
3271                 adapter->oor_devices = g_slist_remove(adapter->oor_devices,
3272                                                         dev);
3273         } else {
3274                 *new_dev = TRUE;
3275                 dev = g_new0(struct remote_dev_info, 1);
3276                 bacpy(&dev->bdaddr, bdaddr);
3277                 adapter->found_devices = g_slist_prepend(adapter->found_devices,
3278                                                                         dev);
3279         }
3280
3281         return dev;
3282 }
3283
3284 static void remove_same_uuid(gpointer data, gpointer user_data)
3285 {
3286         struct remote_dev_info *dev = user_data;
3287         GSList *l;
3288
3289         for (l = dev->services; l; l = l->next) {
3290                 char *current_uuid = l->data;
3291                 char *new_uuid = data;
3292
3293                 if (strcmp(current_uuid, new_uuid) == 0) {
3294                         g_free(current_uuid);
3295                         dev->services = g_slist_delete_link(dev->services, l);
3296                         break;
3297                 }
3298         }
3299 }
3300
3301 static void dev_prepend_uuid(gpointer data, gpointer user_data)
3302 {
3303         struct remote_dev_info *dev = user_data;
3304         char *new_uuid = data;
3305
3306         dev->services = g_slist_prepend(dev->services, g_strdup(new_uuid));
3307 }
3308
3309 void adapter_update_device_from_info(struct btd_adapter *adapter,
3310                                         bdaddr_t bdaddr, int8_t rssi,
3311                                         uint8_t evt_type, const char *name,
3312                                         GSList *services, int flags)
3313 {
3314         struct remote_dev_info *dev;
3315         gboolean new_dev;
3316
3317         dev = get_found_dev(adapter, &bdaddr, &new_dev);
3318
3319         if (new_dev) {
3320                 dev->le = TRUE;
3321                 dev->evt_type = evt_type;
3322         } else if (dev->rssi == rssi)
3323                 return;
3324
3325         dev->rssi = rssi;
3326
3327         adapter->found_devices = g_slist_sort(adapter->found_devices,
3328                                                 (GCompareFunc) dev_rssi_cmp);
3329
3330         g_slist_foreach(services, remove_same_uuid, dev);
3331         g_slist_foreach(services, dev_prepend_uuid, dev);
3332
3333         if (flags >= 0)
3334                 dev->flags = flags;
3335
3336         if (name) {
3337                 g_free(dev->name);
3338                 dev->name = g_strdup(name);
3339         }
3340
3341         /* FIXME: check if other information was changed before emitting the
3342          * signal */
3343         adapter_emit_device_found(adapter, dev);
3344 }
3345
3346 void adapter_update_found_devices(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3347                                 int8_t rssi, uint32_t class, const char *name,
3348                                 const char *alias, gboolean legacy,
3349                                 GSList *services, name_status_t name_status)
3350 {
3351         struct remote_dev_info *dev;
3352         gboolean new_dev;
3353
3354         dev = get_found_dev(adapter, bdaddr, &new_dev);
3355
3356         if (new_dev) {
3357                 if (name)
3358                         dev->name = g_strdup(name);
3359
3360                 if (alias)
3361                         dev->alias = g_strdup(alias);
3362
3363                 dev->le = FALSE;
3364                 dev->class = class;
3365                 dev->legacy = legacy;
3366                 dev->name_status = name_status;
3367         } else if (dev->rssi == rssi)
3368                 return;
3369
3370         dev->rssi = rssi;
3371
3372         adapter->found_devices = g_slist_sort(adapter->found_devices,
3373                                                 (GCompareFunc) dev_rssi_cmp);
3374
3375         g_slist_foreach(services, remove_same_uuid, dev);
3376         g_slist_foreach(services, dev_prepend_uuid, dev);
3377
3378         adapter_emit_device_found(adapter, dev);
3379 }
3380
3381 int adapter_remove_found_device(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3382 {
3383         struct remote_dev_info *dev, match;
3384
3385         memset(&match, 0, sizeof(struct remote_dev_info));
3386         bacpy(&match.bdaddr, bdaddr);
3387
3388         dev = adapter_search_found_devices(adapter, &match);
3389         if (!dev)
3390                 return -1;
3391
3392         dev->name_status = NAME_NOT_REQUIRED;
3393
3394         return 0;
3395 }
3396
3397 void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
3398 {
3399         const gchar *path = adapter_get_path(adapter);
3400         gboolean discoverable, pairable;
3401
3402         DBG("old 0x%02x new 0x%02x", adapter->scan_mode, scan_mode);
3403 #ifdef __TIZEN_PATCH__
3404         gboolean limited;
3405 #endif
3406
3407         if (adapter->scan_mode == scan_mode)
3408                 return;
3409
3410         adapter_remove_discov_timeout(adapter);
3411
3412         switch (scan_mode) {
3413         case SCAN_DISABLED:
3414                 adapter->mode = MODE_OFF;
3415                 discoverable = FALSE;
3416                 pairable = FALSE;
3417 #ifdef __TIZEN_PATCH__
3418                 limited = FALSE;
3419 #endif
3420                 break;
3421         case SCAN_PAGE:
3422                 adapter->mode = MODE_CONNECTABLE;
3423                 discoverable = FALSE;
3424                 pairable = adapter->pairable;
3425 #ifdef __TIZEN_PATCH__
3426                 limited = FALSE;
3427 #endif
3428                 break;
3429         case (SCAN_PAGE | SCAN_INQUIRY):
3430                 adapter->mode = MODE_DISCOVERABLE;
3431                 discoverable = TRUE;
3432                 pairable = adapter->pairable;
3433                 if (adapter->discov_timeout != 0)
3434                         adapter_set_discov_timeout(adapter,
3435                                                 adapter->discov_timeout);
3436                 break;
3437         case SCAN_INQUIRY:
3438                 /* Address the scenario where a low-level application like
3439                  * hciconfig changed the scan mode */
3440                 if (adapter->discov_timeout != 0)
3441                         adapter_set_discov_timeout(adapter,
3442                                                 adapter->discov_timeout);
3443
3444                 /* ignore, this event should not be sent */
3445         default:
3446                 /* ignore, reserved */
3447                 return;
3448         }
3449
3450         /* If page scanning gets toggled emit the Pairable property */
3451         if ((adapter->scan_mode & SCAN_PAGE) != (scan_mode & SCAN_PAGE))
3452                 emit_property_changed(connection, adapter->path,
3453                                         ADAPTER_INTERFACE, "Pairable",
3454                                         DBUS_TYPE_BOOLEAN, &pairable);
3455
3456         if (!discoverable)
3457                 adapter_set_limited_discoverable(adapter, FALSE);
3458
3459         emit_property_changed(connection, path,
3460                                 ADAPTER_INTERFACE, "Discoverable",
3461                                 DBUS_TYPE_BOOLEAN, &discoverable);
3462
3463         adapter->scan_mode = scan_mode;
3464
3465         set_mode_complete(adapter);
3466 }
3467
3468 struct agent *adapter_get_agent(struct btd_adapter *adapter)
3469 {
3470         if (!adapter || !adapter->agent)
3471                 return NULL;
3472
3473         return adapter->agent;
3474 }
3475
3476 void adapter_add_connection(struct btd_adapter *adapter,
3477                                                 struct btd_device *device)
3478 {
3479         if (g_slist_find(adapter->connections, device)) {
3480                 error("Device is already marked as connected");
3481                 return;
3482         }
3483
3484         device_add_connection(device, connection);
3485
3486         adapter->connections = g_slist_append(adapter->connections, device);
3487 }
3488
3489 void adapter_remove_connection(struct btd_adapter *adapter,
3490                                                 struct btd_device *device)
3491 {
3492         bdaddr_t bdaddr;
3493
3494         DBG("");
3495
3496         if (!g_slist_find(adapter->connections, device)) {
3497                 error("No matching connection for device");
3498                 return;
3499         }
3500
3501         device_remove_connection(device, connection);
3502
3503         adapter->connections = g_slist_remove(adapter->connections, device);
3504
3505         /* clean pending HCI cmds */
3506         device_get_address(device, &bdaddr);
3507
3508         if (device_is_authenticating(device))
3509                 device_cancel_authentication(device, TRUE);
3510
3511         if (device_is_temporary(device)) {
3512                 const char *path = device_get_path(device);
3513
3514                 DBG("Removing temporary device %s", path);
3515                 adapter_remove_device(connection, adapter, device, TRUE);
3516         }
3517 }
3518
3519 gboolean adapter_has_discov_sessions(struct btd_adapter *adapter)
3520 {
3521         if (!adapter || !adapter->disc_sessions)
3522                 return FALSE;
3523
3524         return TRUE;
3525 }
3526
3527 void adapter_suspend_discovery(struct btd_adapter *adapter)
3528 {
3529         if (adapter->disc_sessions == NULL ||
3530                         adapter->state & STATE_SUSPENDED)
3531                 return;
3532
3533         DBG("Suspending discovery");
3534
3535         stop_discovery(adapter, TRUE);
3536         adapter->state |= STATE_SUSPENDED;
3537 }
3538
3539 void adapter_resume_discovery(struct btd_adapter *adapter)
3540 {
3541         if (adapter->disc_sessions == NULL)
3542                 return;
3543
3544         DBG("Resuming discovery");
3545
3546         adapter->state &= ~STATE_SUSPENDED;
3547         start_discovery(adapter);
3548 }
3549
3550 int btd_register_adapter_driver(struct btd_adapter_driver *driver)
3551 {
3552         adapter_drivers = g_slist_append(adapter_drivers, driver);
3553
3554         if (driver->probe == NULL)
3555                 return 0;
3556
3557         manager_foreach_adapter(probe_driver, driver);
3558
3559         return 0;
3560 }
3561
3562 static void unload_driver(struct btd_adapter *adapter, gpointer data)
3563 {
3564         adapter->loaded_drivers = g_slist_remove(adapter->loaded_drivers, data);
3565 }
3566
3567 void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
3568 {
3569         adapter_drivers = g_slist_remove(adapter_drivers, driver);
3570
3571         manager_foreach_adapter(unload_driver, driver);
3572 }
3573
3574 static void agent_auth_cb(struct agent *agent, DBusError *derr,
3575                                                         void *user_data)
3576 {
3577         struct service_auth *auth = user_data;
3578
3579         device_set_authorizing(auth->device, FALSE);
3580
3581         auth->cb(derr, auth->user_data);
3582 }
3583
3584 static gboolean auth_idle_cb(gpointer user_data)
3585 {
3586         struct service_auth *auth = user_data;
3587         struct btd_adapter *adapter = auth->adapter;
3588
3589         adapter->auth_idle_id = 0;
3590
3591         auth->cb(NULL, auth->user_data);
3592
3593         return FALSE;
3594 }
3595
3596 static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
3597                                         const char *uuid, service_auth_cb cb,
3598                                         void *user_data)
3599 {
3600         struct service_auth *auth;
3601         struct btd_device *device;
3602         struct agent *agent;
3603         char address[18];
3604         const gchar *dev_path;
3605         int err;
3606
3607         ba2str(dst, address);
3608         device = adapter_find_device(adapter, address);
3609         if (!device)
3610                 return -EPERM;
3611
3612         /* Device connected? */
3613         if (!g_slist_find(adapter->connections, device))
3614                 return -ENOTCONN;
3615
3616         if (adapter->auth_idle_id)
3617                 return -EBUSY;
3618
3619         auth = g_try_new0(struct service_auth, 1);
3620         if (!auth)
3621                 return -ENOMEM;
3622
3623         auth->cb = cb;
3624         auth->user_data = user_data;
3625         auth->device = device;
3626         auth->adapter = adapter;
3627
3628         if (device_is_trusted(device) == TRUE) {
3629                 adapter->auth_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
3630                                                         auth_idle_cb, auth,
3631                                                         g_free);
3632                 return 0;
3633         }
3634
3635         agent = device_get_agent(device);
3636         if (!agent) {
3637                 g_free(auth);
3638                 return -EPERM;
3639         }
3640
3641         dev_path = device_get_path(device);
3642
3643         err = agent_authorize(agent, dev_path, uuid, agent_auth_cb, auth, g_free);
3644         if (err < 0)
3645                 g_free(auth);
3646         else
3647                 device_set_authorizing(device, TRUE);
3648
3649         return err;
3650 }
3651
3652 int btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
3653                                         const char *uuid, service_auth_cb cb,
3654                                         void *user_data)
3655 {
3656         struct btd_adapter *adapter;
3657         GSList *l;
3658
3659         if (bacmp(src, BDADDR_ANY) != 0) {
3660                 adapter = manager_find_adapter(src);
3661                 if (!adapter)
3662                         return -EPERM;
3663
3664                 return adapter_authorize(adapter, dst, uuid, cb, user_data);
3665         }
3666
3667         for (l = manager_get_adapters(); l != NULL; l = g_slist_next(l)) {
3668                 int err;
3669
3670                 adapter = l->data;
3671
3672                 err = adapter_authorize(adapter, dst, uuid, cb, user_data);
3673                 if (err == 0)
3674                         return 0;
3675         }
3676
3677         return -EPERM;
3678 }
3679
3680 int btd_cancel_authorization(const bdaddr_t *src, const bdaddr_t *dst)
3681 {
3682         struct btd_adapter *adapter = manager_find_adapter(src);
3683         struct btd_device *device;
3684         struct agent *agent;
3685         char address[18];
3686         int err;
3687
3688         if (!adapter)
3689                 return -EPERM;
3690
3691         ba2str(dst, address);
3692         device = adapter_find_device(adapter, address);
3693         if (!device)
3694                 return -EPERM;
3695
3696         if (adapter->auth_idle_id) {
3697                 g_source_remove(adapter->auth_idle_id);
3698                 adapter->auth_idle_id = 0;
3699                 return 0;
3700         }
3701
3702         /*
3703          * FIXME: Cancel fails if authorization is requested to adapter's
3704          * agent and in the meanwhile CreatePairedDevice is called.
3705          */
3706
3707         agent = device_get_agent(device);
3708         if (!agent)
3709                 return -EPERM;
3710
3711         err = agent_cancel(agent);
3712
3713         if (err == 0)
3714                 device_set_authorizing(device, FALSE);
3715
3716         return err;
3717 }
3718
3719 static gchar *adapter_any_path = NULL;
3720 static int adapter_any_refcount = 0;
3721
3722 const char *adapter_any_get_path(void)
3723 {
3724         return adapter_any_path;
3725 }
3726
3727 const char *btd_adapter_any_request_path(void)
3728 {
3729         if (adapter_any_refcount++ > 0)
3730                 return adapter_any_path;
3731
3732         adapter_any_path = g_strdup_printf("%s/any", manager_get_base_path());
3733
3734         return adapter_any_path;
3735 }
3736
3737 void btd_adapter_any_release_path(void)
3738 {
3739         adapter_any_refcount--;
3740
3741         if (adapter_any_refcount > 0)
3742                 return;
3743
3744         g_free(adapter_any_path);
3745         adapter_any_path = NULL;
3746 }
3747
3748 gboolean adapter_is_pairable(struct btd_adapter *adapter)
3749 {
3750         return adapter->pairable;
3751 }
3752
3753 gboolean adapter_powering_down(struct btd_adapter *adapter)
3754 {
3755         return adapter->off_requested;
3756 }
3757
3758 int btd_adapter_restore_powered(struct btd_adapter *adapter)
3759 {
3760         char mode[14], address[18];
3761         gboolean discoverable;
3762
3763         if (!adapter_ops)
3764                 return -EINVAL;
3765
3766         if (!main_opts.remember_powered)
3767                 return -EINVAL;
3768
3769         if (adapter->up)
3770                 return 0;
3771
3772         ba2str(&adapter->bdaddr, address);
3773         if (read_device_mode(address, mode, sizeof(mode)) == 0 &&
3774                                                 g_str_equal(mode, "off"))
3775                 return 0;
3776
3777         discoverable = get_mode(&adapter->bdaddr, mode) == MODE_DISCOVERABLE;
3778
3779         return adapter_ops->set_powered(adapter->dev_id, TRUE);
3780 }
3781
3782 int btd_adapter_switch_online(struct btd_adapter *adapter)
3783 {
3784         if (!adapter_ops)
3785                 return -EINVAL;
3786
3787         if (adapter->up)
3788                 return 0;
3789
3790         return adapter_ops->set_powered(adapter->dev_id, TRUE);
3791 }
3792
3793 int btd_adapter_switch_offline(struct btd_adapter *adapter)
3794 {
3795         if (!adapter_ops)
3796                 return -EINVAL;
3797
3798         if (!adapter->up)
3799                 return 0;
3800
3801         return adapter_ops->set_powered(adapter->dev_id, FALSE);
3802 }
3803
3804 int btd_register_adapter_ops(struct btd_adapter_ops *ops, gboolean priority)
3805 {
3806         if (ops->setup == NULL)
3807                 return -EINVAL;
3808
3809         if (priority)
3810                 ops_candidates = g_slist_prepend(ops_candidates, ops);
3811         else
3812                 ops_candidates = g_slist_append(ops_candidates, ops);
3813
3814         return 0;
3815 }
3816
3817 void btd_adapter_cleanup_ops(struct btd_adapter_ops *ops)
3818 {
3819         ops_candidates = g_slist_remove(ops_candidates, ops);
3820         ops->cleanup();
3821
3822         if (adapter_ops == ops)
3823                 adapter_ops = NULL;
3824 }
3825
3826 int adapter_ops_setup(void)
3827 {
3828         GSList *l;
3829         int ret;
3830
3831         if (!ops_candidates)
3832                 return -EINVAL;
3833
3834         for (l = ops_candidates; l != NULL; l = g_slist_next(l)) {
3835                 struct btd_adapter_ops *ops = l->data;
3836
3837                 ret = ops->setup();
3838                 if (ret < 0)
3839                         continue;
3840
3841                 adapter_ops = ops;
3842                 break;
3843         }
3844
3845         return ret;
3846 }
3847
3848 void btd_adapter_register_powered_callback(struct btd_adapter *adapter,
3849                                                 btd_adapter_powered_cb cb)
3850 {
3851         adapter->powered_callbacks =
3852                         g_slist_append(adapter->powered_callbacks, cb);
3853 }
3854
3855 void btd_adapter_unregister_powered_callback(struct btd_adapter *adapter,
3856                                                 btd_adapter_powered_cb cb)
3857 {
3858         adapter->powered_callbacks =
3859                         g_slist_remove(adapter->powered_callbacks, cb);
3860 }
3861
3862 int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
3863                                                         gboolean enable)
3864 {
3865         if (!adapter_ops)
3866                 return -EINVAL;
3867
3868         if (!adapter->up)
3869                 return -EINVAL;
3870
3871         return adapter_ops->set_fast_connectable(adapter->dev_id, enable);
3872 }
3873
3874 int btd_adapter_read_clock(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3875                                 int which, int timeout, uint32_t *clock,
3876                                 uint16_t *accuracy)
3877 {
3878         if (!adapter_ops)
3879                 return -EINVAL;
3880
3881         if (!adapter->up)
3882                 return -EINVAL;
3883
3884         return adapter_ops->read_clock(adapter->dev_id, bdaddr, which,
3885                                                 timeout, clock, accuracy);
3886 }
3887
3888 int btd_adapter_disconnect_device(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3889 {
3890         return adapter_ops->disconnect(adapter->dev_id, bdaddr);
3891 }
3892
3893 int btd_adapter_remove_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3894 {
3895         return adapter_ops->remove_bonding(adapter->dev_id, bdaddr);
3896 }
3897
3898 int btd_adapter_pincode_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3899                                                         const char *pin)
3900 {
3901         return adapter_ops->pincode_reply(adapter->dev_id, bdaddr, pin);
3902 }
3903
3904 int btd_adapter_confirm_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3905                                                         gboolean success)
3906 {
3907         return adapter_ops->confirm_reply(adapter->dev_id, bdaddr, success);
3908 }
3909
3910 int btd_adapter_passkey_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3911                                                         uint32_t passkey)
3912 {
3913         return adapter_ops->passkey_reply(adapter->dev_id, bdaddr, passkey);
3914 }
3915
3916 void btd_adapter_update_local_ext_features(struct btd_adapter *adapter,
3917                                                 const uint8_t *features)
3918 {
3919         struct hci_dev *dev = &adapter->dev;
3920
3921         memcpy(dev->extfeatures, features, 8);
3922 }
3923
3924 int btd_adapter_encrypt_link(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3925                                         bt_hci_result_t cb, gpointer user_data)
3926 {
3927         return adapter_ops->encrypt_link(adapter->dev_id, bdaddr, cb, user_data);
3928 }
3929
3930 int btd_adapter_set_did(struct btd_adapter *adapter, uint16_t vendor,
3931                                         uint16_t product, uint16_t version)
3932 {
3933         return adapter_ops->set_did(adapter->dev_id, vendor, product, version);
3934 }
3935
3936 int adapter_create_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3937                                                                 uint8_t io_cap)
3938 {
3939         return adapter_ops->create_bonding(adapter->dev_id, bdaddr, io_cap);
3940 }
3941
3942 int adapter_cancel_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3943 {
3944         return adapter_ops->cancel_bonding(adapter->dev_id, bdaddr);
3945 }