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 (at) holtmann.org> 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * 23 */ 24 25 #ifdef HAVE_CONFIG_H 26 #include <config.h> 27 #endif 28 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <unistd.h> 32 #include <fcntl.h> 33 #include <sys/stat.h> 34 #include <sys/ioctl.h> 35 #include <errno.h> 36 37 #include <bluetooth/bluetooth.h> 38 #include <bluetooth/hci.h> 39 #include <bluetooth/hci_lib.h> 40 #include <bluetooth/l2cap.h> 41 #include <bluetooth/sdp.h> 42 #include <bluetooth/sdp_lib.h> 43 44 #include <glib.h> 45 #include <dbus/dbus.h> 46 #include <gdbus.h> 47 48 #include "log.h" 49 #include "textfile.h" 50 51 #include "hcid.h" 52 #include "adapter.h" 53 #include "device.h" 54 #include "dbus-common.h" 55 #include "dbus-hci.h" 56 #include "error.h" 57 #include "glib-helper.h" 58 #include "agent.h" 59 #include "sdp-xml.h" 60 #include "storage.h" 61 #include "btio.h" 62 63 #define DEFAULT_XML_BUF_SIZE 1024 64 #define DISCONNECT_TIMER 2 65 #define DISCOVERY_TIMER 2 66 67 struct btd_driver_data { 68 guint id; 69 struct btd_device_driver *driver; 70 void *priv; 71 }; 72 73 struct btd_disconnect_data { 74 guint id; 75 disconnect_watch watch; 76 void *user_data; 77 GDestroyNotify destroy; 78 }; 79 80 struct bonding_req { 81 DBusConnection *conn; 82 DBusMessage *msg; 83 GIOChannel *io; 84 guint listener_id; 85 struct btd_device *device; 86 }; 87 88 struct authentication_req { 89 auth_type_t type; 90 void *cb; 91 struct agent *agent; 92 struct btd_device *device; 93 }; 94 95 struct browse_req { 96 DBusConnection *conn; 97 DBusMessage *msg; 98 struct btd_device *device; 99 GSList *match_uuids; 100 GSList *profiles_added; 101 GSList *profiles_removed; 102 sdp_list_t *records; 103 int search_uuid; 104 int reconnect_attempt; 105 guint listener_id; 106 guint timer; 107 }; 108 109 struct btd_device { 110 bdaddr_t bdaddr; 111 gchar *path; 112 char name[MAX_NAME_LENGTH + 1]; 113 char *alias; 114 struct btd_adapter *adapter; 115 GSList *uuids; 116 GSList *drivers; /* List of driver_data */ 117 GSList *watches; /* List of disconnect_data */ 118 gboolean temporary; 119 struct agent *agent; 120 guint disconn_timer; 121 guint discov_timer; 122 struct browse_req *browse; /* service discover request */ 123 struct bonding_req *bonding; 124 struct authentication_req *authr; /* authentication request */ 125 GSList *disconnects; /* disconnects message */ 126 127 /* For Secure Simple Pairing */ 128 uint8_t cap; 129 uint8_t auth; 130 131 uint16_t handle; /* Connection handle */ 132 133 /* Whether were creating a security mode 3 connection */ 134 gboolean secmode3; 135 136 sdp_list_t *tmp_records; 137 138 gboolean trusted; 139 gboolean paired; 140 gboolean blocked; 141 gboolean renewed_key; 142 143 gboolean authorizing; 144 gint ref; 145 146 gboolean has_debug_key; 147 uint8_t debug_key[16]; 148 }; 149 150 static uint16_t uuid_list[] = { 151 L2CAP_UUID, 152 PNP_INFO_SVCLASS_ID, 153 PUBLIC_BROWSE_GROUP, 154 0 155 }; 156 157 static GSList *device_drivers = NULL; 158 159 static DBusHandlerResult error_failed(DBusConnection *conn, 160 DBusMessage *msg, const char * desc) 161 { 162 return error_common_reply(conn, msg, ERROR_INTERFACE ".Failed", desc); 163 } 164 165 static DBusHandlerResult error_failed_errno(DBusConnection *conn, 166 DBusMessage *msg, int err) 167 { 168 const char *desc = strerror(err); 169 170 return error_failed(conn, msg, desc); 171 } 172 173 static inline DBusMessage *no_such_adapter(DBusMessage *msg) 174 { 175 return g_dbus_create_error(msg, ERROR_INTERFACE ".NoSuchAdapter", 176 "No such adapter"); 177 } 178 179 static inline DBusMessage *in_progress(DBusMessage *msg, const char *str) 180 { 181 return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress", str); 182 } 183 184 static void browse_request_free(struct browse_req *req) 185 { 186 if (req->listener_id) 187 g_dbus_remove_watch(req->conn, req->listener_id); 188 if (req->msg) 189 dbus_message_unref(req->msg); 190 if (req->conn) 191 dbus_connection_unref(req->conn); 192 if (req->device) 193 btd_device_unref(req->device); 194 g_slist_foreach(req->profiles_added, (GFunc) g_free, NULL); 195 g_slist_free(req->profiles_added); 196 g_slist_free(req->profiles_removed); 197 if (req->records) 198 sdp_list_free(req->records, (sdp_free_func_t) sdp_record_free); 199 g_free(req); 200 } 201 202 static void browse_request_cancel(struct browse_req *req) 203 { 204 struct btd_device *device = req->device; 205 struct btd_adapter *adapter = device->adapter; 206 bdaddr_t src; 207 208 if (device_is_creating(device, NULL)) 209 device_set_temporary(device, TRUE); 210 211 adapter_get_address(adapter, &src); 212 213 bt_cancel_discovery(&src, &device->bdaddr); 214 215 device->browse = NULL; 216 browse_request_free(req); 217 } 218 219 static void device_free(gpointer user_data) 220 { 221 struct btd_device *device = user_data; 222 struct btd_adapter *adapter = device->adapter; 223 struct agent *agent = adapter_get_agent(adapter); 224 225 if (device->agent) 226 agent_free(device->agent); 227 228 if (agent && (agent_is_busy(agent, device) || 229 agent_is_busy(agent, device->authr))) 230 agent_cancel(agent); 231 232 g_slist_foreach(device->uuids, (GFunc) g_free, NULL); 233 g_slist_free(device->uuids); 234 235 if (device->tmp_records) 236 sdp_list_free(device->tmp_records, 237 (sdp_free_func_t) sdp_record_free); 238 239 if (device->disconn_timer) 240 g_source_remove(device->disconn_timer); 241 242 if (device->discov_timer) 243 g_source_remove(device->discov_timer); 244 245 DBG("%p", device); 246 247 g_free(device->authr); 248 g_free(device->path); 249 g_free(device->alias); 250 g_free(device); 251 } 252 253 gboolean device_is_paired(struct btd_device *device) 254 { 255 return device->paired; 256 } 257 258 gboolean device_is_trusted(struct btd_device *device) 259 { 260 return device->trusted; 261 } 262 263 static DBusMessage *get_properties(DBusConnection *conn, 264 DBusMessage *msg, void *user_data) 265 { 266 struct btd_device *device = user_data; 267 struct btd_adapter *adapter = device->adapter; 268 DBusMessage *reply; 269 DBusMessageIter iter; 270 DBusMessageIter dict; 271 bdaddr_t src; 272 char name[MAX_NAME_LENGTH + 1], srcaddr[18], dstaddr[18]; 273 char **uuids; 274 const char *ptr; 275 dbus_bool_t boolean; 276 uint32_t class; 277 int i; 278 GSList *l; 279 280 ba2str(&device->bdaddr, dstaddr); 281 282 reply = dbus_message_new_method_return(msg); 283 if (!reply) 284 return NULL; 285 286 dbus_message_iter_init_append(reply, &iter); 287 288 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, 289 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING 290 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING 291 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); 292 293 /* Address */ 294 ptr = dstaddr; 295 dict_append_entry(&dict, "Address", DBUS_TYPE_STRING, &ptr); 296 297 /* Name */ 298 ptr = NULL; 299 memset(name, 0, sizeof(name)); 300 adapter_get_address(adapter, &src); 301 ba2str(&src, srcaddr); 302 303 ptr = device->name; 304 dict_append_entry(&dict, "Name", DBUS_TYPE_STRING, &ptr); 305 306 /* Alias (fallback to name or address) */ 307 if (device->alias != NULL) 308 ptr = device->alias; 309 else if (strlen(ptr) == 0) { 310 g_strdelimit(dstaddr, ":", '-'); 311 ptr = dstaddr; 312 } 313 314 dict_append_entry(&dict, "Alias", DBUS_TYPE_STRING, &ptr); 315 316 /* Class */ 317 if (read_remote_class(&src, &device->bdaddr, &class) == 0) { 318 const char *icon = class_to_icon(class); 319 320 dict_append_entry(&dict, "Class", DBUS_TYPE_UINT32, &class); 321 322 if (icon) 323 dict_append_entry(&dict, "Icon", 324 DBUS_TYPE_STRING, &icon); 325 } 326 327 /* Paired */ 328 boolean = device_is_paired(device); 329 dict_append_entry(&dict, "Paired", DBUS_TYPE_BOOLEAN, &boolean); 330 331 /* Trusted */ 332 boolean = device_is_trusted(device); 333 dict_append_entry(&dict, "Trusted", DBUS_TYPE_BOOLEAN, &boolean); 334 335 /* Blocked */ 336 boolean = device->blocked; 337 dict_append_entry(&dict, "Blocked", DBUS_TYPE_BOOLEAN, &boolean); 338 339 /* Connected */ 340 boolean = (device->handle != 0); 341 dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, 342 &boolean); 343 344 /* UUIDs */ 345 uuids = g_new0(char *, g_slist_length(device->uuids) + 1); 346 for (i = 0, l = device->uuids; l; l = l->next, i++) 347 uuids[i] = l->data; 348 dict_append_array(&dict, "UUIDs", DBUS_TYPE_STRING, &uuids, i); 349 g_free(uuids); 350 351 /* Adapter */ 352 ptr = adapter_get_path(adapter); 353 dict_append_entry(&dict, "Adapter", DBUS_TYPE_OBJECT_PATH, &ptr); 354 355 dbus_message_iter_close_container(&iter, &dict); 356 357 return reply; 358 } 359 360 static DBusMessage *set_alias(DBusConnection *conn, DBusMessage *msg, 361 const char *alias, void *data) 362 { 363 struct btd_device *device = data; 364 struct btd_adapter *adapter = device->adapter; 365 char srcaddr[18], dstaddr[18]; 366 bdaddr_t src; 367 int err; 368 369 /* No change */ 370 if ((device->alias == NULL && g_str_equal(alias, "")) || 371 g_strcmp0(device->alias, alias) == 0) 372 return dbus_message_new_method_return(msg); 373 374 adapter_get_address(adapter, &src); 375 ba2str(&src, srcaddr); 376 ba2str(&device->bdaddr, dstaddr); 377 378 /* Remove alias if empty string */ 379 err = write_device_alias(srcaddr, dstaddr, 380 g_str_equal(alias, "") ? NULL : alias); 381 if (err < 0) 382 return g_dbus_create_error(msg, 383 ERROR_INTERFACE ".Failed", 384 strerror(-err)); 385 386 g_free(device->alias); 387 device->alias = g_str_equal(alias, "") ? NULL : g_strdup(alias); 388 389 emit_property_changed(conn, dbus_message_get_path(msg), 390 DEVICE_INTERFACE, "Alias", 391 DBUS_TYPE_STRING, &alias); 392 393 return dbus_message_new_method_return(msg); 394 } 395 396 static DBusMessage *set_trust(DBusConnection *conn, DBusMessage *msg, 397 gboolean value, void *data) 398 { 399 struct btd_device *device = data; 400 struct btd_adapter *adapter = device->adapter; 401 char srcaddr[18], dstaddr[18]; 402 bdaddr_t src; 403 int err; 404 405 if (device->trusted == value) 406 return dbus_message_new_method_return(msg); 407 408 adapter_get_address(adapter, &src); 409 ba2str(&src, srcaddr); 410 ba2str(&device->bdaddr, dstaddr); 411 412 err = write_trust(srcaddr, dstaddr, GLOBAL_TRUST, value); 413 if (err < 0) 414 return g_dbus_create_error(msg, 415 ERROR_INTERFACE ".Failed", 416 strerror(-err)); 417 418 device->trusted = value; 419 420 emit_property_changed(conn, dbus_message_get_path(msg), 421 DEVICE_INTERFACE, "Trusted", 422 DBUS_TYPE_BOOLEAN, &value); 423 424 return dbus_message_new_method_return(msg); 425 } 426 427 static void driver_remove(struct btd_driver_data *driver_data, 428 struct btd_device *device) 429 { 430 struct btd_device_driver *driver = driver_data->driver; 431 432 driver->remove(device); 433 434 device->drivers = g_slist_remove(device->drivers, driver_data); 435 g_free(driver_data); 436 } 437 438 static gboolean do_disconnect(gpointer user_data) 439 { 440 struct btd_device *device = user_data; 441 disconnect_cp cp; 442 int dd; 443 uint16_t dev_id = adapter_get_dev_id(device->adapter); 444 445 device->disconn_timer = 0; 446 447 dd = hci_open_dev(dev_id); 448 if (dd < 0) 449 goto fail; 450 451 memset(&cp, 0, sizeof(cp)); 452 cp.handle = htobs(device->handle); 453 cp.reason = HCI_OE_USER_ENDED_CONNECTION; 454 455 hci_send_cmd(dd, OGF_LINK_CTL, OCF_DISCONNECT, 456 DISCONNECT_CP_SIZE, &cp); 457 458 close(dd); 459 460 fail: 461 return FALSE; 462 } 463 464 static int device_block(DBusConnection *conn, struct btd_device *device) 465 { 466 int dev_id, dd, err; 467 bdaddr_t src; 468 469 if (device->blocked) 470 return 0; 471 472 dev_id = adapter_get_dev_id(device->adapter); 473 474 dd = hci_open_dev(dev_id); 475 if (dd < 0) 476 return -errno; 477 478 if (device->handle) 479 do_disconnect(device); 480 481 g_slist_foreach(device->drivers, (GFunc) driver_remove, device); 482 483 if (ioctl(dd, HCIBLOCKADDR, &device->bdaddr) < 0) { 484 err = -errno; 485 hci_close_dev(dd); 486 return err; 487 } 488 489 hci_close_dev(dd); 490 491 device->blocked = TRUE; 492 493 adapter_get_address(device->adapter, &src); 494 495 err = write_blocked(&src, &device->bdaddr, TRUE); 496 if (err < 0) 497 error("write_blocked(): %s (%d)", strerror(-err), -err); 498 499 device_set_temporary(device, FALSE); 500 501 emit_property_changed(conn, device->path, DEVICE_INTERFACE, "Blocked", 502 DBUS_TYPE_BOOLEAN, &device->blocked); 503 504 return 0; 505 } 506 507 static int device_unblock(DBusConnection *conn, struct btd_device *device, 508 gboolean silent) 509 { 510 int dev_id, dd, err; 511 bdaddr_t src; 512 513 if (!device->blocked) 514 return 0; 515 516 dev_id = adapter_get_dev_id(device->adapter); 517 518 dd = hci_open_dev(dev_id); 519 if (dd < 0) 520 return -errno; 521 522 if (ioctl(dd, HCIUNBLOCKADDR, &device->bdaddr) < 0) { 523 err = -errno; 524 hci_close_dev(dd); 525 return err; 526 } 527 528 hci_close_dev(dd); 529 530 device->blocked = FALSE; 531 532 adapter_get_address(device->adapter, &src); 533 534 err = write_blocked(&src, &device->bdaddr, FALSE); 535 if (err < 0) 536 error("write_blocked(): %s (%d)", strerror(-err), -err); 537 538 if (!silent) { 539 emit_property_changed(conn, device->path, 540 DEVICE_INTERFACE, "Blocked", 541 DBUS_TYPE_BOOLEAN, &device->blocked); 542 device_probe_drivers(device, device->uuids); 543 } 544 545 return 0; 546 } 547 548 static DBusMessage *set_blocked(DBusConnection *conn, DBusMessage *msg, 549 gboolean value, void *data) 550 { 551 struct btd_device *device = data; 552 int err; 553 554 if (value) 555 err = device_block(conn, device); 556 else 557 err = device_unblock(conn, device, FALSE); 558 559 switch (-err) { 560 case 0: 561 return dbus_message_new_method_return(msg); 562 case EINVAL: 563 return g_dbus_create_error(msg, 564 ERROR_INTERFACE ".NotSupported", 565 "Kernel lacks blacklist support"); 566 default: 567 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed", 568 "%s", strerror(-err)); 569 } 570 } 571 572 static inline DBusMessage *invalid_args(DBusMessage *msg) 573 { 574 return g_dbus_create_error(msg, ERROR_INTERFACE ".InvalidArguments", 575 "Invalid arguments in method call"); 576 } 577 578 static DBusMessage *set_property(DBusConnection *conn, 579 DBusMessage *msg, void *data) 580 { 581 DBusMessageIter iter; 582 DBusMessageIter sub; 583 const char *property; 584 585 if (!dbus_message_iter_init(msg, &iter)) 586 return invalid_args(msg); 587 588 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) 589 return invalid_args(msg); 590 591 dbus_message_iter_get_basic(&iter, &property); 592 dbus_message_iter_next(&iter); 593 594 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) 595 return invalid_args(msg); 596 dbus_message_iter_recurse(&iter, &sub); 597 598 if (g_str_equal("Trusted", property)) { 599 dbus_bool_t value; 600 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN) 601 return invalid_args(msg); 602 dbus_message_iter_get_basic(&sub, &value); 603 604 return set_trust(conn, msg, value, data); 605 } else if (g_str_equal("Alias", property)) { 606 const char *alias; 607 608 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) 609 return invalid_args(msg); 610 dbus_message_iter_get_basic(&sub, &alias); 611 612 return set_alias(conn, msg, alias, data); 613 } else if (g_str_equal("Blocked", property)) { 614 dbus_bool_t value; 615 616 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN) 617 return invalid_args(msg); 618 619 dbus_message_iter_get_basic(&sub, &value); 620 621 return set_blocked(conn, msg, value, data); 622 } 623 624 return invalid_args(msg); 625 } 626 627 static void discover_services_req_exit(DBusConnection *conn, void *user_data) 628 { 629 struct browse_req *req = user_data; 630 631 DBG("DiscoverServices requestor exited"); 632 633 browse_request_cancel(req); 634 } 635 636 static DBusMessage *discover_services(DBusConnection *conn, 637 DBusMessage *msg, void *user_data) 638 { 639 struct btd_device *device = user_data; 640 const char *pattern; 641 int err; 642 643 if (device->browse) 644 return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress", 645 "Discover in progress"); 646 647 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, 648 DBUS_TYPE_INVALID) == FALSE) 649 goto fail; 650 651 if (strlen(pattern) == 0) { 652 err = device_browse(device, conn, msg, NULL, FALSE); 653 if (err < 0) 654 goto fail; 655 } else { 656 uuid_t uuid; 657 658 if (bt_string2uuid(&uuid, pattern) < 0) 659 return invalid_args(msg); 660 661 sdp_uuid128_to_uuid(&uuid); 662 663 err = device_browse(device, conn, msg, &uuid, FALSE); 664 if (err < 0) 665 goto fail; 666 } 667 668 return NULL; 669 670 fail: 671 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed", 672 "Discovery Failed"); 673 } 674 675 static const char *browse_request_get_requestor(struct browse_req *req) 676 { 677 if (!req->msg) 678 return NULL; 679 680 return dbus_message_get_sender(req->msg); 681 } 682 683 static void iter_append_record(DBusMessageIter *dict, uint32_t handle, 684 const char *record) 685 { 686 DBusMessageIter entry; 687 688 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, 689 NULL, &entry); 690 691 dbus_message_iter_append_basic(&entry, DBUS_TYPE_UINT32, &handle); 692 693 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &record); 694 695 dbus_message_iter_close_container(dict, &entry); 696 } 697 698 static void discover_services_reply(struct browse_req *req, int err, 699 sdp_list_t *recs) 700 { 701 DBusMessage *reply; 702 DBusMessageIter iter, dict; 703 sdp_list_t *seq; 704 705 if (err) { 706 const char *err_if; 707 708 if (err == -EHOSTDOWN) 709 err_if = ERROR_INTERFACE ".ConnectionAttemptFailed"; 710 else 711 err_if = ERROR_INTERFACE ".Failed"; 712 713 reply = dbus_message_new_error(req->msg, err_if, 714 strerror(-err)); 715 g_dbus_send_message(req->conn, reply); 716 return; 717 } 718 719 reply = dbus_message_new_method_return(req->msg); 720 if (!reply) 721 return; 722 723 dbus_message_iter_init_append(reply, &iter); 724 725 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, 726 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING 727 DBUS_TYPE_UINT32_AS_STRING DBUS_TYPE_STRING_AS_STRING 728 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); 729 730 for (seq = recs; seq; seq = seq->next) { 731 sdp_record_t *rec = (sdp_record_t *) seq->data; 732 GString *result; 733 734 if (!rec) 735 break; 736 737 result = g_string_new(NULL); 738 739 convert_sdp_record_to_xml(rec, result, 740 (void *) g_string_append); 741 742 if (result->len) 743 iter_append_record(&dict, rec->handle, result->str); 744 745 g_string_free(result, TRUE); 746 } 747 748 dbus_message_iter_close_container(&iter, &dict); 749 750 g_dbus_send_message(req->conn, reply); 751 } 752 753 static DBusMessage *cancel_discover(DBusConnection *conn, 754 DBusMessage *msg, void *user_data) 755 { 756 struct btd_device *device = user_data; 757 const char *sender = dbus_message_get_sender(msg); 758 const char *requestor; 759 760 if (!device->browse) 761 return g_dbus_create_error(msg, 762 ERROR_INTERFACE ".Failed", 763 "No pending discovery"); 764 765 if (!dbus_message_is_method_call(device->browse->msg, DEVICE_INTERFACE, 766 "DiscoverServices")) 767 return g_dbus_create_error(msg, 768 ERROR_INTERFACE ".NotAuthorized", 769 "Not Authorized"); 770 771 requestor = browse_request_get_requestor(device->browse); 772 773 /* only the discover requestor can cancel the inquiry process */ 774 if (!requestor || !g_str_equal(requestor, sender)) 775 return g_dbus_create_error(msg, 776 ERROR_INTERFACE ".NotAuthorized", 777 "Not Authorized"); 778 779 discover_services_reply(device->browse, -ECANCELED, NULL); 780 781 browse_request_cancel(device->browse); 782 783 return dbus_message_new_method_return(msg); 784 } 785 786 static void bonding_request_cancel(struct bonding_req *bonding) 787 { 788 if (!bonding->io) 789 return; 790 791 g_io_channel_shutdown(bonding->io, TRUE, NULL); 792 g_io_channel_unref(bonding->io); 793 bonding->io = NULL; 794 } 795 796 void device_request_disconnect(struct btd_device *device, DBusMessage *msg) 797 { 798 GSList *l; 799 DBusConnection *conn = get_dbus_connection(); 800 801 if (device->bonding) 802 bonding_request_cancel(device->bonding); 803 804 if (device->browse) 805 browse_request_cancel(device->browse); 806 807 if (msg) 808 device->disconnects = g_slist_append(device->disconnects, 809 dbus_message_ref(msg)); 810 811 if (device->disconn_timer) 812 return; 813 814 l = device->watches; 815 while (l) { 816 struct btd_disconnect_data *data = l->data; 817 818 l = l->next; 819 820 if (data->watch) 821 /* temporary is set if device is going to be removed */ 822 data->watch(device, device->temporary, 823 data->user_data); 824 } 825 826 g_slist_foreach(device->watches, (GFunc) g_free, NULL); 827 g_slist_free(device->watches); 828 device->watches = NULL; 829 830 device->disconn_timer = g_timeout_add_seconds(DISCONNECT_TIMER, 831 do_disconnect, device); 832 833 g_dbus_emit_signal(conn, device->path, 834 DEVICE_INTERFACE, "DisconnectRequested", 835 DBUS_TYPE_INVALID); 836 } 837 838 static DBusMessage *disconnect(DBusConnection *conn, DBusMessage *msg, 839 void *user_data) 840 { 841 struct btd_device *device = user_data; 842 843 if (!device->handle) 844 return g_dbus_create_error(msg, 845 ERROR_INTERFACE ".NotConnected", 846 "Device is not connected"); 847 848 device_request_disconnect(device, msg); 849 850 return NULL; 851 } 852 853 static DBusMessage *get_service_attribute_value_reply(DBusMessage *msg, DBusConnection *conn, 854 sdp_data_t *attr) 855 { 856 DBusMessage *reply; 857 DBusMessageIter iter; 858 859 reply = dbus_message_new_method_return(msg); 860 if (!reply) 861 return NULL; 862 sdp_data_t *curr; 863 sdp_list_t *ap = 0; 864 for (; attr; attr = attr->next) { 865 sdp_list_t *pds = 0; 866 for (curr = attr->val.dataseq; curr; curr = curr->next) 867 pds = sdp_list_append(pds, curr->val.dataseq); 868 ap = sdp_list_append(ap, pds); 869 } 870 871 int ch = sdp_get_proto_port(ap, RFCOMM_UUID); 872 sdp_list_foreach(ap, (sdp_list_func_t) sdp_list_free, NULL); 873 sdp_list_free(ap, NULL); 874 ap = NULL; 875 876 dbus_message_append_args(reply, DBUS_TYPE_INT32, &ch, DBUS_TYPE_INVALID); 877 878 return reply; 879 } 880 881 static DBusMessage *get_service_attribute_value(DBusConnection *conn, 882 DBusMessage *msg, 883 void *user_data) 884 { 885 struct btd_device *device = user_data; 886 sdp_record_t *rec; 887 sdp_data_t *attr_data; 888 const char *pattern; 889 uint16_t attrId; 890 int err; 891 892 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, 893 DBUS_TYPE_UINT16, &attrId, 894 DBUS_TYPE_INVALID) == FALSE) 895 goto fail; 896 897 if (strlen(pattern) == 0) 898 return invalid_args(msg); 899 900 rec = btd_device_get_record(device, pattern); 901 if (rec == NULL) { 902 error("rec is NULL"); 903 goto fail; 904 } 905 906 attr_data = sdp_data_get(rec, attrId); 907 908 if (attr_data == NULL) { 909 error("attr in null"); 910 goto fail; 911 } 912 return get_service_attribute_value_reply(msg, conn, attr_data); 913 fail: 914 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed", 915 "GetServiceAttribute Failed"); 916 } 917 918 static GDBusMethodTable device_methods[] = { 919 { "GetProperties", "", "a{sv}", get_properties }, 920 { "SetProperty", "sv", "", set_property }, 921 { "DiscoverServices", "s", "a{us}", discover_services, 922 G_DBUS_METHOD_FLAG_ASYNC}, 923 { "CancelDiscovery", "", "", cancel_discover }, 924 { "Disconnect", "", "", disconnect, 925 G_DBUS_METHOD_FLAG_ASYNC}, 926 { "GetServiceAttributeValue", "sq", "i", get_service_attribute_value}, 927 { } 928 }; 929 930 static GDBusSignalTable device_signals[] = { 931 { "PropertyChanged", "sv" }, 932 { "DisconnectRequested", "" }, 933 { } 934 }; 935 936 gboolean device_is_connected(struct btd_device *device) 937 { 938 return (device->handle != 0); 939 } 940 941 static void device_set_connected(struct btd_device *device, 942 DBusConnection *conn, 943 gboolean connected) 944 { 945 emit_property_changed(conn, device->path, DEVICE_INTERFACE, 946 "Connected", DBUS_TYPE_BOOLEAN, &connected); 947 948 if (connected && device->secmode3) { 949 struct btd_adapter *adapter = device_get_adapter(device); 950 bdaddr_t sba; 951 952 adapter_get_address(adapter, &sba); 953 954 device->secmode3 = FALSE; 955 956 hcid_dbus_bonding_process_complete(&sba, &device->bdaddr, 0); 957 } 958 } 959 960 void device_add_connection(struct btd_device *device, DBusConnection *conn, 961 uint16_t handle) 962 { 963 if (device->handle) { 964 error("%s: Unable to add connection %u, %u already exist)", 965 device->path, handle, device->handle); 966 return; 967 } 968 969 device->handle = handle; 970 971 device_set_connected(device, conn, TRUE); 972 } 973 974 void device_remove_connection(struct btd_device *device, DBusConnection *conn, 975 uint16_t handle) 976 { 977 if (handle && device->handle != handle) { 978 error("%s: Unable to remove connection %u, handle mismatch (%u)", 979 device->path, handle, device->handle); 980 return; 981 } 982 983 device->handle = 0; 984 985 if (device->disconn_timer > 0) { 986 g_source_remove(device->disconn_timer); 987 device->disconn_timer = 0; 988 } 989 990 while (device->disconnects) { 991 DBusMessage *msg = device->disconnects->data; 992 993 g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID); 994 device->disconnects = g_slist_remove(device->disconnects, msg); 995 } 996 997 device_set_connected(device, conn, FALSE); 998 } 999 1000 gboolean device_has_connection(struct btd_device *device, uint16_t handle) 1001 { 1002 return (handle == device->handle); 1003 } 1004 1005 uint16_t device_get_handle(struct btd_device *device) 1006 { 1007 return device->handle; 1008 } 1009 1010 guint device_add_disconnect_watch(struct btd_device *device, 1011 disconnect_watch watch, void *user_data, 1012 GDestroyNotify destroy) 1013 { 1014 struct btd_disconnect_data *data; 1015 static guint id = 0; 1016 1017 data = g_new0(struct btd_disconnect_data, 1); 1018 data->id = ++id; 1019 data->watch = watch; 1020 data->user_data = user_data; 1021 data->destroy = destroy; 1022 1023 device->watches = g_slist_append(device->watches, data); 1024 1025 return data->id; 1026 } 1027 1028 void device_remove_disconnect_watch(struct btd_device *device, guint id) 1029 { 1030 GSList *l; 1031 1032 for (l = device->watches; l; l = l->next) { 1033 struct btd_disconnect_data *data = l->data; 1034 1035 if (data->id == id) { 1036 device->watches = g_slist_remove(device->watches, 1037 data); 1038 if (data->destroy) 1039 data->destroy(data->user_data); 1040 g_free(data); 1041 return; 1042 } 1043 } 1044 } 1045 1046 gboolean device_get_secmode3_conn(struct btd_device *device) 1047 { 1048 return device->secmode3; 1049 } 1050 1051 void device_set_secmode3_conn(struct btd_device *device, gboolean enable) 1052 { 1053 device->secmode3 = enable; 1054 } 1055 1056 struct btd_device *device_create(DBusConnection *conn, 1057 struct btd_adapter *adapter, 1058 const gchar *address) 1059 { 1060 gchar *address_up; 1061 struct btd_device *device; 1062 const gchar *adapter_path = adapter_get_path(adapter); 1063 bdaddr_t src; 1064 char srcaddr[18], alias[MAX_NAME_LENGTH + 1]; 1065 1066 device = g_try_malloc0(sizeof(struct btd_device)); 1067 if (device == NULL) 1068 return NULL; 1069 1070 address_up = g_ascii_strup(address, -1); 1071 device->path = g_strdup_printf("%s/dev_%s", adapter_path, address_up); 1072 g_strdelimit(device->path, ":", '_'); 1073 g_free(address_up); 1074 1075 DBG("Creating device %s", device->path); 1076 1077 if (g_dbus_register_interface(conn, device->path, DEVICE_INTERFACE, 1078 device_methods, device_signals, NULL, 1079 device, device_free) == FALSE) { 1080 device_free(device); 1081 return NULL; 1082 } 1083 1084 str2ba(address, &device->bdaddr); 1085 device->adapter = adapter; 1086 adapter_get_address(adapter, &src); 1087 ba2str(&src, srcaddr); 1088 read_device_name(srcaddr, address, device->name); 1089 if (read_device_alias(srcaddr, address, alias, sizeof(alias)) == 0) 1090 device->alias = g_strdup(alias); 1091 device->trusted = read_trust(&src, address, GLOBAL_TRUST); 1092 1093 if (read_blocked(&src, &device->bdaddr)) 1094 device_block(conn, device); 1095 1096 device->auth = 0xff; 1097 1098 if (read_link_key(&src, &device->bdaddr, NULL, NULL) == 0) 1099 device->paired = TRUE; 1100 1101 return btd_device_ref(device); 1102 } 1103 1104 void device_set_name(struct btd_device *device, const char *name) 1105 { 1106 DBusConnection *conn = get_dbus_connection(); 1107 1108 if (strncmp(name, device->name, MAX_NAME_LENGTH) == 0) 1109 return; 1110 1111 strncpy(device->name, name, MAX_NAME_LENGTH); 1112 1113 emit_property_changed(conn, device->path, 1114 DEVICE_INTERFACE, "Name", 1115 DBUS_TYPE_STRING, &name); 1116 1117 if (device->alias != NULL) 1118 return; 1119 1120 emit_property_changed(conn, device->path, 1121 DEVICE_INTERFACE, "Alias", 1122 DBUS_TYPE_STRING, &name); 1123 } 1124 1125 void device_get_name(struct btd_device *device, char *name, size_t len) 1126 { 1127 strncpy(name, device->name, len); 1128 } 1129 1130 void device_remove_bonding(struct btd_device *device) 1131 { 1132 char filename[PATH_MAX + 1]; 1133 char srcaddr[18], dstaddr[18]; 1134 int dd, dev_id; 1135 bdaddr_t bdaddr; 1136 1137 adapter_get_address(device->adapter, &bdaddr); 1138 ba2str(&bdaddr, srcaddr); 1139 ba2str(&device->bdaddr, dstaddr); 1140 1141 create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, 1142 "linkkeys"); 1143 1144 /* Delete the link key from storage */ 1145 textfile_casedel(filename, dstaddr); 1146 1147 dev_id = adapter_get_dev_id(device->adapter); 1148 1149 dd = hci_open_dev(dev_id); 1150 if (dd < 0) 1151 return; 1152 1153 /* Delete the link key from the Bluetooth chip */ 1154 hci_delete_stored_link_key(dd, &device->bdaddr, 0, HCI_REQ_TIMEOUT); 1155 1156 hci_close_dev(dd); 1157 } 1158 1159 static void device_remove_stored(struct btd_device *device) 1160 { 1161 bdaddr_t src; 1162 char addr[18]; 1163 DBusConnection *conn = get_dbus_connection(); 1164 1165 adapter_get_address(device->adapter, &src); 1166 ba2str(&device->bdaddr, addr); 1167 1168 if (device->paired) 1169 device_remove_bonding(device); 1170 delete_entry(&src, "profiles", addr); 1171 delete_entry(&src, "trusts", addr); 1172 delete_all_records(&src, &device->bdaddr); 1173 1174 if (device->blocked) 1175 device_unblock(conn, device, TRUE); 1176 } 1177 1178 void device_remove(struct btd_device *device, gboolean remove_stored) 1179 { 1180 1181 DBG("Removing device %s", device->path); 1182 1183 if (device->agent) 1184 agent_free(device->agent); 1185 1186 if (device->bonding) 1187 device_cancel_bonding(device, HCI_OE_USER_ENDED_CONNECTION); 1188 1189 if (device->browse) 1190 browse_request_cancel(device->browse); 1191 1192 if (device->handle) 1193 do_disconnect(device); 1194 1195 if (remove_stored) 1196 device_remove_stored(device); 1197 1198 g_slist_foreach(device->drivers, (GFunc) driver_remove, device); 1199 g_slist_free(device->drivers); 1200 device->drivers = NULL; 1201 1202 btd_device_unref(device); 1203 } 1204 1205 gint device_address_cmp(struct btd_device *device, const gchar *address) 1206 { 1207 char addr[18]; 1208 1209 ba2str(&device->bdaddr, addr); 1210 return strcasecmp(addr, address); 1211 } 1212 1213 static gboolean record_has_uuid(const sdp_record_t *rec, 1214 const char *profile_uuid) 1215 { 1216 sdp_list_t *pat; 1217 1218 for (pat = rec->pattern; pat != NULL; pat = pat->next) { 1219 char *uuid; 1220 int ret; 1221 1222 uuid = bt_uuid2string(pat->data); 1223 if (!uuid) 1224 continue; 1225 1226 ret = strcasecmp(uuid, profile_uuid); 1227 1228 g_free(uuid); 1229 1230 if (ret == 0) 1231 return TRUE; 1232 } 1233 1234 return FALSE; 1235 } 1236 1237 static GSList *device_match_pattern(struct btd_device *device, 1238 const char *match_uuid, 1239 GSList *profiles) 1240 { 1241 GSList *l, *uuids = NULL; 1242 1243 for (l = profiles; l; l = l->next) { 1244 char *profile_uuid = l->data; 1245 const sdp_record_t *rec; 1246 1247 rec = btd_device_get_record(device, profile_uuid); 1248 if (!rec) 1249 continue; 1250 1251 if (record_has_uuid(rec, match_uuid)) 1252 uuids = g_slist_append(uuids, profile_uuid); 1253 } 1254 1255 return uuids; 1256 } 1257 1258 static GSList *device_match_driver(struct btd_device *device, 1259 struct btd_device_driver *driver, 1260 GSList *profiles) 1261 { 1262 const char **uuid; 1263 GSList *uuids = NULL; 1264 1265 for (uuid = driver->uuids; *uuid; uuid++) { 1266 GSList *match; 1267 1268 /* skip duplicated uuids */ 1269 if (g_slist_find_custom(uuids, *uuid, 1270 (GCompareFunc) strcasecmp)) 1271 continue; 1272 1273 /* match profile driver */ 1274 match = g_slist_find_custom(profiles, *uuid, 1275 (GCompareFunc) strcasecmp); 1276 if (match) { 1277 uuids = g_slist_append(uuids, match->data); 1278 continue; 1279 } 1280 1281 /* match pattern driver */ 1282 match = device_match_pattern(device, *uuid, profiles); 1283 for (; match; match = match->next) 1284 uuids = g_slist_append(uuids, match->data); 1285 } 1286 1287 return uuids; 1288 } 1289 1290 void device_probe_drivers(struct btd_device *device, GSList *profiles) 1291 { 1292 GSList *list; 1293 int err; 1294 1295 if (device->blocked) { 1296 DBG("Skipping drivers for blocked device %s", device->path); 1297 goto add_uuids; 1298 } 1299 1300 DBG("Probe drivers for %s", device->path); 1301 1302 for (list = device_drivers; list; list = list->next) { 1303 struct btd_device_driver *driver = list->data; 1304 GSList *probe_uuids; 1305 struct btd_driver_data *driver_data; 1306 1307 probe_uuids = device_match_driver(device, driver, profiles); 1308 1309 if (!probe_uuids) 1310 continue; 1311 1312 driver_data = g_new0(struct btd_driver_data, 1); 1313 1314 err = driver->probe(device, probe_uuids); 1315 if (err < 0) { 1316 error("probe failed with driver %s for device %s", 1317 driver->name, device->path); 1318 1319 g_free(driver_data); 1320 g_slist_free(probe_uuids); 1321 continue; 1322 } 1323 1324 driver_data->driver = driver; 1325 device->drivers = g_slist_append(device->drivers, driver_data); 1326 g_slist_free(probe_uuids); 1327 } 1328 1329 add_uuids: 1330 for (list = profiles; list; list = list->next) { 1331 GSList *l = g_slist_find_custom(device->uuids, list->data, 1332 (GCompareFunc) strcasecmp); 1333 if (l) 1334 continue; 1335 1336 device->uuids = g_slist_insert_sorted(device->uuids, 1337 g_strdup(list->data), 1338 (GCompareFunc) strcasecmp); 1339 } 1340 } 1341 1342 static void device_remove_drivers(struct btd_device *device, GSList *uuids) 1343 { 1344 struct btd_adapter *adapter = device_get_adapter(device); 1345 GSList *list, *next; 1346 char srcaddr[18], dstaddr[18]; 1347 bdaddr_t src; 1348 sdp_list_t *records; 1349 1350 adapter_get_address(adapter, &src); 1351 ba2str(&src, srcaddr); 1352 ba2str(&device->bdaddr, dstaddr); 1353 1354 records = read_records(&src, &device->bdaddr); 1355 1356 DBG("Remove drivers for %s", device->path); 1357 1358 for (list = device->drivers; list; list = next) { 1359 struct btd_driver_data *driver_data = list->data; 1360 struct btd_device_driver *driver = driver_data->driver; 1361 const char **uuid; 1362 1363 next = list->next; 1364 1365 for (uuid = driver->uuids; *uuid; uuid++) { 1366 if (!g_slist_find_custom(uuids, *uuid, 1367 (GCompareFunc) strcasecmp)) 1368 continue; 1369 1370 DBG("UUID %s was removed from device %s", 1371 *uuid, dstaddr); 1372 1373 driver->remove(device); 1374 device->drivers = g_slist_remove(device->drivers, 1375 driver_data); 1376 g_free(driver_data); 1377 1378 break; 1379 } 1380 } 1381 1382 for (list = uuids; list; list = list->next) { 1383 sdp_record_t *rec; 1384 1385 device->uuids = g_slist_remove(device->uuids, list->data); 1386 1387 rec = find_record_in_list(records, list->data); 1388 if (!rec) 1389 continue; 1390 1391 delete_record(srcaddr, dstaddr, rec->handle); 1392 1393 records = sdp_list_remove(records, rec); 1394 sdp_record_free(rec); 1395 1396 } 1397 1398 if (records) 1399 sdp_list_free(records, (sdp_free_func_t) sdp_record_free); 1400 } 1401 1402 static void services_changed(struct btd_device *device) 1403 { 1404 DBusConnection *conn = get_dbus_connection(); 1405 char **uuids; 1406 GSList *l; 1407 int i; 1408 1409 uuids = g_new0(char *, g_slist_length(device->uuids) + 1); 1410 for (i = 0, l = device->uuids; l; l = l->next, i++) 1411 uuids[i] = l->data; 1412 1413 emit_array_property_changed(conn, device->path, DEVICE_INTERFACE, 1414 "UUIDs", DBUS_TYPE_STRING, &uuids); 1415 1416 g_free(uuids); 1417 } 1418 1419 static int rec_cmp(const void *a, const void *b) 1420 { 1421 const sdp_record_t *r1 = a; 1422 const sdp_record_t *r2 = b; 1423 1424 return r1->handle - r2->handle; 1425 } 1426 1427 static void update_services(struct browse_req *req, sdp_list_t *recs) 1428 { 1429 struct btd_device *device = req->device; 1430 struct btd_adapter *adapter = device_get_adapter(device); 1431 sdp_list_t *seq; 1432 char srcaddr[18], dstaddr[18]; 1433 bdaddr_t src; 1434 1435 adapter_get_address(adapter, &src); 1436 ba2str(&src, srcaddr); 1437 ba2str(&device->bdaddr, dstaddr); 1438 1439 for (seq = recs; seq; seq = seq->next) { 1440 sdp_record_t *rec = (sdp_record_t *) seq->data; 1441 sdp_list_t *svcclass = NULL; 1442 gchar *profile_uuid; 1443 GSList *l; 1444 1445 if (!rec) 1446 break; 1447 1448 if (sdp_get_service_classes(rec, &svcclass) < 0) 1449 continue; 1450 1451 /* Check for empty service classes list */ 1452 if (svcclass == NULL) { 1453 DBG("Skipping record with no service classes"); 1454 continue; 1455 } 1456 1457 /* Extract the first element and skip the remainning */ 1458 profile_uuid = bt_uuid2string(svcclass->data); 1459 if (!profile_uuid) { 1460 sdp_list_free(svcclass, free); 1461 continue; 1462 } 1463 1464 if (!strcasecmp(profile_uuid, PNP_UUID)) { 1465 uint16_t source, vendor, product, version; 1466 sdp_data_t *pdlist; 1467 1468 pdlist = sdp_data_get(rec, SDP_ATTR_VENDOR_ID_SOURCE); 1469 source = pdlist ? pdlist->val.uint16 : 0x0000; 1470 1471 pdlist = sdp_data_get(rec, SDP_ATTR_VENDOR_ID); 1472 vendor = pdlist ? pdlist->val.uint16 : 0x0000; 1473 1474 pdlist = sdp_data_get(rec, SDP_ATTR_PRODUCT_ID); 1475 product = pdlist ? pdlist->val.uint16 : 0x0000; 1476 1477 pdlist = sdp_data_get(rec, SDP_ATTR_VERSION); 1478 version = pdlist ? pdlist->val.uint16 : 0x0000; 1479 1480 if (source || vendor || product || version) 1481 store_device_id(srcaddr, dstaddr, source, 1482 vendor, product, version); 1483 } 1484 1485 /* Check for duplicates */ 1486 if (sdp_list_find(req->records, rec, rec_cmp)) { 1487 g_free(profile_uuid); 1488 sdp_list_free(svcclass, free); 1489 continue; 1490 } 1491 1492 store_record(srcaddr, dstaddr, rec); 1493 1494 /* Copy record */ 1495 req->records = sdp_list_append(req->records, 1496 sdp_copy_record(rec)); 1497 1498 l = g_slist_find_custom(device->uuids, profile_uuid, 1499 (GCompareFunc) strcmp); 1500 if (!l) 1501 req->profiles_added = 1502 g_slist_append(req->profiles_added, 1503 profile_uuid); 1504 else { 1505 req->profiles_removed = 1506 g_slist_remove(req->profiles_removed, 1507 l->data); 1508 g_free(profile_uuid); 1509 } 1510 1511 sdp_list_free(svcclass, free); 1512 } 1513 } 1514 1515 static void store_profiles(struct btd_device *device) 1516 { 1517 struct btd_adapter *adapter = device->adapter; 1518 bdaddr_t src; 1519 char *str; 1520 1521 adapter_get_address(adapter, &src); 1522 1523 if (!device->uuids) { 1524 write_device_profiles(&src, &device->bdaddr, ""); 1525 return; 1526 } 1527 1528 str = bt_list2string(device->uuids); 1529 write_device_profiles(&src, &device->bdaddr, str); 1530 g_free(str); 1531 } 1532 1533 static void create_device_reply(struct btd_device *device, struct browse_req *req) 1534 { 1535 DBusMessage *reply; 1536 1537 reply = dbus_message_new_method_return(req->msg); 1538 if (!reply) 1539 return; 1540 1541 dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &device->path, 1542 DBUS_TYPE_INVALID); 1543 1544 g_dbus_send_message(req->conn, reply); 1545 } 1546 1547 static void search_cb(sdp_list_t *recs, int err, gpointer user_data) 1548 { 1549 struct browse_req *req = user_data; 1550 struct btd_device *device = req->device; 1551 1552 if (err < 0) { 1553 error("%s: error updating services: %s (%d)", 1554 device->path, strerror(-err), -err); 1555 goto send_reply; 1556 } 1557 1558 update_services(req, recs); 1559 1560 if (device->tmp_records) 1561 sdp_list_free(device->tmp_records, 1562 (sdp_free_func_t) sdp_record_free); 1563 1564 device->tmp_records = req->records; 1565 req->records = NULL; 1566 1567 if (!req->profiles_added && !req->profiles_removed) { 1568 DBG("%s: No service update", device->path); 1569 goto send_reply; 1570 } 1571 1572 /* Probe matching drivers for services added */ 1573 if (req->profiles_added) 1574 device_probe_drivers(device, req->profiles_added); 1575 1576 /* Remove drivers for services removed */ 1577 if (req->profiles_removed) 1578 device_remove_drivers(device, req->profiles_removed); 1579 1580 /* Propagate services changes */ 1581 services_changed(req->device); 1582 1583 send_reply: 1584 if (!req->msg) 1585 goto cleanup; 1586 1587 if (dbus_message_is_method_call(req->msg, DEVICE_INTERFACE, 1588 "DiscoverServices")) 1589 discover_services_reply(req, err, device->tmp_records); 1590 else if (dbus_message_is_method_call(req->msg, ADAPTER_INTERFACE, 1591 "CreatePairedDevice")) 1592 create_device_reply(device, req); 1593 else if (dbus_message_is_method_call(req->msg, ADAPTER_INTERFACE, 1594 "CreateDevice")) { 1595 if (err < 0) { 1596 error_failed_errno(req->conn, req->msg, -err); 1597 goto cleanup; 1598 } 1599 1600 create_device_reply(device, req); 1601 device_set_temporary(device, FALSE); 1602 } 1603 1604 cleanup: 1605 if (!device->temporary) 1606 store_profiles(device); 1607 device->browse = NULL; 1608 browse_request_free(req); 1609 } 1610 1611 static void browse_cb(sdp_list_t *recs, int err, gpointer user_data) 1612 { 1613 struct browse_req *req = user_data; 1614 struct btd_device *device = req->device; 1615 struct btd_adapter *adapter = device->adapter; 1616 bdaddr_t src; 1617 uuid_t uuid; 1618 1619 /* If we have a valid response and req->search_uuid == 2, then L2CAP 1620 * UUID & PNP searching was successful -- we are done */ 1621 if (err < 0 || (req->search_uuid == 2 && req->records)) { 1622 if (err == -ECONNRESET && req->reconnect_attempt < 1) { 1623 req->search_uuid--; 1624 req->reconnect_attempt++; 1625 } else 1626 goto done; 1627 } 1628 1629 update_services(req, recs); 1630 1631 adapter_get_address(adapter, &src); 1632 1633 /* Search for mandatory uuids */ 1634 if (uuid_list[req->search_uuid]) { 1635 sdp_uuid16_create(&uuid, uuid_list[req->search_uuid++]); 1636 bt_search_service(&src, &device->bdaddr, &uuid, 1637 browse_cb, user_data, NULL); 1638 return; 1639 } 1640 1641 done: 1642 search_cb(recs, err, user_data); 1643 } 1644 1645 static void init_browse(struct browse_req *req, gboolean reverse) 1646 { 1647 GSList *l; 1648 1649 /* If we are doing reverse-SDP don't try to detect removed profiles 1650 * since some devices hide their service records while they are 1651 * connected 1652 */ 1653 if (reverse) 1654 return; 1655 1656 for (l = req->device->uuids; l; l = l->next) 1657 req->profiles_removed = g_slist_append(req->profiles_removed, 1658 l->data); 1659 } 1660 1661 int device_browse(struct btd_device *device, DBusConnection *conn, 1662 DBusMessage *msg, uuid_t *search, gboolean reverse) 1663 { 1664 struct btd_adapter *adapter = device->adapter; 1665 struct browse_req *req; 1666 bdaddr_t src; 1667 uuid_t uuid; 1668 bt_callback_t cb; 1669 int err; 1670 1671 if (device->browse) 1672 return -EBUSY; 1673 1674 adapter_get_address(adapter, &src); 1675 1676 req = g_new0(struct browse_req, 1); 1677 1678 if (conn == NULL) 1679 conn = get_dbus_connection(); 1680 1681 req->conn = dbus_connection_ref(conn); 1682 req->device = btd_device_ref(device); 1683 1684 if (search) { 1685 memcpy(&uuid, search, sizeof(uuid_t)); 1686 cb = search_cb; 1687 } else { 1688 sdp_uuid16_create(&uuid, uuid_list[req->search_uuid++]); 1689 init_browse(req, reverse); 1690 cb = browse_cb; 1691 } 1692 1693 device->browse = req; 1694 1695 if (msg) { 1696 const char *sender = dbus_message_get_sender(msg); 1697 1698 req->msg = dbus_message_ref(msg); 1699 /* Track the request owner to cancel it 1700 * automatically if the owner exits */ 1701 req->listener_id = g_dbus_add_disconnect_watch(conn, 1702 sender, 1703 discover_services_req_exit, 1704 req, NULL); 1705 } 1706 1707 err = bt_search_service(&src, &device->bdaddr, 1708 &uuid, cb, req, NULL); 1709 if (err < 0) { 1710 device->browse = NULL; 1711 browse_request_free(req); 1712 } 1713 1714 return err; 1715 } 1716 1717 struct btd_adapter *device_get_adapter(struct btd_device *device) 1718 { 1719 if (!device) 1720 return NULL; 1721 1722 return device->adapter; 1723 } 1724 1725 void device_get_address(struct btd_device *device, bdaddr_t *bdaddr) 1726 { 1727 bacpy(bdaddr, &device->bdaddr); 1728 } 1729 1730 const gchar *device_get_path(struct btd_device *device) 1731 { 1732 if (!device) 1733 return NULL; 1734 1735 return device->path; 1736 } 1737 1738 struct agent *device_get_agent(struct btd_device *device) 1739 { 1740 if (!device) 1741 return NULL; 1742 1743 if (device->agent) 1744 return device->agent; 1745 1746 return adapter_get_agent(device->adapter); 1747 } 1748 1749 gboolean device_is_busy(struct btd_device *device) 1750 { 1751 return device->browse ? TRUE : FALSE; 1752 } 1753 1754 gboolean device_is_temporary(struct btd_device *device) 1755 { 1756 return device->temporary; 1757 } 1758 1759 void device_set_temporary(struct btd_device *device, gboolean temporary) 1760 { 1761 if (!device) 1762 return; 1763 1764 device->temporary = temporary; 1765 } 1766 1767 void device_set_cap(struct btd_device *device, uint8_t cap) 1768 { 1769 if (!device) 1770 return; 1771 1772 device->cap = cap; 1773 } 1774 1775 uint8_t device_get_cap(struct btd_device *device) 1776 { 1777 return device->cap; 1778 } 1779 1780 void device_set_auth(struct btd_device *device, uint8_t auth) 1781 { 1782 if (!device) 1783 return; 1784 1785 device->auth = auth; 1786 } 1787 1788 uint8_t device_get_auth(struct btd_device *device) 1789 { 1790 return device->auth; 1791 } 1792 1793 static gboolean start_discovery(gpointer user_data) 1794 { 1795 struct btd_device *device = user_data; 1796 1797 device_browse(device, NULL, NULL, NULL, TRUE); 1798 1799 device->discov_timer = 0; 1800 1801 return FALSE; 1802 } 1803 1804 static DBusMessage *new_authentication_return(DBusMessage *msg, int status) 1805 { 1806 switch (status) { 1807 case 0x00: /* success */ 1808 return dbus_message_new_method_return(msg); 1809 1810 case 0x04: /* page timeout */ 1811 return dbus_message_new_error(msg, 1812 ERROR_INTERFACE ".ConnectionAttemptFailed", 1813 "Page Timeout"); 1814 case 0x08: /* connection timeout */ 1815 return dbus_message_new_error(msg, 1816 ERROR_INTERFACE ".ConnectionAttemptFailed", 1817 "Connection Timeout"); 1818 case 0x10: /* connection accept timeout */ 1819 case 0x22: /* LMP response timeout */ 1820 case 0x28: /* instant passed - is this a timeout? */ 1821 return dbus_message_new_error(msg, 1822 ERROR_INTERFACE ".AuthenticationTimeout", 1823 "Authentication Timeout"); 1824 case 0x17: /* too frequent pairing attempts */ 1825 return dbus_message_new_error(msg, 1826 ERROR_INTERFACE ".RepeatedAttempts", 1827 "Repeated Attempts"); 1828 1829 case 0x06: 1830 case 0x18: /* pairing not allowed (e.g. gw rejected attempt) */ 1831 return dbus_message_new_error(msg, 1832 ERROR_INTERFACE ".AuthenticationRejected", 1833 "Authentication Rejected"); 1834 1835 case 0x07: /* memory capacity */ 1836 case 0x09: /* connection limit */ 1837 case 0x0a: /* synchronous connection limit */ 1838 case 0x0d: /* limited resources */ 1839 case 0x13: /* user ended the connection */ 1840 case 0x14: /* terminated due to low resources */ 1841 case 0x16: /* connection terminated */ 1842 return dbus_message_new_error(msg, 1843 ERROR_INTERFACE ".AuthenticationCanceled", 1844 "Authentication Canceled"); 1845 1846 case 0x05: /* authentication failure */ 1847 case 0x0E: /* rejected due to security reasons - is this auth failure? */ 1848 case 0x25: /* encryption mode not acceptable - is this auth failure? */ 1849 case 0x26: /* link key cannot be changed - is this auth failure? */ 1850 case 0x29: /* pairing with unit key unsupported - is this auth failure? */ 1851 case 0x2f: /* insufficient security - is this auth failure? */ 1852 default: 1853 return dbus_message_new_error(msg, 1854 ERROR_INTERFACE ".AuthenticationFailed", 1855 "Authentication Failed"); 1856 } 1857 } 1858 1859 static void bonding_request_free(struct bonding_req *bonding) 1860 { 1861 struct btd_device *device; 1862 1863 if (!bonding) 1864 return; 1865 1866 if (bonding->listener_id) 1867 g_dbus_remove_watch(bonding->conn, bonding->listener_id); 1868 1869 if (bonding->msg) 1870 dbus_message_unref(bonding->msg); 1871 1872 if (bonding->conn) 1873 dbus_connection_unref(bonding->conn); 1874 1875 if (bonding->io) 1876 g_io_channel_unref(bonding->io); 1877 1878 device = bonding->device; 1879 g_free(bonding); 1880 1881 if (!device) 1882 return; 1883 1884 device->bonding = NULL; 1885 1886 if (!device->agent) 1887 return; 1888 1889 agent_cancel(device->agent); 1890 agent_free(device->agent); 1891 device->agent = NULL; 1892 } 1893 1894 void device_set_paired(struct btd_device *device, gboolean value) 1895 { 1896 DBusConnection *conn = get_dbus_connection(); 1897 1898 if (device->paired == value) 1899 return; 1900 1901 device->paired = value; 1902 1903 emit_property_changed(conn, device->path, DEVICE_INTERFACE, "Paired", 1904 DBUS_TYPE_BOOLEAN, &value); 1905 } 1906 1907 static void device_agent_removed(struct agent *agent, void *user_data) 1908 { 1909 struct btd_device *device = user_data; 1910 1911 device->agent = NULL; 1912 1913 if (device->authr) 1914 device->authr->agent = NULL; 1915 } 1916 1917 static struct bonding_req *bonding_request_new(DBusConnection *conn, 1918 DBusMessage *msg, 1919 struct btd_device *device, 1920 const char *agent_path, 1921 uint8_t capability, 1922 gboolean oob) 1923 { 1924 struct bonding_req *bonding; 1925 const char *name = dbus_message_get_sender(msg); 1926 struct agent *agent; 1927 1928 DBG("%s: requesting bonding", device->path); 1929 1930 if (!agent_path) 1931 goto proceed; 1932 1933 agent = agent_create(device->adapter, name, agent_path, 1934 capability, 1935 oob, 1936 device_agent_removed, 1937 device); 1938 if (!agent) { 1939 error("Unable to create a new agent"); 1940 return NULL; 1941 } 1942 1943 device->agent = agent; 1944 1945 DBG("Temporary agent registered for %s at %s:%s", 1946 device->path, name, agent_path); 1947 1948 proceed: 1949 bonding = g_new0(struct bonding_req, 1); 1950 1951 bonding->conn = dbus_connection_ref(conn); 1952 bonding->msg = dbus_message_ref(msg); 1953 1954 return bonding; 1955 } 1956 1957 static int device_authentication_requested(struct btd_device *device, 1958 int handle) 1959 { 1960 struct hci_request rq; 1961 auth_requested_cp cp; 1962 evt_cmd_status rp; 1963 int dd; 1964 1965 dd = hci_open_dev(adapter_get_dev_id(device->adapter)); 1966 if (dd < 0) { 1967 int err = -errno; 1968 error("Unable to open adapter: %s(%d)", strerror(-err), -err); 1969 return err; 1970 } 1971 1972 memset(&rp, 0, sizeof(rp)); 1973 1974 memset(&cp, 0, sizeof(cp)); 1975 cp.handle = htobs(handle); 1976 1977 memset(&rq, 0, sizeof(rq)); 1978 rq.ogf = OGF_LINK_CTL; 1979 rq.ocf = OCF_AUTH_REQUESTED; 1980 rq.cparam = &cp; 1981 rq.clen = AUTH_REQUESTED_CP_SIZE; 1982 rq.rparam = &rp; 1983 rq.rlen = EVT_CMD_STATUS_SIZE; 1984 rq.event = EVT_CMD_STATUS; 1985 1986 if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) { 1987 int err = -errno; 1988 error("Unable to send HCI request: %s (%d)", 1989 strerror(-err), -err); 1990 hci_close_dev(dd); 1991 return err; 1992 } 1993 1994 if (rp.status) { 1995 error("HCI_Authentication_Requested failed with status 0x%02x", 1996 rp.status); 1997 hci_close_dev(dd); 1998 return rp.status; 1999 } 2000 2001 info("Authentication requested"); 2002 2003 hci_close_dev(dd); 2004 return 0; 2005 } 2006 2007 static void bonding_connect_cb(GIOChannel *io, GError *err, gpointer user_data) 2008 { 2009 struct btd_device *device = user_data; 2010 uint16_t handle; 2011 int status; 2012 2013 if (!device->bonding) { 2014 if (!err) 2015 g_io_channel_shutdown(io, TRUE, NULL); 2016 return; 2017 } 2018 2019 if (err) 2020 /* Wait proper error to be propagated by bonding complete */ 2021 return; 2022 2023 if (!bt_io_get(io, BT_IO_L2RAW, &err, 2024 BT_IO_OPT_HANDLE, &handle, 2025 BT_IO_OPT_INVALID)) { 2026 error("Unable to get connection handle: %s", err->message); 2027 g_error_free(err); 2028 status = -errno; 2029 goto failed; 2030 } 2031 2032 status = device_authentication_requested(device, handle); 2033 if (status != 0) 2034 goto failed; 2035 2036 return; 2037 2038 failed: 2039 g_io_channel_shutdown(io, TRUE, NULL); 2040 device_cancel_bonding(device, status); 2041 } 2042 2043 static void create_bond_req_exit(DBusConnection *conn, void *user_data) 2044 { 2045 struct btd_device *device = user_data; 2046 2047 DBG("%s: requestor exited before bonding was completed", device->path); 2048 2049 if (device->authr) 2050 device_cancel_authentication(device, FALSE); 2051 2052 if (device->bonding) { 2053 device->bonding->listener_id = 0; 2054 device_request_disconnect(device, NULL); 2055 } 2056 } 2057 2058 DBusMessage *device_create_bonding(struct btd_device *device, 2059 DBusConnection *conn, 2060 DBusMessage *msg, 2061 const char *agent_path, 2062 uint8_t capability, 2063 gboolean oob) 2064 { 2065 char filename[PATH_MAX + 1]; 2066 char *str, srcaddr[18], dstaddr[18]; 2067 struct btd_adapter *adapter = device->adapter; 2068 struct bonding_req *bonding; 2069 bdaddr_t src; 2070 GError *err = NULL; 2071 GIOChannel *io; 2072 BtIOSecLevel sec_level; 2073 2074 adapter_get_address(adapter, &src); 2075 ba2str(&src, srcaddr); 2076 ba2str(&device->bdaddr, dstaddr); 2077 2078 if (device->bonding) 2079 return in_progress(msg, "Bonding in progress"); 2080 2081 /* check if a link key already exists */ 2082 create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, 2083 "linkkeys"); 2084 2085 str = textfile_caseget(filename, dstaddr); 2086 if (str) { 2087 free(str); 2088 return g_dbus_create_error(msg, 2089 ERROR_INTERFACE ".AlreadyExists", 2090 "Bonding already exists"); 2091 } 2092 2093 /* If our IO capability is NoInputNoOutput use medium security 2094 * level (i.e. don't require MITM protection) else use high 2095 * security level */ 2096 if (capability == 0x03) 2097 sec_level = BT_IO_SEC_MEDIUM; 2098 else 2099 sec_level = BT_IO_SEC_HIGH; 2100 2101 io = bt_io_connect(BT_IO_L2RAW, bonding_connect_cb, device, 2102 NULL, &err, 2103 BT_IO_OPT_SOURCE_BDADDR, &src, 2104 BT_IO_OPT_DEST_BDADDR, &device->bdaddr, 2105 BT_IO_OPT_SEC_LEVEL, sec_level, 2106 BT_IO_OPT_INVALID); 2107 if (io == NULL) { 2108 DBusMessage *reply; 2109 reply = g_dbus_create_error(msg, 2110 ERROR_INTERFACE ".ConnectionAttemptFailed", 2111 err->message); 2112 error("bt_io_connect: %s", err->message); 2113 g_error_free(err); 2114 return reply; 2115 } 2116 2117 bonding = bonding_request_new(conn, msg, device, agent_path, 2118 capability, oob); 2119 if (!bonding) { 2120 g_io_channel_shutdown(io, TRUE, NULL); 2121 return NULL; 2122 } 2123 2124 bonding->io = io; 2125 2126 bonding->listener_id = g_dbus_add_disconnect_watch(conn, 2127 dbus_message_get_sender(msg), 2128 create_bond_req_exit, device, 2129 NULL); 2130 2131 device->bonding = bonding; 2132 bonding->device = device; 2133 2134 return NULL; 2135 } 2136 2137 void device_simple_pairing_complete(struct btd_device *device, uint8_t status) 2138 { 2139 struct authentication_req *auth = device->authr; 2140 2141 if (auth && auth->type == AUTH_TYPE_NOTIFY && auth->agent) 2142 agent_cancel(auth->agent); 2143 } 2144 2145 void device_bonding_complete(struct btd_device *device, uint8_t status) 2146 { 2147 struct bonding_req *bonding = device->bonding; 2148 struct authentication_req *auth = device->authr; 2149 2150 if (auth && auth->type == AUTH_TYPE_NOTIFY && auth->agent) 2151 agent_cancel(auth->agent); 2152 2153 if (status) { 2154 device_cancel_authentication(device, TRUE); 2155 device_cancel_bonding(device, status); 2156 return; 2157 } 2158 2159 device->auth = 0xff; 2160 2161 g_free(device->authr); 2162 device->authr = NULL; 2163 2164 if (device->renewed_key) 2165 return; 2166 2167 device_set_temporary(device, FALSE); 2168 2169 /* If we were initiators start service discovery immediately. 2170 * However if the other end was the initator wait a few seconds 2171 * before SDP. This is due to potential IOP issues if the other 2172 * end starts doing SDP at the same time as us */ 2173 if (bonding) { 2174 /* If we are initiators remove any discovery timer and just 2175 * start discovering services directly */ 2176 if (device->discov_timer) { 2177 g_source_remove(device->discov_timer); 2178 device->discov_timer = 0; 2179 } 2180 2181 device_browse(device, bonding->conn, bonding->msg, 2182 NULL, FALSE); 2183 2184 bonding_request_free(bonding); 2185 } else { 2186 if (!device->browse && !device->discov_timer && 2187 main_opts.reverse_sdp) { 2188 /* If we are not initiators and there is no currently 2189 * active discovery or discovery timer, set discovery 2190 * timer */ 2191 DBG("setting timer for reverse service discovery"); 2192 device->discov_timer = g_timeout_add_seconds( 2193 DISCOVERY_TIMER, 2194 start_discovery, 2195 device); 2196 } 2197 } 2198 2199 device_set_paired(device, TRUE); 2200 } 2201 2202 gboolean device_is_creating(struct btd_device *device, const char *sender) 2203 { 2204 DBusMessage *msg; 2205 2206 if (device->bonding && device->bonding->msg) 2207 msg = device->bonding->msg; 2208 else if (device->browse && device->browse->msg) 2209 msg = device->browse->msg; 2210 else 2211 return FALSE; 2212 2213 if (!dbus_message_is_method_call(msg, ADAPTER_INTERFACE, 2214 "CreatePairedDevice") && 2215 !dbus_message_is_method_call(msg, ADAPTER_INTERFACE, 2216 "CreateDevice")) 2217 return FALSE; 2218 2219 if (sender == NULL) 2220 return TRUE; 2221 2222 return g_str_equal(sender, dbus_message_get_sender(msg)); 2223 } 2224 2225 gboolean device_is_bonding(struct btd_device *device, const char *sender) 2226 { 2227 struct bonding_req *bonding = device->bonding; 2228 2229 if (!device->bonding) 2230 return FALSE; 2231 2232 if (!sender) 2233 return TRUE; 2234 2235 return g_str_equal(sender, dbus_message_get_sender(bonding->msg)); 2236 } 2237 2238 void device_cancel_bonding(struct btd_device *device, uint8_t status) 2239 { 2240 struct bonding_req *bonding = device->bonding; 2241 DBusMessage *reply; 2242 2243 if (!bonding) 2244 return; 2245 2246 DBG("%s: canceling bonding request", device->path); 2247 2248 if (device->authr) 2249 device_cancel_authentication(device, FALSE); 2250 2251 reply = new_authentication_return(bonding->msg, status); 2252 g_dbus_send_message(bonding->conn, reply); 2253 2254 bonding_request_cancel(bonding); 2255 bonding_request_free(bonding); 2256 } 2257 2258 static void pincode_cb(struct agent *agent, DBusError *err, 2259 const char *pincode, void *data) 2260 { 2261 struct authentication_req *auth = data; 2262 struct btd_device *device = auth->device; 2263 2264 /* No need to reply anything if the authentication already failed */ 2265 if (auth->cb == NULL) 2266 return; 2267 2268 ((agent_pincode_cb) auth->cb)(agent, err, pincode, device); 2269 2270 device->authr->cb = NULL; 2271 device->authr->agent = NULL; 2272 } 2273 2274 static void confirm_cb(struct agent *agent, DBusError *err, void *data) 2275 { 2276 struct authentication_req *auth = data; 2277 struct btd_device *device = auth->device; 2278 2279 /* No need to reply anything if the authentication already failed */ 2280 if (auth->cb == NULL) 2281 return; 2282 2283 ((agent_cb) auth->cb)(agent, err, device); 2284 2285 device->authr->cb = NULL; 2286 device->authr->agent = NULL; 2287 } 2288 2289 static void oob_data_cb(struct agent *agent, DBusError *err, 2290 uint8_t *hash, uint8_t *randomizer, void *data) 2291 { 2292 struct authentication_req *auth = data; 2293 struct btd_device *device = auth->device; 2294 2295 /* No need to reply anything if the authentication already failed */ 2296 if (auth->cb == NULL) 2297 return; 2298 2299 ((agent_oob_data_cb) auth->cb)(agent, err, hash, randomizer, device); 2300 2301 device->authr->cb = NULL; 2302 device->authr->agent = NULL; 2303 } 2304 2305 static void passkey_cb(struct agent *agent, DBusError *err, 2306 uint32_t passkey, void *data) 2307 { 2308 struct authentication_req *auth = data; 2309 struct btd_device *device = auth->device; 2310 2311 /* No need to reply anything if the authentication already failed */ 2312 if (auth->cb == NULL) 2313 return; 2314 2315 ((agent_passkey_cb) auth->cb)(agent, err, passkey, device); 2316 2317 device->authr->cb = NULL; 2318 device->authr->agent = NULL; 2319 } 2320 2321 static void pairing_consent_cb(struct agent *agent, DBusError *err, void *data) 2322 { 2323 struct authentication_req *auth = data; 2324 struct btd_device *device = auth->device; 2325 2326 /* No need to reply anything if the authentication already failed */ 2327 if (!auth->cb) 2328 return; 2329 2330 ((agent_cb) auth->cb)(agent, err, device); 2331 2332 auth->cb = NULL; 2333 } 2334 2335 int device_request_oob_availability(struct btd_device *device, 2336 void *cb, void *user_data) 2337 { 2338 struct agent *agent; 2339 int err; 2340 2341 DBG("%s: requesting agent oob availability", device->path); 2342 2343 agent = device_get_agent(device); 2344 if (!agent) { 2345 error("No agent available for OOB request"); 2346 return -EPERM; 2347 } 2348 2349 err = agent_request_oob_availability(agent, device_get_path(device), 2350 cb, user_data, g_free); 2351 2352 if (err < 0) { 2353 error("Failed requesting oob availability"); 2354 } 2355 return err; 2356 } 2357 2358 2359 int device_request_authentication(struct btd_device *device, auth_type_t type, 2360 uint32_t passkey, void *cb) 2361 { 2362 struct authentication_req *auth; 2363 struct agent *agent; 2364 int err; 2365 2366 DBG("%s: requesting agent authentication", device->path); 2367 2368 agent = device_get_agent(device); 2369 if (!agent) { 2370 error("No agent available for %u request", type); 2371 return -EPERM; 2372 } 2373 2374 auth = g_new0(struct authentication_req, 1); 2375 auth->agent = agent; 2376 auth->device = device; 2377 auth->cb = cb; 2378 auth->type = type; 2379 device->authr = auth; 2380 2381 switch (type) { 2382 case AUTH_TYPE_PINCODE: 2383 err = agent_request_pincode(agent, device, pincode_cb, 2384 auth, NULL); 2385 break; 2386 case AUTH_TYPE_PASSKEY: 2387 err = agent_request_passkey(agent, device, passkey_cb, 2388 auth, NULL); 2389 break; 2390 case AUTH_TYPE_CONFIRM: 2391 err = agent_request_confirmation(agent, device, passkey, 2392 confirm_cb, auth, NULL); 2393 break; 2394 case AUTH_TYPE_NOTIFY: 2395 err = agent_display_passkey(agent, device, passkey); 2396 break; 2397 case AUTH_TYPE_OOB: 2398 err = agent_request_oob_data(agent, device, oob_data_cb, auth, NULL); 2399 break; 2400 case AUTH_TYPE_AUTO: 2401 err = 0; 2402 break; 2403 case AUTH_TYPE_PAIRING_CONSENT: 2404 err = agent_request_pairing_consent(agent, device, 2405 pairing_consent_cb, auth, NULL); 2406 break; 2407 default: 2408 err = -EINVAL; 2409 } 2410 2411 if (err < 0) { 2412 error("Failed requesting authentication"); 2413 g_free(auth); 2414 device->authr = NULL; 2415 } 2416 2417 return err; 2418 } 2419 2420 static void cancel_authentication(struct authentication_req *auth) 2421 { 2422 struct btd_device *device; 2423 struct agent *agent; 2424 DBusError err; 2425 2426 if (!auth || !auth->cb) 2427 return; 2428 2429 device = auth->device; 2430 agent = auth->agent; 2431 2432 dbus_error_init(&err); 2433 dbus_set_error_const(&err, "org.bluez.Error.Canceled", NULL); 2434 2435 switch (auth->type) { 2436 case AUTH_TYPE_PINCODE: 2437 ((agent_pincode_cb) auth->cb)(agent, &err, NULL, device); 2438 break; 2439 case AUTH_TYPE_CONFIRM: 2440 ((agent_cb) auth->cb)(agent, &err, device); 2441 break; 2442 case AUTH_TYPE_PASSKEY: 2443 ((agent_passkey_cb) auth->cb)(agent, &err, 0, device); 2444 break; 2445 case AUTH_TYPE_OOB: 2446 ((agent_oob_data_cb) auth->cb)(agent, &err, 0, 0, device); 2447 break; 2448 case AUTH_TYPE_PAIRING_CONSENT: 2449 ((agent_cb) auth->cb) (agent, &err, device); 2450 break; 2451 case AUTH_TYPE_NOTIFY: 2452 case AUTH_TYPE_AUTO: 2453 /* User Notify/Auto doesn't require any reply */ 2454 break; 2455 } 2456 2457 dbus_error_free(&err); 2458 auth->cb = NULL; 2459 } 2460 2461 void device_cancel_authentication(struct btd_device *device, gboolean aborted) 2462 { 2463 struct authentication_req *auth = device->authr; 2464 2465 if (!auth) 2466 return; 2467 2468 DBG("%s: canceling authentication request", device->path); 2469 2470 if (auth->agent) 2471 agent_cancel(auth->agent); 2472 2473 if (!aborted) 2474 cancel_authentication(auth); 2475 2476 device->authr = NULL; 2477 g_free(auth); 2478 } 2479 2480 gboolean device_is_authenticating(struct btd_device *device) 2481 { 2482 return (device->authr != NULL); 2483 } 2484 2485 gboolean device_is_authorizing(struct btd_device *device) 2486 { 2487 return device->authorizing; 2488 } 2489 2490 void device_set_authorizing(struct btd_device *device, gboolean auth) 2491 { 2492 device->authorizing = auth; 2493 } 2494 2495 void device_set_renewed_key(struct btd_device *device, gboolean renewed) 2496 { 2497 device->renewed_key = renewed; 2498 } 2499 2500 void btd_device_add_uuid(struct btd_device *device, const char *uuid) 2501 { 2502 GSList *uuid_list; 2503 char *new_uuid; 2504 2505 if (g_slist_find_custom(device->uuids, uuid, 2506 (GCompareFunc) strcasecmp)) 2507 return; 2508 2509 new_uuid = g_strdup(uuid); 2510 uuid_list = g_slist_append(NULL, new_uuid); 2511 2512 device_probe_drivers(device, uuid_list); 2513 2514 g_free(new_uuid); 2515 g_slist_free(uuid_list); 2516 2517 store_profiles(device); 2518 services_changed(device); 2519 } 2520 2521 const sdp_record_t *btd_device_get_record(struct btd_device *device, 2522 const char *uuid) 2523 { 2524 bdaddr_t src; 2525 2526 if (device->tmp_records) { 2527 const sdp_record_t *record; 2528 2529 record = find_record_in_list(device->tmp_records, uuid); 2530 if (record != NULL) 2531 return record; 2532 } 2533 2534 adapter_get_address(device->adapter, &src); 2535 2536 device->tmp_records = read_records(&src, &device->bdaddr); 2537 if (!device->tmp_records) 2538 return NULL; 2539 2540 return find_record_in_list(device->tmp_records, uuid); 2541 } 2542 2543 gboolean device_set_debug_key(struct btd_device *device, uint8_t *key) 2544 { 2545 if (key == NULL) { 2546 device->has_debug_key = FALSE; 2547 return TRUE; 2548 } 2549 2550 memcpy(device->debug_key, key, 16); 2551 device->has_debug_key = TRUE; 2552 2553 return TRUE; 2554 } 2555 2556 gboolean device_get_debug_key(struct btd_device *device, uint8_t *key) 2557 { 2558 if (!device->has_debug_key) 2559 return FALSE; 2560 2561 if (key != NULL) 2562 memcpy(key, device->debug_key, 16); 2563 2564 return TRUE; 2565 } 2566 2567 int btd_register_device_driver(struct btd_device_driver *driver) 2568 { 2569 device_drivers = g_slist_append(device_drivers, driver); 2570 2571 return 0; 2572 } 2573 2574 void btd_unregister_device_driver(struct btd_device_driver *driver) 2575 { 2576 device_drivers = g_slist_remove(device_drivers, driver); 2577 } 2578 2579 struct btd_device *btd_device_ref(struct btd_device *device) 2580 { 2581 device->ref++; 2582 2583 DBG("%p: ref=%d", device, device->ref); 2584 2585 return device; 2586 } 2587 2588 void btd_device_unref(struct btd_device *device) 2589 { 2590 DBusConnection *conn = get_dbus_connection(); 2591 gchar *path; 2592 2593 device->ref--; 2594 2595 DBG("%p: ref=%d", device, device->ref); 2596 2597 if (device->ref > 0) 2598 return; 2599 2600 path = g_strdup(device->path); 2601 2602 g_dbus_unregister_interface(conn, path, DEVICE_INTERFACE); 2603 2604 g_free(path); 2605 } 2606
