lib/libbluetooth/bt_dev.c

   1 /*      $NetBSD: bt_dev.c$      */
   2
   3 /*-
   4  * Copyright (c) 2009 Iain Hibbert
   5  * Copyright (c) 2009 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /*-
  31  * Copyright (c) 2006 Itronix Inc.
  32  * All rights reserved.
  33  *
  34  * Written by Iain Hibbert for Itronix Inc.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the distribution.
  44  * 3. The name of Itronix Inc. may not be used to endorse
  45  *    or promote products derived from this software without specific
  46  *    prior written permission.
  47  *
  48  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
  49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  50  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  51  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
  52  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  53  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  54  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  55  * ON ANY THEORY OF LIABILITY, WHETHER IN
  56  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  57  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  58  * POSSIBILITY OF SUCH DAMAGE.
  59  */
  60
  61 #include <sys/cdefs.h>
  62 __RCSID("$NetBSD: bt_dev.c$");
  63
  64 #include <sys/event.h>
  65 #include <sys/ioctl.h>
  66 #include <sys/param.h>
  67 #include <sys/time.h>
  68 #include <sys/uio.h>
  69
  70 #include <bluetooth.h>
  71 #include <errno.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <unistd.h>
  75
  76 int
  77 bt_devaddr(const char *name, bdaddr_t *addr)
  78 {
  79         struct btreq btr;
  80         bdaddr_t bdaddr;
  81         int s, rv;
  82
  83         if (name == NULL) {
  84                 errno = EINVAL;
  85                 return 0;
  86         }
  87
  88         if (addr == NULL)
  89                 addr = &bdaddr;
  90
  91         if (bt_aton(name, addr))
  92                 return bt_devname(NULL, addr);
  93
  94         memset(&btr, 0, sizeof(btr));
  95         strncpy(btr.btr_name, name, HCI_DEVNAME_SIZE);
  96
  97         s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
  98         if (s == -1)
  99                 return 0;
 100
 101         rv = ioctl(s, SIOCGBTINFO, &btr);
 102         close(s);
 103
 104         if (rv == -1)
 105                 return 0;
 106
 107         if ((btr.btr_flags & BTF_UP) == 0) {
 108                 errno = ENXIO;
 109                 return 0;
 110         }
 111
 112         bdaddr_copy(addr, &btr.btr_bdaddr);
 113         return 1;
 114 }
 115
 116 int
 117 bt_devname(char *name, const bdaddr_t *bdaddr)
 118 {
 119         struct btreq btr;
 120         int s, rv;
 121
 122         if (bdaddr == NULL) {
 123                 errno = EINVAL;
 124                 return 0;
 125         }
 126
 127         memset(&btr, 0, sizeof(btr));
 128         bdaddr_copy(&btr.btr_bdaddr, bdaddr);
 129
 130         s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 131         if (s == -1)
 132                 return 0;
 133
 134         rv = ioctl(s, SIOCGBTINFOA, &btr);
 135         close(s);
 136
 137         if (rv == -1)
 138                 return 0;
 139
 140         if ((btr.btr_flags & BTF_UP) == 0) {
 141                 errno = ENXIO;
 142                 return 0;
 143         }
 144
 145         if (name != NULL)
 146                 strlcpy(name, btr.btr_name, HCI_DEVNAME_SIZE);
 147
 148         return 1;
 149 }
 150
 151 int
 152 bt_devopen(const char *name, int options)
 153 {
 154         struct sockaddr_bt      sa;
 155         int                     opt, s;
 156
 157         memset(&sa, 0, sizeof(sa));
 158         sa.bt_len = sizeof(sa);
 159         sa.bt_family = AF_BLUETOOTH;
 160
 161         if (name != NULL && !bt_devaddr(name, &sa.bt_bdaddr))
 162                 return -1;
 163
 164         s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 165         if (s == -1)
 166                 return -1;
 167
 168         opt = 1;
 169
 170         if ((options & BTOPT_DIRECTION) && setsockopt(s, BTPROTO_HCI,
 171             SO_HCI_DIRECTION, &opt, sizeof(opt)) == -1) {
 172                 close(s);
 173                 return -1;
 174         }
 175
 176         if ((options & BTOPT_TIMESTAMP) && setsockopt(s, SOL_SOCKET,
 177             SO_TIMESTAMP, &opt, sizeof(opt)) == -1) {
 178                 close(s);
 179                 return -1;
 180         }
 181
 182         if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
 183                 close(s);
 184                 return -1;
 185         }
 186
 187         if (name != NULL
 188             && connect(s, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
 189                 close(s);
 190                 return -1;
 191         }
 192
 193         return s;
 194 }
 195
 196 ssize_t
 197 bt_devsend(int s, uint16_t opcode, void *param, size_t plen)
 198 {
 199         hci_cmd_hdr_t   hdr;
 200         struct iovec    iov[2];
 201         ssize_t         n;
 202
 203         if (plen > UINT8_MAX
 204             || (plen == 0 && param != NULL)
 205             || (plen != 0 && param == NULL)) {
 206                 errno = EINVAL;
 207                 return -1;
 208         }
 209
 210         hdr.type = HCI_CMD_PKT;
 211         hdr.opcode = htole16(opcode);
 212         hdr.length = (uint8_t)plen;
 213
 214         iov[0].iov_base = &hdr;
 215         iov[0].iov_len = sizeof(hdr);
 216
 217         iov[1].iov_base = param;
 218         iov[1].iov_len = plen;
 219
 220         while ((n = writev(s, iov, __arraycount(iov))) == -1) {
 221                 if (errno == EINTR)
 222                         continue;
 223
 224                 return -1;
 225         }
 226
 227         return n;
 228 }
 229
 230 ssize_t
 231 bt_devrecv(int s, void *buf, size_t size, time_t to)
 232 {
 233         struct kevent   ev;
 234         struct timespec ts;
 235         uint8_t         *p;
 236         ssize_t         n;
 237         int             kq;
 238
 239         if (buf == NULL || size == 0) {
 240                 errno = EINVAL;
 241                 return -1;
 242         }
 243
 244         if (to >= 0) {  /* timeout is optional */
 245                 kq = kqueue();
 246                 if (kq == -1)
 247                         return -1;
 248
 249                 EV_SET(&ev, s, EVFILT_READ, EV_ADD, 0, 0, 0);
 250
 251                 ts.tv_sec = to;
 252                 ts.tv_nsec = 0;
 253
 254                 while (kevent(kq, &ev, 1, &ev, 1, &ts) == -1) {
 255                         if (errno == EINTR)
 256                                 continue;
 257
 258                         close(kq);
 259                         return -1;
 260                 }
 261
 262                 close(kq);
 263
 264                 if (ev.data == 0) {
 265                         errno = ETIMEDOUT;
 266                         return -1;
 267                 }
 268         }
 269
 270         while ((n = recv(s, buf, size, 0)) == -1) {
 271                 if (errno == EINTR)
 272                         continue;
 273
 274                 return -1;
 275         }
 276
 277         if (n == 0)
 278                 return 0;
 279
 280         p = buf;
 281         switch (p[0]) { /* validate that they get complete packets */
 282         case HCI_CMD_PKT:
 283                 if (sizeof(hci_cmd_hdr_t) > (size_t)n
 284                     || sizeof(hci_cmd_hdr_t) + p[3] != (size_t)n)
 285                         break;
 286
 287                 return n;
 288
 289         case HCI_ACL_DATA_PKT:
 290                 if (sizeof(hci_acldata_hdr_t) > (size_t)n
 291                     || sizeof(hci_acldata_hdr_t) + le16dec(p + 3) != (size_t)n)
 292                         break;
 293
 294                 return n;
 295
 296         case HCI_SCO_DATA_PKT:
 297                 if (sizeof(hci_scodata_hdr_t) > (size_t)n
 298                     || sizeof(hci_scodata_hdr_t) + p[3] != (size_t)n)
 299                         break;
 300
 301                 return n;
 302
 303         case HCI_EVENT_PKT:
 304                 if (sizeof(hci_event_hdr_t) > (size_t)n
 305                     || sizeof(hci_event_hdr_t) + p[2] != (size_t)n)
 306                         break;
 307
 308                 return n;
 309
 310         default:
 311                 break;
 312         }
 313
 314         errno = EIO;
 315         return -1;
 316 }
 317
 318 /*
 319  * Internal handler for bt_devreq(), do the actual request.
 320  */
 321 static int
 322 bt__devreq(int s, struct bt_devreq *req, time_t t_end)
 323 {
 324         uint8_t                 buf[HCI_EVENT_PKT_SIZE], *p;
 325         hci_event_hdr_t         ev;
 326         hci_command_status_ep   cs;
 327         hci_command_compl_ep    cc;
 328         time_t                  to;
 329         ssize_t                 n;
 330
 331         n = bt_devsend(s, req->opcode, req->cparam, req->clen);
 332         if (n == -1)
 333                 return errno;
 334
 335         for (;;) {
 336                 to = t_end - time(NULL);
 337                 if (to < 0)
 338                         return ETIMEDOUT;
 339
 340                 p = buf;
 341                 n = bt_devrecv(s, buf, sizeof(buf), to);
 342                 if (n == -1)
 343                         return errno;
 344
 345                 if (sizeof(ev) > (size_t)n || p[0] != HCI_EVENT_PKT)
 346                         return EIO;
 347
 348                 memcpy(&ev, p, sizeof(ev));
 349                 p += sizeof(ev);
 350                 n -= sizeof(ev);
 351
 352                 if (ev.event == req->event)
 353                         break;
 354
 355                 if (ev.event == HCI_EVENT_COMMAND_STATUS) {
 356                         if (sizeof(cs) > (size_t)n)
 357                                 return EIO;
 358
 359                         memcpy(&cs, p, sizeof(cs));
 360                         p += sizeof(cs);
 361                         n -= sizeof(cs);
 362
 363                         if (le16toh(cs.opcode) == req->opcode) {
 364                                 if (cs.status != 0)
 365                                         return EIO;
 366
 367                                 if (req->event == 0)
 368                                         break;
 369                         }
 370
 371                         continue;
 372                 }
 373
 374                 if (ev.event == HCI_EVENT_COMMAND_COMPL) {
 375                         if (sizeof(cc) > (size_t)n)
 376                                 return EIO;
 377
 378                         memcpy(&cc, p, sizeof(cc));
 379                         p += sizeof(cc);
 380                         n -= sizeof(cc);
 381
 382                         if (le16toh(cc.opcode) == req->opcode)
 383                                 break;
 384
 385                         continue;
 386                 }
 387         }
 388
 389         /* copy out response data */
 390         if (req->rlen >= (size_t)n) {
 391                 req->rlen = n;
 392                 memcpy(req->rparam, p, req->rlen);
 393         } else if (req->rlen > 0)
 394                 return EIO;
 395
 396         return 0;
 397 }
 398
 399 int
 400 bt_devreq(int s, struct bt_devreq *req, time_t to)
 401 {
 402         struct bt_devfilter     new, old;
 403         int                     error;
 404
 405         if (req == NULL || to < 0
 406             || (req->rlen == 0 && req->rparam != NULL)
 407             || (req->rlen != 0 && req->rparam == NULL)) {
 408                 errno = EINVAL;
 409                 return -1;
 410         }
 411
 412         memset(&new, 0, sizeof(new));
 413         bt_devfilter_pkt_set(&new, HCI_EVENT_PKT);
 414         bt_devfilter_evt_set(&new, HCI_EVENT_COMMAND_COMPL);
 415         bt_devfilter_evt_set(&new, HCI_EVENT_COMMAND_STATUS);
 416
 417         if (req->event != 0)
 418                 bt_devfilter_evt_set(&new, req->event);
 419
 420         if (bt_devfilter(s, &new, &old) == -1)
 421                 return -1;
 422
 423         error = bt__devreq(s, req, to + time(NULL));
 424
 425         (void)bt_devfilter(s, &old, NULL);
 426
 427         if (error != 0) {
 428                 errno = error;
 429                 return -1;
 430         }
 431
 432         return 0;
 433 }
 434
 435 int
 436 bt_devfilter(int s, const struct bt_devfilter *new, struct bt_devfilter *old)
 437 {
 438         socklen_t       len;
 439
 440         if (new == NULL && old == NULL) {
 441                 errno = EINVAL;
 442                 return -1;
 443         }
 444
 445         len = sizeof(struct hci_filter);
 446
 447         if (old != NULL) {
 448                 if (getsockopt(s, BTPROTO_HCI,
 449                     SO_HCI_PKT_FILTER, &old->packet_mask, &len) == -1
 450                     || len != sizeof(struct hci_filter))
 451                         return -1;
 452
 453                 if (getsockopt(s, BTPROTO_HCI,
 454                     SO_HCI_EVT_FILTER, &old->event_mask, &len) == -1
 455                     || len != sizeof(struct hci_filter))
 456                         return -1;
 457         }
 458
 459         if (new != NULL) {
 460                 if (setsockopt(s, BTPROTO_HCI,
 461                     SO_HCI_PKT_FILTER, &new->packet_mask, len) == -1)
 462                         return -1;
 463
 464                 if (setsockopt(s, BTPROTO_HCI,
 465                     SO_HCI_EVT_FILTER, &new->event_mask, len) == -1)
 466                         return -1;
 467         }
 468
 469         return 0;
 470 }
 471
 472 void
 473 bt_devfilter_pkt_set(struct bt_devfilter *filter, uint8_t type)
 474 {
 475
 476         hci_filter_set(type, &filter->packet_mask);
 477 }
 478
 479 void
 480 bt_devfilter_pkt_clr(struct bt_devfilter *filter, uint8_t type)
 481 {
 482
 483         hci_filter_clr(type, &filter->packet_mask);
 484 }
 485
 486 int
 487 bt_devfilter_pkt_tst(const struct bt_devfilter *filter, uint8_t type)
 488 {
 489
 490         return hci_filter_test(type, &filter->packet_mask);
 491 }
 492
 493 void
 494 bt_devfilter_evt_set(struct bt_devfilter *filter, uint8_t event)
 495 {
 496
 497         hci_filter_set(event, &filter->event_mask);
 498 }
 499
 500 void
 501 bt_devfilter_evt_clr(struct bt_devfilter *filter, uint8_t event)
 502 {
 503
 504         hci_filter_clr(event, &filter->event_mask);
 505 }
 506
 507 int
 508 bt_devfilter_evt_tst(const struct bt_devfilter *filter, uint8_t event)
 509 {
 510
 511         return hci_filter_test(event, &filter->event_mask);
 512 }
 513
 514 /*
 515  * Internal function used by bt_devinquiry to find the first
 516  * active device.
 517  */
 518 static int
 519 bt__devany_cb(int s, const struct bt_devinfo *info, void *arg)
 520 {
 521
 522         if ((info->enabled)) {
 523                 strlcpy(arg, info->devname, HCI_DEVNAME_SIZE + 1);
 524                 return 1;
 525         }
 526
 527         return 0;
 528 }
 529
 530 /*
 531  * Internal function used by bt_devinquiry to insert inquiry
 532  * results to an array. Make sure that a bdaddr only appears
 533  * once in the list and always use the latest result.
 534  */
 535 static void
 536 bt__devresult(struct bt_devinquiry *ii, int *count, int max_count,
 537     bdaddr_t *ba, uint8_t psrm, uint8_t pspm, uint8_t *cl, uint16_t co,
 538     int8_t rssi, uint8_t *data)
 539 {
 540         int     n;
 541
 542         for (n = 0; ; n++, ii++) {
 543                 if (n == *count) {
 544                         if (*count == max_count)
 545                                 return;
 546
 547                         (*count)++;
 548                         break;
 549                 }
 550
 551                 if (bdaddr_same(&ii->bdaddr, ba))
 552                         break;
 553         }
 554
 555         bdaddr_copy(&ii->bdaddr, ba);
 556         ii->pscan_rep_mode = psrm;
 557         ii->pscan_period_mode = pspm;
 558         ii->clock_offset = le16toh(co);
 559         ii->rssi = rssi;
 560
 561         if (cl != NULL)
 562                 memcpy(ii->dev_class, cl, HCI_CLASS_SIZE);
 563
 564         if (data != NULL)
 565                 memcpy(ii->data, data, 240);
 566 }
 567
 568 int
 569 bt_devinquiry(const char *name, time_t to, int max_rsp,
 570     struct bt_devinquiry **iip)
 571 {
 572         uint8_t                 buf[HCI_EVENT_PKT_SIZE], *p;
 573         struct bt_devfilter     f;
 574         hci_event_hdr_t         ev;
 575         hci_command_status_ep   sp;
 576         hci_inquiry_cp          cp;
 577         hci_inquiry_result_ep   ip;
 578         hci_inquiry_response    ir;
 579         hci_rssi_result_ep      rp;
 580         hci_rssi_response       rr;
 581         hci_extended_result_ep  ep;
 582         struct bt_devinquiry    *ii;
 583         int                     count, i, s;
 584         time_t                  t_end;
 585         ssize_t                 n;
 586
 587         if (iip == NULL) {
 588                 errno = EINVAL;
 589                 return -1;
 590         }
 591
 592         if (name == NULL) {
 593                 if (bt_devenum(bt__devany_cb, buf) == -1)
 594                         return -1;
 595
 596                 name = (const char *)buf;
 597         }
 598
 599         s = bt_devopen(name, 0);
 600         if (s == -1)
 601                 return -1;
 602
 603         memset(&f, 0, sizeof(f));
 604         bt_devfilter_pkt_set(&f, HCI_EVENT_PKT);
 605         bt_devfilter_evt_set(&f, HCI_EVENT_COMMAND_STATUS);
 606         bt_devfilter_evt_set(&f, HCI_EVENT_INQUIRY_COMPL);
 607         bt_devfilter_evt_set(&f, HCI_EVENT_INQUIRY_RESULT);
 608         bt_devfilter_evt_set(&f, HCI_EVENT_RSSI_RESULT);
 609         bt_devfilter_evt_set(&f, HCI_EVENT_EXTENDED_RESULT);
 610         if (bt_devfilter(s, &f, NULL) == -1) {
 611                 close(s);
 612                 return -1;
 613         }
 614
 615         /*
 616          * silently adjust number of reponses to fit in uint8_t
 617          */
 618         if (max_rsp < 1)
 619                 max_rsp = 8;
 620         else if (max_rsp > UINT8_MAX)
 621                 max_rsp = UINT8_MAX;
 622
 623         ii = calloc((size_t)max_rsp, sizeof(struct bt_devinquiry));
 624         if (ii == NULL) {
 625                 close(s);
 626                 return -1;
 627         }
 628
 629         /*
 630          * silently adjust timeout value so that inquiry_length
 631          * falls into the range 0x01->0x30 (unit is 1.28 seconds)
 632          */
 633         if (to < 1)
 634                 to = 5;
 635         else if (to == 1)
 636                 to = 2;
 637         else if (to > 62)
 638                 to = 62;
 639
 640         /* General Inquiry LAP is 0x9e8b33 */
 641         cp.lap[0] = 0x33;
 642         cp.lap[1] = 0x8b;
 643         cp.lap[2] = 0x9e;
 644         cp.inquiry_length = (uint8_t)(to * 100 / 128);
 645         cp.num_responses = (uint8_t)max_rsp;
 646
 647         if (bt_devsend(s, HCI_CMD_INQUIRY, &cp, sizeof(cp)) == -1)
 648                 goto fail;
 649
 650         count = 0;
 651
 652         for (t_end = time(NULL) + to + 1; to > 0; to = t_end - time(NULL)) {
 653                 p = buf;
 654                 n = bt_devrecv(s, buf, sizeof(buf), to);
 655                 if (n == -1)
 656                         goto fail;
 657
 658                 if (sizeof(ev) > (size_t)n) {
 659                         errno = EIO;
 660                         goto fail;
 661                 }
 662
 663                 memcpy(&ev, p, sizeof(ev));
 664                 p += sizeof(ev);
 665                 n -= sizeof(ev);
 666
 667                 switch (ev.event) {
 668                 case HCI_EVENT_COMMAND_STATUS:
 669                         if (sizeof(sp) > (size_t)n)
 670                                 break;
 671
 672                         memcpy(&sp, p, sizeof(sp));
 673
 674                         if (le16toh(sp.opcode) != HCI_CMD_INQUIRY
 675                             || sp.status == 0)
 676                                 break;
 677
 678                         errno = EIO;
 679                         goto fail;
 680
 681                 case HCI_EVENT_INQUIRY_COMPL:
 682                         close(s);
 683                         *iip = ii;
 684                         return count;
 685
 686                 case HCI_EVENT_INQUIRY_RESULT:
 687                         if (sizeof(ip) > (size_t)n)
 688                                 break;
 689
 690                         memcpy(&ip, p, sizeof(ip));
 691                         p += sizeof(ip);
 692                         n -= sizeof(ip);
 693
 694                         if (sizeof(ir) * ip.num_responses != (size_t)n)
 695                                 break;
 696
 697                         for (i = 0; i < ip.num_responses; i++) {
 698                                 memcpy(&ir, p, sizeof(ir));
 699                                 p += sizeof(ir);
 700
 701                                 bt__devresult(ii, &count, max_rsp,
 702                                         &ir.bdaddr,
 703                                         ir.page_scan_rep_mode,
 704                                         ir.page_scan_period_mode,
 705                                         ir.uclass,
 706                                         ir.clock_offset,
 707                                         0,              /* rssi */
 708                                         NULL);          /* extended data */
 709                         }
 710
 711                         break;
 712
 713                 case HCI_EVENT_RSSI_RESULT:
 714                         if (sizeof(rp) > (size_t)n)
 715                                 break;
 716
 717                         memcpy(&rp, p, sizeof(rp));
 718                         p += sizeof(rp);
 719                         n -= sizeof(rp);
 720
 721                         if (sizeof(rr) * rp.num_responses != (size_t)n)
 722                                 break;
 723
 724                         for (i = 0; i < rp.num_responses; i++) {
 725                                 memcpy(&rr, p, sizeof(rr));
 726                                 p += sizeof(rr);
 727
 728                                 bt__devresult(ii, &count, max_rsp,
 729                                         &rr.bdaddr,
 730                                         rr.page_scan_rep_mode,
 731                                         0,      /* page scan period mode */
 732                                         rr.uclass,
 733                                         rr.clock_offset,
 734                                         rr.rssi,
 735                                         NULL);          /* extended data */
 736                         }
 737
 738                         break;
 739
 740                 case HCI_EVENT_EXTENDED_RESULT:
 741                         if (sizeof(ep) != (size_t)n)
 742                                 break;
 743
 744                         memcpy(&ep, p, sizeof(ep));
 745
 746                         if (ep.num_responses != 1)
 747                                 break;
 748
 749                         bt__devresult(ii, &count, max_rsp,
 750                                 &ep.bdaddr,
 751                                 ep.page_scan_rep_mode,
 752                                 0,      /* page scan period mode */
 753                                 ep.uclass,
 754                                 ep.clock_offset,
 755                                 ep.rssi,
 756                                 ep.response);
 757
 758                         break;
 759
 760                 default:
 761                         break;
 762                 }
 763         }
 764
 765         errno = ETIMEDOUT;
 766
 767 fail:
 768         free(ii);
 769         close(s);
 770         return -1;
 771 }
 772
 773 /*
 774  * Internal version of bt_devinfo. Fill in the devinfo structure
 775  * with the socket handle provided. If the device is present and
 776  * active, the socket will be left connected to the device.
 777  */
 778 static int
 779 bt__devinfo(int s, const char *name, struct bt_devinfo *info)
 780 {
 781         struct sockaddr_bt              sa;
 782         struct bt_devreq                req;
 783         struct btreq                    btr;
 784         hci_read_buffer_size_rp         bp;
 785         hci_read_local_features_rp      fp;
 786
 787         memset(&btr, 0, sizeof(btr));
 788         strncpy(btr.btr_name, name, HCI_DEVNAME_SIZE);
 789
 790         if (ioctl(s, SIOCGBTINFO, &btr) == -1)
 791                 return -1;
 792
 793         memset(info, 0, sizeof(struct bt_devinfo));
 794         memcpy(info->devname, btr.btr_name, HCI_DEVNAME_SIZE);
 795         bdaddr_copy(&info->bdaddr, &btr.btr_bdaddr);
 796         info->enabled = ((btr.btr_flags & BTF_UP) ? 1 : 0);
 797
 798         info->sco_size = btr.btr_sco_mtu;
 799         info->acl_size = btr.btr_acl_mtu;
 800         info->cmd_free = btr.btr_num_cmd;
 801         info->sco_free = btr.btr_num_sco;
 802         info->acl_free = btr.btr_num_acl;
 803
 804         info->link_policy_info = btr.btr_link_policy;
 805         info->packet_type_info = btr.btr_packet_type;
 806
 807         if (ioctl(s, SIOCGBTSTATS, &btr) == -1)
 808                 return -1;
 809
 810         info->cmd_sent = btr.btr_stats.cmd_tx;
 811         info->evnt_recv = btr.btr_stats.evt_rx;
 812         info->acl_recv = btr.btr_stats.acl_rx;
 813         info->acl_sent = btr.btr_stats.acl_tx;
 814         info->sco_recv = btr.btr_stats.sco_rx;
 815         info->sco_sent = btr.btr_stats.sco_tx;
 816         info->bytes_recv = btr.btr_stats.byte_rx;
 817         info->bytes_sent = btr.btr_stats.byte_tx;
 818
 819         /* can only get the rest from enabled devices */
 820         if ((info->enabled) == 0)
 821                 return 0;
 822
 823         memset(&sa, 0, sizeof(sa));
 824         sa.bt_len = sizeof(sa);
 825         sa.bt_family = AF_BLUETOOTH;
 826         bdaddr_copy(&sa.bt_bdaddr, &info->bdaddr);
 827
 828         if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) == -1
 829             || connect(s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
 830                 return -1;
 831
 832         memset(&req, 0, sizeof(req));
 833         req.opcode = HCI_CMD_READ_BUFFER_SIZE;
 834         req.rparam = &bp;
 835         req.rlen = sizeof(bp);
 836
 837         if (bt_devreq(s, &req, 5) == -1)
 838                 return -1;
 839
 840         info->acl_pkts = bp.max_acl_size;
 841         info->sco_pkts = bp.max_sco_size;
 842
 843         memset(&req, 0, sizeof(req));
 844         req.opcode = HCI_CMD_READ_LOCAL_FEATURES;
 845         req.rparam = &fp;
 846         req.rlen = sizeof(fp);
 847
 848         if (bt_devreq(s, &req, 5) == -1)
 849                 return -1;
 850
 851         memcpy(info->features, fp.features, HCI_FEATURES_SIZE);
 852
 853         return 0;
 854 }
 855
 856 int
 857 bt_devinfo(const char *name, struct bt_devinfo *info)
 858 {
 859         int     rv, s;
 860
 861         if (name == NULL || info == NULL) {
 862                 errno = EINVAL;
 863                 return -1;
 864         }
 865
 866         s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 867         if (s == -1)
 868                 return -1;
 869
 870         rv = bt__devinfo(s, name, info);
 871         close(s);
 872         return rv;
 873 }
 874
 875 int
 876 bt_devenum(bt_devenum_cb_t cb, void *arg)
 877 {
 878         struct btreq            btr;
 879         struct bt_devinfo       info;
 880         int                     count, fd, rv, s;
 881
 882         s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 883         if (s == -1)
 884                 return -1;
 885
 886         memset(&btr, 0, sizeof(btr));
 887         count = 0;
 888
 889         while (ioctl(s, SIOCNBTINFO, &btr) != -1) {
 890                 count++;
 891
 892                 if (cb == NULL)
 893                         continue;
 894
 895                 fd = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 896                 if (fd == -1) {
 897                         close(s);
 898                         return -1;
 899                 }
 900
 901                 if (bt__devinfo(fd, btr.btr_name, &info) == -1) {
 902                         close(fd);
 903                         close(s);
 904                         return -1;
 905                 }
 906
 907                 rv = (*cb)(fd, &info, arg);
 908                 close(fd);
 909                 if (rv != 0)
 910                         break;
 911         }
 912
 913         close(s);
 914         return count;
 915 }