/*      $NetBSD: bt_dev.c,v 1.5 2023/06/24 05:18:12 msaitoh Exp $       */

/*-
* Copyright (c) 2009 Iain Hibbert
* Copyright (c) 2009 Maksim Yevmenkin <[email protected]>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/*-
* Copyright (c) 2006 Itronix Inc.
* All rights reserved.
*
* Written by Iain Hibbert for Itronix Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. The name of Itronix Inc. may not be used to endorse
*    or promote products derived from this software without specific
*    prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__RCSID("$NetBSD: bt_dev.c,v 1.5 2023/06/24 05:18:12 msaitoh Exp $");

#include <sys/event.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/uio.h>

#include <bluetooth.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int
bt_devaddr(const char *name, bdaddr_t *addr)
{
       struct btreq btr;
       bdaddr_t bdaddr;
       int s, rv;

       if (name == NULL) {
               errno = EINVAL;
               return 0;
       }

       if (addr == NULL)
               addr = &bdaddr;

       if (bt_aton(name, addr))
               return bt_devname(NULL, addr);

       memset(&btr, 0, sizeof(btr));
       strlcpy(btr.btr_name, name, HCI_DEVNAME_SIZE);

       s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
       if (s == -1)
               return 0;

       rv = ioctl(s, SIOCGBTINFO, &btr);
       close(s);

       if (rv == -1)
               return 0;

       if ((btr.btr_flags & BTF_UP) == 0) {
               errno = ENXIO;
               return 0;
       }

       bdaddr_copy(addr, &btr.btr_bdaddr);
       return 1;
}

int
bt_devname(char *name, const bdaddr_t *bdaddr)
{
       struct btreq btr;
       int s, rv;

       if (bdaddr == NULL) {
               errno = EINVAL;
               return 0;
       }

       memset(&btr, 0, sizeof(btr));
       bdaddr_copy(&btr.btr_bdaddr, bdaddr);

       s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
       if (s == -1)
               return 0;

       rv = ioctl(s, SIOCGBTINFOA, &btr);
       close(s);

       if (rv == -1)
               return 0;

       if ((btr.btr_flags & BTF_UP) == 0) {
               errno = ENXIO;
               return 0;
       }

       if (name != NULL)
               strlcpy(name, btr.btr_name, HCI_DEVNAME_SIZE);

       return 1;
}

int
bt_devopen(const char *name, int options)
{
       struct sockaddr_bt      sa;
       int                     opt, s;

       memset(&sa, 0, sizeof(sa));
       sa.bt_len = sizeof(sa);
       sa.bt_family = AF_BLUETOOTH;

       if (name != NULL && !bt_devaddr(name, &sa.bt_bdaddr))
               return -1;

       s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
       if (s == -1)
               return -1;

       opt = 1;

       if ((options & BTOPT_DIRECTION) && setsockopt(s, BTPROTO_HCI,
           SO_HCI_DIRECTION, &opt, sizeof(opt)) == -1) {
               close(s);
               return -1;
       }

       if ((options & BTOPT_TIMESTAMP) && setsockopt(s, SOL_SOCKET,
           SO_TIMESTAMP, &opt, sizeof(opt)) == -1) {
               close(s);
               return -1;
       }

       if (bind(s, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
               close(s);
               return -1;
       }

       if (name != NULL
           && connect(s, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
               close(s);
               return -1;
       }

       return s;
}

ssize_t
bt_devsend(int s, uint16_t opcode, void *param, size_t plen)
{
       hci_cmd_hdr_t   hdr;
       struct iovec    iov[2];
       ssize_t         n;

       if (plen > UINT8_MAX
           || (plen == 0 && param != NULL)
           || (plen != 0 && param == NULL)) {
               errno = EINVAL;
               return -1;
       }

       hdr.type = HCI_CMD_PKT;
       hdr.opcode = htole16(opcode);
       hdr.length = (uint8_t)plen;

       iov[0].iov_base = &hdr;
       iov[0].iov_len = sizeof(hdr);

       iov[1].iov_base = param;
       iov[1].iov_len = plen;

       while ((n = writev(s, iov, __arraycount(iov))) == -1) {
               if (errno == EINTR)
                       continue;

               return -1;
       }

       return n;
}

ssize_t
bt_devrecv(int s, void *buf, size_t size, time_t to)
{
       struct kevent   ev;
       struct timespec ts;
       uint8_t         *p;
       ssize_t         n;
       int             kq;

       if (buf == NULL || size == 0) {
               errno = EINVAL;
               return -1;
       }

       if (to >= 0) {  /* timeout is optional */
               kq = kqueue();
               if (kq == -1)
                       return -1;

               EV_SET(&ev, s, EVFILT_READ, EV_ADD, 0, 0, 0);

               ts.tv_sec = to;
               ts.tv_nsec = 0;

               while (kevent(kq, &ev, 1, &ev, 1, &ts) == -1) {
                       if (errno == EINTR)
                               continue;

                       close(kq);
                       return -1;
               }

               close(kq);

               if (ev.data == 0) {
                       errno = ETIMEDOUT;
                       return -1;
               }
       }

       while ((n = recv(s, buf, size, 0)) == -1) {
               if (errno == EINTR)
                       continue;

               return -1;
       }

       if (n == 0)
               return 0;

       p = buf;
       switch (p[0]) { /* validate that they get complete packets */
       case HCI_CMD_PKT:
               if (sizeof(hci_cmd_hdr_t) > (size_t)n
                   || sizeof(hci_cmd_hdr_t) + p[3] != (size_t)n)
                       break;

               return n;

       case HCI_ACL_DATA_PKT:
               if (sizeof(hci_acldata_hdr_t) > (size_t)n
                   || sizeof(hci_acldata_hdr_t) + le16dec(p + 3) != (size_t)n)
                       break;

               return n;

       case HCI_SCO_DATA_PKT:
               if (sizeof(hci_scodata_hdr_t) > (size_t)n
                   || sizeof(hci_scodata_hdr_t) + p[3] != (size_t)n)
                       break;

               return n;

       case HCI_EVENT_PKT:
               if (sizeof(hci_event_hdr_t) > (size_t)n
                   || sizeof(hci_event_hdr_t) + p[2] != (size_t)n)
                       break;

               return n;

       default:
               break;
       }

       errno = EIO;
       return -1;
}

