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