1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2000-2002 Maxim Krasnyansky <maxk@qualcomm.com>
6 * Copyright (C) 2003-2007 Marcel Holtmann <marcel@holtmann.org>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 #include <stdio.h>
30 #include <errno.h>
31 #include <ctype.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include <sys/types.h>
37 #include <sys/socket.h>
38 #include <netinet/in.h>
39
40 #include <bluetooth/bluetooth.h>
41 #include <bluetooth/hci.h>
42 #include <bluetooth/hci_lib.h>
43
44 #include "parser.h"
45
46 static uint16_t manufacturer = DEFAULT_COMPID;
47
get_manufacturer(void)48 static inline uint16_t get_manufacturer(void)
49 {
50 return (manufacturer == DEFAULT_COMPID ? parser.defcompid : manufacturer);
51 }
52
53 #define EVENT_NUM 61
54 static char *event_str[EVENT_NUM + 1] = {
55 "Unknown",
56 "Inquiry Complete",
57 "Inquiry Result",
58 "Connect Complete",
59 "Connect Request",
60 "Disconn Complete",
61 "Auth Complete",
62 "Remote Name Req Complete",
63 "Encrypt Change",
64 "Change Connection Link Key Complete",
65 "Master Link Key Complete",
66 "Read Remote Supported Features",
67 "Read Remote Ver Info Complete",
68 "QoS Setup Complete",
69 "Command Complete",
70 "Command Status",
71 "Hardware Error",
72 "Flush Occurred",
73 "Role Change",
74 "Number of Completed Packets",
75 "Mode Change",
76 "Return Link Keys",
77 "PIN Code Request",
78 "Link Key Request",
79 "Link Key Notification",
80 "Loopback Command",
81 "Data Buffer Overflow",
82 "Max Slots Change",
83 "Read Clock Offset Complete",
84 "Connection Packet Type Changed",
85 "QoS Violation",
86 "Page Scan Mode Change",
87 "Page Scan Repetition Mode Change",
88 "Flow Specification Complete",
89 "Inquiry Result with RSSI",
90 "Read Remote Extended Features",
91 "Unknown",
92 "Unknown",
93 "Unknown",
94 "Unknown",
95 "Unknown",
96 "Unknown",
97 "Unknown",
98 "Unknown",
99 "Synchronous Connect Complete",
100 "Synchronous Connect Changed",
101 "Sniff Subrate",
102 "Extended Inquiry Result",
103 "Encryption Key Refresh Complete",
104 "IO Capability Request",
105 "IO Capability Response",
106 "User Confirmation Request",
107 "User Passkey Request",
108 "Remote OOB Data Request",
109 "Simple Pairing Complete",
110 "Unknown",
111 "Link Supervision Timeout Change",
112 "Enhanced Flush Complete",
113 "Unknown",
114 "User Passkey Notification",
115 "Keypress Notification",
116 "Remote Host Supported Features Notification",
117 };
118
119 #define CMD_LINKCTL_NUM 52
120 static char *cmd_linkctl_str[CMD_LINKCTL_NUM + 1] = {
121 "Unknown",
122 "Inquiry",
123 "Inquiry Cancel",
124 "Periodic Inquiry Mode",
125 "Exit Periodic Inquiry Mode",
126 "Create Connection",
127 "Disconnect",
128 "Add SCO Connection",
129 "Create Connection Cancel",
130 "Accept Connection Request",
131 "Reject Connection Request",
132 "Link Key Request Reply",
133 "Link Key Request Negative Reply",
134 "PIN Code Request Reply",
135 "PIN Code Request Negative Reply",
136 "Change Connection Packet Type",
137 "Unknown",
138 "Authentication Requested",
139 "Unknown",
140 "Set Connection Encryption",
141 "Unknown",
142 "Change Connection Link Key",
143 "Unknown",
144 "Master Link Key",
145 "Unknown",
146 "Remote Name Request",
147 "Remote Name Request Cancel",
148 "Read Remote Supported Features",
149 "Read Remote Extended Features",
150 "Read Remote Version Information",
151 "Unknown",
152 "Read Clock Offset",
153 "Read LMP Handle",
154 "Unknown",
155 "Unknown",
156 "Unknown",
157 "Unknown",
158 "Unknown",
159 "Unknown",
160 "Unknown",
161 "Setup Synchronous Connection",
162 "Accept Synchronous Connection",
163 "Reject Synchronous Connection",
164 "IO Capability Request Reply",
165 "User Confirmation Request Reply",
166 "User Confirmation Request Negative Reply",
167 "User Passkey Request Reply",
168 "User Passkey Request Negative Reply",
169 "Remote OOB Data Request Reply",
170 "Unknown",
171 "Unknown",
172 "Remote OOB Data Request Negative Reply",
173 "IO Capability Request Negative Reply",
174 };
175
176 #define CMD_LINKPOL_NUM 17
177 static char *cmd_linkpol_str[CMD_LINKPOL_NUM + 1] = {
178 "Unknown",
179 "Hold Mode",
180 "Unknown",
181 "Sniff Mode",
182 "Exit Sniff Mode",
183 "Park State",
184 "Exit Park State",
185 "QoS Setup",
186 "Unknown",
187 "Role Discovery",
188 "Unknown",
189 "Switch Role",
190 "Read Link Policy Settings",
191 "Write Link Policy Settings",
192 "Read Default Link Policy Settings",
193 "Write Default Link Policy Settings",
194 "Flow Specification",
195 "Sniff Subrating",
196 };
197
198 #define CMD_HOSTCTL_NUM 95
199 static char *cmd_hostctl_str[CMD_HOSTCTL_NUM + 1] = {
200 "Unknown",
201 "Set Event Mask",
202 "Unknown",
203 "Reset",
204 "Unknown",
205 "Set Event Filter",
206 "Unknown",
207 "Unknown",
208 "Flush",
209 "Read PIN Type ",
210 "Write PIN Type",
211 "Create New Unit Key",
212 "Unknown",
213 "Read Stored Link Key",
214 "Unknown",
215 "Unknown",
216 "Unknown",
217 "Write Stored Link Key",
218 "Delete Stored Link Key",
219 "Write Local Name",
220 "Read Local Name",
221 "Read Connection Accept Timeout",
222 "Write Connection Accept Timeout",
223 "Read Page Timeout",
224 "Write Page Timeout",
225 "Read Scan Enable",
226 "Write Scan Enable",
227 "Read Page Scan Activity",
228 "Write Page Scan Activity",
229 "Read Inquiry Scan Activity",
230 "Write Inquiry Scan Activity",
231 "Read Authentication Enable",
232 "Write Authentication Enable",
233 "Read Encryption Mode",
234 "Write Encryption Mode",
235 "Read Class of Device",
236 "Write Class of Device",
237 "Read Voice Setting",
238 "Write Voice Setting",
239 "Read Automatic Flush Timeout",
240 "Write Automatic Flush Timeout",
241 "Read Num Broadcast Retransmissions",
242 "Write Num Broadcast Retransmissions",
243 "Read Hold Mode Activity ",
244 "Write Hold Mode Activity",
245 "Read Transmit Power Level",
246 "Read Synchronous Flow Control Enable",
247 "Write Synchronous Flow Control Enable",
248 "Unknown",
249 "Set Host Controller To Host Flow Control",
250 "Unknown",
251 "Host Buffer Size",
252 "Unknown",
253 "Host Number of Completed Packets",
254 "Read Link Supervision Timeout",
255 "Write Link Supervision Timeout",
256 "Read Number of Supported IAC",
257 "Read Current IAC LAP",
258 "Write Current IAC LAP",
259 "Read Page Scan Period Mode",
260 "Write Page Scan Period Mode",
261 "Read Page Scan Mode",
262 "Write Page Scan Mode",
263 "Set AFH Host Channel Classification",
264 "Unknown",
265 "Unknown",
266 "Read Inquiry Scan Type",
267 "Write Inquiry Scan Type",
268 "Read Inquiry Mode",
269 "Write Inquiry Mode",
270 "Read Page Scan Type",
271 "Write Page Scan Type",
272 "Read AFH Channel Assessment Mode",
273 "Write AFH Channel Assessment Mode",
274 "Unknown",
275 "Unknown",
276 "Unknown",
277 "Unknown",
278 "Unknown",
279 "Unknown",
280 "Unknown",
281 "Read Extended Inquiry Response",
282 "Write Extended Inquiry Response",
283 "Refresh Encryption Key",
284 "Unknown",
285 "Read Simple Pairing Mode",
286 "Write Simple Pairing Mode",
287 "Read Local OOB Data",
288 "Read Inquiry Response Transmit Power Level",
289 "Write Inquiry Response Transmit Power Level",
290 "Read Default Erroneous Data Reporting",
291 "Write Default Erroneous Data Reporting",
292 "Unknown",
293 "Unknown",
294 "Unknown",
295 "Enhanced Flush"
296 "Unknown",
297 };
298
299 #define CMD_INFO_NUM 9
300 static char *cmd_info_str[CMD_INFO_NUM + 1] = {
301 "Unknown",
302 "Read Local Version Information",
303 "Read Local Supported Commands",
304 "Read Local Supported Features",
305 "Read Local Extended Features",
306 "Read Buffer Size",
307 "Unknown",
308 "Read Country Code",
309 "Unknown",
310 "Read BD ADDR",
311 };
312
313 #define CMD_STATUS_NUM 7
314 static char *cmd_status_str[CMD_STATUS_NUM + 1] = {
315 "Unknown",
316 "Read Failed Contact Counter",
317 "Reset Failed Contact Counter",
318 "Read Link Quality",
319 "Unknown",
320 "Read RSSI",
321 "Read AFH Channel Map",
322 "Read Clock",
323 };
324
325 #define CMD_TESTING_NUM 4
326 static char *cmd_testing_str[CMD_TESTING_NUM + 1] = {
327 "Unknown",
328 "Read Loopback Mode",
329 "Write Loopback Mode",
330 "Enable Device Under Test mode",
331 "Unknown",
332 };
333
334 #define ERROR_CODE_NUM 56
335 static char *error_code_str[ERROR_CODE_NUM + 1] = {
336 "Success",
337 "Unknown HCI Command",
338 "Unknown Connection Identifier",
339 "Hardware Failure",
340 "Page Timeout",
341 "Authentication Failure",
342 "PIN or Key Missing",
343 "Memory Capacity Exceeded",
344 "Connection Timeout",
345 "Connection Limit Exceeded",
346 "Synchronous Connection to a Device Exceeded",
347 "ACL Connection Already Exists",
348 "Command Disallowed",
349 "Connection Rejected due to Limited Resources",
350 "Connection Rejected due to Security Reasons",
351 "Connection Rejected due to Unacceptable BD_ADDR",
352 "Connection Accept Timeout Exceeded",
353 "Unsupported Feature or Parameter Value",
354 "Invalid HCI Command Parameters",
355 "Remote User Terminated Connection",
356 "Remote Device Terminated Connection due to Low Resources",
357 "Remote Device Terminated Connection due to Power Off",
358 "Connection Terminated by Local Host",
359 "Repeated Attempts",
360 "Pairing Not Allowed",
361 "Unknown LMP PDU",
362 "Unsupported Remote Feature / Unsupported LMP Feature",
363 "SCO Offset Rejected",
364 "SCO Interval Rejected",
365 "SCO Air Mode Rejected",
366 "Invalid LMP Parameters",
367 "Unspecified Error",
368 "Unsupported LMP Parameter Value",
369 "Role Change Not Allowed",
370 "LMP Response Timeout",
371 "LMP Error Transaction Collision",
372 "LMP PDU Not Allowed",
373 "Encryption Mode Not Acceptable",
374 "Link Key Can Not be Changed",
375 "Requested QoS Not Supported",
376 "Instant Passed",
377 "Pairing with Unit Key Not Supported",
378 "Different Transaction Collision",
379 "Reserved",
380 "QoS Unacceptable Parameter",
381 "QoS Rejected",
382 "Channel Classification Not Supported",
383 "Insufficient Security",
384 "Parameter out of Mandatory Range",
385 "Reserved",
386 "Role Switch Pending",
387 "Reserved",
388 "Reserved Slot Violation",
389 "Role Switch Failed",
390 "Extended Inquiry Response Too Large",
391 "Simple Pairing Not Supported by Host",
392 "Host Busy - Pairing",
393 };
394
status2str(uint8_t status)395 static char *status2str(uint8_t status)
396 {
397 char *str;
398
399 if (status <= ERROR_CODE_NUM)
400 str = error_code_str[status];
401 else
402 str = "Unknown";
403
404 return str;
405 }
406
opcode2str(uint16_t opcode)407 static char *opcode2str(uint16_t opcode)
408 {
409 uint16_t ogf = cmd_opcode_ogf(opcode);
410 uint16_t ocf = cmd_opcode_ocf(opcode);
411 char *cmd;
412
413 switch (ogf) {
414 case OGF_INFO_PARAM:
415 if (ocf <= CMD_INFO_NUM)
416 cmd = cmd_info_str[ocf];
417 else
418 cmd = "Unknown";
419 break;
420
421 case OGF_HOST_CTL:
422 if (ocf <= CMD_HOSTCTL_NUM)
423 cmd = cmd_hostctl_str[ocf];
424 else
425 cmd = "Unknown";
426 break;
427
428 case OGF_LINK_CTL:
429 if (ocf <= CMD_LINKCTL_NUM)
430 cmd = cmd_linkctl_str[ocf];
431 else
432 cmd = "Unknown";
433 break;
434
435 case OGF_LINK_POLICY:
436 if (ocf <= CMD_LINKPOL_NUM)
437 cmd = cmd_linkpol_str[ocf];
438 else
439 cmd = "Unknown";
440 break;
441
442 case OGF_STATUS_PARAM:
443 if (ocf <= CMD_STATUS_NUM)
444 cmd = cmd_status_str[ocf];
445 else
446 cmd = "Unknown";
447 break;
448
449 case OGF_TESTING_CMD:
450 if (ocf <= CMD_TESTING_NUM)
451 cmd = cmd_testing_str[ocf];
452 else
453 cmd = "Unknown";
454 break;
455
456 case OGF_VENDOR_CMD:
457 cmd = "Vendor";
458 break;
459
460 default:
461 cmd = "Unknown";
462 break;
463 }
464
465 return cmd;
466 }
467
linktype2str(uint8_t type)468 static char *linktype2str(uint8_t type)
469 {
470 switch (type) {
471 case 0x00:
472 return "SCO";
473 case 0x01:
474 return "ACL";
475 case 0x02:
476 return "eSCO";
477 default:
478 return "Unknown";
479 }
480 }
481
role2str(uint8_t role)482 static char *role2str(uint8_t role)
483 {
484 switch (role) {
485 case 0x00:
486 return "Master";
487 case 0x01:
488 return "Slave";
489 default:
490 return "Unknown";
491 }
492 }
493
mode2str(uint8_t mode)494 static char *mode2str(uint8_t mode)
495 {
496 switch (mode) {
497 case 0x00:
498 return "Active";
499 case 0x01:
500 return "Hold";
501 case 0x02:
502 return "Sniff";
503 case 0x03:
504 return "Park";
505 default:
506 return "Unknown";
507 }
508 }
509
airmode2str(uint8_t mode)510 static char *airmode2str(uint8_t mode)
511 {
512 switch (mode) {
513 case 0x00:
514 return "u-law log";
515 case 0x01:
516 return "A-law log";
517 case 0x02:
518 return "CVSD";
519 case 0x04:
520 return "Transparent data";
521 default:
522 return "Reserved";
523 }
524 }
525
keytype2str(uint8_t type)526 static char *keytype2str(uint8_t type)
527 {
528 switch (type) {
529 case 0x00:
530 return "Combination Key";
531 case 0x01:
532 return "Local Unit Key";
533 case 0x02:
534 return "Remote Unit Key";
535 case 0x03:
536 return "Debug Combination Key";
537 case 0x04:
538 return "Unauthenticated Combination Key";
539 case 0x05:
540 return "Authenticated Combination Key";
541 case 0x06:
542 return "Changed Combination Key";
543 default:
544 return "Reserved";
545 }
546 }
547
capability2str(uint8_t capability)548 static char *capability2str(uint8_t capability)
549 {
550 switch (capability) {
551 case 0x00:
552 return "DisplayOnly";
553 case 0x01:
554 return "DisplayYesNo";
555 case 0x02:
556 return "KeyboardOnly";
557 case 0x03:
558 return "NoInputNoOutput";
559 default:
560 return "Reserved";
561 }
562 }
563
authentication2str(uint8_t authentication)564 static char *authentication2str(uint8_t authentication)
565 {
566 switch (authentication) {
567 case 0x00:
568 return "No Bonding (No MITM Protection)";
569 case 0x01:
570 return "No Bonding (MITM Protection)";
571 case 0x02:
572 return "Dedicated Bonding (No MITM Protection)";
573 case 0x03:
574 return "Dedicated Bonding (MITM Protection)";
575 case 0x04:
576 return "General Bonding (No MITM Protection)";
577 case 0x05:
578 return "General Bonding (MITM Protection)";
579 default:
580 return "Reserved";
581 }
582 }
583
ext_inquiry_response_dump(int level,struct frame * frm)584 static inline void ext_inquiry_response_dump(int level, struct frame *frm)
585 {
586 void *ptr = frm->ptr;
587 uint32_t len = frm->len;
588 uint8_t type, length;
589 char *str;
590 int i;
591
592 length = get_u8(frm);
593
594 while (length > 0) {
595 type = get_u8(frm);
596 length--;
597
598 switch (type) {
599 case 0x01:
600 p_indent(level, frm);
601 printf("Flags:");
602 for (i = 0; i < length; i++)
603 printf(" 0x%2.2x", *((uint8_t *) (frm->ptr + i)));
604 printf("\n");
605 break;
606
607 case 0x02:
608 case 0x03:
609 p_indent(level, frm);
610 printf("%s service classes:",
611 type == 0x02 ? "Shortened" : "Complete");
612 for (i = 0; i < length / 2; i++) {
613 uint16_t val = btohs(bt_get_unaligned((uint16_t *) (frm->ptr + (i * 2))));
614 printf(" 0x%4.4x", val);
615 }
616 printf("\n");
617 break;
618
619 case 0x08:
620 case 0x09:
621 str = malloc(length + 1);
622 if (str) {
623 snprintf(str, length + 1, "%s", (char *) frm->ptr);
624 for (i = 0; i < length; i++)
625 if (!isprint(str[i]))
626 str[i] = '.';
627 p_indent(level, frm);
628 printf("%s local name: \'%s\'\n",
629 type == 0x08 ? "Shortened" : "Complete", str);
630 free(str);
631 }
632 break;
633
634 case 0x0a:
635 p_indent(level, frm);
636 printf("TX power level: %d\n", *((uint8_t *) frm->ptr));
637 break;
638
639 default:
640 p_indent(level, frm);
641 printf("Unknown type 0x%02x with %d bytes data\n",
642 type, length);
643 break;
644 }
645
646 frm->ptr += length;
647 frm->len -= length;
648
649 length = get_u8(frm);
650 }
651
652 frm->ptr = ptr + (EXTENDED_INQUIRY_INFO_SIZE - INQUIRY_INFO_WITH_RSSI_SIZE);
653 frm->len = len + (EXTENDED_INQUIRY_INFO_SIZE - INQUIRY_INFO_WITH_RSSI_SIZE);
654 }
655
bdaddr_command_dump(int level,struct frame * frm)656 static inline void bdaddr_command_dump(int level, struct frame *frm)
657 {
658 bdaddr_t *bdaddr = frm->ptr;
659 char addr[18];
660
661 frm->ptr += sizeof(bdaddr_t);
662 frm->len -= sizeof(bdaddr_t);
663
664 p_indent(level, frm);
665 p_ba2str(bdaddr, addr);
666 printf("bdaddr %s\n", addr);
667
668 raw_dump(level, frm);
669 }
670
generic_command_dump(int level,struct frame * frm)671 static inline void generic_command_dump(int level, struct frame *frm)
672 {
673 uint16_t handle = btohs(htons(get_u16(frm)));
674
675 p_indent(level, frm);
676 printf("handle %d\n", handle);
677
678 raw_dump(level, frm);
679 }
680
generic_write_mode_dump(int level,struct frame * frm)681 static inline void generic_write_mode_dump(int level, struct frame *frm)
682 {
683 uint8_t mode = get_u8(frm);
684
685 p_indent(level, frm);
686 printf("mode 0x%2.2x\n", mode);
687 }
688
inquiry_dump(int level,struct frame * frm)689 static inline void inquiry_dump(int level, struct frame *frm)
690 {
691 inquiry_cp *cp = frm->ptr;
692
693 p_indent(level, frm);
694 printf("lap 0x%2.2x%2.2x%2.2x len %d num %d\n",
695 cp->lap[2], cp->lap[1], cp->lap[0], cp->length, cp->num_rsp);
696 }
697
periodic_inquiry_dump(int level,struct frame * frm)698 static inline void periodic_inquiry_dump(int level, struct frame *frm)
699 {
700 periodic_inquiry_cp *cp = frm->ptr;
701
702 p_indent(level, frm);
703 printf("max %d min %d lap 0x%2.2x%2.2x%2.2x len %d num %d\n",
704 btohs(cp->max_period), btohs(cp->min_period),
705 cp->lap[2], cp->lap[1], cp->lap[0], cp->length, cp->num_rsp);
706 }
707
create_conn_dump(int level,struct frame * frm)708 static inline void create_conn_dump(int level, struct frame *frm)
709 {
710 create_conn_cp *cp = frm->ptr;
711 uint16_t ptype = btohs(cp->pkt_type);
712 uint16_t clkoffset = btohs(cp->clock_offset);
713 char addr[18], *str;
714
715 p_indent(level, frm);
716 p_ba2str(&cp->bdaddr, addr);
717 printf("bdaddr %s ptype 0x%4.4x rswitch 0x%2.2x clkoffset 0x%4.4x%s\n",
718 addr, ptype, cp->role_switch,
719 clkoffset & 0x7fff, clkoffset & 0x8000 ? " (valid)" : "");
720
721 str = hci_ptypetostr(ptype);
722 if (str) {
723 p_indent(level, frm);
724 printf("Packet type: %s\n", str);
725 free(str);
726 }
727 }
728
disconnect_dump(int level,struct frame * frm)729 static inline void disconnect_dump(int level, struct frame *frm)
730 {
731 disconnect_cp *cp = frm->ptr;
732
733 p_indent(level, frm);
734 printf("handle %d reason 0x%2.2x\n", btohs(cp->handle), cp->reason);
735
736 p_indent(level, frm);
737 printf("Reason: %s\n", status2str(cp->reason));
738 }
739
add_sco_dump(int level,struct frame * frm)740 static inline void add_sco_dump(int level, struct frame *frm)
741 {
742 add_sco_cp *cp = frm->ptr;
743 uint16_t ptype = btohs(cp->pkt_type);
744 char *str;
745
746 p_indent(level, frm);
747 printf("handle %d ptype 0x%4.4x\n", btohs(cp->handle), ptype);
748
749 str = hci_ptypetostr(ptype);
750 if (str) {
751 p_indent(level, frm);
752 printf("Packet type: %s\n", str);
753 free(str);
754 }
755 }
756
accept_conn_req_dump(int level,struct frame * frm)757 static inline void accept_conn_req_dump(int level, struct frame *frm)
758 {
759 accept_conn_req_cp *cp = frm->ptr;
760 char addr[18];
761
762 p_indent(level, frm);
763 p_ba2str(&cp->bdaddr, addr);
764 printf("bdaddr %s role 0x%2.2x\n", addr, cp->role);
765
766 p_indent(level, frm);
767 printf("Role: %s\n", role2str(cp->role));
768 }
769
reject_conn_req_dump(int level,struct frame * frm)770 static inline void reject_conn_req_dump(int level, struct frame *frm)
771 {
772 reject_conn_req_cp *cp = frm->ptr;
773 char addr[18];
774
775 p_indent(level, frm);
776 p_ba2str(&cp->bdaddr, addr);
777 printf("bdaddr %s reason 0x%2.2x\n", addr, cp->reason);
778
779 p_indent(level, frm);
780 printf("Reason: %s\n", status2str(cp->reason));
781 }
782
pin_code_reply_dump(int level,struct frame * frm)783 static inline void pin_code_reply_dump(int level, struct frame *frm)
784 {
785 pin_code_reply_cp *cp = frm->ptr;
786 char addr[18], pin[17];
787
788 p_indent(level, frm);
789 p_ba2str(&cp->bdaddr, addr);
790 memset(pin, 0, sizeof(pin));
791 if (parser.flags & DUMP_NOVENDOR)
792 memset(pin, '*', cp->pin_len);
793 else
794 memcpy(pin, cp->pin_code, cp->pin_len);
795 printf("bdaddr %s len %d pin \'%s\'\n", addr, cp->pin_len, pin);
796 }
797
link_key_reply_dump(int level,struct frame * frm)798 static inline void link_key_reply_dump(int level, struct frame *frm)
799 {
800 link_key_reply_cp *cp = frm->ptr;
801 char addr[18];
802 int i;
803
804 p_indent(level, frm);
805 p_ba2str(&cp->bdaddr, addr);
806 printf("bdaddr %s key ", addr);
807 for (i = 0; i < 16; i++)
808 if (parser.flags & DUMP_NOVENDOR)
809 printf("**");
810 else
811 printf("%2.2X", cp->link_key[i]);
812 printf("\n");
813 }
814
pin_code_neg_reply_dump(int level,struct frame * frm)815 static inline void pin_code_neg_reply_dump(int level, struct frame *frm)
816 {
817 bdaddr_t *bdaddr = frm->ptr;
818 char addr[18];
819
820 p_indent(level, frm);
821 p_ba2str(bdaddr, addr);
822 printf("bdaddr %s\n", addr);
823 }
824
user_passkey_reply_dump(int level,struct frame * frm)825 static inline void user_passkey_reply_dump(int level, struct frame *frm)
826 {
827 user_passkey_reply_cp *cp = frm->ptr;
828 char addr[18];
829
830 p_indent(level, frm);
831 p_ba2str(&cp->bdaddr, addr);
832 printf("bdaddr %s passkey %d\n", addr, btohl(cp->passkey));
833 }
834
remote_oob_data_reply_dump(int level,struct frame * frm)835 static inline void remote_oob_data_reply_dump(int level, struct frame *frm)
836 {
837 remote_oob_data_reply_cp *cp = frm->ptr;
838 char addr[18];
839 int i;
840
841 p_indent(level, frm);
842 p_ba2str(&cp->bdaddr, addr);
843 printf("bdaddr %s\n", addr);
844
845 p_indent(level, frm);
846 printf("hash 0x");
847 for (i = 0; i < 16; i++)
848 printf("%02x", cp->hash[i]);
849 printf("\n");
850
851 p_indent(level, frm);
852 printf("randomizer 0x");
853 for (i = 0; i < 16; i++)
854 printf("%02x", cp->randomizer[i]);
855 printf("\n");
856 }
857
io_capability_reply_dump(int level,struct frame * frm)858 static inline void io_capability_reply_dump(int level, struct frame *frm)
859 {
860 io_capability_reply_cp *cp = frm->ptr;
861 char addr[18];
862
863 p_indent(level, frm);
864 p_ba2str(&cp->bdaddr, addr);
865 printf("bdaddr %s capability 0x%2.2x oob 0x%2.2x auth 0x%2.2x\n",
866 addr, cp->capability, cp->oob_data,
867 cp->authentication);
868
869 p_indent(level, frm);
870 printf("Capability: %s (OOB data %s)\n",
871 capability2str(cp->capability),
872 cp->oob_data == 0x00 ? "not present" : "available");
873
874 p_indent(level, frm);
875 printf("Authentication: %s\n", authentication2str(cp->authentication));
876 }
877
set_conn_encrypt_dump(int level,struct frame * frm)878 static inline void set_conn_encrypt_dump(int level, struct frame *frm)
879 {
880 set_conn_encrypt_cp *cp = frm->ptr;
881
882 p_indent(level, frm);
883 printf("handle %d encrypt 0x%2.2x\n", btohs(cp->handle), cp->encrypt);
884 }
885
remote_name_req_dump(int level,struct frame * frm)886 static inline void remote_name_req_dump(int level, struct frame *frm)
887 {
888 remote_name_req_cp *cp = frm->ptr;
889 uint16_t clkoffset = btohs(cp->clock_offset);
890 char addr[18];
891
892 p_indent(level, frm);
893 p_ba2str(&cp->bdaddr, addr);
894 printf("bdaddr %s mode %d clkoffset 0x%4.4x%s\n",
895 addr, cp->pscan_rep_mode,
896 clkoffset & 0x7fff, clkoffset & 0x8000 ? " (valid)" : "");
897 }
898
master_link_key_dump(int level,struct frame * frm)899 static inline void master_link_key_dump(int level, struct frame *frm)
900 {
901 master_link_key_cp *cp = frm->ptr;
902
903 p_indent(level, frm);
904 printf("flag %d\n", cp->key_flag);
905 }
906
read_remote_ext_features_dump(int level,struct frame * frm)907 static inline void read_remote_ext_features_dump(int level, struct frame *frm)
908 {
909 read_remote_ext_features_cp *cp = frm->ptr;
910
911 p_indent(level, frm);
912 printf("handle %d page %d\n", btohs(cp->handle), cp->page_num);
913 }
914
setup_sync_conn_dump(int level,struct frame * frm)915 static inline void setup_sync_conn_dump(int level, struct frame *frm)
916 {
917 setup_sync_conn_cp *cp = frm->ptr;
918
919 p_indent(level, frm);
920 printf("handle %d voice setting 0x%4.4x\n", btohs(cp->handle),
921 btohs(cp->voice_setting));
922 }
923
hold_mode_dump(int level,struct frame * frm)924 static inline void hold_mode_dump(int level, struct frame *frm)
925 {
926 hold_mode_cp *cp = frm->ptr;
927
928 p_indent(level, frm);
929 printf("handle %d max %d min %d\n", btohs(cp->handle),
930 btohs(cp->max_interval), btohs(cp->min_interval));
931 }
932
sniff_mode_dump(int level,struct frame * frm)933 static inline void sniff_mode_dump(int level, struct frame *frm)
934 {
935 sniff_mode_cp *cp = frm->ptr;
936
937 p_indent(level, frm);
938 printf("handle %d max %d min %d attempt %d timeout %d\n",
939 btohs(cp->handle), btohs(cp->max_interval),
940 btohs(cp->min_interval), btohs(cp->attempt), btohs(cp->timeout));
941 }
942
qos_setup_dump(int level,struct frame * frm)943 static inline void qos_setup_dump(int level, struct frame *frm)
944 {
945 qos_setup_cp *cp = frm->ptr;
946
947 p_indent(level, frm);
948 printf("handle %d flags 0x%2.2x\n", btohs(cp->handle), cp->flags);
949
950 p_indent(level, frm);
951 printf("Service type: %d\n", cp->qos.service_type);
952 p_indent(level, frm);
953 printf("Token rate: %d\n", btohl(cp->qos.token_rate));
954 p_indent(level, frm);
955 printf("Peak bandwith: %d\n", btohl(cp->qos.peak_bandwidth));
956 p_indent(level, frm);
957 printf("Latency: %d\n", btohl(cp->qos.latency));
958 p_indent(level, frm);
959 printf("Delay variation: %d\n", btohl(cp->qos.delay_variation));
960 }
961
write_link_policy_dump(int level,struct frame * frm)962 static inline void write_link_policy_dump(int level, struct frame *frm)
963 {
964 write_link_policy_cp *cp = frm->ptr;
965 uint16_t policy = btohs(cp->policy);
966 char *str;
967
968 p_indent(level, frm);
969 printf("handle %d policy 0x%2.2x\n", btohs(cp->handle), policy);
970
971 str = hci_lptostr(policy);
972 if (str) {
973 p_indent(level, frm);
974 printf("Link policy: %s\n", str);
975 free(str);
976 }
977 }
978
write_default_link_policy_dump(int level,struct frame * frm)979 static inline void write_default_link_policy_dump(int level, struct frame *frm)
980 {
981 uint16_t policy = btohs(htons(get_u16(frm)));
982 char *str;
983
984 p_indent(level, frm);
985 printf("policy 0x%2.2x\n", policy);
986
987 str = hci_lptostr(policy);
988 if (str) {
989 p_indent(level, frm);
990 printf("Link policy: %s\n", str);
991 free(str);
992 }
993 }
994
sniff_subrating_dump(int level,struct frame * frm)995 static inline void sniff_subrating_dump(int level, struct frame *frm)
996 {
997 sniff_subrating_cp *cp = frm->ptr;
998
999 p_indent(level, frm);
1000 printf("handle %d\n", btohs(cp->handle));
1001
1002 p_indent(level, frm);
1003 printf("max latency %d\n", btohs(cp->max_latency));
1004
1005 p_indent(level, frm);
1006 printf("min timeout remote %d local %d\n",
1007 btohs(cp->min_remote_timeout), btohs(cp->min_local_timeout));
1008 }
1009
set_event_mask_dump(int level,struct frame * frm)1010 static inline void set_event_mask_dump(int level, struct frame *frm)
1011 {
1012 set_event_mask_cp *cp = frm->ptr;
1013 int i;
1014
1015 p_indent(level, frm);
1016 printf("Mask: 0x");
1017 for (i = 0; i < 8; i++)
1018 printf("%2.2x", cp->mask[i]);
1019 printf("\n");
1020 }
1021
set_event_flt_dump(int level,struct frame * frm)1022 static inline void set_event_flt_dump(int level, struct frame *frm)
1023 {
1024 set_event_flt_cp *cp = frm->ptr;
1025 uint8_t dev_class[3], dev_mask[3];
1026 char addr[18];
1027
1028 p_indent(level, frm);
1029 printf("type %d condition %d\n", cp->flt_type,
1030 (cp->flt_type == 0) ? 0 : cp->cond_type);
1031
1032 switch (cp->flt_type) {
1033 case FLT_CLEAR_ALL:
1034 p_indent(level, frm);
1035 printf("Clear all filters\n");
1036 break;
1037 case FLT_INQ_RESULT:
1038 p_indent(level, frm);
1039 printf("Inquiry result");
1040 switch (cp->cond_type) {
1041 case INQ_RESULT_RETURN_ALL:
1042 printf(" for all devices\n");
1043 break;
1044 case INQ_RESULT_RETURN_CLASS:
1045 memcpy(dev_class, cp->condition, 3);
1046 memcpy(dev_mask, cp->condition + 3, 3);
1047 printf(" with class 0x%2.2x%2.2x%2.2x mask 0x%2.2x%2.2x%2.2x\n",
1048 dev_class[2], dev_class[1], dev_class[0],
1049 dev_mask[2], dev_mask[1], dev_mask[0]);
1050 break;
1051 case INQ_RESULT_RETURN_BDADDR:
1052 p_ba2str((bdaddr_t *) cp->condition, addr);
1053 printf(" with bdaddr %s\n", addr);
1054 break;
1055 default:
1056 printf("\n");
1057 break;
1058 }
1059 break;
1060 case FLT_CONN_SETUP:
1061 p_indent(level, frm);
1062 printf("Connection setup");
1063 switch (cp->cond_type) {
1064 case CONN_SETUP_ALLOW_ALL:
1065 case CONN_SETUP_ALLOW_CLASS:
1066 case CONN_SETUP_ALLOW_BDADDR:
1067 default:
1068 printf("\n");
1069 break;
1070 }
1071 break;
1072 }
1073 }
1074
write_pin_type_dump(int level,struct frame * frm)1075 static inline void write_pin_type_dump(int level, struct frame *frm)
1076 {
1077 write_pin_type_cp *cp = frm->ptr;
1078
1079 p_indent(level, frm);
1080 printf("type %d\n", cp->pin_type);
1081 }
1082
request_stored_link_key_dump(int level,struct frame * frm)1083 static inline void request_stored_link_key_dump(int level, struct frame *frm)
1084 {
1085 read_stored_link_key_cp *cp = frm->ptr;
1086 char addr[18];
1087
1088 p_indent(level, frm);
1089 p_ba2str(&cp->bdaddr, addr);
1090 printf("bdaddr %s all %d\n", addr, cp->read_all);
1091 }
1092
return_link_keys_dump(int level,struct frame * frm)1093 static inline void return_link_keys_dump(int level, struct frame *frm)
1094 {
1095 uint8_t num = get_u8(frm);
1096 uint8_t key[16];
1097 char addr[18];
1098 int i, n;
1099
1100 for (n = 0; n < num; n++) {
1101 p_ba2str(frm->ptr, addr);
1102 memcpy(key, frm->ptr + 6, 16);
1103
1104 p_indent(level, frm);
1105 printf("bdaddr %s key ", addr);
1106 for (i = 0; i < 16; i++)
1107 if (parser.flags & DUMP_NOVENDOR)
1108 printf("**");
1109 else
1110 printf("%2.2X", key[i]);
1111 printf("\n");
1112
1113 frm->ptr += 2;
1114 frm->len -= 2;
1115 }
1116 }
1117
change_local_name_dump(int level,struct frame * frm)1118 static inline void change_local_name_dump(int level, struct frame *frm)
1119 {
1120 change_local_name_cp *cp = frm->ptr;
1121 char name[249];
1122 int i;
1123
1124 memset(name, 0, sizeof(name));
1125 for (i = 0; i < 248 && cp->name[i]; i++)
1126 if (isprint(cp->name[i]))
1127 name[i] = cp->name[i];
1128 else
1129 name[i] = '.';
1130
1131 p_indent(level, frm);
1132 printf("name \'%s\'\n", name);
1133 }
1134
write_class_of_dev_dump(int level,struct frame * frm)1135 static inline void write_class_of_dev_dump(int level, struct frame *frm)
1136 {
1137 write_class_of_dev_cp *cp = frm->ptr;
1138
1139 p_indent(level, frm);
1140 printf("class 0x%2.2x%2.2x%2.2x\n",
1141 cp->dev_class[2], cp->dev_class[1], cp->dev_class[0]);
1142 }
1143
write_voice_setting_dump(int level,struct frame * frm)1144 static inline void write_voice_setting_dump(int level, struct frame *frm)
1145 {
1146 write_voice_setting_cp *cp = frm->ptr;
1147
1148 p_indent(level, frm);
1149 printf("voice setting 0x%4.4x\n", btohs(cp->voice_setting));
1150 }
1151
write_current_iac_lap_dump(int level,struct frame * frm)1152 static inline void write_current_iac_lap_dump(int level, struct frame *frm)
1153 {
1154 write_current_iac_lap_cp *cp = frm->ptr;
1155 int i;
1156
1157 for (i = 0; i < cp->num_current_iac; i++) {
1158 p_indent(level, frm);
1159 printf("IAC 0x%2.2x%2.2x%2.2x", cp->lap[i][2], cp->lap[i][1], cp->lap[i][0]);
1160 if (cp->lap[i][2] == 0x9e && cp->lap[i][1] == 0x8b) {
1161 switch (cp->lap[i][0]) {
1162 case 0x00:
1163 printf(" (Limited Inquiry Access Code)");
1164 break;
1165 case 0x33:
1166 printf(" (General Inquiry Access Code)");
1167 break;
1168 }
1169 }
1170 printf("\n");
1171 }
1172 }
1173
write_scan_enable_dump(int level,struct frame * frm)1174 static inline void write_scan_enable_dump(int level, struct frame *frm)
1175 {
1176 uint8_t enable = get_u8(frm);
1177
1178 p_indent(level, frm);
1179 printf("enable %d\n", enable);
1180 }
1181
write_page_timeout_dump(int level,struct frame * frm)1182 static inline void write_page_timeout_dump(int level, struct frame *frm)
1183 {
1184 write_page_timeout_cp *cp = frm->ptr;
1185
1186 p_indent(level, frm);
1187 printf("timeout %d\n", btohs(cp->timeout));
1188 }
1189
write_page_activity_dump(int level,struct frame * frm)1190 static inline void write_page_activity_dump(int level, struct frame *frm)
1191 {
1192 write_page_activity_cp *cp = frm->ptr;
1193
1194 p_indent(level, frm);
1195 printf("interval %d window %d\n", btohs(cp->interval), btohs(cp->window));
1196 }
1197
write_inquiry_scan_type_dump(int level,struct frame * frm)1198 static inline void write_inquiry_scan_type_dump(int level, struct frame *frm)
1199 {
1200 write_inquiry_scan_type_cp *cp = frm->ptr;
1201
1202 p_indent(level, frm);
1203 printf("type %d\n", cp->type);
1204 }
1205
write_inquiry_mode_dump(int level,struct frame * frm)1206 static inline void write_inquiry_mode_dump(int level, struct frame *frm)
1207 {
1208 write_inquiry_mode_cp *cp = frm->ptr;
1209
1210 p_indent(level, frm);
1211 printf("mode %d\n", cp->mode);
1212 }
1213
set_afh_classification_dump(int level,struct frame * frm)1214 static inline void set_afh_classification_dump(int level, struct frame *frm)
1215 {
1216 set_afh_classification_cp *cp = frm->ptr;
1217 int i;
1218
1219 p_indent(level, frm);
1220 printf("map 0x");
1221 for (i = 0; i < 10; i++)
1222 printf("%02x", cp->map[i]);
1223 printf("\n");
1224 }
1225
write_link_supervision_timeout_dump(int level,struct frame * frm)1226 static inline void write_link_supervision_timeout_dump(int level, struct frame *frm)
1227 {
1228 write_link_supervision_timeout_cp *cp = frm->ptr;
1229
1230 p_indent(level, frm);
1231 printf("handle %d timeout %d\n",
1232 btohs(cp->handle), btohs(cp->timeout));
1233 }
1234
write_ext_inquiry_response_dump(int level,struct frame * frm)1235 static inline void write_ext_inquiry_response_dump(int level, struct frame *frm)
1236 {
1237 write_ext_inquiry_response_cp *cp = frm->ptr;
1238
1239 p_indent(level, frm);
1240 printf("fec 0x%2.2x\n", cp->fec);
1241
1242 frm->ptr++;
1243 frm->len--;
1244
1245 ext_inquiry_response_dump(level, frm);
1246 }
1247
write_inquiry_transmit_power_level_dump(int level,struct frame * frm)1248 static inline void write_inquiry_transmit_power_level_dump(int level, struct frame *frm)
1249 {
1250 write_inquiry_transmit_power_level_cp *cp = frm->ptr;
1251
1252 p_indent(level, frm);
1253 printf("level %d\n", cp->level);
1254 }
1255
write_default_error_data_reporting_dump(int level,struct frame * frm)1256 static inline void write_default_error_data_reporting_dump(int level, struct frame *frm)
1257 {
1258 write_default_error_data_reporting_cp *cp = frm->ptr;
1259
1260 p_indent(level, frm);
1261 printf("reporting %d\n", cp->reporting);
1262 }
1263
enhanced_flush_dump(int level,struct frame * frm)1264 static inline void enhanced_flush_dump(int level, struct frame *frm)
1265 {
1266 enhanced_flush_cp *cp = frm->ptr;
1267
1268 p_indent(level, frm);
1269 printf("handle %d type %d\n", btohs(cp->handle), cp->type);
1270 }
1271
send_keypress_notify_dump(int level,struct frame * frm)1272 static inline void send_keypress_notify_dump(int level, struct frame *frm)
1273 {
1274 send_keypress_notify_cp *cp = frm->ptr;
1275 char addr[18];
1276
1277 p_indent(level, frm);
1278 p_ba2str(&cp->bdaddr, addr);
1279 printf("bdaddr %s type %d\n", addr, cp->type);
1280 }
1281
request_transmit_power_level_dump(int level,struct frame * frm)1282 static inline void request_transmit_power_level_dump(int level, struct frame *frm)
1283 {
1284 read_transmit_power_level_cp *cp = frm->ptr;
1285
1286 p_indent(level, frm);
1287 printf("handle %d type %d (%s)\n",
1288 btohs(cp->handle), cp->type,
1289 cp->type ? "maximum" : "current");
1290 }
1291
request_local_ext_features_dump(int level,struct frame * frm)1292 static inline void request_local_ext_features_dump(int level, struct frame *frm)
1293 {
1294 read_local_ext_features_cp *cp = frm->ptr;
1295
1296 p_indent(level, frm);
1297 printf("page %d\n", cp->page_num);
1298 }
1299
request_clock_dump(int level,struct frame * frm)1300 static inline void request_clock_dump(int level, struct frame *frm)
1301 {
1302 read_clock_cp *cp = frm->ptr;
1303
1304 p_indent(level, frm);
1305 printf("handle %d which %d (%s)\n",
1306 btohs(cp->handle), cp->which_clock,
1307 cp->which_clock ? "piconet" : "local");
1308 }
1309
host_buffer_size_dump(int level,struct frame * frm)1310 static inline void host_buffer_size_dump(int level, struct frame *frm)
1311 {
1312 host_buffer_size_cp *cp = frm->ptr;
1313
1314 p_indent(level, frm);
1315 printf("ACL MTU %d:%d SCO MTU %d:%d\n",
1316 btohs(cp->acl_mtu), btohs(cp->acl_max_pkt),
1317 cp->sco_mtu, btohs(cp->sco_max_pkt));
1318 }
1319
num_comp_pkts_dump(int level,struct frame * frm)1320 static inline void num_comp_pkts_dump(int level, struct frame *frm)
1321 {
1322 uint8_t num = get_u8(frm);
1323 uint16_t handle, packets;
1324 int i;
1325
1326 for (i = 0; i < num; i++) {
1327 handle = btohs(htons(get_u16(frm)));
1328 packets = btohs(htons(get_u16(frm)));
1329
1330 p_indent(level, frm);
1331 printf("handle %d packets %d\n", handle, packets);
1332 }
1333 }
1334
command_dump(int level,struct frame * frm)1335 static inline void command_dump(int level, struct frame *frm)
1336 {
1337 hci_command_hdr *hdr = frm->ptr;
1338 uint16_t opcode = btohs(hdr->opcode);
1339 uint16_t ogf = cmd_opcode_ogf(opcode);
1340 uint16_t ocf = cmd_opcode_ocf(opcode);
1341
1342 if (p_filter(FILT_HCI))
1343 return;
1344
1345 if (ogf == OGF_VENDOR_CMD && (parser.flags & DUMP_NOVENDOR))
1346 return;
1347
1348 p_indent(level, frm);
1349 printf("HCI Command: %s (0x%2.2x|0x%4.4x) plen %d\n",
1350 opcode2str(opcode), ogf, ocf, hdr->plen);
1351
1352 frm->ptr += HCI_COMMAND_HDR_SIZE;
1353 frm->len -= HCI_COMMAND_HDR_SIZE;
1354
1355 if (ogf == OGF_VENDOR_CMD) {
1356 if (ocf == 0 && get_manufacturer() == 10) {
1357 csr_dump(level + 1, frm);
1358 return;
1359 }
1360 }
1361
1362 if (!(parser.flags & DUMP_VERBOSE)) {
1363 raw_dump(level, frm);
1364 return;
1365 }
1366
1367 switch (ogf) {
1368 case OGF_LINK_CTL:
1369 switch (ocf) {
1370 case OCF_INQUIRY:
1371 inquiry_dump(level + 1, frm);
1372 return;
1373 case OCF_PERIODIC_INQUIRY:
1374 periodic_inquiry_dump(level + 1, frm);
1375 return;
1376 case OCF_INQUIRY_CANCEL:
1377 case OCF_EXIT_PERIODIC_INQUIRY:
1378 return;
1379 case OCF_CREATE_CONN:
1380 create_conn_dump(level + 1, frm);
1381 return;
1382 case OCF_DISCONNECT:
1383 disconnect_dump(level + 1, frm);
1384 return;
1385 case OCF_CREATE_CONN_CANCEL:
1386 case OCF_REMOTE_NAME_REQ_CANCEL:
1387 case OCF_ACCEPT_SYNC_CONN_REQ:
1388 bdaddr_command_dump(level + 1, frm);
1389 return;
1390 case OCF_ADD_SCO:
1391 case OCF_SET_CONN_PTYPE:
1392 add_sco_dump(level + 1, frm);
1393 return;
1394 case OCF_ACCEPT_CONN_REQ:
1395 accept_conn_req_dump(level + 1, frm);
1396 return;
1397 case OCF_REJECT_CONN_REQ:
1398 case OCF_REJECT_SYNC_CONN_REQ:
1399 case OCF_IO_CAPABILITY_NEG_REPLY:
1400 reject_conn_req_dump(level + 1, frm);
1401 return;
1402 case OCF_PIN_CODE_REPLY:
1403 pin_code_reply_dump(level + 1, frm);
1404 return;
1405 case OCF_LINK_KEY_REPLY:
1406 link_key_reply_dump(level + 1, frm);
1407 return;
1408 case OCF_PIN_CODE_NEG_REPLY:
1409 case OCF_LINK_KEY_NEG_REPLY:
1410 case OCF_USER_CONFIRM_REPLY:
1411 case OCF_USER_CONFIRM_NEG_REPLY:
1412 case OCF_USER_PASSKEY_NEG_REPLY:
1413 case OCF_REMOTE_OOB_DATA_NEG_REPLY:
1414 pin_code_neg_reply_dump(level + 1, frm);
1415 return;
1416 case OCF_USER_PASSKEY_REPLY:
1417 user_passkey_reply_dump(level + 1, frm);
1418 return;
1419 case OCF_REMOTE_OOB_DATA_REPLY:
1420 remote_oob_data_reply_dump(level + 1, frm);
1421 return;
1422 case OCF_IO_CAPABILITY_REPLY:
1423 io_capability_reply_dump(level + 1, frm);
1424 return;
1425 case OCF_SET_CONN_ENCRYPT:
1426 set_conn_encrypt_dump(level + 1, frm);
1427 return;
1428 case OCF_AUTH_REQUESTED:
1429 case OCF_CHANGE_CONN_LINK_KEY:
1430 case OCF_READ_REMOTE_FEATURES:
1431 case OCF_READ_REMOTE_VERSION:
1432 case OCF_READ_CLOCK_OFFSET:
1433 case OCF_READ_LMP_HANDLE:
1434 generic_command_dump(level + 1, frm);
1435 return;
1436 case OCF_MASTER_LINK_KEY:
1437 master_link_key_dump(level + 1, frm);
1438 return;
1439 case OCF_READ_REMOTE_EXT_FEATURES:
1440 read_remote_ext_features_dump(level + 1, frm);
1441 return;
1442 case OCF_REMOTE_NAME_REQ:
1443 remote_name_req_dump(level + 1, frm);
1444 return;
1445 case OCF_SETUP_SYNC_CONN:
1446 setup_sync_conn_dump(level + 1, frm);
1447 return;
1448 }
1449 break;
1450
1451 case OGF_LINK_POLICY:
1452 switch (ocf) {
1453 case OCF_HOLD_MODE:
1454 case OCF_PARK_MODE:
1455 hold_mode_dump(level + 1, frm);
1456 return;
1457 case OCF_SNIFF_MODE:
1458 sniff_mode_dump(level + 1, frm);
1459 return;
1460 case OCF_EXIT_SNIFF_MODE:
1461 case OCF_EXIT_PARK_MODE:
1462 case OCF_ROLE_DISCOVERY:
1463 case OCF_READ_LINK_POLICY:
1464 generic_command_dump(level + 1, frm);
1465 return;
1466 case OCF_READ_DEFAULT_LINK_POLICY:
1467 return;
1468 case OCF_SWITCH_ROLE:
1469 accept_conn_req_dump(level + 1, frm);
1470 return;
1471 case OCF_QOS_SETUP:
1472 qos_setup_dump(level + 1, frm);
1473 return;
1474 case OCF_WRITE_LINK_POLICY:
1475 write_link_policy_dump(level + 1, frm);
1476 return;
1477 case OCF_WRITE_DEFAULT_LINK_POLICY:
1478 write_default_link_policy_dump(level + 1, frm);
1479 return;
1480 case OCF_SNIFF_SUBRATING:
1481 sniff_subrating_dump(level + 1, frm);
1482 return;
1483 }
1484 break;
1485
1486 case OGF_HOST_CTL:
1487 switch (ocf) {
1488 case OCF_RESET:
1489 case OCF_CREATE_NEW_UNIT_KEY:
1490 return;
1491 case OCF_SET_EVENT_MASK:
1492 set_event_mask_dump(level + 1, frm);
1493 return;
1494 case OCF_SET_EVENT_FLT:
1495 set_event_flt_dump(level + 1, frm);
1496 return;
1497 case OCF_WRITE_PIN_TYPE:
1498 write_pin_type_dump(level + 1, frm);
1499 return;
1500 case OCF_READ_STORED_LINK_KEY:
1501 case OCF_DELETE_STORED_LINK_KEY:
1502 request_stored_link_key_dump(level + 1, frm);
1503 return;
1504 case OCF_WRITE_STORED_LINK_KEY:
1505 return_link_keys_dump(level + 1, frm);
1506 return;
1507 case OCF_CHANGE_LOCAL_NAME:
1508 change_local_name_dump(level + 1, frm);
1509 return;
1510 case OCF_WRITE_CLASS_OF_DEV:
1511 write_class_of_dev_dump(level + 1, frm);
1512 return;
1513 case OCF_WRITE_VOICE_SETTING:
1514 write_voice_setting_dump(level + 1, frm);
1515 return;
1516 case OCF_WRITE_CURRENT_IAC_LAP:
1517 write_current_iac_lap_dump(level + 1, frm);
1518 return;
1519 case OCF_WRITE_SCAN_ENABLE:
1520 case OCF_WRITE_AUTH_ENABLE:
1521 case OCF_SET_CONTROLLER_TO_HOST_FC:
1522 write_scan_enable_dump(level + 1, frm);
1523 return;
1524 case OCF_WRITE_CONN_ACCEPT_TIMEOUT:
1525 case OCF_WRITE_PAGE_TIMEOUT:
1526 write_page_timeout_dump(level + 1, frm);
1527 return;
1528 case OCF_WRITE_PAGE_ACTIVITY:
1529 case OCF_WRITE_INQ_ACTIVITY:
1530 write_page_activity_dump(level + 1, frm);
1531 return;
1532 case OCF_WRITE_INQUIRY_SCAN_TYPE:
1533 write_inquiry_scan_type_dump(level + 1, frm);
1534 return;
1535 case OCF_WRITE_ENCRYPT_MODE:
1536 case OCF_WRITE_INQUIRY_MODE:
1537 case OCF_WRITE_AFH_MODE:
1538 write_inquiry_mode_dump(level + 1, frm);
1539 return;
1540 case OCF_SET_AFH_CLASSIFICATION:
1541 set_afh_classification_dump(level + 1, frm);
1542 return;
1543 case OCF_READ_TRANSMIT_POWER_LEVEL:
1544 request_transmit_power_level_dump(level + 1, frm);
1545 return;
1546 case OCF_HOST_BUFFER_SIZE:
1547 host_buffer_size_dump(level + 1, frm);
1548 return;
1549 case OCF_HOST_NUM_COMP_PKTS:
1550 num_comp_pkts_dump(level + 1, frm);
1551 return;
1552 case OCF_FLUSH:
1553 case OCF_READ_LINK_SUPERVISION_TIMEOUT:
1554 case OCF_REFRESH_ENCRYPTION_KEY:
1555 generic_command_dump(level + 1, frm);
1556 return;
1557 case OCF_WRITE_LINK_SUPERVISION_TIMEOUT:
1558 write_link_supervision_timeout_dump(level + 1, frm);
1559 return;
1560 case OCF_WRITE_EXT_INQUIRY_RESPONSE:
1561 write_ext_inquiry_response_dump(level + 1, frm);
1562 return;
1563 case OCF_WRITE_SIMPLE_PAIRING_MODE:
1564 generic_write_mode_dump(level + 1, frm);
1565 return;
1566 case OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL:
1567 write_inquiry_transmit_power_level_dump(level + 1, frm);
1568 return;
1569 case OCF_WRITE_DEFAULT_ERROR_DATA_REPORTING:
1570 write_default_error_data_reporting_dump(level + 1, frm);
1571 return;
1572 case OCF_ENHANCED_FLUSH:
1573 enhanced_flush_dump(level + 1, frm);
1574 return;
1575 case OCF_SEND_KEYPRESS_NOTIFY:
1576 send_keypress_notify_dump(level + 1, frm);
1577 return;
1578 }
1579 break;
1580
1581 case OGF_INFO_PARAM:
1582 switch (ocf) {
1583 case OCF_READ_LOCAL_EXT_FEATURES:
1584 request_local_ext_features_dump(level + 1, frm);
1585 return;
1586 }
1587 break;
1588
1589 case OGF_STATUS_PARAM:
1590 switch (ocf) {
1591 case OCF_READ_LINK_QUALITY:
1592 case OCF_READ_RSSI:
1593 case OCF_READ_AFH_MAP:
1594 generic_command_dump(level + 1, frm);
1595 return;
1596 case OCF_READ_CLOCK:
1597 request_clock_dump(level + 1, frm);
1598 return;
1599 }
1600 break;
1601
1602 case OGF_TESTING_CMD:
1603 switch (ocf) {
1604 case OCF_WRITE_LOOPBACK_MODE:
1605 case OCF_WRITE_SIMPLE_PAIRING_DEBUG_MODE:
1606 generic_write_mode_dump(level + 1, frm);
1607 return;
1608 }
1609 break;
1610 }
1611
1612 raw_dump(level, frm);
1613 }
1614
status_response_dump(int level,struct frame * frm)1615 static inline void status_response_dump(int level, struct frame *frm)
1616 {
1617 uint8_t status = get_u8(frm);
1618
1619 p_indent(level, frm);
1620 printf("status 0x%2.2x\n", status);
1621
1622 if (status > 0) {
1623 p_indent(level, frm);
1624 printf("Error: %s\n", status2str(status));
1625 }
1626
1627 raw_dump(level, frm);
1628 }
1629
handle_response_dump(int level,struct frame * frm)1630 static inline void handle_response_dump(int level, struct frame *frm)
1631 {
1632 uint16_t handle = btohs(htons(get_u16(frm)));
1633
1634 p_indent(level, frm);
1635 printf("handle %d\n", handle);
1636
1637 raw_dump(level, frm);
1638 }
1639
bdaddr_response_dump(int level,struct frame * frm)1640 static inline void bdaddr_response_dump(int level, struct frame *frm)
1641 {
1642 uint8_t status = get_u8(frm);
1643 bdaddr_t *bdaddr = frm->ptr;
1644 char addr[18];
1645
1646 frm->ptr += sizeof(bdaddr_t);
1647 frm->len -= sizeof(bdaddr_t);
1648
1649 p_indent(level, frm);
1650 p_ba2str(bdaddr, addr);
1651 printf("status 0x%2.2x bdaddr %s\n", status, addr);
1652
1653 if (status > 0) {
1654 p_indent(level, frm);
1655 printf("Error: %s\n", status2str(status));
1656 }
1657
1658 raw_dump(level, frm);
1659 }
1660
generic_response_dump(int level,struct frame * frm)1661 static inline void generic_response_dump(int level, struct frame *frm)
1662 {
1663 uint8_t status = get_u8(frm);
1664 uint16_t handle = btohs(htons(get_u16(frm)));
1665
1666 p_indent(level, frm);
1667 printf("status 0x%2.2x handle %d\n", status, handle);
1668
1669 if (status > 0) {
1670 p_indent(level, frm);
1671 printf("Error: %s\n", status2str(status));
1672 }
1673
1674 raw_dump(level, frm);
1675 }
1676
status_mode_dump(int level,struct frame * frm)1677 static inline void status_mode_dump(int level, struct frame *frm)
1678 {
1679 uint8_t status = get_u8(frm);
1680 uint8_t mode = get_u8(frm);
1681
1682 p_indent(level, frm);
1683 printf("status 0x%2.2x mode 0x%2.2x\n", status, mode);
1684
1685 if (status > 0) {
1686 p_indent(level, frm);
1687 printf("Error: %s\n", status2str(status));
1688 }
1689 }
1690
read_link_policy_dump(int level,struct frame * frm)1691 static inline void read_link_policy_dump(int level, struct frame *frm)
1692 {
1693 read_link_policy_rp *rp = frm->ptr;
1694 uint16_t policy = btohs(rp->policy);
1695 char *str;
1696
1697 p_indent(level, frm);
1698 printf("status 0x%2.2x handle %d policy 0x%2.2x\n",
1699 rp->status, btohs(rp->handle), policy);
1700
1701 if (rp->status > 0) {
1702 p_indent(level, frm);
1703 printf("Error: %s\n", status2str(rp->status));
1704 } else {
1705 str = hci_lptostr(policy);
1706 if (str) {
1707 p_indent(level, frm);
1708 printf("Link policy: %s\n", str);
1709 free(str);
1710 }
1711 }
1712 }
1713
read_default_link_policy_dump(int level,struct frame * frm)1714 static inline void read_default_link_policy_dump(int level, struct frame *frm)
1715 {
1716 uint8_t status = get_u8(frm);
1717 uint16_t policy = btohs(htons(get_u16(frm)));
1718 char *str;
1719
1720 p_indent(level, frm);
1721 printf("status 0x%2.2x policy 0x%2.2x\n", status, policy);
1722
1723 if (status > 0) {
1724 p_indent(level, frm);
1725 printf("Error: %s\n", status2str(status));
1726 } else {
1727 str = hci_lptostr(policy);
1728 if (str) {
1729 p_indent(level, frm);
1730 printf("Link policy: %s\n", str);
1731 free(str);
1732 }
1733 }
1734 }
1735
read_pin_type_dump(int level,struct frame * frm)1736 static inline void read_pin_type_dump(int level, struct frame *frm)
1737 {
1738 read_pin_type_rp *rp = frm->ptr;
1739
1740 p_indent(level, frm);
1741 printf("status 0x%2.2x type %d\n", rp->status, rp->pin_type);
1742
1743 if (rp->status > 0) {
1744 p_indent(level, frm);
1745 printf("Error: %s\n", status2str(rp->status));
1746 }
1747 }
1748
read_stored_link_key_dump(int level,struct frame * frm)1749 static inline void read_stored_link_key_dump(int level, struct frame *frm)
1750 {
1751 read_stored_link_key_rp *rp = frm->ptr;
1752
1753 p_indent(level, frm);
1754 printf("status 0x%2.2x max %d num %d\n",
1755 rp->status, rp->max_keys, rp->num_keys);
1756
1757 if (rp->status > 0) {
1758 p_indent(level, frm);
1759 printf("Error: %s\n", status2str(rp->status));
1760 }
1761 }
1762
write_stored_link_key_dump(int level,struct frame * frm)1763 static inline void write_stored_link_key_dump(int level, struct frame *frm)
1764 {
1765 write_stored_link_key_rp *rp = frm->ptr;
1766
1767 p_indent(level, frm);
1768 printf("status 0x%2.2x written %d\n", rp->status, rp->num_keys);
1769
1770 if (rp->status > 0) {
1771 p_indent(level, frm);
1772 printf("Error: %s\n", status2str(rp->status));
1773 }
1774 }
1775
delete_stored_link_key_dump(int level,struct frame * frm)1776 static inline void delete_stored_link_key_dump(int level, struct frame *frm)
1777 {
1778 delete_stored_link_key_rp *rp = frm->ptr;
1779
1780 p_indent(level, frm);
1781 printf("status 0x%2.2x deleted %d\n", rp->status, btohs(rp->num_keys));
1782
1783 if (rp->status > 0) {
1784 p_indent(level, frm);
1785 printf("Error: %s\n", status2str(rp->status));
1786 }
1787 }
1788
read_local_name_dump(int level,struct frame * frm)1789 static inline void read_local_name_dump(int level, struct frame *frm)
1790 {
1791 read_local_name_rp *rp = frm->ptr;
1792 char name[249];
1793 int i;
1794
1795 memset(name, 0, sizeof(name));
1796 for (i = 0; i < 248 && rp->name[i]; i++)
1797 if (isprint(rp->name[i]))
1798 name[i] = rp->name[i];
1799 else
1800 name[i] = '.';
1801
1802 p_indent(level, frm);
1803 printf("status 0x%2.2x name \'%s\'\n", rp->status, name);
1804
1805 if (rp->status > 0) {
1806 p_indent(level, frm);
1807 printf("Error: %s\n", status2str(rp->status));
1808 }
1809 }
1810
read_class_of_dev_dump(int level,struct frame * frm)1811 static inline void read_class_of_dev_dump(int level, struct frame *frm)
1812 {
1813 read_class_of_dev_rp *rp = frm->ptr;
1814
1815 p_indent(level, frm);
1816 printf("status 0x%2.2x class 0x%2.2x%2.2x%2.2x\n", rp->status,
1817 rp->dev_class[2], rp->dev_class[1], rp->dev_class[0]);
1818
1819 if (rp->status > 0) {
1820 p_indent(level, frm);
1821 printf("Error: %s\n", status2str(rp->status));
1822 }
1823 }
1824
read_voice_setting_dump(int level,struct frame * frm)1825 static inline void read_voice_setting_dump(int level, struct frame *frm)
1826 {
1827 read_voice_setting_rp *rp = frm->ptr;
1828
1829 p_indent(level, frm);
1830 printf("status 0x%2.2x voice setting 0x%4.4x\n",
1831 rp->status, btohs(rp->voice_setting));
1832
1833 if (rp->status > 0) {
1834 p_indent(level, frm);
1835 printf("Error: %s\n", status2str(rp->status));
1836 }
1837 }
1838
read_current_iac_lap_dump(int level,struct frame * frm)1839 static inline void read_current_iac_lap_dump(int level, struct frame *frm)
1840 {
1841 read_current_iac_lap_rp *rp = frm->ptr;
1842 int i;
1843
1844 for (i = 0; i < rp->num_current_iac; i++) {
1845 p_indent(level, frm);
1846 printf("IAC 0x%2.2x%2.2x%2.2x", rp->lap[i][2], rp->lap[i][1], rp->lap[i][0]);
1847 if (rp->lap[i][2] == 0x9e && rp->lap[i][1] == 0x8b) {
1848 switch (rp->lap[i][0]) {
1849 case 0x00:
1850 printf(" (Limited Inquiry Access Code)");
1851 break;
1852 case 0x33:
1853 printf(" (General Inquiry Access Code)");
1854 break;
1855 }
1856 }
1857 printf("\n");
1858 }
1859 }
1860
read_scan_enable_dump(int level,struct frame * frm)1861 static inline void read_scan_enable_dump(int level, struct frame *frm)
1862 {
1863 uint8_t status = get_u8(frm);
1864 uint8_t enable = get_u8(frm);
1865
1866 p_indent(level, frm);
1867 printf("status 0x%2.2x enable %d\n", status, enable);
1868
1869 if (status > 0) {
1870 p_indent(level, frm);
1871 printf("Error: %s\n", status2str(status));
1872 }
1873 }
1874
read_page_timeout_dump(int level,struct frame * frm)1875 static inline void read_page_timeout_dump(int level, struct frame *frm)
1876 {
1877 read_page_timeout_rp *rp = frm->ptr;
1878
1879 p_indent(level, frm);
1880 printf("status 0x%2.2x timeout %d\n", rp->status, btohs(rp->timeout));
1881
1882 if (rp->status > 0) {
1883 p_indent(level, frm);
1884 printf("Error: %s\n", status2str(rp->status));
1885 }
1886 }
1887
read_page_activity_dump(int level,struct frame * frm)1888 static inline void read_page_activity_dump(int level, struct frame *frm)
1889 {
1890 read_page_activity_rp *rp = frm->ptr;
1891
1892 p_indent(level, frm);
1893 printf("status 0x%2.2x interval %d window %d\n",
1894 rp->status, btohs(rp->interval), btohs(rp->window));
1895
1896 if (rp->status > 0) {
1897 p_indent(level, frm);
1898 printf("Error: %s\n", status2str(rp->status));
1899 }
1900 }
1901
read_inquiry_scan_type_dump(int level,struct frame * frm)1902 static inline void read_inquiry_scan_type_dump(int level, struct frame *frm)
1903 {
1904 read_inquiry_scan_type_rp *rp = frm->ptr;
1905
1906 p_indent(level, frm);
1907 printf("status 0x%2.2x type %d\n", rp->status, rp->type);
1908
1909 if (rp->status > 0) {
1910 p_indent(level, frm);
1911 printf("Error: %s\n", status2str(rp->status));
1912 }
1913 }
1914
read_inquiry_mode_dump(int level,struct frame * frm)1915 static inline void read_inquiry_mode_dump(int level, struct frame *frm)
1916 {
1917 read_inquiry_mode_rp *rp = frm->ptr;
1918
1919 p_indent(level, frm);
1920 printf("status 0x%2.2x mode %d\n", rp->status, rp->mode);
1921
1922 if (rp->status > 0) {
1923 p_indent(level, frm);
1924 printf("Error: %s\n", status2str(rp->status));
1925 }
1926 }
1927
read_link_supervision_timeout_dump(int level,struct frame * frm)1928 static inline void read_link_supervision_timeout_dump(int level, struct frame *frm)
1929 {
1930 read_link_supervision_timeout_rp *rp = frm->ptr;
1931
1932 p_indent(level, frm);
1933 printf("status 0x%2.2x handle %d timeout %d\n",
1934 rp->status, btohs(rp->handle), btohs(rp->timeout));
1935
1936 if (rp->status > 0) {
1937 p_indent(level, frm);
1938 printf("Error: %s\n", status2str(rp->status));
1939 }
1940 }
1941
read_transmit_power_level_dump(int level,struct frame * frm)1942 static inline void read_transmit_power_level_dump(int level, struct frame *frm)
1943 {
1944 read_transmit_power_level_rp *rp = frm->ptr;
1945
1946 p_indent(level, frm);
1947 printf("status 0x%2.2x handle %d level %d\n",
1948 rp->status, btohs(rp->handle), rp->level);
1949
1950 if (rp->status > 0) {
1951 p_indent(level, frm);
1952 printf("Error: %s\n", status2str(rp->status));
1953 }
1954 }
1955
read_ext_inquiry_response_dump(int level,struct frame * frm)1956 static inline void read_ext_inquiry_response_dump(int level, struct frame *frm)
1957 {
1958 read_ext_inquiry_response_rp *rp = frm->ptr;
1959
1960 p_indent(level, frm);
1961 printf("status 0x%2.2x fec 0x%2.2x\n", rp->status, rp->fec);
1962
1963 if (rp->status > 0) {
1964 p_indent(level, frm);
1965 printf("Error: %s\n", status2str(rp->status));
1966 } else {
1967 frm->ptr += 2;
1968 frm->len -= 2;
1969
1970 ext_inquiry_response_dump(level, frm);
1971 }
1972 }
1973
read_inquiry_transmit_power_level_dump(int level,struct frame * frm)1974 static inline void read_inquiry_transmit_power_level_dump(int level, struct frame *frm)
1975 {
1976 read_inquiry_transmit_power_level_rp *rp = frm->ptr;
1977
1978 p_indent(level, frm);
1979 printf("status 0x%2.2x level %d\n", rp->status, rp->level);
1980
1981 if (rp->status > 0) {
1982 p_indent(level, frm);
1983 printf("Error: %s\n", status2str(rp->status));
1984 }
1985 }
1986
read_default_error_data_reporting_dump(int level,struct frame * frm)1987 static inline void read_default_error_data_reporting_dump(int level, struct frame *frm)
1988 {
1989 read_default_error_data_reporting_rp *rp = frm->ptr;
1990
1991 p_indent(level, frm);
1992 printf("status 0x%2.2x reporting %d\n", rp->status, rp->reporting);
1993
1994 if (rp->status > 0) {
1995 p_indent(level, frm);
1996 printf("Error: %s\n", status2str(rp->status));
1997 }
1998 }
1999
read_local_oob_data_dump(int level,struct frame * frm)2000 static inline void read_local_oob_data_dump(int level, struct frame *frm)
2001 {
2002 read_local_oob_data_rp *rp = frm->ptr;
2003 int i;
2004
2005 p_indent(level, frm);
2006 printf("status 0x%2.2x\n", rp->status);
2007
2008 if (rp->status > 0) {
2009 p_indent(level, frm);
2010 printf("Error: %s\n", status2str(rp->status));
2011 } else {
2012 p_indent(level, frm);
2013 printf("hash 0x");
2014 for (i = 0; i < 16; i++)
2015 printf("%02x", rp->hash[i]);
2016 printf("\n");
2017
2018 p_indent(level, frm);
2019 printf("randomizer 0x");
2020 for (i = 0; i < 16; i++)
2021 printf("%02x", rp->randomizer[i]);
2022 printf("\n");
2023 }
2024 }
2025
read_local_version_dump(int level,struct frame * frm)2026 static inline void read_local_version_dump(int level, struct frame *frm)
2027 {
2028 read_local_version_rp *rp = frm->ptr;
2029 uint16_t manufacturer = btohs(rp->manufacturer);
2030
2031 p_indent(level, frm);
2032 printf("status 0x%2.2x\n", rp->status);
2033
2034 if (rp->status > 0) {
2035 p_indent(level, frm);
2036 printf("Error: %s\n", status2str(rp->status));
2037 } else {
2038 p_indent(level, frm);
2039 printf("HCI Version: %s (0x%x) HCI Revision: 0x%x\n",
2040 hci_vertostr(rp->hci_ver),
2041 rp->hci_ver, btohs(rp->hci_rev));
2042 p_indent(level, frm);
2043 printf("LMP Version: %s (0x%x) LMP Subversion: 0x%x\n",
2044 lmp_vertostr(rp->lmp_ver),
2045 rp->lmp_ver, btohs(rp->lmp_subver));
2046 p_indent(level, frm);
2047 printf("Manufacturer: %s (%d)\n",
2048 bt_compidtostr(manufacturer), manufacturer);
2049 }
2050 }
2051
read_local_commands_dump(int level,struct frame * frm)2052 static inline void read_local_commands_dump(int level, struct frame *frm)
2053 {
2054 read_local_commands_rp *rp = frm->ptr;
2055 int i, max = 0;
2056
2057 p_indent(level, frm);
2058 printf("status 0x%2.2x\n", rp->status);
2059
2060 if (rp->status > 0) {
2061 p_indent(level, frm);
2062 printf("Error: %s\n", status2str(rp->status));
2063 } else {
2064 for (i = 0; i < 64; i++)
2065 if (rp->commands[i])
2066 max = i + 1;
2067 p_indent(level, frm);
2068 printf("Commands: ");
2069 for (i = 0; i < (max > 32 ? 32 : max); i++)
2070 printf("%2.2x", rp->commands[i]);
2071 printf("\n");
2072 if (max > 32) {
2073 p_indent(level, frm);
2074 printf(" ");
2075 for (i = 32; i < max; i++)
2076 printf("%2.2x", rp->commands[i]);
2077 printf("\n");
2078 }
2079 }
2080 }
2081
read_local_features_dump(int level,struct frame * frm)2082 static inline void read_local_features_dump(int level, struct frame *frm)
2083 {
2084 read_local_features_rp *rp = frm->ptr;
2085 int i;
2086
2087 p_indent(level, frm);
2088 printf("status 0x%2.2x\n", rp->status);
2089
2090 if (rp->status > 0) {
2091 p_indent(level, frm);
2092 printf("Error: %s\n", status2str(rp->status));
2093 } else {
2094 p_indent(level, frm);
2095 printf("Features:");
2096 for (i = 0; i < 8; i++)
2097 printf(" 0x%2.2x", rp->features[i]);
2098 printf("\n");
2099 }
2100 }
2101
read_local_ext_features_dump(int level,struct frame * frm)2102 static inline void read_local_ext_features_dump(int level, struct frame *frm)
2103 {
2104 read_local_ext_features_rp *rp = frm->ptr;
2105 int i;
2106
2107 p_indent(level, frm);
2108 printf("status 0x%2.2x page %d max %d\n",
2109 rp->status, rp->page_num, rp->max_page_num);
2110
2111 if (rp->status > 0) {
2112 p_indent(level, frm);
2113 printf("Error: %s\n", status2str(rp->status));
2114 } else {
2115 p_indent(level, frm);
2116 printf("Features:");
2117 for (i = 0; i < 8; i++)
2118 printf(" 0x%2.2x", rp->features[i]);
2119 printf("\n");
2120 }
2121 }
2122
read_buffer_size_dump(int level,struct frame * frm)2123 static inline void read_buffer_size_dump(int level, struct frame *frm)
2124 {
2125 read_buffer_size_rp *rp = frm->ptr;
2126
2127 p_indent(level, frm);
2128 printf("status 0x%2.2x\n", rp->status);
2129
2130 if (rp->status > 0) {
2131 p_indent(level, frm);
2132 printf("Error: %s\n", status2str(rp->status));
2133 } else {
2134 p_indent(level, frm);
2135 printf("ACL MTU %d:%d SCO MTU %d:%d\n",
2136 btohs(rp->acl_mtu), btohs(rp->acl_max_pkt),
2137 rp->sco_mtu, btohs(rp->sco_max_pkt));
2138 }
2139 }
2140
read_link_quality_dump(int level,struct frame * frm)2141 static inline void read_link_quality_dump(int level, struct frame *frm)
2142 {
2143 read_link_quality_rp *rp = frm->ptr;
2144
2145 p_indent(level, frm);
2146 printf("status 0x%2.2x handle %d lq %d\n",
2147 rp->status, btohs(rp->handle), rp->link_quality);
2148
2149 if (rp->status > 0) {
2150 p_indent(level, frm);
2151 printf("Error: %s\n", status2str(rp->status));
2152 }
2153 }
2154
read_rssi_dump(int level,struct frame * frm)2155 static inline void read_rssi_dump(int level, struct frame *frm)
2156 {
2157 read_rssi_rp *rp = frm->ptr;
2158
2159 p_indent(level, frm);
2160 printf("status 0x%2.2x handle %d rssi %d\n",
2161 rp->status, btohs(rp->handle), rp->rssi);
2162
2163 if (rp->status > 0) {
2164 p_indent(level, frm);
2165 printf("Error: %s\n", status2str(rp->status));
2166 }
2167 }
2168
read_afh_map_dump(int level,struct frame * frm)2169 static inline void read_afh_map_dump(int level, struct frame *frm)
2170 {
2171 read_afh_map_rp *rp = frm->ptr;
2172 int i;
2173
2174 p_indent(level, frm);
2175 printf("status 0x%2.2x handle %d mode %d\n",
2176 rp->status, btohs(rp->handle), rp->mode);
2177
2178 if (rp->status > 0) {
2179 p_indent(level, frm);
2180 printf("Error: %s\n", status2str(rp->status));
2181 } else {
2182 p_indent(level, frm);
2183 printf("AFH map: 0x");
2184 for (i = 0; i < 10; i++)
2185 printf("%2.2x", rp->map[i]);
2186 printf("\n");
2187 }
2188 }
2189
read_clock_dump(int level,struct frame * frm)2190 static inline void read_clock_dump(int level, struct frame *frm)
2191 {
2192 read_clock_rp *rp = frm->ptr;
2193
2194 p_indent(level, frm);
2195 printf("status 0x%2.2x handle %d clock 0x%4.4x accuracy %d\n",
2196 rp->status, btohs(rp->handle),
2197 btohl(rp->clock), btohs(rp->accuracy));
2198
2199 if (rp->status > 0) {
2200 p_indent(level, frm);
2201 printf("Error: %s\n", status2str(rp->status));
2202 }
2203 }
2204
cmd_complete_dump(int level,struct frame * frm)2205 static inline void cmd_complete_dump(int level, struct frame *frm)
2206 {
2207 evt_cmd_complete *evt = frm->ptr;
2208 uint16_t opcode = btohs(evt->opcode);
2209 uint16_t ogf = cmd_opcode_ogf(opcode);
2210 uint16_t ocf = cmd_opcode_ocf(opcode);
2211
2212 if (ogf == OGF_VENDOR_CMD && (parser.flags & DUMP_NOVENDOR))
2213 return;
2214
2215 p_indent(level, frm);
2216 printf("%s (0x%2.2x|0x%4.4x) ncmd %d\n",
2217 opcode2str(opcode), ogf, ocf, evt->ncmd);
2218
2219 frm->ptr += EVT_CMD_COMPLETE_SIZE;
2220 frm->len -= EVT_CMD_COMPLETE_SIZE;
2221
2222 if (!(parser.flags & DUMP_VERBOSE)) {
2223 raw_dump(level, frm);
2224 return;
2225 }
2226
2227 switch (ogf) {
2228 case OGF_LINK_CTL:
2229 switch (ocf) {
2230 case OCF_INQUIRY_CANCEL:
2231 case OCF_PERIODIC_INQUIRY:
2232 case OCF_EXIT_PERIODIC_INQUIRY:
2233 case OCF_READ_REMOTE_EXT_FEATURES:
2234 status_response_dump(level, frm);
2235 return;
2236 case OCF_CREATE_CONN_CANCEL:
2237 case OCF_REMOTE_NAME_REQ_CANCEL:
2238 case OCF_PIN_CODE_REPLY:
2239 case OCF_LINK_KEY_REPLY:
2240 case OCF_PIN_CODE_NEG_REPLY:
2241 case OCF_LINK_KEY_NEG_REPLY:
2242 case OCF_USER_CONFIRM_REPLY:
2243 case OCF_USER_CONFIRM_NEG_REPLY:
2244 case OCF_USER_PASSKEY_REPLY:
2245 case OCF_USER_PASSKEY_NEG_REPLY:
2246 case OCF_REMOTE_OOB_DATA_REPLY:
2247 case OCF_REMOTE_OOB_DATA_NEG_REPLY:
2248 case OCF_IO_CAPABILITY_REPLY:
2249 case OCF_IO_CAPABILITY_NEG_REPLY:
2250 bdaddr_response_dump(level, frm);
2251 return;
2252 }
2253 break;
2254
2255 case OGF_LINK_POLICY:
2256 switch (ocf) {
2257 case OCF_READ_LINK_POLICY:
2258 read_link_policy_dump(level, frm);
2259 return;
2260 case OCF_WRITE_LINK_POLICY:
2261 case OCF_SNIFF_SUBRATING:
2262 generic_response_dump(level, frm);
2263 return;
2264 case OCF_READ_DEFAULT_LINK_POLICY:
2265 read_default_link_policy_dump(level, frm);
2266 return;
2267 case OCF_WRITE_DEFAULT_LINK_POLICY:
2268 status_response_dump(level, frm);
2269 return;
2270 }
2271 break;
2272
2273 case OGF_HOST_CTL:
2274 switch (ocf) {
2275 case OCF_READ_PIN_TYPE:
2276 read_pin_type_dump(level, frm);
2277 return;
2278 case OCF_READ_STORED_LINK_KEY:
2279 read_stored_link_key_dump(level, frm);
2280 return;
2281 case OCF_WRITE_STORED_LINK_KEY:
2282 write_stored_link_key_dump(level, frm);
2283 return;
2284 case OCF_DELETE_STORED_LINK_KEY:
2285 delete_stored_link_key_dump(level, frm);
2286 return;
2287 case OCF_READ_LOCAL_NAME:
2288 read_local_name_dump(level, frm);
2289 return;
2290 case OCF_READ_CLASS_OF_DEV:
2291 read_class_of_dev_dump(level, frm);
2292 return;
2293 case OCF_READ_VOICE_SETTING:
2294 read_voice_setting_dump(level, frm);
2295 return;
2296 case OCF_READ_CURRENT_IAC_LAP:
2297 read_current_iac_lap_dump(level, frm);
2298 return;
2299 case OCF_READ_SCAN_ENABLE:
2300 case OCF_READ_AUTH_ENABLE:
2301 read_scan_enable_dump(level, frm);
2302 return;
2303 case OCF_READ_CONN_ACCEPT_TIMEOUT:
2304 case OCF_READ_PAGE_TIMEOUT:
2305 read_page_timeout_dump(level, frm);
2306 return;
2307 case OCF_READ_PAGE_ACTIVITY:
2308 case OCF_READ_INQ_ACTIVITY:
2309 read_page_activity_dump(level, frm);
2310 return;
2311 case OCF_READ_INQUIRY_SCAN_TYPE:
2312 read_inquiry_scan_type_dump(level, frm);
2313 return;
2314 case OCF_READ_ENCRYPT_MODE:
2315 case OCF_READ_INQUIRY_MODE:
2316 case OCF_READ_AFH_MODE:
2317 read_inquiry_mode_dump(level, frm);
2318 return;
2319 case OCF_READ_LINK_SUPERVISION_TIMEOUT:
2320 read_link_supervision_timeout_dump(level, frm);
2321 return;
2322 case OCF_READ_TRANSMIT_POWER_LEVEL:
2323 read_transmit_power_level_dump(level, frm);
2324 return;
2325 case OCF_READ_EXT_INQUIRY_RESPONSE:
2326 read_ext_inquiry_response_dump(level, frm);
2327 return;
2328 case OCF_READ_INQUIRY_TRANSMIT_POWER_LEVEL:
2329 read_inquiry_transmit_power_level_dump(level, frm);
2330 return;
2331 case OCF_READ_DEFAULT_ERROR_DATA_REPORTING:
2332 read_default_error_data_reporting_dump(level, frm);
2333 return;
2334 case OCF_READ_LOCAL_OOB_DATA:
2335 read_local_oob_data_dump(level, frm);
2336 return;
2337 case OCF_READ_SIMPLE_PAIRING_MODE:
2338 status_mode_dump(level, frm);
2339 return;
2340 case OCF_FLUSH:
2341 case OCF_WRITE_LINK_SUPERVISION_TIMEOUT:
2342 generic_response_dump(level, frm);
2343 return;
2344 case OCF_RESET:
2345 case OCF_SET_EVENT_MASK:
2346 case OCF_SET_EVENT_FLT:
2347 case OCF_WRITE_PIN_TYPE:
2348 case OCF_CREATE_NEW_UNIT_KEY:
2349 case OCF_CHANGE_LOCAL_NAME:
2350 case OCF_WRITE_CLASS_OF_DEV:
2351 case OCF_WRITE_VOICE_SETTING:
2352 case OCF_WRITE_CURRENT_IAC_LAP:
2353 case OCF_WRITE_SCAN_ENABLE:
2354 case OCF_WRITE_AUTH_ENABLE:
2355 case OCF_WRITE_ENCRYPT_MODE:
2356 case OCF_WRITE_CONN_ACCEPT_TIMEOUT:
2357 case OCF_WRITE_PAGE_TIMEOUT:
2358 case OCF_WRITE_PAGE_ACTIVITY:
2359 case OCF_WRITE_INQ_ACTIVITY:
2360 case OCF_WRITE_INQUIRY_SCAN_TYPE:
2361 case OCF_WRITE_INQUIRY_MODE:
2362 case OCF_WRITE_AFH_MODE:
2363 case OCF_SET_AFH_CLASSIFICATION:
2364 case OCF_WRITE_EXT_INQUIRY_RESPONSE:
2365 case OCF_WRITE_SIMPLE_PAIRING_MODE:
2366 case OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL:
2367 case OCF_WRITE_DEFAULT_ERROR_DATA_REPORTING:
2368 case OCF_SET_CONTROLLER_TO_HOST_FC:
2369 case OCF_HOST_BUFFER_SIZE:
2370 case OCF_REFRESH_ENCRYPTION_KEY:
2371 case OCF_SEND_KEYPRESS_NOTIFY:
2372 status_response_dump(level, frm);
2373 return;
2374 }
2375 break;
2376
2377 case OGF_INFO_PARAM:
2378 switch (ocf) {
2379 case OCF_READ_LOCAL_VERSION:
2380 read_local_version_dump(level, frm);
2381 return;
2382 case OCF_READ_LOCAL_COMMANDS:
2383 read_local_commands_dump(level, frm);
2384 return;
2385 case OCF_READ_LOCAL_FEATURES:
2386 read_local_features_dump(level, frm);
2387 return;
2388 case OCF_READ_LOCAL_EXT_FEATURES:
2389 read_local_ext_features_dump(level, frm);
2390 return;
2391 case OCF_READ_BUFFER_SIZE:
2392 read_buffer_size_dump(level, frm);
2393 return;
2394 case OCF_READ_BD_ADDR:
2395 bdaddr_response_dump(level, frm);
2396 return;
2397 }
2398 break;
2399
2400 case OGF_STATUS_PARAM:
2401 switch (ocf) {
2402 case OCF_READ_FAILED_CONTACT_COUNTER:
2403 case OCF_RESET_FAILED_CONTACT_COUNTER:
2404 status_response_dump(level, frm);
2405 return;
2406 case OCF_READ_LINK_QUALITY:
2407 read_link_quality_dump(level, frm);
2408 return;
2409 case OCF_READ_RSSI:
2410 read_rssi_dump(level, frm);
2411 return;
2412 case OCF_READ_AFH_MAP:
2413 read_afh_map_dump(level, frm);
2414 return;
2415 case OCF_READ_CLOCK:
2416 read_clock_dump(level, frm);
2417 return;
2418 }
2419 break;
2420
2421 case OGF_TESTING_CMD:
2422 switch (ocf) {
2423 case OCF_READ_LOOPBACK_MODE:
2424 status_mode_dump(level, frm);
2425 return;
2426 case OCF_WRITE_LOOPBACK_MODE:
2427 case OCF_ENABLE_DEVICE_UNDER_TEST_MODE:
2428 case OCF_WRITE_SIMPLE_PAIRING_DEBUG_MODE:
2429 status_response_dump(level, frm);
2430 return;
2431 }
2432 break;
2433 }
2434
2435 raw_dump(level, frm);
2436 }
2437
cmd_status_dump(int level,struct frame * frm)2438 static inline void cmd_status_dump(int level, struct frame *frm)
2439 {
2440 evt_cmd_status *evt = frm->ptr;
2441 uint16_t opcode = btohs(evt->opcode);
2442 uint16_t ogf = cmd_opcode_ogf(opcode);
2443 uint16_t ocf = cmd_opcode_ocf(opcode);
2444
2445 if (ogf == OGF_VENDOR_CMD && (parser.flags & DUMP_NOVENDOR))
2446 return;
2447
2448 p_indent(level, frm);
2449 printf("%s (0x%2.2x|0x%4.4x) status 0x%2.2x ncmd %d\n",
2450 opcode2str(opcode), ogf, ocf, evt->status, evt->ncmd);
2451
2452 if (evt->status > 0) {
2453 p_indent(level, frm);
2454 printf("Error: %s\n", status2str(evt->status));
2455 }
2456 }
2457
hardware_error_dump(int level,struct frame * frm)2458 static inline void hardware_error_dump(int level, struct frame *frm)
2459 {
2460 evt_hardware_error *evt = frm->ptr;
2461
2462 p_indent(level, frm);
2463 printf("code %d\n", evt->code);
2464 }
2465
inq_result_dump(int level,struct frame * frm)2466 static inline void inq_result_dump(int level, struct frame *frm)
2467 {
2468 uint8_t num = get_u8(frm);
2469 char addr[18];
2470 int i;
2471
2472 for (i = 0; i < num; i++) {
2473 inquiry_info *info = frm->ptr;
2474
2475 p_ba2str(&info->bdaddr, addr);
2476
2477 p_indent(level, frm);
2478 printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x\n",
2479 addr, info->pscan_rep_mode, btohs(info->clock_offset),
2480 info->dev_class[2], info->dev_class[1], info->dev_class[0]);
2481
2482 frm->ptr += INQUIRY_INFO_SIZE;
2483 frm->len -= INQUIRY_INFO_SIZE;
2484 }
2485 }
2486
conn_complete_dump(int level,struct frame * frm)2487 static inline void conn_complete_dump(int level, struct frame *frm)
2488 {
2489 evt_conn_complete *evt = frm->ptr;
2490 char addr[18];
2491
2492 p_ba2str(&evt->bdaddr, addr);
2493
2494 p_indent(level, frm);
2495 printf("status 0x%2.2x handle %d bdaddr %s type %s encrypt 0x%2.2x\n",
2496 evt->status, btohs(evt->handle), addr,
2497 linktype2str(evt->link_type), evt->encr_mode);
2498
2499 if (evt->status > 0) {
2500 p_indent(level, frm);
2501 printf("Error: %s\n", status2str(evt->status));
2502 }
2503 }
2504
conn_request_dump(int level,struct frame * frm)2505 static inline void conn_request_dump(int level, struct frame *frm)
2506 {
2507 evt_conn_request *evt = frm->ptr;
2508 char addr[18];
2509
2510 p_ba2str(&evt->bdaddr, addr);
2511
2512 p_indent(level, frm);
2513 printf("bdaddr %s class 0x%2.2x%2.2x%2.2x type %s\n",
2514 addr, evt->dev_class[2], evt->dev_class[1],
2515 evt->dev_class[0], linktype2str(evt->link_type));
2516 }
2517
disconn_complete_dump(int level,struct frame * frm)2518 static inline void disconn_complete_dump(int level, struct frame *frm)
2519 {
2520 evt_disconn_complete *evt = frm->ptr;
2521
2522 p_indent(level, frm);
2523 printf("status 0x%2.2x handle %d reason 0x%2.2x\n",
2524 evt->status, btohs(evt->handle), evt->reason);
2525
2526 if (evt->status > 0) {
2527 p_indent(level, frm);
2528 printf("Error: %s\n", status2str(evt->status));
2529 } else if (evt->reason > 0) {
2530 p_indent(level, frm);
2531 printf("Reason: %s\n", status2str(evt->reason));
2532 }
2533 }
2534
remote_name_req_complete_dump(int level,struct frame * frm)2535 static inline void remote_name_req_complete_dump(int level, struct frame *frm)
2536 {
2537 evt_remote_name_req_complete *evt = frm->ptr;
2538 char addr[18], name[249];
2539 int i;
2540
2541 p_ba2str(&evt->bdaddr, addr);
2542
2543 memset(name, 0, sizeof(name));
2544 for (i = 0; i < 248 && evt->name[i]; i++)
2545 if (isprint(evt->name[i]))
2546 name[i] = evt->name[i];
2547 else
2548 name[i] = '.';
2549
2550 p_indent(level, frm);
2551 printf("status 0x%2.2x bdaddr %s name '%s'\n", evt->status, addr, name);
2552
2553 if (evt->status > 0) {
2554 p_indent(level, frm);
2555 printf("Error: %s\n", status2str(evt->status));
2556 }
2557 }
2558
master_link_key_complete_dump(int level,struct frame * frm)2559 static inline void master_link_key_complete_dump(int level, struct frame *frm)
2560 {
2561 evt_master_link_key_complete *evt = frm->ptr;
2562
2563 p_indent(level, frm);
2564 printf("status 0x%2.2x handle %d flag %d\n",
2565 evt->status, btohs(evt->handle), evt->key_flag);
2566
2567 if (evt->status > 0) {
2568 p_indent(level, frm);
2569 printf("Error: %s\n", status2str(evt->status));
2570 }
2571 }
2572
encrypt_change_dump(int level,struct frame * frm)2573 static inline void encrypt_change_dump(int level, struct frame *frm)
2574 {
2575 evt_encrypt_change *evt = frm->ptr;
2576
2577 p_indent(level, frm);
2578 printf("status 0x%2.2x handle %d encrypt 0x%2.2x\n",
2579 evt->status, btohs(evt->handle), evt->encrypt);
2580
2581 if (evt->status > 0) {
2582 p_indent(level, frm);
2583 printf("Error: %s\n", status2str(evt->status));
2584 }
2585 }
2586
read_remote_features_complete_dump(int level,struct frame * frm)2587 static inline void read_remote_features_complete_dump(int level, struct frame *frm)
2588 {
2589 evt_read_remote_features_complete *evt = frm->ptr;
2590 int i;
2591
2592 p_indent(level, frm);
2593 printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
2594
2595 if (evt->status > 0) {
2596 p_indent(level, frm);
2597 printf("Error: %s\n", status2str(evt->status));
2598 } else {
2599 p_indent(level, frm);
2600 printf("Features:");
2601 for (i = 0; i < 8; i++)
2602 printf(" 0x%2.2x", evt->features[i]);
2603 printf("\n");
2604 }
2605 }
2606
read_remote_version_complete_dump(int level,struct frame * frm)2607 static inline void read_remote_version_complete_dump(int level, struct frame *frm)
2608 {
2609 evt_read_remote_version_complete *evt = frm->ptr;
2610 uint16_t manufacturer = btohs(evt->manufacturer);
2611
2612 p_indent(level, frm);
2613 printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
2614
2615 if (evt->status > 0) {
2616 p_indent(level, frm);
2617 printf("Error: %s\n", status2str(evt->status));
2618 } else {
2619 p_indent(level, frm);
2620 printf("LMP Version: %s (0x%x) LMP Subversion: 0x%x\n",
2621 lmp_vertostr(evt->lmp_ver), evt->lmp_ver,
2622 btohs(evt->lmp_subver));
2623 p_indent(level, frm);
2624 printf("Manufacturer: %s (%d)\n",
2625 bt_compidtostr(manufacturer), manufacturer);
2626 }
2627 }
2628
qos_setup_complete_dump(int level,struct frame * frm)2629 static inline void qos_setup_complete_dump(int level, struct frame *frm)
2630 {
2631 evt_qos_setup_complete *evt = frm->ptr;
2632
2633 p_indent(level, frm);
2634 printf("status 0x%2.2x handle %d flags %d\n",
2635 evt->status, btohs(evt->handle), evt->flags);
2636
2637 if (evt->status > 0) {
2638 p_indent(level, frm);
2639 printf("Error: %s\n", status2str(evt->status));
2640 } else {
2641 p_indent(level, frm);
2642 printf("Service type: %d\n", evt->qos.service_type);
2643 p_indent(level, frm);
2644 printf("Token rate: %d\n", btohl(evt->qos.token_rate));
2645 p_indent(level, frm);
2646 printf("Peak bandwith: %d\n", btohl(evt->qos.peak_bandwidth));
2647 p_indent(level, frm);
2648 printf("Latency: %d\n", btohl(evt->qos.latency));
2649 p_indent(level, frm);
2650 printf("Delay variation: %d\n", btohl(evt->qos.delay_variation));
2651 }
2652 }
2653
role_change_dump(int level,struct frame * frm)2654 static inline void role_change_dump(int level, struct frame *frm)
2655 {
2656 evt_role_change *evt = frm->ptr;
2657 char addr[18];
2658
2659 p_indent(level, frm);
2660 p_ba2str(&evt->bdaddr, addr);
2661 printf("status 0x%2.2x bdaddr %s role 0x%2.2x\n",
2662 evt->status, addr, evt->role);
2663
2664 if (evt->status > 0) {
2665 p_indent(level, frm);
2666 printf("Error: %s\n", status2str(evt->status));
2667 } else {
2668 p_indent(level, frm);
2669 printf("Role: %s\n", role2str(evt->role));
2670 }
2671 }
2672
mode_change_dump(int level,struct frame * frm)2673 static inline void mode_change_dump(int level, struct frame *frm)
2674 {
2675 evt_mode_change *evt = frm->ptr;
2676
2677 p_indent(level, frm);
2678 printf("status 0x%2.2x handle %d mode 0x%2.2x interval %d\n",
2679 evt->status, btohs(evt->handle), evt->mode, btohs(evt->interval));
2680
2681 if (evt->status > 0) {
2682 p_indent(level, frm);
2683 printf("Error: %s\n", status2str(evt->status));
2684 } else {
2685 p_indent(level, frm);
2686 printf("Mode: %s\n", mode2str(evt->mode));
2687 }
2688 }
2689
pin_code_req_dump(int level,struct frame * frm)2690 static inline void pin_code_req_dump(int level, struct frame *frm)
2691 {
2692 evt_pin_code_req *evt = frm->ptr;
2693 char addr[18];
2694
2695 p_indent(level, frm);
2696 p_ba2str(&evt->bdaddr, addr);
2697 printf("bdaddr %s\n", addr);
2698 }
2699
link_key_notify_dump(int level,struct frame * frm)2700 static inline void link_key_notify_dump(int level, struct frame *frm)
2701 {
2702 evt_link_key_notify *evt = frm->ptr;
2703 char addr[18];
2704 int i;
2705
2706 p_indent(level, frm);
2707 p_ba2str(&evt->bdaddr, addr);
2708 printf("bdaddr %s key ", addr);
2709 for (i = 0; i < 16; i++)
2710 if (parser.flags & DUMP_NOVENDOR)
2711 printf("**");
2712 else
2713 printf("%2.2X", evt->link_key[i]);
2714 printf(" type %d\n", evt->key_type);
2715
2716 p_indent(level, frm);
2717 printf("Type: %s\n", keytype2str(evt->key_type));
2718 }
2719
max_slots_change_dump(int level,struct frame * frm)2720 static inline void max_slots_change_dump(int level, struct frame *frm)
2721 {
2722 evt_max_slots_change *evt = frm->ptr;
2723
2724 p_indent(level, frm);
2725 printf("handle %d slots %d\n", btohs(evt->handle), evt->max_slots);
2726 }
2727
data_buffer_overflow_dump(int level,struct frame * frm)2728 static inline void data_buffer_overflow_dump(int level, struct frame *frm)
2729 {
2730 evt_data_buffer_overflow *evt = frm->ptr;
2731
2732 p_indent(level, frm);
2733 printf("type %s\n", linktype2str(evt->link_type));
2734 }
2735
read_clock_offset_complete_dump(int level,struct frame * frm)2736 static inline void read_clock_offset_complete_dump(int level, struct frame *frm)
2737 {
2738 evt_read_clock_offset_complete *evt = frm->ptr;
2739
2740 p_indent(level, frm);
2741 printf("status 0x%2.2x handle %d clkoffset 0x%4.4x\n",
2742 evt->status, btohs(evt->handle), btohs(evt->clock_offset));
2743
2744 if (evt->status > 0) {
2745 p_indent(level, frm);
2746 printf("Error: %s\n", status2str(evt->status));
2747 }
2748 }
2749
conn_ptype_changed_dump(int level,struct frame * frm)2750 static inline void conn_ptype_changed_dump(int level, struct frame *frm)
2751 {
2752 evt_conn_ptype_changed *evt = frm->ptr;
2753 uint16_t ptype = btohs(evt->ptype);
2754 char *str;
2755
2756 p_indent(level, frm);
2757 printf("status 0x%2.2x handle %d ptype 0x%4.4x\n",
2758 evt->status, btohs(evt->handle), ptype);
2759
2760 if (evt->status > 0) {
2761 p_indent(level, frm);
2762 printf("Error: %s\n", status2str(evt->status));
2763 } else {
2764 str = hci_ptypetostr(ptype);
2765 if (str) {
2766 p_indent(level, frm);
2767 printf("Packet type: %s\n", str);
2768 free(str);
2769 }
2770 }
2771 }
2772
pscan_rep_mode_change_dump(int level,struct frame * frm)2773 static inline void pscan_rep_mode_change_dump(int level, struct frame *frm)
2774 {
2775 evt_pscan_rep_mode_change *evt = frm->ptr;
2776 char addr[18];
2777
2778 p_indent(level, frm);
2779 p_ba2str(&evt->bdaddr, addr);
2780 printf("bdaddr %s mode %d\n", addr, evt->pscan_rep_mode);
2781 }
2782
flow_spec_complete_dump(int level,struct frame * frm)2783 static inline void flow_spec_complete_dump(int level, struct frame *frm)
2784 {
2785 evt_flow_spec_complete *evt = frm->ptr;
2786
2787 p_indent(level, frm);
2788 printf("status 0x%2.2x handle %d flags %d %s\n",
2789 evt->status, btohs(evt->handle), evt->flags,
2790 evt->direction == 0 ? "outgoing" : "incoming");
2791
2792 if (evt->status > 0) {
2793 p_indent(level, frm);
2794 printf("Error: %s\n", status2str(evt->status));
2795 } else {
2796 p_indent(level, frm);
2797 printf("Service type: %d\n", evt->qos.service_type);
2798 p_indent(level, frm);
2799 printf("Token rate: %d\n", btohl(evt->qos.token_rate));
2800 p_indent(level, frm);
2801 printf("Peak bandwith: %d\n", btohl(evt->qos.peak_bandwidth));
2802 p_indent(level, frm);
2803 printf("Latency: %d\n", btohl(evt->qos.latency));
2804 p_indent(level, frm);
2805 printf("Delay variation: %d\n", btohl(evt->qos.delay_variation));
2806 }
2807 }
2808
inq_result_with_rssi_dump(int level,struct frame * frm)2809 static inline void inq_result_with_rssi_dump(int level, struct frame *frm)
2810 {
2811 uint8_t num = get_u8(frm);
2812 char addr[18];
2813 int i;
2814
2815 if (!num)
2816 return;
2817
2818 if (frm->len / num == INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE) {
2819 for (i = 0; i < num; i++) {
2820 inquiry_info_with_rssi_and_pscan_mode *info = frm->ptr;
2821
2822 p_indent(level, frm);
2823
2824 p_ba2str(&info->bdaddr, addr);
2825 printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x rssi %d\n",
2826 addr, info->pscan_rep_mode, btohs(info->clock_offset),
2827 info->dev_class[2], info->dev_class[1], info->dev_class[0], info->rssi);
2828
2829 frm->ptr += INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE;
2830 frm->len -= INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE;
2831 }
2832 } else {
2833 for (i = 0; i < num; i++) {
2834 inquiry_info_with_rssi *info = frm->ptr;
2835
2836 p_indent(level, frm);
2837
2838 p_ba2str(&info->bdaddr, addr);
2839 printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x rssi %d\n",
2840 addr, info->pscan_rep_mode, btohs(info->clock_offset),
2841 info->dev_class[2], info->dev_class[1], info->dev_class[0], info->rssi);
2842
2843 frm->ptr += INQUIRY_INFO_WITH_RSSI_SIZE;
2844 frm->len -= INQUIRY_INFO_WITH_RSSI_SIZE;
2845 }
2846 }
2847 }
2848
read_remote_ext_features_complete_dump(int level,struct frame * frm)2849 static inline void read_remote_ext_features_complete_dump(int level, struct frame *frm)
2850 {
2851 evt_read_remote_ext_features_complete *evt = frm->ptr;
2852 int i;
2853
2854 p_indent(level, frm);
2855 printf("status 0x%2.2x handle %d page %d max %d\n",
2856 evt->status, btohs(evt->handle),
2857 evt->page_num, evt->max_page_num);
2858
2859 if (evt->status > 0) {
2860 p_indent(level, frm);
2861 printf("Error: %s\n", status2str(evt->status));
2862 } else {
2863 p_indent(level, frm);
2864 printf("Features:");
2865 for (i = 0; i < 8; i++)
2866 printf(" 0x%2.2x", evt->features[i]);
2867 printf("\n");
2868 }
2869 }
2870
sync_conn_complete_dump(int level,struct frame * frm)2871 static inline void sync_conn_complete_dump(int level, struct frame *frm)
2872 {
2873 evt_sync_conn_complete *evt = frm->ptr;
2874 char addr[18];
2875
2876 p_ba2str(&evt->bdaddr, addr);
2877
2878 p_indent(level, frm);
2879 printf("status 0x%2.2x handle %d bdaddr %s type %s\n",
2880 evt->status, btohs(evt->handle), addr,
2881 evt->link_type == 0 ? "SCO" : "eSCO");
2882
2883 if (evt->status > 0) {
2884 p_indent(level, frm);
2885 printf("Error: %s\n", status2str(evt->status));
2886 } else {
2887 p_indent(level, frm);
2888 printf("Air mode: %s\n", airmode2str(evt->air_mode));
2889 }
2890 }
2891
sync_conn_changed_dump(int level,struct frame * frm)2892 static inline void sync_conn_changed_dump(int level, struct frame *frm)
2893 {
2894 evt_sync_conn_changed *evt = frm->ptr;
2895
2896 p_indent(level, frm);
2897 printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
2898
2899 if (evt->status > 0) {
2900 p_indent(level, frm);
2901 printf("Error: %s\n", status2str(evt->status));
2902 }
2903 }
2904
sniff_subrating_event_dump(int level,struct frame * frm)2905 static inline void sniff_subrating_event_dump(int level, struct frame *frm)
2906 {
2907 evt_sniff_subrating *evt = frm->ptr;
2908
2909 p_indent(level, frm);
2910 printf("status 0x%2.2x handle %d\n", evt->status, btohs(evt->handle));
2911
2912 if (evt->status > 0) {
2913 p_indent(level, frm);
2914 printf("Error: %s\n", status2str(evt->status));
2915 } else {
2916 p_indent(level, frm);
2917 printf("max latency transmit %d receive %d\n",
2918 btohs(evt->max_tx_latency),
2919 btohs(evt->max_rx_latency));
2920
2921 p_indent(level, frm);
2922 printf("min timeout remote %d local %d\n",
2923 btohs(evt->min_remote_timeout),
2924 btohs(evt->min_local_timeout));
2925 }
2926 }
2927
extended_inq_result_dump(int level,struct frame * frm)2928 static inline void extended_inq_result_dump(int level, struct frame *frm)
2929 {
2930 uint8_t num = get_u8(frm);
2931 char addr[18];
2932 int i;
2933
2934 for (i = 0; i < num; i++) {
2935 extended_inquiry_info *info = frm->ptr;
2936
2937 p_ba2str(&info->bdaddr, addr);
2938
2939 p_indent(level, frm);
2940 printf("bdaddr %s mode %d clkoffset 0x%4.4x class 0x%2.2x%2.2x%2.2x rssi %d\n",
2941 addr, info->pscan_rep_mode, btohs(info->clock_offset),
2942 info->dev_class[2], info->dev_class[1], info->dev_class[0], info->rssi);
2943
2944 frm->ptr += INQUIRY_INFO_WITH_RSSI_SIZE;
2945 frm->len -= INQUIRY_INFO_WITH_RSSI_SIZE;
2946
2947 ext_inquiry_response_dump(level, frm);
2948 }
2949 }
2950
link_supervision_timeout_changed_dump(int level,struct frame * frm)2951 static inline void link_supervision_timeout_changed_dump(int level, struct frame *frm)
2952 {
2953 evt_link_supervision_timeout_changed *evt = frm->ptr;
2954
2955 p_indent(level, frm);
2956 printf("handle %d timeout %d\n",
2957 btohs(evt->handle), btohs(evt->timeout));
2958 }
2959
user_passkey_notify_dump(int level,struct frame * frm)2960 static inline void user_passkey_notify_dump(int level, struct frame *frm)
2961 {
2962 evt_user_passkey_notify *evt = frm->ptr;
2963 char addr[18];
2964
2965 p_indent(level, frm);
2966 p_ba2str(&evt->bdaddr, addr);
2967 printf("bdaddr %s passkey %d\n", addr, btohl(evt->passkey));
2968 }
2969
keypress_notify_dump(int level,struct frame * frm)2970 static inline void keypress_notify_dump(int level, struct frame *frm)
2971 {
2972 evt_keypress_notify *evt = frm->ptr;
2973 char addr[18];
2974
2975 p_indent(level, frm);
2976 p_ba2str(&evt->bdaddr, addr);
2977 printf("bdaddr %s type %d\n", addr, evt->type);
2978 }
2979
remote_host_features_notify_dump(int level,struct frame * frm)2980 static inline void remote_host_features_notify_dump(int level, struct frame *frm)
2981 {
2982 evt_remote_host_features_notify *evt = frm->ptr;
2983 char addr[18];
2984 int i;
2985
2986 p_indent(level, frm);
2987 p_ba2str(&evt->bdaddr, addr);
2988 printf("bdaddr %s\n", addr);
2989
2990 p_indent(level, frm);
2991 printf("Features:");
2992 for (i = 0; i < 8; i++)
2993 printf(" 0x%2.2x", evt->features[i]);
2994 printf("\n");
2995 }
2996
event_dump(int level,struct frame * frm)2997 static inline void event_dump(int level, struct frame *frm)
2998 {
2999 hci_event_hdr *hdr = frm->ptr;
3000 uint8_t event = hdr->evt;
3001
3002 if (p_filter(FILT_HCI))
3003 return;
3004
3005 if (event <= EVENT_NUM) {
3006 p_indent(level, frm);
3007 printf("HCI Event: %s (0x%2.2x) plen %d\n",
3008 event_str[hdr->evt], hdr->evt, hdr->plen);
3009 } else if (hdr->evt == EVT_TESTING) {
3010 p_indent(level, frm);
3011 printf("HCI Event: Testing (0x%2.2x) plen %d\n", hdr->evt, hdr->plen);
3012 } else if (hdr->evt == EVT_VENDOR) {
3013 uint16_t manufacturer;
3014
3015 if (parser.flags & DUMP_NOVENDOR)
3016 return;
3017
3018 p_indent(level, frm);
3019 printf("HCI Event: Vendor (0x%2.2x) plen %d\n", hdr->evt, hdr->plen);
3020
3021 manufacturer = get_manufacturer();
3022
3023 switch (manufacturer) {
3024 case 0:
3025 case 37:
3026 case 48:
3027 frm->ptr += HCI_EVENT_HDR_SIZE;
3028 frm->len -= HCI_EVENT_HDR_SIZE;
3029 ericsson_dump(level + 1, frm);
3030 return;
3031 case 10:
3032 frm->ptr += HCI_EVENT_HDR_SIZE;
3033 frm->len -= HCI_EVENT_HDR_SIZE;
3034 csr_dump(level + 1, frm);
3035 return;
3036 }
3037 } else {
3038 p_indent(level, frm);
3039 printf("HCI Event: code 0x%2.2x plen %d\n", hdr->evt, hdr->plen);
3040 }
3041
3042 frm->ptr += HCI_EVENT_HDR_SIZE;
3043 frm->len -= HCI_EVENT_HDR_SIZE;
3044
3045 if (event == EVT_CMD_COMPLETE) {
3046 evt_cmd_complete *cc = frm->ptr;
3047 if (cc->opcode == cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_VERSION)) {
3048 read_local_version_rp *rp = frm->ptr + EVT_CMD_COMPLETE_SIZE;
3049 manufacturer = rp->manufacturer;
3050 }
3051 }
3052
3053 if (event == EVT_DISCONN_COMPLETE) {
3054 evt_disconn_complete *evt = frm->ptr;
3055 l2cap_clear(btohs(evt->handle));
3056 }
3057
3058 if (!(parser.flags & DUMP_VERBOSE)) {
3059 raw_dump(level, frm);
3060 return;
3061 }
3062
3063 switch (event) {
3064 case EVT_LOOPBACK_COMMAND:
3065 command_dump(level + 1, frm);
3066 break;
3067 case EVT_CMD_COMPLETE:
3068 cmd_complete_dump(level + 1, frm);
3069 break;
3070 case EVT_CMD_STATUS:
3071 cmd_status_dump(level + 1, frm);
3072 break;
3073 case EVT_HARDWARE_ERROR:
3074 hardware_error_dump(level + 1, frm);
3075 break;
3076 case EVT_FLUSH_OCCURRED:
3077 case EVT_QOS_VIOLATION:
3078 handle_response_dump(level + 1, frm);
3079 break;
3080 case EVT_INQUIRY_COMPLETE:
3081 status_response_dump(level + 1, frm);
3082 break;
3083 case EVT_INQUIRY_RESULT:
3084 inq_result_dump(level + 1, frm);
3085 break;
3086 case EVT_CONN_COMPLETE:
3087 conn_complete_dump(level + 1, frm);
3088 break;
3089 case EVT_CONN_REQUEST:
3090 conn_request_dump(level + 1, frm);
3091 break;
3092 case EVT_DISCONN_COMPLETE:
3093 disconn_complete_dump(level + 1, frm);
3094 break;
3095 case EVT_AUTH_COMPLETE:
3096 case EVT_CHANGE_CONN_LINK_KEY_COMPLETE:
3097 generic_response_dump(level + 1, frm);
3098 break;
3099 case EVT_MASTER_LINK_KEY_COMPLETE:
3100 master_link_key_complete_dump(level + 1, frm);
3101 break;
3102 case EVT_REMOTE_NAME_REQ_COMPLETE:
3103 remote_name_req_complete_dump(level + 1, frm);
3104 break;
3105 case EVT_ENCRYPT_CHANGE:
3106 encrypt_change_dump(level + 1, frm);
3107 break;
3108 case EVT_READ_REMOTE_FEATURES_COMPLETE:
3109 read_remote_features_complete_dump(level + 1, frm);
3110 break;
3111 case EVT_READ_REMOTE_VERSION_COMPLETE:
3112 read_remote_version_complete_dump(level + 1, frm);
3113 break;
3114 case EVT_QOS_SETUP_COMPLETE:
3115 qos_setup_complete_dump(level + 1, frm);
3116 break;
3117 case EVT_ROLE_CHANGE:
3118 role_change_dump(level + 1, frm);
3119 break;
3120 case EVT_NUM_COMP_PKTS:
3121 num_comp_pkts_dump(level + 1, frm);
3122 break;
3123 case EVT_MODE_CHANGE:
3124 mode_change_dump(level + 1, frm);
3125 break;
3126 case EVT_RETURN_LINK_KEYS:
3127 return_link_keys_dump(level + 1, frm);
3128 break;
3129 case EVT_PIN_CODE_REQ:
3130 case EVT_LINK_KEY_REQ:
3131 case EVT_IO_CAPABILITY_REQUEST:
3132 case EVT_USER_PASSKEY_REQUEST:
3133 case EVT_REMOTE_OOB_DATA_REQUEST:
3134 pin_code_req_dump(level + 1, frm);
3135 break;
3136 case EVT_LINK_KEY_NOTIFY:
3137 link_key_notify_dump(level + 1, frm);
3138 break;
3139 case EVT_DATA_BUFFER_OVERFLOW:
3140 data_buffer_overflow_dump(level + 1, frm);
3141 break;
3142 case EVT_MAX_SLOTS_CHANGE:
3143 max_slots_change_dump(level + 1, frm);
3144 break;
3145 case EVT_READ_CLOCK_OFFSET_COMPLETE:
3146 read_clock_offset_complete_dump(level + 1, frm);
3147 break;
3148 case EVT_CONN_PTYPE_CHANGED:
3149 conn_ptype_changed_dump(level + 1, frm);
3150 break;
3151 case EVT_PSCAN_REP_MODE_CHANGE:
3152 pscan_rep_mode_change_dump(level + 1, frm);
3153 break;
3154 case EVT_FLOW_SPEC_COMPLETE:
3155 flow_spec_complete_dump(level + 1, frm);
3156 break;
3157 case EVT_INQUIRY_RESULT_WITH_RSSI:
3158 inq_result_with_rssi_dump(level + 1, frm);
3159 break;
3160 case EVT_READ_REMOTE_EXT_FEATURES_COMPLETE:
3161 read_remote_ext_features_complete_dump(level + 1, frm);
3162 break;
3163 case EVT_SYNC_CONN_COMPLETE:
3164 sync_conn_complete_dump(level + 1, frm);
3165 break;
3166 case EVT_SYNC_CONN_CHANGED:
3167 sync_conn_changed_dump(level + 1, frm);
3168 break;
3169 case EVT_SNIFF_SUBRATING:
3170 sniff_subrating_event_dump(level + 1, frm);
3171 break;
3172 case EVT_EXTENDED_INQUIRY_RESULT:
3173 extended_inq_result_dump(level + 1, frm);
3174 break;
3175 case EVT_ENCRYPTION_KEY_REFRESH_COMPLETE:
3176 generic_response_dump(level + 1, frm);
3177 break;
3178 case EVT_SIMPLE_PAIRING_COMPLETE:
3179 bdaddr_response_dump(level + 1, frm);
3180 break;
3181 case EVT_LINK_SUPERVISION_TIMEOUT_CHANGED:
3182 link_supervision_timeout_changed_dump(level + 1, frm);
3183 break;
3184 case EVT_ENHANCED_FLUSH_COMPLETE:
3185 generic_command_dump(level + 1, frm);
3186 break;
3187 case EVT_IO_CAPABILITY_RESPONSE:
3188 io_capability_reply_dump(level + 1, frm);
3189 break;
3190 case EVT_USER_CONFIRM_REQUEST:
3191 case EVT_USER_PASSKEY_NOTIFY:
3192 user_passkey_notify_dump(level + 1, frm);
3193 break;
3194 case EVT_KEYPRESS_NOTIFY:
3195 keypress_notify_dump(level + 1, frm);
3196 break;
3197 case EVT_REMOTE_HOST_FEATURES_NOTIFY:
3198 remote_host_features_notify_dump(level + 1, frm);
3199 break;
3200 default:
3201 raw_dump(level, frm);
3202 break;
3203 }
3204 }
3205
acl_dump(int level,struct frame * frm)3206 static inline void acl_dump(int level, struct frame *frm)
3207 {
3208 hci_acl_hdr *hdr = (void *) frm->ptr;
3209 uint16_t handle = btohs(hdr->handle);
3210 uint16_t dlen = btohs(hdr->dlen);
3211 uint8_t flags = acl_flags(handle);
3212
3213 if (!p_filter(FILT_HCI)) {
3214 p_indent(level, frm);
3215 printf("ACL data: handle %d flags 0x%2.2x dlen %d\n",
3216 acl_handle(handle), flags, dlen);
3217 level++;
3218 }
3219
3220 frm->ptr += HCI_ACL_HDR_SIZE;
3221 frm->len -= HCI_ACL_HDR_SIZE;
3222 frm->flags = flags;
3223 frm->handle = acl_handle(handle);
3224
3225 if (parser.filter & ~FILT_HCI)
3226 l2cap_dump(level, frm);
3227 else
3228 raw_dump(level, frm);
3229 }
3230
sco_dump(int level,struct frame * frm)3231 static inline void sco_dump(int level, struct frame *frm)
3232 {
3233 hci_sco_hdr *hdr = (void *) frm->ptr;
3234 uint16_t handle = btohs(hdr->handle);
3235 uint8_t flags = acl_flags(handle);
3236 int len;
3237
3238 if (frm->audio_fd > fileno(stderr))
3239 len = write(frm->audio_fd, frm->ptr + HCI_SCO_HDR_SIZE, hdr->dlen);
3240
3241 if (!p_filter(FILT_SCO)) {
3242 p_indent(level, frm);
3243 printf("SCO data: handle %d flags 0x%2.2x dlen %d\n",
3244 acl_handle(handle), flags, hdr->dlen);
3245 level++;
3246
3247 frm->ptr += HCI_SCO_HDR_SIZE;
3248 frm->len -= HCI_SCO_HDR_SIZE;
3249 raw_dump(level, frm);
3250 }
3251 }
3252
vendor_dump(int level,struct frame * frm)3253 static inline void vendor_dump(int level, struct frame *frm)
3254 {
3255 if (p_filter(FILT_HCI))
3256 return;
3257
3258 if (frm->dev_id == HCI_DEV_NONE) {
3259 uint16_t device = btohs(htons(get_u16(frm)));
3260 uint16_t proto = btohs(htons(get_u16(frm)));
3261 uint16_t type = btohs(htons(get_u16(frm)));
3262 uint16_t plen = btohs(htons(get_u16(frm)));
3263
3264 p_indent(level, frm);
3265
3266 printf("System %s: device hci%d proto 0x%2.2x type 0x%2.2x plen %d\n",
3267 frm->in ? "event" : "command", device, proto, type, plen);
3268
3269 raw_dump(level, frm);
3270 return;
3271 }
3272
3273 if (parser.flags & DUMP_NOVENDOR)
3274 return;
3275
3276 if (get_manufacturer() == 12) {
3277 bpa_dump(level, frm);
3278 return;
3279 }
3280
3281 p_indent(level, frm);
3282 printf("Vendor data: len %d\n", frm->len);
3283 raw_dump(level, frm);
3284 }
3285
hci_dump(int level,struct frame * frm)3286 void hci_dump(int level, struct frame *frm)
3287 {
3288 uint8_t type = *(uint8_t *)frm->ptr;
3289
3290 frm->ptr++; frm->len--;
3291
3292 switch (type) {
3293 case HCI_COMMAND_PKT:
3294 command_dump(level, frm);
3295 break;
3296
3297 case HCI_EVENT_PKT:
3298 event_dump(level, frm);
3299 break;
3300
3301 case HCI_ACLDATA_PKT:
3302 acl_dump(level, frm);
3303 break;
3304
3305 case HCI_SCODATA_PKT:
3306 sco_dump(level, frm);
3307 break;
3308
3309 case HCI_VENDOR_PKT:
3310 vendor_dump(level, frm);
3311 break;
3312
3313 default:
3314 if (p_filter(FILT_HCI))
3315 break;
3316
3317 p_indent(level, frm);
3318 printf("Unknown: type 0x%2.2x len %d\n", type, frm->len);
3319 raw_dump(level, frm);
3320 break;
3321 }
3322 }
3323