void
dissect_dm1(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset)
{
int len; /* payload length indicated by payload header */
int llid; /* logical link id */
int l2len; /* length indicated by l2cap header */
proto_item *dm1_item;
proto_tree *dm1_tree;
tvbuff_t *pld_tvb;
/*
* FIXME
* I'm probably doing a terrible, terrible thing here, but it gets my
* initial test cases working.
*/
guint16 fake_acl_data;
if(tvb_reported_length_remaining(tvb, offset) < 3) {
col_add_str(pinfo->cinfo, COL_INFO, "Encrypted or malformed payload data");
return;
}
dm1_item = proto_tree_add_item(tree, hf_btbredr_payload, tvb, offset, -1, ENC_NA);
dm1_tree = proto_item_add_subtree(dm1_item, ett_btbredr_payload);
len = dissect_payload_header1(dm1_tree, tvb, offset);
llid = tvb_get_guint8(tvb, offset) & 0x3;
offset += 1;
if(tvb_reported_length_remaining(tvb, offset) < len + 2) {
col_add_str(pinfo->cinfo, COL_INFO, "Encrypted or malformed payload data");
return;
}
if (llid == 3 && btlmp_handle) {
/* LMP */
pld_tvb = tvb_new_subset(tvb, offset, len, len);
call_dissector(btlmp_handle, pld_tvb, pinfo, dm1_tree);
} else if (llid == 2 && btl2cap_handle) {
/* unfragmented L2CAP or start of fragment */
l2len = tvb_get_letohs(tvb, offset);
if (l2len + 4 == len) {
/* unfragmented */
pld_tvb = tvb_new_subset(tvb, offset, len, len);
call_dissector_with_data(btl2cap_handle, pld_tvb, pinfo, dm1_tree, &fake_acl_data);
} else {
/* start of fragment */
proto_tree_add_item(dm1_tree, hf_btbredr_pldbody, tvb, offset, len, ENC_NA);
}
} else {
proto_tree_add_item(dm1_tree, hf_btbredr_pldbody, tvb, offset, len, ENC_NA);
}
offset += len;
proto_tree_add_item(dm1_tree, hf_btbredr_crc, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
}
static void
dissect_bthcrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *main_item;
proto_tree *main_tree;
btl2cap_data_t *l2cap_data;
gint offset = 0;
gboolean is_client_message;
l2cap_data = (btl2cap_data_t *) pinfo->private_data;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HCRP");
col_clear(pinfo->cinfo, COL_INFO);
switch (pinfo->p2p_dir) {
case P2P_DIR_SENT:
col_add_str(pinfo->cinfo, COL_INFO, "Sent ");
break;
case P2P_DIR_RECV:
col_add_str(pinfo->cinfo, COL_INFO, "Rcvd ");
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unknown direction %d ",
pinfo->p2p_dir);
break;
}
main_item = proto_tree_add_item(tree, proto_bthcrp, tvb, offset, -1, ENC_NA);
main_tree = proto_item_add_subtree(main_item, ett_bthcrp);
/* TODO: Implement streams reconizing by SDP
* Server provide SDP record for Control and Data PSM
* Client provide SDP record for Notification PSM (optional)
*/
is_client_message = (is_client && pinfo->p2p_dir == P2P_DIR_SENT) ||
(!is_client && pinfo->p2p_dir == P2P_DIR_RECV);
if (psm_control != 0 && l2cap_data->psm == psm_control) {
offset = dissect_control(tvb, pinfo, main_tree, offset, is_client_message);
} else if (psm_data_stream != 0 && l2cap_data->psm == psm_data_stream) {
offset = dissect_data(tvb, pinfo, main_tree, offset);
} else if (psm_notification != 0 && l2cap_data->psm == psm_notification) {
offset = dissect_notification(tvb, pinfo, main_tree, offset, is_client_message);
} else {
col_append_fstr(pinfo->cinfo, COL_INFO, "HCRP stream (CID: 0x%04X)", l2cap_data->cid);
}
if (tvb_length_remaining(tvb, offset)) {
proto_item *pitem;
pitem = proto_tree_add_item(main_tree, hf_bthcrp_data, tvb, offset, -1, ENC_NA);
expert_add_info_format(pinfo, pitem, PI_PROTOCOL, PI_WARN,
"Unexpected data");
}
}
static void
dissect_teimanagement(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *tei_tree = NULL;
proto_item *tei_ti;
guint8 message;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TEI");
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
tei_ti = proto_tree_add_item(tree, proto_tei, tvb, 0, 5, ENC_NA);
tei_tree = proto_item_add_subtree(tei_ti, lm_subtree);
proto_tree_add_item(tei_tree, lm_entity_id, tvb, 0, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tei_tree, lm_reference, tvb, 1, 2, ENC_BIG_ENDIAN);
}
message = tvb_get_guint8(tvb, 3);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(message, tei_msg_vals, "Unknown message type (0x%04x)"));
if (tree) {
proto_tree_add_uint(tei_tree, lm_message, tvb, 3, 1, message);
proto_tree_add_item(tei_tree, lm_action, tvb, 4, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tei_tree, lm_extend, tvb, 4, 1, ENC_BIG_ENDIAN);
}
}
WSLUA_METAMETHOD Columns__newindex(lua_State *L) {
/* Sets the text of a specific column */
#define WSLUA_ARG_Columns__newindex_COLUMN 2 /* The name of the column to set */
#define WSLUA_ARG_Columns__newindex_TEXT 3 /* The text for the column */
Columns cols = checkColumns(L,1);
const struct col_names_t* cn;
const char* colname;
const char* text;
if (!cols) return 0;
if (cols->expired) {
luaL_error(L,"expired column");
return 0;
}
colname = luaL_checkstring(L,WSLUA_ARG_Columns__newindex_COLUMN);
text = luaL_checkstring(L,WSLUA_ARG_Columns__newindex_TEXT);
for(cn = colnames; cn->name; cn++) {
if( g_str_equal(cn->name,colname) ) {
col_add_str(cols->cinfo, cn->id, text);
return 0;
}
}
WSLUA_ARG_ERROR(Columns__newindex,COLUMN,"the column name must be a valid column");
}
static void
dissect_asf(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *asf_tree = NULL;
proto_item *ti;
guint8 type;
guint8 len;
tvbuff_t *next_tvb;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ASF");
col_clear(pinfo->cinfo, COL_INFO);
type = tvb_get_guint8(tvb, 4);
len = tvb_get_guint8(tvb, 7);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(type, asf_type_vals, "Unknown (0x%02x)"));
if (tree) {
ti = proto_tree_add_item(tree, proto_asf, tvb, 0, 8, FALSE);
asf_tree = proto_item_add_subtree(ti, ett_asf);
/* FIXME: resolve enterprise ID */
proto_tree_add_item(asf_tree, hf_asf_iana, tvb, 0, 4, FALSE);
proto_tree_add_item(asf_tree, hf_asf_type, tvb, 4, 1, FALSE);
proto_tree_add_item(asf_tree, hf_asf_tag, tvb, 5, 1, FALSE);
proto_tree_add_item(asf_tree, hf_asf_len, tvb, 7, 1, FALSE);
}
if (len) {
next_tvb = tvb_new_subset(tvb, 8, -1, len);
call_dissector(data_handle, next_tvb, pinfo, tree);
}
}
static gboolean ParseCommand(proto_tree *tree,tvbuff_t *tvb, int offset, packet_info *pinfo,UI16_T dataLen)
{
UI8_T pAddress[1024];
UI16_T SQLDataLen = dataLen;
int i;
UI8_P pAddr;
for (i=0; i<1024; i++)
{
pAddress[i] = '\0';
}
tvb_memcpy (tvb, pAddress,offset, dataLen);
pAddr = (UI8_P)pAddress;
/* see if SQL statement is there */
if (FindBeginningSQLString((UI8_P*)&pAddr, &SQLDataLen, 0x30) == TRUE)
{
ParseSqlStatement( pAddr, dataLen);
if (tree)
proto_tree_add_text(tree, tvb, offset+dataLen-SQLDataLen, SQLDataLen,
"SQL statement = %s",m_pCurQuery);
col_clear(pinfo->cinfo, COL_INFO);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, m_pCurQuery );
return TRUE;
}
return FALSE;
}
static void dissect_fcsp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *ti = NULL;
guint8 opcode;
int offset = 0;
proto_tree *fcsp_tree = NULL;
/* Make entry in the Info column on summary display */
opcode = tvb_get_guint8 (tvb, 2);
if (check_col (pinfo->cinfo, COL_INFO)) {
col_add_str (pinfo->cinfo, COL_INFO,
val_to_str (opcode, fcauth_msgcode_vals, "0x%x"));
}
if (tree) {
ti = proto_tree_add_protocol_format (tree, proto_fcsp, tvb, 0,
tvb_length (tvb), "FC-SP");
fcsp_tree = proto_item_add_subtree (ti, ett_fcsp);
proto_tree_add_item (fcsp_tree, hf_auth_flags, tvb, offset+1, 1, 0);
proto_tree_add_item (fcsp_tree, hf_auth_msg_code, tvb, offset+2, 1, 0);
proto_tree_add_item (fcsp_tree, hf_auth_proto_ver, tvb, offset+3, 1,
0);
proto_tree_add_item (fcsp_tree, hf_auth_len, tvb, offset+4, 4, 0);
proto_tree_add_item (fcsp_tree, hf_auth_tid, tvb, offset+8, 4, 0);
switch (opcode) {
case FC_AUTH_MSG_AUTH_REJECT:
dissect_fcsp_auth_rjt (tvb, tree);
break;
case FC_AUTH_MSG_AUTH_NEGOTIATE:
dissect_fcsp_auth_negotiate (tvb, tree);
break;
case FC_AUTH_MSG_AUTH_DONE:
dissect_fcsp_auth_done (tvb, tree);
break;
case FC_AUTH_DHCHAP_CHALLENGE:
dissect_fcsp_dhchap_challenge (tvb, tree);
break;
case FC_AUTH_DHCHAP_REPLY:
dissect_fcsp_dhchap_reply (tvb, tree);
break;
case FC_AUTH_DHCHAP_SUCCESS:
dissect_fcsp_dhchap_success (tvb, tree);
break;
case FC_AUTH_FCAP_REQUEST:
case FC_AUTH_FCAP_ACKNOWLEDGE:
case FC_AUTH_FCAP_CONFIRM:
case FC_AUTH_FCPAP_INIT:
case FC_AUTH_FCPAP_ACCEPT:
case FC_AUTH_FCPAP_COMPLETE:
proto_tree_add_text (fcsp_tree, tvb, offset+12, tvb_length (tvb),
"FCAP Decoding Not Supported");
break;
default:
break;
}
}
}
/*
* Dissect the raw IrCOMM/IrLPT protocol
*/
static void dissect_raw_ircomm(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root)
{
unsigned len = tvb_length(tvb);
if (len == 0)
return;
/* Make entries in Protocol column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IrCOMM");
if (check_col(pinfo->cinfo, COL_INFO))
{
char buf[128];
g_snprintf(buf, 128, "User Data: %d byte%s", len, (len > 1)? "s": "");
col_add_str(pinfo->cinfo, COL_INFO, buf);
}
if (root)
{
/* create display subtree for the protocol */
proto_item* ti = proto_tree_add_item(root, proto_ircomm, tvb, 0, -1, FALSE);
proto_tree* tree = proto_item_add_subtree(ti, ett_ircomm);
call_dissector(data_handle, tvb, pinfo, tree);
}
}
static void dissect_ioraw(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *ti;
proto_tree *ioraw_tree;
gint offset = 0;
char szText[200];
int nMax = sizeof(szText)-1;
guint ioraw_length = tvb_reported_length(tvb);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IO-RAW");
IoRawSummaryFormater(szText, nMax);
col_add_str(pinfo->cinfo, COL_INFO, szText);
if (tree)
{
ti = proto_tree_add_item(tree, proto_ioraw, tvb, 0, -1, ENC_NA);
ioraw_tree = proto_item_add_subtree(ti, ett_ioraw);
proto_item_append_text(ti,": %s",szText);
proto_tree_add_item(ioraw_tree, hf_ioraw_header, tvb, offset, IoRawParserHDR_Len, ENC_NA);
offset+=IoRawParserHDR_Len;
proto_tree_add_item(ioraw_tree, hf_ioraw_data, tvb, offset, ioraw_length - offset, ENC_NA);
}
}
static void
dissect_rsh(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *rsh_tree;
proto_item *ti, *hidden_item;
gint offset = 0;
gint next_offset;
int linelen;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RSH");
if (check_col(pinfo->cinfo, COL_INFO)) {
/* Put the first line from the buffer into the summary. */
tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
linelen = next_offset - offset; /* include the line terminator */
/*
* Make sure the line terminator isn't past the end of
* the captured data in the packet, so we don't throw
* an exception in the "tvb_get_ptr()" call.
*/
if (linelen > (int) tvb_length(tvb))
linelen = tvb_length(tvb);
col_add_str(pinfo->cinfo, COL_INFO,
tvb_format_text(tvb, offset, linelen));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_rsh, tvb, offset, -1,
FALSE);
rsh_tree = proto_item_add_subtree(ti, ett_rsh);
/*
* Process the packet data, a line at a time.
*/
while (tvb_offset_exists(tvb, offset)) {
/*
* Find the end of the line.
*/
tvb_find_line_end(tvb, offset, -1, &next_offset,
FALSE);
/*
* Put this line.
*/
proto_tree_add_text(rsh_tree, tvb, offset,
next_offset - offset, "%s",
tvb_format_text(tvb, offset, next_offset - offset));
offset = next_offset;
}
if (pinfo->match_port == pinfo->destport) {
hidden_item = proto_tree_add_boolean(rsh_tree,
hf_rsh_request, tvb, 0, 0, 1);
} else {
hidden_item = proto_tree_add_boolean(rsh_tree,
hf_rsh_response, tvb, 0, 0, 1);
}
PROTO_ITEM_SET_HIDDEN(hidden_item);
}
}
static void
dissect_msnms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *msnms_tree;
proto_item *ti;
gint offset = 0;
const guchar *line;
gint next_offset;
int linelen;
/* int tokenlen; */
/* const guchar *next_token; */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MSNMS");
/*
* Find the end of the first line.
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
if (check_col(pinfo->cinfo, COL_INFO)) {
/*
* Put the first line from the buffer into the summary.
*/
col_add_str(pinfo->cinfo, COL_INFO,
format_text(line, linelen));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_msnms, tvb, offset, -1,
FALSE);
msnms_tree = proto_item_add_subtree(ti, ett_msnms);
/*
* Show the rest of the packet as text,
* a line at a time.
*/
while (tvb_offset_exists(tvb, offset)) {
/*
* Find the end of the line.
*/
linelen = tvb_find_line_end(tvb, offset, -1,
&next_offset, FALSE);
/*
* Put this line.
*/
proto_tree_add_text(msnms_tree, tvb, offset,
next_offset - offset, "%s",
tvb_format_text(tvb, offset, next_offset - offset));
offset = next_offset;
}
}
}
static void
expert_set_info_vformat(packet_info *pinfo, proto_item *pi, int group, int severity, const char *format, va_list ap)
{
char formatted[ITEM_LABEL_LENGTH];
int tap;
expert_info_t *ei;
proto_tree *tree;
proto_item *ti;
/* if this packet isn't loaded because of a read filter, don't output anything */
if (pinfo == NULL || PINFO_FD_NUM(pinfo) == 0) {
return;
}
if (severity > highest_severity) {
highest_severity = severity;
}
if (pi != NULL && PITEM_FINFO(pi) != NULL) {
expert_set_item_flags(pi, group, severity);
}
col_add_str(pinfo->cinfo, COL_EXPERT, val_to_str(severity, expert_severity_vals, "Unknown (%u)"));
g_vsnprintf(formatted, ITEM_LABEL_LENGTH, format, ap);
tree = expert_create_tree(pi, group, severity, formatted);
ti = proto_tree_add_string(tree, hf_expert_msg, NULL, 0, 0, formatted);
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_uint_format_value(tree, hf_expert_severity, NULL, 0, 0, severity,
"%s", val_to_str_const(severity, expert_severity_vals, "Unknown"));
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_uint_format_value(tree, hf_expert_group, NULL, 0, 0, group,
"%s", val_to_str_const(group, expert_group_vals, "Unknown"));
PROTO_ITEM_SET_GENERATED(ti);
tap = have_tap_listener(expert_tap);
if (!tap)
return;
ei = ep_alloc(sizeof(expert_info_t));
ei->packet_num = PINFO_FD_NUM(pinfo);
ei->group = group;
ei->severity = severity;
ei->protocol = pinfo->current_proto;
ei->summary = ep_strdup(formatted);
/* if we have a proto_item (not a faked item), set expert attributes to it */
if (pi != NULL && PITEM_FINFO(pi) != NULL) {
ei->pitem = pi;
} else {
ei->pitem = NULL;
}
tap_queue_packet(expert_tap, pinfo, ei);
}
static void
dissect_msdp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *ti;
proto_tree *msdp_tree;
int offset;
guint8 type;
guint16 length;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MSDP");
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, val_to_str_const(tvb_get_guint8(tvb, 0),
msdp_types,
"<Unknown MSDP message type>"));
ti = proto_tree_add_item(tree, proto_msdp, tvb, 0, -1, ENC_NA);
msdp_tree = proto_item_add_subtree(ti, ett_msdp);
offset = 0;
while (tvb_reported_length_remaining(tvb, offset) >= 3) {
type = tvb_get_guint8(tvb, offset);
length = tvb_get_ntohs(tvb, offset + 1);
if (length < 3)
break;
proto_tree_add_uint(msdp_tree, hf_msdp_type, tvb, offset, 1, type);
proto_tree_add_uint(msdp_tree, hf_msdp_length, tvb, offset + 1, 2, length);
offset += 3;
length -= 3;
switch (type) {
case MSDP_SA:
case MSDP_SA_RSP:
dissect_msdp_sa(tvb, pinfo, msdp_tree, &offset,
length);
break;
case MSDP_SA_REQ:
proto_tree_add_item(msdp_tree, hf_msdp_sa_req_res, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(msdp_tree, hf_msdp_sa_req_group, tvb, offset + 1, 4, ENC_BIG_ENDIAN);
offset += 5;
break;
case MSDP_NOTIFICATION:
dissect_msdp_notification(tvb, pinfo, msdp_tree, &offset, length);
break;
default:
if (length > 0)
proto_tree_add_text(msdp_tree, tvb, offset, length, "TLV contents");
offset += length;
break;
}
}
if (tvb_length_remaining(tvb, offset) > 0)
proto_tree_add_text(msdp_tree, tvb, offset,
-1, "Trailing junk");
return;
}
static void
dissect_tsp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *tsp_tree = NULL;
proto_item *tsp_item = NULL;
guint8 tsp_type;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TSP");
col_clear(pinfo->cinfo, COL_INFO);
tsp_type = tvb_get_guint8(tvb, 0);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(tsp_type, names_tsp_type, "Unknown message type (%u)"));
if (tree) {
tsp_item = proto_tree_add_item(tree, proto_tsp,
tvb, 0, -1, FALSE);
if (tsp_item)
tsp_tree = proto_item_add_subtree(tsp_item, ett_tsp);
}
if (tsp_tree) {
proto_tree_add_uint(tsp_tree, hf_tsp_type,
tvb, 0, 1, tsp_type);
proto_tree_add_item(tsp_tree, hf_tsp_vers,
tvb, 1, 1, FALSE);
proto_tree_add_item(tsp_tree, hf_tsp_seq,
tvb, 2, 2, FALSE);
}
switch (tsp_type) {
case TSP_LOOP:
if (tsp_tree)
proto_tree_add_item(tsp_tree, hf_tsp_hopcnt,
tvb, 4, 1, FALSE);
break;
case TSP_SETTIME:
case TSP_ADJTIME:
case TSP_SETDATE:
case TSP_SETDATEREQ:
if (tsp_tree) {
proto_tree_add_item(tsp_tree, hf_tsp_time_sec,
tvb, 4, 4, FALSE);
proto_tree_add_item(tsp_tree, hf_tsp_time_usec,
tvb, 8, 4, FALSE);
}
break;
}
if (tsp_tree) {
proto_tree_add_item(tsp_tree, hf_tsp_name, tvb, 12,
-1, FALSE);
}
}
static void
dissect_lmi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *lmi_tree = NULL, *lmi_subtree;
proto_item *ti;
int offset = 2, len;
guint8 msg_type;
guint8 ele_id;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "LMI");
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
ti = proto_tree_add_item(tree, proto_lmi, tvb, 0, 3, FALSE);
lmi_tree = proto_item_add_subtree(ti, ett_lmi_ele);
proto_tree_add_item(lmi_tree, hf_lmi_call_ref, tvb, 0, 1, FALSE);
}
msg_type = tvb_get_guint8( tvb, 1);
if (check_col(pinfo->cinfo, COL_INFO)) {
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(msg_type, msg_type_str, "Unknown message type (0x%02x)"));
}
if (tree) {
proto_tree_add_uint(lmi_tree, hf_lmi_msg_type, tvb, 1, 1, msg_type);
/* Display the LMI elements */
while (tvb_reported_length_remaining(tvb, offset) > 0) {
ele_id = tvb_get_guint8( tvb, offset);
len = tvb_get_guint8( tvb, offset + 1);
ti = proto_tree_add_text(lmi_tree, tvb, offset, len + 2,
"Information Element: %s",
val_to_str(ele_id, element_type_str, "Unknown (%u)"));
lmi_subtree = proto_item_add_subtree(ti, ett_lmi_ele);
proto_tree_add_uint(lmi_subtree, hf_lmi_inf_ele, tvb, offset, 1,
ele_id);
++offset;
proto_tree_add_uint(lmi_subtree, hf_lmi_inf_len, tvb, offset, 1, len);
++offset;
if (( ele_id == 1) || (ele_id == 51))
dissect_lmi_report_type( tvb, offset, lmi_subtree);
else if (( ele_id == 3) || (ele_id == 53))
dissect_lmi_link_int( tvb, offset, lmi_subtree);
else if (( ele_id == 7) || (ele_id == 57))
dissect_lmi_pvc_status( tvb, offset, lmi_subtree);
offset += len;
}
}
else {
lmi_tree = NULL;
}
}
static void
dissect_pptp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
int offset = 0;
guint16 len;
guint16 cntrl_type;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PPTP");
col_clear(pinfo->cinfo, COL_INFO);
len = tvb_get_ntohs(tvb, offset);
cntrl_type = tvb_get_ntohs(tvb, offset + 8);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, cntrltype2str(cntrl_type));
if (tree) {
guint32 cookie;
proto_item * ti;
proto_tree * pptp_tree;
ti = proto_tree_add_item(tree, proto_pptp, tvb, offset, len, FALSE);
pptp_tree = proto_item_add_subtree(ti, ett_pptp);
proto_tree_add_text(pptp_tree, tvb, offset, 2, "Length: %u", len);
offset += 2;
proto_tree_add_item(pptp_tree, hf_pptp_message_type, tvb,
offset, 2, FALSE);
offset += 2;
cookie = tvb_get_ntohl(tvb, offset);
if (cookie == MAGIC_COOKIE)
proto_tree_add_text(pptp_tree, tvb, offset, 4,
"Cookie: %#08x (correct)", cookie);
else
proto_tree_add_text(pptp_tree, tvb, offset, 4,
"Cookie: %#08x (incorrect)", cookie);
offset += 4;
proto_tree_add_text(pptp_tree, tvb, offset, 2,
"Control type: %s (%u)", cntrltype2str(cntrl_type), cntrl_type);
offset += 2;
proto_tree_add_text(pptp_tree, tvb, offset, 2,
"Reserved: %u", tvb_get_ntohs(tvb, offset));
offset += 2;
if (cntrl_type < NUM_CNTRL_TYPES)
( *(strfuncs[cntrl_type].func))(tvb, offset, pinfo, pptp_tree);
else
call_dissector(data_handle,tvb_new_subset_remaining(tvb, offset), pinfo, pptp_tree);
}
}
void
dissect_fhs(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int offset)
{
proto_item *fhs_item, *psmode_item;
proto_tree *fhs_tree;
const gchar *description;
guint8 psmode;
if(tvb_reported_length_remaining(tvb, offset) != 20) {
col_add_str(pinfo->cinfo, COL_INFO, "Encrypted or malformed payload data");
return;
}
fhs_item = proto_tree_add_item(tree, hf_btbredr_payload, tvb, offset, -1, ENC_NA);
fhs_tree = proto_item_add_subtree(fhs_item, ett_btbredr_payload);
/* Use proto_tree_add_bits_item() to get around 32bit limit on bitmasks */
proto_tree_add_bits_item(fhs_tree, hf_btbredr_fhs_parity, tvb, offset*8, 34, ENC_LITTLE_ENDIAN);
/* proto_tree_add_item(fhs_tree, hf_btbredr_fhs_parity, tvb, offset, 5, ENC_LITTLE_ENDIAN); */
offset += 4;
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_lap, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 3;
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_eir, tvb, offset, 1, ENC_NA);
/* skipping 1 undefined bit */
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_sr, tvb, offset, 1, ENC_NA);
/* skipping 2 reserved bits */
offset += 1;
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_uap, tvb, offset, 1, ENC_NA);
offset += 1;
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_nap, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_class, tvb, offset, 3, ENC_LITTLE_ENDIAN);
offset += 3;
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_ltaddr, tvb, offset, 1, ENC_NA);
proto_tree_add_item(fhs_tree, hf_btbredr_fhs_clk, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 3;
psmode = tvb_get_guint8(tvb, offset);
description = try_rval_to_str(psmode, ps_modes);
psmode_item = proto_tree_add_item(fhs_tree, hf_btbredr_fhs_psmode, tvb, offset, 1, ENC_NA);
if (description)
proto_item_append_text(psmode_item, " (%s)", description);
offset += 1;
proto_tree_add_item(fhs_tree, hf_btbredr_crc, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
}
WSLUA_METHOD Column_set(lua_State *L) {
/* Sets the text of a Column. */
#define WSLUA_ARG_Column_set_TEXT 2 /* The text to which to set the Column. */
Column c = checkColumn(L,1);
const gchar* s = luaL_checkstring(L,WSLUA_ARG_Column_set_TEXT);
if (!(c->cinfo))
return 0;
col_add_str(c->cinfo, c->col, s);
return 0;
}
static int dissect_bjnp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *bjnp_tree;
proto_item *ti;
gint offset = 0;
guint32 payload_len;
guint8 dev_type, cmd_code;
gchar *info;
col_set_str (pinfo->cinfo, COL_PROTOCOL, PSNAME);
col_clear (pinfo->cinfo, COL_INFO);
ti = proto_tree_add_item (tree, proto_bjnp, tvb, offset, -1, ENC_NA);
bjnp_tree = proto_item_add_subtree (ti, ett_bjnp);
proto_tree_add_item (bjnp_tree, hf_bjnp_id, tvb, offset, 4, ENC_ASCII|ENC_NA);
offset += 4;
dev_type = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (bjnp_tree, hf_dev_type, tvb, offset, 1, ENC_BIG_ENDIAN);
offset++;
cmd_code = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (bjnp_tree, hf_cmd_code, tvb, offset, 1, ENC_BIG_ENDIAN);
offset++;
info = g_strdup_printf ("%s: %s",val_to_str (dev_type, dev_type_vals, "Unknown type (%d)"),
val_to_str (cmd_code, cmd_code_vals, "Unknown code (%d)"));
proto_item_append_text (ti, ", %s", info);
col_add_str (pinfo->cinfo, COL_INFO, info);
g_free (info);
proto_tree_add_item (bjnp_tree, hf_seq_no, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item (bjnp_tree, hf_session_id, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
payload_len = tvb_get_ntohl (tvb, offset);
proto_tree_add_item (bjnp_tree, hf_payload_len, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
if (payload_len > 0) {
/* TBD: Dissect various commands */
proto_tree_add_item (bjnp_tree, hf_payload, tvb, offset, payload_len, ENC_NA);
offset += payload_len;
}
return offset;
}
/* This function is only called from the IGMP dissector */
int
dissect_msnip(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
{
proto_tree *tree;
proto_item *item;
guint8 type;
if (!proto_is_protocol_enabled(find_protocol_by_id(proto_msnip))) {
/* we are not enabled, skip entire packet to be nice
to the igmp layer. (so clicking on IGMP will display the data)
*/
return offset+tvb_length_remaining(tvb, offset);
}
item = proto_tree_add_item(parent_tree, proto_msnip, tvb, offset, -1, FALSE);
tree = proto_item_add_subtree(item, ett_msnip);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MSNIP");
col_clear(pinfo->cinfo, COL_INFO);
type = tvb_get_guint8(tvb, offset);
if (check_col(pinfo->cinfo, COL_INFO)) {
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(type, msnip_types,
"Unknown Type:0x%02x"));
}
/* type of command */
proto_tree_add_uint(tree, hf_type, tvb, offset, 1, type);
offset += 1;
switch (type) {
case MSNIP_GM:
offset = dissect_msnip_gm(tvb, pinfo, tree, offset);
break;
case MSNIP_IS:
offset = dissect_msnip_is(tvb, pinfo, tree, offset);
break;
case MSNIP_RMR:
offset = dissect_msnip_rmr(tvb, pinfo, tree, offset);
break;
}
if (item) {
proto_item_set_len(item, offset);
}
return offset;
}
/*
* Dissect the cooked IrCOMM protocol
*/
static void dissect_cooked_ircomm(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root)
{
unsigned offset = 0;
unsigned clen;
if (tvb_length(tvb) == 0)
return;
/* Make entries in Protocol column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IrCOMM");
clen = tvb_get_guint8(tvb, offset);
if (check_col(pinfo->cinfo, COL_INFO))
{
char buf[128];
unsigned len = tvb_length(tvb) - 1 - clen;
if (len > 0)
g_snprintf(buf, 128, "Clen=%d, UserData: %d byte%s", clen, len, (len > 1)? "s": "");
else
g_snprintf(buf, 128, "Clen=%d", clen);
col_add_str(pinfo->cinfo, COL_INFO, buf);
}
if (root)
{
/* create display subtree for the protocol */
proto_item* ti = proto_tree_add_item(root, proto_ircomm, tvb, 0, -1, FALSE);
proto_tree* tree = proto_item_add_subtree(ti, ett_ircomm);
proto_tree* ctrl_tree;
ti = proto_tree_add_item(tree, hf_control, tvb, 0, clen + 1, FALSE);
ctrl_tree = proto_item_add_subtree(ti, ett_ircomm_ctrl);
proto_tree_add_item(ctrl_tree, hf_control_len, tvb, offset, 1, FALSE);
offset++;
{
tvbuff_t *cvalue = tvb_new_subset(tvb, offset, clen, clen);
call_dissector(data_handle, cvalue, pinfo, ctrl_tree);
offset += clen;
}
tvb = tvb_new_subset_remaining(tvb, offset);
call_dissector(data_handle, tvb, pinfo, tree);
}
}
static void
dissect_quakeworld(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *quakeworld_tree = NULL;
int direction;
direction = (pinfo->destport == gbl_quakeworldServerPort) ?
DIR_C2S : DIR_S2C;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "QUAKEWORLD");
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, val_to_str(direction,
names_direction, "%u"));
if (tree) {
proto_item *quakeworld_item;
quakeworld_item = proto_tree_add_item(tree, proto_quakeworld,
tvb, 0, -1, ENC_NA);
quakeworld_tree = proto_item_add_subtree(quakeworld_item, ett_quakeworld);
proto_tree_add_uint_format(quakeworld_tree,
direction == DIR_S2C ?
hf_quakeworld_s2c :
hf_quakeworld_c2s,
tvb, 0, 0, 1,
"Direction: %s", val_to_str(direction, names_direction, "%u"));
}
if (tvb_get_ntohl(tvb, 0) == 0xffffffff) {
col_append_str(pinfo->cinfo, COL_INFO, " Connectionless");
if (quakeworld_tree)
proto_tree_add_uint_format(quakeworld_tree,
hf_quakeworld_connectionless,
tvb, 0, 0, 1,
"Type: Connectionless");
dissect_quakeworld_ConnectionlessPacket(
tvb, pinfo, quakeworld_tree, direction);
}
else {
col_append_str(pinfo->cinfo, COL_INFO, " Game");
if (quakeworld_tree)
proto_tree_add_uint_format(quakeworld_tree,
hf_quakeworld_game,
tvb, 0, 0, 1,
"Type: Game");
dissect_quakeworld_GamePacket(
tvb, pinfo, quakeworld_tree, direction);
}
}
static void
dissect_cimd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint8 OC; /* Operation Code */
guint8 PN; /* Packet number */
guint16 checksum = 0; /* Checksum */
guint16 pkt_check = 0;
gint etxp = 0; /* ETX position */
gint offset = 0;
gboolean checksumIsValid = TRUE;
guint8 last1, last2, last3;
etxp = tvb_find_guint8(tvb, CIMD_PN_OFFSET + CIMD_PN_LENGTH, -1, CIMD_ETX);
if (etxp == -1) return;
OC = (guint8)strtoul(tvb_get_string_enc(wmem_packet_scope(), tvb, CIMD_OC_OFFSET, CIMD_OC_LENGTH, ENC_ASCII), NULL, 10);
PN = (guint8)strtoul(tvb_get_string_enc(wmem_packet_scope(), tvb, CIMD_PN_OFFSET, CIMD_PN_LENGTH, ENC_ASCII), NULL, 10);
last1 = tvb_get_guint8(tvb, etxp - 1);
last2 = tvb_get_guint8(tvb, etxp - 2);
last3 = tvb_get_guint8(tvb, etxp - 3);
if (last1 == CIMD_DELIM) {
/* valid packet, CC is missing */
} else if (last1 != CIMD_DELIM && last2 != CIMD_DELIM && last3 == CIMD_DELIM) {
/* looks valid, it would be nice to check that last1 and last2 are HEXA */
/* CC is present */
checksum = (guint16)strtoul(tvb_get_string_enc(wmem_packet_scope(), tvb, etxp - 2, 2, ENC_ASCII), NULL, 16);
for (; offset < (etxp - 2); offset++)
{
pkt_check += tvb_get_guint8(tvb, offset);
pkt_check &= 0xFF;
}
checksumIsValid = (checksum == pkt_check);
} else {
checksumIsValid = FALSE;
}
/* Make entries in Protocol column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "CIMD");
if (checksumIsValid)
col_add_str(pinfo->cinfo, COL_INFO, val_to_str(OC, vals_hdr_OC, "Unknown (%d)"));
else
col_add_fstr(pinfo->cinfo, COL_INFO, "%s - %s", val_to_str(OC, vals_hdr_OC, "Unknown (%d)"), "invalid checksum");
dissect_cimd_operation(tvb, tree, etxp, checksum, last1, OC, PN);
}
static int
dissect_asf(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *asf_tree = NULL;
proto_item *ti;
guint8 type;
guint8 len;
tvbuff_t *next_tvb;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ASF");
col_clear(pinfo->cinfo, COL_INFO);
type = tvb_get_guint8(tvb, 4);
len = tvb_get_guint8(tvb, 7);
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(type, asf_type_vals, "Unknown (0x%02x)"));
if (tree) {
ti = proto_tree_add_item(tree, proto_asf, tvb, 0, 8,ENC_NA);
asf_tree = proto_item_add_subtree(ti, ett_asf);
proto_tree_add_item(asf_tree, hf_asf_iana, tvb, 0, 4,ENC_BIG_ENDIAN);
proto_tree_add_item(asf_tree, hf_asf_type, tvb, 4, 1,ENC_BIG_ENDIAN);
proto_tree_add_item(asf_tree, hf_asf_tag, tvb, 5, 1,ENC_BIG_ENDIAN);
proto_tree_add_item(asf_tree, hf_asf_len, tvb, 7, 1,ENC_BIG_ENDIAN);
}
if (len) {
switch(type) {
case ASF_TYPE_OPEN_SESS_RQST:
dissect_asf_open_session_request(tvb, asf_tree, 8, len);
break;
case ASF_TYPE_OPEN_SESS_RESP:
dissect_asf_open_session_response(tvb, asf_tree, 8, len);
break;
/* TODO: Add the rest as captures become available to test. */
default:
next_tvb = tvb_new_subset(tvb, 8, len, len);
call_dissector(data_handle, next_tvb, pinfo, tree);
break;
}
}
return 8 + len;
}
static gboolean ParseNewCommand( proto_tree *tree,tvbuff_t *tvb, int offset, packet_info *pinfo, UI16_T dataLen)
{
UI8_T pAddress[1024];
/* find the first sequence of zeros */
int amount = dataLen - 12;
int i = 0, sqlamount;
UI8_P pAddr;
tvb_memcpy (tvb, pAddress,offset, dataLen);
pAddr = (UI8_P)&pAddress;
for (; i < amount; i++)
{
if (*((UI32_P)((UI8_P)pAddr++)) == 0x0000)
break;
}
/* was there a sequence of 4 zeros */
if (i >= amount)
{
/* free(pAddr); */
return FALSE; /* went past, can not be a sql command */
}
/* look for the end of the zeros */
amount = dataLen - i - 4; /* rest of the data */
pAddr += 3;
for (i = 0; *pAddr++ == 0 && i < amount; i++);
if (i >= amount)
{
/* free (pAddr); */
return FALSE; /* no values after zeros */
}
amount -= i + 1; /* rest of the data */
/* see if SQL statement is there */
sqlamount = amount;
if (FindBeginningSQLString((UI8_P*)&pAddr, (UI16_P)&sqlamount, 13) == TRUE)
{
ParseSqlStatement( pAddr, amount);
col_clear(pinfo->cinfo, COL_INFO);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, m_pCurQuery );
proto_tree_add_text(tree, tvb, offset+amount-sqlamount, sqlamount,
"SQL statement = %s",m_pCurQuery);
return TRUE;
}
return FALSE;
}
/* This function is only called from the IGMP dissector */
int
dissect_mrdisc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
{
proto_tree *tree;
proto_item *item;
guint8 type;
if (!proto_is_protocol_enabled(find_protocol_by_id(proto_mrdisc))) {
/* we are not enabled, skip entire packet to be nice
to the igmp layer. (so clicking on IGMP will display the data)
*/
return offset+tvb_length_remaining(tvb, offset);
}
item = proto_tree_add_item(parent_tree, proto_mrdisc, tvb, offset, 0, ENC_NA);
tree = proto_item_add_subtree(item, ett_mrdisc);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MRDISC");
col_clear(pinfo->cinfo, COL_INFO);
type = tvb_get_guint8(tvb, offset);
if (check_col(pinfo->cinfo, COL_INFO)) {
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(type, mrdisc_types,
"Unknown Type:0x%02x"));
}
/* type of command */
proto_tree_add_uint(tree, hf_type, tvb, offset, 1, type);
offset += 1;
switch (type) {
case MRDISC_MRA:
offset = dissect_mrdisc_mra(tvb, pinfo, tree, offset);
break;
case MRDISC_MRS:
case MRDISC_MRT:
/* MRS and MRT packets looks the same */
offset = dissect_mrdisc_mrst(tvb, pinfo, tree, offset);
break;
}
return offset;
}
/* Decode both the SB-3 and basic IU header */
static void
dissect_fc_sbccs_sb3_iu_hdr (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
guint offset)
{
proto_item *subti;
proto_tree *sb3hdr_tree;
proto_tree *iuhdr_tree;
guint8 iui, dhflags;
guint type;
/* Decode the basic SB3 and IU header and determine type of frame */
type = get_fc_sbccs_iu_type (tvb, offset);
if (check_col (pinfo->cinfo, COL_INFO)) {
col_add_str (pinfo->cinfo, COL_INFO, val_to_str (type, fc_sbccs_iu_val,
"0x%x"));
}
if (tree) {
/* Dissect SB3 header first */
subti = proto_tree_add_text (tree, tvb, offset, FC_SBCCS_SB3_HDR_SIZE,
"SB-3 Header");
sb3hdr_tree = proto_item_add_subtree (subti, ett_fc_sbccs);
proto_tree_add_item (sb3hdr_tree, hf_sbccs_chid, tvb, offset+1, 1, ENC_BIG_ENDIAN);
proto_tree_add_item (sb3hdr_tree, hf_sbccs_cuid, tvb, offset+3, 1, ENC_BIG_ENDIAN);
proto_tree_add_item (sb3hdr_tree, hf_sbccs_devaddr, tvb, offset+4, 2, ENC_BIG_ENDIAN);
/* Dissect IU Header */
subti = proto_tree_add_text (tree, tvb, offset + FC_SBCCS_SB3_HDR_SIZE,
FC_SBCCS_IU_HDR_SIZE, "IU Header");
iuhdr_tree = proto_item_add_subtree (subti, ett_fc_sbccs);
offset += FC_SBCCS_SB3_HDR_SIZE;
iui = tvb_get_guint8 (tvb, offset);
dissect_iui_flags(iuhdr_tree, tvb, offset, iui);
dhflags = tvb_get_guint8 (tvb, offset+1);
dissect_dh_flags(iuhdr_tree, tvb, offset+1, dhflags);
proto_tree_add_item (iuhdr_tree, hf_sbccs_ccw, tvb, offset+2, 2, ENC_BIG_ENDIAN);
proto_tree_add_item (iuhdr_tree, hf_sbccs_token, tvb, offset+5, 3, ENC_BIG_ENDIAN);
}
}
static void
dissect_trmac(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *mac_tree = NULL;
proto_item *ti;
int mv_length, sv_offset, sv_additional;
guint8 mv_val;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TR MAC");
col_clear(pinfo->cinfo, COL_INFO);
mv_val = tvb_get_guint8(tvb, 3);
/* Interpret the major vector */
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(mv_val, major_vector_vs, "Unknown Major Vector: %u"));
if (tree) {
mv_length = tvb_get_ntohs(tvb, 0);
ti = proto_tree_add_item(tree, proto_trmac, tvb, 0, mv_length, FALSE);
mac_tree = proto_item_add_subtree(ti, ett_tr_mac);
proto_tree_add_uint(mac_tree, hf_trmac_mv, tvb, 3, 1, mv_val);
proto_tree_add_uint_format(mac_tree, hf_trmac_length, tvb, 0, 2, mv_length,
"Total Length: %d bytes", mv_length);
proto_tree_add_uint(mac_tree, hf_trmac_srcclass, tvb, 2, 1, tvb_get_guint8(tvb, 2) & 0x0f);
proto_tree_add_uint(mac_tree, hf_trmac_dstclass, tvb, 2, 1, tvb_get_guint8(tvb, 2) >> 4 );
/* interpret the subvectors */
sv_offset = 4;
while (sv_offset < mv_length) {
sv_additional = sv_text(tvb, sv_offset, mac_tree);
/* if this is a bad packet, we could get a 0-length added here,
* looping forever */
if (sv_additional > 0)
sv_offset += sv_additional;
else
break;
}
}
}
static void
dissect_tuxedo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *tuxedoroot_tree = NULL;
proto_item *ti;
guint32 magic;
guint32 opcode;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TUXEDO");
if (tvb_length(tvb) >= 8)
{
magic = tvb_get_ntohl(tvb, 0);
if (magic == TUXEDO_MAGIC || magic == TUXEDO_SMAGIC)
{
opcode = tvb_get_ntohl(tvb, 4);
if (check_col(pinfo->cinfo, COL_INFO))
{
col_add_str(pinfo->cinfo, COL_INFO, val_to_str(opcode, tuxedo_opcode_vals, "Unknown (0x%02x)"));
}
if (tree)
{
ti = proto_tree_add_item(tree, proto_tuxedo, tvb, 0, -1, FALSE);
tuxedoroot_tree = proto_item_add_subtree(ti, ett_tuxedo);
proto_tree_add_item(tuxedoroot_tree, hf_tuxedo_magic, tvb, 0, 4, FALSE);
proto_tree_add_item(tuxedoroot_tree, hf_tuxedo_opcode, tvb, 4, 4, FALSE);
}
}
else
{
/* This packet is a continuation */
col_set_str(pinfo->cinfo, COL_INFO, "Continuation");
if (tree)
{
ti = proto_tree_add_item(tree, proto_tuxedo, tvb, 0, -1, FALSE);
}
}
}
}
static void
dissect_netrom_type(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
int hf_netrom_type_param, gint ett_netrom_type_param, const netrom_tf_items *type_items )
{
proto_tree *tc;
proto_tree *type_tree;
char *info_buffer;
guint8 type;
guint8 op_code;
type = tvb_get_guint8( tvb, offset );
op_code = type &0x0f;
info_buffer = ep_strdup_printf( "%s%s%s%s (0x%02x)",
val_to_str_const( op_code, op_code_vals_text, "Unknown" ),
( type & NETROM_MORE_FLAG ) ? ", More" : "",
( type & NETROM_NAK_FLAG ) ? ", NAK" : "",
( type & NETROM_CHOKE_FLAG ) ? ", Choke" : "",
type );
col_add_str( pinfo->cinfo, COL_INFO, info_buffer );
if ( tree )
{
tc = proto_tree_add_uint_format( tree,
hf_netrom_type_param,
tvb,
offset,
1,
type,
"Type field: %s",
info_buffer
);
type_tree = proto_item_add_subtree( tc, ett_netrom_type_param );
proto_tree_add_item( type_tree, *type_items->hf_tf_op, tvb, offset, 1, ENC_BIG_ENDIAN );
proto_tree_add_item( type_tree, *type_items->hf_tf_choke, tvb, offset, 1, ENC_BIG_ENDIAN );
proto_tree_add_item( type_tree, *type_items->hf_tf_nak, tvb, offset, 1, ENC_BIG_ENDIAN );
proto_tree_add_item( type_tree, *type_items->hf_tf_more, tvb, offset, 1, ENC_BIG_ENDIAN );
}
}