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); }