diff --git a/tools/hcidump.c b/tools/hcidump.c
index 09436c0..206dd09 100644
--- a/tools/hcidump.c
+++ b/tools/hcidump.c
exit(1);
}
- printf("device: hci%d snap_len: %d filter: none\n", dev, snap_len);
+ printf("device: hci%d snap_len: %d filter: 0x%lx\n",
+ dev, snap_len, filter);
while (1) {
iv.iov_base = frm.data;
return 0;
}
-static struct argp parser = {
+static struct argp arg_parser = {
options,
parse_opt,
- "",
+ "[filter]",
"HCIDump - HCI packet analyzer ver " VERSION
};
int main(int argc, char *argv[])
{
- argp_parse(&parser, argc, argv, 0, NULL, NULL);
+ argp_parse(&arg_parser, argc, argv, 0, NULL, NULL);
printf("HCIDump - HCI packet analyzer ver %s.\n", VERSION);
diff --git a/tools/parser/hci.c b/tools/parser/hci.c
index d1b7369..070fbcd 100644
--- a/tools/parser/hci.c
+++ b/tools/parser/hci.c
};
#define CMD_STATUS_NUM 5
-static inline void command_dump(struct frame *frm)
+static inline void command_dump(int level, struct frame *frm)
{
hci_command_hdr *hdr = frm->ptr;
__u16 opcode = __le16_to_cpu(hdr->opcode);
__u16 ocf = cmd_opcode_ocf(opcode);
char *cmd;
- frm->ptr += HCI_COMMAND_HDR_SIZE;
- frm->len -= HCI_COMMAND_HDR_SIZE;
+ if (p_filter(FILT_HCI))
+ return;
switch (ogf) {
case OGF_INFO_PARAM:
break;
}
- printf("HCI Command: %s(0x%2.2x|0x%4.4x) plen %d\n", cmd, ogf, ocf, hdr->plen);
- raw_dump(1, frm);
+ p_indent(level, frm->in);
+
+ printf("HCI Command: %s(0x%2.2x|0x%4.4x) plen %d\n",
+ cmd, ogf, ocf, hdr->plen);
+
+ frm->ptr += HCI_COMMAND_HDR_SIZE;
+ frm->len -= HCI_COMMAND_HDR_SIZE;
+
+ raw_dump(level, frm);
}
-static inline void event_dump(struct frame *frm)
+static inline void event_dump(int level, struct frame *frm)
{
hci_event_hdr *hdr = frm->ptr;
-
- frm->ptr += HCI_EVENT_HDR_SIZE;
- frm->len -= HCI_EVENT_HDR_SIZE;
+
+ if (p_filter(FILT_HCI))
+ return;
+
+ p_indent(level, frm->in);
if (hdr->evt <= EVENT_NUM)
printf("HCI Event: %s(0x%2.2x) plen %d\n",
event_map[hdr->evt], hdr->evt, hdr->plen);
else
printf("HCI Event: code 0x%2.2x plen %d\n", hdr->evt, hdr->plen);
- raw_dump(1, frm);
+
+ frm->ptr += HCI_EVENT_HDR_SIZE;
+ frm->len -= HCI_EVENT_HDR_SIZE;
+
+ raw_dump(level, frm);
}
-static inline void acl_dump(struct frame *frm)
+static inline void acl_dump(int level, struct frame *frm)
{
hci_acl_hdr *hdr = (void *) frm->ptr;
__u16 handle = __le16_to_cpu(hdr->handle);
__u16 dlen = __le16_to_cpu(hdr->dlen);
__u8 flags = acl_flags(handle);
-
- printf("ACL data: handle 0x%4.4x flags 0x%2.2x dlen %d\n",
- acl_handle(handle), flags, dlen);
-
+
+ if (!p_filter(FILT_HCI)) {
+ p_indent(level, frm->in);
+ printf("ACL data: handle 0x%4.4x flags 0x%2.2x dlen %d\n",
+ acl_handle(handle), flags, dlen);
+ level++;
+ }
+
frm->ptr += HCI_ACL_HDR_SIZE;
frm->len -= HCI_ACL_HDR_SIZE;
frm->flags = flags;
frm->handle = acl_handle(handle);
-
- l2cap_dump(1, frm);
+
+ if (parser.filter & ~FILT_HCI)
+ l2cap_dump(level, frm);
+ else
+ raw_dump(level, frm);
}
void hci_dump(int level, struct frame *frm)
switch (type) {
case HCI_COMMAND_PKT:
- command_dump(frm);
+ command_dump(level, frm);
break;
case HCI_EVENT_PKT:
- event_dump(frm);
+ event_dump(level, frm);
break;
case HCI_ACLDATA_PKT:
- acl_dump(frm);
+ acl_dump(level, frm);
break;
default:
+ if (p_filter(FILT_HCI))
+ break;
+
+ p_indent(level, frm->in);
printf("Unknown: type 0x%2.2x len %d\n", type, frm->len);
- raw_dump(1, frm);
+ raw_dump(level, frm);
break;
}
}
diff --git a/tools/parser/l2cap.c b/tools/parser/l2cap.c
index 5a971e8..bcf0e2f 100644
--- a/tools/parser/l2cap.c
+++ b/tools/parser/l2cap.c
static inline void command_rej(int level, struct frame *frm)
{
l2cap_cmd_rej *h = frm->ptr;
+
printf("Command rej: reason %d\n",
btohs(h->reason));
}
static inline void conn_req(int level, struct frame *frm)
{
l2cap_conn_req *h = frm->ptr;
- printf("Connect req: psm %d scid 0x%4.4x\n",
- btohs(h->psm), btohs(h->scid));
add_cid(frm->in, btohs(h->scid), btohs(h->psm));
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
+ printf("Connect req: psm %d scid 0x%4.4x\n",
+ btohs(h->psm), btohs(h->scid));
}
static inline void conn_rsp(int level, struct frame *frm)
{
l2cap_conn_rsp *h = frm->ptr;
__u16 psm;
- printf("Connect rsp: dcid 0x%4.4x scid 0x%4.4x result %d status %d\n",
- btohs(h->dcid), btohs(h->scid),
- btohs(h->result), btohs(h->status));
if ((psm = get_psm(!frm->in, btohs(h->scid))))
add_cid(frm->in, btohs(h->dcid), psm);
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
+ printf("Connect rsp: dcid 0x%4.4x scid 0x%4.4x result %d status %d\n",
+ btohs(h->dcid), btohs(h->scid),
+ btohs(h->result), btohs(h->status));
}
static __u32 conf_opt_val(__u8 *ptr, __u8 len)
static void conf_opt(int level, void *ptr, int len)
{
- indent(level);
+ p_indent(level, 0);
while (len > 0) {
l2cap_conf_opt *h = ptr;
{
l2cap_conf_req *h = frm->ptr;
int clen = btohs(cmd->len) - L2CAP_CONF_REQ_SIZE;
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Config req: dcid 0x%4.4x flags 0x%4.4x clen %d\n",
btohs(h->dcid), btohs(h->flags), clen);
if (clen)
- conf_opt(level+1, h->data, clen);
+ conf_opt(level, h->data, clen);
}
static inline void conf_rsp(int level, l2cap_cmd_hdr *cmd, struct frame *frm)
{
l2cap_conf_rsp *h = frm->ptr;
int clen = btohs(cmd->len) - L2CAP_CONF_RSP_SIZE;
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Config rsp: scid 0x%4.4x flags 0x%4.4x result %d clen %d\n",
btohs(h->scid), btohs(h->flags), btohs(h->result), clen);
if (clen)
- conf_opt(level+1, h->data, clen);
+ conf_opt(level, h->data, clen);
}
static inline void disconn_req(int level, struct frame *frm)
{
l2cap_disconn_req *h = frm->ptr;
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Disconn req: dcid 0x%4.4x scid 0x%4.4x\n",
btohs(h->dcid), btohs(h->scid));
}
static inline void disconn_rsp(int level, struct frame *frm)
{
l2cap_disconn_rsp *h = frm->ptr;
+ del_cid(frm->in, btohs(h->dcid), btohs(h->scid));
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Disconn rsp: dcid 0x%4.4x scid 0x%4.4x\n",
btohs(h->dcid), btohs(h->scid));
-
- del_cid(frm->in, btohs(h->dcid), btohs(h->scid));
}
static inline void echo_req(int level, l2cap_cmd_hdr *cmd, struct frame *frm)
{
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Echo req: dlen %d\n",
btohs(cmd->len));
raw_dump(level, frm);
static inline void echo_rsp(int level, l2cap_cmd_hdr *cmd, struct frame *frm)
{
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Echo rsp: dlen %d\n",
btohs(cmd->len));
raw_dump(level, frm);
static inline void info_req(int level, l2cap_cmd_hdr *cmd, struct frame *frm)
{
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Info req: dlen %d\n",
btohs(cmd->len));
raw_dump(level, frm);
static inline void info_rsp(int level, l2cap_cmd_hdr *cmd, struct frame *frm)
{
+ if (p_filter(FILT_L2CAP))
+ return;
+
printf("Info rsp: dlen %d\n",
btohs(cmd->len));
raw_dump(level, frm);
l2cap_hdr *hdr = (void *)frm->ptr;
__u16 dlen = btohs(hdr->len);
__u16 cid = btohs(hdr->cid);
+ __u16 psm;
frm->ptr += L2CAP_HDR_SIZE;
frm->len -= L2CAP_HDR_SIZE;
- indent(level);
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;
- printf("L2CAP(s): ");
+ if (!p_filter(FILT_L2CAP)) {
+ p_indent(level, frm->in);
+ printf("L2CAP(s): ");
+ }
switch (hdr->code) {
case L2CAP_COMMAND_REJ:
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);
}
} else if (cid == 0x2) {
/* Connectionless channel */
- __u16 psm = btohs(*(__u16*)frm->ptr);
+
+ if (p_filter(FILT_L2CAP))
+ return;
+
+ psm = btohs(*(__u16*)frm->ptr);
frm->len -= 2;
+ p_indent(level, frm->in);
printf("L2CAP(c): cid 0x%x len %d psm %d\n", cid, dlen, psm);
-
raw_dump(level, frm);
} else {
/* Connection oriented channel */
__u16 psm = get_psm(!frm->in, cid);
-
- printf("L2CAP(d): cid 0x%x len %d [psm %d]\n", cid, dlen, psm);
+
+ if (!p_filter(FILT_L2CAP)) {
+ p_indent(level, frm->in);
+ printf("L2CAP(d): cid 0x%x len %d [psm %d]\n",
+ cid, dlen, psm);
+ level++;
+ }
switch (psm) {
case 0x01:
+ if (p_filter(FILT_SDP))
+ break;
+
sdp_dump(level+1, frm);
break;
case 0x03:
- rfcomm_dump(level+1, frm);
+ if (p_filter(FILT_RFCOMM))
+ break;
+
+ rfcomm_dump(level, frm);
break;
default:
+ if (p_filter(FILT_L2CAP))
+ break;
+
raw_dump(level, frm);
break;
}
fr->data_len = dlen + L2CAP_HDR_SIZE;
fr->len = frm->len;
fr->ptr = fr->data;
+ fr->in = frm->in;
} else {
if (!(fr = get_frame(frm->handle))) {
fprintf(stderr, "Not enough connetion handles\n");
diff --git a/tools/parser/parser.c b/tools/parser/parser.c
index 0c88659..5e0e5a9 100644
--- a/tools/parser/parser.c
+++ b/tools/parser/parser.c
#include "parser.h"
-long parser_flags;
-long parser_filter;
+struct parser_t parser;
-void init_parser(long flags, long filter)
+void init_parser(unsigned long flags, unsigned long filter)
{
- parser_flags = flags;
- parser_filter = parser_filter;
+ parser.flags = flags;
+ parser.filter = filter;
+ parser.state = 0;
}
static inline void hex_dump(int level, unsigned char *buf, int len)
for (i=0, n=1; i<len; i++, n++) {
if (n == 1)
- indent(level);
+ p_indent(level, 0);
printf("%2.2X ", buf[i]);
if (n == DUMP_WIDTH) {
printf("\n");
for (i=0, n=1; i<len; i++, n++) {
if (n == 1)
- indent(level);
+ p_indent(level, 0);
printf("%1c ", isprint(buf[i]) ? buf[i] : '.');
if (n == DUMP_WIDTH) {
printf("\n");
if (!frm->len)
return;
- switch (parser_flags & DUMP_TYPE_MASK) {
+ switch (parser.flags & DUMP_TYPE_MASK) {
case DUMP_HEX:
hex_dump(level, frm->ptr, frm->len);
break;
break;
}
}
-
diff --git a/tools/parser/parser.h b/tools/parser/parser.h
index 88b5f70..d5b1f26 100644
--- a/tools/parser/parser.h
+++ b/tools/parser/parser.h
#define FILT_RFCOMM 0x04
#define FILT_SDP 0x08
-void init_parser(long flags, long filter);
+struct parser_t {
+ unsigned long flags;
+ unsigned long filter;
+ int state;
+};
+
+extern struct parser_t parser;
+
+void init_parser(unsigned long flags, unsigned long filter);
+
+static inline int p_filter(unsigned long f)
+{
+ return !(parser.filter & f);
+}
+
+static inline void p_indent(int level, int in)
+{
+ if (level < 0) {
+ parser.state = 0;
+ return;
+ }
+
+ if (!parser.state) {
+ printf("%c ", (in ? '>' : '<'));
+ parser.state = 1;
+ } else
+ printf(" ");
+
+ if (level)
+ printf("%*c", (level*2), ' ');
+}
void raw_dump(int level, struct frame *frm);
void hci_dump(int level, struct frame *frm);
void rfcomm_dump(int level, struct frame *frm);
void sdp_dump(int level, struct frame *frm);
-static inline void indent(int level)
-{
- printf("%*c", (level*2), ' ');
-}
-
static inline void parse(struct frame *frm)
{
- printf("%c ", (frm->in ? '>' : '<'));
+ p_indent(-1, 0);
hci_dump(0, frm);
fflush(stdout);
}
diff --git a/tools/parser/rfcomm.c b/tools/parser/rfcomm.c
index cf7774e..1751526 100644
--- a/tools/parser/rfcomm.c
+++ b/tools/parser/rfcomm.c
ctr_type = CLR_PF(ctr);
fcs = *(ptr + len - 1);
- printf("cr %d dlci %d pf %d ilen %d fcs 0x%x", addr.cr, dlci, pf, ilen, fcs);
+ printf("cr %d dlci %d pf %d ilen %d fcs 0x%x ", addr.cr, dlci, pf, ilen, fcs);
}
void print_mcc(mcc_long_frame_head* mcc_head)
{
- printf(" mcc_len %d\n", mcc_head->length.len);
+ printf("mcc_len %d\n", mcc_head->length.len);
}
-static inline void mcc_test(int level, __u8 *ptr, int len,
+static inline void mcc_test(int level, __u8 *ptr, int len,
long_frame_head *head,
mcc_long_frame_head *mcc_head)
{
- indent(level);
- printf("RFCOMM(s): TEST %s: ", CR_STR(mcc_head));
+ printf("TEST %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
}
-static inline void mcc_fcon(int level, __u8 *ptr, int len,
+static inline void mcc_fcon(int level, __u8 *ptr, int len,
long_frame_head *head,
mcc_long_frame_head *mcc_head)
{
- indent(level);
- printf("RFCOMM(s): FCON %s: ", CR_STR(mcc_head));
+ printf("FCON %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
}
-static inline void mcc_fcoff(int level, __u8 *ptr, int len,
+static inline void mcc_fcoff(int level, __u8 *ptr, int len,
long_frame_head *head,
mcc_long_frame_head *mcc_head)
{
- indent(level);
- printf("RFCOMM(s): FCOFF %s: ", CR_STR(mcc_head));
+ printf("FCOFF %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
}
-static inline void mcc_msc(int level, __u8 *ptr, int len,
+static inline void mcc_msc(int level, __u8 *ptr, int len,
long_frame_head *head,
mcc_long_frame_head *mcc_head)
{
msc_data *msc = (void*) ptr;
- indent(level);
- printf("RFCOMM(s): MSC %s: ", CR_STR(mcc_head));
+ printf("MSC %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
- indent(level+1);
+ p_indent(level, 0);
printf("dlci %d fc %d rtc %d rtr %d ic %d dv %d",
GET_DLCI(msc->addr), msc->v24_sigs.fc, msc->v24_sigs.rtc,
msc->v24_sigs.rtr, msc->v24_sigs.ic, msc->v24_sigs.dv );
{
rpn_data *rpn = (void*) ptr;
- indent(level);
- printf("RFCOMM(s): RPN %s: ", CR_STR(mcc_head));
+ printf("RPN %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
printf("dlci %d ", GET_DLCI(rpn->addr));
+
if (len == RPN_DATA_NO_RPN_SIZE) {
printf("\n");
- } else {
- printf(" br: %d db: %d sb: %d p: %d pt: %d xi: %d xo: %d",
- rpn->rpn_val.bit_rate, rpn->rpn_val.data_bits,
- rpn->rpn_val.stop_bit, rpn->rpn_val.parity,
- rpn->rpn_val.parity_type, rpn->rpn_val.xon_input,
- rpn->rpn_val.xon_output);
- indent(level+1);
- printf(" rtri: %d rtro: %d rtci: %d rtco: %d xon: %d xoff: %d pm: %04x",
- rpn->rpn_val.rtr_input, rpn->rpn_val.rtr_output,
- rpn->rpn_val.rtc_input, rpn->rpn_val.rtc_output,
- rpn->rpn_val.xon___u8, rpn->rpn_val.xoff___u8,
- *((__u16*)&rpn->rpn_val.pm));
+ return;
}
+
+ printf(" br: %d db: %d sb: %d p: %d pt: %d xi: %d xo: %d\n",
+ rpn->rpn_val.bit_rate, rpn->rpn_val.data_bits,
+ rpn->rpn_val.stop_bit, rpn->rpn_val.parity,
+ rpn->rpn_val.parity_type, rpn->rpn_val.xon_input,
+ rpn->rpn_val.xon_output);
+ p_indent(level, 0);
+ printf(" rtri: %d rtro: %d rtci: %d rtco: %d xon: %d xoff: %d pm: %04x",
+ rpn->rpn_val.rtr_input, rpn->rpn_val.rtr_output,
+ rpn->rpn_val.rtc_input, rpn->rpn_val.rtc_output,
+ rpn->rpn_val.xon___u8, rpn->rpn_val.xoff___u8,
+ *((__u16*)&rpn->rpn_val.pm));
}
static inline void mcc_rls(int level, __u8 *ptr, int len,
long_frame_head *head,
{
rls_data* rls = (void*) ptr;
- indent(level);
- printf("RFCOMM(s): RLS %s ", CR_STR(mcc_head));
+ printf("RLS %s ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
printf("dlci %d error: %d", GET_DLCI(rls->addr), rls->error);
{
pn_data *pn = (void*) ptr;
- indent(level);
- printf("RFCOMM(s): PN %s", CR_STR(mcc_head));
+ printf("PN %s", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
- indent(level+1);
+
+ p_indent(level, 0);
printf("dlci %d frame_type %d conv_lay %d pri %d ack_timer %d "
"frame_size %d max_retrans %d win_size %d\n",
pn->dlci, pn->frame_type, pn->conv_layer, pn->pri,
nsc_data *nsc = (void*) ptr;
- indent(level);
- printf("RFCOMM(s): NSC %s: ", CR_STR(mcc_head));
+ printf("NSC %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
- indent(level+1);
+
+ p_indent(level, 0);
printf("cr %d, mcc_cmd_type %x\n",
nsc->cmd_type.cr, nsc->cmd_type.type );
}
frm->ptr += hdr_size;
frm->len -= hdr_size;
+ p_indent(level, frm->in);
+ printf("RFCOMM(s): ");
+
switch (mcc_head.type.type) {
case TEST:
mcc_test(level, frm->ptr, frm->len, head, &mcc_head);
- frm->len--;
- raw_dump(level+1, frm);
+ raw_dump(level, frm);
break;
case FCON:
mcc_fcon(level, frm->ptr, frm->len, head, &mcc_head);
mcc_test(level, frm->ptr, frm->len, head, &mcc_head);
break;
default:
- indent(level);
- printf("RFCOMM(s): MCC ERR: ");
+ printf("MCC ERR: ");
print_rfcomm_hdr(head, frm->ptr, frm->len);
printf("\n");
+
frm->len--;
raw_dump(level, frm);
}
static inline void uih_frame(int level, struct frame *frm, long_frame_head *head)
{
- if (head->addr.server_chn == 0) {
+ if (!head->addr.server_chn) {
mcc_frame(level, frm, head);
} else {
- indent(level);
+ p_indent(level, frm->in);
printf("RFCOMM(d): UIH: ");
print_rfcomm_hdr(head, frm->ptr, frm->len);
printf("\n");
frm->len--;
- raw_dump(level+1, frm);
+ raw_dump(level, frm);
}
}
if (ctr_type == UIH) {
uih_frame(level, frm, &head);
} else {
- indent(level);
+ p_indent(level, frm->in);
printf("RFCOMM(s): ");
switch (ctr_type) {
diff --git a/tools/parser/sdp.c b/tools/parser/sdp.c
index 2268159..037eb3e 100644
--- a/tools/parser/sdp.c
+++ b/tools/parser/sdp.c
int n1;
int n2;
- indent(level);
+ p_indent(level, frm->in);
printf("pat");
if (parse_de_hdr(frm, &n1) == SDP_DE_SEQ) {
int n2;
int len = frm->len;
- indent(level);
+ p_indent(level, frm->in);
printf("aid(s)");
if (parse_de_hdr(frm, &n1) == SDP_DE_SEQ) {
if ((parse_de_hdr(frm, &n2) == SDP_DE_UINT) &&
(n2 == sizeof(attr_id))) {
attr_id = get_u16(frm);
- indent(level);
+ p_indent(level, 0);
printf("aid 0x%x (%s)\n", attr_id, get_attr_id_name(attr_id));
/* Print AttributeValue */
- indent(++level);
+ p_indent(++level, 0);
print_de(level, frm);
} else {
printf("\nERROR: Unexpected syntax\n");
if (parse_de_hdr(frm, &n) == SDP_DE_SEQ) {
while (len - frm->len < n ) {
- indent(level);
+ p_indent(level, 0);
printf("srv rec #%d\n", cnt++);
print_attr_list(level+1, frm);
}
{
printf("SDP Error Rsp: tid 0x%x len 0x%x\n", tid, len);
- indent(++level);
+ p_indent(++level, 0);
printf("ec 0x%x info ", get_u16(frm));
if (frm->len > 0) {
raw_dump(0, frm);
print_srv_srch_pat(++level, frm);
/* Parse MaximumServiceRecordCount */
- indent(level);
+ p_indent(level, 0);
printf("max 0x%x\n", get_u16(frm));
}
printf("SDP SS Rsp: tid 0x%x len 0x%x\n", tid, len);
- indent(++level);
+ p_indent(++level, 0);
printf("cur 0x%x tot 0x%x", cur_srv_rec_cnt, tot_srv_rec_cnt);
/* Parse service record handle(s) */
printf("SDP SA Req: tid 0x%x len 0x%x\n", tid, len);
/* Parse ServiceRecordHandle */
- indent(++level);
+ p_indent(++level, 0);
printf("hndl 0x%x\n", get_u32(frm));
/* Parse MaximumAttributeByteCount */
- indent(level);
+ p_indent(level, 0);
printf("max 0x%x\n", get_u16(frm));
/* Parse ServiceSearchPattern */
printf("SDP SA Rsp: tid 0x%x len 0x%x\n", tid, len);
/* Parse AttributeByteCount */
- indent(++level);
+ p_indent(++level, 0);
printf("cnt 0x%x\n", get_u16(frm));
/* Parse AttributeList */
print_srv_srch_pat(++level, frm);
/* Parse MaximumAttributeByteCount */
- indent(level);
+ p_indent(level, 0);
printf("max 0x%x\n", get_u16(frm));
/* Parse AttributeList */
printf("SDP SSA Rsp: tid 0x%x len 0x%x\n", tid, len);
/* Parse AttributeByteCount */
- indent(++level);
+ p_indent(++level, 0);
printf("cnt 0x%x\n", get_u16(frm));
/* Parse AttributeLists */
frm->ptr += SDP_PDU_HDR_SIZE;
frm->len -= SDP_PDU_HDR_SIZE;
- indent(++level);
+ p_indent(++level, frm->in);
switch(hdr->pid) {
case SDP_ERROR_RSP:
{
/* Parse ContinuationState */
if (*(__u8*) frm->ptr) {
- indent(++level);
+ p_indent(++level, frm->in);
printf("cont ");
raw_dump(0, frm);
}