/*
* Internal handler for bt_devreq(), do the actual request.
*/
static int
bt__devreq(int s, struct bt_devreq *req, time_t t_end)
{
       uint8_t                 buf[HCI_EVENT_PKT_SIZE], *p;
       hci_event_hdr_t         ev;
       hci_command_status_ep   cs;
       hci_command_compl_ep    cc;
       time_t                  to;
       ssize_t                 n;

       n = bt_devsend(s, req->opcode, req->cparam, req->clen);
       if (n == -1)
               return errno;

       for (;;) {
               to = t_end - time(NULL);
               if (to < 0)
                       return ETIMEDOUT;

               p = buf;
               n = bt_devrecv(s, buf, sizeof(buf), to);
               if (n == -1)
                       return errno;

               if (sizeof(ev) > (size_t)n || p[0] != HCI_EVENT_PKT)
                       return EIO;

               memcpy(&ev, p, sizeof(ev));
               p += sizeof(ev);
               n -= sizeof(ev);

               if (ev.event == req->event)
                       break;

               if (ev.event == HCI_EVENT_COMMAND_STATUS) {
                       if (sizeof(cs) > (size_t)n)
                               return EIO;

                       memcpy(&cs, p, sizeof(cs));
                       p += sizeof(cs);
                       n -= sizeof(cs);

                       if (le16toh(cs.opcode) == req->opcode) {
                               if (cs.status != 0)
                                       return EIO;

                               if (req->event == 0)
                                       break;
                       }

                       continue;
               }

               if (ev.event == HCI_EVENT_COMMAND_COMPL) {
                       if (sizeof(cc) > (size_t)n)
                               return EIO;

                       memcpy(&cc, p, sizeof(cc));
                       p += sizeof(cc);
                       n -= sizeof(cc);

                       if (le16toh(cc.opcode) == req->opcode)
                               break;

                       continue;
               }
       }

       /* copy out response data */
       if (req->rlen >= (size_t)n) {
               req->rlen = n;
               memcpy(req->rparam, p, req->rlen);
       } else if (req->rlen > 0)
               return EIO;

       return 0;
}

int
bt_devreq(int s, struct bt_devreq *req, time_t to)
{
       struct bt_devfilter     new, old;
       int                     error;

       if (req == NULL || to < 0
           || (req->rlen == 0 && req->rparam != NULL)
           || (req->rlen != 0 && req->rparam == NULL)) {
               errno = EINVAL;
               return -1;
       }

       memset(&new, 0, sizeof(new));
       bt_devfilter_pkt_set(&new, HCI_EVENT_PKT);
       bt_devfilter_evt_set(&new, HCI_EVENT_COMMAND_COMPL);
       bt_devfilter_evt_set(&new, HCI_EVENT_COMMAND_STATUS);

       if (req->event != 0)
               bt_devfilter_evt_set(&new, req->event);

       if (bt_devfilter(s, &new, &old) == -1)
               return -1;

       error = bt__devreq(s, req, to + time(NULL));

       (void)bt_devfilter(s, &old, NULL);

       if (error != 0) {
               errno = error;
               return -1;
       }

       return 0;
}

