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