1 /* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2004-2009 Marcel Holtmann <marcel (at) holtmann.org> 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 21 * 22 */ 23 24 #ifdef HAVE_CONFIG_H 25 #include <config.h> 26 #endif 27 28 #include <stdlib.h> 29 #include <errno.h> 30 #include <fcntl.h> 31 #include <unistd.h> 32 #include <sys/ioctl.h> 33 #include <sys/socket.h> 34 35 #include <bluetooth/bluetooth.h> 36 #include <bluetooth/hci.h> 37 #include <bluetooth/hci_lib.h> 38 #include <bluetooth/rfcomm.h> 39 #include <bluetooth/l2cap.h> 40 #include <bluetooth/sco.h> 41 #include <bluetooth/sdp.h> 42 #include <bluetooth/sdp_lib.h> 43 44 #include <glib.h> 45 46 #include "glib-helper.h" 47 48 /* Number of seconds to keep a sdp_session_t in the cache */ 49 #define CACHE_TIMEOUT 2 50 51 struct cached_sdp_session { 52 bdaddr_t src; 53 bdaddr_t dst; 54 sdp_session_t *session; 55 guint timer; 56 }; 57 58 static GSList *cached_sdp_sessions = NULL; 59 60 struct hci_cmd_data { 61 bt_hci_result_t cb; 62 uint16_t handle; 63 uint16_t ocf; 64 gpointer caller_data; 65 }; 66 67 static gboolean cached_session_expired(gpointer user_data) 68 { 69 struct cached_sdp_session *cached = user_data; 70 71 cached_sdp_sessions = g_slist_remove(cached_sdp_sessions, cached); 72 73 sdp_close(cached->session); 74 75 g_free(cached); 76 77 return FALSE; 78 } 79 80 static sdp_session_t *get_sdp_session(const bdaddr_t *src, const bdaddr_t *dst) 81 { 82 GSList *l; 83 84 for (l = cached_sdp_sessions; l != NULL; l = l->next) { 85 struct cached_sdp_session *c = l->data; 86 sdp_session_t *session; 87 88 if (bacmp(&c->src, src) || bacmp(&c->dst, dst)) 89 continue; 90 91 g_source_remove(c->timer); 92 93 session = c->session; 94 95 cached_sdp_sessions = g_slist_remove(cached_sdp_sessions, c); 96 g_free(c); 97 98 return session; 99 } 100 101 return sdp_connect(src, dst, SDP_NON_BLOCKING); 102 } 103 104 static void cache_sdp_session(bdaddr_t *src, bdaddr_t *dst, 105 sdp_session_t *session) 106 { 107 struct cached_sdp_session *cached; 108 109 cached = g_new0(struct cached_sdp_session, 1); 110 111 bacpy(&cached->src, src); 112 bacpy(&cached->dst, dst); 113 114 cached->session = session; 115 116 cached_sdp_sessions = g_slist_append(cached_sdp_sessions, cached); 117 118 cached->timer = g_timeout_add_seconds(CACHE_TIMEOUT, 119 cached_session_expired, 120 cached); 121 } 122 123 int set_nonblocking(int fd) 124 { 125 long arg; 126 127 arg = fcntl(fd, F_GETFL); 128 if (arg < 0) 129 return -errno; 130 131 /* Return if already nonblocking */ 132 if (arg & O_NONBLOCK) 133 return 0; 134 135 arg |= O_NONBLOCK; 136 if (fcntl(fd, F_SETFL, arg) < 0) 137 return -errno; 138 139 return 0; 140 } 141 142 struct search_context { 143 bdaddr_t src; 144 bdaddr_t dst; 145 sdp_session_t *session; 146 bt_callback_t cb; 147 bt_destroy_t destroy; 148 gpointer user_data; 149 uuid_t uuid; 150 guint io_id; 151 }; 152 153 static GSList *context_list = NULL; 154 155 static void search_context_cleanup(struct search_context *ctxt) 156 { 157 context_list = g_slist_remove(context_list, ctxt); 158 159 if (ctxt->destroy) 160 ctxt->destroy(ctxt->user_data); 161 162 g_free(ctxt); 163 } 164 165 static void search_completed_cb(uint8_t type, uint16_t status, 166 uint8_t *rsp, size_t size, void *user_data) 167 { 168 struct search_context *ctxt = user_data; 169 sdp_list_t *recs = NULL; 170 int scanned, seqlen = 0, bytesleft = size; 171 uint8_t dataType; 172 int err = 0; 173 174 if (status || type != SDP_SVC_SEARCH_ATTR_RSP) { 175 err = -EPROTO; 176 goto done; 177 } 178 179 scanned = sdp_extract_seqtype(rsp, bytesleft, &dataType, &seqlen); 180 if (!scanned || !seqlen) 181 goto done; 182 183 rsp += scanned; 184 bytesleft -= scanned; 185 do { 186 sdp_record_t *rec; 187 int recsize; 188 189 recsize = 0; 190 rec = sdp_extract_pdu(rsp, bytesleft, &recsize); 191 if (!rec) 192 break; 193 194 if (!recsize) { 195 sdp_record_free(rec); 196 break; 197 } 198 199 scanned += recsize; 200 rsp += recsize; 201 bytesleft -= recsize; 202 203 recs = sdp_list_append(recs, rec); 204 } while (scanned < (ssize_t) size && bytesleft > 0); 205 206 done: 207 cache_sdp_session(&ctxt->src, &ctxt->dst, ctxt->session); 208 209 if (ctxt->cb) 210 ctxt->cb(recs, err, ctxt->user_data); 211 212 if (recs) 213 sdp_list_free(recs, (sdp_free_func_t) sdp_record_free); 214 215 search_context_cleanup(ctxt); 216 } 217 218 static gboolean search_process_cb(GIOChannel *chan, 219 GIOCondition cond, void *user_data) 220 { 221 struct search_context *ctxt = user_data; 222 int err = 0; 223 224 if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) { 225 err = EIO; 226 goto failed; 227 } 228 229 if (sdp_process(ctxt->session) < 0) 230 goto failed; 231 232 return TRUE; 233 234 failed: 235 if (err) { 236 sdp_close(ctxt->session); 237 ctxt->session = NULL; 238 239 if (ctxt->cb) 240 ctxt->cb(NULL, err, ctxt->user_data); 241 242 search_context_cleanup(ctxt); 243 } 244 245 return FALSE; 246 } 247 248 static gboolean connect_watch(GIOChannel *chan, GIOCondition cond, gpointer user_data) 249 { 250 struct search_context *ctxt = user_data; 251 sdp_list_t *search, *attrids; 252 uint32_t range = 0x0000ffff; 253 socklen_t len; 254 int sk, err = 0; 255 256 sk = g_io_channel_unix_get_fd(chan); 257 ctxt->io_id = 0; 258 259 len = sizeof(err); 260 if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &err, &len) < 0) { 261 err = errno; 262 goto failed; 263 } 264 265 if (err != 0) 266 goto failed; 267 268 if (sdp_set_notify(ctxt->session, search_completed_cb, ctxt) < 0) { 269 err = EIO; 270 goto failed; 271 } 272 273 search = sdp_list_append(NULL, &ctxt->uuid); 274 attrids = sdp_list_append(NULL, &range); 275 if (sdp_service_search_attr_async(ctxt->session, 276 search, SDP_ATTR_REQ_RANGE, attrids) < 0) { 277 sdp_list_free(attrids, NULL); 278 sdp_list_free(search, NULL); 279 err = EIO; 280 goto failed; 281 } 282 283 sdp_list_free(attrids, NULL); 284 sdp_list_free(search, NULL); 285 286 /* Set callback responsible for update the internal SDP transaction */ 287 ctxt->io_id = g_io_add_watch(chan, 288 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, 289 search_process_cb, ctxt); 290 return FALSE; 291 292 failed: 293 sdp_close(ctxt->session); 294 ctxt->session = NULL; 295 296 if (ctxt->cb) 297 ctxt->cb(NULL, -err, ctxt->user_data); 298 299 search_context_cleanup(ctxt); 300 301 return FALSE; 302 } 303 304 static int create_search_context(struct search_context **ctxt, 305 const bdaddr_t *src, const bdaddr_t *dst, 306 uuid_t *uuid) 307 { 308 sdp_session_t *s; 309 GIOChannel *chan; 310 311 if (!ctxt) 312 return -EINVAL; 313 314 s = get_sdp_session(src, dst); 315 if (!s) 316 return -errno; 317 318 *ctxt = g_try_malloc0(sizeof(struct search_context)); 319 if (!*ctxt) { 320 sdp_close(s); 321 return -ENOMEM; 322 } 323 324 bacpy(&(*ctxt)->src, src); 325 bacpy(&(*ctxt)->dst, dst); 326 (*ctxt)->session = s; 327 (*ctxt)->uuid = *uuid; 328 329 chan = g_io_channel_unix_new(sdp_get_socket(s)); 330 (*ctxt)->io_id = g_io_add_watch(chan, 331 G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL, 332 connect_watch, *ctxt); 333 g_io_channel_unref(chan); 334 335 return 0; 336 } 337 338 int bt_search_service(const bdaddr_t *src, const bdaddr_t *dst, 339 uuid_t *uuid, bt_callback_t cb, void *user_data, 340 bt_destroy_t destroy) 341 { 342 struct search_context *ctxt = NULL; 343 int err; 344 345 if (!cb) 346 return -EINVAL; 347 348 err = create_search_context(&ctxt, src, dst, uuid); 349 if (err < 0) 350 return err; 351 352 ctxt->cb = cb; 353 ctxt->destroy = destroy; 354 ctxt->user_data = user_data; 355 356 context_list = g_slist_append(context_list, ctxt); 357 358 return 0; 359 } 360 361 int bt_discover_services(const bdaddr_t *src, const bdaddr_t *dst, 362 bt_callback_t cb, void *user_data, bt_destroy_t destroy) 363 { 364 uuid_t uuid; 365 366 sdp_uuid16_create(&uuid, PUBLIC_BROWSE_GROUP); 367 368 return bt_search_service(src, dst, &uuid, cb, user_data, destroy); 369 } 370 371 static int find_by_bdaddr(const void *data, const void *user_data) 372 { 373 const struct search_context *ctxt = data, *search = user_data; 374 375 return (bacmp(&ctxt->dst, &search->dst) && 376 bacmp(&ctxt->src, &search->src)); 377 } 378 379 int bt_cancel_discovery(const bdaddr_t *src, const bdaddr_t *dst) 380 { 381 struct search_context search, *ctxt; 382 GSList *match; 383 384 memset(&search, 0, sizeof(search)); 385 bacpy(&search.src, src); 386 bacpy(&search.dst, dst); 387 388 /* Ongoing SDP Discovery */ 389 match = g_slist_find_custom(context_list, &search, find_by_bdaddr); 390 if (!match) 391 return -ENODATA; 392 393 ctxt = match->data; 394 if (!ctxt->session) 395 return -ENOTCONN; 396 397 if (ctxt->io_id) 398 g_source_remove(ctxt->io_id); 399 400 if (ctxt->session) 401 sdp_close(ctxt->session); 402 403 search_context_cleanup(ctxt); 404 return 0; 405 } 406 407 char *bt_uuid2string(uuid_t *uuid) 408 { 409 gchar *str; 410 uuid_t uuid128; 411 unsigned int data0; 412 unsigned short data1; 413 unsigned short data2; 414 unsigned short data3; 415 unsigned int data4; 416 unsigned short data5; 417 418 if (!uuid) 419 return NULL; 420 421 switch (uuid->type) { 422 case SDP_UUID16: 423 sdp_uuid16_to_uuid128(&uuid128, uuid); 424 break; 425 case SDP_UUID32: 426 sdp_uuid32_to_uuid128(&uuid128, uuid); 427 break; 428 case SDP_UUID128: 429 memcpy(&uuid128, uuid, sizeof(uuid_t)); 430 break; 431 default: 432 /* Type of UUID unknown */ 433 return NULL; 434 } 435 436 memcpy(&data0, &uuid128.value.uuid128.data[0], 4); 437 memcpy(&data1, &uuid128.value.uuid128.data[4], 2); 438 memcpy(&data2, &uuid128.value.uuid128.data[6], 2); 439 memcpy(&data3, &uuid128.value.uuid128.data[8], 2); 440 memcpy(&data4, &uuid128.value.uuid128.data[10], 4); 441 memcpy(&data5, &uuid128.value.uuid128.data[14], 2); 442 443 str = g_try_malloc0(MAX_LEN_UUID_STR); 444 if (!str) 445 return NULL; 446 447 sprintf(str, "%.8x-%.4x-%.4x-%.4x-%.8x%.4x", 448 g_ntohl(data0), g_ntohs(data1), 449 g_ntohs(data2), g_ntohs(data3), 450 g_ntohl(data4), g_ntohs(data5)); 451 452 return str; 453 } 454 455 static struct { 456 const char *name; 457 uint16_t class; 458 } bt_services[] = { 459 { "vcp", VIDEO_CONF_SVCLASS_ID }, 460 { "pbap", PBAP_SVCLASS_ID }, 461 { "sap", SAP_SVCLASS_ID }, 462 { "ftp", OBEX_FILETRANS_SVCLASS_ID }, 463 { "bpp", BASIC_PRINTING_SVCLASS_ID }, 464 { "bip", IMAGING_SVCLASS_ID }, 465 { "synch", IRMC_SYNC_SVCLASS_ID }, 466 { "dun", DIALUP_NET_SVCLASS_ID }, 467 { "opp", OBEX_OBJPUSH_SVCLASS_ID }, 468 { "fax", FAX_SVCLASS_ID }, 469 { "spp", SERIAL_PORT_SVCLASS_ID }, 470 { "hsp", HEADSET_SVCLASS_ID }, 471 { "hfp", HANDSFREE_SVCLASS_ID }, 472 { } 473 }; 474 475 uint16_t bt_name2class(const char *pattern) 476 { 477 int i; 478 479 for (i = 0; bt_services[i].name; i++) { 480 if (strcasecmp(bt_services[i].name, pattern) == 0) 481 return bt_services[i].class; 482 } 483 484 return 0; 485 } 486 487 static inline gboolean is_uuid128(const char *string) 488 { 489 return (strlen(string) == 36 && 490 string[8] == '-' && 491 string[13] == '-' && 492 string[18] == '-' && 493 string[23] == '-'); 494 } 495 496 char *bt_name2string(const char *pattern) 497 { 498 uuid_t uuid; 499 uint16_t uuid16; 500 int i; 501 502 /* UUID 128 string format */ 503 if (is_uuid128(pattern)) 504 return g_strdup(pattern); 505 506 /* Friendly service name format */ 507 uuid16 = bt_name2class(pattern); 508 if (uuid16) 509 goto proceed; 510 511 /* HEX format */ 512 uuid16 = strtol(pattern, NULL, 16); 513 for (i = 0; bt_services[i].class; i++) { 514 if (bt_services[i].class == uuid16) 515 goto proceed; 516 } 517 518 return NULL; 519 520 proceed: 521 sdp_uuid16_create(&uuid, uuid16); 522 523 return bt_uuid2string(&uuid); 524 } 525 526 int bt_string2uuid(uuid_t *uuid, const char *string) 527 { 528 uint32_t data0, data4; 529 uint16_t data1, data2, data3, data5; 530 531 if (is_uuid128(string) && 532 sscanf(string, "%08x-%04hx-%04hx-%04hx-%08x%04hx", 533 &data0, &data1, &data2, &data3, &data4, &data5) == 6) { 534 uint8_t val[16]; 535 536 data0 = g_htonl(data0); 537 data1 = g_htons(data1); 538 data2 = g_htons(data2); 539 data3 = g_htons(data3); 540 data4 = g_htonl(data4); 541 data5 = g_htons(data5); 542 543 memcpy(&val[0], &data0, 4); 544 memcpy(&val[4], &data1, 2); 545 memcpy(&val[6], &data2, 2); 546 memcpy(&val[8], &data3, 2); 547 memcpy(&val[10], &data4, 4); 548 memcpy(&val[14], &data5, 2); 549 550 sdp_uuid128_create(uuid, val); 551 552 return 0; 553 } else { 554 uint16_t class = bt_name2class(string); 555 if (class) { 556 sdp_uuid16_create(uuid, class); 557 return 0; 558 } 559 } 560 561 return -1; 562 } 563 564 gchar *bt_list2string(GSList *list) 565 { 566 GSList *l; 567 gchar *str, *tmp; 568 569 if (!list) 570 return NULL; 571 572 str = g_strdup((const gchar *) list->data); 573 574 for (l = list->next; l; l = l->next) { 575 tmp = g_strconcat(str, " " , (const gchar *) l->data, NULL); 576 g_free(str); 577 str = tmp; 578 } 579 580 return str; 581 } 582 583 GSList *bt_string2list(const gchar *str) 584 { 585 GSList *l = NULL; 586 gchar **uuids; 587 int i = 0; 588 589 if (!str) 590 return NULL; 591 592 /* FIXME: eglib doesn't support g_strsplit */ 593 uuids = g_strsplit(str, " ", 0); 594 if (!uuids) 595 return NULL; 596 597 while (uuids[i]) { 598 l = g_slist_append(l, uuids[i]); 599 i++; 600 } 601 602 g_free(uuids); 603 604 return l; 605 } 606 607 static gboolean hci_event_watch(GIOChannel *io, 608 GIOCondition cond, gpointer user_data) 609 { 610 unsigned char buf[HCI_MAX_EVENT_SIZE], *body; 611 struct hci_cmd_data *cmd = user_data; 612 evt_cmd_status *evt_status; 613 evt_auth_complete *evt_auth; 614 evt_encrypt_change *evt_enc; 615 hci_event_hdr *hdr; 616 set_conn_encrypt_cp cp; 617 int dd; 618 uint16_t ocf; 619 uint8_t status = HCI_OE_POWER_OFF; 620 621 if (cond & G_IO_NVAL) { 622 cmd->cb(status, cmd->caller_data); 623 return FALSE; 624 } 625 626 if (cond & (G_IO_ERR | G_IO_HUP)) 627 goto failed; 628 629 dd = g_io_channel_unix_get_fd(io); 630 631 if (read(dd, buf, sizeof(buf)) < 0) 632 goto failed; 633 634 hdr = (hci_event_hdr *) (buf + 1); 635 body = buf + (1 + HCI_EVENT_HDR_SIZE); 636 637 switch (hdr->evt) { 638 case EVT_CMD_STATUS: 639 evt_status = (evt_cmd_status *) body; 640 ocf = cmd_opcode_ocf(evt_status->opcode); 641 if (ocf != cmd->ocf) 642 return TRUE; 643 switch (ocf) { 644 case OCF_AUTH_REQUESTED: 645 case OCF_SET_CONN_ENCRYPT: 646 if (evt_status->status != 0) { 647 /* Baseband rejected command */ 648 status = evt_status->status; 649 goto failed; 650 } 651 break; 652 default: 653 return TRUE; 654 } 655 /* Wait for the next event */ 656 return TRUE; 657 case EVT_AUTH_COMPLETE: 658 evt_auth = (evt_auth_complete *) body; 659 if (evt_auth->handle != cmd->handle) { 660 /* Skipping */ 661 return TRUE; 662 } 663 664 if (evt_auth->status != 0x00) { 665 status = evt_auth->status; 666 /* Abort encryption */ 667 goto failed; 668 } 669 670 memset(&cp, 0, sizeof(cp)); 671 cp.handle = cmd->handle; 672 cp.encrypt = 1; 673 674 cmd->ocf = OCF_SET_CONN_ENCRYPT; 675 676 if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, 677 SET_CONN_ENCRYPT_CP_SIZE, &cp) < 0) { 678 status = HCI_COMMAND_DISALLOWED; 679 goto failed; 680 } 681 /* Wait for encrypt change event */ 682 return TRUE; 683 case EVT_ENCRYPT_CHANGE: 684 evt_enc = (evt_encrypt_change *) body; 685 if (evt_enc->handle != cmd->handle) 686 return TRUE; 687 688 /* Procedure finished: reporting status */ 689 status = evt_enc->status; 690 break; 691 default: 692 /* Skipping */ 693 return TRUE; 694 } 695 696 failed: 697 cmd->cb(status, cmd->caller_data); 698 g_io_channel_shutdown(io, TRUE, NULL); 699 700 return FALSE; 701 } 702 703 int bt_acl_encrypt(const bdaddr_t *src, const bdaddr_t *dst, 704 bt_hci_result_t cb, gpointer user_data) 705 { 706 GIOChannel *io; 707 struct hci_cmd_data *cmd; 708 struct hci_conn_info_req *cr; 709 auth_requested_cp cp; 710 struct hci_filter nf; 711 int dd, dev_id, err; 712 char src_addr[18]; 713 uint32_t link_mode; 714 uint16_t handle; 715 716 ba2str(src, src_addr); 717 dev_id = hci_devid(src_addr); 718 if (dev_id < 0) 719 return -errno; 720 721 dd = hci_open_dev(dev_id); 722 if (dd < 0) 723 return -errno; 724 725 cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info)); 726 cr->type = ACL_LINK; 727 bacpy(&cr->bdaddr, dst); 728 729 err = ioctl(dd, HCIGETCONNINFO, cr); 730 link_mode = cr->conn_info->link_mode; 731 handle = cr->conn_info->handle; 732 g_free(cr); 733 734 if (err < 0) { 735 err = errno; 736 goto failed; 737 } 738 739 if (link_mode & HCI_LM_ENCRYPT) { 740 /* Already encrypted */ 741 err = EALREADY; 742 goto failed; 743 } 744 745 memset(&cp, 0, sizeof(cp)); 746 cp.handle = htobs(handle); 747 748 if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_AUTH_REQUESTED, 749 AUTH_REQUESTED_CP_SIZE, &cp) < 0) { 750 err = errno; 751 goto failed; 752 } 753 754 cmd = g_new0(struct hci_cmd_data, 1); 755 cmd->handle = handle; 756 cmd->ocf = OCF_AUTH_REQUESTED; 757 cmd->cb = cb; 758 cmd->caller_data = user_data; 759 760 hci_filter_clear(&nf); 761 hci_filter_set_ptype(HCI_EVENT_PKT, &nf); 762 hci_filter_set_event(EVT_CMD_STATUS, &nf); 763 hci_filter_set_event(EVT_AUTH_COMPLETE, &nf); 764 hci_filter_set_event(EVT_ENCRYPT_CHANGE, &nf); 765 766 if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0) { 767 err = errno; 768 goto failed; 769 } 770 771 io = g_io_channel_unix_new(dd); 772 g_io_channel_set_close_on_unref(io, FALSE); 773 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, 774 G_IO_HUP | G_IO_ERR | G_IO_NVAL | G_IO_IN, 775 hci_event_watch, cmd, g_free); 776 g_io_channel_unref(io); 777 778 return 0; 779 780 failed: 781 close(dd); 782 783 return -err; 784 } 785