int
bt_devfilter(int s, const struct bt_devfilter *new, struct bt_devfilter *old)
{
       socklen_t       len;

       if (new == NULL && old == NULL) {
               errno = EINVAL;
               return -1;
       }

       len = sizeof(struct hci_filter);

       if (old != NULL) {
               if (getsockopt(s, BTPROTO_HCI,
                   SO_HCI_PKT_FILTER, &old->packet_mask, &len) == -1
                   || len != sizeof(struct hci_filter))
                       return -1;

               if (getsockopt(s, BTPROTO_HCI,
                   SO_HCI_EVT_FILTER, &old->event_mask, &len) == -1
                   || len != sizeof(struct hci_filter))
                       return -1;
       }

       if (new != NULL) {
               if (setsockopt(s, BTPROTO_HCI,
                   SO_HCI_PKT_FILTER, &new->packet_mask, len) == -1)
                       return -1;

               if (setsockopt(s, BTPROTO_HCI,
                   SO_HCI_EVT_FILTER, &new->event_mask, len) == -1)
                       return -1;
       }

       return 0;
}

void
bt_devfilter_pkt_set(struct bt_devfilter *filter, uint8_t type)
{

       hci_filter_set(type, &filter->packet_mask);
}

void
bt_devfilter_pkt_clr(struct bt_devfilter *filter, uint8_t type)
{

       hci_filter_clr(type, &filter->packet_mask);
}

int
bt_devfilter_pkt_tst(const struct bt_devfilter *filter, uint8_t type)
{

       return hci_filter_test(type, &filter->packet_mask);
}

void
bt_devfilter_evt_set(struct bt_devfilter *filter, uint8_t event)
{

       hci_filter_set(event, &filter->event_mask);
}

void
bt_devfilter_evt_clr(struct bt_devfilter *filter, uint8_t event)
{

       hci_filter_clr(event, &filter->event_mask);
}

int
bt_devfilter_evt_tst(const struct bt_devfilter *filter, uint8_t event)
{

       return hci_filter_test(event, &filter->event_mask);
}

/*
* Internal function used by bt_devinquiry to find the first
* active device.
*/
/* ARGSUSED */
static int
bt__devany_cb(int s, const struct bt_devinfo *info, void *arg)
{

       if ((info->enabled)) {
               strlcpy(arg, info->devname, HCI_DEVNAME_SIZE + 1);
               return 1;
       }

       return 0;
}

/*
* Internal function used by bt_devinquiry to insert inquiry
* results to an array. Make sure that a bdaddr only appears
* once in the list and always use the latest result.
*/
static void
bt__devresult(struct bt_devinquiry *ii, int *count, int max_count,
   bdaddr_t *ba, uint8_t psrm, uint8_t pspm, uint8_t *cl, uint16_t co,
   int8_t rssi, uint8_t *data)
{
       int     n;

       for (n = 0; ; n++, ii++) {
               if (n == *count) {
                       if (*count == max_count)
                               return;

                       (*count)++;
                       break;
               }

               if (bdaddr_same(&ii->bdaddr, ba))
                       break;
       }

       bdaddr_copy(&ii->bdaddr, ba);
       ii->pscan_rep_mode = psrm;
       ii->pscan_period_mode = pspm;
       ii->clock_offset = le16toh(co);
       ii->rssi = rssi;

       if (cl != NULL)
               memcpy(ii->dev_class, cl, HCI_CLASS_SIZE);

       if (data != NULL)
               memcpy(ii->data, data, 240);
}

int
bt_devinquiry(const char *name, time_t to, int max_rsp,
   struct bt_devinquiry **iip)
{
       uint8_t                 buf[HCI_EVENT_PKT_SIZE], *p;
       struct bt_devfilter     f;
       hci_event_hdr_t         ev;
       hci_command_status_ep   sp;
       hci_inquiry_cp          cp;
       hci_inquiry_result_ep   ip;
       hci_inquiry_response    ir;
       hci_rssi_result_ep      rp;
       hci_rssi_response       rr;
       hci_extended_result_ep  ep;
       struct bt_devinquiry    *ii;
       int                     count, i, s;
       time_t                  t_end;
       ssize_t                 n;

