lib/libbluetooth/hci.c

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