1 /* 2 * hci.c 3 */ 4 5 /*- 6 * SPDX-License-Identifier: BSD-2-Clause 7 * 8 * Copyright (c) 2009 Maksim Yevmenkin <m_evmenkin@yahoo.com> 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 #include <sys/types.h> 34 #include <sys/sysctl.h> 35 36 #include <assert.h> 37 #define L2CAP_SOCKET_CHECKED 38 #include <bluetooth.h> 39 #include <inttypes.h> 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <string.h> 43 #include <time.h> 44 #include <unistd.h> 45 46 #undef MIN 47 #define MIN(a, b) (((a) < (b))? (a) : (b)) 48 49 static int bt_devany_cb(int s, struct bt_devinfo const *di, void *xdevname); 50 static char * bt_dev2node (char const *devname, char *nodename, int nnlen); 51 static time_t bt_get_default_hci_command_timeout(void); 52 53 int 54 bt_devopen(char const *devname) 55 { 56 struct sockaddr_hci ha; 57 bdaddr_t ba; 58 int s; 59 60 if (devname == NULL) { 61 errno = EINVAL; 62 return (-1); 63 } 64 65 memset(&ha, 0, sizeof(ha)); 66 ha.hci_len = sizeof(ha); 67 ha.hci_family = AF_BLUETOOTH; 68 69 if (bt_aton(devname, &ba)) { 70 if (!bt_devname(ha.hci_node, &ba)) 71 return (-1); 72 } else if (bt_dev2node(devname, ha.hci_node, 73 sizeof(ha.hci_node)) == NULL) { 74 errno = ENXIO; 75 return (-1); 76 } 77 78 s = socket(PF_BLUETOOTH, SOCK_RAW, BLUETOOTH_PROTO_HCI); 79 if (s < 0) 80 return (-1); 81 82 if (bind(s, (struct sockaddr *) &ha, sizeof(ha)) < 0 || 83 connect(s, (struct sockaddr *) &ha, sizeof(ha)) < 0) { 84 close(s); 85 return (-1); 86 } 87 88 return (s); 89 } 90 91 int 92 bt_devclose(int s) 93 { 94 return (close(s)); 95 } 96 97 int 98 bt_devsend(int s, uint16_t opcode, void *param, size_t plen) 99 { 100 ng_hci_cmd_pkt_t h; 101 struct iovec iv[2]; 102 int ivn; 103 104 if ((plen == 0 && param != NULL) || 105 (plen > 0 && param == NULL) || 106 plen > UINT8_MAX) { 107 errno = EINVAL; 108 return (-1); 109 } 110 111 iv[0].iov_base = &h; 112 iv[0].iov_len = sizeof(h); 113 ivn = 1; 114 115 h.type = NG_HCI_CMD_PKT; 116 h.opcode = htole16(opcode); 117 if (plen > 0) { 118 h.length = plen; 119 120 iv[1].iov_base = param; 121 iv[1].iov_len = plen; 122 ivn = 2; 123 } else 124 h.length = 0; 125 126 while (writev(s, iv, ivn) < 0) { 127 if (errno == EAGAIN || errno == EINTR) 128 continue; 129 130 return (-1); 131 } 132 133 return (0); 134 } 135 136 ssize_t 137 bt_devrecv(int s, void *buf, size_t size, time_t to) 138 { 139 ssize_t n; 140 141 if (buf == NULL || size == 0) { 142 errno = EINVAL; 143 return (-1); 144 } 145 146 if (to >= 0) { 147 fd_set rfd; 148 struct timeval tv; 149 150 FD_ZERO(&rfd); 151 FD_SET(s, &rfd); 152 153 tv.tv_sec = to; 154 tv.tv_usec = 0; 155 156 while ((n = select(s + 1, &rfd, NULL, NULL, &tv)) < 0) { 157 if (errno == EAGAIN || errno == EINTR) 158 continue; 159 160 return (-1); 161 } 162 163 if (n == 0) { 164 errno = ETIMEDOUT; 165 return (-1); 166 } 167 168 assert(FD_ISSET(s, &rfd)); 169 } 170 171 while ((n = read(s, buf, size)) < 0) { 172 if (errno == EAGAIN || errno == EINTR) 173 continue; 174 175 return (-1); 176 } 177 178 switch (*((uint8_t *) buf)) { 179 case NG_HCI_CMD_PKT: { 180 ng_hci_cmd_pkt_t *h = (ng_hci_cmd_pkt_t *) buf; 181 182 if (n >= sizeof(*h) && n == (sizeof(*h) + h->length)) 183 return (n); 184 } break; 185 186 case NG_HCI_ACL_DATA_PKT: { 187 ng_hci_acldata_pkt_t *h = (ng_hci_acldata_pkt_t *) buf; 188 189 if (n >= sizeof(*h) && n == (sizeof(*h) + le16toh(h->length))) 190 return (n); 191 } break; 192 193 case NG_HCI_SCO_DATA_PKT: { 194 ng_hci_scodata_pkt_t *h = (ng_hci_scodata_pkt_t *) buf; 195 196 if (n >= sizeof(*h) && n == (sizeof(*h) + h->length)) 197 return (n); 198 } break; 199 200 case NG_HCI_EVENT_PKT: { 201 ng_hci_event_pkt_t *h = (ng_hci_event_pkt_t *) buf; 202 203 if (n >= sizeof(*h) && n == (sizeof(*h) + h->length)) 204 return (n); 205 } break; 206 } 207 208 errno = EIO; 209 return (-1); 210 } 211 212 int 213 bt_devreq(int s, struct bt_devreq *r, time_t to) 214 { 215 uint8_t buf[320]; /* more than enough */ 216 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) buf; 217 ng_hci_command_compl_ep *cc = (ng_hci_command_compl_ep *)(e+1); 218 ng_hci_command_status_ep *cs = (ng_hci_command_status_ep*)(e+1); 219 struct bt_devfilter old, new; 220 time_t t_end; 221 uint16_t opcode; 222 ssize_t n; 223 int error; 224 225 if (s < 0 || r == NULL || to < 0) { 226 errno = EINVAL; 227 return (-1); 228 } 229 230 if ((r->rlen == 0 && r->rparam != NULL) || 231 (r->rlen > 0 && r->rparam == NULL)) { 232 errno = EINVAL; 233 return (-1); 234 } 235 236 memset(&new, 0, sizeof(new)); 237 bt_devfilter_pkt_set(&new, NG_HCI_EVENT_PKT); 238 bt_devfilter_evt_set(&new, NG_HCI_EVENT_COMMAND_COMPL); 239 bt_devfilter_evt_set(&new, NG_HCI_EVENT_COMMAND_STATUS); 240 if (r->event != 0) 241 bt_devfilter_evt_set(&new, r->event); 242 243 if (bt_devfilter(s, &new, &old) < 0) 244 return (-1); 245 246 error = 0; 247 248 n = bt_devsend(s, r->opcode, r->cparam, r->clen); 249 if (n < 0) { 250 error = errno; 251 goto out; 252 } 253 254 opcode = htole16(r->opcode); 255 t_end = time(NULL) + to; 256 257 do { 258 to = t_end - time(NULL); 259 if (to < 0) 260 to = 0; 261 262 n = bt_devrecv(s, buf, sizeof(buf), to); 263 if (n < 0) { 264 error = errno; 265 goto out; 266 } 267 268 if (e->type != NG_HCI_EVENT_PKT) { 269 error = EIO; 270 goto out; 271 } 272 273 n -= sizeof(*e); 274 275 switch (e->event) { 276 case NG_HCI_EVENT_COMMAND_COMPL: 277 if (cc->opcode == opcode) { 278 n -= sizeof(*cc); 279 280 if (r->rlen >= n) { 281 r->rlen = n; 282 memcpy(r->rparam, cc + 1, r->rlen); 283 } 284 285 goto out; 286 } 287 break; 288 289 case NG_HCI_EVENT_COMMAND_STATUS: 290 if (cs->opcode == opcode) { 291 if (r->event != NG_HCI_EVENT_COMMAND_STATUS) { 292 if (cs->status != 0) { 293 error = EIO; 294 goto out; 295 } 296 } else { 297 if (r->rlen >= n) { 298 r->rlen = n; 299 memcpy(r->rparam, cs, r->rlen); 300 } 301 302 goto out; 303 } 304 } 305 break; 306 307 default: 308 if (e->event == r->event) { 309 if (r->rlen >= n) { 310 r->rlen = n; 311 memcpy(r->rparam, e + 1, r->rlen); 312 } 313 314 goto out; 315 } 316 break; 317 } 318 } while (to > 0); 319 320 error = ETIMEDOUT; 321 out: 322 bt_devfilter(s, &old, NULL); 323 324 if (error != 0) { 325 errno = error; 326 return (-1); 327 } 328 329 return (0); 330 } 331 332 int 333 bt_devfilter(int s, struct bt_devfilter const *new, struct bt_devfilter *old) 334 { 335 struct ng_btsocket_hci_raw_filter f; 336 socklen_t len; 337 338 if (new == NULL && old == NULL) { 339 errno = EINVAL; 340 return (-1); 341 } 342 343 if (old != NULL) { 344 len = sizeof(f); 345 if (getsockopt(s, SOL_HCI_RAW, SO_HCI_RAW_FILTER, &f, &len) < 0) 346 return (-1); 347 348 memset(old, 0, sizeof(*old)); 349 memcpy(old->packet_mask, &f.packet_mask, 350 MIN(sizeof(old->packet_mask), sizeof(f.packet_mask))); 351 memcpy(old->event_mask, &f.event_mask, 352 MIN(sizeof(old->event_mask), sizeof(f.packet_mask))); 353 } 354 355 if (new != NULL) { 356 memset(&f, 0, sizeof(f)); 357 memcpy(&f.packet_mask, new->packet_mask, 358 MIN(sizeof(f.packet_mask), sizeof(new->event_mask))); 359 memcpy(&f.event_mask, new->event_mask, 360 MIN(sizeof(f.event_mask), sizeof(new->event_mask))); 361 362 len = sizeof(f); 363 if (setsockopt(s, SOL_HCI_RAW, SO_HCI_RAW_FILTER, &f, len) < 0) 364 return (-1); 365 } 366 367 return (0); 368 } 369 370 void 371 bt_devfilter_pkt_set(struct bt_devfilter *filter, uint8_t type) 372 { 373 bit_set(filter->packet_mask, type - 1); 374 } 375 376 void 377 bt_devfilter_pkt_clr(struct bt_devfilter *filter, uint8_t type) 378 { 379 bit_clear(filter->packet_mask, type - 1); 380 } 381 382 int 383 bt_devfilter_pkt_tst(struct bt_devfilter const *filter, uint8_t type) 384 { 385 return (bit_test(filter->packet_mask, type - 1)); 386 } 387 388 void 389 bt_devfilter_evt_set(struct bt_devfilter *filter, uint8_t event) 390 { 391 bit_set(filter->event_mask, event - 1); 392 } 393 394 void 395 bt_devfilter_evt_clr(struct bt_devfilter *filter, uint8_t event) 396 { 397 bit_clear(filter->event_mask, event - 1); 398 } 399 400 int 401 bt_devfilter_evt_tst(struct bt_devfilter const *filter, uint8_t event) 402 { 403 return (bit_test(filter->event_mask, event - 1)); 404 } 405 406 int 407 bt_devinquiry(char const *devname, time_t length, int num_rsp, 408 struct bt_devinquiry **ii) 409 { 410 uint8_t buf[320]; 411 char _devname[HCI_DEVNAME_SIZE]; 412 struct bt_devfilter f; 413 ng_hci_inquiry_cp *cp = (ng_hci_inquiry_cp *) buf; 414 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) buf; 415 ng_hci_inquiry_result_ep *ep = (ng_hci_inquiry_result_ep *)(e+1); 416 ng_hci_inquiry_response *ir; 417 struct bt_devinquiry *i; 418 int s, n; 419 420 if (ii == NULL) { 421 errno = EINVAL; 422 return (-1); 423 } 424 425 if (devname == NULL) { 426 memset(_devname, 0, sizeof(_devname)); 427 devname = _devname; 428 429 n = bt_devenum(bt_devany_cb, _devname); 430 if (n <= 0) { 431 if (n == 0) 432 *ii = NULL; 433 434 return (n); 435 } 436 } 437 438 s = bt_devopen(devname); 439 if (s < 0) 440 return (-1); 441 442 if (bt_devfilter(s, NULL, &f) < 0) { 443 bt_devclose(s); 444 return (-1); 445 } 446 447 bt_devfilter_evt_set(&f, NG_HCI_EVENT_INQUIRY_COMPL); 448 bt_devfilter_evt_set(&f, NG_HCI_EVENT_INQUIRY_RESULT); 449 450 if (bt_devfilter(s, &f, NULL) < 0) { 451 bt_devclose(s); 452 return (-1); 453 } 454 455 /* Always use GIAC LAP */ 456 cp->lap[0] = 0x33; 457 cp->lap[1] = 0x8b; 458 cp->lap[2] = 0x9e; 459 460 /* 461 * Calculate inquire length in 1.28 second units 462 * v2.x specification says that 1.28 -> 61.44 seconds 463 * range is acceptable 464 */ 465 466 if (length <= 0) 467 length = 5; 468 else if (length == 1) 469 length = 2; 470 else if (length > 62) 471 length = 62; 472 473 cp->inquiry_length = (uint8_t)((length * 100) / 128); 474 475 if (num_rsp <= 0 || num_rsp > 255) 476 num_rsp = 8; 477 cp->num_responses = (uint8_t) num_rsp; 478 479 i = *ii = calloc(num_rsp, sizeof(struct bt_devinquiry)); 480 if (i == NULL) { 481 bt_devclose(s); 482 errno = ENOMEM; 483 return (-1); 484 } 485 486 if (bt_devsend(s, 487 NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, NG_HCI_OCF_INQUIRY), 488 cp, sizeof(*cp)) < 0) { 489 free(i); 490 bt_devclose(s); 491 return (-1); 492 } 493 494 wait_for_more: 495 496 n = bt_devrecv(s, buf, sizeof(buf), length); 497 if (n < 0) { 498 free(i); 499 bt_devclose(s); 500 return (-1); 501 } 502 503 if (n < sizeof(ng_hci_event_pkt_t)) { 504 free(i); 505 bt_devclose(s); 506 errno = EIO; 507 return (-1); 508 } 509 510 switch (e->event) { 511 case NG_HCI_EVENT_INQUIRY_COMPL: 512 break; 513 514 case NG_HCI_EVENT_INQUIRY_RESULT: 515 ir = (ng_hci_inquiry_response *)(ep + 1); 516 517 for (n = 0; n < MIN(ep->num_responses, num_rsp); n ++) { 518 bdaddr_copy(&i->bdaddr, &ir->bdaddr); 519 i->pscan_rep_mode = ir->page_scan_rep_mode; 520 i->pscan_period_mode = ir->page_scan_period_mode; 521 memcpy(i->dev_class, ir->uclass, sizeof(i->dev_class)); 522 i->clock_offset = le16toh(ir->clock_offset); 523 524 ir ++; 525 i ++; 526 num_rsp --; 527 } 528 /* FALLTHROUGH */ 529 530 default: 531 goto wait_for_more; 532 /* NOT REACHED */ 533 } 534 535 bt_devclose(s); 536 537 return (i - *ii); 538 } 539 540 char * 541 bt_devremote_name(char const *devname, const bdaddr_t *remote, time_t to, 542 uint16_t clk_off, uint8_t ps_rep_mode, uint8_t ps_mode) 543 { 544 char _devname[HCI_DEVNAME_SIZE]; 545 struct bt_devreq r; 546 ng_hci_remote_name_req_cp cp; 547 ng_hci_remote_name_req_compl_ep ep; 548 int s; 549 char *remote_name = NULL; 550 551 if (remote == NULL || to < 0) { 552 errno = EINVAL; 553 goto out; 554 } 555 556 if (to == 0) { 557 to = bt_get_default_hci_command_timeout(); 558 if (to < 0) 559 goto out; 560 } 561 to++; 562 563 if (devname == NULL) { 564 memset(_devname, 0, sizeof(_devname)); 565 devname = _devname; 566 if (bt_devenum(bt_devany_cb, _devname) <= 0) 567 goto out; 568 } 569 570 memset(&r, 0, sizeof(r)); 571 memset(&cp, 0, sizeof(cp)); 572 memset(&ep, 0, sizeof(ep)); 573 cp.clock_offset = htole16(clk_off); 574 cp.page_scan_rep_mode = ps_rep_mode; 575 cp.page_scan_mode = ps_mode; 576 bdaddr_copy(&cp.bdaddr, remote); 577 r.opcode = NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 578 NG_HCI_OCF_REMOTE_NAME_REQ); 579 r.event = NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL; 580 r.cparam = &cp; 581 r.clen = sizeof(cp); 582 r.rparam = &ep; 583 r.rlen = sizeof(ep); 584 585 s = bt_devopen(devname); 586 if (s < 0) 587 goto out; 588 589 if (bt_devreq(s, &r, to) == 0 || ep.status == 0x00) 590 remote_name = strndup((const char *)&ep.name, sizeof(ep.name)); 591 592 bt_devclose(s); 593 out: 594 return (remote_name); 595 } 596 597 int 598 bt_devinfo(struct bt_devinfo *di) 599 { 600 union { 601 struct ng_btsocket_hci_raw_node_state r0; 602 struct ng_btsocket_hci_raw_node_bdaddr r1; 603 struct ng_btsocket_hci_raw_node_features r2; 604 struct ng_btsocket_hci_raw_node_buffer r3; 605 struct ng_btsocket_hci_raw_node_stat r4; 606 struct ng_btsocket_hci_raw_node_link_policy_mask r5; 607 struct ng_btsocket_hci_raw_node_packet_mask r6; 608 struct ng_btsocket_hci_raw_node_role_switch r7; 609 struct ng_btsocket_hci_raw_node_debug r8; 610 } rp; 611 struct sockaddr_hci ha; 612 socklen_t halen; 613 int s, rval; 614 615 if (di == NULL) { 616 errno = EINVAL; 617 return (-1); 618 } 619 620 s = bt_devopen(di->devname); 621 if (s < 0) 622 return (-1); 623 624 rval = -1; 625 626 halen = sizeof(ha); 627 if (getsockname(s, (struct sockaddr *) &ha, &halen) < 0) 628 goto bad; 629 strlcpy(di->devname, ha.hci_node, sizeof(di->devname)); 630 631 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_STATE, &rp.r0, sizeof(rp.r0)) < 0) 632 goto bad; 633 di->state = rp.r0.state; 634 635 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_BDADDR, &rp.r1, sizeof(rp.r1)) < 0) 636 goto bad; 637 bdaddr_copy(&di->bdaddr, &rp.r1.bdaddr); 638 639 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_FEATURES, &rp.r2, sizeof(rp.r2)) < 0) 640 goto bad; 641 memcpy(di->features, rp.r2.features, sizeof(di->features)); 642 643 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_BUFFER, &rp.r3, sizeof(rp.r3)) < 0) 644 goto bad; 645 di->cmd_free = rp.r3.buffer.cmd_free; 646 di->sco_size = rp.r3.buffer.sco_size; 647 di->sco_pkts = rp.r3.buffer.sco_pkts; 648 di->sco_free = rp.r3.buffer.sco_free; 649 di->acl_size = rp.r3.buffer.acl_size; 650 di->acl_pkts = rp.r3.buffer.acl_pkts; 651 di->acl_free = rp.r3.buffer.acl_free; 652 653 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_STAT, &rp.r4, sizeof(rp.r4)) < 0) 654 goto bad; 655 di->cmd_sent = rp.r4.stat.cmd_sent; 656 di->evnt_recv = rp.r4.stat.evnt_recv; 657 di->acl_recv = rp.r4.stat.acl_recv; 658 di->acl_sent = rp.r4.stat.acl_sent; 659 di->sco_recv = rp.r4.stat.sco_recv; 660 di->sco_sent = rp.r4.stat.sco_sent; 661 di->bytes_recv = rp.r4.stat.bytes_recv; 662 di->bytes_sent = rp.r4.stat.bytes_sent; 663 664 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK, 665 &rp.r5, sizeof(rp.r5)) < 0) 666 goto bad; 667 di->link_policy_info = rp.r5.policy_mask; 668 669 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_PACKET_MASK, 670 &rp.r6, sizeof(rp.r6)) < 0) 671 goto bad; 672 di->packet_type_info = rp.r6.packet_mask; 673 674 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_ROLE_SWITCH, 675 &rp.r7, sizeof(rp.r7)) < 0) 676 goto bad; 677 di->role_switch_info = rp.r7.role_switch; 678 679 if (ioctl(s, SIOC_HCI_RAW_NODE_GET_DEBUG, &rp.r8, sizeof(rp.r8)) < 0) 680 goto bad; 681 di->debug = rp.r8.debug; 682 683 rval = 0; 684 bad: 685 bt_devclose(s); 686 687 return (rval); 688 } 689 690 int 691 bt_devenum(bt_devenum_cb_t cb, void *arg) 692 { 693 struct ng_btsocket_hci_raw_node_list_names rp; 694 struct bt_devinfo di; 695 struct sockaddr_hci ha; 696 int s, i, count; 697 698 rp.num_names = HCI_DEVMAX; 699 rp.names = (struct nodeinfo *) calloc(rp.num_names, 700 sizeof(struct nodeinfo)); 701 if (rp.names == NULL) { 702 errno = ENOMEM; 703 return (-1); 704 } 705 706 memset(&ha, 0, sizeof(ha)); 707 ha.hci_len = sizeof(ha); 708 ha.hci_family = AF_BLUETOOTH; 709 ha.hci_node[0] = 'x'; 710 711 s = socket(PF_BLUETOOTH, SOCK_RAW, BLUETOOTH_PROTO_HCI); 712 if (s < 0) { 713 free(rp.names); 714 715 return (-1); 716 } 717 718 if (bind(s, (struct sockaddr *) &ha, sizeof(ha)) < 0 || 719 connect(s, (struct sockaddr *) &ha, sizeof(ha)) < 0 || 720 ioctl(s, SIOC_HCI_RAW_NODE_LIST_NAMES, &rp, sizeof(rp)) < 0) { 721 close(s); 722 free(rp.names); 723 724 return (-1); 725 } 726 727 for (count = 0, i = 0; i < rp.num_names; i ++) { 728 strlcpy(di.devname, rp.names[i].name, sizeof(di.devname)); 729 if (bt_devinfo(&di) < 0) 730 continue; 731 732 count ++; 733 734 if (cb == NULL) 735 continue; 736 737 strlcpy(ha.hci_node, rp.names[i].name, sizeof(ha.hci_node)); 738 if (bind(s, (struct sockaddr *) &ha, sizeof(ha)) < 0 || 739 connect(s, (struct sockaddr *) &ha, sizeof(ha)) < 0) 740 continue; 741 742 if ((*cb)(s, &di, arg) > 0) 743 break; 744 } 745 746 close (s); 747 free(rp.names); 748 749 return (count); 750 } 751 752 static int 753 bt_devany_cb(int s, struct bt_devinfo const *di, void *xdevname) 754 { 755 strlcpy((char *) xdevname, di->devname, HCI_DEVNAME_SIZE); 756 return (1); 757 } 758 759 static char * 760 bt_dev2node(char const *devname, char *nodename, int nnlen) 761 { 762 static char const * bt_dev_prefix[] = { 763 "ubt", /* Bluetooth USB devices */ 764 NULL /* should be last */ 765 }; 766 767 static char _nodename[HCI_DEVNAME_SIZE]; 768 char const **p; 769 char *ep; 770 int plen, unit; 771 772 if (nodename == NULL) { 773 nodename = _nodename; 774 nnlen = HCI_DEVNAME_SIZE; 775 } 776 777 for (p = bt_dev_prefix; *p != NULL; p ++) { 778 plen = strlen(*p); 779 if (strncmp(devname, *p, plen) != 0) 780 continue; 781 782 unit = strtoul(devname + plen, &ep, 10); 783 if (*ep != '\0' && 784 strcmp(ep, "hci") != 0 && 785 strcmp(ep, "l2cap") != 0) 786 return (NULL); /* can't make sense of device name */ 787 788 snprintf(nodename, nnlen, "%s%uhci", *p, unit); 789 790 return (nodename); 791 } 792 793 return (NULL); 794 } 795 796 static time_t 797 bt_get_default_hci_command_timeout(void) 798 { 799 int to; 800 size_t to_size = sizeof(to); 801 802 if (sysctlbyname("net.bluetooth.hci.command_timeout", 803 &to, &to_size, NULL, 0) < 0) 804 return (-1); 805 806 /* Should not happen */ 807 if (to <= 0) { 808 errno = ERANGE; 809 return (-1); 810 } 811 812 return ((time_t)to); 813 } 814