       if (iip == NULL) {
               errno = EINVAL;
               return -1;
       }

       if (name == NULL) {
               if (bt_devenum(bt__devany_cb, buf) == -1)
                       return -1;

               name = (const char *)buf;
       }

       s = bt_devopen(name, 0);
       if (s == -1)
               return -1;

       memset(&f, 0, sizeof(f));
       bt_devfilter_pkt_set(&f, HCI_EVENT_PKT);
       bt_devfilter_evt_set(&f, HCI_EVENT_COMMAND_STATUS);
       bt_devfilter_evt_set(&f, HCI_EVENT_INQUIRY_COMPL);
       bt_devfilter_evt_set(&f, HCI_EVENT_INQUIRY_RESULT);
       bt_devfilter_evt_set(&f, HCI_EVENT_RSSI_RESULT);
       bt_devfilter_evt_set(&f, HCI_EVENT_EXTENDED_RESULT);
       if (bt_devfilter(s, &f, NULL) == -1) {
               close(s);
               return -1;
       }

       /*
        * silently adjust number of responses to fit in uint8_t
        */
       if (max_rsp < 1)
               max_rsp = 8;
       else if (max_rsp > UINT8_MAX)
               max_rsp = UINT8_MAX;

       ii = calloc((size_t)max_rsp, sizeof(struct bt_devinquiry));
       if (ii == NULL) {
               close(s);
               return -1;
       }

       /*
        * silently adjust timeout value so that inquiry_length
        * falls into the range 0x01->0x30 (unit is 1.28 seconds)
        */
       if (to < 1)
               to = 5;
       else if (to == 1)
               to = 2;
       else if (to > 62)
               to = 62;

       /* General Inquiry LAP is 0x9e8b33 */
       cp.lap[0] = 0x33;
       cp.lap[1] = 0x8b;
       cp.lap[2] = 0x9e;
       cp.inquiry_length = (uint8_t)(to * 100 / 128);
       cp.num_responses = (uint8_t)max_rsp;

       if (bt_devsend(s, HCI_CMD_INQUIRY, &cp, sizeof(cp)) == -1)
               goto fail;

       count = 0;

       for (t_end = time(NULL) + to + 1; to > 0; to = t_end - time(NULL)) {
               p = buf;
               n = bt_devrecv(s, buf, sizeof(buf), to);
               if (n == -1)
                       goto fail;

               if (sizeof(ev) > (size_t)n) {
                       errno = EIO;
                       goto fail;
               }

               memcpy(&ev, p, sizeof(ev));
               p += sizeof(ev);
               n -= sizeof(ev);

               switch (ev.event) {
               case HCI_EVENT_COMMAND_STATUS:
                       if (sizeof(sp) > (size_t)n)
                               break;

                       memcpy(&sp, p, sizeof(sp));

                       if (le16toh(sp.opcode) != HCI_CMD_INQUIRY
                           || sp.status == 0)
                               break;

                       errno = EIO;
                       goto fail;

               case HCI_EVENT_INQUIRY_COMPL:
                       close(s);
                       *iip = ii;
                       return count;

               case HCI_EVENT_INQUIRY_RESULT:
                       if (sizeof(ip) > (size_t)n)
                               break;

                       memcpy(&ip, p, sizeof(ip));
                       p += sizeof(ip);
                       n -= sizeof(ip);

                       if (sizeof(ir) * ip.num_responses != (size_t)n)
                               break;

                       for (i = 0; i < ip.num_responses; i++) {
                               memcpy(&ir, p, sizeof(ir));
                               p += sizeof(ir);

                               bt__devresult(ii, &count, max_rsp,
                                       &ir.bdaddr,
                                       ir.page_scan_rep_mode,
                                       ir.page_scan_period_mode,
                                       ir.uclass,
                                       ir.clock_offset,
                                       0,              /* rssi */
                                       NULL);          /* extended data */
                       }

                       break;

               case HCI_EVENT_RSSI_RESULT:
                       if (sizeof(rp) > (size_t)n)
                               break;

                       memcpy(&rp, p, sizeof(rp));
                       p += sizeof(rp);
                       n -= sizeof(rp);

                       if (sizeof(rr) * rp.num_responses != (size_t)n)
                               break;

                       for (i = 0; i < rp.num_responses; i++) {
                               memcpy(&rr, p, sizeof(rr));
                               p += sizeof(rr);

                               bt__devresult(ii, &count, max_rsp,
                                       &rr.bdaddr,
                                       rr.page_scan_rep_mode,
                                       0,      /* page scan period mode */
                                       rr.uclass,
                                       rr.clock_offset,
                                       rr.rssi,
                                       NULL);          /* extended data */
                       }

                       break;

               case HCI_EVENT_EXTENDED_RESULT:
                       if (sizeof(ep) != (size_t)n)
                               break;

                       memcpy(&ep, p, sizeof(ep));

                       if (ep.num_responses != 1)
                               break;

                       bt__devresult(ii, &count, max_rsp,
                               &ep.bdaddr,
                               ep.page_scan_rep_mode,
                               0,      /* page scan period mode */
                               ep.uclass,
                               ep.clock_offset,
                               ep.rssi,
                               ep.response);

                       break;

               default:
                       break;
               }
       }

