static inline void mcc_fcoff(int level, uint8_t *ptr, int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
printf("FCOFF %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
}
static inline void mcc_rpn(int level, uint8_t *ptr, unsigned int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
rpn_msg *rpn = (void *) (ptr - STRUCT_END(rpn_msg, mcc_s_head));
printf("RPN %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
p_indent(level, 0);
printf("dlci %d ", GET_DLCI(rpn->dlci));
/* Assuming that rpn_val is _declared_ as a member of rpn_msg... */
if (len <= STRUCT_OFFSET(rpn_msg, rpn_val) - STRUCT_END(rpn_msg, mcc_s_head)) {
printf("\n");
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 0x%04x\n",
rpn->rpn_val.rtr_input, rpn->rpn_val.rtr_output,
rpn->rpn_val.rtc_input, rpn->rpn_val.rtc_output,
rpn->rpn_val.xon, rpn->rpn_val.xoff, btohs(rpn->rpn_val.pm));
}
static inline void mcc_frame(int level, struct frame *frm, long_frame_head *head)
{
mcc_short_frame_head *mcc_short_head_p = frm->ptr;
mcc_long_frame_head mcc_head;
uint8_t hdr_size;
if ( mcc_short_head_p->length.ea == EA ) {
mcc_head.type = mcc_short_head_p->type;
mcc_head.length.bits.len = mcc_short_head_p->length.len;
hdr_size = sizeof(mcc_short_frame_head);
} else {
mcc_head = *(mcc_long_frame_head *)frm->ptr;
mcc_head.length.val = btohs(mcc_head.length.val);
hdr_size = sizeof(mcc_long_frame_head);
}
frm->ptr += hdr_size;
frm->len -= hdr_size;
p_indent(level, frm);
printf("RFCOMM(s): ");
switch (mcc_head.type.type) {
case TEST:
mcc_test(level, frm->ptr, frm->len, head, &mcc_head);
raw_dump(level, frm);
break;
case FCON:
mcc_fcon(level, frm->ptr, frm->len, head, &mcc_head);
break;
case FCOFF:
mcc_fcoff(level, frm->ptr, frm->len, head, &mcc_head);
break;
case MSC:
mcc_msc(level, frm->ptr, frm->len, head, &mcc_head);
break;
case RPN:
mcc_rpn(level, frm->ptr, frm->len, head, &mcc_head);
break;
case RLS:
mcc_rls(level, frm->ptr, frm->len, head, &mcc_head);
break;
case PN:
mcc_pn(level, frm->ptr, frm->len, head, &mcc_head);
break;
case NSC:
mcc_nsc(level, frm->ptr, frm->len, head, &mcc_head);
break;
default:
printf("MCC message type 0x%02x: ", mcc_head.type.type);
print_rfcomm_hdr(head, frm->ptr, frm->len);
printf("\n");
frm->len--;
raw_dump(level, frm);
}
}
static inline void mcc_rls(int level, uint8_t *ptr, int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
rls_msg* rls = (void*) (ptr - STRUCT_END(rls_msg, mcc_s_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->dlci), rls->error);
}
static inline void uih_frame(int level, struct frame *frm, long_frame_head *head)
{
uint32_t proto;
if (!head->addr.server_chn) {
mcc_frame(level, frm, head);
} else {
p_indent(level, frm);
printf("RFCOMM(d): UIH: ");
print_rfcomm_hdr(head, frm->ptr, frm->len);
if (GET_PF(head->control)) {
printf("credits %d\n", *(uint8_t *)(frm->ptr));
frm->ptr++;
frm->len--;
} else
printf("\n");
frm->len--;
frm->dlci = GET_DLCI(head->addr);
frm->channel = head->addr.server_chn;
proto = get_proto(frm->handle, RFCOMM_PSM, frm->channel);
if (frm->len > 0) {
switch (proto) {
case SDP_UUID_OBEX:
if (!p_filter(FILT_OBEX))
obex_dump(level + 1, frm);
else
raw_dump(level, frm);
break;
case SDP_UUID_LAN_ACCESS_PPP:
case SDP_UUID_DIALUP_NETWORKING:
if (!p_filter(FILT_PPP))
ppp_dump(level + 1, frm);
else
raw_dump(level, frm);
break;
default:
if (p_filter(FILT_RFCOMM))
break;
raw_dump(level, frm);
break;
}
}
}
}
static inline void mcc_nsc(int level, uint8_t *ptr, int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
nsc_msg *nsc = (void*) (ptr - STRUCT_END(nsc_msg, mcc_s_head));
printf("NSC %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
p_indent(level, 0);
printf("cr %d, mcc_cmd_type %x\n",
nsc->command_type.cr, nsc->command_type.type );
}
void rfcomm_dump(int level, struct frame *frm)
{
uint8_t hdr_size, ctr_type;
short_frame_head *short_head_p = (void *) frm->ptr;
long_frame_head head;
if (short_head_p->length.ea == EA) {
head.addr = short_head_p->addr;
head.control = short_head_p->control;
head.length.bits.len = short_head_p->length.len;
hdr_size = sizeof(short_frame_head);
} else {
head = *(long_frame_head *) frm->ptr;
head.length.val = btohs(head.length.val);
hdr_size = sizeof(long_frame_head);
}
frm->ptr += hdr_size;
frm->len -= hdr_size;
ctr_type = CLR_PF(head.control);
if (ctr_type == UIH) {
uih_frame(level, frm, &head);
} else {
p_indent(level, frm);
printf("RFCOMM(s): ");
switch (ctr_type) {
case SABM:
printf("SABM: ");
break;
case UA:
printf("UA: ");
break;
case DM:
printf("DM: ");
break;
case DISC:
printf("DISC: ");
del_frame(frm->handle, GET_DLCI(head.addr));
break;
default:
printf("ERR: ");
}
print_rfcomm_hdr(&head, frm->ptr, frm->len);
printf("\n");
}
}
static inline void mcc_pn(int level, uint8_t *ptr, int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
pn_msg *pn = (void*) (ptr - STRUCT_END(pn_msg, mcc_s_head));
printf("PN %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
p_indent(level, 0);
printf("dlci %d frame_type %d credit_flow %d pri %d ack_timer %d\n",
pn->dlci, pn->frame_type, pn->credit_flow, pn->prior, pn->ack_timer);
p_indent(level, 0);
printf("frame_size %d max_retrans %d credits %d\n",
btohs(pn->frame_size), pn->max_nbrof_retrans, pn->credits);
}
static inline void mcc_msc(int level, uint8_t *ptr, unsigned int len,
long_frame_head *head, mcc_long_frame_head *mcc_head)
{
msc_msg *msc = (void*) (ptr - STRUCT_END(msc_msg, mcc_s_head));
printf("MSC %s: ", CR_STR(mcc_head));
print_rfcomm_hdr(head, ptr, len);
print_mcc(mcc_head);
p_indent(level, 0);
printf("dlci %d fc %d rtc %d rtr %d ic %d dv %d",
GET_DLCI(msc->dlci), msc->v24_sigs.fc, msc->v24_sigs.rtc,
msc->v24_sigs.rtr, msc->v24_sigs.ic, msc->v24_sigs.dv );
/* Assuming that break_signals field is _not declared_ in struct msc_msg... */
if (len > STRUCT_OFFSET(msc_msg, fcs) - STRUCT_END(msc_msg, v24_sigs)) {
break_signals *brk = (break_signals *)
(ptr + STRUCT_END(msc_msg, v24_sigs));
printf(" b1 %d b2 %d b3 %d len %d\n",
brk->b1, brk->b2, brk->b3, brk->len);
} else
printf("\n");
}
void rfcomm_packet(const struct l2cap_frame *frame)
{
uint8_t ctype, length, ex_length, indent = 1;
const char *frame_str, *frame_color;
struct l2cap_frame *l2cap_frame, tmp_frame;
struct rfcomm_frame rfcomm_frame;
struct rfcomm_lhdr hdr;
const struct rfcomm_data *rfcomm_data = NULL;
int i;
l2cap_frame_pull(&rfcomm_frame.l2cap_frame, frame, 0);
l2cap_frame = &rfcomm_frame.l2cap_frame;
if (frame->size < 4)
goto fail;
if (!l2cap_frame_get_u8(l2cap_frame, &hdr.address) ||
!l2cap_frame_get_u8(l2cap_frame, &hdr.control) ||
!l2cap_frame_get_u8(l2cap_frame, &length))
goto fail;
/* length maybe 1 or 2 octets */
if (RFCOMM_TEST_EA(length))
hdr.length = (uint16_t) GET_LEN8(length);
else {
if (!l2cap_frame_get_u8(l2cap_frame, &ex_length))
goto fail;
hdr.length = ((uint16_t)length << 8) | ex_length;
hdr.length = GET_LEN16(hdr.length);
}
l2cap_frame_pull(&tmp_frame, l2cap_frame, l2cap_frame->size-1);
if(!l2cap_frame_get_u8(&tmp_frame, &hdr.fcs))
goto fail;
/* Decoding frame type */
ctype = RFCOMM_GET_TYPE(hdr.control);
for (i = 0; rfcomm_table[i].str; i++) {
if (rfcomm_table[i].frame == ctype) {
rfcomm_data = &rfcomm_table[i];
break;
}
}
if (rfcomm_data) {
if (frame->in)
frame_color = COLOR_MAGENTA;
else
frame_color = COLOR_BLUE;
frame_str = rfcomm_data->str;
} else {
frame_color = COLOR_WHITE_BG;
frame_str = "Unknown";
}
if (!rfcomm_data) {
packet_hexdump(frame->data, frame->size);
return;
}
print_indent(6, frame_color, "RFCOMM: ", frame_str, COLOR_OFF,
"(0x%2.2x)", ctype);
rfcomm_frame.hdr = hdr;
print_rfcomm_hdr(&rfcomm_frame, indent);
/* UIH frame */
if (ctype == 0xef)
if (!uih_frame(&rfcomm_frame, indent))
goto fail;
return;
fail:
print_text(COLOR_ERROR, "Frame too short");
packet_hexdump(frame->data, frame->size);
return;
}
