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