       errno = ETIMEDOUT;

fail:
       free(ii);
       close(s);
       return -1;
}

/*
* Internal version of bt_devinfo. Fill in the devinfo structure
* with the socket handle provided.
*/
static int
bt__devinfo(int s, const char *name, struct bt_devinfo *info)
{
       struct btreq                    btr;

       memset(&btr, 0, sizeof(btr));
       strlcpy(btr.btr_name, name, HCI_DEVNAME_SIZE);

       if (ioctl(s, SIOCGBTINFO, &btr) == -1)
               return -1;

       memset(info, 0, sizeof(struct bt_devinfo));
       memcpy(info->devname, btr.btr_name, HCI_DEVNAME_SIZE);
       bdaddr_copy(&info->bdaddr, &btr.btr_bdaddr);
       info->enabled = ((btr.btr_flags & BTF_UP) ? 1 : 0);

       info->sco_size = btr.btr_sco_mtu;
       info->acl_size = btr.btr_acl_mtu;
       info->cmd_free = btr.btr_num_cmd;
       info->sco_free = btr.btr_num_sco;
       info->acl_free = btr.btr_num_acl;
       info->sco_pkts = btr.btr_max_sco;
       info->acl_pkts = btr.btr_max_acl;

       info->link_policy_info = btr.btr_link_policy;
       info->packet_type_info = btr.btr_packet_type;

       if (ioctl(s, SIOCGBTFEAT, &btr) == -1)
               return -1;

       memcpy(info->features, btr.btr_features0, HCI_FEATURES_SIZE);

       if (ioctl(s, SIOCGBTSTATS, &btr) == -1)
               return -1;

       info->cmd_sent = btr.btr_stats.cmd_tx;
       info->evnt_recv = btr.btr_stats.evt_rx;
       info->acl_recv = btr.btr_stats.acl_rx;
       info->acl_sent = btr.btr_stats.acl_tx;
       info->sco_recv = btr.btr_stats.sco_rx;
       info->sco_sent = btr.btr_stats.sco_tx;
       info->bytes_recv = btr.btr_stats.byte_rx;
       info->bytes_sent = btr.btr_stats.byte_tx;

       return 0;
}

int
bt_devinfo(const char *name, struct bt_devinfo *info)
{
       int     rv, s;

       if (name == NULL || info == NULL) {
               errno = EINVAL;
               return -1;
       }

       s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
       if (s == -1)
               return -1;

       rv = bt__devinfo(s, name, info);
       close(s);
       return rv;
}

int
bt_devenum(bt_devenum_cb_t cb, void *arg)
{
       struct btreq            btr;
       struct bt_devinfo       info;
       struct sockaddr_bt      sa;
       int                     count, fd, rv, s;

       s = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
       if (s == -1)
               return -1;

       memset(&btr, 0, sizeof(btr));
       count = 0;

       while (ioctl(s, SIOCNBTINFO, &btr) != -1) {
               count++;

               if (cb == NULL)
                       continue;

               fd = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
               if (fd == -1) {
                       close(s);
                       return -1;
               }

               if (bt__devinfo(fd, btr.btr_name, &info) == -1) {
                       close(fd);
                       close(s);
                       return -1;
               }

               if (info.enabled) {
                       memset(&sa, 0, sizeof(sa));
                       sa.bt_len = sizeof(sa);
                       sa.bt_family = AF_BLUETOOTH;
                       bdaddr_copy(&sa.bt_bdaddr, &info.bdaddr);

                       if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1
                           || connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
                               close(fd);
                               close(s);
                               return -1;
                       }
               }

               rv = (*cb)(fd, &info, arg);
               close(fd);
               if (rv != 0)
                       break;
       }

       close(s);
       return count;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.