static void cmd_facility(int level, uint8_t subcmd, struct frame *frm)
{
uint16_t sel;
cmd_common(level, subcmd, frm);
sel = CAPI_U16(frm);
CAPI_U8(frm);
p_indent(level, frm);
printf("Selector: 0x%04x (%s)\n", sel, facilitysel2str(sel));
raw_dump(level, frm);
}
/* Process SLIP line input */
void
slip_rx(
struct iface *iface)
{
int c;
struct mbuf *bp;
register struct slip *sp;
int cdev;
uint8 *cp;
uint8 buf[4096];
int cnt;
int xdev;
xdev = iface->xdev;
sp = &Slip[xdev];
cdev = sp->iface->dev;
cnt = (*sp->get)(cdev,cp=buf,sizeof(buf));
while(--cnt >= 0){
if((bp = slip_decode(sp,*cp++)) == NULL)
continue; /* More to come */
if (sp->iface->trace & IF_TRACE_RAW)
raw_dump(sp->iface,IF_TRACE_IN,bp);
if(sp->slcomp){
if ((c = bp->data[0]) & SL_TYPE_COMPRESSED_TCP) {
if ( slhc_uncompress(sp->slcomp, &bp) <= 0 ) {
free_p(&bp);
sp->errors++;
continue;
}
} else if (c >= SL_TYPE_UNCOMPRESSED_TCP) {
bp->data[0] &= 0x4f;
if ( slhc_remember(sp->slcomp, &bp) <= 0 ) {
free_p(&bp);
sp->errors++;
continue;
}
}
}
net_route( sp->iface, &bp);
/* Especially on slow machines, serial I/O can be quite
* compute intensive, so release the machine before we
* do the next packet. This will allow this packet to
* go on toward its ultimate destination. [Karn]
*/
kwait(NULL);
}
}
static void avrcp_get_current_player_value_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len)
{
uint8_t num;
p_indent(level, frm);
if (len < 2) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
num = get_u8(frm);
printf("AttributeCount: 0x%02x\n", num);
for (; num > 0; num--) {
uint8_t attr;
p_indent(level, frm);
attr = get_u8(frm);
printf("AttributeID: 0x%02x (%s)\n", attr, attr2str(attr));
}
return;
response:
num = get_u8(frm);
printf("ValueCount: 0x%02x\n", num);
for (; num > 0; num--) {
uint8_t attr, value;
p_indent(level, frm);
attr = get_u8(frm);
printf("AttributeID: 0x%02x (%s)\n", attr, attr2str(attr));
p_indent(level, frm);
value = get_u8(frm);
printf("ValueID: 0x%02x (%s)\n", value,
value2str(attr, value));
}
}
static void avrcp_rejected_dump(int level, struct frame *frm, uint16_t len)
{
uint8_t status;
p_indent(level, frm);
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
status = get_u8(frm);
printf("Error: 0x%02x (%s)\n", status, error2str(status));
}
static void avrcp_set_absolute_volume_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len)
{
uint8_t value;
p_indent(level, frm);
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
value = get_u8(frm) & 0x7F;
printf("Volume: %.2f%% (%d/127)\n", value/1.27, value);
}
void smp_dump(int level, struct frame *frm)
{
uint8_t cmd;
cmd = p_get_u8(frm);
p_indent(level, frm);
printf("SMP: %s (0x%.2x)\n", smpcmd2str(cmd), cmd);
switch (cmd) {
case SMP_CMD_PAIRING_REQ:
smp_cmd_pairing_dump(level + 1, frm);
break;
case SMP_CMD_PAIRING_RESP:
smp_cmd_pairing_dump(level + 1, frm);
break;
case SMP_CMD_PAIRING_CONFIRM:
smp_cmd_pairing_confirm_dump(level + 1, frm);
break;
case SMP_CMD_PAIRING_RANDOM:
smp_cmd_pairing_random_dump(level + 1, frm);
break;
case SMP_CMD_PAIRING_FAILED:
smp_cmd_pairing_failed_dump(level + 1, frm);
break;
case SMP_CMD_ENCRYPT_INFO:
smp_cmd_encrypt_info_dump(level + 1, frm);
break;
case SMP_CMD_MASTER_IDENT:
smp_cmd_master_ident_dump(level + 1, frm);
break;
case SMP_CMD_IDENT_INFO:
smp_cmd_ident_info_dump(level + 1, frm);
break;
case SMP_CMD_IDENT_ADDR_INFO:
smp_cmd_ident_addr_info_dump(level + 1, frm);
break;
case SMP_CMD_SIGN_INFO:
smp_cmd_sign_info_dump(level + 1, frm);
break;
case SMP_CMD_SECURITY_REQ:
smp_cmd_security_req_dump(level + 1, frm);
break;
default:
raw_dump(level, frm);
}
}
/* Send a raw slip frame */
int
slip_raw(
struct iface *iface,
struct mbuf **bpp
){
struct mbuf *bp1;
dump(iface,IF_TRACE_OUT,*bpp);
iface->rawsndcnt++;
iface->lastsent = secclock();
if((bp1 = slip_encode(bpp)) == NULL){
return -1;
}
if (iface->trace & IF_TRACE_RAW)
raw_dump(iface,-1,bp1);
return Slip[iface->xdev].send(iface->dev,&bp1);
}
static void avrcp_passthrough_dump(int level, struct frame *frm)
{
uint8_t op, len;
p_indent(level, frm);
op = get_u8(frm);
printf("Operation: 0x%02x (%s %s)\n", op, op2str(op),
op & 0x80 ? "Released" : "Pressed");
p_indent(level, frm);
len = get_u8(frm);
printf("Lenght: 0x%02x\n", len);
raw_dump(level, frm);
}
void bpa_dump(int level, struct frame *frm)
{
uint8_t id, status, channel;
uint16_t num, len;
uint32_t time;
id = get_u8(frm);
num = get_u16(frm);
len = BPA_U16(frm);
status = get_u8(frm);
time = get_u32(frm);
channel = get_u8(frm);
p_indent(level, frm);
printf("BPA: id %d num %d len %u status 0x%02x time %d channel %d\n",
id, num, len, status, time, channel);
raw_dump(level, frm);
}
void avctp_dump(int level, struct frame *frm, uint16_t psm)
{
uint8_t hdr;
uint16_t pid;
p_indent(level, frm);
hdr = get_u8(frm);
pid = get_u16(frm);
printf("AVCTP %s: %s %s: pt 0x%02x transaction %d pid 0x%04x\n",
psm == 23 ? "Control" : "Browsing",
hdr & 0x02 ? "Response" : "Command",
pt2str(hdr), hdr & 0x0c, hdr >> 4, pid);
if (pid == SDP_UUID_AV_REMOTE || pid == SDP_UUID_AV_REMOTE_TARGET)
avrcp_dump(level + 1, frm, hdr, psm);
else
raw_dump(level + 1, frm);
}
static void att_read_by_type_req_dump(int level, struct frame *frm)
{
uint16_t start = btohs(htons(get_u16(frm)));
uint16_t end = btohs(htons(get_u16(frm)));
p_indent(level, frm);
printf("start 0x%4.4x, end 0x%4.4x\n", start, end);
p_indent(level, frm);
if (frm->len == 2) {
printf("type-uuid 0x%4.4x\n", btohs(htons(get_u16(frm))));
} else if (frm->len == 16) {
printf("type-uuid ");
print_uuid128(frm);
printf("\n");
} else {
printf("malformed uuid (expected 2 or 16 octets)\n");
p_indent(level, frm);
raw_dump(level, frm);
}
}
static void cmd_data_b3(int level, uint8_t subcmd, struct frame *frm)
{
uint32_t data;
uint16_t length, handle, flags, info;
cmd_common(level, 0x00, frm);
if (subcmd == 0x81 || subcmd == 0x83) {
handle = CAPI_U16(frm);
p_indent(level, frm);
printf("Data handle: 0x%04x\n", handle);
if (subcmd == 0x81) {
info = CAPI_U16(frm);
p_indent(level, frm);
printf("Info: 0x%04x (%s)\n", info, info2str(info));
}
} else {
data = CAPI_U32(frm);
length = CAPI_U16(frm);
p_indent(level, frm);
printf("Data length: 0x%04x (%d bytes)\n", length, length);
handle = CAPI_U16(frm);
p_indent(level, frm);
printf("Data handle: 0x%04x\n", handle);
flags = CAPI_U16(frm);
p_indent(level, frm);
printf("Flags: 0x%04x\n", flags);
if (data == 0)
(void) get_u64(frm);
raw_dump(level, frm);
}
}
static void l2cap_parse(int level, struct frame *frm)
{
l2cap_hdr *hdr = (void *)frm->ptr;
uint16_t dlen = btohs(hdr->len);
uint16_t cid = btohs(hdr->cid);
uint16_t psm;
frm->ptr += L2CAP_HDR_SIZE;
frm->len -= L2CAP_HDR_SIZE;
if (cid == 0x1) {
/* Signaling channel */
while (frm->len >= L2CAP_CMD_HDR_SIZE) {
l2cap_cmd_hdr *hdr = frm->ptr;
frm->ptr += L2CAP_CMD_HDR_SIZE;
frm->len -= L2CAP_CMD_HDR_SIZE;
if (!p_filter(FILT_L2CAP)) {
p_indent(level, frm);
printf("L2CAP(s): ");
}
switch (hdr->code) {
case L2CAP_COMMAND_REJ:
command_rej(level, frm);
break;
case L2CAP_CONN_REQ:
conn_req(level, frm);
break;
case L2CAP_CONN_RSP:
conn_rsp(level, frm);
break;
case L2CAP_CONF_REQ:
conf_req(level, hdr, frm);
break;
case L2CAP_CONF_RSP:
conf_rsp(level, hdr, frm);
break;
case L2CAP_DISCONN_REQ:
disconn_req(level, frm);
break;
case L2CAP_DISCONN_RSP:
disconn_rsp(level, frm);
break;
case L2CAP_ECHO_REQ:
echo_req(level, hdr, frm);
break;
case L2CAP_ECHO_RSP:
echo_rsp(level, hdr, frm);
break;
case L2CAP_INFO_REQ:
info_req(level, hdr, frm);
break;
case L2CAP_INFO_RSP:
info_rsp(level, hdr, frm);
break;
default:
if (p_filter(FILT_L2CAP))
break;
printf("code 0x%2.2x ident %d len %d\n",
hdr->code, hdr->ident, btohs(hdr->len));
raw_dump(level, frm);
}
if (frm->len > btohs(hdr->len)) {
frm->len -= btohs(hdr->len);
frm->ptr += btohs(hdr->len);
} else
frm->len = 0;
}
} else if (cid == 0x2) {
/* Connectionless channel */
if (p_filter(FILT_L2CAP))
return;
psm = btohs(bt_get_unaligned((uint16_t *) frm->ptr));
frm->ptr += 2;
frm->len -= 2;
p_indent(level, frm);
printf("L2CAP(c): len %d psm %d\n", dlen, psm);
raw_dump(level, frm);
} else {
/* Connection oriented channel */
uint8_t mode = get_mode(!frm->in, cid);
uint16_t psm = get_psm(!frm->in, cid);
uint16_t ctrl = 0, fcs = 0;
uint32_t proto;
frm->cid = cid;
frm->num = get_num(!frm->in, cid);
if (mode > 0) {
ctrl = btohs(bt_get_unaligned((uint16_t *) frm->ptr));
frm->ptr += 2;
frm->len -= 4;
fcs = btohs(bt_get_unaligned((uint16_t *) (frm->ptr + frm->len)));
}
if (!p_filter(FILT_L2CAP)) {
p_indent(level, frm);
printf("L2CAP(d): cid 0x%4.4x len %d", cid, dlen);
if (mode > 0)
printf(" ctrl 0x%4.4x fcs 0x%4.4x", ctrl, fcs);
printf(" [psm %d]\n", psm);
level++;
if (mode > 0) {
p_indent(level, frm);
printf("%s:", ctrl & 0x01 ? "S-frame" : "I-frame");
if (ctrl & 0x01) {
printf(" %s", supervisory2str((ctrl & 0x0c) >> 2));
} else {
int main(int argc, char **argv)
{
struct bt_opts opts;
struct btproc *bt_proc;
bt_proc = parse_args(argc, argv, &opts);
bt_proc->pi->pi_debug = opts.debug_opt;
if (opts.target_opt && opts.pid_opt) {
bt_proc_destroy(bt_proc);
printfd(2,
FATAL " You can't choose target and pid together !\n");
btrace_banner(*argv, 1);
} else if (!opts.target_opt && !opts.pid_opt) {
printfd(2, FATAL "No such target or porcess\n");
btrace_banner(*argv, 1);
} else {
/* using target executable */
if (opts.target_opt) {
bt_proc->exec =
check_target_path(bt_proc->pi->pi_target,
bt_proc->pi->pi_perm);
if (!bt_proc->exec) {
bt_proc_destroy(bt_proc);
btrace_banner(*argv, 1);
}
if (opts.target_has_args)
bt_proc->args_parser((char *)bt_proc->pi->
pi_args, bt_proc);
else
bt_proc->proc_arguments[0] =
strdup((const char *)bt_proc->exec);
if ((!opts.force_addr_opt && opts.off_opt) ||
(opts.force_addr_opt && !opts.off_opt)) {
printfd(STDERR_FILENO,
WARN
"You may choose both of address and offset !\n");
bt_proc_destroy(bt_proc);
btrace_banner(*argv, 1);
}
/* if address & offset are set */
else {
bt_proc->pi->pi_stack->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_stack->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
bt_proc->pi->pi_addr->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_addr->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
}
exec_target(bt_proc);
/* If force address and offset are not set we read
* from profs and fetch memory base address
* and write new elf binary
*/
if (!opts.force_addr_opt && !opts.off_opt) {
printfd(2,
DO "Target :" GREEN " %s " NORM
" PID : " GREEN "%d" NORM "\n",
bt_proc->exec, bt_proc->pi->pi_pid);
if (read_procfs_maps(bt_proc->pi) == -1)
die("no such process");
}
fetch_data(bt_proc->pi);
}
/* pid attach */
if (opts.pid_opt) {
if (attach_process(bt_proc->pi) == -1)
die(FATAL "Can't attach process");
get_cmdline_by_pid(bt_proc->pi);
printfd(2,
DO "Attach PID:" GREEN " %d" NORM " Target :"
GREEN " %s" NORM "\n", bt_proc->pi->pi_pid,
bt_proc->pi->pi_perm->p_full_path);
if ((!opts.force_addr_opt && opts.off_opt) ||
(opts.force_addr_opt && !opts.off_opt)) {
printfd(STDERR_FILENO,
WARN
"You may choose both of address and offset !\n");
bt_proc_destroy(bt_proc);
btrace_banner(*argv, 1);
}
/* if address & offset are set */
else {
bt_proc->pi->pi_stack->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_stack->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
bt_proc->pi->pi_addr->ma_map[0] =
bt_proc->pi->pi_address;
bt_proc->pi->pi_addr->ma_map[1] =
bt_proc->pi->pi_address +
bt_proc->pi->pi_offset;
}
if (!opts.force_addr_opt && !opts.off_opt)
if (read_procfs_maps(bt_proc->pi) == -1)
die(FATAL "No such process");
/* it shouldn't return anything
* BACK TO ME
*/
fetch_data(bt_proc->pi);
}
if (opts.raw_opt)
raw_dump(bt_proc->pi);
else
dump_using_memory(bt_proc->pi);
if(opts.elf_dump_opts) {
}
pinfo_destroy(bt_proc->pi);
bt_proc_destroy(bt_proc);
}
return 0;
}
void Debugger::DebuggerImpl::dump_memory_as_array() {
auto stream = array_streams.get_next();
auto info = get_debug_memory_info();
raw_dump(*stream, *info.stack, *info.space);
}
static inline void bccmd_dump(int level, struct frame *frm)
{
uint16_t type, length, seqno, varid, status;
type = CSR_U16(frm);
length = CSR_U16(frm);
seqno = CSR_U16(frm);
varid = CSR_U16(frm);
status = CSR_U16(frm);
p_indent(level, frm);
printf("BCCMD: %s: len %d seqno %d varid 0x%4.4x status %d\n",
type2str(type), length, seqno, varid, status);
if (!(parser.flags & DUMP_VERBOSE)) {
raw_dump(level + 1, frm);
return;
}
switch (varid) {
case 0x000b:
valueless_dump(level + 1, "PS_CLR_ALL", frm);
break;
case 0x000c:
valueless_dump(level + 1, "PS_FACTORY_SET", frm);
break;
case 0x082d:
uint16_dump(level + 1, "PS_CLR_ALL_STORES", frm);
break;
case 0x2801:
uint16_dump(level + 1, "BC01_STATUS", frm);
break;
case 0x2819:
uint16_dump(level + 1, "BUILDID", frm);
break;
case 0x281a:
uint16_dump(level + 1, "CHIPVER", frm);
break;
case 0x281b:
uint16_dump(level + 1, "CHIPREV", frm);
break;
case 0x2825:
uint16_dump(level + 1, "INTERFACE_VERSION", frm);
break;
case 0x282a:
uint16_dump(level + 1, "RAND", frm);
break;
case 0x282c:
uint16_dump(level + 1, "MAX_CRYPT_KEY_LENGTH", frm);
break;
case 0x2833:
uint16_dump(level + 1, "E2_APP_SIZE", frm);
break;
case 0x2836:
uint16_dump(level + 1, "CHIPANAREV", frm);
break;
case 0x2838:
uint16_dump(level + 1, "BUILDID_LOADER", frm);
break;
case 0x2c00:
uint32_dump(level + 1, "BT_CLOCK", frm);
break;
case 0x3005:
psnext_dump(level + 1, "PS_NEXT", frm);
break;
case 0x3006:
pssize_dump(level + 1, "PS_SIZE", frm);
break;
case 0x3008:
handle_length_dump(level + 1, "CRYPT_KEY_LENGTH", frm);
break;
case 0x3009:
handle_clock_dump(level + 1, "PICONET_INSTANCE", frm);
break;
case 0x300a:
complex_dump(level + 1, "GET_CLR_EVT", frm);
break;
case 0x300b:
complex_dump(level + 1, "GET_NEXT_BUILDDEF", frm);
break;
case 0x300e:
complex_dump(level + 1, "E2_DEVICE", frm);
break;
case 0x300f:
complex_dump(level + 1, "E2_APP_DATA", frm);
break;
case 0x3012:
psmemtype_dump(level + 1, "PS_MEMORY_TYPE", frm);
break;
case 0x301c:
complex_dump(level + 1, "READ_BUILD_NAME", frm);
break;
case 0x4001:
valueless_dump(level + 1, "COLD_RESET", frm);
break;
case 0x4002:
valueless_dump(level + 1, "WARM_RESET", frm);
break;
case 0x4003:
valueless_dump(level + 1, "COLD_HALT", frm);
break;
case 0x4004:
valueless_dump(level + 1, "WARM_HALT", frm);
break;
case 0x4005:
valueless_dump(level + 1, "INIT_BT_STACK", frm);
break;
case 0x4006:
valueless_dump(level + 1, "ACTIVATE_BT_STACK", frm);
break;
case 0x4007:
valueless_dump(level + 1, "ENABLE_TX", frm);
break;
case 0x4008:
valueless_dump(level + 1, "DISABLE_TX", frm);
break;
case 0x4009:
valueless_dump(level + 1, "RECAL", frm);
break;
case 0x400d:
valueless_dump(level + 1, "PS_FACTORY_RESTORE", frm);
break;
case 0x400e:
valueless_dump(level + 1, "PS_FACTORY_RESTORE_ALL", frm);
break;
case 0x400f:
valueless_dump(level + 1, "PS_DEFRAG_RESET", frm);
break;
case 0x4011:
valueless_dump(level + 1, "HOPPING_ON", frm);
break;
case 0x4012:
valueless_dump(level + 1, "CANCEL_PAGE", frm);
break;
case 0x4818:
uint16_dump(level + 1, "PS_CLR", frm);
break;
case 0x481c:
uint16_dump(level + 1, "MAP_SCO_PCM", frm);
break;
case 0x482e:
uint16_dump(level + 1, "SINGLE_CHAN", frm);
break;
case 0x5004:
radiotest_dump(level + 1, "RADIOTEST", frm);
break;
case 0x500c:
psstores_dump(level + 1, "PS_CLR_STORES", frm);
break;
case 0x6000:
valueless_dump(level + 1, "NO_VARIABLE", frm);
break;
case 0x6802:
uint16_dump(level + 1, "CONFIG_UART", frm);
break;
case 0x6805:
uint16_dump(level + 1, "PANIC_ARG", frm);
break;
case 0x6806:
uint16_dump(level + 1, "FAULT_ARG", frm);
break;
case 0x6827:
int8_dump(level + 1, "MAX_TX_POWER", frm);
break;
case 0x682b:
int8_dump(level + 1, "DEFAULT_TX_POWER", frm);
break;
case 0x7003:
pskey_dump(level + 1, frm);
break;
default:
raw_dump(level + 1, frm);
break;
}
}
static void avrcp_pdu_dump(int level, struct frame *frm, uint8_t ctype)
{
uint8_t pduid, pt;
uint16_t len;
p_indent(level, frm);
pduid = get_u8(frm);
pt = get_u8(frm);
len = get_u16(frm);
printf("AVRCP: %s: pt %s len 0x%04x\n", pdu2str(pduid),
pt2str(pt), len);
if (len != frm->len) {
p_indent(level, frm);
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
if (ctype == AVC_CTYPE_REJECTED) {
avrcp_rejected_dump(level + 1, frm, len);
return;
}
switch (pduid) {
case AVRCP_GET_CAPABILITIES:
avrcp_get_capabilities_dump(level + 1, frm, len);
break;
case AVRCP_LIST_PLAYER_ATTRIBUTES:
avrcp_list_player_attributes_dump(level + 1, frm, len);
break;
case AVRCP_LIST_PLAYER_VALUES:
avrcp_list_player_values_dump(level + 1, frm, ctype, len);
break;
case AVRCP_GET_CURRENT_PLAYER_VALUE:
avrcp_get_current_player_value_dump(level + 1, frm, ctype,
len);
break;
case AVRCP_SET_PLAYER_VALUE:
avrcp_set_player_value_dump(level + 1, frm, ctype, len);
break;
case AVRCP_GET_PLAYER_ATTRIBUTE_TEXT:
avrcp_get_player_attribute_text_dump(level + 1, frm, ctype,
len);
break;
case AVRCP_GET_PLAYER_VALUE_TEXT:
avrcp_get_player_value_text_dump(level + 1, frm, ctype, len);
break;
case AVRCP_DISPLAYABLE_CHARSET:
avrcp_displayable_charset(level + 1, frm, ctype, len);
break;
case AVRCP_CT_BATTERY_STATUS:
avrcp_ct_battery_status_dump(level + 1, frm, ctype, len);
break;
case AVRCP_GET_ELEMENT_ATTRIBUTES:
avrcp_get_element_attributes_dump(level + 1, frm, ctype, len,
pt);
break;
case AVRCP_GET_PLAY_STATUS:
avrcp_get_play_status_dump(level + 1, frm, ctype, len);
break;
case AVRCP_REGISTER_NOTIFICATION:
avrcp_register_notification_dump(level + 1, frm, ctype, len);
break;
case AVRCP_SET_ABSOLUTE_VOLUME:
avrcp_set_absolute_volume_dump(level + 1, frm, ctype, len);
break;
case AVRCP_SET_ADDRESSED_PLAYER:
avrcp_set_addressed_player(level + 1, frm, ctype, len);
break;
case AVRCP_SET_BROWSED_PLAYER:
avrcp_set_browsed_player(level + 1, frm, ctype, len);
break;
default:
raw_dump(level, frm);
}
}
static void avrcp_set_browsed_player(int level, struct frame *frm,
uint8_t ctype, uint16_t len)
{
uint32_t items;
uint16_t id, uids, charset;
uint8_t status, folders;
p_indent(level, frm);
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
if (len < 2) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
id = get_u16(frm);
printf("PlayerID: 0x%04x (%u)", id, id);
return;
response:
if (len != 1 && len < 10) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
status = get_u8(frm);
printf("Status: 0x%02x (%s)\n", status, error2str(status));
if (len == 1)
return;
p_indent(level, frm);
uids = get_u16(frm);
printf("UIDCounter: 0x%04x (%u)", uids, uids);
p_indent(level, frm);
items = get_u32(frm);
printf("Number of Items: 0x%04x (%u)", items, items);
p_indent(level, frm);
charset = get_u16(frm);
printf("CharsetID: 0x%04x (%s)\n", charset, charset2str(charset));
p_indent(level, frm);
folders = get_u8(frm);
printf("Folder Depth: 0x%02x (%u)", folders, folders);
for (; folders > 0; folders--) {
uint16_t len;
p_indent(level, frm);
len = get_u8(frm);
printf("Folder: ");
for (; len > 0; len--) {
uint8_t c = get_u8(frm);
printf("%1c", isprint(c) ? c : '.');
}
printf("\n");
}
}
static void
check_integrity (const gdsl_interval_heap_t heap)
{
int i, j;
for (i = 1; i <= heap->card; i++)
{
if (i % 2 == 0)
{
int comp = heap->comp_f (heap->nodes[ LAST_INDEX (i-1) ], heap->nodes[ LAST_INDEX (i) ]);
//printf("comp %d\n", comp);
assert (comp <= 0);
}
if (LAST_INDEX (i) > INDEX_MAX ())
{
int comp1 = heap->comp_f (heap->nodes[ LAST_INDEX (i) ], heap->nodes[ PARENT_MIN (LAST_INDEX (i)) ]);
int comp2 = heap->comp_f (heap->nodes[ LAST_INDEX (i) ], heap->nodes[ PARENT_MAX (LAST_INDEX (i)) ]);
//printf("LAST_INDEX(i): %lu PARENT_MIN: %lu\n", LAST_INDEX(i), PARENT_MIN( LAST_INDEX(i) ));
//printf("LAST_INDEX(i): %lu PARENT_MAX: %lu\n", LAST_INDEX(i), PARENT_MAX( LAST_INDEX(i) ));
if (comp1 < 0)
{
int li = LAST_INDEX (i);
int pi = PARENT_MIN (li);
fprintf (stderr, "min child t[%d]: %d parent t[%d]: %d\n", li, vti (heap->nodes[li]), pi, vti (heap->nodes[pi]));
raw_dump (heap);
}
if (comp2 > 0)
{
int li = LAST_INDEX (i);
int pi = PARENT_MAX (li);
fprintf (stderr, "max child t[%d]: %d parent t[%d]: %d\n", li, vti (heap->nodes[li]), pi, vti (heap->nodes[pi]));
raw_dump (heap);
}
assert (comp1 >= 0);
assert (comp2 <= 0);
}
for (j = i+ 1; j <= heap->card; j++)
{
if (heap->nodes[ LAST_INDEX(i) ] == heap->nodes[ LAST_INDEX(j) ])
{
fprintf(stderr, "IDENTICAL VALUES: %d %d\n", i, j);
// N.B. I don't want any exit in my code! :)
// exit (1);
return 1; // I prefer a simple return (N. D.)
}
assert (heap->nodes[ LAST_INDEX (i) ] != heap->nodes[ LAST_INDEX (j) ]);
}
}
//printf("passed integrity check\n");
}
static void avrcp_register_notification_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len)
{
uint8_t event, status;
uint16_t uid;
uint32_t interval;
uint64_t id;
p_indent(level, frm);
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
if (len < 5) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
event = get_u8(frm);
printf("EventID: 0x%02x (%s)\n", event, event2str(event));
p_indent(level, frm);
interval = get_u32(frm);
printf("Interval: 0x%08x (%u seconds)\n", interval, interval);
return;
response:
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
event = get_u8(frm);
printf("EventID: 0x%02x (%s)\n", event, event2str(event));
p_indent(level, frm);
switch (event) {
case AVRCP_EVENT_PLAYBACK_STATUS_CHANGED:
status = get_u8(frm);
printf("PlayStatus: 0x%02x (%s)\n", status,
playstatus2str(status));
break;
case AVRCP_EVENT_TRACK_CHANGED:
id = get_u64(frm);
printf("Identifier: 0x%jx (%s)\n", id,
id ? "Reserved" : "PLAYING");
break;
case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
interval = get_u32(frm);
printf("Position: 0x%08x (%u miliseconds)\n", interval,
interval);
break;
case AVRCP_EVENT_BATT_STATUS_CHANGED:
status = get_u8(frm);
printf("BatteryStatus: 0x%02x (%s)\n", status,
status2str(status));
break;
case AVRCP_EVENT_SYSTEM_STATUS_CHANGED:
status = get_u8(frm);
printf("SystemStatus: 0x%02x ", status);
switch (status) {
case 0x00:
printf("(POWER_ON)\n");
case 0x01:
printf("(POWER_OFF)\n");
case 0x02:
printf("(UNPLUGGED)\n");
default:
printf("(UNKOWN)\n");
}
break;
case AVRCP_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
status = get_u8(frm);
printf("AttributeCount: 0x%02x\n", status);
for (; status > 0; status--) {
uint8_t attr, value;
p_indent(level, frm);
attr = get_u8(frm);
printf("AttributeID: 0x%02x (%s)\n", attr,
attr2str(attr));
p_indent(level, frm);
value = get_u8(frm);
printf("ValueID: 0x%02x (%s)\n", value,
value2str(attr, value));
}
break;
case AVRCP_EVENT_VOLUME_CHANGED:
status = get_u8(frm) & 0x7F;
printf("Volume: %.2f%% (%d/127)\n", status/1.27, status);
break;
case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
uid = get_u16(frm);
printf("PlayerID: 0x%04x (%u)\n", uid, uid);
p_indent(level, frm);
uid = get_u16(frm);
printf("UIDCounter: 0x%04x (%u)\n", uid, uid);
break;
}
}
void att_dump(int level, struct frame *frm)
{
uint8_t op;
op = get_u8(frm);
p_indent(level, frm);
printf("ATT: %s (0x%.2x)\n", attop2str(op), op);
switch (op) {
case ATT_OP_ERROR:
att_error_dump(level + 1, frm);
break;
case ATT_OP_MTU_REQ:
att_mtu_req_dump(level + 1, frm);
break;
case ATT_OP_MTU_RESP:
att_mtu_resp_dump(level + 1, frm);
break;
case ATT_OP_FIND_INFO_REQ:
att_find_info_req_dump(level + 1, frm);
break;
case ATT_OP_FIND_INFO_RESP:
att_find_info_resp_dump(level + 1, frm);
break;
case ATT_OP_FIND_BY_TYPE_REQ:
att_find_by_type_req_dump(level + 1, frm);
break;
case ATT_OP_FIND_BY_TYPE_RESP:
att_find_by_type_resp_dump(level + 1, frm);
break;
case ATT_OP_READ_BY_TYPE_REQ:
case ATT_OP_READ_BY_GROUP_REQ: /* exact same parsing */
att_read_by_type_req_dump(level + 1, frm);
break;
case ATT_OP_READ_BY_TYPE_RESP:
att_read_by_type_resp_dump(level + 1, frm);
break;
case ATT_OP_READ_REQ:
att_read_req_dump(level + 1, frm);
break;
case ATT_OP_READ_RESP:
raw_dump(level + 1, frm);
break;
case ATT_OP_READ_BLOB_REQ:
att_read_blob_req_dump(level + 1, frm);
break;
case ATT_OP_READ_BLOB_RESP:
att_read_blob_resp_dump(level + 1, frm);
break;
case ATT_OP_READ_MULTI_REQ:
att_read_multi_req_dump(level + 1, frm);
break;
case ATT_OP_READ_MULTI_RESP:
att_read_multi_resp_dump(level + 1, frm);
break;
case ATT_OP_READ_BY_GROUP_RESP:
att_read_by_group_resp_dump(level + 1, frm);
break;
case ATT_OP_WRITE_REQ:
case ATT_OP_WRITE_CMD:
att_write_req_dump(level + 1, frm);
break;
case ATT_OP_SIGNED_WRITE_CMD:
att_signed_write_dump(level + 1, frm);
break;
case ATT_OP_PREP_WRITE_REQ:
case ATT_OP_PREP_WRITE_RESP:
att_prep_write_dump(level + 1, frm);
break;
case ATT_OP_EXEC_WRITE_REQ:
att_exec_write_req_dump(level + 1, frm);
break;
case ATT_OP_HANDLE_NOTIFY:
att_handle_notify_dump(level + 1, frm);
break;
default:
raw_dump(level, frm);
break;
}
}
static inline void pskey_dump(int level, struct frame *frm)
{
uint16_t key, length, stores;
key = CSR_U16(frm);
length = CSR_U16(frm);
stores = CSR_U16(frm);
p_indent(level, frm);
printf("PSKEY: key 0x%4.4x len %d stores 0x%4.4x\n", key, length, stores);
switch (key) {
case 0x0001:
bdaddr_dump(level + 1, "BDADDR", frm);
break;
case 0x0002:
uint16_dump(level + 1, "COUNTRYCODE", frm);
break;
case 0x0003:
uint32_dump(level + 1, "CLASSOFDEVICE", frm);
break;
case 0x0004:
uint16_dump(level + 1, "DEVICE_DRIFT", frm);
break;
case 0x0005:
uint16_dump(level + 1, "DEVICE_JITTER", frm);
break;
case 0x000d:
uint16_dump(level + 1, "MAX_ACLS", frm);
break;
case 0x000e:
uint16_dump(level + 1, "MAX_SCOS", frm);
break;
case 0x000f:
uint16_dump(level + 1, "MAX_REMOTE_MASTERS", frm);
break;
case 0x00da:
uint16_dump(level + 1, "ENC_KEY_LMIN", frm);
break;
case 0x00db:
uint16_dump(level + 1, "ENC_KEY_LMAX", frm);
break;
case 0x00ef:
features_dump(level + 1, "LOCAL_SUPPORTED_FEATURES", frm);
break;
case 0x0106:
commands_dump(level + 1, "LOCAL_SUPPORTED_COMMANDS", frm);
break;
case 0x010d:
uint16_dump(level + 1, "HCI_LMP_LOCAL_VERSION", frm);
break;
case 0x010e:
uint16_dump(level + 1, "LMP_REMOTE_VERSION", frm);
break;
case 0x01a5:
bool_dump(level + 1, "HOSTIO_USE_HCI_EXTN", frm);
break;
case 0x01ab:
bool_dump(level + 1, "HOSTIO_MAP_SCO_PCM", frm);
break;
case 0x01be:
uint16_dump(level + 1, "UART_BAUDRATE", frm);
break;
case 0x01f6:
uint16_dump(level + 1, "ANA_FTRIM", frm);
break;
case 0x01f9:
uint16_dump(level + 1, "HOST_INTERFACE", frm);
break;
case 0x01fe:
uint16_dump(level + 1, "ANA_FREQ", frm);
break;
case 0x02be:
uint16_dump(level + 1, "USB_VENDOR_ID", frm);
break;
case 0x02bf:
uint16_dump(level + 1, "USB_PRODUCT_ID", frm);
break;
case 0x02cb:
uint16_dump(level + 1, "USB_DFU_PRODUCT_ID", frm);
break;
case 0x03cd:
int16_dump(level + 1, "INITIAL_BOOTMODE", frm);
break;
default:
raw_dump(level + 1, frm);
break;
}
}
void bnep_dump(int level, struct frame *frm)
{
uint8_t type = p_get_u8(frm);
uint16_t proto = 0x0000;
int extension = type & 0x80;
p_indent(level, frm);
switch (type & 0x7f) {
case BNEP_CONTROL:
printf("BNEP: Control(0x%02x|%s)\n",
type & 0x7f, extension ? "1" : "0");
bnep_control(level, frm, -1);
break;
case BNEP_COMPRESSED_ETHERNET:
printf("BNEP: Compressed(0x%02x|%s)\n",
type & 0x7f, extension ? "1" : "0");
p_indent(++level, frm);
proto = p_get_u16(frm);
printf("[proto 0x%04x]\n", proto);
break;
case BNEP_GENERAL_ETHERNET:
printf("BNEP: General ethernet(0x%02x|%s)\n",
type & 0x7f, extension ? "1" : "0");
p_indent(++level, frm);
printf("dst %s ", get_macaddr(frm));
printf("src %s ", get_macaddr(frm));
proto = p_get_u16(frm);
printf("[proto 0x%04x]\n", proto);
break;
case BNEP_COMPRESSED_ETHERNET_DEST_ONLY:
printf("BNEP: Compressed DestOnly(0x%02x|%s)\n",
type & 0x7f, extension ? "1" : "0");
p_indent(++level, frm);
printf("dst %s ", get_macaddr(frm));
proto = p_get_u16(frm);
printf("[proto 0x%04x]\n", proto);
break;
case BNEP_COMPRESSED_ETHERNET_SOURCE_ONLY:
printf("BNEP: Compressed SrcOnly(0x%02x|%s)\n",
type & 0x7f, extension ? "1" : "0");
p_indent(++level, frm);
printf("src %s ", get_macaddr(frm));
proto = p_get_u16(frm);
printf("[proto 0x%04x]\n", proto);
break;
default:
printf("(Unknown packet type)\n");
return;
}
/* Extension info */
if (extension)
bnep_eval_extension(++level, frm);
/* Control packet => No payload info */
if ((type & 0x7f) == BNEP_CONTROL)
return;
/* 802.1p header */
if (proto == 0x8100) {
p_indent(level, frm);
printf("802.1p Header: 0x%04x ", p_get_u16(frm));
proto = p_get_u16(frm);
printf("[proto 0x%04x]\n", proto);
}
if (!(parser.flags & DUMP_VERBOSE)) {
raw_dump(level, frm);
return;
}
switch (proto) {
case ETHERTYPE_ARP:
p_indent(++level, frm);
printf("ARP: ");
arp_dump(level, frm);
break;
case ETHERTYPE_REVARP:
p_indent(++level, frm);
printf("RARP: ");
arp_dump(level, frm);
break;
case ETHERTYPE_IP:
p_indent(++level, frm);
printf("IP: ");
ip_dump(level, frm);
break;
case ETHERTYPE_IPV6:
p_indent(++level, frm);
printf("IPV6: ");
ip_dump(level, frm);
break;
default:
raw_dump(level, frm);
break;
}
}
void csr_dump(int level, struct frame *frm)
{
uint8_t desc, cid, type;
uint16_t handle, master, addr;
desc = CSR_U8(frm);
cid = desc & 0x3f;
switch (cid) {
case 2:
bccmd_dump(level, frm);
break;
case 20:
type = CSR_U8(frm);
if (!p_filter(FILT_LMP)) {
switch (type) {
case 0x0f:
frm->handle = ((uint8_t *) frm->ptr)[17];
frm->master = 0;
frm->len--;
lmp_dump(level, frm);
return;
case 0x10:
frm->handle = ((uint8_t *) frm->ptr)[17];
frm->master = 1;
frm->len--;
lmp_dump(level, frm);
return;
case 0x12:
handle = CSR_U16(frm);
master = CSR_U16(frm);
addr = CSR_U16(frm);
p_indent(level, frm);
printf("FHS: handle %d addr %d (%s)\n", handle,
addr, master ? "master" : "slave");
if (!master) {
char addr[18];
p_ba2str((bdaddr_t *) frm->ptr, addr);
p_indent(level + 1, frm);
printf("bdaddr %s class "
"0x%2.2x%2.2x%2.2x\n", addr,
((uint8_t *) frm->ptr)[8],
((uint8_t *) frm->ptr)[7],
((uint8_t *) frm->ptr)[6]);
}
return;
case 0x7b:
p_indent(level, frm);
printf("LMP(r): duplicate (same SEQN)\n");
return;
}
}
p_indent(level, frm);
printf("CSR: Debug (type 0x%2.2x)\n", type);
raw_dump(level, frm);
break;
default:
p_indent(level, frm);
printf("CSR: %s (channel %d)%s\n", cid2str(cid), cid, frag2str(desc));
raw_dump(level, frm);
break;
}
}
static void avrcp_get_player_value_text_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len)
{
static uint8_t attr = 0; /* Remember attribute */
uint8_t num;
p_indent(level, frm);
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
attr = get_u8(frm);
printf("AttributeID: 0x%02x (%s)\n", attr, attr2str(attr));
p_indent(level, frm);
num = get_u8(frm);
printf("ValueCount: 0x%02x\n", num);
for (; num > 0; num--) {
uint8_t value;
p_indent(level, frm);
value = get_u8(frm);
printf("ValueID: 0x%02x (%s)\n", value,
value2str(attr, value));
}
return;
response:
num = get_u8(frm);
printf("ValueCount: 0x%02x\n", num);
for (; num > 0; num--) {
uint8_t value, len;
uint16_t charset;
p_indent(level, frm);
value = get_u8(frm);
printf("ValueID: 0x%02x (%s)\n", value,
value2str(attr, value));
p_indent(level, frm);
charset = get_u16(frm);
printf("CharsetID: 0x%04x (%s)\n", charset,
charset2str(charset));
p_indent(level, frm);
len = get_u8(frm);
printf("StringLength: 0x%02x\n", len);
p_indent(level, frm);
printf("String: ");
for (; len > 0; len--) {
uint8_t c = get_u8(frm);
printf("%1c", isprint(c) ? c : '.');
}
printf("\n");
}
}
void ip_dump(int level, struct frame *frm)
{
char src[50], dst[50];
struct ip *ip = (struct ip *) (frm->ptr);
uint8_t proto;
int len;
if (ip->ip_v == 4) {
struct sockaddr_in sai;
proto = ip->ip_p;
len = ip->ip_hl << 2;
memset(&sai, 0, sizeof(sai));
sai.sin_family = AF_INET;
memcpy(&sai.sin_addr, &ip->ip_src, sizeof(struct in_addr));
getnameinfo((struct sockaddr *) &sai, sizeof(sai),
src, sizeof(src), NULL, 0, NI_NUMERICHOST);
memcpy(&sai.sin_addr, &ip->ip_dst, sizeof(struct in_addr));
getnameinfo((struct sockaddr *) &sai, sizeof(sai),
dst, sizeof(dst), NULL, 0, NI_NUMERICHOST);
} else if (ip->ip_v == 6) {
struct sockaddr_in6 sai6;
struct ip6_hdr *ip6 = (struct ip6_hdr *) ip;
proto = ip6->ip6_nxt;
len = sizeof(struct ip6_hdr);
memset(&sai6, 0, sizeof(sai6));
sai6.sin6_family = AF_INET6;
memcpy(&sai6.sin6_addr, &ip6->ip6_src, sizeof(struct in6_addr));
getnameinfo((struct sockaddr *) &sai6, sizeof(sai6),
src, sizeof(src), NULL, 0, NI_NUMERICHOST);
memcpy(&sai6.sin6_addr, &ip6->ip6_dst, sizeof(struct in6_addr));
getnameinfo((struct sockaddr *) &sai6, sizeof(sai6),
dst, sizeof(dst), NULL, 0, NI_NUMERICHOST);
} else {
raw_dump(level, frm);
return;
}
printf("src %s ", src);
printf("dst %s\n", dst);
frm->ptr += len;
frm->len -= len;
p_indent(++level, frm);
switch (proto) {
case IPPROTO_TCP:
printf("TCP:\n");
break;
case IPPROTO_UDP:
printf("UDP:\n");
break;
case IPPROTO_ICMP:
printf("ICMP:\n");
break;
case IPPROTO_ICMPV6:
printf("ICMPv6:\n");
break;
default:
printf("Unknown Protocol: 0x%02x\n", ip->ip_p);
break;
}
raw_dump(level, frm);
}
static void avrcp_get_element_attributes_dump(int level, struct frame *frm,
uint8_t ctype, uint16_t len,
uint8_t pt)
{
uint64_t id;
uint8_t num;
p_indent(level, frm);
if (ctype > AVC_CTYPE_GENERAL_INQUIRY)
goto response;
if (len < 9) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
id = get_u64(frm);
printf("Identifier: 0x%jx (%s)\n", id, id ? "Reserved" : "PLAYING");
p_indent(level, frm);
num = get_u8(frm);
printf("AttributeCount: 0x%02x\n", num);
for (; num > 0; num--) {
uint32_t attr;
p_indent(level, frm);
attr = get_u32(frm);
printf("Attribute: 0x%08x (%s)\n", attr, mediattr2str(attr));
}
return;
response:
if (pt == AVRCP_PACKET_TYPE_SINGLE || pt == AVRCP_PACKET_TYPE_START) {
if (len < 1) {
printf("PDU Malformed\n");
raw_dump(level, frm);
return;
}
num = get_u8(frm);
avrcp_continuing.num = num;
printf("AttributeCount: 0x%02x\n", num);
len--;
} else {
num = avrcp_continuing.num;
if (avrcp_continuing.size > 0) {
uint16_t size;
if (avrcp_continuing.size > len) {
size = len;
avrcp_continuing.size -= len;
} else {
size = avrcp_continuing.size;
avrcp_continuing.size = 0;
}
printf("ContinuingAttributeValue: ");
for (; size > 0; size--) {
uint8_t c = get_u8(frm);
printf("%1c", isprint(c) ? c : '.');
}
printf("\n");
len -= size;
}
}
while (num > 0 && len > 0) {
uint32_t attr;
uint16_t charset, attrlen;
p_indent(level, frm);
attr = get_u32(frm);
printf("Attribute: 0x%08x (%s)\n", attr, mediattr2str(attr));
p_indent(level, frm);
charset = get_u16(frm);
printf("CharsetID: 0x%04x (%s)\n", charset,
charset2str(charset));
p_indent(level, frm);
attrlen = get_u16(frm);
printf("AttributeValueLength: 0x%04x\n", attrlen);
len -= sizeof(attr) + sizeof(charset) + sizeof(attrlen);
num--;
p_indent(level, frm);
printf("AttributeValue: ");
for (; attrlen > 0 && len > 0; attrlen--, len--) {
uint8_t c = get_u8(frm);
printf("%1c", isprint(c) ? c : '.');
}
printf("\n");
if (attrlen > 0)
avrcp_continuing.size = attrlen;
}
avrcp_continuing.num = num;
}
static void cmd_interoperability(int level, uint8_t subcmd, struct frame *frm)
{
uint16_t sel, func, info;
uint16_t nconn, datablkcnt, datablklen;
uint32_t ctr, value, major, minor;
info = (subcmd == 0x81) ? CAPI_U16(frm) : 0;
sel = CAPI_U16(frm);
CAPI_U8(frm);
if (subcmd != 0x83) {
func = CAPI_U16(frm);
CAPI_U8(frm);
} else
func = 0;
p_indent(level, frm);
printf("Selector: 0x%04x (%s)\n", sel, interopsel2str(sel));
switch (sel) {
case 0x0001:
p_indent(level, frm);
printf("Function: %d (%s)\n", func, func2str(func));
switch (subcmd) {
case 0x80:
switch (func) {
case 0:
nconn = CAPI_U16(frm);
p_indent(level + 1, frm);
printf("maxLogicalConnections: %d\n", nconn);
datablkcnt = CAPI_U16(frm);
p_indent(level + 1, frm);
printf("maxBDataBlocks: %d\n", datablkcnt);
datablklen = CAPI_U16(frm);
p_indent(level + 1, frm);
printf("maxBDataLen: %d\n", datablklen);
break;
case 2:
case 3:
case 4:
case 5:
ctr = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Controller: %d\n", ctr);
break;
default:
raw_dump(level + 1, frm);
break;
}
break;
case 0x81:
switch (func) {
case 0:
case 1:
info = CAPI_U16(frm);
p_indent(level + 1, frm);
printf("Info: 0x%04x (%s)\n", info, info2str(info));
break;
case 2:
info = CAPI_U16(frm);
p_indent(level + 1, frm);
printf("Info: 0x%04x (%s)\n", info, info2str(info));
CAPI_U8(frm);
profile(level + 1, frm);
break;
case 3:
info = CAPI_U16(frm);
p_indent(level + 1, frm);
printf("Info: 0x%04x (%s)\n", info, info2str(info));
ctr = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Controller: %d\n", ctr);
CAPI_U8(frm);
p_indent(level + 1, frm);
printf("Identification: \"%s\"\n", (char *) frm->ptr);
break;
case 4:
value = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Return value: 0x%04x\n", value);
ctr = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Controller: %d\n", ctr);
p_indent(level + 1, frm);
major = CAPI_U32(frm);
minor = CAPI_U32(frm);
printf("CAPI: %d.%d\n", major, minor);
major = CAPI_U32(frm);
minor = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Manufacture: %u.%01x%01x-%02u (%d.%d)\n",
(major & 0xf0) >> 4, (major & 0x0f) << 4,
(minor & 0xf0) >> 4, minor & 0x0f,
major, minor);
break;
case 5:
value = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Return value: 0x%04x\n", value);
ctr = CAPI_U32(frm);
p_indent(level + 1, frm);
printf("Controller: %d\n", ctr);
CAPI_U8(frm);
p_indent(level + 1, frm);
printf("Serial number: %.7s\n", (char *) frm->ptr);
break;
default:
raw_dump(level + 1, frm);
break;
}
break;
default:
raw_dump(level, frm);
break;
}
break;
default:
p_indent(level, frm);
printf("Function: %d\n", func);
if (subcmd == 0x81) {
p_indent(level, frm);
printf("Info: 0x%04x (%s)\n", info, info2str(info));
}
raw_dump(level + 1, frm);
break;
}
}
void avdtp_dump(int level, struct frame *frm)
{
uint8_t hdr, sid, nsp, type;
uint16_t seqn;
uint32_t time, ssrc;
switch (frm->num) {
case 1:
p_indent(level, frm);
hdr = get_u8(frm);
nsp = (hdr & 0x0c) == 0x04 ? get_u8(frm) : 0;
sid = hdr & 0x08 ? 0x00 : get_u8(frm);
printf("AVDTP(s): %s %s: transaction %d nsp 0x%02x\n",
hdr & 0x08 ? pt2str(hdr) : si2str(sid),
mt2str(hdr), hdr >> 4, nsp);
switch (sid & 0x7f) {
case 0x01:
discover(level + 1, hdr, frm);
break;
case 0x02:
case 0x0c:
get_capabilities(level + 1, hdr, frm);
break;
case 0x03:
set_configuration(level + 1, hdr, frm);
break;
case 0x04:
get_configuration(level + 1, hdr, frm);
break;
case 0x05:
reconfigure(level + 1, hdr, frm);
break;
case 0x06:
open_close_stream(level + 1, hdr, frm);
break;
case 0x07:
start_suspend_stream(level + 1, hdr, frm);
break;
case 0x08:
open_close_stream(level + 1, hdr, frm);
break;
case 0x09:
start_suspend_stream(level + 1, hdr, frm);
break;
case 0x0a:
abort_streaming(level + 1, hdr, frm);
break;
case 0x0b:
security(level + 1, hdr, frm);
break;
case 0x0d:
delay_report(level + 1, hdr, frm);
break;
}
break;
case 2:
p_indent(level, frm);
hdr = get_u8(frm);
type = get_u8(frm);
seqn = get_u16(frm);
time = get_u32(frm);
ssrc = get_u32(frm);
printf("AVDTP(m): ver %d %s%scc %d %spt %d seqn %d time %d ssrc %d\n",
hdr >> 6, hdr & 0x20 ? "pad " : "", hdr & 0x10 ? "ext " : "",
hdr & 0xf, type & 0x80 ? "mark " : "", type & 0x7f, seqn, time, ssrc);
break;
}
raw_dump(level, frm);
}
