?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix typo.
[dragonfly.git] / usr.sbin / btconfig / btconfig.c
blob8dc4b645e9b89662c8dac03caa0b9ce985f5b69d
1 /* $NetBSD: btconfig.c,v 1.6 2007/09/07 18:40:01 plunky Exp $ */
2 /* $DragonFly: src/usr.sbin/btconfig/btconfig.c,v 1.2 2008/04/20 13:44:26 swildner Exp $ */
3
4 /*-
5 * Copyright (c) 2006 Itronix Inc.
6 * All rights reserved.
7 *
8 * Written by Iain Hibbert for Itronix Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. The name of Itronix Inc. may not be used to endorse
19 * or promote products derived from this software without specific
20 * prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
26 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29 * ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include <sys/types.h>
36 #include <sys/param.h>
37 #include <sys/socket.h>
38 #include <sys/ioctl.h>
39
40 #include <net/if.h>
41
42 #include <stdio.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <stdlib.h>
46 #include <stdarg.h>
47 #include <unistd.h>
48 #include <errno.h>
49 #include <err.h>
50 #include <bluetooth.h>
51 #include <netbt/hci.h>
52 #include <sys/endian.h>
53
54 /* inquiry results storage */
55 struct result {
56 bdaddr_t bdaddr;
57 uint8_t page_scan_rep_mode;
58 uint8_t uclass[HCI_CLASS_SIZE];
59 uint16_t clock_offset;
60 int8_t rssi;
61 };
62
63 int main(int, char *[]);
64 void badarg(const char *);
65 void badparam(const char *);
66 void usage(void);
67 int set_unit(unsigned long);
68 void config_unit(void);
69 void print_info(int);
70 void print_stats(void);
71 void print_class(const char *);
72 void print_voice(int);
73 void tag(const char *);
74 void print_features(const char *, uint8_t *);
75 void do_inquiry(void);
76 void print_result(int, struct result *, int);
77 void printb(uint16_t v, const char *bits);
78
79 void hci_req(uint16_t, uint8_t , void *, size_t, void *, size_t);
80 #define save_value(opcode, cbuf, clen) hci_req(opcode, 0, cbuf, clen, NULL, 0)
81 #define load_value(opcode, rbuf, rlen) hci_req(opcode, 0, NULL, 0, rbuf, rlen)
82 #define hci_cmd(opcode, cbuf, clen) hci_req(opcode, 0, cbuf, clen, NULL, 0)
83
84 #define MAX_STR_SIZE 0xff
85
86 /* print width */
87 int width = 0;
88 #define MAX_WIDTH 70
89
90 /* global variables */
91 int hci;
92 struct btreq btr;
93
94 /* command line flags */
95 int verbose = 0; /* more info */
96 int lflag = 0; /* list devices */
97 int sflag = 0; /* get/zero stats */
98
99 /* device up/down (flag) */
100 int opt_enable = 0;
101 int opt_reset = 0;
102 #define FLAGBITS "\001UP" \
103 "\002RUNNING" \
104 "\003XMIT_CMD" \
105 "\004XMIT_ACL" \
106 "\005XMIT_SCO" \
107 "\006INIT_BDADDR" \
108 "\007INIT_BUFFER_SIZE" \
109 "\010INIT_FEATURES"
110
111 /* authorisation (flag) */
112 int opt_auth = 0;
113
114 /* encryption (flag) */
115 int opt_encrypt = 0;
116
117 /* scan enable options (flags) */
118 int opt_pscan = 0;
119 int opt_iscan = 0;
120
121 /* link policy options (flags) */
122 int opt_switch = 0;
123 int opt_hold = 0;
124 int opt_sniff = 0;
125 int opt_park = 0;
126
127 /* class of device (hex value) */
128 int opt_class = 0;
129 uint32_t class;
130
131 /* packet type mask (hex value) */
132 int opt_ptype = 0;
133 uint32_t ptype;
134
135 /* unit name (string) */
136 int opt_name = 0;
137 char name[MAX_STR_SIZE];
138
139 /* pin type */
140 int opt_pin = 0;
141
142 /* Inquiry */
143 int opt_rssi = 0; /* inquiry_with_rssi (flag) */
144 int opt_inquiry = 0;
145 #define INQUIRY_LENGTH 10 /* about 12 seconds */
146 #define INQUIRY_MAX_RESPONSES 10
147
148 /* Voice Settings */
149 int opt_voice = 0;
150 uint32_t voice;
151
152 /* Page Timeout */
153 int opt_pto = 0;
154 uint32_t pto;
155
156 /* set SCO mtu */
157 int opt_scomtu;
158 uint32_t scomtu;
159
160 struct parameter {
161 const char *name;
162 enum { P_SET, P_CLR, P_STR, P_HEX, P_NUM } type;
163 int *opt;
164 void *val;
165 } parameters[] = {
166 { "up", P_SET, &opt_enable, NULL },
167 { "enable", P_SET, &opt_enable, NULL },
168 { "down", P_CLR, &opt_enable, NULL },
169 { "disable", P_CLR, &opt_enable, NULL },
170 { "name", P_STR, &opt_name, name },
171 { "pscan", P_SET, &opt_pscan, NULL },
172 { "-pscan", P_CLR, &opt_pscan, NULL },
173 { "iscan", P_SET, &opt_iscan, NULL },
174 { "-iscan", P_CLR, &opt_iscan, NULL },
175 { "switch", P_SET, &opt_switch, NULL },
176 { "-switch", P_CLR, &opt_switch, NULL },
177 { "hold", P_SET, &opt_hold, NULL },
178 { "-hold", P_CLR, &opt_hold, NULL },
179 { "sniff", P_SET, &opt_sniff, NULL },
180 { "-sniff", P_CLR, &opt_sniff, NULL },
181 { "park", P_SET, &opt_park, NULL },
182 { "-park", P_CLR, &opt_park, NULL },
183 { "auth", P_SET, &opt_auth, NULL },
184 { "-auth", P_CLR, &opt_auth, NULL },
185 { "encrypt", P_SET, &opt_encrypt, NULL },
186 { "-encrypt", P_CLR, &opt_encrypt, NULL },
187 { "ptype", P_HEX, &opt_ptype, &ptype },
188 { "class", P_HEX, &opt_class, &class },
189 { "fixed", P_SET, &opt_pin, NULL },
190 { "variable", P_CLR, &opt_pin, NULL },
191 { "inq", P_SET, &opt_inquiry, NULL },
192 { "inquiry", P_SET, &opt_inquiry, NULL },
193 { "rssi", P_SET, &opt_rssi, NULL },
194 { "-rssi", P_CLR, &opt_rssi, NULL },
195 { "reset", P_SET, &opt_reset, NULL },
196 { "voice", P_HEX, &opt_voice, &voice },
197 { "pto", P_NUM, &opt_pto, &pto },
198 { "scomtu", P_NUM, &opt_scomtu, &scomtu },
199 { NULL, 0, NULL, NULL }
200 };
201
202 int
203 main(int ac, char *av[])
204 {
205 int ch;
206 struct parameter *p;
207
208 while ((ch = getopt(ac, av, "hlsvz")) != -1) {
209 switch(ch) {
210 case 'l':
211 lflag = 1;
212 break;
213
214 case 's':
215 sflag = 1;
216 break;
217
218 case 'v':
219 verbose++;
220 break;
221
222 case 'z':
223 sflag = 2;
224 break;
225
226 case 'h':
227 default:
228 usage();
229 }
230 }
231 av += optind;
232 ac -= optind;
233
234 if (lflag && sflag)
235 usage();
236
237
238 hci = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
239 if (hci == -1)
240 err(EXIT_FAILURE, "socket");
241
242 if (ac == 0) {
243 verbose++;
244
245 memset(&btr, 0, sizeof(btr));
246 while (set_unit(SIOCNBTINFO) != -1) {
247 print_info(99);
248 print_stats();
249 }
250
251 tag(NULL);
252 } else {
253 strlcpy(btr.btr_name, *av, HCI_DEVNAME_SIZE);
254 av++, ac--;
255
256 if (set_unit(SIOCGBTINFO) < 0)
257 err(EXIT_FAILURE, "%s", btr.btr_name);
258
259 if (ac == 0)
260 verbose += 2;
261
262 while (ac > 0) {
263 for (p = parameters ; ; p++) {
264 if (p->name == NULL)
265 badparam(*av);
266
267 if (strcmp(*av, p->name) == 0)
268 break;
269 }
270
271 switch(p->type) {
272 case P_SET:
273 *(p->opt) = 1;
274 break;
275
276 case P_CLR:
277 *(p->opt) = -1;
278 break;
279
280 case P_STR:
281 if (--ac < 1) badarg(p->name);
282 strlcpy((char *)(p->val), *++av, MAX_STR_SIZE);
283 *(p->opt) = 1;
284 break;
285
286 case P_HEX:
287 if (--ac < 1) badarg(p->name);
288 *(uint32_t *)(p->val) = strtoul(*++av, NULL, 16);
289 *(p->opt) = 1;
290 break;
291
292 case P_NUM:
293 if (--ac < 1) badarg(p->name);
294 *(uint32_t *)(p->val) = strtoul(*++av, NULL, 10);
295 *(p->opt) = 1;
296 break;
297 }
298
299 av++, ac--;
300 }
301
302 config_unit();
303 print_info(verbose);
304 print_stats();
305 do_inquiry();
306 }
307
308 close(hci);
309 return EXIT_SUCCESS;
310 }
311
312 void
313 badparam(const char *param)
314 {
315 fprintf(stderr, "unknown parameter '%s'\n", param);
316 exit(EXIT_FAILURE);
317 }
318
319 void
320 badarg(const char *param)
321 {
322 fprintf(stderr, "parameter '%s' needs argument\n", param);
323 exit(EXIT_FAILURE);
324 }
325
326 void
327 usage(void)
328 {
329 fprintf(stderr, "usage: %s [-svz] [device [parameters]]\n", getprogname());
330 fprintf(stderr, " %s -l\n", getprogname());
331 exit(EXIT_FAILURE);
332 }
333
334 /*
335 * pretty printing feature
336 */
337 void
338 tag(const char *f)
339 {
340 if (f == NULL) {
341 if (width > 0)
342 printf("\n");
343
344 width = 0;
345 } else {
346 width += printf("%*s%s",
347 (width == 0 ? (lflag ? 0 : 8) : 1),
348 "", f);
349
350 if (width > MAX_WIDTH) {
351 printf("\n");
352 width = 0;
353 }
354 }
355 }
356
357 /*
358 * basic HCI cmd request function with argument return.
359 *
360 * Normally, this will return on COMMAND_STATUS or COMMAND_COMPLETE for the given
361 * opcode, but if event is given then it will ignore COMMAND_STATUS (unless error)
362 * and wait for the specified event.
363 *
364 * if rbuf/rlen is given, results will be copied into the result buffer for
365 * COMMAND_COMPLETE/event responses.
366 */
367 void
368 hci_req(uint16_t opcode, uint8_t event, void *cbuf, size_t clen, void *rbuf, size_t rlen)
369 {
370 uint8_t msg[sizeof(hci_cmd_hdr_t) + HCI_CMD_PKT_SIZE];
371 hci_event_hdr_t *ep;
372 hci_cmd_hdr_t *cp;
373
374 cp = (hci_cmd_hdr_t *)msg;
375 cp->type = HCI_CMD_PKT;
376 cp->opcode = opcode = htole16(opcode);
377 cp->length = clen = MIN(clen, sizeof(msg) - sizeof(hci_cmd_hdr_t));
378
379 if (clen) memcpy((cp + 1), cbuf, clen);
380
381 if (send(hci, msg, sizeof(hci_cmd_hdr_t) + clen, 0) < 0)
382 err(EXIT_FAILURE, "HCI Send");
383
384 ep = (hci_event_hdr_t *)msg;
385 for(;;) {
386 if (recv(hci, msg, sizeof(msg), 0) < 0) {
387 if (errno == EAGAIN || errno == EINTR)
388 continue;
389
390 err(EXIT_FAILURE, "HCI Recv");
391 }
392
393 if (ep->event == HCI_EVENT_COMMAND_STATUS) {
394 hci_command_status_ep *cs;
395
396 cs = (hci_command_status_ep *)(ep + 1);
397 if (cs->opcode != opcode)
398 continue;
399
400 if (cs->status)
401 errx(EXIT_FAILURE,
402 "HCI cmd (%4.4x) failed (status %d)",
403 opcode, cs->status);
404
405 if (event == 0)
406 break;
407
408 continue;
409 }
410
411 if (ep->event == HCI_EVENT_COMMAND_COMPL) {
412 hci_command_compl_ep *cc;
413 uint8_t *ptr;
414
415 cc = (hci_command_compl_ep *)(ep + 1);
416 if (cc->opcode != opcode)
417 continue;
418
419 if (rbuf == NULL)
420 break;
421
422 ptr = (uint8_t *)(cc + 1);
423 if (*ptr)
424 errx(EXIT_FAILURE,
425 "HCI cmd (%4.4x) failed (status %d)",
426 opcode, *ptr);
427
428 memcpy(rbuf, ++ptr, rlen);
429 break;
430 }
431
432 if (ep->event == event) {
433 if (rbuf == NULL)
434 break;
435
436 memcpy(rbuf, (ep + 1), rlen);
437 break;
438 }
439 }
440 }
441
442 int
443 set_unit(unsigned long cmd)
444 {
445 if (ioctl(hci, cmd, &btr) == -1)
446 return -1;
447
448 if (btr.btr_flags & BTF_UP) {
449 struct sockaddr_bt sa;
450
451 sa.bt_len = sizeof(sa);
452 sa.bt_family = AF_BLUETOOTH;
453 bdaddr_copy(&sa.bt_bdaddr, &btr.btr_bdaddr);
454
455 if (bind(hci, (struct sockaddr *)&sa, sizeof(sa)) < 0)
456 err(EXIT_FAILURE, "bind");
457
458 if (connect(hci, (struct sockaddr *)&sa, sizeof(sa)) < 0)
459 err(EXIT_FAILURE, "connect");
460 }
461
462 return 0;
463 }
464
465 /*
466 * apply configuration parameters to unit
467 */
468 void
469 config_unit(void)
470 {
471 if (opt_enable) {
472 if (opt_enable > 0)
473 btr.btr_flags |= BTF_UP;
474 else
475 btr.btr_flags &= ~BTF_UP;
476
477 if (ioctl(hci, SIOCSBTFLAGS, &btr) < 0)
478 err(EXIT_FAILURE, "SIOCSBTFLAGS");
479
480 if (set_unit(SIOCGBTINFO) < 0)
481 err(EXIT_FAILURE, "%s", btr.btr_name);
482 }
483
484 if (opt_reset) {
485 hci_cmd(HCI_CMD_RESET, NULL, 0);
486
487 btr.btr_flags |= BTF_INIT;
488 if (ioctl(hci, SIOCSBTFLAGS, &btr) < 0)
489 err(EXIT_FAILURE, "SIOCSBTFLAGS");
490
491 /*
492 * although the reset command will automatically
493 * carry out these commands, we do them manually
494 * just so we can wait for completion.
495 */
496 hci_cmd(HCI_CMD_READ_BDADDR, NULL, 0);
497 hci_cmd(HCI_CMD_READ_BUFFER_SIZE, NULL, 0);
498 hci_cmd(HCI_CMD_READ_LOCAL_FEATURES, NULL, 0);
499
500 if (set_unit(SIOCGBTINFO) < 0)
501 err(EXIT_FAILURE, "%s", btr.btr_name);
502 }
503
504 if (opt_switch || opt_hold || opt_sniff || opt_park) {
505 uint16_t val = btr.btr_link_policy;
506
507 if (opt_switch > 0) val |= HCI_LINK_POLICY_ENABLE_ROLE_SWITCH;
508 if (opt_switch < 0) val &= ~HCI_LINK_POLICY_ENABLE_ROLE_SWITCH;
509 if (opt_hold > 0) val |= HCI_LINK_POLICY_ENABLE_HOLD_MODE;
510 if (opt_hold < 0) val &= ~HCI_LINK_POLICY_ENABLE_HOLD_MODE;
511 if (opt_sniff > 0) val |= HCI_LINK_POLICY_ENABLE_SNIFF_MODE;
512 if (opt_sniff < 0) val &= ~HCI_LINK_POLICY_ENABLE_SNIFF_MODE;
513 if (opt_park > 0) val |= HCI_LINK_POLICY_ENABLE_PARK_MODE;
514 if (opt_park < 0) val &= ~HCI_LINK_POLICY_ENABLE_PARK_MODE;
515
516 btr.btr_link_policy = val;
517 if (ioctl(hci, SIOCSBTPOLICY, &btr) < 0)
518 err(EXIT_FAILURE, "SIOCSBTPOLICY");
519 }
520
521 if (opt_ptype) {
522 btr.btr_packet_type = ptype;
523 if (ioctl(hci, SIOCSBTPTYPE, &btr) < 0)
524 err(EXIT_FAILURE, "SIOCSBTPTYPE");
525 }
526
527 if (opt_pscan || opt_iscan) {
528 uint8_t val;
529
530 load_value(HCI_CMD_READ_SCAN_ENABLE, &val, sizeof(val));
531 if (opt_pscan > 0) val |= HCI_PAGE_SCAN_ENABLE;
532 if (opt_pscan < 0) val &= ~HCI_PAGE_SCAN_ENABLE;
533 if (opt_iscan > 0) val |= HCI_INQUIRY_SCAN_ENABLE;
534 if (opt_iscan < 0) val &= ~HCI_INQUIRY_SCAN_ENABLE;
535 save_value(HCI_CMD_WRITE_SCAN_ENABLE, &val, sizeof(val));
536 }
537
538 if (opt_auth) {
539 uint8_t val = (opt_auth > 0 ? 1 : 0);
540
541 save_value(HCI_CMD_WRITE_AUTH_ENABLE, &val, sizeof(val));
542 }
543
544 if (opt_encrypt) {
545 uint8_t val = (opt_encrypt > 0 ? 1 : 0);
546
547 save_value(HCI_CMD_WRITE_ENCRYPTION_MODE, &val, sizeof(val));
548 }
549
550 if (opt_name)
551 save_value(HCI_CMD_WRITE_LOCAL_NAME, name, HCI_UNIT_NAME_SIZE);
552
553 if (opt_class) {
554 uint8_t val[HCI_CLASS_SIZE];
555
556 val[0] = (class >> 0) & 0xff;
557 val[1] = (class >> 8) & 0xff;
558 val[2] = (class >> 16) & 0xff;
559
560 save_value(HCI_CMD_WRITE_UNIT_CLASS, val, HCI_CLASS_SIZE);
561 }
562
563 if (opt_pin) {
564 uint8_t val;
565
566 if (opt_pin > 0) val = 1;
567 else val = 0;
568
569 save_value(HCI_CMD_WRITE_PIN_TYPE, &val, sizeof(val));
570 }
571
572 if (opt_voice) {
573 uint16_t val;
574
575 val = htole16(voice & 0x03ff);
576 save_value(HCI_CMD_WRITE_VOICE_SETTING, &val, sizeof(val));
577 }
578
579 if (opt_pto) {
580 uint16_t val;
581
582 val = htole16(pto * 8 / 5);
583 save_value(HCI_CMD_WRITE_PAGE_TIMEOUT, &val, sizeof(val));
584 }
585
586 if (opt_scomtu) {
587 if (scomtu > 0xff) {
588 warnx("Invalid SCO mtu %d", scomtu);
589 } else {
590 btr.btr_sco_mtu = scomtu;
591
592 if (ioctl(hci, SIOCSBTSCOMTU, &btr) < 0)
593 warn("SIOCSBTSCOMTU");
594 }
595 }
596
597 if (opt_rssi) {
598 uint8_t val = (opt_rssi > 0 ? 1 : 0);
599
600 save_value(HCI_CMD_WRITE_INQUIRY_MODE, &val, sizeof(val));
601 }
602 }
603
604 /*
605 * Print info for Bluetooth Device with varying verbosity levels
606 */
607 void
608 print_info(int level)
609 {
610 uint8_t val, buf[MAX_STR_SIZE];
611 uint16_t val16;
612
613 if (lflag) {
614 tag(btr.btr_name);
615 return;
616 }
617
618 if (level-- < 1)
619 return;
620
621 printf("%s: bdaddr %s flags %#x", btr.btr_name,
622 bt_ntoa(&btr.btr_bdaddr, NULL), btr.btr_flags);
623 printb(btr.btr_flags, FLAGBITS);
624 printf("\n");
625
626 if (level-- < 1)
627 return;
628
629 printf("\tnum_cmd = %d\n"
630 "\tnum_acl = %d, acl_mtu = %d\n"
631 "\tnum_sco = %d, sco_mtu = %d\n",
632 btr.btr_num_cmd,
633 btr.btr_num_acl, btr.btr_acl_mtu,
634 btr.btr_num_sco, btr.btr_sco_mtu);
635
636 if (level-- < 1 || (btr.btr_flags & BTF_UP) == 0)
637 return;
638
639 load_value(HCI_CMD_READ_UNIT_CLASS, buf, HCI_CLASS_SIZE);
640 class = (buf[2] << 16) | (buf[1] << 8) | (buf[0]);
641 print_class("\t");
642
643 load_value(HCI_CMD_READ_LOCAL_NAME, buf, HCI_UNIT_NAME_SIZE);
644 printf("\tname: \"%s\"\n", buf);
645
646 load_value(HCI_CMD_READ_VOICE_SETTING, buf, sizeof(uint16_t));
647 voice = (buf[1] << 8) | buf[0];
648 print_voice(level);
649
650 load_value(HCI_CMD_READ_PIN_TYPE, &val, sizeof(val));
651 printf("\tpin: %s\n", val ? "fixed" : "variable");
652
653 width = printf("\toptions:");
654
655 load_value(HCI_CMD_READ_SCAN_ENABLE, &val, sizeof(val));
656 if (val & HCI_INQUIRY_SCAN_ENABLE) tag("iscan");
657 else if (level > 0) tag("-iscan");
658
659 if (val & HCI_PAGE_SCAN_ENABLE) tag("pscan");
660 else if (level > 0) tag("-pscan");
661
662 load_value(HCI_CMD_READ_AUTH_ENABLE, &val, sizeof(val));
663 if (val) tag("auth");
664 else if (level > 0) tag("-auth");
665
666 load_value(HCI_CMD_READ_ENCRYPTION_MODE, &val, sizeof(val));
667 if (val) tag("encrypt");
668 else if (level > 0) tag("-encrypt");
669
670 val = btr.btr_link_policy;
671 if (val & HCI_LINK_POLICY_ENABLE_ROLE_SWITCH) tag("switch");
672 else if (level > 0) tag("-switch");
673 if (val & HCI_LINK_POLICY_ENABLE_HOLD_MODE) tag("hold");
674 else if (level > 0) tag("-hold");
675 if (val & HCI_LINK_POLICY_ENABLE_SNIFF_MODE) tag("sniff");
676 else if (level > 0) tag("-sniff");
677 if (val & HCI_LINK_POLICY_ENABLE_PARK_MODE) tag("park");
678 else if (level > 0) tag("-park");
679
680 load_value(HCI_CMD_READ_INQUIRY_MODE, &val, sizeof(val));
681 if (val) tag("rssi");
682 else if (level > 0) tag("-rssi");
683
684 tag(NULL);
685
686 if (level-- < 1)
687 return;
688
689 ptype = btr.btr_packet_type;
690 width = printf("\tptype: [0x%04x]", ptype);
691 if (ptype & HCI_PKT_DM1) tag("DM1");
692 if (ptype & HCI_PKT_DH1) tag("DH1");
693 if (ptype & HCI_PKT_DM3) tag("DM3");
694 if (ptype & HCI_PKT_DH3) tag("DH3");
695 if (ptype & HCI_PKT_DM5) tag("DM5");
696 if (ptype & HCI_PKT_DH5) tag("DH5");
697 if ((ptype & HCI_PKT_2MBPS_DH1) == 0) tag("2-DH1");
698 if ((ptype & HCI_PKT_3MBPS_DH1) == 0) tag("3-DH1");
699 if ((ptype & HCI_PKT_2MBPS_DH3) == 0) tag("2-DH3");
700 if ((ptype & HCI_PKT_3MBPS_DH3) == 0) tag("3-DH3");
701 if ((ptype & HCI_PKT_2MBPS_DH5) == 0) tag("2-DH5");
702 if ((ptype & HCI_PKT_3MBPS_DH5) == 0) tag("3-DH5");
703 tag(NULL);
704
705 load_value(HCI_CMD_READ_PAGE_TIMEOUT, &val16, sizeof(val16));
706 printf("\tpage timeout: %d ms\n", val16 * 5 / 8);
707
708 if (level-- < 1)
709 return;
710
711 load_value(HCI_CMD_READ_LOCAL_FEATURES, buf, HCI_FEATURES_SIZE);
712 print_features("\tfeatures:", buf);
713 }
714
715 void
716 print_stats(void)
717 {
718 if (sflag == 0)
719 return;
720
721 if (sflag == 1) {
722 if (ioctl(hci, SIOCGBTSTATS, &btr) < 0)
723 err(EXIT_FAILURE, "SIOCGBTSTATS");
724 } else {
725 if (ioctl(hci, SIOCZBTSTATS, &btr) < 0)
726 err(EXIT_FAILURE, "SIOCZBTSTATS");
727 }
728
729 printf( "\tTotal bytes sent %d, received %d\n"
730 "\tCommands sent %d, Events received %d\n"
731 "\tACL data packets sent %d, received %d\n"
732 "\tSCO data packets sent %d, received %d\n"
733 "\tInput errors %d, Output errors %d\n",
734 btr.btr_stats.byte_tx, btr.btr_stats.byte_rx,
735 btr.btr_stats.cmd_tx, btr.btr_stats.evt_rx,
736 btr.btr_stats.acl_tx, btr.btr_stats.acl_rx,
737 btr.btr_stats.sco_tx, btr.btr_stats.sco_rx,
738 btr.btr_stats.err_rx, btr.btr_stats.err_tx);
739 }
740
741 void
742 print_features(const char *str, uint8_t *f)
743 {
744 width = printf("%s", str);
745
746 /* ------------------- byte 0 --------------------*/
747 if (*f & HCI_LMP_3SLOT) tag("<3 slot>");
748 if (*f & HCI_LMP_5SLOT) tag("<5 slot>");
749 if (*f & HCI_LMP_ENCRYPTION) tag("<encryption>");
750 if (*f & HCI_LMP_SLOT_OFFSET) tag("<slot offset>");
751 if (*f & HCI_LMP_TIMIACCURACY) tag("<timing accuracy>");
752 if (*f & HCI_LMP_ROLE_SWITCH) tag("<role switch>");
753 if (*f & HCI_LMP_HOLD_MODE) tag("<hold mode>");
754 if (*f & HCI_LMP_SNIFF_MODE) tag("<sniff mode>");
755 f++;
756
757 /* ------------------- byte 1 --------------------*/
758 if (*f & HCI_LMP_PARK_MODE) tag("<park mode>");
759 if (*f & HCI_LMP_RSSI) tag("<RSSI>");
760 if (*f & HCI_LMP_CHANNEL_QUALITY) tag("<channel quality>");
761 if (*f & HCI_LMP_SCO_LINK) tag("<SCO link>");
762 if (*f & HCI_LMP_HV2_PKT) tag("<HV2>");
763 if (*f & HCI_LMP_HV3_PKT) tag("<HV3>");
764 if (*f & HCI_LMP_ULAW_LOG) tag("<u-Law log>");
765 if (*f & HCI_LMP_ALAW_LOG) tag("<A-Law log>");
766 f++;
767
768 /* ------------------- byte 1 --------------------*/
769 if (*f & HCI_LMP_CVSD) tag("<CVSD data>");
770 if (*f & HCI_LMP_PAGISCHEME) tag("<paging parameter>");
771 if (*f & HCI_LMP_POWER_CONTROL) tag("<power control>");
772 if (*f & HCI_LMP_TRANSPARENT_SCO) tag("<transparent SCO>");
773 if (*f & HCI_LMP_FLOW_CONTROL_LAG0) tag("<flow control lag 0>");
774 if (*f & HCI_LMP_FLOW_CONTROL_LAG1) tag("<flow control lag 1>");
775 if (*f & HCI_LMP_FLOW_CONTROL_LAG2) tag("<flow control lag 2>");
776 if (*f & HCI_LMP_BC_ENCRYPTION) tag("<broadcast encryption>");
777 f++;
778
779 /* ------------------- byte 3 --------------------*/
780 if (*f & HCI_LMP_EDR_ACL_2MBPS) tag("<EDR ACL 2Mbps>");
781 if (*f & HCI_LMP_EDR_ACL_3MBPS) tag("<EDR ACL 3Mbps>");
782 if (*f & HCI_LMP_ENHANCED_ISCAN) tag("<enhanced inquiry scan>");
783 if (*f & HCI_LMP_INTERLACED_ISCAN) tag("<interlaced inquiry scan>");
784 if (*f & HCI_LMP_INTERLACED_PSCAN) tag("<interlaced page scan>");
785 if (*f & HCI_LMP_RSSI_INQUIRY) tag("<RSSI with inquiry result>");
786 if (*f & HCI_LMP_EV3_PKT) tag("<EV3 packets>");
787 f++;
788
789 /* ------------------- byte 4 --------------------*/
790 if (*f & HCI_LMP_EV4_PKT) tag("<EV4 packets>");
791 if (*f & HCI_LMP_EV5_PKT) tag("<EV5 packets>");
792 if (*f & HCI_LMP_AFH_CAPABLE_SLAVE) tag("<AFH capable slave>");
793 if (*f & HCI_LMP_AFH_CLASS_SLAVE) tag("<AFH class slave>");
794 if (*f & HCI_LMP_3SLOT_EDR_ACL) tag("<3 slot EDR ACL>");
795 f++;
796
797 /* ------------------- byte 5 --------------------*/
798 if (*f & HCI_LMP_5SLOT_EDR_ACL) tag("<5 slot EDR ACL>");
799 if (*f & HCI_LMP_AFH_CAPABLE_MASTER)tag("<AFH capable master>");
800 if (*f & HCI_LMP_AFH_CLASS_MASTER) tag("<AFH class master>");
801 if (*f & HCI_LMP_EDR_eSCO_2MBPS) tag("<EDR eSCO 2Mbps>");
802 if (*f & HCI_LMP_EDR_eSCO_3MBPS) tag("<EDR eSCO 3Mbps>");
803 if (*f & HCI_LMP_3SLOT_EDR_eSCO) tag("<3 slot EDR eSCO>");
804 f++;
805
806 /* ------------------- byte 6 --------------------*/
807 f++;
808
809 /* ------------------- byte 7 --------------------*/
810 if (*f & HCI_LMP_EXTENDED_FEATURES) tag("<extended features>");
811
812 tag(NULL);
813 }
814
815 void
816 print_class(const char *str)
817 {
818 int major, minor;
819
820 major = (class & 0x1f00) >> 8;
821 minor = (class & 0x00fc) >> 2;
822
823 width = printf("%sclass: [0x%6.6x]", str, class);
824
825 switch (major) {
826 case 1: /* Computer */
827 switch (minor) {
828 case 1: tag("Desktop"); break;
829 case 2: tag("Server"); break;
830 case 3: tag("Laptop"); break;
831 case 4: tag("Handheld"); break;
832 case 5: tag("Palm Sized"); break;
833 case 6: tag("Wearable"); break;
834 }
835 tag("Computer");
836 break;
837
838 case 2: /* Phone */
839 switch (minor) {
840 case 1: tag("Cellular Phone"); break;
841 case 2: tag("Cordless Phone"); break;
842 case 3: tag("Smart Phone"); break;
843 case 4: tag("Wired Modem/Phone Gateway"); break;
844 case 5: tag("Common ISDN"); break;
845 default:tag("Phone"); break;
846 }
847 break;
848
849 case 3: /* LAN */
850 tag("LAN");
851 switch ((minor & 0x38) >> 3) {
852 case 0: tag("[Fully available]"); break;
853 case 1: tag("[1-17% utilised]"); break;
854 case 2: tag("[17-33% utilised]"); break;
855 case 3: tag("[33-50% utilised]"); break;
856 case 4: tag("[50-67% utilised]"); break;
857 case 5: tag("[67-83% utilised]"); break;
858 case 6: tag("[83-99% utilised]"); break;
859 case 7: tag("[No service available]"); break;
860 }
861 break;
862
863 case 4: /* Audio/Visual */
864 switch (minor) {
865 case 1: tag("Wearable Headset"); break;
866 case 2: tag("Hands-free Audio"); break;
867 case 4: tag("Microphone"); break;
868 case 5: tag("Loudspeaker"); break;
869 case 6: tag("Headphones"); break;
870 case 7: tag("Portable Audio"); break;
871 case 8: tag("Car Audio"); break;
872 case 9: tag("Set-top Box"); break;
873 case 10: tag("HiFi Audio"); break;
874 case 11: tag("VCR"); break;
875 case 12: tag("Video Camera"); break;
876 case 13: tag("Camcorder"); break;
877 case 14: tag("Video Monitor"); break;
878 case 15: tag("Video Display and Loudspeaker"); break;
879 case 16: tag("Video Conferencing"); break;
880 case 18: tag("A/V [Gaming/Toy]"); break;
881 default: tag("Audio/Visual"); break;
882 }
883 break;
884
885 case 5: /* Peripheral */
886 switch (minor & 0x0f) {
887 case 1: tag("Joystick"); break;
888 case 2: tag("Gamepad"); break;
889 case 3: tag("Remote Control"); break;
890 case 4: tag("Sensing Device"); break;
891 case 5: tag("Digitiser Tablet"); break;
892 case 6: tag("Card Reader"); break;
893 default: tag("Peripheral"); break;
894 }
895
896 if (minor & 0x10) tag("Keyboard");
897 if (minor & 0x20) tag("Mouse");
898 break;
899
900 case 6: /* Imaging */
901 if (minor & 0x20) tag("Printer");
902 if (minor & 0x10) tag("Scanner");
903 if (minor & 0x08) tag("Camera");
904 if (minor & 0x04) tag("Display");
905 if ((minor & 0x3c) == 0) tag("Imaging");
906 break;
907
908 case 7: /* Wearable */
909 switch (minor) {
910 case 1: tag("Wrist Watch"); break;
911 case 2: tag("Pager"); break;
912 case 3: tag("Jacket"); break;
913 case 4: tag("Helmet"); break;
914 case 5: tag("Glasses"); break;
915 default: tag("Wearable"); break;
916 }
917 break;
918
919 case 8: /* Toy */
920 switch (minor) {
921 case 1: tag("Robot"); break;
922 case 2: tag("Vehicle"); break;
923 case 3: tag("Doll / Action Figure"); break;
924 case 4: tag("Controller"); break;
925 case 5: tag("Game"); break;
926 default: tag("Toy"); break;
927 }
928 break;
929
930 default:
931 break;
932 }
933
934 if (class & 0x002000) tag("<Limited Discoverable>");
935 if (class & 0x010000) tag("<Positioning>");
936 if (class & 0x020000) tag("<Networking>");
937 if (class & 0x040000) tag("<Rendering>");
938 if (class & 0x080000) tag("<Capturing>");
939 if (class & 0x100000) tag("<Object Transfer>");
940 if (class & 0x200000) tag("<Audio>");
941 if (class & 0x400000) tag("<Telephony>");
942 if (class & 0x800000) tag("<Information>");
943 tag(NULL);
944 }
945
946 void
947 print_voice(int level)
948 {
949 printf("\tvoice: [0x%4.4x]\n", voice);
950
951 if (level == 0)
952 return;
953
954 printf("\t\tInput Coding: ");
955 switch ((voice & 0x0300) >> 8) {
956 case 0x00: printf("Linear PCM [%d-bit, pos %d]",
957 (voice & 0x0020 ? 16 : 8),
958 (voice & 0x001c) >> 2); break;
959 case 0x01: printf("u-Law"); break;
960 case 0x02: printf("A-Law"); break;
961 case 0x03: printf("unknown"); break;
962 }
963
964 switch ((voice & 0x00c0) >> 6) {
965 case 0x00: printf(", 1's complement"); break;
966 case 0x01: printf(", 2's complement"); break;
967 case 0x02: printf(", sign magnitude"); break;
968 case 0x03: printf(", unsigned"); break;
969 }
970
971 printf("\n\t\tAir Coding: ");
972 switch (voice & 0x0003) {
973 case 0x00: printf("CVSD"); break;
974 case 0x01: printf("u-Law"); break;
975 case 0x02: printf("A-Law"); break;
976 case 0x03: printf("Transparent"); break;
977 }
978
979 printf("\n");
980 }
981
982 void
983 print_result(int num, struct result *r, int rssi)
984 {
985 hci_remote_name_req_cp ncp;
986 hci_remote_name_req_compl_ep nep;
987 #if 0
988 hci_read_remote_features_cp fcp;
989 hci_read_remote_features_compl_ep fep;
990 #endif
991 struct hostent *hp;
992
993 printf("%3d: bdaddr %s",
994 num,
995 bt_ntoa(&r->bdaddr, NULL));
996
997 hp = bt_gethostbyaddr((const char *)&r->bdaddr, sizeof(bdaddr_t), AF_BLUETOOTH);
998
999 #if 0
1000 if (hp != NULL)
1001 printf(" (%s)", hp->h_name);
1002 #endif
1003 printf("\n");
1004
1005 memset(&ncp, 0, sizeof(ncp));
1006 bdaddr_copy(&ncp.bdaddr, &r->bdaddr);
1007 ncp.page_scan_rep_mode = r->page_scan_rep_mode;
1008 ncp.clock_offset = r->clock_offset;
1009
1010 hci_req(HCI_CMD_REMOTE_NAME_REQ,
1011 HCI_EVENT_REMOTE_NAME_REQ_COMPL,
1012 &ncp, sizeof(ncp),
1013 &nep, sizeof(nep));
1014
1015 printf(" : name \"%s\"\n", nep.name);
1016
1017 class = (r->uclass[2] << 16) | (r->uclass[1] << 8) | (r->uclass[0]);
1018 print_class(" : ");
1019
1020 #if 0
1021 hci_req(HCI_CMD_READ_REMOTE_FEATURES,
1022 HCI_EVENT_READ_REMOTE_FEATURES_COMPL,
1023 &fcp, sizeof(fcp),
1024 &fep, sizeof(fep));
1025
1026 print_features(" : features", fep.features);
1027 #endif
1028
1029 printf(" : page scan rep mode 0x%02x\n", r->page_scan_rep_mode);
1030 printf(" : clock offset %d\n", le16toh(r->clock_offset));
1031
1032 if (rssi)
1033 printf(" : rssi %d\n", r->rssi);
1034
1035 printf("\n");
1036 }
1037
1038 void
1039 do_inquiry(void)
1040 {
1041 uint8_t buf[HCI_EVENT_PKT_SIZE];
1042 struct result result[INQUIRY_MAX_RESPONSES];
1043 hci_inquiry_cp inq;
1044 struct hci_filter f;
1045 hci_event_hdr_t *hh;
1046 int i, j, num, rssi;
1047
1048 if (opt_inquiry == 0)
1049 return;
1050
1051 printf("Device Discovery from device: %s ...", btr.btr_name);
1052 fflush(stdout);
1053
1054 memset(&f, 0, sizeof(f));
1055 hci_filter_set(HCI_EVENT_COMMAND_STATUS, &f);
1056 hci_filter_set(HCI_EVENT_COMMAND_COMPL, &f);
1057 hci_filter_set(HCI_EVENT_INQUIRY_RESULT, &f);
1058 hci_filter_set(HCI_EVENT_RSSI_RESULT, &f);
1059 hci_filter_set(HCI_EVENT_INQUIRY_COMPL, &f);
1060 hci_filter_set(HCI_EVENT_REMOTE_NAME_REQ_COMPL, &f);
1061 hci_filter_set(HCI_EVENT_READ_REMOTE_FEATURES_COMPL, &f);
1062 if (setsockopt(hci, BTPROTO_HCI, SO_HCI_EVT_FILTER, &f, sizeof(f)) < 0)
1063 err(EXIT_FAILURE, "Can't set event filter");
1064
1065 /* General Inquiry LAP is 0x9e8b33 */
1066 inq.lap[0] = 0x33;
1067 inq.lap[1] = 0x8b;
1068 inq.lap[2] = 0x9e;
1069 inq.inquiry_length = INQUIRY_LENGTH;
1070 inq.num_responses = INQUIRY_MAX_RESPONSES;
1071
1072 hci_cmd(HCI_CMD_INQUIRY, &inq, sizeof(inq));
1073
1074 num = 0;
1075 rssi = 0;
1076 hh = (hci_event_hdr_t *)buf;
1077
1078 for (;;) {
1079 if (recv(hci, buf, sizeof(buf), 0) <= 0)
1080 err(EXIT_FAILURE, "recv");
1081
1082 if (hh->event == HCI_EVENT_INQUIRY_COMPL)
1083 break;
1084
1085 if (hh->event == HCI_EVENT_INQUIRY_RESULT) {
1086 hci_inquiry_result_ep *ep = (hci_inquiry_result_ep *)(hh + 1);
1087 hci_inquiry_response *ir = (hci_inquiry_response *)(ep + 1);
1088
1089 for (i = 0 ; i < ep->num_responses ; i++) {
1090 if (num == INQUIRY_MAX_RESPONSES)
1091 break;
1092
1093 /* some devices keep responding, ignore dupes */
1094 for (j = 0 ; j < num ; j++)
1095 if (bdaddr_same(&result[j].bdaddr, &ir[i].bdaddr))
1096 break;
1097
1098 if (j < num)
1099 continue;
1100
1101 bdaddr_copy(&result[num].bdaddr, &ir[i].bdaddr);
1102 memcpy(&result[num].uclass, &ir[i].uclass, HCI_CLASS_SIZE);
1103 result[num].page_scan_rep_mode = ir[i].page_scan_rep_mode;
1104 result[num].clock_offset = ir[i].clock_offset;
1105 result[num].rssi = 0;
1106 num++;
1107 printf(".");
1108 fflush(stdout);
1109 }
1110 continue;
1111 }
1112 #if 0
1113 if (hh->event == HCI_EVENT_RSSI_RESULT) {
1114 hci_rssi_result_ep *ep = (hci_rssi_result_ep *)(hh + 1);
1115 hci_rssi_response *rr = (hci_rssi_response *)(ep + 1);
1116
1117 for (i = 0 ; i < ep->num_responses ; i++) {
1118 if (num == INQUIRY_MAX_RESPONSES)
1119 break;
1120
1121 /* some devices keep responding, ignore dupes */
1122 for (j = 0 ; j < num ; j++)
1123 if (bdaddr_same(&result[j].bdaddr, &rr[i].bdaddr))
1124 break;
1125
1126 if (j < num)
1127 continue;
1128
1129 bdaddr_copy(&result[num].bdaddr, &rr[i].bdaddr);
1130 memcpy(&result[num].uclass, &rr[i].uclass, HCI_CLASS_SIZE);
1131 result[num].page_scan_rep_mode = rr[i].page_scan_rep_mode;
1132 result[num].clock_offset = rr[i].clock_offset;
1133 result[num].rssi = rr[i].rssi;
1134 rssi = 1;
1135 num++;
1136 printf(".");
1137 fflush(stdout);
1138 }
1139 continue;
1140 }
1141 #endif
1142 }
1143
1144 printf(" %d response%s\n", num, (num == 1 ? "" : "s"));
1145
1146 for (i = 0 ; i < num ; i++)
1147 print_result(i + 1, &result[i], rssi);
1148 }
1149
1150 /*
1151 * Print a value a la the %b format of the kernel's printf borrowed
1152 * from ifconfig(8).
1153 */
1154 void
1155 printb(uint16_t v, const char *bits)
1156 {
1157 int i, any = 0;
1158 char c;
1159
1160 if (bits) {
1161 putchar('<');
1162 while ((i = *bits++) != '\0') {
1163 if (v & (1 << (i-1))) {
1164 if (any)
1165 putchar(',');
1166 any = 1;
1167 for (; (c = *bits) > 32; bits++)
1168 putchar(c);
1169 } else
1170 for (; *bits > 32; bits++)
1171 ;
1172 }
1173 putchar('>');
1174 }
1175 }
1176
DragonFly BSD