static guint dissect_s5066dts_eow(tvbuff_t *tvb, packet_info * pinfo, guint offset, proto_tree *tree,
guint pdu_type)
{
- proto_item *ti = NULL;
- proto_tree *eow_tree = NULL;
+ proto_tree *eow_tree;
guint eow_type;
eow_type = tvb_get_guint8(tvb, offset) & 0x0F;
- ti = proto_tree_add_text(tree, tvb, offset, 2, "EOW Field");
- eow_tree = proto_item_add_subtree(ti, ett_s5066dts_eow);
+ eow_tree = proto_tree_add_subtree(tree, tvb, offset, 2, ett_s5066dts_eow, NULL, "EOW Field");
proto_tree_add_item(eow_tree, hf_s5066dts_eow_type, tvb, offset, 1, ENC_BIG_ENDIAN); offset++;
switch (eow_type)
guint addr_size)
{
guint32 source_address = 0, destination_address = 0;
- proto_item *ti;
- proto_tree *address_tree = NULL;
+ proto_tree *address_tree;
unsigned int i;
for ( i = 0; i < addr_size; i++)
: (tvb_get_guint8(tvb, offset + (i + addr_size) / 2))) & 0x0F);
}
- ti = proto_tree_add_text(tree, tvb, offset, addr_size, "Destination & Source Addresses");
- address_tree = proto_item_add_subtree(ti, ett_s5066dts_address);
+ address_tree = proto_tree_add_subtree(tree, tvb, offset, addr_size, ett_s5066dts_address, NULL, "Destination & Source Addresses");
proto_tree_add_text(address_tree,
tvb,
static guint dissect_s5066dts_management(tvbuff_t *tvb, guint offset, proto_tree *tree, guint header_size)
{
guint8 eow_content;
- proto_item *hftrp_proto_item = NULL;
proto_tree *hftrp_token_tree = NULL;
guint eow_type;
guint extended_message_size;
if (eow_type == S5066_EOW_HFTRP_TOKEN)
{
/* Add a new subtree for HFTRP token details */
- hftrp_proto_item = proto_tree_add_text(tree, tvb, offset, extended_message_size, "HFTRP Token (%s)",
+ hftrp_token_tree = proto_tree_add_subtree_format(tree, tvb, offset, extended_message_size,
+ ett_s5066dts_hftrp_token, NULL, "HFTRP Token (%s)",
val_to_str_const(eow_content, s5066dts_eow_hftrp_frame_control, "UNKNOWN_HFTRP_TOKEN"));
- hftrp_token_tree = proto_item_add_subtree(hftrp_proto_item, ett_s5066dts_hftrp_token);
proto_tree_add_item(hftrp_token_tree,
hf_s5066dts_management_extended_message_hftrp_payload_size, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2;
proto_tree_add_item(hftrp_token_tree,
proto_tree_add_item(s5066dts_tree, hf_s5066dts_header_size, tvb, offset, 1, ENC_BIG_ENDIAN); offset++;
offset = dissect_s5066dts_address(tvb, offset, s5066dts_tree, pinfo, address_size);
header_size = tvb_get_guint8(tvb, S5066_DPDU_SIZE_OF_HEADER_INDEX) & 0x1F;
- ti = proto_tree_add_text(s5066dts_tree, tvb, offset, header_size - 6, "D_PDU Type Specific Header");
- pdu_tree = proto_item_add_subtree(ti, ett_s5066dts_pdu);
+ pdu_tree = proto_tree_add_subtree(s5066dts_tree, tvb, offset, header_size - 6, ett_s5066dts_pdu, NULL, "D_PDU Type Specific Header");
switch (pdu_type)
{
static guint
dissect_s5066_address(tvbuff_t *tvb, guint offset, proto_tree *tree, gint source)
{
- proto_item *ti = NULL;
- proto_tree *s5066_tree_address = NULL;
+ proto_tree *s5066_tree_address;
guint32 addr;
- if (source) {
- ti = proto_tree_add_text(tree, tvb, offset, 4, "Source Address");
+ if (source) {
+ s5066_tree_address = proto_tree_add_subtree(tree, tvb, offset, 4, ett_s5066_address, NULL, "Source Address");
}
else {
- ti = proto_tree_add_text(tree, tvb, offset, 4, "Destination Address");
+ s5066_tree_address = proto_tree_add_subtree(tree, tvb, offset, 4, ett_s5066_address, NULL, "Destination Address");
}
- s5066_tree_address = proto_item_add_subtree(ti, ett_s5066_address);
- proto_tree_add_item(s5066_tree_address, hf_s5066_ad_size, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+ proto_tree_add_item(s5066_tree_address, hf_s5066_ad_size, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(s5066_tree_address, hf_s5066_ad_group, tvb, offset, 1, ENC_BIG_ENDIAN);
addr = tvb_get_ntohl(tvb, offset);
addr = addr & 0x1FFFFFFF;
static guint
dissect_s5066_servicetype(tvbuff_t *tvb, guint offset, proto_tree *tree)
{
- proto_item *ti = NULL;
- proto_tree *s5066_tree_servicetype = NULL;
+ proto_tree *s5066_tree_servicetype;
- ti = proto_tree_add_text(tree, tvb, offset, 2, "Service type");
- s5066_tree_servicetype = proto_item_add_subtree(ti, ett_s5066_servicetype);
+ s5066_tree_servicetype = proto_tree_add_subtree(tree, tvb, offset, 2, ett_s5066_servicetype, NULL, "Service type");
proto_tree_add_item(s5066_tree_servicetype, hf_s5066_st_txmode, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(s5066_tree_servicetype, hf_s5066_st_delivery_confirmation, tvb, offset, 1, ENC_BIG_ENDIAN);
static void dissect_reg_req(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *reg_tree;
proto_tree *reg_req_data;
guint16 gmd_cnt, i;
- reg_tree = proto_tree_add_text(pay_load, tvb, offset, -1, "Reg Request");
- reg_req_data = proto_item_add_subtree(reg_tree, ett_sasp_reg_req_sz);
+ reg_req_data = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_reg_req_sz, NULL, "Reg Request");
/* Reg Req Size */
proto_tree_add_item(reg_req_data, hf_sasp_reg_req_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_reg_rep(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *reg_rep;
proto_tree *reg_rep_tree;
- reg_rep = proto_tree_add_text(pay_load, tvb, offset, -1 , "Reg Reply");
- reg_rep_tree = proto_item_add_subtree(reg_rep, ett_sasp_reg_rep);
+ reg_rep_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1 , ett_sasp_reg_rep, NULL, "Reg Reply");
/* Size */
proto_tree_add_item(reg_rep_tree, hf_sasp_reg_rep_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
/*proto_item *dereg_req_reason_flag;*/
/*proto_tree *dereg_req_reason_flag_tree;*/
guint16 gmd_cnt, i;
- proto_item *dereg_tree;
proto_tree *dereg_req_data;
guint8 reason_flag;
static gboolean first_flag = TRUE;
wmem_strbuf_t *reasonflags_strbuf = wmem_strbuf_new_label(wmem_packet_scope());
static const gchar *fstr[] = {"No Reason", "Learned & Purposeful" };
- dereg_tree = proto_tree_add_text(pay_load, tvb, offset, -1 , "DeReg Request");
- dereg_req_data = proto_item_add_subtree(dereg_tree, ett_sasp_dereg_req_sz);
+ dereg_req_data = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_dereg_req_sz, NULL, "DeReg Request");
/* Size */
proto_tree_add_item(dereg_req_data, hf_sasp_dereg_req_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_dereg_rep(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *dereg_rep;
proto_tree *dereg_rep_tree;
- dereg_rep = proto_tree_add_text(pay_load, tvb, offset, -1 , "Dereg Reply");
- dereg_rep_tree = proto_item_add_subtree(dereg_rep, ett_sasp_dereg_rep);
+ dereg_rep_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_dereg_rep, NULL, "Dereg Reply");
/* Size */
proto_tree_add_item(dereg_rep_tree, hf_sasp_dereg_rep_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_sendwt(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *sendwt;
proto_tree *sendwt_tree;
guint16 gwed_cnt, i;
- sendwt = proto_tree_add_text(pay_load, tvb, offset, -1 , "Send Weight");
- sendwt_tree = proto_item_add_subtree(sendwt, ett_sasp_sendwt);
+ sendwt_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_sendwt, NULL, "Send Weight");
/* Size */
proto_tree_add_item(sendwt_tree, hf_sasp_sendwt_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_setmemstate_req(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *setmemstate;
proto_tree *setmemstate_req_data;
guint16 gmsd_cnt, i;
- setmemstate = proto_tree_add_text(pay_load, tvb, offset, -1 , "Set Mem State Request");
- setmemstate_req_data = proto_item_add_subtree(setmemstate, ett_sasp_setmemstate_req);
+ setmemstate_req_data = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_setmemstate_req, NULL, "Set Mem State Request");
/* Size */
proto_tree_add_item(setmemstate_req_data, hf_sasp_setmemstate_req_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_setmemstate_rep(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *setmemstate_rep;
proto_tree *setmemstate_rep_tree;
- setmemstate_rep = proto_tree_add_text(pay_load, tvb, offset, -1 , "Set Mem State Reply");
- setmemstate_rep_tree = proto_item_add_subtree(setmemstate_rep, ett_sasp_setmemstate_rep);
+ setmemstate_rep_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_setmemstate_rep, NULL, "Set Mem State Reply");
/* Size */
proto_tree_add_item(setmemstate_rep_tree, hf_sasp_setmemstate_rep_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static guint32 dissect_grpdatacomp(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *grpdatacomp;
proto_tree *grpdatacomp_tree;
guint8 LB_uid_len;
guint8 grp_name_len;
- grpdatacomp = proto_tree_add_text(pay_load, tvb, offset, -1 , "Group Data Component");
- grpdatacomp_tree = proto_item_add_subtree(grpdatacomp, ett_sasp_grpdatacomp);
+ grpdatacomp_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_grpdatacomp, NULL, "Group Data Component");
/*Type*/
proto_tree_add_item(grpdatacomp_tree, hf_sasp_grpdatacomp, tvb, offset, 2, ENC_BIG_ENDIAN);
static guint32 dissect_grp_memdatacomp(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *grp_memdatacomp;
proto_tree *grp_memdatacomp_tree;
guint16 mem_cnt;
guint16 i;
- grp_memdatacomp = proto_tree_add_text(pay_load, tvb, offset, -1 , "Group Of Member Data");
- grp_memdatacomp_tree = proto_item_add_subtree(grp_memdatacomp, ett_sasp_grp_memdatacomp);
+ grp_memdatacomp_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_grp_memdatacomp, NULL, "Group Of Member Data");
/* Group MEM Data */
proto_tree_add_item(grp_memdatacomp_tree, hf_sasp_grp_memdatacomp, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_wt_req(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *get_wt_data;
proto_tree *get_wt_tree;
guint16 gd_cnt, i;
- get_wt_data = proto_tree_add_text(pay_load, tvb, offset, -1 , "Get Wt Req");
- get_wt_tree = proto_item_add_subtree(get_wt_data, ett_sasp_getwt);
+ get_wt_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_getwt, NULL, "Get Wt Req");
/* Size */
proto_tree_add_item(get_wt_tree, hf_sasp_wt_req_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
static void dissect_wt_rep(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *wt_rep;
proto_tree *wt_rep_tree;
guint16 gwed_cnt, i;
- wt_rep = proto_tree_add_text(pay_load, tvb, offset, -1 , "Get Weights Reply");
- wt_rep_tree = proto_item_add_subtree(wt_rep, ett_sasp_wt_rep);
+ wt_rep_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_wt_rep, NULL, "Get Weights Reply");
/* Size */
proto_tree_add_item(wt_rep_tree, hf_sasp_wt_rep_sz, tvb, offset, 2, ENC_BIG_ENDIAN);
NULL
};
- proto_item *setlbstate_req;
proto_tree *setlbstate_req_tree;
- setlbstate_req = proto_tree_add_text(pay_load, tvb, offset, -1 , "Set LB State Req");
- setlbstate_req_tree = proto_item_add_subtree(setlbstate_req, ett_sasp_setlbstate_req);
+ setlbstate_req_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_setlbstate_req, NULL, "Set LB State Req");
/* Size*/
proto_tree_add_item(setlbstate_req_tree, hf_sasp_setlbstate_req_sz,
static void dissect_setlbstate_rep(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *setlbstate_rep;
proto_tree *setlbstate_rep_tree;
- setlbstate_rep = proto_tree_add_text(pay_load, tvb, offset, -1 , "Set LB State Rep");
- setlbstate_rep_tree = proto_item_add_subtree(setlbstate_rep, ett_sasp_setlbstate_rep);
+ setlbstate_rep_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_setlbstate_rep, NULL, "Set LB State Rep");
/* Size */
proto_tree_add_item(setlbstate_rep_tree, hf_sasp_setlbstate_rep_sz,
static guint32 dissect_grp_memstatedatacomp(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *grp_memstatedatacomp;
proto_tree *grp_memstatedatacomp_tree;
guint16 mem_cnt;
guint16 i;
- grp_memstatedatacomp = proto_tree_add_text(pay_load, tvb, offset, -1 , "Group Mem State Comp");
- grp_memstatedatacomp_tree = proto_item_add_subtree(grp_memstatedatacomp,
- ett_sasp_grp_memstatedatacomp);
+ grp_memstatedatacomp_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1,
+ ett_sasp_grp_memstatedatacomp, NULL, "Group Mem State Comp");
/* Type */
proto_tree_add_item(grp_memstatedatacomp_tree, hf_sasp_grp_memstatedatacomp,
static guint32 dissect_memstatedatacomp(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
proto_tree *memstatedatacomp_tree;
- proto_item *memstatedatacomp;
proto_tree *memdatacomp_tree;
guint8 memstate_flag;
offset = dissect_memdatacomp(tvb, pay_load, offset, &memdatacomp_tree);
- memstatedatacomp = proto_tree_add_text(memdatacomp_tree, tvb, offset, -1 , "Member State Data");
- memstatedatacomp_tree = proto_item_add_subtree(memstatedatacomp, ett_sasp_memstatedatacomp);
+ memstatedatacomp_tree = proto_tree_add_subtree(memdatacomp_tree, tvb, offset, -1, ett_sasp_memstatedatacomp, NULL, "Member State Data");
/* Type */
proto_tree_add_item(memstatedatacomp_tree, hf_sasp_memstatedatacomp_instance,
static guint32 dissect_weight_entry_data_comp(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
proto_tree *weight_entry_data_comp_tree;
- proto_item *weight_entry_data_comp;
static const int *wtflags[] = {
&hf_sasp_wed_contactsuccess_flag,
offset = dissect_memdatacomp(tvb, pay_load, offset, NULL);
- weight_entry_data_comp = proto_tree_add_text(pay_load, tvb, offset, -1 , "Weight Entry Data");
- weight_entry_data_comp_tree = proto_item_add_subtree(weight_entry_data_comp,
- ett_sasp_weight_entry_data_comp);
+ weight_entry_data_comp_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1,
+ ett_sasp_weight_entry_data_comp, NULL, "Weight Entry Data");
/* Type */
proto_tree_add_item(weight_entry_data_comp_tree, hf_sasp_weight_entry_data_comp_type,
static guint32 dissect_grp_wt_entry_datacomp(tvbuff_t *tvb, proto_tree *pay_load, guint32 offset)
{
- proto_item *grp_wt_entry_datacomp;
proto_tree *grp_wt_entry_datacomp_tree;
guint16 wt_entry_cnt;
guint16 i;
- grp_wt_entry_datacomp = proto_tree_add_text(pay_load, tvb, offset, -1 , "Group of Wt Entry Data");
- grp_wt_entry_datacomp_tree = proto_item_add_subtree(grp_wt_entry_datacomp,
- ett_sasp_grp_wt_entry_datacomp);
+ grp_wt_entry_datacomp_tree = proto_tree_add_subtree(pay_load, tvb, offset, -1, ett_sasp_grp_wt_entry_datacomp, NULL, "Group of Wt Entry Data");
/* Type */
proto_tree_add_item(grp_wt_entry_datacomp_tree, hf_sasp_grp_wt_entry_datacomp_type,
proto_item *ti;
proto_tree *sbc_tree;
proto_item *pitem;
- proto_item *ritem;
proto_tree *rtree;
gint offset = 0;
guint8 number_of_frames;
expected_speed_data = (frame_length * frequency) / (sbc_subbands * sbc_blocks);
- ritem = proto_tree_add_text(sbc_tree, tvb, offset, 4 + frame_length,
- "Frame: %3u/%3u", counter, number_of_frames);
- rtree = proto_item_add_subtree(ritem, ett_sbc_list);
+ rtree = proto_tree_add_subtree_format(sbc_tree, tvb, offset, 4 + frame_length,
+ ett_sbc_list, NULL, "Frame: %3u/%3u", counter, number_of_frames);
pitem = proto_tree_add_item(rtree, hf_sbc_syncword, tvb, offset, 1, ENC_BIG_ENDIAN);
syncword = tvb_get_guint8(tvb, offset);
}
offset += 1;
- proto_tree_add_item(ritem, hf_sbc_sampling_frequency, tvb, offset, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ritem, hf_sbc_blocks, tvb, offset, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ritem, hf_sbc_channel_mode, tvb, offset, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ritem, hf_sbc_allocation_method, tvb, offset, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ritem, hf_sbc_subbands, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_sampling_frequency, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_blocks, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_channel_mode, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_allocation_method, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_subbands, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- proto_tree_add_item(ritem, hf_sbc_bitpool, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_bitpool, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- proto_tree_add_item(ritem, hf_sbc_crc_check, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(rtree, hf_sbc_crc_check, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- proto_tree_add_item(ritem, hf_sbc_data, tvb, offset, frame_length, ENC_NA);
+ proto_tree_add_item(rtree, hf_sbc_data, tvb, offset, frame_length, ENC_NA);
offset += frame_length;
/* TODO: expert_info for invalid CRC */
- pitem = proto_tree_add_uint(ritem, hf_sbc_expected_data_speed, tvb, offset, 0, expected_speed_data / 1024);
+ pitem = proto_tree_add_uint(rtree, hf_sbc_expected_data_speed, tvb, offset, 0, expected_speed_data / 1024);
proto_item_append_text(pitem, " KiB/s");
PROTO_ITEM_SET_GENERATED(pitem);
frame_duration = (((double) frame_length / (double) expected_speed_data) * 1000.0);
cummulative_frame_duration += frame_duration;
- pitem = proto_tree_add_double(ritem, hf_sbc_frame_duration, tvb, offset, 0, frame_duration);
+ pitem = proto_tree_add_double(rtree, hf_sbc_frame_duration, tvb, offset, 0, frame_duration);
proto_item_append_text(pitem, " ms");
PROTO_ITEM_SET_GENERATED(pitem);
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *ti, *et, *dt, *hi, *cs;
+ proto_item *ti, *hi, *cs;
proto_tree *sbus_tree, *ethsbus_tree, *sbusdata_tree;
gint i; /*for CRC calculation*/
sbus_tree = proto_item_add_subtree(ti, ett_sbus);
/*Add subtree for Ether-S-Bus header*/
- et = proto_tree_add_text(sbus_tree, tvb, offset, 8, "Ether-S-Bus header");
- ethsbus_tree = proto_item_add_subtree(et, ett_sbus_ether);
+ ethsbus_tree = proto_tree_add_subtree(sbus_tree, tvb, offset, 8, ett_sbus_ether, NULL, "Ether-S-Bus header");
/* add an item to the subtree*/
sbus_eth_len = tvb_get_ntohl(tvb,offset);
hf_sbus_addr_rtc, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- ((sbus_media_cnt) * 4),"Data");
-
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ ((sbus_media_cnt) * 4), ett_sbus_data, NULL, "Data");
for (i=((sbus_media_cnt)); i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_rtc, tvb, offset,
hf_sbus_fio_count, tvb, offset, 1, sbus_fio_cnt);
offset += 1;
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- sbus_media_cnt,"Data");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ sbus_media_cnt, ett_sbus_data, NULL, "Data");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=sbus_media_cnt; i>0; i--) {
sbus_helper = 1;
sbus_show_bin = 0;
proto_tree_add_text(sbus_tree, tvb, offset, 2,
"Calendar week: %x, Week day: %x", sbus_helper, sbus_helper1);
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- 8, "Clock data");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ 8, ett_sbus_data, NULL, "Clock data");
proto_tree_add_item(sbusdata_tree,
hf_sbus_week_day, tvb, offset, 2, ENC_BIG_ENDIAN);
hf_sbus_addr_68k, tvb, offset, 3, ENC_BIG_ENDIAN);
offset += 3;
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- ((sbus_media_cnt) * 4),"Program lines");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ ((sbus_media_cnt) * 4), ett_sbus_data, NULL, "Program lines");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=((sbus_media_cnt)); i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_rtc, tvb, offset,
hf_sbus_addr_68k, tvb, offset, 3, ENC_BIG_ENDIAN);
offset += 3;
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- ((sbus_media_cnt) * 4),"Data (bytes)");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ ((sbus_media_cnt) * 4), ett_sbus_data, NULL, "Data (bytes)");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=sbus_media_cnt; i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_byte, tvb, offset,
offset += 1;
if (sbus_web_size > 1) {
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- (sbus_web_size - 1),"Data (bytes)");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ (sbus_web_size - 1), ett_sbus_data, NULL, "Data (bytes)");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=sbus_web_size -1 ; i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_byte, tvb, offset,
case SBUS_RD_PROGRAM_LINE:
case SBUS_RD_USER_EEPROM_REGISTER:
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- ((request_val->count) * 4),"Data");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ ((request_val->count) * 4), ett_sbus_data, NULL, "Data");
for (i=(request_val->count); i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_rtc, tvb, offset,
case SBUS_RD_INPUT:
case SBUS_RD_OUTPUT:
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- (((request_val->count) + 7) / 8), "Data");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ (((request_val->count) + 7) / 8), ett_sbus_data, NULL, "Data");
for (i=(((request_val->count) + 7) / 8); i>0; i--) {
sbus_helper = 1;
proto_tree_add_text(sbus_tree, tvb, offset, 2,
"Calendar week: %x, Week day: %x", sbus_helper, sbus_helper1);
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- 8, "Clock data");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ 8, ett_sbus_data, NULL, "Clock data");
proto_tree_add_item(sbusdata_tree,
hf_sbus_week_day, tvb, offset, 2, ENC_BIG_ENDIAN);
/* Response for Status Flags*/
case SBUS_RD_STATUSFLAG_ACCU:
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- 1,"ACCU and arithmetic status");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ 1, ett_sbus_data, NULL, "ACCU and arithmetic status");
proto_tree_add_item(sbusdata_tree, hf_sbus_flags_accu,
tvb, offset, 1, ENC_BIG_ENDIAN);
/* Response for Read byte */
case SBUS_RD_BYTE:
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- (request_val->count),"Data (bytes)");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ (request_val->count), ett_sbus_data, NULL, "Data (bytes)");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=(request_val->count); i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_byte, tvb, offset,
/* Response for Read Index register */
case SBUS_RD_INDEX_REGISTER:
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- 2,"Data (hex bytes)");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ 2, ett_sbus_data, NULL, "Data (hex bytes)");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=0; i<2; i++) { /*2 bytes*/
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_byte_hex, tvb, offset,
if (request_val->sysinfo == 0x00){ /*sysinfo 0*/
offset += 1; /* this byte is always 0x01*/
/*Add subtree for Data*/
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- 1,"System info");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ 1, ett_sbus_data, NULL, "System info");
proto_tree_add_item(sbusdata_tree, hf_sbus_sysinfo0_1,
tvb, offset, 1, ENC_BIG_ENDIAN);
1, sbus_web_seq);
offset += 1;
- dt = proto_tree_add_text(sbus_tree, tvb, offset,
- (sbus_web_size - 2),"Data (bytes)");
+ sbusdata_tree = proto_tree_add_subtree(sbus_tree, tvb, offset,
+ (sbus_web_size - 2), ett_sbus_data, NULL, "Data (bytes)");
- sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data);
for (i=sbus_web_size - 2; i>0; i--) {
proto_tree_add_item(sbusdata_tree,
hf_sbus_data_byte, tvb, offset,
/* Shift GTI to where we can work with it */
gti >>= GTI_SHIFT;
- gt_item = proto_tree_add_text(tree, tvb, offset, length,
+ gt_tree = proto_tree_add_subtree_format(tree, tvb, offset, length,
+ called ? ett_sccp_called_gt : ett_sccp_calling_gt, >_item,
"Global Title 0x%x (%u byte%s)",
gti, length, plurality(length,"", "s"));
- gt_tree = proto_item_add_subtree(gt_item, called ? ett_sccp_called_gt
- : ett_sccp_calling_gt);
/* Decode Transation Type (if present) */
if ((gti == AI_GTI_TT) ||
dissect_sccp_called_calling_param(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo,
guint length, gboolean called)
{
- proto_item *call_item = 0, *call_ai_item = 0, *item, *hidden_item, *expert_item;
- proto_tree *call_tree = 0, *call_ai_tree = 0;
+ proto_item *call_ai_item, *item, *hidden_item, *expert_item;
+ proto_tree *call_tree, *call_ai_tree;
guint offset;
guint8 national = 0xFFU, routing_ind, gti, pci, ssni, ssn;
tvbuff_t *gt_tvb;
const char *ssn_dissector_short_name = NULL;
const char *tcap_ssn_dissector_short_name = NULL;
- call_item = proto_tree_add_text(tree, tvb, 0, length,
+ call_tree = proto_tree_add_subtree_format(tree, tvb, 0, length,
+ called ? ett_sccp_called : ett_sccp_calling, NULL,
"%s Party address (%u byte%s)",
called ? "Called" : "Calling", length,
plurality(length, "", "s"));
- call_tree = proto_item_add_subtree(call_item, called ? ett_sccp_called : ett_sccp_calling);
- call_ai_item = proto_tree_add_text(call_tree, tvb, 0,
+ call_ai_tree = proto_tree_add_subtree(call_tree, tvb, 0,
ADDRESS_INDICATOR_LENGTH,
- "Address Indicator");
- call_ai_tree = proto_item_add_subtree(call_ai_item, called ? ett_sccp_called_ai : ett_sccp_calling_ai);
+ called ? ett_sccp_called_ai : ett_sccp_calling_ai, &call_ai_item, "Address Indicator");
if (decode_mtp3_standard == ANSI_STANDARD) {
national = tvb_get_guint8(tvb, 0) & ANSI_NATIONAL_MASK;
dissect_sccp_sequencing_segmenting_param(tvbuff_t *tvb, proto_tree *tree, guint length)
{
guint8 rsn, ssn;
- proto_item *param_item;
proto_tree *param_tree;
ssn = tvb_get_guint8(tvb, 0) >> 1;
rsn = tvb_get_guint8(tvb, SEQUENCING_SEGMENTING_SSN_LENGTH) >> 1;
- param_item = proto_tree_add_text(tree, tvb, 0, length, "%s",
+ param_tree = proto_tree_add_subtree(tree, tvb, 0, length, ett_sccp_sequencing_segmenting, NULL,
val_to_str(PARAMETER_SEQUENCING_SEGMENTING,
sccp_parameter_values, "Unknown: %d"));
- param_tree = proto_item_add_subtree(param_item,
- ett_sccp_sequencing_segmenting);
proto_tree_add_uint(param_tree, hf_sccp_sequencing_segmenting_ssn, tvb, 0,
SEQUENCING_SEGMENTING_SSN_LENGTH, ssn);
static void
dissect_sccp_segmentation_param(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint length)
{
- proto_item *param_item;
proto_tree *param_tree;
- param_item = proto_tree_add_text(tree, tvb, 0, length, "%s",
+ param_tree = proto_tree_add_subtree(tree, tvb, 0, length, ett_sccp_segmentation, NULL,
val_to_str(PARAMETER_SEGMENTATION,
sccp_parameter_values, "Unknown: %d"));
- param_tree = proto_item_add_subtree(param_item, ett_sccp_segmentation);
proto_tree_add_item(param_tree, hf_sccp_segmentation_first, tvb, 0, 1, ENC_NA);
proto_tree_add_item(param_tree, hf_sccp_segmentation_class, tvb, 0, 1, ENC_NA);
{
guint8 ti;
guint offset = 0;
- proto_item *param_item;
proto_tree *param_tree;
/* Create a subtree for ISNI Routing Control */
- param_item = proto_tree_add_text(tree, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH,
- "ISNI Routing Control");
- param_tree = proto_item_add_subtree(param_item,
- ett_sccp_ansi_isni_routing_control);
+ param_tree = proto_tree_add_subtree(tree, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH,
+ ett_sccp_ansi_isni_routing_control, NULL, "ISNI Routing Control");
proto_tree_add_item(param_tree, hf_sccp_ansi_isni_mi, tvb, offset,
ANSI_ISNI_ROUTING_CONTROL_LENGTH, ENC_NA);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SSP");
- /* In the interest of speed, if "tree" is NULL, don't do any work not
- necessary to generate protocol tree items. */
- if (tree) {
- /* create the ssprotocol protocol tree */
- ssprotocol_item = proto_tree_add_item(tree, proto_ssprotocol, message_tvb, 0, -1, ENC_NA);
- ssprotocol_tree = proto_item_add_subtree(ssprotocol_item, ett_ssprotocol);
- } else {
- ssprotocol_tree = NULL;
- };
+ /* create the ssprotocol protocol tree */
+ ssprotocol_item = proto_tree_add_item(tree, proto_ssprotocol, message_tvb, 0, -1, ENC_NA);
+ ssprotocol_tree = proto_item_add_subtree(ssprotocol_item, ett_ssprotocol);
+
/* dissect the message */
return dissect_ssprotocol_message(message_tvb, pinfo, ssprotocol_tree);
}
switch(feature){
case 0x0000: /* profile list */
while(try_offset<(old_offset+additional_length)){
- proto_item *it=NULL;
- proto_tree *tr=NULL;
+ proto_item *it;
+ proto_tree *tr;
guint16 profile;
guint8 cur_profile;
- if(tree){
- it=proto_tree_add_text(tree, try_tvb, try_offset, 4, "Profile:");
- tr=proto_item_add_subtree(it, ett_scsi_mmc_profile);
- }
+ tr=proto_tree_add_subtree(tree, try_tvb, try_offset, 4, ett_scsi_mmc_profile, &it, "Profile:");
profile=tvb_get_ntohs(try_tvb, try_offset);
proto_tree_add_item (tr, hf_scsi_mmc_feature_profile, try_tvb, try_offset, 2, ENC_BIG_ENDIAN);
}
if ((guint32)(offset-start_offset)+attribute_entry_length>length) break;
- ti = proto_tree_add_text(tree, tvb, offset, attribute_entry_length, "Attribute:");
- tt = proto_item_add_subtree(ti, ett_osd_attribute);
+ tt = proto_tree_add_subtree(tree, tvb, offset, attribute_entry_length, ett_osd_attribute, &ti, "Attribute:");
switch (type) {
case 0x01: /* retrieving attributes 7.1.3.2 */
static void
dissect_osd_option(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
{
- proto_tree *tree = NULL;
- proto_item *it = NULL;
+ proto_tree *tree;
+ proto_item *it;
guint8 option;
option = tvb_get_guint8(tvb, offset);
- if (parent_tree) {
- it = proto_tree_add_item(parent_tree, hf_scsi_osd_option, tvb, offset, 1, ENC_BIG_ENDIAN);
- tree = proto_item_add_subtree(it, ett_osd_option);
- }
+ it = proto_tree_add_item(parent_tree, hf_scsi_osd_option, tvb, offset, 1, ENC_BIG_ENDIAN);
+ tree = proto_item_add_subtree(it, ett_osd_option);
proto_tree_add_item(tree, hf_scsi_osd_option_dpo, tvb, offset, 1, ENC_BIG_ENDIAN);
if (option&0x10) {
dissect_osd_attribute_parameters(packet_info *pinfo, tvbuff_t *tvb, int offset, proto_tree *parent_tree, scsi_task_data_t *cdata)
{
guint8 gsatype = 0;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
scsi_osd_extra_data_t *extra_data = NULL;
gboolean osd2;
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, 28,
- "Attribute Parameters");
- tree = proto_item_add_subtree(item, ett_osd_attribute_parameters);
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, 28,
+ ett_osd_attribute_parameters, NULL, "Attribute Parameters");
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
{
guint8 gsatype = 0;
proto_tree *subtree;
- proto_item *item;
scsi_osd_extra_data_t *extra_data = NULL;
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
break;
case 3: /* 5.2.2.3 attribute list */
if (extra_data->u.al.get_list_length) {
- item = proto_tree_add_text(tree, tvb, extra_data->u.al.get_list_offset, extra_data->u.al.get_list_length, "Get Attributes Segment");
- subtree= proto_item_add_subtree(item, ett_osd_get_attributes);
+ subtree = proto_tree_add_subtree(tree, tvb, extra_data->u.al.get_list_offset, extra_data->u.al.get_list_length,
+ ett_osd_get_attributes, NULL, "Get Attributes Segment");
dissect_osd_attributes_list(pinfo, tvb, extra_data->u.al.get_list_offset, subtree, lun_info, extra_data->osd2);
}
if (extra_data->u.al.set_list_length) {
- item = proto_tree_add_text(tree, tvb, extra_data->u.al.set_list_offset, extra_data->u.al.set_list_length, "Set Attributes Segment");
- subtree= proto_item_add_subtree(item, ett_osd_set_attributes);
+ subtree = proto_tree_add_subtree(tree, tvb, extra_data->u.al.set_list_offset, extra_data->u.al.set_list_length,
+ ett_osd_get_attributes, NULL, "Set Attributes Segment");
dissect_osd_attributes_list(pinfo, tvb, extra_data->u.al.set_list_offset, subtree, lun_info, extra_data->osd2);
}
break;
static void
dissect_osd_capability(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
guint8 format;
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, 80,
- "Capability");
- tree = proto_item_add_subtree(item, ett_osd_capability);
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, 80,
+ ett_osd_capability, NULL, "Capability");
/* capability format */
proto_tree_add_item(tree, hf_scsi_osd_capability_format, tvb, offset, 1, ENC_BIG_ENDIAN);
static int
dissect_osd_security_parameters(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, 40,
- "Security Parameters");
- tree = proto_item_add_subtree(item, ett_osd_security_parameters);
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, 40,
+ ett_osd_security_parameters, NULL, "Security Parameters");
/* request integrity check value */
proto_tree_add_item(tree, hf_scsi_osd_ricv, tvb, offset, 20, ENC_NA);
if (attr_list_end>additional_length+8) break;
while (offset+16<attr_list_end) {
guint32 attribute_length = tvb_get_ntohs(tvb, offset+14);
- proto_item *att_item = proto_tree_add_text(subtree, tvb, offset, 16+attribute_length, "Attribute:");
- proto_tree *att_tree = proto_item_add_subtree(att_item, ett_osd_attribute);
+ proto_item *att_item;
+ proto_tree *att_tree = proto_tree_add_subtree(subtree, tvb, offset, 16+attribute_length, ett_osd_attribute, &att_item, "Attribute:");
offset = dissect_osd_attribute_list_entry(pinfo, tvb, att_tree, att_item, offset, lun_info, TRUE);
}
offset = attr_list_end;
gint64 lba;
gint32 num_blocks;
- it = proto_tree_add_text(tree, tvb, offset, 16, "UNMAP Block Descriptor: LBA ");
- tr = proto_item_add_subtree(it, ett_scsi_unmap_block_descriptor);
+ tr = proto_tree_add_subtree(tree, tvb, offset, 16, ett_scsi_unmap_block_descriptor, &it, "UNMAP Block Descriptor: LBA ");
proto_tree_add_item (tr, hf_scsi_sbc_unmap_lba, tvb, offset, 8, ENC_BIG_ENDIAN);
lba = tvb_get_ntoh64 (tvb, offset);
guint32 num_blocks;
guint8 type;
- it = proto_tree_add_text(tree, tvb, offset, 16, "LBA Status Descriptor: ");
- tr = proto_item_add_subtree(it, ett_scsi_lba_status_descriptor);
+ tr = proto_tree_add_subtree(tree, tvb, offset, 16, ett_scsi_lba_status_descriptor, &it, "LBA Status Descriptor: ");
proto_tree_add_item (tr, hf_scsi_sbc_get_lba_status_lba, tvb, offset, 8, ENC_BIG_ENDIAN);
lba = tvb_get_ntoh64(tvb, offset);
if (tree) {
pcode = tvb_get_guint8(tvb, offset+1);
plen = tvb_get_guint8(tvb, offset+3);
- ti = proto_tree_add_text(tree, tvb, offset, plen+4, "Page Code: %s",
+ evpd_tree = proto_tree_add_subtree_format(tree, tvb, offset, plen+4,
+ ett_scsi_page, NULL, "Page Code: %s",
val_to_str(pcode, scsi_evpd_pagecode_val,
"Unknown (0x%08x)"));
- evpd_tree = proto_item_add_subtree(ti, ett_scsi_page);
proto_tree_add_item(evpd_tree, hf_scsi_inq_qualifier, tvb, offset,
1, ENC_BIG_ENDIAN);
guint offset, guint tot_len _U_)
{
proto_tree *cmdt_tree;
- proto_item *ti;
guint plen;
if (tree) {
plen = tvb_get_guint8(tvb, offset+5);
- ti = proto_tree_add_text(tree, tvb, offset, plen, "Command Data");
- cmdt_tree = proto_item_add_subtree(ti, ett_scsi_page);
+ cmdt_tree = proto_tree_add_subtree_format(tree, tvb, offset, plen, ett_scsi_page, NULL, "Command Data");
proto_tree_add_item(cmdt_tree, hf_scsi_inq_qualifier, tvb, offset,
1, ENC_BIG_ENDIAN);
guint16 cscd_desc_list_len, seg_desc_len;
guint32 /*param_list_len,*/ seg_desc_list_len, inline_data_len, i;
proto_tree *cscds_tree = NULL, *dev_tree = NULL, *cscd_tree = NULL, *segs_tree = NULL, *seg_tree = NULL, *seg_param_tree = NULL;
- proto_item *ti;
if (isreq && iscdb) {
proto_tree_add_item(tree, hf_scsi_spc_xcopy_service, tvb, offset, 1, ENC_NA);
inline_data_len = tvb_get_ntohl(tvb, offset);
offset += 4;
if (cscd_desc_list_len > 0) {
- ti = proto_tree_add_text(tree, tvb, offset, cscd_desc_list_len, "CSCD (Copy Source and Copy Destination) descriptors (%u bytes)", cscd_desc_list_len);
- cscds_tree = proto_item_add_subtree(ti, ett_scsi_xcopy_cscds);
+ cscds_tree = proto_tree_add_subtree_format(tree, tvb, offset, cscd_desc_list_len, ett_scsi_xcopy_cscds, NULL,
+ "CSCD (Copy Source and Copy Destination) descriptors (%u bytes)", cscd_desc_list_len);
i = 1;
while(cscd_desc_list_len > 0) {
cscd_desc_type = tvb_get_guint8(tvb, offset);
if (cscd_desc_type == 0xEA || cscd_desc_type == 0xEB) { /* both types occupy 64 bytes overall, everything else is 32 bytes */
- ti = proto_tree_add_text(cscds_tree, tvb, offset, 64, "CSCD descriptor #%u", i);
+ cscd_tree = proto_tree_add_subtree_format(cscds_tree, tvb, offset, 64, ett_scsi_xcopy_cscd, NULL, "CSCD descriptor #%u", i);
} else {
- ti = proto_tree_add_text(cscds_tree, tvb, offset, 32, "CSCD descriptor #%u", i);
+ cscd_tree = proto_tree_add_subtree_format(cscds_tree, tvb, offset, 32, ett_scsi_xcopy_cscd, NULL, "CSCD descriptor #%u", i);
}
i++;
- cscd_tree = proto_item_add_subtree(ti, ett_scsi_xcopy_cscd);
proto_tree_add_item(cscd_tree, hf_scsi_spc_xcopy_cscd_desc_type_code, tvb, offset, 1, ENC_NA);
offset += 1;
proto_tree_add_bitmask(cscd_tree, tvb, offset, hf_scsi_spc_xcopy_per_dev_type_byte, ett_xcopy_per_dev_type, per_dev_type_bitmask_fields, ENC_NA);
proto_tree_add_text(cscd_tree, tvb, offset, des_len, "WWN: %s", tvb_fcwwn_to_str(tvb, offset));
}
offset += 20;
- ti = proto_tree_add_text(cscd_tree, tvb, offset, 4, "Device type specific parameters");
- dev_tree = proto_item_add_subtree(ti, ett_scsi_xcopy_dev_params);
+ dev_tree = proto_tree_add_subtree(cscd_tree, tvb, offset, 4, ett_scsi_xcopy_dev_params, NULL, "Device type specific parameters");
if (dev_type == BLOCK_DEV_0 || dev_type == BLOCK_DEV_4 || dev_type == BLOCK_DEV_5 || dev_type == BLOCK_DEV_7 || dev_type == BLOCK_DEV_E) {
proto_tree_add_text(dev_tree, tvb, offset, 1, "Reserved|PAD|Reserved");
offset += 1; /*TODO: dissect this byte */
}
}
if (seg_desc_list_len > 0) {
- ti = proto_tree_add_text(tree, tvb, offset, seg_desc_list_len, "Segment descriptor list (%u bytes)", seg_desc_list_len);
- segs_tree = proto_item_add_subtree(ti, ett_scsi_xcopy_segs);
+ segs_tree = proto_tree_add_subtree_format(tree, tvb, offset, seg_desc_list_len,
+ ett_scsi_xcopy_segs, NULL, "Segment descriptor list (%u bytes)", seg_desc_list_len);
i = 1;
while(seg_desc_list_len > 0) {
seg_desc_len = tvb_get_ntohs(tvb, offset + 2);
- ti = proto_tree_add_text(segs_tree, tvb, offset, seg_desc_len + 4, "Segment descriptor #%u", i);
+ seg_tree = proto_tree_add_subtree_format(segs_tree, tvb, offset, seg_desc_len + 4,
+ ett_scsi_xcopy_seg, NULL, "Segment descriptor #%u", i);
i++;
- seg_tree = proto_item_add_subtree(ti, ett_scsi_xcopy_seg);
proto_tree_add_item(seg_tree, hf_scsi_spc_xcopy_seg_desc_type, tvb, offset, 1, ENC_NA);
seg_type = tvb_get_guint8(tvb, offset);
offset += 1;
offset += 2;
proto_tree_add_item(seg_tree, hf_scsi_spc_xcopy_seg_des_dest_desc_id, tvb, offset, 2, ENC_NA);
offset += 2;
- ti = proto_tree_add_text(seg_tree, tvb, offset, seg_desc_len - 4, "Segment descriptor parameters");
- seg_param_tree = proto_item_add_subtree(ti, ett_scsi_xcopy_seg_param);
+ seg_param_tree = proto_tree_add_subtree(seg_tree, tvb, offset, seg_desc_len - 4,
+ ett_scsi_xcopy_seg_param, NULL, "Segment descriptor parameters");
seg_desc_list_len -= (seg_desc_len + 4);
if (seg_type == BLOCK_TO_BLOCK) {
proto_tree_add_item(seg_param_tree, hf_scsi_reserved_16, tvb, offset, 2, ENC_NA);
};
guint16 pagelen, pagecode;
guint8 paramlen;
- proto_tree *log_tree = NULL;
- proto_item *ti = NULL;
+ proto_tree *log_tree;
+ proto_item *ti;
guint old_offset = offset;
const log_pages_t *log_page;
pagecode = tvb_get_guint8(tvb, offset) & 0x3f;
- if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, -1,
- "Log Page: %s", val_to_str(pagecode, scsi_log_page_val, "Unknown (0x%04x)"));
- log_tree = proto_item_add_subtree(ti, ett_scsi_log);
- }
+ log_tree = proto_tree_add_subtree_format(tree, tvb, offset, -1, ett_scsi_log, &ti,
+ "Log Page: %s", val_to_str(pagecode, scsi_log_page_val, "Unknown (0x%04x)"));
/* page code */
proto_tree_add_bitmask(log_tree, tvb, offset, hf_scsi_log_pc_flags, ett_scsi_log_pc, pcflags_fields, ENC_BIG_ENDIAN);
guint16 plen;
guint8 pcode, spf, subpcode = 0;
proto_tree *tree;
- proto_item *ti;
const value_string *modepage_val;
int hf_pagecode;
gboolean (*dissect_modepage)(tvbuff_t *, packet_info *, proto_tree *,
dissect_modepage = dissect_scsi_spc_modepage;
}
- ti = proto_tree_add_text(scsi_tree, tvb, offset, plen + (spf ? 4 : 2),
- "%s Mode Page",
+ tree = proto_tree_add_subtree_format(scsi_tree, tvb, offset, plen + (spf ? 4 : 2),
+ ett_scsi_page, NULL, "%s Mode Page",
val_to_str(pcode & SCSI_MS_PCODE_BITS,
modepage_val, "Unknown (0x%08x)"));
- tree = proto_item_add_subtree(ti, ett_scsi_page);
proto_tree_add_item(tree, hf_scsi_modepage_ps, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_scsi_modepage_spf, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_pagecode, tvb, offset, 1, ENC_BIG_ENDIAN);
void
dissect_scsi_lun(proto_tree *tree, tvbuff_t *tvb, guint offset) {
- proto_item *ti = proto_tree_add_text(tree, tvb, offset, 8, "LUN: ");
- proto_tree *tt = proto_item_add_subtree(ti, ett_scsi_lun);
+ proto_item *ti;
+ proto_tree *tt = proto_tree_add_subtree(tree, tvb, offset, 8, ett_scsi_lun, &ti, "LUN: ");
guint8 address_mode;
guint16 lun = 0;
if (ctdp) {
proto_tree *tr;
- it = proto_tree_add_text(tree, try_tvb, try_offset,
- 12, "Timeout Descriptor");
-
- tr = proto_item_add_subtree(it,
- ett_timeout_descriptor);
+ tr = proto_tree_add_subtree(tree, try_tvb, try_offset,
+ 12, ett_timeout_descriptor, NULL, "Timeout Descriptor");
proto_tree_add_item(tr, hf_scsi_report_opcodes_tdl,
try_tvb, try_offset, 2, ENC_BIG_ENDIAN);
while (length >= 20) {
proto_tree *tr;
- it = proto_tree_add_text(tree, try_tvb, try_offset,
- 20, "Command Descriptor: %s",
+ tr = proto_tree_add_subtree_format(tree, try_tvb, try_offset,
+ 20, ett_command_descriptor, NULL, "Command Descriptor: %s",
val_to_str_ext_const(tvb_get_guint8(try_tvb, try_offset+0), csdata->cdb_vals_ext, "Unknown"));
- tr = proto_item_add_subtree(it,
- ett_command_descriptor);
proto_tree_add_item(tr, csdata->hf_opcode,
try_tvb, try_offset+0, 1, ENC_BIG_ENDIAN);
continue;
}
- it = proto_tree_add_text(tree, try_tvb, try_offset,
- 12, "Timeout Descriptor");
-
- tr = proto_item_add_subtree(it,
- ett_timeout_descriptor);
+ tr = proto_tree_add_subtree(tree, try_tvb, try_offset,
+ 12, ett_timeout_descriptor, NULL, "Timeout Descriptor");
proto_tree_add_item(tr, hf_scsi_report_opcodes_tdl,
try_tvb, try_offset, 2, ENC_BIG_ENDIAN);
desc_type = tvb_get_guint8(tvb, offset);
desc_length = tvb_get_guint8(tvb, offset+1);
desc_end = offset+desc_length+2;
- item = proto_tree_add_text(sns_tree, tvb, offset, desc_length+2, "%s",
+ desc_tree = proto_tree_add_subtree(sns_tree, tvb, offset, desc_length+2, ett_sense_descriptor, NULL,
val_to_str(desc_type, scsi_sense_desc_type_val, "Unknown (0x%02x)"));
- desc_tree = proto_item_add_subtree(item, ett_sense_descriptor);
proto_tree_add_item(desc_tree, hf_scsi_sns_desc_type, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(desc_tree, hf_scsi_sns_desc_length, tvb, offset+1, 1, ENC_BIG_ENDIAN);
switch (desc_type) {
reported_length = tvb_reported_length(parameter_tvb);
padding_length = reported_length - length;
- parameter_item = proto_tree_add_text(chunk_tree, parameter_tvb, PARAMETER_HEADER_OFFSET, tvb_reported_length(parameter_tvb), "%s parameter", val_to_str_const(type, parameter_identifier_values, "Unknown"));
- parameter_tree = proto_item_add_subtree(parameter_item, ett_sctp_chunk_parameter);
+ parameter_tree = proto_tree_add_subtree_format(chunk_tree, parameter_tvb, PARAMETER_HEADER_OFFSET, -1,
+ ett_sctp_chunk_parameter, ¶meter_item, "%s parameter",
+ val_to_str_const(type, parameter_identifier_values, "Unknown"));
if (final_parameter) {
if (padding_length > 0) {
expert_add_info(pinfo, parameter_item, &ei_sctp_parameter_padding);
length = tvb_get_ntohs(cause_tvb, CAUSE_LENGTH_OFFSET);
padding_length = tvb_reported_length(cause_tvb) - length;
- cause_item = proto_tree_add_text(chunk_tree, cause_tvb, CAUSE_HEADER_OFFSET, tvb_reported_length(cause_tvb), "%s cause", val_to_str_const(code, cause_code_values, "Unknown"));
- cause_tree = proto_item_add_subtree(cause_item, ett_sctp_chunk_cause);
+ cause_tree = proto_tree_add_subtree_format(chunk_tree, cause_tvb, CAUSE_HEADER_OFFSET, -1,
+ ett_sctp_chunk_cause, &cause_item, "%s cause", val_to_str_const(code, cause_code_values, "Unknown"));
proto_tree_add_item(cause_tree, hf_cause_code, cause_tvb, CAUSE_CODE_OFFSET, CAUSE_CODE_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(cause_tree, hf_cause_length, cause_tvb, CAUSE_LENGTH_OFFSET, CAUSE_LENGTH_LENGTH, ENC_BIG_ENDIAN);
guint16 gap_block_number, dup_tsn_number, start, end;
gint gap_block_offset, dup_tsn_offset;
guint32 cum_tsn_ack;
- proto_item *block_item;
proto_tree *block_tree;
proto_tree *flags_tree;
proto_item *ctsa_item;
end = tvb_get_ntohs(chunk_tvb, gap_block_offset + SACK_CHUNK_GAP_BLOCK_START_LENGTH);
tsn_start = cum_tsn_ack + start;
- block_item = proto_tree_add_text(chunk_tree, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_LENGTH, "Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
- block_tree = proto_item_add_subtree(block_item, ett_sctp_sack_chunk_gap_block);
+ block_tree = proto_tree_add_subtree_format(chunk_tree, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_LENGTH,
+ ett_sctp_sack_chunk_gap_block, NULL, "Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
pi = proto_tree_add_item(block_tree, hf_sack_chunk_gap_block_start, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_START_LENGTH, ENC_BIG_ENDIAN);
pt = proto_item_add_subtree(pi, ett_sctp_sack_chunk_gap_block_start);
guint16 gap_block_number, nr_gap_block_number, dup_tsn_number, start, end;
gint gap_block_offset, nr_gap_block_offset, dup_tsn_offset;
guint32 cum_tsn_ack;
- proto_item *block_item;
proto_tree *block_tree;
proto_tree *flags_tree;
proto_item *ctsa_item;
end = tvb_get_ntohs(chunk_tvb, gap_block_offset + NR_SACK_CHUNK_GAP_BLOCK_START_LENGTH);
tsn_start = cum_tsn_ack + start;
- block_item = proto_tree_add_text(chunk_tree, chunk_tvb, gap_block_offset, NR_SACK_CHUNK_GAP_BLOCK_LENGTH, "Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
- block_tree = proto_item_add_subtree(block_item, ett_sctp_nr_sack_chunk_gap_block);
+ block_tree = proto_tree_add_subtree_format(chunk_tree, chunk_tvb, gap_block_offset, NR_SACK_CHUNK_GAP_BLOCK_LENGTH,
+ ett_sctp_nr_sack_chunk_gap_block, NULL, "Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
pi = proto_tree_add_item(block_tree, hf_nr_sack_chunk_gap_block_start, chunk_tvb, gap_block_offset, NR_SACK_CHUNK_GAP_BLOCK_START_LENGTH, ENC_BIG_ENDIAN);
pt = proto_item_add_subtree(pi, ett_sctp_nr_sack_chunk_gap_block_start);
end = tvb_get_ntohs(chunk_tvb, nr_gap_block_offset + NR_SACK_CHUNK_NR_GAP_BLOCK_START_LENGTH);
/*tsn_start = cum_tsn_ack + start;*/
- block_item = proto_tree_add_text(chunk_tree, chunk_tvb, nr_gap_block_offset, NR_SACK_CHUNK_NR_GAP_BLOCK_LENGTH, "NR-Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
- block_tree = proto_item_add_subtree(block_item, ett_sctp_nr_sack_chunk_nr_gap_block);
+ block_tree = proto_tree_add_subtree_format(chunk_tree, chunk_tvb, nr_gap_block_offset, NR_SACK_CHUNK_NR_GAP_BLOCK_LENGTH,
+ ett_sctp_nr_sack_chunk_nr_gap_block, NULL, "NR-Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
pi = proto_tree_add_item(block_tree, hf_nr_sack_chunk_nr_gap_block_start, chunk_tvb, nr_gap_block_offset, NR_SACK_CHUNK_NR_GAP_BLOCK_START_LENGTH, ENC_BIG_ENDIAN);
pt = proto_item_add_subtree(pi, ett_sctp_nr_sack_chunk_nr_gap_block_start);
col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str_const(type, chunk_type_values, "RESERVED"));
/* create proto_tree stuff */
- chunk_item = proto_tree_add_text(sctp_tree, chunk_tvb, CHUNK_HEADER_OFFSET, reported_length, "%s chunk", val_to_str_const(type, chunk_type_values, "RESERVED"));
- chunk_tree = proto_item_add_subtree(chunk_item, ett_sctp_chunk);
+ chunk_tree = proto_tree_add_subtree_format(sctp_tree, chunk_tvb, CHUNK_HEADER_OFFSET, reported_length,
+ ett_sctp_chunk, &chunk_item, "%s chunk",
+ val_to_str_const(type, chunk_type_values, "RESERVED"));
if (reported_length % 4)
expert_add_info_format(pinfo, chunk_item, &ei_sctp_chunk_length_bad, "Chunk length is not padded to a multiple of 4 bytes (length=%d).", reported_length);
}
if (tvb_strncaseeql(tvb, offset, "inline", next_offset-offset) == 0) {
- parameter_item = proto_tree_add_text(sdp_media_attribute_tree,
- tvb, offset, param_end_offset-offset, "Key parameters");
- parameter_tree = proto_item_add_subtree(parameter_item, ett_sdp_crypto_key_parameters);
+ parameter_tree = proto_tree_add_subtree(sdp_media_attribute_tree, tvb, offset,
+ param_end_offset-offset, ett_sdp_crypto_key_parameters, NULL, "Key parameters");
/* XXX only for SRTP? */
/* srtp-key-info = key-salt ["|" lifetime] ["|" mki] */
offset = next_offset +1;
dissect_relaydef_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *relaydef_item, *relaydef_fm_item, *relaydef_flags_item, *relaydef_proto_item;
+ proto_item *relaydef_fm_item, *relaydef_flags_item, *relaydef_proto_item;
proto_tree *relaydef_tree, *relaydef_fm_tree, *relaydef_flags_tree, *relaydef_proto_tree;
guint8 len, num_proto, num_fm, num_flags;
int count;
num_flags = tvb_get_guint8(tvb, offset+3);
/* Add items to protocol tree specific to Relay Definition Block */
- relaydef_item = proto_tree_add_text(tree, tvb, offset, len-2, "Relay Definition Block Details");
- relaydef_tree = proto_item_add_subtree(relaydef_item, ett_selfm_relaydef);
+ relaydef_tree = proto_tree_add_subtree(tree, tvb, offset, len-2, ett_selfm_relaydef, NULL, "Relay Definition Block Details");
/* Reported length */
proto_tree_add_item(relaydef_tree, hf_selfm_relaydef_len, tvb, offset, 1, ENC_BIG_ENDIAN);
dissect_fmconfig_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *fmconfig_item, *fmconfig_ai_item=NULL, *fmconfig_calc_item=NULL;
proto_tree *fmconfig_tree, *fmconfig_ai_tree=NULL, *fmconfig_calc_tree=NULL;
guint count;
guint8 len, sf_loc, num_sf, num_ai, num_calc;
/* skip num_dig, position offset+6 */
num_calc = tvb_get_guint8(tvb, offset+7);
- fmconfig_item = proto_tree_add_text(tree, tvb, offset, len, "Fast Meter Configuration Details");
- fmconfig_tree = proto_item_add_subtree(fmconfig_item, ett_selfm_fmconfig);
+ fmconfig_tree = proto_tree_add_subtree(tree, tvb, offset, len, ett_selfm_fmconfig, NULL, "Fast Meter Configuration Details");
/* Add items to protocol tree specific to Fast Meter Configuration Block */
tvb_memcpy(tvb, &ai_name, offset, 6);
ai_name[FM_CONFIG_ANA_CHNAME_LEN] = '\0'; /* Put a terminating null onto the end of the AI name, in case none exists */
- fmconfig_ai_item = proto_tree_add_text(fmconfig_tree, tvb, offset, 10, "Analog Channel: %s", ai_name);
- fmconfig_ai_tree = proto_item_add_subtree(fmconfig_ai_item, ett_selfm_fmconfig_ai);
+ fmconfig_ai_tree = proto_tree_add_subtree_format(fmconfig_tree, tvb, offset, 10,
+ ett_selfm_fmconfig_ai, NULL, "Analog Channel: %s", ai_name);
/* Add Channel Name, Channel Data Type, Scale Factor Type and Scale Factor Offset to tree */
proto_tree_add_text(fmconfig_ai_tree, tvb, offset, 6, "Analog Channel Name: %s", ai_name);
/* 14-byte Calculation block instances based on num_calc */
for (count = 0; count < num_calc; count++) {
- fmconfig_calc_item = proto_tree_add_text(fmconfig_tree, tvb, offset, 14, "Calculation Block: %d", count+1);
- fmconfig_calc_tree = proto_item_add_subtree(fmconfig_calc_item, ett_selfm_fmconfig_calc);
+ fmconfig_calc_tree = proto_tree_add_subtree_format(fmconfig_tree, tvb, offset, 14,
+ ett_selfm_fmconfig_calc, NULL, "Calculation Block: %d", count+1);
/* Rotation, Voltage Connection and Current Connection are all bit-masked on the same byte */
proto_tree_add_item(fmconfig_calc_tree, hf_selfm_fmconfig_cblk_rot, tvb, offset, 1, ENC_BIG_ENDIAN);
dissect_fmdata_frame(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int offset, guint16 config_cmd_match)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *fmdata_item, *fmdata_ai_item=NULL, *fmdata_dig_item=NULL, *fmdata_ai_ch_item=NULL, *fmdata_dig_ch_item=NULL;
- proto_item *fmdata_ai_sf_item=NULL;
+ proto_item *fmdata_item, *fmdata_dig_ch_item;
+ proto_item *fmdata_ai_sf_item;
proto_tree *fmdata_tree, *fmdata_ai_tree=NULL, *fmdata_dig_tree=NULL, *fmdata_ai_ch_tree=NULL, *fmdata_dig_ch_tree=NULL;
guint8 len, idx=0, j=0, ts_mon, ts_day, ts_year, ts_hour, ts_min, ts_sec;
guint16 config_cmd, ts_msec;
len = tvb_get_guint8(tvb, offset);
- fmdata_item = proto_tree_add_text(tree, tvb, offset, len-2, "Fast Meter Data Details");
- fmdata_tree = proto_item_add_subtree(fmdata_item, ett_selfm_fmdata);
+ fmdata_tree = proto_tree_add_subtree_format(tree, tvb, offset, len-2, ett_selfm_fmdata, &fmdata_item, "Fast Meter Data Details");
/* Reported length */
proto_tree_add_item(fmdata_tree, hf_selfm_fmdata_len, tvb, offset, 1, ENC_BIG_ENDIAN);
/* Use different lookup strings, depending on how many samples are available per Analog Channel */
if (cfg_data->num_ai_samples == 1) {
- fmdata_ai_item = proto_tree_add_text(fmdata_tree, tvb, offset, ((cfg_data->offset_ts - cfg_data->offset_ai)/cfg_data->num_ai_samples),
- "Analog Channels (%d), Sample: %d (%s)",
+ fmdata_ai_tree = proto_tree_add_subtree_format(fmdata_tree, tvb, offset, ((cfg_data->offset_ts - cfg_data->offset_ai)/cfg_data->num_ai_samples),
+ ett_selfm_fmdata_ai, NULL, "Analog Channels (%d), Sample: %d (%s)",
cfg_data->num_ai, j+1, val_to_str_const(j+1, selfm_fmconfig_numsamples1_vals, "Unknown"));
- fmdata_ai_tree = proto_item_add_subtree(fmdata_ai_item, ett_selfm_fmdata_ai);
}
else if (cfg_data->num_ai_samples == 2) {
- fmdata_ai_item = proto_tree_add_text(fmdata_tree, tvb, offset, ((cfg_data->offset_ts - cfg_data->offset_ai)/cfg_data->num_ai_samples),
- "Analog Channels (%d), Sample: %d (%s)",
+ fmdata_ai_tree = proto_tree_add_subtree_format(fmdata_tree, tvb, offset, ((cfg_data->offset_ts - cfg_data->offset_ai)/cfg_data->num_ai_samples),
+ ett_selfm_fmdata_ai, NULL, "Analog Channels (%d), Sample: %d (%s)",
cfg_data->num_ai, j+1, val_to_str_const(j+1, selfm_fmconfig_numsamples2_vals, "Unknown"));
- fmdata_ai_tree = proto_item_add_subtree(fmdata_ai_item, ett_selfm_fmdata_ai);
}
else if (cfg_data->num_ai_samples == 4) {
- fmdata_ai_item = proto_tree_add_text(fmdata_tree, tvb, offset, ((cfg_data->offset_ts - cfg_data->offset_ai)/cfg_data->num_ai_samples),
- "Analog Channels (%d), Sample: %d (%s)",
+ fmdata_ai_tree = proto_tree_add_subtree_format(fmdata_tree, tvb, offset, ((cfg_data->offset_ts - cfg_data->offset_ai)/cfg_data->num_ai_samples),
+ ett_selfm_fmdata_ai, NULL, "Analog Channels (%d), Sample: %d (%s)",
cfg_data->num_ai, j+1, val_to_str_const(j+1, selfm_fmconfig_numsamples4_vals, "Unknown"));
- fmdata_ai_tree = proto_item_add_subtree(fmdata_ai_item, ett_selfm_fmdata_ai);
}
/* For each analog channel we encounter... */
}
/* Build sub-tree for each Analog Channel */
- fmdata_ai_ch_item = proto_tree_add_text(fmdata_ai_tree, tvb, offset, ch_size, "Analog Channel %d: %s", idx+1, ai->name);
- fmdata_ai_ch_tree = proto_item_add_subtree(fmdata_ai_ch_item, ett_selfm_fmdata_ai_ch);
+ fmdata_ai_ch_tree = proto_tree_add_subtree_format(fmdata_ai_tree, tvb, offset, ch_size,
+ ett_selfm_fmdata_ai_ch, NULL, "Analog Channel %d: %s", idx+1, ai->name);
/* XXX - Need more decoding options here for different data types, but I need packet capture examples first */
/* Decode analog value appropriately, according to data type */
/* Check that we actually have digital data */
if (cfg_data->num_dig > 0) {
- fmdata_dig_item = proto_tree_add_text(fmdata_tree, tvb, offset, cfg_data->num_dig, "Digital Channels (%d)", cfg_data->num_dig);
- fmdata_dig_tree = proto_item_add_subtree(fmdata_dig_item, ett_selfm_fmdata_dig);
+ fmdata_dig_tree = proto_tree_add_subtree_format(fmdata_tree, tvb, offset, cfg_data->num_dig,
+ ett_selfm_fmdata_dig, NULL, "Digital Channels (%d)", cfg_data->num_dig);
for (idx=0; idx < cfg_data->num_dig; idx++) {
- fmdata_dig_ch_item = proto_tree_add_text(fmdata_dig_tree, tvb, offset, 1, "Digital Word Bit Row: %2d", idx+1);
- fmdata_dig_ch_tree = proto_item_add_subtree(fmdata_dig_ch_item, ett_selfm_fmdata_dig_ch);
+ fmdata_dig_ch_tree = proto_tree_add_subtree_format(fmdata_dig_tree, tvb, offset, 1, ett_selfm_fmdata_dig_ch, &fmdata_dig_ch_item, "Digital Word Bit Row: %2d", idx+1);
/* Display the bit pattern on the digital channel proto_item */
proto_item_append_text(fmdata_dig_ch_item, " [ %d %d %d %d %d %d %d %d ]",
dissect_foconfig_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *foconfig_item, *foconfig_brkr_item, *foconfig_rb_item;
+ proto_item *foconfig_brkr_item, *foconfig_rb_item;
proto_tree *foconfig_tree, *foconfig_brkr_tree=NULL, *foconfig_rb_tree=NULL;
guint count;
guint8 len, num_brkr, prb_supp;
num_rb = tvb_get_ntohs(tvb, offset+2);
prb_supp = tvb_get_guint8(tvb, offset+4);
- foconfig_item = proto_tree_add_text(tree, tvb, offset, len-2, "Fast Operate Configuration Details");
- foconfig_tree = proto_item_add_subtree(foconfig_item, ett_selfm_foconfig);
+ foconfig_tree = proto_tree_add_subtree(tree, tvb, offset, len-2, ett_selfm_foconfig, NULL, "Fast Operate Configuration Details");
/* Add items to protocol tree specific to Fast Operate Configuration Block */
dissect_alt_fastop_config_frame(tvbuff_t *tvb, proto_tree *tree, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *foconfig_item=NULL;
- proto_tree *foconfig_tree=NULL;
+ proto_tree *foconfig_tree;
guint8 len;
len = tvb_get_guint8(tvb, offset);
- foconfig_item = proto_tree_add_text(tree, tvb, offset, len-2, "Alternate Fast Operate Configuration Details");
- foconfig_tree = proto_item_add_subtree(foconfig_item, ett_selfm_foconfig);
+ foconfig_tree = proto_tree_add_subtree(tree, tvb, offset, len-2,
+ ett_selfm_foconfig, NULL, "Alternate Fast Operate Configuration Details");
/* Add items to protocol tree specific to Fast Operate Configuration Block */
dissect_fastop_frame(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *fastop_item;
proto_tree *fastop_tree;
guint8 len, opcode;
guint16 msg_type;
msg_type = tvb_get_ntohs(tvb, offset-2);
len = tvb_get_guint8(tvb, offset);
- fastop_item = proto_tree_add_text(tree, tvb, offset, len-2, "Fast Operate Details");
- fastop_tree = proto_item_add_subtree(fastop_item, ett_selfm_fastop);
+ fastop_tree = proto_tree_add_subtree(tree, tvb, offset, len-2, ett_selfm_fastop, NULL, "Fast Operate Details");
/* Add Reported length to tree*/
proto_tree_add_item(fastop_tree, hf_selfm_fastop_len, tvb, offset, 1, ENC_BIG_ENDIAN);
dissect_alt_fastop_frame(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *fastop_item;
proto_tree *fastop_tree;
guint8 len;
guint16 opcode;
len = tvb_get_guint8(tvb, offset);
- fastop_item = proto_tree_add_text(tree, tvb, offset, len-2, "Alternate Fast Operate Details");
- fastop_tree = proto_item_add_subtree(fastop_item, ett_selfm_fastop);
+ fastop_tree = proto_tree_add_subtree(tree, tvb, offset, len-2, ett_selfm_fastop, NULL, "Alternate Fast Operate Details");
/* Add Reported length to tree */
proto_tree_add_item(fastop_tree, hf_selfm_alt_fastop_len, tvb, offset, 1, ENC_BIG_ENDIAN);
static int
dissect_fastser_readresp_frame(tvbuff_t *tvb, proto_tree *fastser_tree, packet_info *pinfo, int offset, guint8 seq_byte)
{
- proto_item *fastser_tag_item=NULL, *fastser_tag_value_item=NULL, *fmdata_dig_item=NULL;
+ proto_item *fastser_tag_value_item=NULL, *fmdata_dig_item=NULL;
proto_item *pi_baseaddr=NULL, *pi_fnum=NULL, *pi_type=NULL, *pi_qty=NULL;
proto_tree *fastser_tag_tree=NULL, *fmdata_dig_tree=NULL;
guint32 base_addr;
break;
}
- fastser_tag_item = proto_tree_add_text(fastser_tree, payload_tvb, payload_offset, data_size, "Data Item Name: %s", dataitem->name);
- fastser_tag_tree = proto_item_add_subtree(fastser_tag_item, ett_selfm_fastser_tag);
+ fastser_tag_tree = proto_tree_add_subtree_format(fastser_tree, payload_tvb, payload_offset, data_size,
+ ett_selfm_fastser_tag, NULL, "Data Item Name: %s", dataitem->name);
/* Load some information from the stored Data Format Response message into the tree for reference */
pi_fnum = proto_tree_add_text(fastser_tag_tree, payload_tvb, payload_offset, data_size, "Using frame number %d (Index Pos: %d) as Data Format Reference",dataitem->fnum, dataitem->index_pos );
for (cnt=1; cnt <= dataitem->quantity; cnt++) {
- fmdata_dig_item = proto_tree_add_text(fastser_tag_tree, payload_tvb, payload_offset, 1, "8-bit Binary Items (Row: %2d)", cnt);
- fmdata_dig_tree = proto_item_add_subtree(fmdata_dig_item, ett_selfm_fmdata_dig);
+ fmdata_dig_tree = proto_tree_add_subtree_format(fastser_tag_tree, payload_tvb, payload_offset, 1,
+ ett_selfm_fmdata_dig, &fmdata_dig_item, "8-bit Binary Items (Row: %2d)", cnt);
/* Display the bit pattern on the digital channel proto_item */
proto_item_append_text(fmdata_dig_item, " [ %d %d %d %d %d %d %d %d ]",
dissect_fastser_frame(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int offset)
{
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *fastser_item, *fastser_def_fc_item=NULL, *fastser_seq_item=NULL, *fastser_elementlist_item=NULL;
- proto_item *fastser_element_item=NULL, *fastser_datareg_item=NULL, *fastser_tag_item=NULL;
- proto_item *pi_baseaddr=NULL, *fastser_crc16_item=NULL;
+ proto_item *fastser_def_fc_item, *fastser_seq_item, *fastser_elementlist_item;
+ proto_item *fastser_tag_item;
+ proto_item *pi_baseaddr, *fastser_crc16_item;
proto_tree *fastser_tree, *fastser_def_fc_tree=NULL, *fastser_seq_tree=NULL, *fastser_elementlist_tree=NULL;
proto_tree *fastser_element_tree=NULL, *fastser_datareg_tree=NULL, *fastser_tag_tree=NULL;
gint cnt, num_elements, elmt_status32_ofs=0, elmt_status, null_offset;
len = tvb_get_guint8(tvb, offset);
- fastser_item = proto_tree_add_text(tree, tvb, offset, len-2, "Fast SER Message Details");
- fastser_tree = proto_item_add_subtree(fastser_item, ett_selfm_fastser);
+ fastser_tree = proto_tree_add_subtree(tree, tvb, offset, len-2, ett_selfm_fastser, NULL, "Fast SER Message Details");
/* Reported length */
proto_tree_add_item(fastser_tree, hf_selfm_fastser_len, tvb, offset, 1, ENC_BIG_ENDIAN);
elmt_status = ((elmt_status32 >> cnt) & 0x01);
/* Build the tree */
- fastser_element_item = proto_tree_add_text(fastser_elementlist_tree, tvb, offset, 4,
+ fastser_element_tree = proto_tree_add_subtree_format(fastser_elementlist_tree, tvb, offset, 4, ett_selfm_fastser_element, NULL,
"Reported Event %d (Index: %d, New State: %s)", cnt+1, elmt_idx, val_to_str_const(elmt_status, selfm_ser_status_vals, "Unknown"));
- fastser_element_tree = proto_item_add_subtree(fastser_element_item, ett_selfm_fastser_element);
/* Add Index Number and Timestamp offset to tree */
proto_tree_add_item(fastser_element_tree, hf_selfm_fastser_unsresp_elmt_idx, tvb, offset, 1, ENC_BIG_ENDIAN);
/* 16-bit message word count and 16-bit flag field */
for (cnt=0; cnt<num_reg; cnt++) {
- fastser_datareg_item = proto_tree_add_text(fastser_tree, tvb, offset, 18, "Fast SER Data Region #%d", cnt+1);
- fastser_datareg_tree = proto_item_add_subtree(fastser_datareg_item, ett_selfm_fastser_datareg);
+ fastser_datareg_tree = proto_tree_add_subtree_format(fastser_tree, tvb, offset, 18,
+ ett_selfm_fastser_datareg, NULL, "Fast SER Data Region #%d", cnt+1);
/* 10-Byte Region description */
region_name_ptr = tvb_get_string_enc(wmem_packet_scope(), tvb, offset, 10, ENC_ASCII);
static void dissect_siii_mst(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree)
{
- proto_item *ti;
proto_tree *subtree;
proto_tree *subtree2;
- ti = proto_tree_add_text(tree, tvb, 0, 6, "MST");
- subtree = proto_item_add_subtree(ti, ett_siii_mst);
+ subtree = proto_tree_add_subtree(tree, tvb, 0, 6, ett_siii_mst, NULL, "MST");
- ti = proto_tree_add_text(subtree, tvb, 0, 1, "Telegram Type");
- subtree2 = proto_item_add_subtree(ti, ett_siii_mst_teltype);
+ subtree2 = proto_tree_add_subtree(subtree, tvb, 0, 1, ett_siii_mst_teltype, NULL, "Telegram Type");
proto_tree_add_item(subtree2, hf_siii_mst_channel, tvb, 0, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item(subtree2, hf_siii_mst_type, tvb, 0, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item(subtree2, hf_siii_mst_cyclecntvalid, tvb, 0, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item(subtree2, hf_siii_mst_telno, tvb, 0, 1, ENC_LITTLE_ENDIAN);
- ti = proto_tree_add_text(subtree, tvb, 1, 1, "Phase Field");
- subtree2 = proto_item_add_subtree(ti, ett_siii_mst_phase);
+ subtree2 = proto_tree_add_subtree(subtree, tvb, 1, 1, ett_siii_mst_phase, NULL, "Phase Field");
proto_tree_add_item(subtree2, hf_siii_mst_phase, tvb, 1, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item(subtree2, hf_siii_mst_cyclecnt, tvb, 1, 1, ENC_LITTLE_ENDIAN);
proto_tree *subtree2;
proto_item *ti;
- ti = proto_tree_add_text(tree, tvb, 0, 8, "Hot-Plug");
- subtree = proto_item_add_subtree(ti, ett_siii_mdt_hp);
+ subtree = proto_tree_add_subtree(tree, tvb, 0, 8, ett_siii_mdt_hp, NULL, "Hot-Plug");
proto_tree_add_item(subtree, hf_siii_mdt_hotplug_address, tvb, 2, 2, ENC_LITTLE_ENDIAN);
tvbuff_t *tvb_n;
guint idx;
-
- proto_item *ti;
proto_tree *subtree;
proto_tree *subtree_svc;
proto_tree *subtree_devctrl;
- ti = proto_tree_add_text(tree, tvb, 0, SERCOS_SLAVE_GROUP_SIZE * 6, "Service Channels");
- subtree_svc = proto_item_add_subtree(ti, ett_siii_mdt_svc);
+ subtree_svc = proto_tree_add_subtree(tree, tvb, 0, SERCOS_SLAVE_GROUP_SIZE * 6, ett_siii_mdt_svc, NULL, "Service Channels");
- ti = proto_tree_add_text(tree, tvb, SERCOS_SLAVE_GROUP_SIZE * 6, 512, "Device Control");
- subtree_devctrl = proto_item_add_subtree(ti, ett_siii_mdt_svc);
+ subtree_devctrl = proto_tree_add_subtree(tree, tvb, SERCOS_SLAVE_GROUP_SIZE * 6, 512, ett_siii_mdt_svc, NULL, "Device Control");
for (idx = 0; idx < SERCOS_SLAVE_GROUP_SIZE; ++idx) /* each MDT of CP1/2 has data for 128 different slaves */
{
tvb_n = tvb_new_subset_length(tvb, 6 * idx, 6); /* subset for service channel data */
- ti = proto_tree_add_text(subtree_svc, tvb_n, 0, 6, "Device %u", idx + devstart);
- subtree = proto_item_add_subtree(ti, ett_siii_mdt_svc_channel);
+ subtree = proto_tree_add_subtree_format(subtree_svc, tvb_n, 0, 6, ett_siii_mdt_svc_channel, NULL, "Device %u", idx + devstart);
dissect_siii_mdt_svc(tvb_n, pinfo, subtree, idx + devstart);
tvb_n = tvb_new_subset_length(tvb, SERCOS_SLAVE_GROUP_SIZE * 6 + 4 * idx, 2); /* subset for device control information */
- ti = proto_tree_add_text(subtree_devctrl, tvb_n, 0, 2, "Device %u", idx + devstart);
- subtree = proto_item_add_subtree(ti, ett_siii_mdt_dev_control);
+ subtree = proto_tree_add_subtree_format(subtree_devctrl, tvb_n, 0, 2, ett_siii_mdt_dev_control, NULL, "Device %u", idx + devstart);
dissect_siii_mdt_devctrl(tvb_n, pinfo, subtree);
}
static void dissect_siii_mdt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- proto_item *ti;
proto_tree *subtree;
tvbuff_t *tvb_n;
(t_phase&0x0f));
}
- ti = proto_tree_add_text(tree, tvb, 0, -1, "MDT%u", telno);
- subtree = proto_item_add_subtree(ti, ett_siii_mdt);
+ subtree = proto_tree_add_subtree_format(tree, tvb, 0, -1, ett_siii_mdt, NULL, "MDT%u", telno);
dissect_siii_mst(tvb, pinfo, subtree); /* dissect SERCOS III header */
proto_tree *subtree2;
proto_item *ti;
- ti = proto_tree_add_text(tree, tvb, 0, 8, "Hot-Plug");
- subtree = proto_item_add_subtree(ti, ett_siii_at_hp);
+ subtree = proto_tree_add_subtree(tree, tvb, 0, 8, ett_siii_at_hp, NULL, "Hot-Plug");
proto_tree_add_item(subtree, hf_siii_at_hotplug_address, tvb, 2, 2, ENC_LITTLE_ENDIAN);
guint idx;
- proto_item *ti;
proto_tree *subtree;
proto_tree *subtree_svc;
proto_tree *subtree_devstat;
- ti = proto_tree_add_text(tree, tvb, 0, SERCOS_SLAVE_GROUP_SIZE * 6, "Service Channel");
- subtree_svc = proto_item_add_subtree(ti, ett_siii_at_svc);
+ subtree_svc = proto_tree_add_subtree(tree, tvb, 0, SERCOS_SLAVE_GROUP_SIZE * 6, ett_siii_at_svc, NULL, "Service Channel");
- ti = proto_tree_add_text(tree, tvb, SERCOS_SLAVE_GROUP_SIZE * 6, 512, "Device Status");
- subtree_devstat = proto_item_add_subtree(ti, ett_siii_at_devstats);
+ subtree_devstat = proto_tree_add_subtree(tree, tvb, SERCOS_SLAVE_GROUP_SIZE * 6, 512, ett_siii_at_devstats, NULL, "Device Status");
for (idx = 0; idx < SERCOS_SLAVE_GROUP_SIZE; ++idx) /* each AT of CP1/2 has data of 128 different slaves */
{
tvb_n = tvb_new_subset_length(tvb, 6 * idx, 6); /* subset for service channel data */
- ti = proto_tree_add_text(subtree_svc, tvb_n, 0, 6, "Device %u", idx + devstart);
- subtree = proto_item_add_subtree(ti, ett_siii_at_svc_channel);
+ subtree = proto_tree_add_subtree_format(subtree_svc, tvb_n, 0, 6, ett_siii_at_svc_channel, NULL, "Device %u", idx + devstart);
dissect_siii_at_svc(tvb_n, pinfo, subtree, idx + devstart);
tvb_n = tvb_new_subset_length(tvb, SERCOS_SLAVE_GROUP_SIZE * 6 + 4 * idx, 2); /* subset for device status information */
- ti = proto_tree_add_text(subtree_devstat, tvb_n, 0, 2, "Device %u", idx + devstart);
- subtree = proto_item_add_subtree(ti, ett_siii_at_dev_status);
+ subtree = proto_tree_add_subtree_format(subtree_devstat, tvb_n, 0, 2, ett_siii_at_dev_status, NULL, "Device %u", idx + devstart);
dissect_siii_at_devstat(tvb_n, pinfo, subtree);
}
}
static void dissect_siii_at(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- proto_item *ti;
proto_tree *subtree;
tvbuff_t *tvb_n;
(phase&0x0f));
}
- ti = proto_tree_add_text(tree, tvb, 0, -1, "AT%u", telno);
- subtree = proto_item_add_subtree(ti, ett_siii_at);
+ subtree = proto_tree_add_subtree_format(tree, tvb, 0, -1, ett_siii_at, NULL, "AT%u", telno);
dissect_siii_mst(tvb, pinfo, subtree); /* dissect SERCOS III header */
while(pg_len != 0)
{
param_type = tvb_get_guint8(tvb, offset);
- ti = proto_tree_add_text(pg_tree, tvb, offset, -1, "%s",
- val_to_str(param_type, param_vals,
- "Unknown parameter type (0x%02x)"));
- param_tree = proto_item_add_subtree(ti, ett_ses_param);
+ param_tree = proto_tree_add_subtree(pg_tree, tvb, offset, -1,
+ ett_ses_param, &ti,
+ val_to_str(param_type, param_vals, "Unknown parameter type (0x%02x)"));
param_str = val_to_str_const(param_type, param_vals, "Unknown");
proto_tree_add_text(param_tree, tvb, offset, 1,
"Parameter type: %s", param_str);
while (len != 0)
{
param_type = tvb_get_guint8(tvb, offset);
- ti = proto_tree_add_text(ses_tree, tvb, offset, -1, "%s",
+ param_tree = proto_tree_add_subtree(ses_tree, tvb, offset, -1, ett_ses_param, &ti,
val_to_str(param_type, param_vals,
"Unknown parameter type (0x%02x)"));
- param_tree = proto_item_add_subtree(ti, ett_ses_param);
param_str = val_to_str_const(param_type, param_vals, "Unknown");
proto_tree_add_text(param_tree, tvb, offset, 1,
"Parameter type: %s", param_str);
dissect_sflow_5_extended_mpls_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint offset) {
guint32 in_label_count, out_label_count, label, i, j;
proto_tree *in_stack;
- proto_item *ti_in;
proto_tree *out_stack;
- proto_item *ti_out;
struct sflow_address_type addr_type;
addr_type.hf_addr_v4 = hf_sflow_245_nexthop_v4;
proto_tree_add_item(tree, hf_sflow_245_extended_mpls_in_label_stack_entries, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
- ti_in = proto_tree_add_text(tree, tvb, offset, -1, "In Label Stack");
- in_stack = proto_item_add_subtree(ti_in, ett_sflow_5_mpls_in_label_stack);
+ in_stack = proto_tree_add_subtree(tree, tvb, offset, -1, ett_sflow_5_mpls_in_label_stack, NULL, "In Label Stack");
/* by applying the mask, we avoid possible corrupted data that causes huge number of loops
* 255 is a sensible limit of label count */
proto_tree_add_item(tree, hf_sflow_245_extended_mpls_out_label_stack_entries, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
- ti_out = proto_tree_add_text(tree, tvb, offset, -1, "Out Label Stack");
- out_stack = proto_item_add_subtree(ti_out, ett_sflow_5_mpls_in_label_stack);
+ out_stack = proto_tree_add_subtree(tree, tvb, offset, -1, ett_sflow_5_mpls_in_label_stack, NULL, "Out Label Stack");
/* by applying the mask, we avoid possible corrupted data that causes huge number of loops
* 255 is a sensible limit of label count */
/* only accept default enterprise 0 (InMon sFlow) */
if (enterprise == ENTERPRISE_DEFAULT) {
- ti = proto_tree_add_text(tree, tvb, offset, -1, "%s",
+ flow_data_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_sflow_5_flow_record, &ti,
val_to_str_ext_const(format, &sflow_5_flow_record_type_ext, "Unknown sample format"));
- flow_data_tree = proto_item_add_subtree(ti, ett_sflow_5_flow_record);
proto_tree_add_uint_format_value(flow_data_tree, hf_sflow_enterprise, tvb, offset, 4,
enterprise, "standard sFlow (%u)", enterprise);
}
} else {
/* unknown enterprise format, what to do?? */
- ti = proto_tree_add_text(tree, tvb, offset, -1, "Unknown enterprise format");
- flow_data_tree = proto_item_add_subtree(ti, ett_sflow_5_flow_record);
+ flow_data_tree = proto_tree_add_subtree(tree, tvb, offset, -1,
+ ett_sflow_5_flow_record, &ti, "Unknown enterprise format");
proto_tree_add_uint_format_value(flow_data_tree, hf_sflow_enterprise, tvb, offset, -1,
enterprise, "Non-standard sFlow (%u)", enterprise);
}
format = enterprise_format & 0x00000fff;
if (enterprise == ENTERPRISE_DEFAULT) { /* only accept default enterprise 0 (InMon sFlow) */
- ti = proto_tree_add_text(tree, tvb, offset, -1, "%s",
+ counter_data_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_sflow_5_counters_record, &ti,
val_to_str_const(format, sflow_5_counters_record_type, "Unknown sample format"));
- counter_data_tree = proto_item_add_subtree(ti, ett_sflow_5_counters_record);
proto_tree_add_uint_format_value(counter_data_tree, hf_sflow_enterprise, tvb, offset, 4,
enterprise, "standard sFlow (%u)", enterprise);
break;
}
} else { /* unknown enterprise format, what to do?? */
- ti = proto_tree_add_text(tree, tvb, offset, -1, "Unknown enterprise format");
- counter_data_tree = proto_item_add_subtree(ti, ett_sflow_5_counters_record);
+ counter_data_tree = proto_tree_add_subtree(tree, tvb, offset, -1,
+ ett_sflow_5_counters_record, &ti, "Unknown enterprise format");
proto_tree_add_uint_format_value(counter_data_tree, hf_sflow_enterprise, tvb, offset, -1,
enterprise, "Non-standard sFlow (%u)", enterprise);
}
format = sample_type & 0x00000fff;
if (enterprise == ENTERPRISE_DEFAULT) { /* only accept default enterprise 0 (InMon sFlow) */
- ti = proto_tree_add_text(tree, tvb, offset, -1, "%s",
+ sflow_245_sample_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_sflow_245_sample, &ti,
val_to_str_const(format, sflow_245_sampletype, "Unknown sample format"));
- sflow_245_sample_tree = proto_item_add_subtree(ti, ett_sflow_245_sample);
proto_tree_add_uint_format_value(sflow_245_sample_tree, hf_sflow_enterprise, tvb, offset, 4, enterprise, "standard sFlow (%u)", enterprise);
proto_tree_add_item(sflow_245_sample_tree, hf_sflow_245_sampletype12, tvb, offset, 4, ENC_BIG_ENDIAN);
/* current offset points to sample length field, which is 4 bytes from the beginning of the packet*/
offset += length;
} else { /* unknown enterprise format, what to do?? */
- ti = proto_tree_add_text(tree, tvb, offset, -1, "Unknown enterprise format");
- sflow_245_sample_tree = proto_item_add_subtree(ti, ett_sflow_245_sample);
+ sflow_245_sample_tree = proto_tree_add_subtree(tree, tvb, offset, -1,
+ ett_sflow_245_sample, &ti, "Unknown enterprise format");
proto_tree_add_uint_format_value(sflow_245_sample_tree, hf_sflow_enterprise, tvb, offset, -1,
enterprise, "Non-standard sFlow (%u)", enterprise);
}
} else { /* version 2 or 4 */
- ti = proto_tree_add_text(tree, tvb, offset, -1, "%s",
+ sflow_245_sample_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_sflow_245_sample, &ti,
val_to_str_const(sample_type, sflow_245_sampletype, "Unknown sample type"));
- sflow_245_sample_tree = proto_item_add_subtree(ti, ett_sflow_245_sample);
proto_tree_add_item(sflow_245_sample_tree, hf_sflow_245_sampletype, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
case OTHER_LINE:
if (sip_tree) {
- ti_a = proto_tree_add_text(sip_tree, tvb, offset, next_offset,
- "%s line: %s", descr,
+ reqresp_tree = proto_tree_add_subtree_format(sip_tree, tvb, offset, next_offset,
+ ett_sip_reqresp, NULL, "%s line: %s", descr,
tvb_format_text(tvb, offset, linelen));
- reqresp_tree = proto_item_add_subtree(ti_a, ett_sip_reqresp);
/* XXX: Is adding to 'reqresp_tree as intended ? Changed from original 'sip_tree' */
proto_tree_add_text(reqresp_tree, tvb, offset, -1, "Continuation data");
}
proto_tree_add_uint(sita_tree, hf_proto, tvb, 0, 0, proto);
flags_string = format_flags_string(flags, flags_str);
- ti = proto_tree_add_text(sita_tree, tvb, 0, 0, "Flags: 0x%02x (From %s)%s%s",
+ sita_flags_tree = proto_tree_add_subtree_format(sita_tree, tvb, 0, 0,
+ ett_sita_flags, NULL, "Flags: 0x%02x (From %s)%s%s",
flags,
((flags & SITA_FRAME_DIR) == SITA_FRAME_DIR_TXED) ? IOP : REMOTE,
strlen(flags_string) ? ", " : "",
flags_string);
- sita_flags_tree = proto_item_add_subtree(ti, ett_sita_flags);
proto_tree_add_boolean(sita_flags_tree, hf_droppedframe, tvb, 0, 0, flags);
proto_tree_add_boolean(sita_flags_tree, hf_dir, tvb, 0, 0, flags);
/* Set up structures we will need to add the protocol subtree and manage it */
proto_item *ti;
proto_tree *skinny_tree = NULL;
- proto_item *ti_sub;
proto_tree *skinny_sub_tree;
proto_tree *skinny_sub_tree_sav;
proto_tree *skinny_sub_tree_sav_sav;
capCount=tvb_get_letohl(tvb, offset+28);
for ( i = 0; i < MAX_CUSTOM_PICTURES; i++ ) {
if (i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "customPictureFormat[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL,
+ "customPictureFormat[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureWidth, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureHeight, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+=20;
}
}
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "confResources");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "confResources");
proto_tree_add_item(skinny_sub_tree, hf_skinny_activeStreamsOnRegistration, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_maxBW, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
skinny_sub_tree_sav = skinny_sub_tree;
for ( i = 0; i < MAX_SERVICE_TYPE; i++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 20, "serviceResource[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 20, ett_skinny_tree, NULL,
+ "serviceResource[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_layoutCount, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
skinny_sub_tree_sav_sav = skinny_sub_tree_sav;
for ( t = 0; t < MAX_LAYOUT_WITH_SAME_SERVICE; t++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 20, "layouts[%d]", t);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 20, ett_skinny_tree, NULL, "layouts[%d]", t);
proto_tree_add_item(skinny_sub_tree, hf_skinny_layout, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
}
capCount=tvb_get_letohl(tvb, offset+12);
for ( i = 0; i < StationMaxCapabilities; i++ ) {
if (i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "audiocaps[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "audiocaps[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_payloadCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_maxFramesPerPacket, tvb, count, 2, ENC_LITTLE_ENDIAN);
capCount=tvb_get_letohl(tvb, offset+16);
for ( i = 0; i < StationMaxVideoCapabilities; i++ ) {
if (i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "vidCaps[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "vidCaps[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_payloadCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_transmitOrReceive, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
skinny_sub_tree_sav = skinny_sub_tree;
for ( t = 0; t < MAX_LEVEL_PREFERENCE; t++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 20, "levelPreference[%d]", t);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 20, ett_skinny_tree, NULL, "levelPreference[%d]", t);
proto_tree_add_item(skinny_sub_tree, hf_skinny_transmitPreference, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_format, tvb, count, 4, ENC_LITTLE_ENDIAN);
val = count;
/* H.261 */
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h261VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h261VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_temporalSpatialTradeOffCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_stillImageTransmission, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* H.263 */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h263VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h263VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_h263_capability_bitfield, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_annexNandWFutureUse, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* Video */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "vieoVideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "vieoVideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_modelNumber, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_bandwidth, tvb, count, 4, ENC_LITTLE_ENDIAN);
capCount=tvb_get_letohl(tvb, offset+20);
for ( i = 0; i < StationMaxDataCapabilities; i++ ) {
if ( i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "dataCaps[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "dataCaps[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_payloadCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_transmitOrReceive, tvb, count, 4, ENC_LITTLE_ENDIAN);
capCount=tvb_get_letohl(tvb, offset+28);
for ( i = 0; i < MAX_CUSTOM_PICTURES; i++ ) {
if (i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "customPictureFormat[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "customPictureFormat[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureWidth, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureHeight, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+=20;
}
}
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "confResources");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "confResources");
proto_tree_add_item(skinny_sub_tree, hf_skinny_activeStreamsOnRegistration, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_maxBW, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
skinny_sub_tree_sav = skinny_sub_tree;
for ( i = 0; i < MAX_SERVICE_TYPE; i++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 20, "serviceResource[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 20, ett_skinny_tree, NULL, "serviceResource[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_layoutCount, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
skinny_sub_tree_sav_sav = skinny_sub_tree_sav;
for ( t = 0; t < MAX_LAYOUT_WITH_SAME_SERVICE; t++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 20, "layouts[%d]", t);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 20, ett_skinny_tree, NULL, "layouts[%d]", t);
proto_tree_add_item(skinny_sub_tree, hf_skinny_layout, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
}
capCount=tvb_get_letohl(tvb, offset+12);
for ( i = 0; i < StationMaxCapabilities; i++ ) {
if (i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "audiocaps[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "audiocaps[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_payloadCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_maxFramesPerPacket, tvb, count, 2, ENC_LITTLE_ENDIAN);
capCount=tvb_get_letohl(tvb, offset+16);
for ( i = 0; i < StationMaxVideoCapabilities; i++ ) {
if (i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "vidCaps[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "vidCaps[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_payloadCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_transmitOrReceive, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
skinny_sub_tree_sav = skinny_sub_tree;
for ( t = 0; t < MAX_LEVEL_PREFERENCE; t++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 20, "levelPreference[%d]", t);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 20, ett_skinny_tree, NULL, "levelPreference[%d]", t);
proto_tree_add_item(skinny_sub_tree, hf_skinny_transmitPreference, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_format, tvb, count, 4, ENC_LITTLE_ENDIAN);
val = count;
/* H.261 */
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h261VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h261VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_temporalSpatialTradeOffCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_stillImageTransmission, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* H.263 */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h263VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h263VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_h263_capability_bitfield, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_annexNandWFutureUse, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* Video */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "vieoVideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "vieoVideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_modelNumber, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_bandwidth, tvb, count, 4, ENC_LITTLE_ENDIAN);
capCount=tvb_get_letohl(tvb, offset+20);
for ( i = 0; i < StationMaxDataCapabilities; i++ ) {
if ( i < capCount) {
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 20, "dataCaps[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_tree, tvb, offset, 20, ett_skinny_tree, NULL, "dataCaps[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_payloadCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count+= 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_transmitOrReceive, tvb, count, 4, ENC_LITTLE_ENDIAN);
i += 4;
proto_tree_add_item(skinny_tree, hf_skinny_callSecurityStatus, tvb, i, 4, ENC_LITTLE_ENDIAN);
i += 4;
- ti_sub = proto_tree_add_text(skinny_tree, tvb, i, 8, "partyPIRestrictionBits");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, i, 8, ett_skinny_tree, NULL, "partyPIRestrictionBits");
proto_tree_add_item(skinny_sub_tree, hf_skinny_partyPIRestrictionBits_CallingPartyName, tvb, i, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_partyPIRestrictionBits_CallingPartyNumber, tvb, i, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_partyPIRestrictionBits_CalledPartyName, tvb, i, 4, ENC_LITTLE_ENDIAN);
si->callId = tvb_get_letohl(tvb, offset+28);
/* add audio part of union */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 12, "audioParameters");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 12, ett_skinny_tree, NULL, "audioParameters");
proto_tree_add_item(skinny_sub_tree, hf_skinny_millisecondPacketSize, tvb, offset+44, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_echoCancelType, tvb, offset+48, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_g723BitRate, tvb, offset+52, 4, ENC_LITTLE_ENDIAN);
/* add video part of union */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 30, "vidParameters");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 30, ett_skinny_tree, NULL, "vidParameters");
proto_tree_add_item(skinny_sub_tree, hf_skinny_bitRate, tvb, offset+44, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureFormatCount, tvb, offset+48, 4, ENC_LITTLE_ENDIAN);
skinny_sub_tree_sav = skinny_sub_tree;
count = offset+52;
for ( i = 0; i < MAX_PICTURE_FORMAT; i++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8 * MAX_PICTURE_FORMAT, "pictureFormat[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 8 * MAX_PICTURE_FORMAT,
+ ett_skinny_tree, NULL, "pictureFormat[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_format, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_MPI, tvb, count, 4, ENC_LITTLE_ENDIAN);
val = count;
/* add H261 part of union */
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h261VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h261VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_temporalSpatialTradeOffCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_stillImageTransmission, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* add H263 part of union */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h263VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h263VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_h263_capability_bitfield, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_annexNandWFutureUse, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* add Vieo part of union */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "vieoVideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "vieoVideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_modelNumber, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_bandwidth, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* add data part of union */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "dataParameters");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "dataParameters");
proto_tree_add_item(skinny_sub_tree, hf_skinny_protocolDependentData, tvb, offset+44, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_maxBitRate, tvb, offset+48, 4, ENC_LITTLE_ENDIAN);
break;
si->callId = tvb_get_letohl(tvb, offset+32);
/* add audio part of union */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 12, "audioParameters");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 12, ett_skinny_tree, NULL, "audioParameters");
proto_tree_add_item(skinny_sub_tree, hf_skinny_millisecondPacketSize, tvb, offset+48, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_echoCancelType, tvb, offset+52, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_g723BitRate, tvb, offset+56, 4, ENC_LITTLE_ENDIAN);
/* add video part of union */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 30, "vidParameters");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 30, ett_skinny_tree, NULL, "vidParameters");
proto_tree_add_item(skinny_sub_tree, hf_skinny_bitRate, tvb, offset+48, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureFormatCount, tvb, offset+52, 4, ENC_LITTLE_ENDIAN);
skinny_sub_tree_sav = skinny_sub_tree;
count = offset+56;
for ( i = 0; i < MAX_PICTURE_FORMAT; i++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8 * MAX_PICTURE_FORMAT, "pictureFormat[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 8 * MAX_PICTURE_FORMAT,
+ ett_skinny_tree, NULL, "pictureFormat[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_format, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_MPI, tvb, count, 4, ENC_LITTLE_ENDIAN);
val = count;
/* add H261 part of union */
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h261VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h261VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_temporalSpatialTradeOffCapability, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_stillImageTransmission, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* add H263 part of union */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "h263VideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "h263VideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_h263_capability_bitfield, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_annexNandWFutureUse, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* add Vieo part of union */
count = val;
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "vieoVideoCapability");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "vieoVideoCapability");
proto_tree_add_item(skinny_sub_tree, hf_skinny_modelNumber, tvb, count, 4, ENC_LITTLE_ENDIAN);
count += 4;
proto_tree_add_item(skinny_sub_tree, hf_skinny_bandwidth, tvb, count, 4, ENC_LITTLE_ENDIAN);
/* add data part of union */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "dataParameters");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "dataParameters");
proto_tree_add_item(skinny_sub_tree, hf_skinny_protocolDependentData, tvb, offset+48, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_maxBitRate, tvb, offset+52, 4, ENC_LITTLE_ENDIAN);
break;
/* not sure of format */
/* show videoFastUpdateGOB */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "videoFastUpdateGOB");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "videoFastUpdateGOB");
proto_tree_add_item(skinny_sub_tree, hf_skinny_firstGOB, tvb, offset+28, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_numberOfGOBs, tvb, offset+32, 4, ENC_LITTLE_ENDIAN);
/* show videoFastUpdateMB */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "videoFastUpdateGOB");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "videoFastUpdateGOB");
proto_tree_add_item(skinny_sub_tree, hf_skinny_firstGOB, tvb, offset+28, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_firstMB, tvb, offset+32, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_numberOfMBs, tvb, offset+36, 4, ENC_LITTLE_ENDIAN);
/* show lostPicture */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "lostPicture");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "lostPicture");
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureNumber, tvb, offset+28, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_longTermPictureIndex, tvb, offset+32, 4, ENC_LITTLE_ENDIAN);
/* show lostPartialPicture */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "lostPartialPicture");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "lostPartialPicture");
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureNumber, tvb, offset+28, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_longTermPictureIndex, tvb, offset+32, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_firstMB, tvb, offset+36, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_numberOfMBs, tvb, offset+40, 4, ENC_LITTLE_ENDIAN);
/* show recoveryReferencePicture */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 8, "recoveryReferencePicture");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 8, ett_skinny_tree, NULL, "recoveryReferencePicture");
proto_tree_add_item(skinny_sub_tree, hf_skinny_recoveryReferencePictureCount, tvb, offset+28, 4, ENC_LITTLE_ENDIAN);
skinny_sub_tree_sav = skinny_sub_tree;
for ( i = 0; i < MAX_REFERENCE_PICTURE; i++ ) {
- ti_sub = proto_tree_add_text(skinny_sub_tree_sav, tvb, offset, 8, "recoveryReferencePicture[%d]", i);
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree_format(skinny_sub_tree_sav, tvb, offset, 8, ett_skinny_tree, NULL, "recoveryReferencePicture[%d]", i);
proto_tree_add_item(skinny_sub_tree, hf_skinny_pictureNumber, tvb, offset+32+(i*8), 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(skinny_sub_tree, hf_skinny_longTermPictureIndex, tvb, offset+36+(i*8), 4, ENC_LITTLE_ENDIAN);
}
/* show temporalSpatialTradeOff */
- ti_sub = proto_tree_add_text(skinny_tree, tvb, offset, 4, "temporalSpatialTradeOff");
- skinny_sub_tree = proto_item_add_subtree(ti_sub, ett_skinny_tree);
+ skinny_sub_tree = proto_tree_add_subtree(skinny_tree, tvb, offset, 4, ett_skinny_tree, NULL, "temporalSpatialTradeOff");
proto_tree_add_item(skinny_sub_tree, hf_skinny_temporalSpatialTradeOff, tvb, offset+28, 4, ENC_LITTLE_ENDIAN);
break;
{
/*** 0x0A ( Announce change to UAS or SAM ) ***/
guint32 info_count;
- proto_item *ti = NULL;
- proto_tree *info_tree = NULL;
+ proto_tree *info_tree;
guint32 db_index;
guint32 domain_sid_size;
while (info_count != 0) {
db_index = tvb_get_letohl(tvb, offset);
- if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, 20,
- "DBChange Info Structure: index %u", db_index);
- info_tree = proto_item_add_subtree(ti, ett_smb_db_info);
- }
+ info_tree = proto_tree_add_subtree_format(tree, tvb, offset, 20,
+ ett_smb_db_info, NULL, "DBChange Info Structure: index %u", db_index);
proto_tree_add_uint(info_tree, hf_db_index, tvb, offset, 4,
db_index);
const char *label;
gint ett;
const item_t *resp_data;
- proto_item *data_item;
- proto_tree *data_tree;
+ proto_item *data_item = NULL;
+ proto_tree *data_tree = NULL;
proto_item *entry_item;
proto_tree *entry_tree;
guint i, j;
ett = *lanman->ett_data_entry_list;
else
ett = ett_lanman_unknown_entries;
- data_item = proto_tree_add_text(tree, tvb, offset, -1, "%s", label);
- data_tree = proto_item_add_subtree(data_item, ett);
- } else {
- data_item = NULL;
- data_tree = NULL;
+
+ data_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett, &data_item, label);
}
- } else {
- /*
- * Just leave it at the top level.
- */
- data_item = NULL;
- data_tree = tree;
}
if (trp->data_descrip == NULL) {
static int
dissect_negprot_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, proto_tree *smb_tree _U_, smb_info_t *si)
{
- proto_item *it = NULL;
proto_tree *tr = NULL;
guint16 bc;
guint8 wc;
if (tree) {
tvb_ensure_bytes_exist(tvb, offset, bc);
- it = proto_tree_add_text(tree, tvb, offset, bc, "Requested Dialects");
- tr = proto_item_add_subtree(it, ett_smb_dialects);
+ tr = proto_tree_add_subtree(tree, tvb, offset, bc, ett_smb_dialects, NULL, "Requested Dialects");
}
if (!pinfo->fd->flags.visited && si->sip) {
proto_tree *parent_tree, int offset, guint16 *bcp, gboolean *trunc,
gboolean has_find_id, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
int fn_len;
const char *fn;
char fname[11+1];
DISSECTOR_ASSERT(si);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, 21,
- "Resume Key");
- tree = proto_item_add_subtree(item, ett_smb_search_resume_key);
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, 21,
+ ett_smb_search_resume_key, NULL, "Resume Key");
/* reserved byte */
CHECK_BYTE_COUNT_SUBR(1);
proto_tree *parent_tree, int offset, guint16 *bcp, gboolean *trunc,
gboolean has_find_id, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
int fn_len;
const char *fn;
char fname[13+1];
DISSECTOR_ASSERT(si);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, 46,
- "Directory Information");
- tree = proto_item_add_subtree(item, ett_smb_search_dir_info);
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, 46,
+ ett_smb_search_dir_info, NULL, "Directory Information");
/* resume key */
offset = dissect_search_resume_key(tvb, pinfo, tree, offset, bcp,
if (un) {
old_offset = offset;
- it = proto_tree_add_text(tree, tvb, offset, -1, "Unlocks");
- tr = proto_item_add_subtree(it, ett_smb_unlocks);
+ tr = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb_unlocks, &it, "Unlocks");
while (un--) {
- proto_item *litem_2 = NULL;
- proto_tree *ltree_2 = NULL;
+ proto_tree *ltree_2;
if (lt&0x10) {
guint64 val;
guint16 lock_pid;
guint64 lock_length;
/* large lock format */
- litem_2 = proto_tree_add_text(tr, tvb, offset, 20, "Unlock");
- ltree_2 = proto_item_add_subtree(litem_2, ett_smb_unlock);
+ ltree_2 = proto_tree_add_subtree(tr, tvb, offset, 20, ett_smb_unlock, NULL, "Unlock");
/* PID */
CHECK_BYTE_COUNT(2);
}
} else {
/* normal lock format */
- litem_2 = proto_tree_add_text(tr, tvb, offset, 10, "Unlock");
- ltree_2 = proto_item_add_subtree(litem_2, ett_smb_unlock);
+ ltree_2 = proto_tree_add_subtree(tr, tvb, offset, 10, ett_smb_unlock, NULL, "Unlock");
/* PID */
CHECK_BYTE_COUNT(2);
if (ln) {
old_offset = offset;
- it = proto_tree_add_text(tree, tvb, offset, -1, "Locks");
- tr = proto_item_add_subtree(it, ett_smb_locks);
+ tr = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb_locks, &it, "Locks");
while (ln--) {
- proto_item *litem_2 = NULL;
- proto_tree *ltree_2 = NULL;
+ proto_tree *ltree_2;
if (lt&0x10) {
guint64 val;
guint16 lock_pid;
guint64 lock_length;
/* large lock format */
- litem_2 = proto_tree_add_text(tr, tvb, offset, 20, "Lock");
- ltree_2 = proto_item_add_subtree(litem_2, ett_smb_lock);
+ ltree_2 = proto_tree_add_subtree(tr, tvb, offset, 20, ett_smb_lock, NULL, "Lock");
/* PID */
CHECK_BYTE_COUNT(2);
}
} else {
/* normal lock format */
- litem_2 = proto_tree_add_text(tr, tvb, offset, 10, "Lock");
- ltree_2 = proto_item_add_subtree(litem_2, ett_smb_lock);
+ ltree_2 = proto_tree_add_subtree(tr, tvb, offset, 10, ett_smb_lock, NULL, "Lock");
/* PID */
CHECK_BYTE_COUNT(2);
ld = (smb_locking_saved_info_t *)si->sip->extra_info;
if (ld != NULL) {
- proto_item *lit;
proto_tree *ltr;
smb_lock_info_t *li;
if (tree) {
proto_tree_add_uint(ltree, hf_smb_number_of_unlocks, tvb, 0, 0, ld->num_unlock);
proto_tree_add_uint(ltree, hf_smb_number_of_locks, tvb, 0, 0, ld->num_lock);
- lit = proto_tree_add_text(ltree, tvb, 0, 0, "Locks");
- ltr = proto_item_add_subtree(lit, ett_smb_lock);
+ ltr = proto_tree_add_subtree(ltree, tvb, 0, 0, ett_smb_lock, NULL, "Locks");
li = ld->locks;
while (li) {
proto_tree_add_uint(ltr, hf_smb_pid, tvb, 0, 0, li->pid);
proto_tree_add_uint64(ltr, hf_smb_lock_long_length, tvb, 0, 0, li->length);
li = li->next;
}
- lit = proto_tree_add_text(ltree, tvb, 0, 0, "Unlocks");
- ltr = proto_item_add_subtree(lit, ett_smb_unlock);
+ ltr = proto_tree_add_subtree(ltree, tvb, 0, 0, ett_smb_unlock, NULL, "Unlocks");
li = ld->unlocks;
while (li) {
proto_tree_add_uint(ltr, hf_smb_pid, tvb, 0, 0, li->pid);
guint16 bc;
int an_len;
int count = 0;
- proto_item *it = NULL;
proto_tree *tr = NULL;
const char *an;
* has added.
*/
if (count == 0) {
- it = proto_tree_add_text(tree, tvb, offset, 4,
- "Maximal Share Access Rights");
+ tr = proto_tree_add_subtree(tree, tvb, offset, 4,
+ ett_smb_nt_access_mask, NULL, "Maximal Share Access Rights");
} else {
- it = proto_tree_add_text(tree, tvb, offset, 4,
- "Guest Maximal Share Access Rights");
+ tr = proto_tree_add_subtree(tree, tvb, offset, 4,
+ ett_smb_nt_access_mask, NULL, "Guest Maximal Share Access Rights");
}
- tr = proto_item_add_subtree(it, ett_smb_nt_access_mask);
offset = dissect_smb_access_mask(tvb, tr, offset);
wleft -= 2;
static int
dissect_nt_trans_data_request(tvbuff_t *tvb, packet_info *pinfo, int offset, proto_tree *parent_tree, int bc, nt_trans_data *ntd, smb_nt_transact_info_t *nti, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
int old_offset = offset;
guint16 bcp = bc; /* XXX fixme */
struct access_mask_info *ami = NULL;
DISSECTOR_ASSERT(si);
- if (parent_tree) {
- guint32 bytes = 0;
- bytes = tvb_length_remaining(tvb, offset);
- /*tvb_ensure_bytes_exist(tvb, offset, bc);*/
- item = proto_tree_add_text(parent_tree, tvb, offset, bytes,
- "%s Data",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, -1,
+ ett_smb_nt_trans_data, NULL, "%s Data",
val_to_str_ext(ntd->subcmd, &nt_cmd_vals_ext, "Unknown NT transaction (%u)"));
- tree = proto_item_add_subtree(item, ett_smb_nt_trans_data);
- }
switch(ntd->subcmd) {
case NT_TRANS_CREATE:
static int
dissect_nt_trans_param_request(tvbuff_t *tvb, packet_info *pinfo, int offset, proto_tree *parent_tree, int len, nt_trans_data *ntd, guint16 bc, smb_nt_transact_info_t *nti, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
guint32 fn_len, create_flags, access_mask, share_access, create_options;
const char *fn;
DISSECTOR_ASSERT(si);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, len,
- "%s Parameters",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, len,
+ ett_smb_nt_trans_param, NULL, "%s Parameters",
val_to_str_ext(ntd->subcmd, &nt_cmd_vals_ext, "Unknown NT transaction (%u)"));
- tree = proto_item_add_subtree(item, ett_smb_nt_trans_param);
- }
switch(ntd->subcmd) {
case NT_TRANS_CREATE:
static int
dissect_nt_trans_setup_request(tvbuff_t *tvb, packet_info *pinfo, int offset, proto_tree *parent_tree, int len, nt_trans_data *ntd, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
smb_nt_transact_info_t *nti = NULL;
smb_saved_info_t *sip;
nti = (smb_nt_transact_info_t *)sip->extra_info;
}
- if (parent_tree) {
- tvb_ensure_bytes_exist(tvb, offset, len);
- item = proto_tree_add_text(parent_tree, tvb, offset, len,
- "%s Setup",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, len,
+ ett_smb_nt_trans_setup, NULL, "%s Setup",
val_to_str_ext(ntd->subcmd, &nt_cmd_vals_ext, "Unknown NT transaction (%u)"));
- tree = proto_item_add_subtree(item, ett_smb_nt_trans_setup);
- }
switch(ntd->subcmd) {
case NT_TRANS_CREATE:
nt_trans_data *ntd _U_,
smb_nt_transact_info_t *nti, smb_info_t *si)
{
- proto_item *item = NULL;
proto_tree *tree = NULL;
guint16 bcp;
struct access_mask_info *ami = NULL;
if (parent_tree) {
tvb_ensure_bytes_exist(tvb, offset, len);
if (nti != NULL) {
- item = proto_tree_add_text(parent_tree, tvb, offset, len,
- "%s Data",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, len,
+ ett_smb_nt_trans_data, NULL, "%s Data",
val_to_str_ext(nti->subcmd, &nt_cmd_vals_ext, "Unknown NT Transaction (%u)"));
} else {
/*
* We never saw the request to which this is a
* response.
*/
- item = proto_tree_add_text(parent_tree, tvb, offset, len,
- "Unknown NT Transaction Data (matching request not seen)");
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, len,
+ ett_smb_nt_trans_data, NULL, "Unknown NT Transaction Data (matching request not seen)");
}
- tree = proto_item_add_subtree(item, ett_smb_nt_trans_data);
}
if (nti == NULL) {
int offset, proto_tree *parent_tree,
int len, nt_trans_data *ntd _U_, guint16 bc, smb_info_t *si)
{
- proto_item *item = NULL;
proto_tree *tree = NULL;
guint32 fn_len;
const char *fn;
if (parent_tree) {
tvb_ensure_bytes_exist(tvb, offset, len);
if (nti != NULL) {
- item = proto_tree_add_text(parent_tree, tvb, offset, len,
- "%s Parameters",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, len,
+ ett_smb_nt_trans_param, NULL, "%s Parameters",
val_to_str_ext(nti->subcmd, &nt_cmd_vals_ext, "Unknown NT Transaction (%u)"));
} else {
/*
* We never saw the request to which this is a
* response.
*/
- item = proto_tree_add_text(parent_tree, tvb, offset, len,
- "Unknown NT Transaction Parameters (matching request not seen)");
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, len,
+ ett_smb_nt_trans_param, NULL, "Unknown NT Transaction Parameters (matching request not seen)");
}
- tree = proto_item_add_subtree(item, ett_smb_nt_trans_param);
}
if (nti == NULL) {
dissect_print_queue_element(tvbuff_t *tvb, packet_info *pinfo _U_,
proto_tree *parent_tree, int offset, guint16 *bcp, gboolean *trunc, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
int fn_len;
const char *fn;
DISSECTOR_ASSERT(si);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, 28,
- "Queue entry");
- tree = proto_item_add_subtree(item, ett_smb_print_queue_entry);
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, 28,
+ ett_smb_print_queue_entry, NULL, "Queue entry");
/* queued time */
CHECK_BYTE_COUNT_SUBR(4);
if ExtendedResponses requested. */
if ((si->sip != NULL) && (si->sip->extra_info_type == SMB_EI_FILEDATA) &&
(((smb_fid_saved_info_t *)(si->sip->extra_info))->create_flags & 0x10)) {
- proto_item *mar = NULL;
- proto_item *gmar = NULL;
proto_tree *tr = NULL;
/* The first field is a Volume GUID ... */
tvb, offset, 8, ENC_LITTLE_ENDIAN);
offset += 8;
- mar = proto_tree_add_text(tree, tvb, offset, 4,
- "Maximal Access Rights");
-
- tr = proto_item_add_subtree(mar, ett_smb_nt_access_mask);
+ tr = proto_tree_add_subtree(tree, tvb, offset, 4,
+ ett_smb_nt_access_mask, NULL, "Maximal Access Rights");
offset = dissect_smb_access_mask(tvb, tr, offset);
- gmar = proto_tree_add_text(tree, tvb, offset, 4,
- "Guest Maximal Access Rights");
-
- tr = proto_item_add_subtree(gmar, ett_smb_nt_access_mask);
+ tr = proto_tree_add_subtree(tree, tvb, offset, 4,
+ ett_smb_nt_access_mask, NULL, "Guest Maximal Access Rights");
offset = dissect_smb_access_mask(tvb, tr, offset);
}
dissect_transaction2_request_parameters(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *parent_tree, int offset, int subcmd, guint16 bc, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_tree *tree;
smb_transact2_info_t *t2i;
int fn_len;
const char *fn;
else
t2i = NULL;
- if (parent_tree) {
- tvb_ensure_bytes_exist(tvb, offset, bc);
- item = proto_tree_add_text(parent_tree, tvb, offset, bc,
- "%s Parameters",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, bc,
+ ett_smb_transaction_params, NULL, "%s Parameters",
val_to_str_ext(subcmd, &trans2_cmd_vals_ext,
"Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_transaction_params);
- }
switch(subcmd) {
case 0x0000: /*TRANS2_OPEN2*/
}
/* expanded names */
if (expoffset) {
- proto_item *expitem = NULL;
- proto_tree *exptree = NULL;
+ proto_tree *exptree;
- expitem = proto_tree_add_text(tree, tvb, offset, *bcp, "Expanded Names");
- exptree = proto_item_add_subtree(expitem, ett_smb_dfs_referral_expnames);
+ exptree = proto_tree_add_subtree(tree, tvb, offset, *bcp, ett_smb_dfs_referral_expnames, NULL, "Expanded Names");
dissect_dfs_referral_strings(tvb, exptree, hf_smb_dfs_referral_expname,
nexpnames, expoffset+oldoffset, oldoffset, offset,
/* if there are any referrals */
if (numref) {
- proto_item *ref_item = NULL;
- proto_tree *ref_tree = NULL;
+ proto_item *ref_item;
+ proto_tree *ref_tree;
int old_offset = offset;
- if (tree) {
- tvb_ensure_bytes_exist(tvb, offset, *bcp);
- ref_item = proto_tree_add_text(tree,
- tvb, offset, *bcp, "Referrals");
- ref_tree = proto_item_add_subtree(ref_item,
- ett_smb_dfs_referrals);
- }
+ ref_tree = proto_tree_add_subtree(tree,
+ tvb, offset, *bcp, ett_smb_dfs_referrals, &ref_item, "Referrals");
ucstring_end = -1;
while (numref--) {
- proto_item *ri = NULL;
- proto_tree *rt = NULL;
+ proto_item *ri;
+ proto_tree *rt;
int old_offset_2 = offset;
guint16 version;
- if (tree) {
- tvb_ensure_bytes_exist(tvb, offset, *bcp);
- ri = proto_tree_add_text(ref_tree,
- tvb, offset, *bcp, "Referral");
- rt = proto_item_add_subtree(ri,
- ett_smb_dfs_referral);
- }
+ rt = proto_tree_add_subtree(ref_tree,
+ tvb, offset, *bcp, ett_smb_dfs_referral, &ri, "Referral");
/* referral version */
CHECK_BYTE_COUNT_TRANS_SUBR(2);
int start_offset = offset;
guint8 *name;
- item = proto_tree_add_text(
- tree, tvb, offset, 0, "Extended Attribute");
- subtree = proto_item_add_subtree(item, ett_smb_ea);
+ subtree = proto_tree_add_subtree(
+ tree, tvb, offset, 0, ett_smb_ea, &item, "Extended Attribute");
/* EA flags */
/* next entry offset */
CHECK_BYTE_COUNT_SUBR(4);
- if (parent_tree) {
- tvb_ensure_bytes_exist(tvb, offset, *bcp);
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "Stream Info");
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- } else {
- item = NULL;
- tree = NULL;
- }
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item, "Stream Info");
neo = tvb_get_letohl(tvb, offset);
proto_tree_add_uint(tree, hf_smb_next_entry_offset, tvb, offset, 4, neo);
int old_offset = offset;
guint8 ace_type;
- it = proto_tree_add_text(tree, tvb, offset, 0, "ACE");
- tr = proto_item_add_subtree(it, ett_smb_posix_ace);
+ tr = proto_tree_add_subtree(tree, tvb, offset, 0, ett_smb_posix_ace, &it, "ACE");
/* ace type */
CHECK_BYTE_COUNT_SUBR(1);
dissect_transaction2_request_data(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *parent_tree, int offset, int subcmd, guint16 dc, smb_info_t *si)
{
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
DISSECTOR_ASSERT(si);
- if (parent_tree) {
- tvb_ensure_bytes_exist(tvb, offset, dc);
- item = proto_tree_add_text(parent_tree, tvb, offset, dc,
- "%s Data",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, dc,
+ ett_smb_transaction_data, &item, "%s Data",
val_to_str_ext(subcmd, &trans2_cmd_vals_ext,
"Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_transaction_data);
- }
switch(subcmd) {
case 0x0000: /*TRANS2_OPEN2*/
int fn_len;
const char *fn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
smb_transact2_info_t *t2i;
gboolean resume_keys = FALSE;
guint32 bytes_needed = 0;
resume_keys = t2i->resume_keys;
}
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* Figure out of there are enough bytes to display the whole entry.
int fn_len;
const char *fn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
smb_transact2_info_t *t2i;
gboolean resume_keys = FALSE;
guint32 bytes_needed = 0;
resume_keys = t2i->resume_keys;
}
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* Figure out of there are enough bytes to display the whole entry.
const char *fn;
int old_offset = offset;
int ea_size = 0;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
smb_transact2_info_t *t2i;
gboolean resume_keys = FALSE;
resume_keys = t2i->resume_keys;
}
- if (parent_tree) {
- tvb_ensure_bytes_exist(tvb, offset, *bcp);
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
if (resume_keys) {
/* resume key */
int fn_len;
const char *fn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
guint32 neo;
int padcnt;
/* Ensure we have the bytes we need, which is up to neo */
tvb_ensure_bytes_exist(tvb, offset, neo ? neo : *bcp);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* We assume that the presence of a next entry offset implies the
int fn_len;
const char *fn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
guint32 neo;
int padcnt;
/* Ensure we have the bytes we need, which is up to neo */
tvb_ensure_bytes_exist(tvb, offset, neo ? neo : *bcp);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* We assume that the presence of a next entry offset implies the
int fn_len, sfn_len;
const char *fn, *sfn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
guint32 neo;
int padcnt;
/* Ensure we have the bytes we need, which is up to neo */
tvb_ensure_bytes_exist(tvb, offset, neo ? neo : *bcp);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* XXX - I have not seen any of these that contain a resume
int fn_len;
const char *fn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
guint32 neo;
int padcnt;
/* Ensure we have the bytes we need, which is up to neo */
tvb_ensure_bytes_exist(tvb, offset, neo ? neo : *bcp);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* XXX - I have not seen any of these that contain a resume
int fn_len, sfn_len;
const char *fn, *sfn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
guint32 neo;
int padcnt;
/* Ensure we have the bytes we need, which is up to neo */
tvb_ensure_bytes_exist(tvb, offset, neo ? neo : *bcp);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* XXX - I have not seen any of these that contain a resume
int fn_len;
const char *fn;
int old_offset = offset;
- proto_item *item = NULL;
- proto_tree *tree = NULL;
+ proto_item *item;
+ proto_tree *tree;
guint32 neo;
int padcnt;
/* Ensure we have the bytes we need, which is up to neo */
tvb_ensure_bytes_exist(tvb, offset, neo ? neo : *bcp);
- if (parent_tree) {
- item = proto_tree_add_text(parent_tree, tvb, offset, *bcp, "%s",
+ tree = proto_tree_add_subtree(parent_tree, tvb, offset, *bcp, ett_smb_ff2_data, &item,
val_to_str(si->info_level, ff2_il_vals, "Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_ff2_data);
- }
/*
* We assume that the presence of a next entry offset implies the
}
case 0x202: { /* SMB_QUERY_POSIX_WHOAMI */
- proto_item *it_gids = NULL;
- proto_tree *st_gids = NULL;
+ proto_tree *st_gids;
guint32 num_gids;
guint i;
- proto_item *it_sids = NULL;
- proto_tree *st_sids = NULL;
+ proto_tree *st_sids;
int old_sid_offset;
guint32 num_sids;
guint32 sids_buflen;
/* GIDs */
- it_gids = proto_tree_add_text(tree, tvb, offset, num_gids * 8,
- "Supplementary UNIX GIDs");
- st_gids = proto_item_add_subtree(it_gids, ett_smb_unix_whoami_gids);
+ st_gids = proto_tree_add_subtree(tree, tvb, offset, num_gids * 8,
+ ett_smb_unix_whoami_gids, NULL, "Supplementary UNIX GIDs");
for (i = 0; i < num_gids; i++) {
CHECK_BYTE_COUNT_TRANS_SUBR(8);
}
/* SIDs */
- it_sids = proto_tree_add_text(tree, tvb, offset, sids_buflen,
- "List of SIDs");
- st_sids = proto_item_add_subtree(it_sids, ett_smb_unix_whoami_sids);
+ st_sids = proto_tree_add_subtree(tree, tvb, offset, sids_buflen,
+ ett_smb_unix_whoami_sids, NULL, "List of SIDs");
for (i = 0; i < num_sids; i++) {
old_sid_offset = offset;
if (parent_tree) {
if ((t2i != NULL) && (t2i->subcmd != -1)) {
- item = proto_tree_add_text(parent_tree, tvb, offset, dc,
- "%s Data",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, dc,
+ ett_smb_transaction_data, &item, "%s Data",
val_to_str_ext(t2i->subcmd, &trans2_cmd_vals_ext,
"Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_transaction_data);
} else {
proto_tree_add_text(parent_tree, tvb, offset, dc,
"Unknown Transaction2 Data");
if (parent_tree) {
if ((t2i != NULL) && (t2i->subcmd != -1)) {
- item = proto_tree_add_text(parent_tree, tvb, offset, pc,
- "%s Parameters",
+ tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, pc,
+ ett_smb_transaction_params, &item, "%s Parameters",
val_to_str_ext(t2i->subcmd, &trans2_cmd_vals_ext,
"Unknown (0x%02x)"));
- tree = proto_item_add_subtree(item, ett_smb_transaction_params);
} else {
proto_tree_add_text(parent_tree, tvb, offset, pc,
"Unknown Transaction2 Parameters");
val_to_str_ext(cmd, &smb_cmd_vals_ext, "Unknown (0x%02x)"));
}
- cmd_item = proto_tree_add_text(smb_tree, tvb, offset, -1,
- "%s %s (0x%02x)",
+ cmd_tree = proto_tree_add_subtree_format(smb_tree, tvb, offset, -1,
+ ett_smb_command, &cmd_item, "%s %s (0x%02x)",
val_to_str_ext_const(cmd, &smb_cmd_vals_ext, "Unknown"),
(si->request)?"Request":"Response",
cmd);
- cmd_tree = proto_item_add_subtree(cmd_item, ett_smb_command);
-
/* we track FIDs on a per transaction basis.
if this was a request and the fid was seen in a reply
we add a "generated" fid tree for this pdu and v.v.
dissect_smb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
{
int offset = 0;
- proto_item *item = NULL, *hitem = NULL;
- proto_tree *tree = NULL, *htree = NULL;
+ proto_item *item;
+ proto_tree *tree, *htree;
proto_item *tmp_item = NULL;
guint8 flags;
guint16 flags2;
si->info_level = -1;
si->info_count = -1;
- if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_smb, tvb, offset,
+ item = proto_tree_add_item(parent_tree, proto_smb, tvb, offset,
-1, ENC_NA);
- tree = proto_item_add_subtree(item, ett_smb);
+ tree = proto_item_add_subtree(item, ett_smb);
- hitem = proto_tree_add_text(tree, tvb, offset, 32,
- "SMB Header");
+ htree = proto_tree_add_subtree(tree, tvb, offset, 32,
+ ett_smb_hdr, NULL, "SMB Header");
- htree = proto_item_add_subtree(hitem, ett_smb_hdr);
- }
proto_tree_add_text(htree, tvb, offset, 4, "Server Component: SMB");
offset += 4; /* Skip the marker */
const char *data = "";
guint16 bc;
int start_offset = offset;
- proto_item *ea_item = NULL;
- proto_tree *ea_tree = NULL;
+ proto_item *ea_item;
+ proto_tree *ea_tree;
- if (tree) {
- ea_item = proto_tree_add_text(tree, tvb, offset, -1, "EA:");
- ea_tree = proto_item_add_subtree(ea_item, ett_smb2_ea);
- }
+ ea_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_ea, &ea_item, "EA:");
/* next offset */
next_offset = tvb_get_letohl(tvb, offset);
int len;
int i;
int num;
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
- proto_item *parent_item = NULL;
+ proto_tree *sub_tree;
+ proto_item *parent_item;
- if (parent_tree) {
- parent_item = proto_tree_get_parent(parent_tree);
- }
+ parent_item = proto_tree_get_parent(parent_tree);
len = tvb_reported_length(tvb);
}
for (i = 0; i < num; i++) {
- if (parent_tree) {
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, 8, "RDMA V1");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_rdma_v1);
- }
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, 8, ett_smb2_rdma_v1, NULL, "RDMA V1");
proto_tree_add_item(sub_tree, hf_smb2_rdma_v1_offset, tvb, offset, 8, ENC_LITTLE_ENDIAN);
offset += 8;
static void
dissect_windows_sockaddr_in(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *parent_tree, int offset, int len)
{
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
- proto_item *parent_item = NULL;
- guint32 addr;
+ proto_item *sub_item;
+ proto_tree *sub_tree;
+ proto_item *parent_item;
if (len == -1) {
len = 16;
}
- if (parent_tree) {
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "Socket Address");
- sub_tree = proto_item_add_subtree(sub_item, ett_windows_sockaddr);
- parent_item = proto_tree_get_parent(parent_tree);
- }
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_windows_sockaddr, &sub_item, "Socket Address");
+ parent_item = proto_tree_get_parent(parent_tree);
/* family */
proto_tree_add_item(sub_tree, hf_windows_sockaddr_family, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
/* IPv4 address */
- addr = tvb_get_ipv4(tvb, offset);
- proto_tree_add_ipv4(sub_tree, hf_windows_sockaddr_in_addr, tvb, offset, 4, addr);
- if (sub_item) {
- proto_item_append_text(sub_item, ", IPv4: %s", tvb_ip_to_str(tvb, offset));
- }
- if (parent_item) {
- proto_item_append_text(parent_item, ", IPv4: %s", tvb_ip_to_str(tvb, offset));
- }
+ proto_tree_add_item(sub_tree, hf_windows_sockaddr_in_addr, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+
+ proto_item_append_text(sub_item, ", IPv4: %s", tvb_ip_to_str(tvb, offset));
+ proto_item_append_text(parent_item, ", IPv4: %s", tvb_ip_to_str(tvb, offset));
}
static void
dissect_windows_sockaddr_in6(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *parent_tree, int offset, int len)
{
- struct e_in6_addr addr;
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
- proto_item *parent_item = NULL;
+ proto_item *sub_item;
+ proto_tree *sub_tree;
+ proto_item *parent_item;
if (len == -1) {
len = 16;
}
- if (parent_tree) {
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "Socket Address");
- sub_tree = proto_item_add_subtree(sub_item, ett_windows_sockaddr);
- parent_item = proto_tree_get_parent(parent_tree);
- }
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_windows_sockaddr, &sub_item, "Socket Address");
+ parent_item = proto_tree_get_parent(parent_tree);
/* family */
proto_tree_add_item(sub_tree, hf_windows_sockaddr_family, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 4;
/* IPv4 address */
- tvb_get_ipv6(tvb, offset, &addr);
- proto_tree_add_ipv6(sub_tree, hf_windows_sockaddr_in6_addr, tvb, offset, 16, (guint8 *)&addr);
- if (sub_item) {
- proto_item_append_text(sub_item, ", IPv6: %s", tvb_ip6_to_str(tvb, offset));
- }
- if (parent_item) {
- proto_item_append_text(parent_item, ", IPv6: %s", tvb_ip6_to_str(tvb, offset));
- }
+ proto_tree_add_item(sub_tree, hf_windows_sockaddr_in6_addr, tvb, offset, 16, ENC_NA);
+ proto_item_append_text(sub_item, ", IPv6: %s", tvb_ip6_to_str(tvb, offset));
+ proto_item_append_text(parent_item, ", IPv6: %s", tvb_ip6_to_str(tvb, offset));
offset += 16;
/* sin6_scope_id */
dissect_windows_sockaddr_storage(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
{
int len = 128;
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
- proto_item *parent_item = NULL;
+ proto_item *sub_item;
+ proto_tree *sub_tree;
+ proto_item *parent_item;
guint16 family;
family = tvb_get_letohs(tvb, offset);
return;
}
- if (parent_tree) {
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "Socket Address");
- sub_tree = proto_item_add_subtree(sub_item, ett_windows_sockaddr);
- parent_item = proto_tree_get_parent(parent_tree);
- }
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_windows_sockaddr, &sub_item, "Socket Address");
+ parent_item = proto_tree_get_parent(parent_tree);
/* ss_family */
proto_tree_add_item(sub_tree, hf_windows_sockaddr_family, tvb, offset, 2, ENC_LITTLE_ENDIAN);
- if (sub_item) {
- proto_item_append_text(sub_item, ", Family: %d (0x%04x)", family, family);
- }
- if (parent_item) {
- proto_item_append_text(sub_item, ", Family: %d (0x%04x)", family, family);
- }
+ proto_item_append_text(sub_item, ", Family: %d (0x%04x)", family, family);
+ proto_item_append_text(parent_item, ", Family: %d (0x%04x)", family, family);
/*offset += 2;*/
/* unknown */
guint32 next_offset;
int offset = 0;
int len = -1;
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
- proto_item *item = NULL;
+ proto_item *sub_item;
+ proto_tree *sub_tree;
+ proto_item *item;
guint32 capabilities;
guint64 link_speed;
gfloat val = 0;
len = next_offset;
}
- if (parent_tree) {
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "Network Interface");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_ioctl_network_interface);
- }
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_smb2_ioctl_network_interface, &sub_item, "Network Interface");
+ item = proto_tree_get_parent(parent_tree);
/* next offset */
proto_tree_add_item(sub_tree, hf_smb2_ioctl_network_interface_next_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN);
proto_item_append_text(item, "%s%s",
(capabilities & NETWORK_INTERFACE_CAP_RDMA)?", RDMA":"",
(capabilities & NETWORK_INTERFACE_CAP_RSS)?", RSS":"");
- if (sub_item) {
- proto_item_append_text(sub_item, "%s%s",
+ proto_item_append_text(sub_item, "%s%s",
(capabilities & NETWORK_INTERFACE_CAP_RDMA)?", RDMA":"",
(capabilities & NETWORK_INTERFACE_CAP_RSS)?", RSS":"");
- }
}
offset += 4;
unit = "";
}
proto_item_append_text(item, ", %.1f %sBits/s", val, unit);
- if (sub_item) {
- proto_item_append_text(sub_item, ", %.1f %sBits/s", val, unit);
- }
+ proto_item_append_text(sub_item, ", %.1f %sBits/s", val, unit);
offset += 8;
dissect_smb2_QFid_buffer_response(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, smb2_info_t *si _U_)
{
int offset = 0;
- proto_item *item = NULL;
- proto_item *sub_item = NULL;
- proto_item *sub_tree = NULL;
+ proto_item *item;
+ proto_item *sub_tree;
- if (tree) {
- item = proto_tree_get_parent(tree);
- }
+ item = proto_tree_get_parent(tree);
- if (item) {
- proto_item_append_text(item, ": QFid INFO");
- sub_item = proto_tree_add_text(tree, tvb, offset, -1, "QFid INFO");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_QFid_buffer);
- }
+ proto_item_append_text(item, ": QFid INFO");
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_QFid_buffer, NULL, "QFid INFO");
proto_tree_add_item(sub_tree, hf_smb2_qfid_fid, tvb, offset, 32, ENC_NA);
}
NULL
};
int offset = 0;
- proto_item *item = NULL;
- proto_item *sub_item = NULL;
- proto_item *sub_tree = NULL;
+ proto_item *item;
+ proto_item *sub_tree;
- if (tree) {
- item = proto_tree_get_parent(tree);
- }
+ item = proto_tree_get_parent(tree);
- if (item) {
- proto_item_append_text(item, ": DH2Q Request");
- sub_item = proto_tree_add_text(tree, tvb, offset, -1, "DH2Q Request");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_DH2Q_buffer);
- }
+ proto_item_append_text(item, ": DH2Q Request");
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_DH2Q_buffer, NULL, "DH2Q Request");
/* timeout */
proto_tree_add_item(sub_tree, hf_smb2_dh2x_buffer_timeout, tvb, offset, 4, ENC_LITTLE_ENDIAN);
dissect_smb2_DH2Q_buffer_response(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, smb2_info_t *si _U_)
{
int offset = 0;
- proto_item *item = NULL;
- proto_item *sub_item = NULL;
- proto_item *sub_tree = NULL;
+ proto_item *item;
+ proto_item *sub_tree;
- if (tree) {
- item = proto_tree_get_parent(tree);
- }
+ item = proto_tree_get_parent(tree);
- if (item) {
- proto_item_append_text(item, ": DH2Q Response");
- sub_item = proto_tree_add_text(tree, tvb, offset, -1, "DH2Q Response");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_DH2Q_buffer);
- }
+ proto_item_append_text(item, ": DH2Q Response");
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_DH2Q_buffer, NULL, "DH2Q Response");
/* timeout */
proto_tree_add_item(sub_tree, hf_smb2_dh2x_buffer_timeout, tvb, offset, 4, ENC_LITTLE_ENDIAN);
dissect_smb2_DH2C_buffer_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, smb2_info_t *si)
{
int offset = 0;
- proto_item *item = NULL;
- proto_item *sub_item = NULL;
- proto_item *sub_tree = NULL;
+ proto_item *item;
+ proto_item *sub_tree;
- if (tree) {
- item = proto_tree_get_parent(tree);
- }
+ item = proto_tree_get_parent(tree);
- if (item) {
- proto_item_append_text(item, ": DH2C Request");
- sub_item = proto_tree_add_text(tree, tvb, offset, -1, "DH2C Request");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_DH2C_buffer);
- }
+ proto_item_append_text(item, ": DH2C Request");
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_DH2C_buffer, NULL, "DH2C Request");
/* file id */
dissect_smb2_fid(tvb, pinfo, sub_tree, offset, si, FID_MODE_DHNC);
dissect_smb2_MxAc_buffer_response(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, smb2_info_t *si _U_)
{
int offset = 0;
- proto_item *item = NULL;
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
+ proto_item *item;
+ proto_tree *sub_tree;
- if (tree) {
- item = proto_tree_get_parent(tree);
- }
+ item = proto_tree_get_parent(tree);
if (tvb_length(tvb) == 0) {
- if (item) {
- proto_item_append_text(item, ": NO DATA");
- }
+ proto_item_append_text(item, ": NO DATA");
return;
}
- if (item) {
- proto_item_append_text(item, ": MxAc INFO");
- sub_item = proto_tree_add_text(tree, tvb, offset, -1, "MxAc INFO");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_MxAc_buffer);
- }
+ proto_item_append_text(item, ": MxAc INFO");
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_MxAc_buffer, NULL, "MxAc INFO");
proto_tree_add_item(sub_tree, hf_smb2_mxac_status, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
{
int offset = 0;
int len;
- proto_item *sub_item = NULL;
proto_tree *sub_tree = NULL;
- proto_item *parent_item = NULL;
+ proto_item *parent_item;
- if (parent_tree) {
- parent_item = proto_tree_get_parent(parent_tree);
- }
+ parent_item = proto_tree_get_parent(parent_tree);
len = tvb_length(tvb);
switch (len) {
case 32: /* SMB2_CREATE_REQUEST/RESPONSE_LEASE */
- if (parent_item) {
- proto_item_append_text(parent_item, ": LEASE_V1");
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "LEASE_V1");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_RqLs_buffer);
- }
-
+ proto_item_append_text(parent_item, ": LEASE_V1");
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_smb2_RqLs_buffer, NULL, "LEASE_V1");
break;
case 52: /* SMB2_CREATE_REQUEST/RESPONSE_LEASE_V2 */
- if (parent_item) {
- proto_item_append_text(parent_item, ": LEASE_V2");
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "LEASE_V2");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_RqLs_buffer);
- }
-
+ proto_item_append_text(parent_item, ": LEASE_V2");
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_smb2_RqLs_buffer, NULL, "LEASE_V2");
break;
default:
report_create_context_malformed_buffer(tvb, pinfo, parent_tree, "RqLs");
dissect_smb2_APP_INSTANCE_buffer_request(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, smb2_info_t *si _U_)
{
int offset = 0;
- proto_item *item = NULL;
- proto_item *sub_item = NULL;
- proto_item *sub_tree = NULL;
+ proto_item *item;
+ proto_item *sub_tree;
- if (tree) {
- item = proto_tree_get_parent(tree);
- }
+ item = proto_tree_get_parent(tree);
- if (item) {
- proto_item_append_text(item, ": APP INSTANCE ID");
- sub_item = proto_tree_add_text(tree, tvb, offset, -1, "APP INSTANCE ID");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_APP_INSTANCE_buffer);
- }
+ proto_item_append_text(item, ": APP INSTANCE ID");
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_APP_INSTANCE_buffer, NULL, "APP INSTANCE ID");
/* struct size */
proto_tree_add_item(sub_tree, hf_smb2_APP_INSTANCE_buffer_struct_size,
guint16 chain_offset;
int offset = 0;
int len = -1;
- proto_item *sub_item = NULL;
- proto_tree *sub_tree = NULL;
+ proto_item *sub_item;
+ proto_tree *sub_tree;
proto_item *parent_item = NULL;
create_context_data_dissectors_t *dissectors = NULL;
create_context_data_dissector_t dissector = NULL;
len = chain_offset;
}
- if (parent_tree) {
- sub_item = proto_tree_add_text(parent_tree, tvb, offset, len, "Chain Element");
- sub_tree = proto_item_add_subtree(sub_item, ett_smb2_create_chain_element);
- parent_item = proto_tree_get_parent(parent_tree);
- }
+ sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_smb2_create_chain_element, &sub_item, "Chain Element");
+ parent_item = proto_tree_get_parent(parent_tree);
/* chain offset */
proto_tree_add_item(sub_tree, hf_smb2_create_chain_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN);
sesid_offset = offset;
sti->sesid = tvb_get_letoh64(tvb, offset);
sesid_item = proto_tree_add_item(tree, hf_smb2_sesid, tvb, offset, 8, ENC_LITTLE_ENDIAN);
- if (tree) {
- sesid_tree = proto_item_add_subtree(sesid_item, ett_smb2_sesid_tree);
- }
+ sesid_tree = proto_item_add_subtree(sesid_item, ett_smb2_sesid_tree);
offset += 8;
/* now we need to first lookup the uid session */
proto_tree *cmd_tree;
int old_offset = offset;
- cmd_item = proto_tree_add_text(tree, tvb, offset, -1,
- "%s %s (0x%02x)",
+ cmd_tree = proto_tree_add_subtree_format(tree, tvb, offset, -1,
+ ett_smb2_command, &cmd_item, "%s %s (0x%02x)",
decode_smb2_name(si->opcode),
(si->flags & SMB2_FLAGS_RESPONSE)?"Response":"Request",
si->opcode);
- cmd_tree = proto_item_add_subtree(cmd_item, ett_smb2_command);
-
cmd_dissector = (si->flags & SMB2_FLAGS_RESPONSE)?
smb2_dissector[si->opcode&0xff].response:
tid_offset = offset;
si->tid = tvb_get_letohl(tvb, offset);
tid_item = proto_tree_add_item(tree, hf_smb2_tid, tvb, offset, 4, ENC_LITTLE_ENDIAN);
- if (tree) {
- tid_tree = proto_item_add_subtree(tid_item, ett_smb2_tid_tree);
- }
+ tid_tree = proto_item_add_subtree(tid_item, ett_smb2_tid_tree);
offset += 4;
}
sesid_offset = offset;
si->sesid = tvb_get_letoh64(tvb, offset);
sesid_item = proto_tree_add_item(tree, hf_smb2_sesid, tvb, offset, 8, ENC_LITTLE_ENDIAN);
- if (tree) {
- sesid_tree = proto_item_add_subtree(sesid_item, ett_smb2_sesid_tree);
- }
+ sesid_tree = proto_item_add_subtree(sesid_item, ett_smb2_sesid_tree);
offset += 8;
/* now we need to first lookup the uid session */
col_append_str(pinfo->cinfo, COL_INFO, ";");
}
- if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_smb2, tvb, offset,
- -1, ENC_NA);
- tree = proto_item_add_subtree(item, ett_smb2);
- }
-
+ item = proto_tree_add_item(parent_tree, proto_smb2, tvb, offset, -1, ENC_NA);
+ tree = proto_item_add_subtree(item, ett_smb2);
- if (tree) {
- header_item = proto_tree_add_text(tree, tvb, offset, -1, "%s", label);
- header_tree = proto_item_add_subtree(header_item, ett_smb2_header);
- }
+ header_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_smb2_header, &header_item, label);
/* Decode the header */
/* Decode the payload */
offset = dissect_smb2_command(pinfo, tree, tvb, offset, si);
} else {
- proto_item *enc_item;
proto_tree *enc_tree;
tvbuff_t *enc_tvb = NULL;
tvbuff_t *plain_tvb = NULL;
offset = dissect_smb2_transform_header(pinfo, header_tree, tvb, offset, sti,
&enc_tvb, &plain_tvb);
- enc_item = proto_tree_add_text(tree, enc_tvb, 0, sti->size, "Encrypted SMB3 data");
- enc_tree = proto_item_add_subtree(enc_item, ett_smb2_encrypted);
+ enc_tree = proto_tree_add_subtree(tree, enc_tvb, 0, sti->size, ett_smb2_encrypted, NULL, "Encrypted SMB3 data");
if (plain_tvb != NULL) {
col_append_str(pinfo->cinfo, COL_INFO, "Decrypted SMB3");
dissect_smb2(plain_tvb, pinfo, enc_tree, FALSE);
-/* packet-SML.c
+/* packet-sml.c
* Routines for SML dissection
* Copyright 2013, Alexander Gaertner <gaertner.alex@gmx.de>
*
}
static void sml_time_type(tvbuff_t *tvb, proto_tree *SML_time_tree, guint *offset){
- proto_item *timetype = NULL;
- proto_tree *timetype_tree = NULL;
+ proto_tree *timetype_tree;
- timetype = proto_tree_add_text (SML_time_tree, tvb, *offset, 2, "SML-Time Type");
- timetype_tree = proto_item_add_subtree (timetype, ett_sml_timetype);
+ timetype_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, 2, ett_sml_timetype, NULL, "SML-Time Type");
proto_tree_add_item (timetype_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
}
static void field_reqFileId(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *reqFileId = NULL;
- proto_tree *reqFileId_tree = NULL;
+ proto_tree *reqFileId_tree;
get_length(tvb, offset, data, length);
- reqFileId = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data, "reqFileId");
+ reqFileId_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_reqFileId, NULL, "reqFileId");
- reqFileId_tree = proto_item_add_subtree (reqFileId, ett_sml_reqFileId);
proto_tree_add_text (reqFileId_tree, tvb, *offset, *length, "Length: %d %s", *data, plurality(*data, "octet", "octets"));
*offset+=*length;
proto_tree_add_item (reqFileId_tree, hf_sml_reqFileId, tvb, *offset, *data, ENC_NA);
}
static void field_objName(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *objName = NULL;
- proto_tree *objName_tree = NULL;
+ proto_tree *objName_tree;
/*Objectname*/
get_length(tvb, offset, data, length);
- objName = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data ,"Objectname");
+ objName_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_objName, NULL, "Objectname");
- objName_tree = proto_item_add_subtree (objName, ett_sml_objName);
proto_tree_add_text (objName_tree, tvb, *offset, *length, "Length: %d %s", *data ,plurality(*data, "octet", "octets"));
*offset+=*length;
proto_tree_add_item (objName_tree, hf_sml_objName, tvb, *offset, *data, ENC_NA);
}
static void field_status(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *status = NULL;
proto_tree *status_tree = NULL;
get_length(tvb, offset, data, length);
- status = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data ,"status %s", (*data == 0)? ": NOT SET" : "");
+ status_tree = proto_tree_add_subtree_format(insert_tree, tvb, *offset, *length + *data,
+ ett_sml_status, NULL, "status %s", (*data == 0)? ": NOT SET" : "");
if (*data > 0){
- status_tree = proto_item_add_subtree (status, ett_sml_status);
proto_tree_add_item (status_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (status_tree, hf_sml_status, tvb, *offset, *data, ENC_BIG_ENDIAN);
}
static void field_ObjReqEntry(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *object_list_Entry = NULL;
- proto_tree *object_list_Entry_tree = NULL;
+ proto_tree *object_list_Entry_tree;
/*parameterTreePath*/
get_length(tvb, offset, data, length);
- object_list_Entry = proto_tree_add_text (insert_tree, tvb ,*offset, *length + *data, "object_list_Entry");
- object_list_Entry_tree = proto_item_add_subtree (object_list_Entry, ett_sml_object_list_Entry);
+ object_list_Entry_tree = proto_tree_add_subtree(insert_tree, tvb ,*offset, *length + *data, ett_sml_object_list_Entry, NULL, "object_list_Entry");
proto_tree_add_text (object_list_Entry_tree, tvb, *offset, *length, "Length: %d %s", *data ,plurality(*data, "octet", "octets"));
*offset+=*length;
proto_tree_add_item (object_list_Entry_tree, hf_sml_object_list_Entry, tvb, *offset, *data, ENC_NA);
}
static void field_regPeriod(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *regPeriod = NULL;
- proto_tree *regPeriod_tree = NULL;
+ proto_tree *regPeriod_tree;
get_length(tvb, offset, data, length);
- regPeriod = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data, "regPeriod");
+ regPeriod_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_regPeriod, NULL, "regPeriod");
- regPeriod_tree = proto_item_add_subtree (regPeriod, ett_sml_regPeriod);
proto_tree_add_item (regPeriod_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (regPeriod_tree, hf_sml_regPeriod, tvb, *offset, *data, ENC_BIG_ENDIAN);
}
static void field_actTime(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *actTime = NULL;
- proto_tree *actTime_tree = NULL;
+ proto_tree *actTime_tree;
get_length(tvb, offset, data, length);
- actTime = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data, "actTime");
- actTime_tree = proto_item_add_subtree (actTime, ett_sml_actTime);
+ actTime_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_actTime, NULL, "actTime");
proto_tree_add_item (actTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(actTime_tree, hf_sml_actTime, tvb, *offset, *data, ENC_BIG_ENDIAN);
}
static void field_valTime(tvbuff_t *tvb, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *valTime = NULL;
- proto_tree *valTime_tree = NULL;
+ proto_tree *valTime_tree;
get_length(tvb, offset, data, length);
- valTime = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data, "valTime");
- valTime_tree = proto_item_add_subtree (valTime, ett_sml_valTime);
+ valTime_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_valTime, NULL, "valTime");
proto_tree_add_item (valTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(valTime_tree, hf_sml_valTime, tvb, *offset, *data, ENC_BIG_ENDIAN);
}
static void TupelEntryTree(tvbuff_t *tvb, proto_tree *procParValue_tree, guint *offset){
- proto_item *TupelEntry = NULL;
- proto_item *SML_time = NULL;
- proto_item *secIndex = NULL;
- proto_item *unit_pA = NULL;
- proto_item *scaler_pA = NULL;
- proto_item *value_pA = NULL;
- proto_item *unit_mA = NULL;
- proto_item *scaler_mA = NULL;
- proto_item *value_mA = NULL;
- proto_item *unit_R1 = NULL;
- proto_item *scaler_R1 = NULL;
- proto_item *value_R1 = NULL;
- proto_item *unit_R2 = NULL;
- proto_item *scaler_R2 = NULL;
- proto_item *value_R2 = NULL;
- proto_item *unit_R3 = NULL;
- proto_item *scaler_R3 = NULL;
- proto_item *value_R3 = NULL;
- proto_item *unit_R4 = NULL;
- proto_item *scaler_R4 = NULL;
- proto_item *value_R4 = NULL;
- proto_item *signature_pA_R1_R4 = NULL;
- proto_item *signature_mA_R2_R3 = NULL;
+ proto_item *SML_time;
+ proto_item *TupelEntry;
proto_tree *TupelEntry_list = NULL;
proto_tree *SML_time_tree = NULL;
guint length = 0;
/*Tupel_List*/
- TupelEntry = proto_tree_add_text (procParValue_tree, tvb, *offset, -1, "TupelEntry");
- TupelEntry_list = proto_item_add_subtree (TupelEntry, ett_sml_tupel);
+ TupelEntry_list = proto_tree_add_subtree(procParValue_tree, tvb, *offset, -1, ett_sml_tupel, &TupelEntry, "TupelEntry");
get_length(tvb, offset, &data, &length);
*offset+=length;
field_serverId(tvb, TupelEntry_list, offset, &data, &length);
/*secindex*/
- SML_time = proto_tree_add_text (procParValue_tree, tvb, *offset, -1, "secIndex");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(procParValue_tree, tvb, *offset, -1, ett_sml_time, &SML_time, "secIndex");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
get_length(tvb, offset, &data, &length);
- secIndex = proto_tree_add_text (SML_time_tree, tvb, *offset, length + data, "secIndex");
- secIndex_tree = proto_item_add_subtree (secIndex, ett_sml_secIndex);
+ secIndex_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_secIndex, NULL, "secIndex");
proto_tree_add_item (secIndex_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(secIndex_tree, hf_sml_secIndex, tvb, *offset, data, ENC_BIG_ENDIAN);
field_status(tvb, TupelEntry_list, offset, &data, &length);
/*unit_pA*/
- unit_pA= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "unit_pA");
- unit_pA_tree = proto_item_add_subtree(unit_pA, ett_sml_unit_pA);
+ unit_pA_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_unit_pA, NULL, "unit_pA");
proto_tree_add_item (unit_pA_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (unit_pA_tree, hf_sml_unit_pA, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*scaler_pA*/
- scaler_pA= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "scaler_pA");
- scaler_pA_tree = proto_item_add_subtree(scaler_pA, ett_sml_scaler_pA);
+ scaler_pA_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_scaler_pA, NULL, "scaler_pA");
proto_tree_add_item (scaler_pA_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (scaler_pA_tree, hf_sml_scaler_pA, tvb, *offset, 1, ENC_NA);
/*value_pA*/
get_length(tvb, offset, &data, &length);
- value_pA= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "value_pA");
- value_pA_tree = proto_item_add_subtree(value_pA, ett_sml_value_pA);
+ value_pA_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_value_pA, NULL, "value_pA");
proto_tree_add_item (value_pA_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (value_pA_tree, hf_sml_value_pA, tvb, *offset, data, ENC_NA);
*offset+=data;
/*unit_R1*/
- unit_R1= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "unit_R1");
- unit_R1_tree = proto_item_add_subtree(unit_R1, ett_sml_unit_R1);
+ unit_R1_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_unit_R1, NULL, "unit_R1");
proto_tree_add_item (unit_R1_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (unit_R1_tree, hf_sml_unit_R1, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*scaler_R1*/
- scaler_R1= proto_tree_add_text (TupelEntry_list, tvb, *offset, 1, "scaler_R1");
- scaler_R1_tree = proto_item_add_subtree(scaler_R1, ett_sml_scaler_R1);
+ scaler_R1_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 1, ett_sml_scaler_R1, NULL, "scaler_R1");
proto_tree_add_item (scaler_R1_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (scaler_R1_tree, hf_sml_scaler_R1, tvb, *offset, 1, ENC_NA);
/*value_R1*/
get_length(tvb, offset, &data, &length);
- value_R1= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "value_R1");
- value_R1_tree = proto_item_add_subtree(value_R1, ett_sml_value_R1);
+ value_R1_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_value_R1, NULL, "value_R1");
proto_tree_add_item (value_R1_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (value_R1_tree, hf_sml_value_R1, tvb, *offset, data, ENC_NA);
*offset+=data;
/*unit_R4*/
- unit_R4= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "unit_R4");
- unit_R4_tree = proto_item_add_subtree(unit_R4, ett_sml_unit_R4);
+ unit_R4_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_unit_R4, NULL, "unit_R4");
proto_tree_add_item (unit_R4_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (unit_R4_tree, hf_sml_unit_R4, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*scaler_R4*/
- scaler_R4= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "scaler_R4");
- scaler_R4_tree = proto_item_add_subtree(scaler_R4, ett_sml_scaler_R4);
+ scaler_R4_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_scaler_R4, NULL, "scaler_R4");
proto_tree_add_item (scaler_R4_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (scaler_R4_tree, hf_sml_scaler_R4, tvb, *offset, 1, ENC_NA);
/*value_R4*/
get_length(tvb, offset, &data, &length);
- value_R4= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "value_R4");
- value_R4_tree = proto_item_add_subtree(value_R4, ett_sml_value_R4);
+ value_R4_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_value_R4, NULL, "value_R4");
proto_tree_add_item (value_R4_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (value_R4_tree, hf_sml_value_R4, tvb, *offset, data, ENC_NA);
/*signature_pA_R1_R4*/
get_length(tvb, offset, &data, &length);
- signature_pA_R1_R4= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "signature_pa_R1_R4");
- signature_pA_R1_R4_tree = proto_item_add_subtree(signature_pA_R1_R4, ett_sml_signature_pA_R1_R4);
+ signature_pA_R1_R4_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_signature_pA_R1_R4, NULL, "signature_pa_R1_R4");
proto_tree_add_text (signature_pA_R1_R4_tree, tvb, *offset, length, "Length: %d %s", data ,plurality(data, "octet", "octets"));
*offset+=length;
proto_tree_add_item (signature_pA_R1_R4_tree, hf_sml_signature_pA_R1_R4, tvb, *offset, data, ENC_NA);
*offset+=data;
/*unit_mA*/
- unit_mA= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "unit_mA");
- unit_mA_tree = proto_item_add_subtree(unit_mA, ett_sml_unit_mA);
+ unit_mA_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_unit_mA, NULL, "unit_mA");
proto_tree_add_item (unit_mA_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (unit_mA_tree, hf_sml_unit_mA, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*scaler_mA*/
- scaler_mA= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "scaler_mA");
- scaler_mA_tree = proto_item_add_subtree(scaler_mA, ett_sml_scaler_mA);
+ scaler_mA_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_scaler_mA, NULL, "scaler_mA");
proto_tree_add_item (scaler_mA_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (scaler_mA_tree, hf_sml_scaler_mA, tvb, *offset, 1, ENC_NA);
/*value_mA*/
get_length(tvb, offset, &data, &length);
- value_mA= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "value_mA");
- value_mA_tree = proto_item_add_subtree(value_mA, ett_sml_value_mA);
+ value_mA_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_value_mA, NULL, "value_mA");
proto_tree_add_item (value_mA_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (value_mA_tree, hf_sml_value_mA, tvb, *offset, data, ENC_NA);
*offset+=data;
/*unit_R2*/
- unit_R2= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "unit_R2");
- unit_R2_tree = proto_item_add_subtree(unit_R2, ett_sml_unit_R2);
+ unit_R2_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_unit_R2, NULL, "unit_R2");
proto_tree_add_item (unit_R2_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (unit_R2_tree, hf_sml_unit_R2, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*scaler_R2*/
- scaler_R2= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "scaler_R2");
- scaler_R2_tree = proto_item_add_subtree(scaler_R2, ett_sml_scaler_R2);
+ scaler_R2_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_scaler_R2, NULL, "scaler_R2");
proto_tree_add_item (scaler_R2_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (scaler_R2_tree, hf_sml_scaler_R2, tvb, *offset, 1, ENC_NA);
/*value_R2*/
get_length(tvb, offset, &data, &length);
- value_R2= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "value_R2");
- value_R2_tree = proto_item_add_subtree(value_R2, ett_sml_value_R2);
+ value_R2_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_value_R2, NULL, "value_R2");
proto_tree_add_item (value_R2_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (value_R2_tree, hf_sml_value_R2, tvb, *offset, data, ENC_NA);
*offset+=data;
/*unit_R3*/
- unit_R3= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "unit_R3");
- unit_R3_tree = proto_item_add_subtree(unit_R3, ett_sml_unit_R3);
+ unit_R3_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_unit_R3, NULL, "unit_R3");
proto_tree_add_item (unit_R3_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (unit_R3_tree, hf_sml_unit_R3, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*scaler_R3*/
- scaler_R3= proto_tree_add_text (TupelEntry_list, tvb, *offset, 2, "scaler_R3");
- scaler_R3_tree = proto_item_add_subtree(scaler_R3, ett_sml_scaler_R3);
+ scaler_R3_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, 2, ett_sml_scaler_R3, NULL, "scaler_R3");
proto_tree_add_item (scaler_R3_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (scaler_R3_tree, hf_sml_scaler_R3, tvb, *offset, 1, ENC_NA);
/*value_R3*/
get_length(tvb, offset, &data, &length);
- value_R3= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "value_R3");
- value_R3_tree = proto_item_add_subtree(value_R3, ett_sml_value_R3);
+ value_R3_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_value_R3, NULL, "value_R3");
proto_tree_add_item (value_R3_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (value_R3_tree, hf_sml_value_R3, tvb, *offset, data, ENC_NA);
/*signature_mA_R2_R3*/
get_length(tvb, offset, &data, &length);
- signature_mA_R2_R3= proto_tree_add_text (TupelEntry_list, tvb, *offset, length+data, "signature_mA_R2_R3");
- signature_mA_R2_R3_tree = proto_item_add_subtree(signature_mA_R2_R3, ett_sml_signature_mA_R2_R3);
- proto_tree_add_text (signature_mA_R2_R3_tree, tvb, *offset, length, "Length: %d %s", data ,plurality(data, "octet", "octets"));
+ signature_mA_R2_R3_tree = proto_tree_add_subtree(TupelEntry_list, tvb, *offset, length+data, ett_sml_signature_mA_R2_R3, NULL, "signature_mA_R2_R3");
+ proto_tree_add_text (signature_mA_R2_R3_tree, tvb, *offset, length, "Length: %d %s", data, plurality(data, "octet", "octets"));
*offset+=length;
proto_tree_add_item (signature_mA_R2_R3_tree, hf_sml_signature_mA_R2_R3, tvb, *offset, data, ENC_NA);
*offset+=data;
}
static void child_tree(tvbuff_t *tvb, packet_info *pinfo, proto_tree *insert_tree, guint *offset, guint *data, guint *length){
- proto_item *parameterName = NULL;
- proto_item *procParValue = NULL;
- proto_item *child = NULL;
- proto_item *procParValuetype = NULL;
- proto_item *periodEntry = NULL;
- proto_item *SML_time = NULL;
- proto_item *procParValueTime = NULL;
- proto_item *tree_Entry = NULL;
+ proto_item *parameterName;
+ proto_item *procParValue;
+ proto_item *child;
+ proto_item *periodEntry;
+ proto_item *SML_time;
+ proto_item *tree_Entry;
proto_tree *parameterName_tree = NULL;
proto_tree *procParValue_tree = NULL;
/*parameterName*/
get_length(tvb, offset, data, length);
- parameterName = proto_tree_add_text (insert_tree, tvb, *offset, *length + *data ,"parameterName");
- parameterName_tree = proto_item_add_subtree (parameterName, ett_sml_parameterName);
+ parameterName_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, *length + *data, ett_sml_parameterName, ¶meterName, "parameterName");
proto_tree_add_text (parameterName_tree, tvb, *offset, *length, "Length: %d %s", *data ,plurality(*data, "octet", "octets"));
*offset+=*length;
proto_tree_add_item (parameterName_tree, hf_sml_parameterName, tvb, *offset, *data, ENC_NA);
}
else if (check == 0x72){
get_length(tvb, offset, data, length);
- procParValue = proto_tree_add_text(insert_tree, tvb, *offset, -1, "ProcParValue");
- procParValue_tree = proto_item_add_subtree (procParValue, ett_sml_procParValue);
+ procParValue_tree = proto_tree_add_subtree(insert_tree, tvb, *offset, -1, ett_sml_procParValue, &procParValue, "ProcParValue");
*offset+=1;
/*procParValue CHOOSE*/
- procParValuetype = proto_tree_add_text (procParValue_tree, tvb, *offset, 2, "ProcParValueType");
- procParValuetype_tree = proto_item_add_subtree (procParValuetype, ett_sml_procParValuetype);
+ procParValuetype_tree = proto_tree_add_subtree(procParValue_tree, tvb, *offset, 2, ett_sml_procParValuetype, NULL, "ProcParValueType");
proto_tree_add_item (procParValuetype_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
check = tvb_get_guint8(tvb, *offset);
case PROC_PERIOD:
/*period*/
get_length(tvb, offset, data, length);
- periodEntry = proto_tree_add_text(procParValue_tree, tvb, *offset, -1, "PeriodEntry List with %d %s", *length + *data, plurality(*length + *data, "element", "elements"));
- periodEntry_tree = proto_item_add_subtree(periodEntry, ett_sml_periodEntry);
+ periodEntry_tree = proto_tree_add_subtree_format(procParValue_tree, tvb, *offset, -1, ett_sml_periodEntry, &periodEntry,
+ "PeriodEntry List with %d %s", *length + *data, plurality(*length + *data, "element", "elements"));
*offset+=*length;
/*objName*/
break;
case PROC_TIME:
- SML_time = proto_tree_add_text (procParValue_tree, tvb, *offset, -1, "Time");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(procParValue_tree, tvb, *offset, -1, ett_sml_time, &SML_time, "Time");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
/*Time*/
get_length(tvb, offset, data, length);
- procParValueTime = proto_tree_add_text (SML_time_tree, tvb, *offset, *length + *data, "procParValueTime");
- procParValueTime_tree = proto_item_add_subtree (procParValueTime, ett_sml_procParValueTime);
+ procParValueTime_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, *length + *data, ett_sml_procParValueTime, NULL, "procParValueTime");
proto_tree_add_item (procParValueTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(procParValueTime_tree, hf_sml_procParValueTime, tvb, *offset, *data, ENC_BIG_ENDIAN);
else if ((check & 0x0F) != 0){
if (check == 0x71){
get_length(tvb, offset, data, length);
- child = proto_tree_add_text(insert_tree, tvb, *offset, -1, "Child List with %d %s", *length + *data, plurality(*length + *data, "element", "elements"));
- child_list = proto_item_add_subtree(child, ett_sml_child);
+ child_list = proto_tree_add_subtree_format(insert_tree, tvb, *offset, -1, ett_sml_child, &child,
+ "Child List with %d %s", *length + *data, plurality(*length + *data, "element", "elements"));
*offset+=1;
- tree_Entry = proto_tree_add_text (child_list, tvb, *offset, -1, "tree_Entry");
- tree_Entry_list = proto_item_add_subtree(tree_Entry, ett_sml_tree_Entry);
+ tree_Entry_list = proto_tree_add_subtree(child_list, tvb, *offset, -1, ett_sml_tree_Entry, &tree_Entry, "tree_Entry");
*offset+=1;
child_tree(tvb, pinfo,tree_Entry_list, offset, data, length);
else if ((check & 0xF0) == SHORT_LIST || (check & 0xF0) == LONG_LIST){
get_length(tvb, offset, data, length);
repeat = *length + *data;
- child = proto_tree_add_text(insert_tree, tvb, *offset, -1, "Child List with %d %s", *length + *data, plurality(*length + *data, "element", "elements"));
- child_list = proto_item_add_subtree(child, ett_sml_child);
+ child_list = proto_tree_add_subtree_format(insert_tree, tvb, *offset, -1, ett_sml_child, &child,
+ "Child List with %d %s", *length + *data, plurality(*length + *data, "element", "elements"));
if (repeat <= 0){
expert_add_info_format(pinfo, child, &ei_sml_invalid_count, "invalid loop count");
return;
*offset+=*length;
for(i =0 ; i < repeat; i++){
- tree_Entry = proto_tree_add_text (child_list, tvb, *offset, -1, "tree_Entry");
- tree_Entry_list = proto_item_add_subtree(tree_Entry, ett_sml_tree_Entry);
+ tree_Entry_list = proto_tree_add_subtree(child_list, tvb, *offset, -1, ett_sml_tree_Entry, &tree_Entry, "tree_Entry");
if (tvb_get_guint8(tvb, *offset) != 0x73){
expert_add_info_format(pinfo, tree_Entry, &ei_sml_invalid_count, "invalid count of elements in tree_Entry");
}
static void decode_PublicOpenRes (tvbuff_t *tvb, proto_tree *messagebodytree_list, guint *offset){
- proto_item *refTime = NULL;
proto_item *SML_time = NULL;
proto_tree *refTime_tree = NULL;
}
else{
/*SML TIME*/
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "refTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "refTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
/*refTime*/
get_length(tvb, offset, &data, &length);
- refTime = proto_tree_add_text (SML_time_tree, tvb, *offset, length+data, "refTime");
- refTime_tree = proto_item_add_subtree (refTime, ett_sml_refTime);
+ refTime_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length+data, ett_sml_refTime, NULL, "refTime");
proto_tree_add_item (refTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(refTime_tree, hf_sml_refTime, tvb, *offset, data, ENC_BIG_ENDIAN);
static gboolean decode_GetProfile_List_Pack_Req (tvbuff_t *tvb, packet_info *pinfo, proto_tree *messagebodytree_list, guint *offset){
proto_item *withRawdata = NULL;
proto_item *SML_time = NULL;
- proto_item *beginTime = NULL;
proto_item *treepath = NULL;
proto_item *object_list = NULL;
- proto_item *endTime = NULL;
proto_item *dasDetails = NULL;
proto_tree *withRawdata_tree = NULL;
}
else {
/*SML TIME*/
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "beginTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "beginTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
/*beginTime*/
get_length(tvb, offset, &data, &length);
- beginTime = proto_tree_add_text (SML_time_tree, tvb, *offset, length + data, "beginTime");
- beginTime_tree = proto_item_add_subtree (beginTime, ett_sml_beginTime);
+ beginTime_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_beginTime, NULL, "beginTime");
proto_tree_add_item (beginTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(beginTime_tree, hf_sml_beginTime, tvb, *offset, data, ENC_BIG_ENDIAN);
}
else {
/*SML TIME*/
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "endTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "endTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
/*endTime*/
get_length(tvb, offset, &data, &length);
- endTime = proto_tree_add_text (SML_time_tree, tvb, *offset, length + data, "endTime");
- endTime_tree = proto_item_add_subtree (endTime, ett_sml_beginTime);
+ endTime_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_beginTime, NULL, "endTime");
proto_tree_add_item (endTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(endTime_tree, hf_sml_endTime, tvb, *offset, data, ENC_BIG_ENDIAN);
/*Treepath List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- treepath = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
- treepath_list = proto_item_add_subtree(treepath, ett_sml_treepath);
+ treepath_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_treepath, &treepath,
+ "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, treepath, &ei_sml_invalid_count, "invalid count of elements in Treepath");
else{
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- object_list = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "object_List with %d %s", length+data, plurality(length+data, "element", "elements"));
- object_list_list = proto_item_add_subtree(object_list, ett_sml_object_list);
+ object_list_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_object_list, &object_list,
+ "object_List with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, object_list, &ei_sml_invalid_count, "invalid count of elements in object_List");
}
else if ((check & 0xF0) == LONG_LIST || (check & 0xF0) == SHORT_LIST){
get_length(tvb, offset, &data, &length);
- dasDetails = proto_tree_add_text(messagebodytree_list, tvb, *offset, -1, "dasDetails with %d %s", length+data, plurality(length+data, "element", "elements"));
- dasDetails_list = proto_item_add_subtree(dasDetails, ett_sml_dasDetails);
+ dasDetails_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_dasDetails, &dasDetails,
+ "dasDetails with %d %s", length+data, plurality(length+data, "element", "elements"));
*offset+=length;
child_tree(tvb, pinfo, dasDetails_list, offset, &data, &length);
/*actTime*/
get_length(tvb, offset, &data, &length);
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "actTime List with %d %s", length+data, plurality(length+data, "element", "elements"));
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time,
+ "actTime List with %d %s", length+data, plurality(length+data, "element", "elements"));
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
field_actTime(tvb, SML_time_tree, offset, &data, &length);
/*Treepath List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- treepath = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
- treepath_list = proto_item_add_subtree(treepath, ett_sml_treepath);
+ treepath_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_treepath, &treepath,
+ "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, treepath, &ei_sml_invalid_count, "invalid count of elements in Treepath");
/*headerList*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- headerList = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "header_List with %d %s", length+data, plurality(length+data, "element", "elements"));
- headerList_subtree = proto_item_add_subtree(headerList, ett_sml_headerList);
+ headerList_subtree = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_headerList, &headerList,
+ "header_List with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, headerList, &ei_sml_invalid_count, "invalid count of elements in headerlist");
for (i=0; i< repeat; i++) {
get_length(tvb, offset, &data, &length);
- header_List_Entry = proto_tree_add_text (headerList_subtree, tvb, *offset, -1, "header_List_Entry with %d %s", length+data, plurality(length+data, "element", "elements"));
- header_List_Entry_list = proto_item_add_subtree(header_List_Entry, ett_sml_header_List_Entry);
+ header_List_Entry_list = proto_tree_add_subtree_format(headerList_subtree, tvb, *offset, -1, ett_sml_header_List_Entry, &header_List_Entry,
+ "header_List_Entry with %d %s", length+data, plurality(length+data, "element", "elements"));
*offset+=1;
/*objname*/
/*period List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- periodList = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "period_List with %d %s", length+data, plurality(length+data, "element", "elements"));
- periodList_list = proto_item_add_subtree(periodList, ett_sml_periodList);
+ periodList_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_periodList, &periodList,
+ "period_List with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, periodList, &ei_sml_invalid_count, "invalid count of elements in periodList");
for (i=0; i< repeat; i++) {
get_length(tvb, offset, &data, &length);
- period_List_Entry = proto_tree_add_text (periodList_list, tvb, *offset, -1, "period_List_Entry with %d %s", length+data, plurality(length+data, "element", "elements"));
- period_List_Entry_list = proto_item_add_subtree(period_List_Entry, ett_sml_period_List_Entry);
+ period_List_Entry_list = proto_tree_add_subtree_format(periodList_list, tvb, *offset, -1, ett_sml_period_List_Entry, &period_List_Entry,
+ "period_List_Entry with %d %s", length+data, plurality(length+data, "element", "elements"));
*offset+=1;
/*valTime*/
get_length(tvb, offset, &data, &length);
- SML_time = proto_tree_add_text (period_List_Entry, tvb, *offset, -1, "valTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(period_List_Entry, tvb, *offset, -1, ett_sml_time, &SML_time, "valTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
field_valTime(tvb, SML_time_tree, offset, &data, &length);
/*value List*/
get_length(tvb, offset, &data, &length);
repeat2 = data + length;
- valuelist = proto_tree_add_text (period_List_Entry_list, tvb, *offset, -1, "period_List with %d %s", length+data, plurality(length+data, "element", "elements"));
- valuelist_list = proto_item_add_subtree(valuelist, ett_sml_valuelist);
+ valuelist_list = proto_tree_add_subtree_format(period_List_Entry_list, tvb, *offset, -1, ett_sml_valuelist, &valuelist,
+ "period_List with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, valuelist, &ei_sml_invalid_count, "invalid count of elements in valueList");
for (d=0; d< repeat2; d++) {
get_length(tvb, offset, &data, &length);
- value_List_Entry = proto_tree_add_text (valuelist_list, tvb, *offset, -1, "value_List_Entry with %d %s", length+data, plurality(length+data, "element", "elements"));
- value_List_Entry_list = proto_item_add_subtree(value_List_Entry, ett_sml_value_List_Entry);
+ value_List_Entry_list = proto_tree_add_subtree_format(valuelist_list, tvb, *offset, -1, ett_sml_value_List_Entry, NULL,
+ "value_List_Entry with %d %s", length+data, plurality(length+data, "element", "elements"));
*offset+=1;
/*value*/
/*actTime*/
get_length(tvb, offset, &data, &length);
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "actTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "actTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
field_actTime(tvb, SML_time_tree, offset, &data, &length);
/*Treepath List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- treepath = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
- treepath_list = proto_item_add_subtree(treepath, ett_sml_treepath);
+ treepath_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_treepath, &treepath,
+ "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, treepath, &ei_sml_invalid_count, "invalid count of elements in parameterTreePath");
}
else {
/*SML TIME*/
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "valTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "valTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
/*period-List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- periodList = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "period-List with %d %s", length+data, plurality(length+data, "element", "elements"));
- periodList_list = proto_item_add_subtree(periodList, ett_sml_periodList);
+ periodList_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_periodList, &periodList,
+ "period-List with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, periodList, &ei_sml_invalid_count, "invalid count of elements in periodList");
for (i=0; i< repeat; i++) {
get_length(tvb, offset, &data, &length);
- periodList_Entry = proto_tree_add_text (periodList_list, tvb, *offset, -1, "PeriodEntry");
- periodList_Entry_list = proto_item_add_subtree(periodList_Entry, ett_sml_period_List_Entry);
+ periodList_Entry_list = proto_tree_add_subtree(periodList_list, tvb, *offset, -1, ett_sml_period_List_Entry, &periodList_Entry, "PeriodEntry");
*offset+=1;
/*ObjName*/
}
static gboolean decode_GetListRes (tvbuff_t *tvb, packet_info *pinfo, proto_tree *messagebodytree_list, guint *offset){
- proto_item *actSensorTime = NULL;
proto_item *valList = NULL;
proto_item *listSignature = NULL;
proto_item *valtree = NULL;
- proto_item *actGatewayTime = NULL;
proto_item *SML_time;
proto_tree *actSensorTime_tree = NULL;
}
else {
/*SML TIME*/
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "actSensorTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "actSensorTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
/*actSensorTime*/
get_length(tvb, offset, &data, &length);
- actSensorTime = proto_tree_add_text (SML_time_tree, tvb, *offset, length + data, "actSensorTime");
- actSensorTime_tree = proto_item_add_subtree (actSensorTime, ett_sml_actSensorTime);
+ actSensorTime_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_actSensorTime, NULL, "actSensorTime");
proto_tree_add_item (actSensorTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(actSensorTime_tree, hf_sml_actSensorTime, tvb, *offset, data, ENC_BIG_ENDIAN);
/*valList*/
get_length(tvb, offset, &data, &length);
repeat = (length + data);
- valtree = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "valList with %d %s", length+data, plurality(length+data, "element", "elements"));
- valtree_list = proto_item_add_subtree (valtree, ett_sml_valtree);
+ valtree_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_valtree, &valtree,
+ "valList with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, valtree, &ei_sml_invalid_count, "invalid count of elements in valList");
for (i=0; i < repeat; i++){
get_length(tvb, offset, &data, &length);
- valList = proto_tree_add_text (valtree_list, tvb, *offset, -1, "valListEntry");
- valList_list = proto_item_add_subtree (valList, ett_sml_valList);
+ valList_list = proto_tree_add_subtree(valtree_list, tvb, *offset, -1, ett_sml_valList, &valList, "valListEntry");
*offset+=length;
/*objName*/
}
else {
/*SML TIME*/
- SML_time = proto_tree_add_text (valList_list, tvb, *offset, -1, "valTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(valList_list, tvb, *offset, -1, ett_sml_time, &SML_time, "valTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
}
else{
/*SML TIME*/
- SML_time = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "actGatewayTime");
- SML_time_tree = proto_item_add_subtree (SML_time, ett_sml_time);
+ SML_time_tree = proto_tree_add_subtree(messagebodytree_list, tvb, *offset, -1, ett_sml_time, &SML_time, "actGatewayTime");
*offset+=1;
sml_time_type(tvb, SML_time_tree, offset);
get_length(tvb, offset, &data, &length);
- actGatewayTime = proto_tree_add_text (SML_time_tree, tvb, *offset, length + data, "actGatewayTime");
- actGatewayTime_tree = proto_item_add_subtree (actGatewayTime, ett_sml_actSensorTime);
+ actGatewayTime_tree = proto_tree_add_subtree(SML_time_tree, tvb, *offset, length + data, ett_sml_actSensorTime, NULL, "actGatewayTime");
proto_tree_add_item (actGatewayTime_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(actGatewayTime_tree, hf_sml_actGatewayTime, tvb, *offset, data, ENC_BIG_ENDIAN);
/*Treepath List*/
get_length(tvb, offset, &data, &length);
repeat = data+length;
- treepath = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "ParameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
- treepath_list = proto_item_add_subtree(treepath, ett_sml_treepath);
+ treepath_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_treepath, &treepath,
+ "ParameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, treepath, &ei_sml_invalid_count, "invalid count of elements in ParameterTreePath");
/*Treepath List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- treepath = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
- treepath_list = proto_item_add_subtree(treepath, ett_sml_treepath);
+ treepath_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_treepath, &treepath,
+ "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, treepath, &ei_sml_invalid_count, "invalid count of elements in ParameterTreePath");
/*parameterTree*/
get_length(tvb, offset, &data, &length);
- parameterTree = proto_tree_add_text(messagebodytree_list, tvb, *offset, -1, "parameterTree with %d %s", length+data, plurality(length+data, "element", "elements"));
- parameterTree_list = proto_item_add_subtree(parameterTree, ett_sml_parameterTree);
+ parameterTree_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_parameterTree, ¶meterTree,
+ "parameterTree with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, parameterTree, &ei_sml_invalid_count, "invalid count of elements in parameterTree");
/*Treepath List*/
get_length(tvb, offset, &data, &length);
repeat = (data+length);
- treepath = proto_tree_add_text (messagebodytree_list, tvb, *offset, -1, "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
- treepath_list = proto_item_add_subtree(treepath, ett_sml_treepath);
+ treepath_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_treepath, &treepath,
+ "parameterTreePath with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, treepath, &ei_sml_invalid_count, "invalid count of elements in ParameterTreePath");
/*parameterTree*/
get_length(tvb, offset, &data, &length);
- parameterTree = proto_tree_add_text(messagebodytree_list, tvb, *offset, -1, "parameterTree with %d %s", length+data, plurality(length+data, "element", "elements"));
- parameterTree_list = proto_item_add_subtree(parameterTree, ett_sml_parameterTree);
+ parameterTree_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_parameterTree, ¶meterTree,
+ "parameterTree with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, parameterTree, &ei_sml_invalid_count, "invalid count of elements in parameterTree");
}
static gboolean decode_AttentionRes(tvbuff_t *tvb, packet_info *pinfo, proto_tree *messagebodytree_list, guint *offset){
- proto_item *attentionNo = NULL;
proto_item *attentionMsg = NULL;
proto_item *attentionDetails = NULL;
/*attention NO*/
get_length(tvb, offset, &data, &length);
- attentionNo = proto_tree_add_text (messagebodytree_list, tvb ,*offset, length+data, "attentionNo");
- attentionNo_tree = proto_item_add_subtree (attentionNo, ett_sml_attentionNo);
+ attentionNo_tree = proto_tree_add_subtree(messagebodytree_list, tvb ,*offset, length+data, ett_sml_attentionNo, NULL, "attentionNo");
proto_tree_add_text (attentionNo_tree, tvb, *offset, length, "Length: %d %s", data ,plurality(data, "octet", "octets"));
*offset+=length;
}
else{
get_length(tvb, offset, &data, &length);
- attentionDetails = proto_tree_add_text(messagebodytree_list, tvb, *offset, -1, "attentionDetails with %d %s", length+data, plurality(length+data, "element", "elements"));
- attentionDetails_list = proto_item_add_subtree(attentionDetails, ett_sml_attentionDetails);
+ attentionDetails_list = proto_tree_add_subtree_format(messagebodytree_list, tvb, *offset, -1, ett_sml_attentionDetails, &attentionDetails,
+ "attentionDetails with %d %s", length+data, plurality(length+data, "element", "elements"));
if ((tvb_get_guint8(tvb,*offset) & 0xF0) != LONG_LIST && (tvb_get_guint8(tvb,*offset) & 0xF0) != SHORT_LIST){
expert_add_info_format(pinfo, attentionDetails, &ei_sml_invalid_count, "invalid count of elements in attentionDetails");
/*dissect SML-File*/
static void dissect_sml_file(tvbuff_t *tvb, packet_info *pinfo, gint *offset, proto_tree *sml_tree){
proto_item *file = NULL;
- proto_item *mainlist = NULL;
- proto_item *trans = NULL;
- proto_item *groupNo = NULL;
- proto_item *abortOnError = NULL;
- proto_item *sublist = NULL;
- proto_item *messagebody = NULL;
- proto_item *crc16 = NULL;
- proto_item *messagebodytree = NULL;
- proto_item *msgend = NULL;
+ proto_item *mainlist;
+ proto_item *sublist;
+ proto_item *messagebody;
+ proto_item *crc16;
+ proto_item *messagebodytree;
+ proto_item *msgend;
proto_tree *mainlist_list = NULL;
proto_tree *trans_tree = NULL;
/*List*/
get_length(tvb, offset, &data, &length);
- mainlist = proto_tree_add_text (sml_tree, tvb, *offset, -1, "List with %d %s", length+data, plurality(length+data, "element", "elements"));
+ mainlist_list = proto_tree_add_subtree_format(sml_tree, tvb, *offset, -1, ett_sml_mainlist, &mainlist, "List with %d %s",
+ length+data, plurality(length+data, "element", "elements"));
- mainlist_list = proto_item_add_subtree (mainlist, ett_sml_mainlist);
if (tvb_get_guint8(tvb, *offset) != LIST_6_ELEMENTS) {
expert_add_info_format(pinfo, mainlist, &ei_sml_invalid_count, "invalid count of elements");
return;
/*Transaction ID*/
get_length(tvb, offset, &data, &length);
- trans = proto_tree_add_text (mainlist_list, tvb, *offset, length + data ,"Transaction ID");
- trans_tree = proto_item_add_subtree (trans, ett_sml_trans);
+ trans_tree = proto_tree_add_subtree_format(mainlist_list, tvb, *offset, length + data, ett_sml_trans, NULL, "Transaction ID");
proto_tree_add_text (trans_tree, tvb, *offset, length, "Length: %d %s", data, plurality(data, "octet", "octets"));
*offset+=length;
proto_tree_add_item (trans_tree, hf_sml_transactionId, tvb, *offset, data, ENC_NA);
*offset+=data;
/*Group No*/
- groupNo = proto_tree_add_text (mainlist_list, tvb, *offset, 2, "Group No");
- groupNo_tree = proto_item_add_subtree (groupNo, ett_sml_group);
+ groupNo_tree = proto_tree_add_subtree(mainlist_list, tvb, *offset, 2, ett_sml_group, NULL, "Group No");
proto_tree_add_item (groupNo_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item (groupNo_tree, hf_sml_groupNo, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*abort on Error*/
- abortOnError = proto_tree_add_text (mainlist_list, tvb, *offset, 2, "Abort on Error");
- abortOnError_tree = proto_item_add_subtree (abortOnError ,ett_sml_abort);
+ abortOnError_tree = proto_tree_add_subtree(mainlist_list, tvb, *offset, 2, ett_sml_abort, NULL, "Abort on Error");
proto_tree_add_item(abortOnError_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
proto_tree_add_item(abortOnError_tree, hf_sml_abortOnError, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*Sub List*/
- sublist = proto_tree_add_text (mainlist_list, tvb, *offset, -1, "MessageBody");
- sublist_list = proto_item_add_subtree (sublist, ett_sml_sublist);
+ sublist_list = proto_tree_add_subtree(mainlist_list, tvb, *offset, -1, ett_sml_sublist, &sublist, "MessageBody");
*offset+=1;
/*Zero Cutting Check*/
get_length(tvb, offset, &data, &length);
- messagebody = proto_tree_add_text (sublist_list, tvb, *offset, length + data, "Messagetype");
- messagebody_tree = proto_item_add_subtree (messagebody , ett_sml_mttree);
+ messagebody_tree = proto_tree_add_subtree(sublist_list, tvb, *offset, length + data, ett_sml_mttree, &messagebody, "Messagetype");
proto_tree_add_item (messagebody_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
/*MessageBody List*/
get_length(tvb, offset, &data, &length);
- messagebodytree = proto_tree_add_text (sublist_list, tvb, *offset, -1, "List with %d %s", length+data, plurality(length+data, "element", "elements"));
- messagebodytree_list = proto_item_add_subtree (messagebodytree, ett_sml_mblist);
+ messagebodytree_list = proto_tree_add_subtree_format(sublist_list, tvb, *offset, -1, ett_sml_mblist, &messagebodytree,
+ "List with %d %s", length+data, plurality(length+data, "element", "elements"));
*offset+=length;
switch (messagebody_switch){
/* CRC 16*/
get_length(tvb, offset, &data, &length);
- crc16 = proto_tree_add_text (mainlist_list, tvb, *offset, data + length, "CRC");
- crc16_tree = proto_item_add_subtree (crc16, ett_sml_crc16);
+ crc16_tree = proto_tree_add_subtree(mainlist_list, tvb, *offset, data + length, ett_sml_crc16, &crc16, "CRC");
if(tvb_get_guint8(tvb, *offset) != UNSIGNED8 && tvb_get_guint8(tvb, *offset) != UNSIGNED16){
expert_add_info(pinfo, crc16, &ei_sml_crc_error_length);
proto_tree_add_item (crc16_tree, hf_sml_datatype, tvb, *offset, 1, ENC_NA);
*offset+=1;
- proto_tree_add_item (crc16_tree, hf_sml_crc16, tvb, *offset, data, ENC_BIG_ENDIAN);
+ crc16 = proto_tree_add_item (crc16_tree, hf_sml_crc16, tvb, *offset, data, ENC_BIG_ENDIAN);
*offset+=data;
if (sml_crc_enabled) {
}
if (crc_check == crc_ref) {
- proto_tree_add_text (crc16_tree, tvb, *offset, 0, "[CRC Okay]");
+ proto_item_append_text(crc16, " [CRC Okay]");
}
else {
/*(little to big endian convert) to display in correct order*/
crc_check = ((crc_check >> 8) & 0xFF) + ((crc_check << 8 & 0xFF00));
- proto_tree_add_text (crc16_tree, tvb, *offset, 0, "[CRC Bad 0x%X]", crc_check);
+ proto_item_append_text(crc16, " [CRC Bad 0x%X]", crc_check);
expert_add_info(pinfo, crc16, &ei_sml_crc_error);
}
}
else {
- proto_tree_add_text (crc16_tree, tvb, *offset, 0, "[CRC validation disabled]");
+ proto_item_append_text(crc16, " [CRC validation disabled]");
}
/*Message END*/
*offset+=1;
proto_tree_add_item (msgend_tree, hf_sml_padding, tvb, *offset, 1, ENC_NA);
*offset+=1;
- proto_tree_add_item (msgend_tree, hf_sml_crc16, tvb, *offset, 2, ENC_BIG_ENDIAN);
+ crc16 = proto_tree_add_item (msgend_tree, hf_sml_crc16, tvb, *offset, 2, ENC_BIG_ENDIAN);
*offset+=2;
if (sml_crc_enabled && sml_reassemble){
crc_ref = tvb_get_letohs(tvb, *offset-2);
if (crc_check == crc_ref){
- proto_tree_add_text (msgend_tree, tvb, *offset, 0, "[CRC Okay]");
+ proto_item_append_text(crc16, " [CRC Okay]");
}
else{
/*(little to big endian convert) to display in correct order*/
crc_check = ((crc_check >> 8) & 0xFF) + ((crc_check << 8) & 0xFF00);
- proto_tree_add_text (msgend_tree, tvb, *offset, 0, "[CRC Bad 0x%X]", crc_check);
+ proto_item_append_text(crc16, " [CRC Bad 0x%X]", crc_check);
expert_add_info_format(pinfo, msgend, &ei_sml_crc_error, "CRC error (messages not reassembled ?)");
}
}
else {
- proto_tree_add_text (msgend_tree, tvb, *offset, 0, "[CRC validation disabled]");
+ proto_item_append_text(crc16, " [CRC validation disabled]");
}
available = tvb_reported_length_remaining(tvb, *offset);
const gchar *command_str;
const gchar *command_status_str = NULL;
/* Set up structures needed to add the protocol subtree and manage it */
- proto_item *ti = NULL;
- proto_tree *smpp_tree = NULL;
+ proto_item *ti;
+ proto_tree *smpp_tree;
/*
* Safety: don't even try to dissect the PDU
/*
* Create display subtree for the protocol
*/
- if (tree) {
- ti = proto_tree_add_item (tree, proto_smpp, tvb, 0, tvb_length(tvb), ENC_NA);
- smpp_tree = proto_item_add_subtree (ti, ett_smpp);
- }
+ ti = proto_tree_add_item (tree, proto_smpp, tvb, 0, tvb_length(tvb), ENC_NA);
+ smpp_tree = proto_item_add_subtree (ti, ett_smpp);
/*
* Cycle over the encapsulated PDUs
dissect_optional_14(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *sub_tree, *bf_tree;
- proto_item *sub_item, *bf_item;
+ proto_item *bf_item;
int len, pad, type, bits, offset, num, sublen;
if (!tree)
tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return;
}
- sub_item = proto_tree_add_text(tree, tvb, offset, len,
- "Switching Information Control Vector");
- sub_tree = proto_item_add_subtree(sub_item, ett_sna_nlp_opti_14_si);
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, len,
+ ett_sna_nlp_opti_14_si, NULL, "Switching Information Control Vector");
proto_tree_add_uint(sub_tree, hf_sna_nlp_opti_14_si_len,
tvb, offset, 1, len);
tvb_new_subset_remaining(tvb, offset), pinfo, tree);
return;
}
- sub_item = proto_tree_add_text(tree, tvb, offset, len,
- "Return Route TG Descriptor Control Vector");
- sub_tree = proto_item_add_subtree(sub_item, ett_sna_nlp_opti_14_rr);
+ sub_tree = proto_tree_add_subtree(tree, tvb, offset, len,
+ ett_sna_nlp_opti_14_rr, NULL, "Return Route TG Descriptor Control Vector");
proto_tree_add_uint(sub_tree, hf_sna_nlp_opti_14_rr_len,
tvb, offset, 1, len);
dissect_optional(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_tree *sub_tree;
- proto_item *sub_item;
int offset, type, len;
gint ett;
if(type == 0x14) ett = ett_sna_nlp_opti_14;
if(type == 0x22) ett = ett_sna_nlp_opti_22;
if (tree) {
- sub_item = proto_tree_add_text(tree, tvb,
- offset, len << 2, "%s",
+ sub_tree = proto_tree_add_subtree(tree, tvb,
+ offset, len << 2, ett, NULL,
val_to_str(type, sna_nlp_opti_vals,
"Unknown Segment Type"));
- sub_tree = proto_item_add_subtree(sub_item, ett);
proto_tree_add_uint(sub_tree, hf_sna_nlp_opti_len,
tvb, offset, 1, len);
proto_tree_add_uint(sub_tree, hf_sna_nlp_opti_type,
tvbuff_t *tvb;
gint length, reported_length;
proto_tree *sub_tree;
- proto_item *sub_item;
int len, key;
gint ett;
if (key == 0x0e) ett = ett_sna_control_0e;
if (((key == 0) || (key == 3) || (key == 5)) && hpr)
- sub_item = proto_tree_add_text(tree, tvb, 0, -1, "%s",
+ sub_tree = proto_tree_add_subtree(tree, tvb, 0, -1, ett, NULL,
val_to_str_const(key, sna_control_hpr_vals,
"Unknown Control Vector"));
else
- sub_item = proto_tree_add_text(tree, tvb, 0, -1, "%s",
+ sub_tree = proto_tree_add_subtree(tree, tvb, 0, -1, ett, NULL,
val_to_str_const(key, sna_control_vals,
"Unknown Control Vector"));
- sub_tree = proto_item_add_subtree(sub_item, ett);
if (parse == LT) {
proto_tree_add_uint(sub_tree, hf_sna_control_len,
tvb, 0, 1, len);
{
/* Set up structures needed to add the protocol subtree and manage it
*/
- proto_item *ti, *version_item, *dcomp_item, *pcomp_item;
+ proto_item *ti, *dcomp_item;
proto_tree *sndcp_tree, *version_tree, *dcomp_tree, *pcomp_tree;
guint16 offset = 0, l3_param_len;
guint8 parameter_type, parameter_len;
if (parameter_type == SNDCP_VERSION_PAR_TYPE)
{
guint8 value = tvb_get_guint8(tvb, offset+2);
- version_item = proto_tree_add_text(sndcp_tree, tvb, offset, parameter_len+2,
- "Version (SNDCP version number) - Value %d", value);
+ version_tree = proto_tree_add_subtree_format(sndcp_tree, tvb, offset, parameter_len+2,
+ ett_sndcp_xid_version_field, NULL, "Version (SNDCP version number) - Value %d", value);
- version_tree = proto_item_add_subtree(version_item, ett_sndcp_xid_version_field);
proto_tree_add_uint(version_tree, hf_sndcp_xid_type, tvb, offset,
1, parameter_type);
proto_tree_add_uint(version_tree, hf_sndcp_xid_len, tvb, offset+1,
{
tvbuff_t * dcomp_tvb;
- dcomp_item = proto_tree_add_text(sndcp_tree, tvb, offset, parameter_len+2,
- "Data Compression");
- dcomp_tree = proto_item_add_subtree(dcomp_item, ett_sndcp_comp_field);
+ dcomp_tree = proto_tree_add_subtree(sndcp_tree, tvb, offset, parameter_len+2,
+ ett_sndcp_comp_field, &dcomp_item, "Data Compression");
proto_tree_add_uint(dcomp_tree, hf_sndcp_xid_type, tvb, offset,
1, parameter_type);
proto_tree_add_uint(dcomp_tree, hf_sndcp_xid_len, tvb, offset+1,
{
tvbuff_t * pcomp_tvb;
- pcomp_item = proto_tree_add_text(sndcp_tree, tvb, offset, parameter_len+2,
- "Protocol Control Information Compression");
- pcomp_tree = proto_item_add_subtree(pcomp_item, ett_sndcp_comp_field);
+ pcomp_tree = proto_tree_add_subtree(sndcp_tree, tvb, offset, parameter_len+2,
+ ett_sndcp_comp_field, NULL, "Protocol Control Information Compression");
proto_tree_add_uint(pcomp_tree, hf_sndcp_xid_type, tvb, offset,
1, parameter_type);
proto_tree_add_uint(pcomp_tree, hf_sndcp_xid_len, tvb, offset+1,
gboolean p_bit_set;
algo_parameters_t * algo_pars;
guint8 function_index;
- proto_item *comp_entity_field = NULL;
proto_tree *comp_entity_tree = NULL;
guint16 tvb_len, offset=0 , new_offset, entity_offset;
value_string const * comp_algo_str;
/* Read the length */
len = tvb_get_guint8(tvb, offset+2);
- comp_entity_field = proto_tree_add_text(tree, tvb, offset, len + 3,
- "Entity %d, Algorithm %s",
+ comp_entity_tree = proto_tree_add_subtree_format(tree, tvb, offset, len + 3,
+ ett_sndcp_comp_field, NULL, "Entity %d, Algorithm %s",
entity & 0x1F, val_to_str(algo_id & 0x1F, comp_algo_str,"Undefined Algorithm Identifier:%X"));
- comp_entity_tree = proto_item_add_subtree(comp_entity_field, ett_sndcp_comp_field);
proto_tree_add_uint(comp_entity_tree, hf_sndcp_xid_comp_pbit, tvb, offset, 1, p_bit_set << 7);
proto_tree_add_uint(comp_entity_tree, hf_sndcp_xid_comp_spare_byte1, tvb, offset, 1, entity);
algo_id = pcomp_entity_algo_id[entity];
comp_algo_str = sndcp_xid_pcomp_algo_str;
}
- comp_entity_field = proto_tree_add_text(tree, tvb, offset, len + 2,
- "Entity %d decoded as Algorithm %s",
+ comp_entity_tree = proto_tree_add_subtree_format(tree, tvb, offset, len + 2,
+ ett_sndcp_comp_field, NULL, "Entity %d decoded as Algorithm %s",
entity & 0x1F, val_to_str(algo_id & 0x1F, comp_algo_str,"Undefined Algorithm Identifier:%X"));
- comp_entity_tree = proto_item_add_subtree(comp_entity_field, ett_sndcp_comp_field);
-
proto_tree_add_uint(comp_entity_tree, hf_sndcp_xid_comp_pbit, tvb, offset, 1, p_bit_set << 7);
proto_tree_add_uint(comp_entity_tree, hf_sndcp_xid_comp_spare_byte1, tvb, offset, 1, entity);
proto_tree_add_uint(comp_entity_tree, hf_sndcp_xid_comp_entity, tvb, offset, 1, entity);
/* Set up structures needed to add the protocol subtree and manage it
*/
- proto_item *ti, *address_field_item, *compression_field_item, *npdu_field_item;
- proto_tree *sndcp_tree = NULL, *address_field_tree, *compression_field_tree, *npdu_field_tree;
+ proto_item *ti, *address_field_item;
+ proto_tree *sndcp_tree, *address_field_tree, *compression_field_tree, *npdu_field_tree;
/* Make entries in Protocol column and clear Info column on summary display
*/
/* create display subtree for the protocol
*/
- if (tree) {
- ti = proto_tree_add_item(tree, proto_sndcp, tvb, 0, -1, ENC_NA);
- sndcp_tree = proto_item_add_subtree(ti, ett_sndcp);
- }
+ ti = proto_tree_add_item(tree, proto_sndcp, tvb, 0, -1, ENC_NA);
+ sndcp_tree = proto_item_add_subtree(ti, ett_sndcp);
/* get address field from next byte
*/
if (tree) {
if (!pcomp) {
if (!dcomp) {
- compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "No compression");
+ compression_field_tree = proto_tree_add_subtree(sndcp_tree, tvb, offset, 1, ett_sndcp_compression_field, NULL, "No compression");
}
else {
- compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Data compression");
+ compression_field_tree = proto_tree_add_subtree(sndcp_tree, tvb, offset, 1, ett_sndcp_compression_field, NULL, "Data compression");
}
}
else {
if (!dcomp) {
- compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Protocol compression");
+ compression_field_tree = proto_tree_add_subtree(sndcp_tree, tvb, offset, 1, ett_sndcp_compression_field, NULL, "Protocol compression");
}
else {
- compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Data and Protocol compression");
+ compression_field_tree = proto_tree_add_subtree(sndcp_tree, tvb, offset, 1, ett_sndcp_compression_field, NULL, "Data and Protocol compression");
}
}
- compression_field_tree = proto_item_add_subtree(compression_field_item, ett_sndcp_compression_field);
proto_tree_add_uint(compression_field_tree, hf_sndcp_dcomp, tvb, offset, 1, comp_field );
proto_tree_add_uint(compression_field_tree, hf_sndcp_pcomp, tvb, offset, 1, comp_field );
}
npdu = npdu_field1 = tvb_get_guint8(tvb,offset);
col_add_fstr(pinfo->cinfo, COL_INFO, "SN-DATA N-PDU %d", npdu_field1);
if (tree) {
- npdu_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Acknowledged mode, N-PDU %d", npdu_field1 );
- npdu_field_tree = proto_item_add_subtree(npdu_field_item, ett_sndcp_npdu_field);
+ npdu_field_tree = proto_tree_add_subtree_format(sndcp_tree, tvb, offset, 1, ett_sndcp_npdu_field, NULL, "Acknowledged mode, N-PDU %d", npdu_field1 );
proto_tree_add_uint(npdu_field_tree, hf_sndcp_npdu1, tvb, offset, 1, npdu_field1 );
}
offset++;
npdu = (npdu_field2 & 0x0FFF);
col_add_fstr(pinfo->cinfo, COL_INFO, "SN-UNITDATA N-PDU %d (segment %d)", npdu, segment);
if (tree) {
- npdu_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,2, "Unacknowledged mode, N-PDU %d (segment %d)", npdu, segment );
- npdu_field_tree = proto_item_add_subtree(npdu_field_item, ett_sndcp_npdu_field);
+ npdu_field_tree = proto_tree_add_subtree_format(sndcp_tree, tvb, offset, 2, ett_sndcp_npdu_field, NULL,
+ "Unacknowledged mode, N-PDU %d (segment %d)", npdu, segment );
proto_tree_add_uint(npdu_field_tree, hf_sndcp_segment, tvb, offset, 2, npdu_field2 );
proto_tree_add_uint(npdu_field_tree, hf_sndcp_npdu2, tvb, offset, 2, npdu_field2 );
}
proto_item *ti;
guint8 num_auth_methods, auth;
- ti = proto_tree_add_text( tree, tvb, offset, -1, "Client Authentication Methods");
- AuthTree = proto_item_add_subtree(ti, ett_socks_auth);
+ AuthTree = proto_tree_add_subtree( tree, tvb, offset, -1, ett_socks_auth, &ti, "Client Authentication Methods");
num_auth_methods = tvb_get_guint8(tvb, offset);
proto_item_set_len(ti, num_auth_methods+1);
/*
* Add the encoded entity to the protocol tree
*/
- e_ti = proto_tree_add_text(spdy_tree, data_tvb,
- 0, tvb_reported_length(data_tvb),
+ e_tree = proto_tree_add_subtree_format(spdy_tree, data_tvb,
+ 0, tvb_reported_length(data_tvb), ett_spdy_encoded_entity, &e_ti,
"Content-encoded entity body (%s): %u bytes",
si->content_encoding,
tvb_reported_length(data_tvb));
- e_tree = proto_item_add_subtree(e_ti, ett_spdy_encoded_entity);
if (si->num_data_frames > 1) {
wmem_list_t *dflist = si->data_frames;
wmem_list_frame_t *frame_item;
static guint32
dissect_SpiceHead(tvbuff_t *tvb, proto_tree *tree, guint32 offset, const guint16 num)
{
- proto_item *ti;
proto_tree *SpiceHead_tree;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_SpiceHead, "Display Head #%u", num);
- SpiceHead_tree = proto_item_add_subtree(ti, ett_SpiceHead);
+ SpiceHead_tree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof_SpiceHead,
+ ett_SpiceHead, NULL, "Display Head #%u", num);
proto_tree_add_item(SpiceHead_tree, hf_display_head_id, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
proto_tree_add_item(SpiceHead_tree, hf_display_head_surface_id, tvb, offset, 4, ENC_LITTLE_ENDIAN);
static guint32
dissect_AgentMonitorConfig(tvbuff_t *tvb, proto_tree *tree, guint32 offset, const guint16 num)
{
- proto_item *ti;
proto_tree *subtree;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_AgentMonitorConfig, "Monitor Config #%u", num);
- subtree = proto_item_add_subtree(ti, ett_SpiceHead);
+ subtree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof_AgentMonitorConfig,
+ ett_SpiceHead, NULL, "Monitor Config #%u", num);
proto_tree_add_item(subtree, hf_agent_monitor_height, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
proto_tree_add_item(subtree, hf_agent_monitor_width, tvb, offset, 4, ENC_LITTLE_ENDIAN);
guint32 PixmapSize;
guint32 strides, height, pallete_ptr;
- ti = proto_tree_add_text(tree, tvb, offset, 0, "Pixmap"); /* size is fixed later */
- Pixmap_tree = proto_item_add_subtree(ti, ett_Pixmap);
+ Pixmap_tree = proto_tree_add_subtree(tree, tvb, offset, 0, ett_Pixmap, &ti, "Pixmap"); /* size is fixed later */
proto_tree_add_item(Pixmap_tree, hf_pixmap_format, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
proto_tree_add_item(Pixmap_tree, hf_pixmap_flags, tvb, offset, 1, ENC_LITTLE_ENDIAN);
*height = tvb_get_letohs(tvb, offset + 8 + 1 + 2);
if (tree) {
- proto_item *ti;
proto_tree *CursorHeader_tree;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_CursorHeader, "Cursor Header");
- CursorHeader_tree = proto_item_add_subtree(ti, ett_cursor_header);
+ CursorHeader_tree = proto_tree_add_subtree(tree, tvb, offset, sizeof_CursorHeader, ett_cursor_header, NULL, "Cursor Header");
proto_tree_add_item(CursorHeader_tree, hf_cursor_unique, tvb, offset, 8, ENC_LITTLE_ENDIAN);
offset += 8;
proto_tree_add_item(CursorHeader_tree, hf_cursor_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
static guint32
dissect_RedCursor(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti;
+ proto_item *ti;
proto_tree *RedCursor_tree;
guint8 type;
guint16 height, width;
const guint16 flags = tvb_get_letohs(tvb, offset);
guint32 data_size = 0;
- ti = proto_tree_add_text(tree, tvb, offset, 2, "RedCursor"); /* FIXME - fix size if flag is not NONE */
- RedCursor_tree = proto_item_add_subtree(ti, ett_RedCursor);
+ RedCursor_tree = proto_tree_add_subtree(tree, tvb, offset, 2, ett_RedCursor, &ti, "RedCursor"); /* FIXME - fix size if flag is not NONE */
proto_tree_add_item(RedCursor_tree, hf_cursor_flags, tvb, offset, 2, ENC_LITTLE_ENDIAN);
if (flags == SPICE_CURSOR_FLAGS_NONE) {
const guint8 type = tvb_get_guint8(tvb, offset + 8);
if (tree) {
- proto_item *ti;
proto_tree *ImageDescriptor_tree;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_ImageDescriptor, "Image Descriptor");
- ImageDescriptor_tree = proto_item_add_subtree(ti, ett_imagedesc);
+ ImageDescriptor_tree = proto_tree_add_subtree(tree, tvb, offset, sizeof_ImageDescriptor, ett_imagedesc, NULL, "Image Descriptor");
proto_tree_add_item(ImageDescriptor_tree, hf_image_desc_id, tvb, offset, 8, ENC_LITTLE_ENDIAN);
offset += 8;
const guint32 QuicSize = tvb_get_letohl(tvb, offset);
if (tree) {
- proto_item *ti;
proto_tree *ImageQuic_tree;
- ti = proto_tree_add_text(tree, tvb, offset, QuicSize + 4, "QUIC Image");
- ImageQuic_tree = proto_item_add_subtree(ti, ett_imageQuic);
+ ImageQuic_tree = proto_tree_add_subtree(tree, tvb, offset, QuicSize + 4, ett_imageQuic, NULL, "QUIC Image");
proto_tree_add_text(ImageQuic_tree, tvb, offset, 4, "QUIC image size: %u bytes", QuicSize);
offset += 4;
static guint32
dissect_ImageLZ_JPEG(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti;
proto_tree *LZ_JPEG_tree;
const guint32 LZ_JPEGSize = tvb_get_letohl(tvb, offset);
- ti = proto_tree_add_text(tree, tvb, offset, LZ_JPEGSize + 4, "LZ_JPEG Image");
- LZ_JPEG_tree = proto_item_add_subtree(ti, ett_LZ_JPEG);
+ LZ_JPEG_tree = proto_tree_add_subtree(tree, tvb, offset, LZ_JPEGSize + 4, ett_LZ_JPEG, NULL, "LZ_JPEG Image");
proto_tree_add_text(LZ_JPEG_tree, tvb, offset, 4, "LZ JPEG image size: %u bytes", LZ_JPEGSize);
offset += 4;
offset += dissect_ImageLZ_common_header(tvb, LZ_JPEG_tree, offset);
static guint32
dissect_ImageGLZ_RGB(tvbuff_t *tvb, proto_tree *tree, guint32 offset, const guint32 size)
{
- proto_item *ti = NULL;
proto_tree *GLZ_RGB_tree;
guint32 GLZ_RGBSize;
if (size == 0) { /* if no size was passed to us, need to fetch it. Otherwise, we already have it from the callee */
GLZ_RGBSize = tvb_get_letohl(tvb, offset);
- ti = proto_tree_add_text(tree, tvb, offset, GLZ_RGBSize + 4, "GLZ_RGB Image");
- GLZ_RGB_tree = proto_item_add_subtree(ti, ett_GLZ_RGB);
+ GLZ_RGB_tree = proto_tree_add_subtree(tree, tvb, offset, GLZ_RGBSize + 4, ett_GLZ_RGB, NULL, "GLZ_RGB Image");
proto_tree_add_text(GLZ_RGB_tree, tvb, offset, 4, "GLZ RGB image size: %u bytes", GLZ_RGBSize);
offset += 4;
} else {
GLZ_RGBSize = size;
- ti = proto_tree_add_text(tree, tvb, offset, GLZ_RGBSize, "GLZ_RGB Image");
- GLZ_RGB_tree = proto_item_add_subtree(ti, ett_GLZ_RGB);
+ GLZ_RGB_tree = proto_tree_add_subtree(tree, tvb, offset, GLZ_RGBSize, ett_GLZ_RGB, NULL, "GLZ_RGB Image");
}
dissect_ImageLZ_common(tvb, GLZ_RGB_tree, offset, FALSE, GLZ_RGBSize);
static guint32
dissect_ImageLZ_RGB(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti;
proto_tree *LZ_RGB_tree;
const guint32 LZ_RGBSize = tvb_get_letohl(tvb, offset);
- ti = proto_tree_add_text(tree, tvb, offset, LZ_RGBSize + 4, "LZ_RGB Image");
- LZ_RGB_tree = proto_item_add_subtree(ti, ett_LZ_RGB);
+ LZ_RGB_tree = proto_tree_add_subtree(tree, tvb, offset, LZ_RGBSize + 4, ett_LZ_RGB, NULL, "LZ_RGB Image");
proto_tree_add_text(LZ_RGB_tree, tvb, offset, 4, "LZ RGB image size: %u bytes", LZ_RGBSize);
offset += 4;
static guint32
dissect_ImageLZ_PLT(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti;
proto_tree *LZ_PLT_tree;
guint32 LZ_PLTSize, pal_size;
const guint32 current_offset = offset;
LZ_PLTSize = tvb_get_letohl(tvb, offset + 1); /* for some reason, it reports two extra bytes */
- ti = proto_tree_add_text(tree, tvb, offset, (LZ_PLTSize - 2)+ 1 + 4 + 4 + 8 + 4 + 4 + 4 + 4 + 4, "LZ_PLT Image");
- LZ_PLT_tree = proto_item_add_subtree(ti, ett_LZ_PLT);
+ LZ_PLT_tree = proto_tree_add_subtree(tree, tvb, offset, (LZ_PLTSize - 2)+ 1 + 4 + 4 + 8 + 4 + 4 + 4 + 4 + 4, ett_LZ_PLT, NULL, "LZ_PLT Image");
proto_tree_add_text(LZ_PLT_tree, tvb, offset, 1, "LZ_PLT Flag"); /* TODO: dissect */
offset += 1;
static guint32
dissect_ImageJPEG_Alpha(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, guint32 offset)
{
- proto_item *ti;
proto_tree *JPEG_tree;
tvbuff_t *jpeg_tvb;
guint32 JPEG_Size, Data_Size;
Data_Size = tvb_get_letohl(tvb, offset);
offset += 4;
- ti = proto_tree_add_text(tree, tvb, offset - 9, Data_Size + 9, "RGB JPEG Image, Alpha channel (%u bytes)", Data_Size);
- JPEG_tree = proto_item_add_subtree(ti, ett_JPEG);
+ JPEG_tree = proto_tree_add_subtree_format(tree, tvb, offset - 9, Data_Size + 9,
+ ett_JPEG, NULL, "RGB JPEG Image, Alpha channel (%u bytes)", Data_Size);
jpeg_tvb = tvb_new_subset_length(tvb, offset, JPEG_Size);
call_dissector(jpeg_handle, jpeg_tvb, pinfo, JPEG_tree);
static guint32
dissect_ImageJPEG(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, const guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *JPEG_tree;
tvbuff_t *jpeg_tvb;
const guint32 JPEG_Size = tvb_get_letohl(tvb, offset);
- ti = proto_tree_add_text(tree, tvb, offset, JPEG_Size + 4, "JPEG Image (%u bytes)", JPEG_Size);
- JPEG_tree = proto_item_add_subtree(ti, ett_JPEG);
+ JPEG_tree = proto_tree_add_subtree_format(tree, tvb, offset, JPEG_Size + 4, ett_JPEG, NULL, "JPEG Image (%u bytes)", JPEG_Size);
jpeg_tvb = tvb_new_subset_length(tvb, offset + 4, JPEG_Size);
call_dissector(jpeg_handle, jpeg_tvb, pinfo, JPEG_tree);
proto_tree *Uncomp_tree;
tvbuff_t *uncompressed_tvb;
- ti = proto_tree_add_text(ZLIB_GLZ_tree, tvb, offset, ZLIB_GLZSize, "ZLIB stream (%u bytes)", ZLIB_GLZSize);
+ Uncomp_tree = proto_tree_add_subtree_format(ZLIB_GLZ_tree, tvb, offset, ZLIB_GLZSize, ett_Uncomp_tree, &ti, "ZLIB stream (%u bytes)", ZLIB_GLZSize);
uncompressed_tvb = tvb_child_uncompress(tvb, tvb, offset, ZLIB_GLZSize);
if (uncompressed_tvb != NULL) {
add_new_data_source(pinfo, uncompressed_tvb, "Uncompressed GLZ stream");
- Uncomp_tree = proto_item_add_subtree(ti, ett_Uncomp_tree);
dissect_ImageGLZ_RGB(uncompressed_tvb, Uncomp_tree, 0, ZLIB_uncompSize);
} else {
expert_add_info(pinfo, ti, &ei_spice_decompress_error);
static guint32
dissect_ImageZLIB_GLZ(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, guint32 offset)
{
- proto_item *ti = NULL;
+ proto_item *ti;
proto_tree *ZLIB_GLZ_tree;
guint32 ZLIB_GLZSize, ZLIB_uncompSize;
ZLIB_uncompSize = tvb_get_letohl(tvb, offset);
ZLIB_GLZSize = tvb_get_letohl(tvb, offset + 4); /* compressed size */
if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, ZLIB_GLZSize + 8, "ZLIB over GLZ Image");
- ZLIB_GLZ_tree = proto_item_add_subtree(ti, ett_ZLIB_GLZ);
+ ZLIB_GLZ_tree = proto_tree_add_subtree(tree, tvb, offset, ZLIB_GLZSize + 8, ett_ZLIB_GLZ, NULL, "ZLIB over GLZ Image");
ti = proto_tree_add_item(ZLIB_GLZ_tree, hf_zlib_uncompress_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);
proto_item_append_text(ti, " bytes");
static SpiceRect
dissect_SpiceRect(tvbuff_t *tvb, proto_tree *tree, const guint32 offset, const gint32 id)
{
- proto_item *ti = NULL;
proto_tree *rect_tree;
SpiceRect rect;
if (tree) {
if (id != -1) {
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_SpiceRect,
+ rect_tree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof_SpiceRect, ett_rect, NULL,
"RECT %u: (%u-%u, %u-%u)", id, rect.left, rect.top, rect.right, rect.bottom);
} else { /* single rectangle */
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_SpiceRect,
+ rect_tree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof_SpiceRect, ett_rect, NULL,
"RECT: (%u-%u, %u-%u)", rect.left, rect.top, rect.right, rect.bottom);
}
- rect_tree = proto_item_add_subtree(ti, ett_rect);
proto_tree_add_item(rect_tree, hf_rect_left, tvb, offset, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(rect_tree, hf_rect_top, tvb, offset + 4, 4, ENC_LITTLE_ENDIAN);
static guint32
dissect_RectList(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *rectlist_tree;
guint32 i;
const guint32 rectlist_size = tvb_get_letohl(tvb, offset);
if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, 4 + (rectlist_size * sizeof_SpiceRect),
- "RectList (%d rects)", rectlist_size);
- rectlist_tree = proto_item_add_subtree(ti, ett_rectlist);
+ rectlist_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 + (rectlist_size * sizeof_SpiceRect),
+ ett_rectlist, NULL, "RectList (%d rects)", rectlist_size);
proto_tree_add_item(rectlist_tree, hf_rectlist_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
static guint8
dissect_Clip(tvbuff_t *tvb, proto_tree *tree, const guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *Clip_tree;
const guint8 type = tvb_get_guint8(tvb, offset);
if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, 1, "SpiceClip");
- Clip_tree = proto_item_add_subtree(ti, ett_Clip);
+ Clip_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_Clip, NULL, "SpiceClip");
proto_tree_add_item(Clip_tree, hf_Clip_type, tvb, offset, sizeof_Clip, ENC_LITTLE_ENDIAN);
}
static point32_t
dissect_POINT32(tvbuff_t *tvb, proto_tree *tree, const guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *point_tree;
point32_t point;
point.y = tvb_get_letohl(tvb, offset + 4);
if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, sizeof(point32_t), "POINT (%u, %u)", point.x, point.y);
- point_tree = proto_item_add_subtree(ti, ett_point);
+ point_tree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof(point32_t), ett_point, NULL, "POINT (%u, %u)", point.x, point.y);
proto_tree_add_item(point_tree, hf_point32_x, tvb, offset, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(point_tree, hf_point32_y, tvb, offset + 4, 4, ENC_LITTLE_ENDIAN);
static point16_t
dissect_POINT16(tvbuff_t *tvb, proto_tree *tree, const guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *point16_tree;
point16_t point16;
point16.y = tvb_get_letohs(tvb, offset + 2);
if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, sizeof(point16_t), "POINT16 (%u, %u)", point16.x, point16.y);
- point16_tree = proto_item_add_subtree(ti, ett_point16);
+ point16_tree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof(point16_t), ett_point16, NULL, "POINT16 (%u, %u)", point16.x, point16.y);
proto_tree_add_item(point16_tree, hf_point16_x, tvb, offset, 2, ENC_LITTLE_ENDIAN);
proto_tree_add_item(point16_tree, hf_point16_y, tvb, offset + 2, 2, ENC_LITTLE_ENDIAN);
static guint32
dissect_Mask(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti = NULL;
+ proto_item *ti;
proto_tree *Mask_tree;
guint32 bitmap;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_Mask, "Mask");
- Mask_tree = proto_item_add_subtree(ti, ett_Mask);
+ Mask_tree = proto_tree_add_subtree(tree, tvb, offset, sizeof_Mask, ett_Mask, &ti, "Mask");
bitmap = tvb_get_letohl(tvb, offset + (int)sizeof(point32_t) + 1);
if (bitmap != 0) {
static guint32
dissect_Brush(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *brush_tree;
const guint8 type = tvb_get_guint8(tvb, offset);
switch (type) {
case SPICE_BRUSH_TYPE_SOLID:
- ti = proto_tree_add_text(tree, tvb, offset, 5, "Brush - SOLID");
- brush_tree = proto_item_add_subtree(ti, ett_brush);
+ brush_tree = proto_tree_add_subtree(tree, tvb, offset, 5, ett_brush, NULL, "Brush - SOLID");
proto_tree_add_item(brush_tree, hf_brush_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
proto_tree_add_item(brush_tree, hf_brush_rgb, tvb, offset, 4, ENC_LITTLE_ENDIAN);
return 5;
break;
case SPICE_BRUSH_TYPE_PATTERN:
- ti = proto_tree_add_text(tree, tvb, offset, 17, "Brush - PATTERN");
- brush_tree = proto_item_add_subtree(ti, ett_brush);
+ brush_tree = proto_tree_add_subtree(tree, tvb, offset, 17, ett_brush, NULL, "Brush - PATTERN");
proto_tree_add_item(brush_tree, hf_brush_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
/* FIXME: this is supposed to be the offset to the image to be used as the pattern. */
static guint32
dissect_DisplayBase(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti = NULL;
+ proto_item *ti;
proto_tree *DisplayBase_tree;
SpiceRect rect;
guint8 clip_type;
guint32 clip_size = 0;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_DisplayBase, "SpiceMsgDisplayBase");
- DisplayBase_tree = proto_item_add_subtree(ti, ett_DisplayBase);
+ DisplayBase_tree = proto_tree_add_subtree(tree, tvb, offset, sizeof_DisplayBase, ett_DisplayBase, &ti, "SpiceMsgDisplayBase");
proto_tree_add_item(DisplayBase_tree, hf_display_surface_id, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
rect = dissect_SpiceRect(tvb, DisplayBase_tree, offset, -1);
static guint32
dissect_SpiceResourceId(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint16 count)
{
- proto_item *ti;
proto_tree *resource_tree;
- ti = proto_tree_add_text(tree, tvb, offset, sizeof_ResourceId, "Resource #%d", count);
- resource_tree = proto_item_add_subtree(ti, ett_cursor_header);
+ resource_tree = proto_tree_add_subtree_format(tree, tvb, offset, sizeof_ResourceId,
+ ett_cursor_header, NULL, "Resource #%d", count);
proto_tree_add_item(resource_tree, hf_resource_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
proto_tree_add_item(resource_tree, hf_resource_id, tvb, offset, 8, ENC_LITTLE_ENDIAN);
dissect_spice_mini_data_header(tvbuff_t *tvb, proto_tree *tree, const spice_conversation_t *spice_info,
const gboolean client_message, const guint16 message_type, guint32 offset)
{
- proto_item* ti;
proto_tree* subtree;
if (tree) {
- ti = proto_tree_add_text(tree, tvb, offset, 2, "Message type: %s (%d)", get_message_type_string(message_type, spice_info, client_message), message_type);
- subtree = proto_item_add_subtree(ti, ett_common_client_message);
+ subtree = proto_tree_add_subtree_format(tree, tvb, offset, 2, ett_common_client_message, NULL,
+ "Message type: %s (%d)", get_message_type_string(message_type, spice_info, client_message), message_type);
proto_tree_add_item(subtree, hf_message_type, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
proto_tree_add_item(tree, hf_data_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);
dissect_spice_data_header(tvbuff_t *tvb, proto_tree *tree, const spice_conversation_t *spice_info,
const gboolean client_message, const guint16 message_type, guint32 *sublist_size, guint32 offset)
{
- proto_item* ti;
proto_tree* subtree;
*sublist_size = tvb_get_letohl(tvb, offset + 14);
if (tree) {
proto_tree_add_item(tree, hf_serial, tvb, offset, 8, ENC_LITTLE_ENDIAN);
offset += 8;
- ti = proto_tree_add_text(tree, tvb, offset, 2, "Message type: %s (%d)", get_message_type_string(message_type, spice_info, client_message), message_type);
- subtree = proto_item_add_subtree(ti, ett_common_client_message);
+ subtree = proto_tree_add_subtree_format(tree, tvb, offset, 2, ett_common_client_message, NULL,
+ "Message type: %s (%d)", get_message_type_string(message_type, spice_info, client_message), message_type);
proto_tree_add_item(subtree, hf_message_type, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
offset += 2;
static guint32
dissect_spice_record_client(tvbuff_t *tvb, proto_tree *tree, const guint16 message_type, guint32 offset)
{
- proto_item *ti;
proto_tree *record_tree;
switch (message_type) {
case SPICE_MSGC_RECORD_MODE:
- ti = proto_tree_add_text(tree, tvb, offset, 8, "Client RECORD_MODE message"); /* size is incorrect, fixed later */
- record_tree = proto_item_add_subtree(ti, ett_record_client);
+ record_tree = proto_tree_add_subtree(tree, tvb, offset, 8, ett_record_client, NULL, "Client RECORD_MODE message"); /* size is incorrect, fixed later */
proto_tree_add_item(record_tree, hf_audio_timestamp, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
proto_tree_add_item(record_tree, hf_audio_mode, tvb, offset, 2, ENC_LITTLE_ENDIAN);
dissect_spice_playback_server(tvbuff_t *tvb, proto_tree *tree, const guint16 message_type, guint32 message_size, spice_conversation_t *spice_info, guint32 offset)
{
guint8 num_channels, i;
- proto_item* ti;
proto_tree* subtree;
switch (message_type) {
num_channels = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_audio_channels, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
- ti = proto_tree_add_text(tree, tvb, offset, 2 * num_channels, "Channel volume array");
- subtree = proto_item_add_subtree(ti, ett_record_server);
+ subtree = proto_tree_add_subtree(tree, tvb, offset, 2 * num_channels, ett_record_server, NULL, "Channel volume array");
for (i = 0; i < num_channels; i++) {
proto_tree_add_item(subtree, hf_audio_volume, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
dissect_spice_record_server(tvbuff_t *tvb, proto_tree *tree, const guint16 message_type, guint32 offset)
{
guint8 num_channels, i;
- proto_item* ti;
proto_tree* subtree;
switch (message_type) {
num_channels = tvb_get_guint8(tvb, offset);
proto_tree_add_item(tree, hf_audio_channels, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
- ti = proto_tree_add_text(tree, tvb, offset, 2 * num_channels, "Volume Array");
- subtree = proto_item_add_subtree(ti, ett_record_server);
+ subtree = proto_tree_add_subtree(tree, tvb, offset, 2 * num_channels, ett_record_server, NULL, "Volume Array");
for (i = 0; i < num_channels; i++) {
proto_tree_add_item(subtree, hf_audio_volume, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
static guint32
dissect_spice_agent_message(tvbuff_t *tvb, proto_tree *tree, const guint32 message_type, guint32 message_len, guint32 offset)
{
- proto_item *ti=NULL;
proto_tree *agent_tree;
guint32 n_monitors = 0, i;
offset += 4;
break;
case VD_AGENT_CLIPBOARD_GRAB:
- ti = proto_tree_add_text(tree, tvb, offset, 4, "VD_AGENT_CLIPBOARD_GRAB message");
- agent_tree = proto_item_add_subtree(ti, ett_spice_agent);
+ agent_tree = proto_tree_add_subtree(tree, tvb, offset, 4, ett_spice_agent, NULL, "VD_AGENT_CLIPBOARD_GRAB message");
proto_tree_add_item(agent_tree, hf_agent_clipboard_selection, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
proto_tree_add_text(agent_tree, tvb, offset, 3, "reserved");
offset += 3;
break;
case VD_AGENT_CLIPBOARD_REQUEST:
- ti = proto_tree_add_text(tree, tvb, offset, 8, "VD_AGENT_CLIPBOARD_REQUEST message");
- agent_tree = proto_item_add_subtree(ti, ett_spice_agent);
+ agent_tree = proto_tree_add_subtree(tree, tvb, offset, 8, ett_spice_agent, NULL, "VD_AGENT_CLIPBOARD_REQUEST message");
proto_tree_add_item(agent_tree, hf_agent_clipboard_selection, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
proto_tree_add_text(agent_tree, tvb, offset, 3, "reserved");
{
guint32 num_channels, i, agent_msg_type, agent_msg_len, name_len, data_size;
proto_tree *subtree = NULL;
- proto_item *ti = NULL;
switch (message_type) {
case SPICE_MSG_MAIN_MIGRATE_BEGIN:
num_channels = tvb_get_letohl(tvb, offset);
proto_tree_add_item(tree, hf_main_num_channels, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
- ti = proto_tree_add_text(tree, tvb, offset, 2 * num_channels, "Channel Array");
- subtree = proto_item_add_subtree(ti, ett_main_client);
+ subtree = proto_tree_add_subtree(tree, tvb, offset, 2 * num_channels, ett_main_client, NULL, "Channel Array");
for (i = 0; i < num_channels; i++ ) {
- proto_tree *subsubtree = NULL;
+ proto_tree *subsubtree;
- ti = proto_tree_add_text(subtree, tvb, offset, 2, "channels[%u]", i);
- subsubtree = proto_item_add_subtree(ti, ett_main_client);
+ subsubtree = proto_tree_add_subtree_format(subtree, tvb, offset, 2, ett_main_client, NULL, "channels[%u]", i);
proto_tree_add_item(subsubtree, hf_channel_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
static guint32
dissect_spice_main_client(tvbuff_t *tvb, proto_tree *tree, const guint16 message_type, guint32 offset)
{
- proto_item *ti = NULL;
proto_tree *main_tree;
guint32 agent_msg_type, agent_msg_len;
case SPICE_MSGC_MAIN_ATTACH_CHANNELS:
break;
case SPICE_MSGC_MAIN_AGENT_START:
- ti = proto_tree_add_text(tree, tvb, offset, 4, "Client AGENT_START message");
- main_tree = proto_item_add_subtree(ti, ett_main_client);
+ main_tree = proto_tree_add_subtree(tree, tvb, offset, 4, ett_main_client, NULL, "Client AGENT_START message");
proto_tree_add_item(main_tree, hf_main_client_agent_tokens, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
break;
case SPICE_MSGC_MAIN_AGENT_DATA:
- ti = proto_tree_add_text(tree, tvb, offset, 24, "Client AGENT_DATA message");
- main_tree = proto_item_add_subtree(ti, ett_main_client);
+ main_tree = proto_tree_add_subtree(tree, tvb, offset, 24, ett_main_client, NULL, "Client AGENT_DATA message");
proto_tree_add_item(main_tree, hf_agent_protocol, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
proto_tree_add_item(main_tree, hf_agent_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);
static int
dissect_spice_keyboard_modifiers(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
{
- proto_item *ti = NULL;
- proto_tree *subtree = NULL;
+ proto_item *ti;
+ proto_tree *subtree;
ti = proto_tree_add_item(tree, hf_keyboard_modifiers, tvb, offset, 2, ENC_LITTLE_ENDIAN);
subtree = proto_item_add_subtree(ti, ett_link_caps);
static guint32
dissect_spice_inputs_client(tvbuff_t *tvb, proto_tree *tree, const guint16 message_type, guint32 offset)
{
- proto_item *ti=NULL;
proto_tree *inputs_tree;
switch (message_type) {
case SPICE_MSGC_INPUTS_KEY_DOWN:
- ti = proto_tree_add_text(tree, tvb, offset, 4, "Client KEY_DOWN message");
- inputs_tree = proto_item_add_subtree(ti, ett_inputs_client);
+ inputs_tree = proto_tree_add_subtree(tree, tvb, offset, 4, ett_inputs_client, NULL, "Client KEY_DOWN message");
proto_tree_add_item(inputs_tree, hf_keyboard_code, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
break;
case SPICE_MSGC_INPUTS_KEY_UP:
- ti = proto_tree_add_text(tree, tvb, offset, 4, "Client KEY_UP message");
- inputs_tree = proto_item_add_subtree(ti, ett_inputs_client);
+ inputs_tree = proto_tree_add_subtree(tree, tvb, offset, 4, ett_inputs_client, NULL, "Client KEY_UP message");
proto_tree_add_item(inputs_tree, hf_keyboard_code, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
break;
offset += dissect_spice_keyboard_modifiers(tvb, tree, offset);
break;
case SPICE_MSGC_INPUTS_MOUSE_POSITION:
- ti = proto_tree_add_text(tree, tvb, offset, sizeof(point32_t) + 3, "Client MOUSE_POSITION message");
- inputs_tree = proto_item_add_subtree(ti, ett_inputs_client);
+ inputs_tree = proto_tree_add_subtree(tree, tvb, offset, sizeof(point32_t) + 3, ett_inputs_client, NULL, "Client MOUSE_POSITION message");
dissect_POINT32(tvb, inputs_tree, offset);
offset += (int)sizeof(point32_t);
proto_tree_add_item(inputs_tree, hf_button_state, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 1;
break;
case SPICE_MSGC_INPUTS_MOUSE_MOTION:
- ti = proto_tree_add_text(tree, tvb, offset, sizeof(point32_t) + 4, "Client MOUSE_MOTION message");
- inputs_tree = proto_item_add_subtree(ti, ett_inputs_client);
+ inputs_tree = proto_tree_add_subtree(tree, tvb, offset, sizeof(point32_t) + 4, ett_inputs_client, NULL, "Client MOUSE_MOTION message");
dissect_POINT32(tvb, inputs_tree, offset);
offset += (int)sizeof(point32_t);
proto_tree_add_item(inputs_tree, hf_button_state, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
break;
case SPICE_MSGC_INPUTS_MOUSE_PRESS:
- ti = proto_tree_add_text(tree, tvb, offset, 3, "Client MOUSE_PRESS message");
- inputs_tree = proto_item_add_subtree(ti, ett_inputs_client);
+ inputs_tree = proto_tree_add_subtree(tree, tvb, offset, 3, ett_inputs_client, NULL, "Client MOUSE_PRESS message");
proto_tree_add_item(inputs_tree, hf_button_state, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
proto_tree_add_item(inputs_tree, hf_mouse_display_id, tvb, offset, 1, ENC_NA);
offset += 1;
break;
case SPICE_MSGC_INPUTS_MOUSE_RELEASE:
- ti = proto_tree_add_text(tree, tvb, offset, 3, "Client MOUSE_RELEASE message");
- inputs_tree = proto_item_add_subtree(ti, ett_inputs_client);
+ inputs_tree = proto_tree_add_subtree(tree, tvb, offset, 3, ett_inputs_client, NULL, "Client MOUSE_RELEASE message");
proto_tree_add_item(inputs_tree, hf_button_state, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
proto_tree_add_item(inputs_tree, hf_mouse_display_id, tvb, offset, 1, ENC_NA);
header_size = sizeof_SpiceMiniDataHeader;
message_type = tvb_get_letohs(tvb, offset);
message_size = tvb_get_letohl(tvb, offset +2);
- msg_ti = proto_tree_add_text(tree, tvb, offset, 0,
- "%s (%d bytes)",
+ message_tree = proto_tree_add_subtree_format(tree, tvb, offset, 0,
+ ett_message, &msg_ti, "%s (%d bytes)",
get_message_type_string(message_type, spice_info, FALSE),
message_size + header_size);
- message_tree = proto_item_add_subtree(msg_ti, ett_message);
ti = proto_tree_add_item(message_tree, hf_data, tvb, offset, header_size, ENC_NA);
data_header_tree = proto_item_add_subtree(ti, ett_data);
dissect_spice_mini_data_header(tvb, data_header_tree, spice_info, FALSE, message_type, offset);
header_size = sizeof_SpiceDataHeader;
message_type = tvb_get_letohs(tvb, offset + 8);
message_size = tvb_get_letohl(tvb, offset + 10);
- msg_ti = proto_tree_add_text(tree, tvb, offset, 0,
- "%s (%d bytes)",
+ message_tree = proto_tree_add_subtree_format(tree, tvb, offset, 0,
+ ett_message, &msg_ti, "%s (%d bytes)",
get_message_type_string(message_type, spice_info, FALSE),
message_size + header_size);
- message_tree = proto_item_add_subtree(msg_ti, ett_message);
ti = proto_tree_add_item(message_tree, hf_data, tvb, offset, header_size, ENC_NA);
data_header_tree = proto_item_add_subtree(ti, ett_data);
dissect_spice_data_header(tvb, data_header_tree, spice_info, FALSE, message_type, &sublist_size, offset);
offset += 4;
if (common_caps_len > 0) {
- ti = proto_tree_add_text(tree, tvb, offset, common_caps_len * 4,
- "Client Common Capabilities (%d bytes)",
+ caps_tree = proto_tree_add_subtree_format(tree, tvb, offset, common_caps_len * 4,
+ ett_link_caps, NULL, "Client Common Capabilities (%d bytes)",
common_caps_len * 4); /* caps_len multiplied by 4 as length is in UINT32 units */
- caps_tree = proto_item_add_subtree(ti, ett_link_caps);
dissect_spice_common_capabilities(tvb, caps_tree, offset, common_caps_len, spice_info, TRUE);
offset += (common_caps_len * 4);
}
if (channel_caps_len > 0) {
- ti = proto_tree_add_text(tree, tvb, offset, channel_caps_len * 4,
- "Client Channel-specific Capabilities (%d bytes)",
+ caps_tree = proto_tree_add_subtree_format(tree, tvb, offset, channel_caps_len * 4,
+ ett_link_caps, NULL, "Client Channel-specific Capabilities (%d bytes)",
channel_caps_len * 4); /* caps_len multiplied by 4 as length is in UINT32 units */
- caps_tree = proto_item_add_subtree(ti, ett_link_caps);
dissect_spice_link_capabilities(tvb, caps_tree, offset, channel_caps_len, spice_info);
}
}
offset += (int)sizeof_SpiceLinkHeader + SPICE_TICKET_PUBKEY_BYTES;
if (common_caps_len > 0) {
- ti = proto_tree_add_text(tree, tvb, offset, common_caps_len * 4,
- "Common Capabilities (%d bytes)",
+ caps_tree = proto_tree_add_subtree_format(tree, tvb, offset, common_caps_len * 4,
+ ett_link_caps, NULL, "Common Capabilities (%d bytes)",
common_caps_len * 4); /* caps_len multiplied by 4 as length is in UINT32 units */
- caps_tree = proto_item_add_subtree(ti, ett_link_caps);
dissect_spice_common_capabilities(tvb, caps_tree, offset, common_caps_len, spice_info, FALSE);
offset += (common_caps_len * 4);
}
if (channel_caps_len > 0) {
- ti = proto_tree_add_text(tree, tvb, offset, channel_caps_len * 4,
- "Channel Capabilities (%d bytes)",
+ caps_tree = proto_tree_add_subtree_format(tree, tvb, offset, channel_caps_len * 4,
+ ett_link_caps, NULL, "Channel Capabilities (%d bytes)",
channel_caps_len * 4); /* caps_len multiplied by 4 as length is in UINT32 units */
- caps_tree = proto_item_add_subtree(ti, ett_link_caps);
dissect_spice_link_capabilities(tvb, caps_tree, offset, channel_caps_len, spice_info);
}
}
int i, svc, ss, type_len, foffset=offset;
guint32 prot;
const guint8 *byte_value;
- proto_item *ti;
proto_tree *srvloc_tree;
char *tmp;
i=1;
for (foffset = offset; foffset<length; foffset += 2) {
- ti = proto_tree_add_text(tree, tvb, foffset, -1, "Item %d", i);
- srvloc_tree = proto_item_add_subtree(ti, ett_srvloc_attr);
+ srvloc_tree = proto_tree_add_subtree_format(tree, tvb, foffset, -1, ett_srvloc_attr, NULL, "Item %d", i);
svc = tvb_get_guint8(tvb, foffset+1);
proto_tree_add_text(srvloc_tree, tvb, foffset+1, 1,
i=1;
for (foffset = offset + (type_len); foffset<length; foffset++) {
- ti = proto_tree_add_text(tree, tvb, foffset, -1, "Item %d", i);
- srvloc_tree = proto_item_add_subtree(ti, ett_srvloc_attr);
+ srvloc_tree = proto_tree_add_subtree_format(tree, tvb, foffset, -1, ett_srvloc_attr, NULL, "Item %d", i);
svc = tvb_get_guint8(tvb, foffset+1);
proto_tree_add_text(srvloc_tree, tvb, foffset+1, 1,
static void dissect_stat_list(proto_tree *tree, tvbuff_t *tvb,guint h) {
gint n,i;
- proto_item* pi;
if ((n = (tvb_reported_length(tvb))/4 - h)) {
- pi = proto_tree_add_text(tree,tvb,0,n*4,"SD List");
- tree = proto_item_add_subtree(pi,ett_stat);
+ tree = proto_tree_add_subtree(tree,tvb,0,n*4,ett_stat,NULL,"SD List");
for (i = 0; i < n; i++) {
proto_tree_add_item(tree, hf_sscop_stat_s, tvb, i*4 + 1,3,ENC_BIG_ENDIAN);
int offset, proto_tree *tree, int is_response,
gboolean *need_desegmentation)
{
- proto_item *ti;
proto_item *ssh2_tree=NULL;
struct ssh_peer_data *peer_data = &global_data->peer_data[is_response];
wmem_strbuf_append_printf(title, ")");
}
- ti=proto_tree_add_text(tree, tvb, offset, -1, "%s", wmem_strbuf_get_str(title));
- ssh2_tree = proto_item_add_subtree(ti, ett_ssh2);
+ ssh2_tree=proto_tree_add_subtree(tree, tvb, offset, -1, ett_ssh2, NULL, wmem_strbuf_get_str(title));
}
if ((peer_data->frame_key_start == 0) ||
guint8 msg_code;
guint remain_length;
- proto_item *ti;
- proto_item *ssh1_tree =NULL;
+ proto_item *ssh1_tree;
struct ssh_peer_data *peer_data = &global_data->peer_data[is_response];
- if (tree) {
- ti=proto_tree_add_text(tree, tvb, offset, -1, "SSH Version 1");
- ssh1_tree = proto_item_add_subtree(ti, ett_ssh1);
- }
+ ssh1_tree=proto_tree_add_subtree(tree, tvb, offset, -1, ett_ssh1, NULL, "SSH Version 1");
/*
* We use "tvb_ensure_length_remaining()" to make sure there
int last_offset=offset;
guint msg_code;
- proto_item *tf, *ti;
+ proto_item *ti;
proto_item *key_ex_tree =NULL;
struct ssh_peer_data *peer_data = &global_data->peer_data[is_response];
proto_tree_add_uint(tree, hf_ssh_padding_length, tvb, offset, 1, padding_length);
offset += 1;
- tf=proto_tree_add_text(tree, tvb, offset, -1, "Key Exchange");
- key_ex_tree = proto_item_add_subtree(tf, ett_key_exchange);
+ key_ex_tree=proto_tree_add_subtree(tree, tvb, offset, -1, ett_key_exchange, NULL, "Key Exchange");
/* msg_code */
msg_code = tvb_get_guint8(tvb, offset);
{
int start_offset = offset;
- proto_item *tf = NULL;
- proto_item *key_init_tree=NULL;
+ proto_item *tf;
+ proto_tree *key_init_tree;
struct ssh_peer_data *peer_data = &global_data->peer_data[is_response];
- if (tree) {
- tf=proto_tree_add_text(tree, tvb, offset, -1, "Algorithms");
- key_init_tree = proto_item_add_subtree(tf, ett_key_init);
- proto_tree_add_item(key_init_tree, hf_ssh_cookie,
+ key_init_tree=proto_tree_add_subtree(tree, tvb, offset, -1, ett_key_init, &tf, "Algorithms");
+ proto_tree_add_item(key_init_tree, hf_ssh_cookie,
tvb, offset, 16, ENC_NA);
- }
offset += 16;
offset = ssh_dissect_proposal(tvb, offset, key_init_tree,
{
guint8 npn_length;
proto_tree *npn_tree;
- proto_item *ti;
if (ext_len == 0) {
return offset;
}
- ti = proto_tree_add_text(tree, tvb, offset, ext_len, "Next Protocol Negotiation");
- npn_tree = proto_item_add_subtree(ti, hf->ett.hs_ext_npn);
+ npn_tree = proto_tree_add_subtree(tree, tvb, offset, ext_len, hf->ett.hs_ext_npn, NULL, "Next Protocol Negotiation");
while (ext_len > 0) {
npn_length = tvb_get_guint8(tvb, offset);
{
guint8 reneg_info_length;
proto_tree *reneg_info_tree;
- proto_item *ti;
if (ext_len == 0) {
return offset;
}
- ti = proto_tree_add_text(tree, tvb, offset, ext_len, "Renegotiation Info extension");
- reneg_info_tree = proto_item_add_subtree(ti, hf->ett.hs_ext_reneg_info);
+ reneg_info_tree = proto_tree_add_subtree(tree, tvb, offset, ext_len, hf->ett.hs_ext_reneg_info, NULL, "Renegotiation Info extension");
reneg_info_length = tvb_get_guint8(tvb, offset);
proto_tree_add_item(reneg_info_tree, hf->hf.hs_ext_reneg_info_len,
{
guint16 server_name_length;
proto_tree *server_name_tree;
- proto_item *ti;
if (ext_len == 0) {
return offset;
}
- ti = proto_tree_add_text(tree, tvb, offset, ext_len, "Server Name Indication extension");
- server_name_tree = proto_item_add_subtree(ti, hf->ett.hs_ext_server_name);
+ server_name_tree = proto_tree_add_subtree(tree, tvb, offset, ext_len, hf->ett.hs_ext_server_name, NULL, "Server Name Indication extension");
proto_tree_add_item(server_name_tree, hf->hf.hs_ext_server_name_list_len,
tvb, offset, 2, ENC_BIG_ENDIAN);
guint16 extension_length;
guint16 ext_type;
guint16 ext_len;
- proto_item *pi;
proto_tree *ext_tree;
if (left < 2)
ext_type = tvb_get_ntohs(tvb, offset);
ext_len = tvb_get_ntohs(tvb, offset + 2);
- pi = proto_tree_add_text(tree, tvb, offset, 4 + ext_len, "Extension: %s",
- val_to_str(ext_type,
+ ext_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 + ext_len, hf->ett.hs_ext, NULL,
+ "Extension: %s", val_to_str(ext_type,
tls_hello_extension_types,
"Unknown %u"));
- ext_tree = proto_item_add_subtree(pi, hf->ett.hs_ext);
- if (!ext_tree)
- ext_tree = tree;
proto_tree_add_uint(ext_tree, hf->hf.hs_ext_type,
tvb, offset, 2, ext_type);
guint32 length)
{
gint point_len;
- proto_item *ti_ecdh;
proto_tree *ssl_ecdh_tree;
- ti_ecdh = proto_tree_add_text(tree, tvb, offset, length,
- "EC Diffie-Hellman Client Params");
- ssl_ecdh_tree = proto_item_add_subtree(ti_ecdh, hf->ett.keyex_params);
+ ssl_ecdh_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "EC Diffie-Hellman Client Params");
/* point */
point_len = tvb_get_guint8(tvb, offset);
proto_tree *tree, guint32 offset, guint32 length)
{
gint yc_len;
- proto_item *ti_dh;
proto_tree *ssl_dh_tree;
- ti_dh = proto_tree_add_text(tree, tvb, offset, length,
- "Diffie-Hellman Client Params");
- ssl_dh_tree = proto_item_add_subtree(ti_dh, hf->ett.keyex_params);
+ ssl_dh_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "Diffie-Hellman Client Params");
/* ClientDiffieHellmanPublic.dh_public (explicit) */
yc_len = tvb_get_ntohs(tvb, offset);
guint32 length, const SslSession *session)
{
gint epms_len;
- proto_item *ti_rsa;
proto_tree *ssl_rsa_tree;
- ti_rsa = proto_tree_add_text(tree, tvb, offset, length,
- "RSA Encrypted PreMaster Secret");
- ssl_rsa_tree = proto_item_add_subtree(ti_rsa, hf->ett.keyex_params);
+ ssl_rsa_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "RSA Encrypted PreMaster Secret");
/* EncryptedPreMasterSecret.pre_master_secret */
switch (session->version) {
proto_tree *tree, guint32 offset, guint32 length)
{
guint identity_len;
- proto_item *ti_psk;
proto_tree *ssl_psk_tree;
- ti_psk = proto_tree_add_text(tree, tvb, offset, length,
- "PSK Client Params");
- ssl_psk_tree = proto_item_add_subtree(ti_psk, hf->ett.keyex_params);
-
+ ssl_psk_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "PSK Client Params");
/* identity */
identity_len = tvb_get_ntohs(tvb, offset);
proto_tree_add_item(ssl_psk_tree, hf->hf.hs_client_keyex_identity_len, tvb,
guint32 length)
{
gint identity_len, epms_len;
- proto_item *ti_psk;
proto_tree *ssl_psk_tree;
- ti_psk = proto_tree_add_text(tree, tvb, offset, length,
- "RSA PSK Client Params");
- ssl_psk_tree = proto_item_add_subtree(ti_psk, hf->ett.keyex_params);
+ ssl_psk_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "RSA PSK Client Params");
/* identity */
identity_len = tvb_get_ntohs(tvb, offset);
gint curve_type;
gint point_len;
- proto_item *ti_ecdh;
proto_tree *ssl_ecdh_tree;
- ti_ecdh = proto_tree_add_text(tree, tvb, offset, length,
- "EC Diffie-Hellman Server Params");
- ssl_ecdh_tree = proto_item_add_subtree(ti_ecdh, hf->ett.keyex_params);
+ ssl_ecdh_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "EC Diffie-Hellman Server Params");
/* ECParameters.curve_type */
curve_type = tvb_get_guint8(tvb, offset);
const SslSession *session)
{
gint p_len, g_len, ys_len;
- proto_item *ti_dh;
proto_tree *ssl_dh_tree;
- ti_dh = proto_tree_add_text(tree, tvb, offset, length,
- "Diffie-Hellman Server Params");
- ssl_dh_tree = proto_item_add_subtree(ti_dh, hf->ett.keyex_params);
+ ssl_dh_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "Diffie-Hellman Server Params");
/* p */
p_len = tvb_get_ntohs(tvb, offset);
const SslSession *session)
{
gint modulus_len, exponent_len;
- proto_item *ti_rsa;
proto_tree *ssl_rsa_tree;
- ti_rsa = proto_tree_add_text(tree, tvb, offset, length,
- "RSA-EXPORT Server Params");
- ssl_rsa_tree = proto_item_add_subtree(ti_rsa, hf->ett.keyex_params);
+ ssl_rsa_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "RSA-EXPORT Server Params");
/* modulus */
modulus_len = tvb_get_ntohs(tvb, offset);
proto_tree *tree, guint32 offset, guint32 length)
{
guint hint_len;
- proto_item *ti_psk;
proto_tree *ssl_psk_tree;
hint_len = tvb_get_ntohs(tvb, offset);
return;
}
- ti_psk = proto_tree_add_text(tree, tvb, offset, length,
- "PSK Server Params");
- ssl_psk_tree = proto_item_add_subtree(ti_psk, hf->ett.keyex_params);
+ ssl_psk_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ hf->ett.keyex_params, NULL, "PSK Server Params");
/* hint */
proto_tree_add_item(ssl_psk_tree, hf->hf.hs_server_keyex_hint_len, tvb,
/* show the client's random challenge */
nstime_t gmt_unix_time;
guint8 session_id_length;
- proto_item *ti_rnd;
proto_tree *ssl_rnd_tree;
session_id_length = 0;
if (tree)
{
- ti_rnd = proto_tree_add_text(tree, tvb, offset, 32, "Random");
- ssl_rnd_tree = proto_item_add_subtree(ti_rnd, ett_ssl_random);
+ ssl_rnd_tree = proto_tree_add_subtree(tree, tvb, offset, 32, ett_ssl_random, NULL, "Random");
/* show the time */
gmt_unix_time.secs = tvb_get_ntohl(tvb, offset);
guint32 offset, guint32 length, SslDecryptSession *ssl)
{
guint nst_len;
- proto_item *ti;
proto_tree *subtree;
guint16 session_ticket_length = 0;
return;
}
- ti = proto_tree_add_text(tree, tvb, offset, 6+nst_len, "TLS Session Ticket");
- subtree = proto_item_add_subtree(ti, ett_ssl_new_ses_ticket);
+ subtree = proto_tree_add_subtree(tree, tvb, offset, 6+nst_len, ett_ssl_new_ses_ticket, NULL, "TLS Session Ticket");
proto_tree_add_item(subtree, hf_ssl_handshake_session_ticket_lifetime_hint,
tvb, offset, 4, ENC_BIG_ENDIAN);
dissect_ssl3_hnd_cli_cert_verify(tvbuff_t *tvb, proto_tree *tree,
guint32 offset, guint32 length)
{
- proto_item *ti_sig;
proto_tree *ssl_sig_tree;
/*
*/
- ti_sig = proto_tree_add_text(tree, tvb, offset, length,
- "Signature with client's private key");
- ssl_sig_tree = proto_item_add_subtree(ti_sig, ett_ssl_cli_sig);
+ ssl_sig_tree = proto_tree_add_subtree(tree, tvb, offset, length,
+ ett_ssl_cli_sig, NULL, "Signature with client's private key");
proto_tree_add_item(ssl_sig_tree, hf_ssl_handshake_client_cert_vrfy_sig_len,
tvb, offset, 2, ENC_BIG_ENDIAN);
if(bRequest){
if(tvb_length_remaining(tvb, offset) >= 20){
- ti = proto_tree_add_text(starteamroot_tree, tvb, offset, 20, STARTEAM_TEXT_MDH);
- starteam_tree = proto_item_add_subtree(ti, ett_starteam_mdh);
+ starteam_tree = proto_tree_add_subtree(starteamroot_tree, tvb, offset, 20, ett_starteam_mdh, NULL, STARTEAM_TEXT_MDH);
proto_tree_add_item(starteam_tree, hf_starteam_mdh_session_tag, tvb, offset + 0, 4, ENC_LITTLE_ENDIAN);
proto_tree_add_item(starteam_tree, hf_starteam_mdh_ctimestamp, tvb, offset + 4, 4, ENC_LITTLE_ENDIAN);
}
if(tvb_length_remaining(tvb, offset) >= 16){
- ti = proto_tree_add_text(starteamroot_tree, tvb, offset, 16, STARTEAM_TEXT_PH);
- starteam_tree = proto_item_add_subtree(ti, ett_starteam_ph);
+ starteam_tree = proto_tree_add_subtree(starteamroot_tree, tvb, offset, 16, ett_starteam_ph, NULL, STARTEAM_TEXT_PH);
proto_tree_add_item(starteam_tree, hf_starteam_ph_signature, tvb, offset + 0, 4, ENC_ASCII|ENC_NA);
proto_tree_add_item(starteam_tree, hf_starteam_ph_packet_size, tvb, offset + 4, 4, ENC_LITTLE_ENDIAN);
if(bRequest){
if(tvb_length_remaining(tvb, offset) >= 38){
- ti = proto_tree_add_text(starteamroot_tree, tvb, offset, 38, STARTEAM_TEXT_ID);
- starteam_tree = proto_item_add_subtree(ti, ett_starteam_id);
+ starteam_tree = proto_tree_add_subtree(starteamroot_tree, tvb, offset, 38, ett_starteam_id, NULL, STARTEAM_TEXT_ID);
proto_tree_add_item(starteam_tree, hf_starteam_id_revision_level, tvb, offset + 0, 2, ENC_LITTLE_ENDIAN);
proto_tree_add_item(starteam_tree, hf_starteam_id_client, tvb, offset + 2, 16, ENC_ASCII|ENC_NA);
}
}
if(tvb_length_remaining(tvb, offset) > 0){
- ti = proto_tree_add_text(starteamroot_tree, tvb, offset, -1, STARTEAM_TEXT_DATA);
- starteam_tree = proto_item_add_subtree(ti, ett_starteam_data);
- proto_tree_add_item(starteam_tree, hf_starteam_data_data, tvb, offset, tvb_length_remaining(tvb, offset), ENC_ASCII|ENC_NA);
+ starteam_tree = proto_tree_add_subtree(starteamroot_tree, tvb, offset, -1, ett_starteam_data, NULL, STARTEAM_TEXT_DATA);
+ proto_tree_add_item(starteam_tree, hf_starteam_data_data, tvb, offset, -1, ENC_ASCII|ENC_NA);
}
}
}
static int
dissect_stat_stat_res(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
- proto_item* sub_item = NULL;
- proto_tree* sub_tree = NULL;
+ proto_item* sub_item;
+ proto_tree* sub_tree;
gint32 res;
- if (tree) {
- sub_item = proto_tree_add_item(tree, &hfi_stat_stat_res, tvb,
+ sub_item = proto_tree_add_item(tree, &hfi_stat_stat_res, tvb,
offset, -1, ENC_NA);
- if (sub_item)
- sub_tree = proto_item_add_subtree(sub_item, ett_stat_stat_res);
- }
+ sub_tree = proto_item_add_subtree(sub_item, ett_stat_stat_res);
res = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32(tvb,sub_tree,hfi_stat_stat_res_res.id,offset);
static int
dissect_stat_my_id(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- proto_item* sub_item = NULL;
- proto_tree* sub_tree = NULL;
+ proto_item* sub_item;
+ proto_tree* sub_tree;
- if (tree) {
- sub_item = proto_tree_add_item(tree, &hfi_stat_my_id, tvb,
+ sub_item = proto_tree_add_item(tree, &hfi_stat_my_id, tvb,
offset, my_id_len(tvb,offset), ENC_NA);
- if (sub_item)
- sub_tree = proto_item_add_subtree(sub_item, ett_stat_my_id);
- }
+ sub_tree = proto_item_add_subtree(sub_item, ett_stat_my_id);
offset = dissect_rpc_string(tvb,sub_tree,hfi_stat_my_id_hostname.id,offset,NULL);
offset = dissect_rpc_uint32(tvb,sub_tree,hfi_stat_my_id_prog.id,offset);
static int
dissect_stat_mon_id(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
- proto_item* sub_item = NULL;
- proto_tree* sub_tree = NULL;
+ proto_item* sub_item;
+ proto_tree* sub_tree;
- if (tree) {
- sub_item = proto_tree_add_item(tree, &hfi_stat_mon, tvb,
+ sub_item = proto_tree_add_item(tree, &hfi_stat_mon, tvb,
offset, mon_id_len(tvb,offset), ENC_NA);
- if (sub_item)
- sub_tree = proto_item_add_subtree(sub_item, ett_stat_mon);
- }
-
+ sub_tree = proto_item_add_subtree(sub_item, ett_stat_mon);
offset = dissect_rpc_string(tvb,sub_tree,hfi_stat_mon_id_name.id,offset,NULL);
static int
dissect_stat_notify(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
- proto_item* sub_item = NULL;
- proto_tree* sub_tree = NULL;
+ proto_item* sub_item;
+ proto_tree* sub_tree;
int start_offset = offset;
- if (tree) {
- sub_item = proto_tree_add_item(tree, &hfi_stat_stat_chge, tvb,
+ sub_item = proto_tree_add_item(tree, &hfi_stat_stat_chge, tvb,
offset, -1, ENC_NA);
- if (sub_item)
- sub_tree = proto_item_add_subtree(sub_item, ett_stat_stat_chge);
- }
+ sub_tree = proto_item_add_subtree(sub_item, ett_stat_stat_chge);
offset = dissect_rpc_string(tvb,sub_tree,hfi_stat_mon_id_name.id,offset,NULL);
static void
dissect_source_address_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, guint8 *ssn)
{
- proto_item *address_indicator_item;
proto_tree *address_indicator_tree;
tvbuff_t *parameters_tvb;
if(parameter_tree) {
proto_tree_add_item(parameter_tree, hf_sua_source_address_routing_indicator, parameter_tvb, ROUTING_INDICATOR_OFFSET, ROUTING_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
- address_indicator_item = proto_tree_add_text(parameter_tree, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, "Address Indicator");
- address_indicator_tree = proto_item_add_subtree(address_indicator_item, ett_sua_source_address_indicator);
+ address_indicator_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ett_sua_source_address_indicator, NULL, "Address Indicator");
proto_tree_add_item(address_indicator_tree, hf_sua_source_address_reserved_bits, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(address_indicator_tree, hf_sua_source_address_gt_bit, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(address_indicator_tree, hf_sua_source_address_pc_bit, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
static void
dissect_destination_address_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, guint8 *ssn)
{
- proto_item *address_indicator_item;
proto_tree *address_indicator_tree;
tvbuff_t *parameters_tvb;
if(parameter_tree) {
proto_tree_add_item(parameter_tree, hf_sua_destination_address_routing_indicator, parameter_tvb, ROUTING_INDICATOR_OFFSET, ROUTING_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
- address_indicator_item = proto_tree_add_text(parameter_tree, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, "Address Indicator");
- address_indicator_tree = proto_item_add_subtree(address_indicator_item, ett_sua_destination_address_indicator);
+ address_indicator_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ett_sua_destination_address_indicator, NULL, "Address Indicator");
proto_tree_add_item(address_indicator_tree, hf_sua_destination_address_reserved_bits, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(address_indicator_tree, hf_sua_destination_address_gt_bit, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(address_indicator_tree, hf_sua_destination_address_pc_bit, parameter_tvb, ADDRESS_INDICATOR_OFFSET, ADDRESS_INDICATOR_LENGTH, ENC_BIG_ENDIAN);
static void
dissect_sequence_number_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree)
{
- proto_item *sent_sequence_number_item;
proto_tree *sent_sequence_number_tree;
- proto_item *receive_sequence_number_item;
proto_tree *receive_sequence_number_tree;
proto_tree_add_item(parameter_tree, hf_sua_sequence_number_reserved, parameter_tvb, PARAMETER_VALUE_OFFSET, RESERVED_2_LENGTH, ENC_NA);
- receive_sequence_number_item = proto_tree_add_text(parameter_tree, parameter_tvb, SEQUENCE_NUMBER_REC_SEQ_OFFSET, SEQUENCE_NUMBER_REC_SEQ_LENGTH, "Receive Sequence Number");
- receive_sequence_number_tree = proto_item_add_subtree(receive_sequence_number_item, ett_sua_sequence_number_rec_number);
+ receive_sequence_number_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, SEQUENCE_NUMBER_REC_SEQ_OFFSET, SEQUENCE_NUMBER_REC_SEQ_LENGTH,
+ ett_sua_sequence_number_rec_number, NULL, "Receive Sequence Number");
proto_tree_add_item(receive_sequence_number_tree, hf_sua_sequence_number_rec_number, parameter_tvb, SEQUENCE_NUMBER_REC_SEQ_OFFSET, SEQUENCE_NUMBER_REC_SEQ_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(receive_sequence_number_tree, hf_sua_sequence_number_more_data_bit, parameter_tvb, SEQUENCE_NUMBER_REC_SEQ_OFFSET, SEQUENCE_NUMBER_REC_SEQ_LENGTH, ENC_BIG_ENDIAN);
- sent_sequence_number_item = proto_tree_add_text(parameter_tree, parameter_tvb, SEQUENCE_NUMBER_SENT_SEQ_OFFSET, SEQUENCE_NUMBER_SENT_SEQ_LENGTH, "Sent Sequence Number");
- sent_sequence_number_tree = proto_item_add_subtree(sent_sequence_number_item, ett_sua_sequence_number_sent_number);
+ sent_sequence_number_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, SEQUENCE_NUMBER_SENT_SEQ_OFFSET, SEQUENCE_NUMBER_SENT_SEQ_LENGTH,
+ ett_sua_sequence_number_sent_number, NULL, "Sent Sequence Number");
proto_tree_add_item(sent_sequence_number_tree, hf_sua_sequence_number_sent_number, parameter_tvb, SEQUENCE_NUMBER_SENT_SEQ_OFFSET, SEQUENCE_NUMBER_SENT_SEQ_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(sent_sequence_number_tree, hf_sua_sequence_number_spare_bit, parameter_tvb, SEQUENCE_NUMBER_SENT_SEQ_OFFSET, SEQUENCE_NUMBER_SENT_SEQ_LENGTH, ENC_BIG_ENDIAN);
}
static void
dissect_receive_sequence_number_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree)
{
- proto_item *receive_sequence_number_item;
proto_tree *receive_sequence_number_tree;
proto_tree_add_item(parameter_tree, hf_sua_receive_sequence_number_reserved, parameter_tvb, PARAMETER_VALUE_OFFSET, RESERVED_3_LENGTH, ENC_NA);
- receive_sequence_number_item = proto_tree_add_text(parameter_tree, parameter_tvb, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_OFFSET, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_LENGTH, "Receive Sequence Number");
- receive_sequence_number_tree = proto_item_add_subtree(receive_sequence_number_item, ett_sua_receive_sequence_number_number);
+ receive_sequence_number_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_OFFSET, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_LENGTH,
+ ett_sua_receive_sequence_number_number, NULL, "Receive Sequence Number");
proto_tree_add_item(receive_sequence_number_tree, hf_sua_receive_sequence_number_number, parameter_tvb, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_OFFSET, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(receive_sequence_number_tree, hf_sua_receive_sequence_number_spare_bit, parameter_tvb, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_OFFSET, RECEIVE_SEQUENCE_NUMBER_REC_SEQ_LENGTH, ENC_BIG_ENDIAN);
}
length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
padding_length = tvb_length(parameter_tvb) - length;
- if (tree) {
- /* create proto_tree stuff */
- parameter_item = proto_tree_add_text(tree, parameter_tvb, PARAMETER_HEADER_OFFSET, tvb_length(parameter_tvb), "%s", val_to_str_const(tag, v8_parameter_tag_values, "Unknown parameter"));
- parameter_tree = proto_item_add_subtree(parameter_item, ett_sua_parameter);
+ /* create proto_tree stuff */
+ parameter_tree = proto_tree_add_subtree(tree, parameter_tvb, PARAMETER_HEADER_OFFSET, -1, ett_sua_parameter, ¶meter_item, val_to_str_const(tag, v8_parameter_tag_values, "Unknown parameter"));
- /* add tag and length to the sua tree */
- proto_tree_add_item(parameter_tree, hf_sua_v8_parameter_tag, parameter_tvb, PARAMETER_TAG_OFFSET, PARAMETER_TAG_LENGTH, ENC_BIG_ENDIAN);
- proto_tree_add_item(parameter_tree, hf_sua_parameter_length, parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH, ENC_BIG_ENDIAN);
- } else {
- parameter_tree = NULL;
- parameter_item = NULL;
- }
+ /* add tag and length to the sua tree */
+ proto_tree_add_item(parameter_tree, hf_sua_v8_parameter_tag, parameter_tvb, PARAMETER_TAG_OFFSET, PARAMETER_TAG_LENGTH, ENC_BIG_ENDIAN);
+ proto_tree_add_item(parameter_tree, hf_sua_parameter_length, parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH, ENC_BIG_ENDIAN);
/*
** If no tree, only the data and ssn parameters in the source and destination
length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
padding_length = tvb_length(parameter_tvb) - length;
- if (tree) {
- /* Create proto_tree stuff */
- /* If it's a known parameter it's present in the value_string.
- * If param_tag_str = NULL then this is an unknown parameter
- */
- param_tag_str = try_val_to_str(tag, parameter_tag_values);
- if(param_tag_str) {
- /* The parameter exists */
- parameter_item = proto_tree_add_text(tree, parameter_tvb, PARAMETER_HEADER_OFFSET, tvb_length(parameter_tvb), "%s", param_tag_str);
- } else {
- if(dissector_try_uint(sua_parameter_table, tag, parameter_tvb, pinfo,tree)) {
- return;
- } else {
- parameter_item = proto_tree_add_text(tree, parameter_tvb, PARAMETER_HEADER_OFFSET, tvb_length(parameter_tvb), "Unknown parameter");
- }
- }
- parameter_tree = proto_item_add_subtree(parameter_item, ett_sua_parameter);
-
- /* Add tag and length to the sua tree */
- proto_tree_add_item(parameter_tree, hf_sua_parameter_tag, parameter_tvb, PARAMETER_TAG_OFFSET, PARAMETER_TAG_LENGTH, ENC_BIG_ENDIAN);
- proto_tree_add_item(parameter_tree, hf_sua_parameter_length, parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH, ENC_BIG_ENDIAN);
+ /* Create proto_tree stuff */
+ /* If it's a known parameter it's present in the value_string.
+ * If param_tag_str = NULL then this is an unknown parameter
+ */
+ param_tag_str = try_val_to_str(tag, parameter_tag_values);
+ if(param_tag_str) {
+ /* The parameter exists */
+ parameter_tree = proto_tree_add_subtree(tree, parameter_tvb, PARAMETER_HEADER_OFFSET, -1, ett_sua_parameter, ¶meter_item, param_tag_str);
} else {
- parameter_tree = NULL;
- parameter_item = NULL;
+ if(dissector_try_uint(sua_parameter_table, tag, parameter_tvb, pinfo,tree)) {
+ return;
+ }
+
+ parameter_tree = proto_tree_add_subtree(tree, parameter_tvb, PARAMETER_HEADER_OFFSET, -1, ett_sua_parameter, ¶meter_item, "Unknown parameter");
}
+ /* Add tag and length to the sua tree */
+ proto_tree_add_item(parameter_tree, hf_sua_parameter_tag, parameter_tvb, PARAMETER_TAG_OFFSET, PARAMETER_TAG_LENGTH, ENC_BIG_ENDIAN);
+ proto_tree_add_item(parameter_tree, hf_sua_parameter_length, parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH, ENC_BIG_ENDIAN);
+
/*
** If no tree, only the data, ssn, PC, and GT parameters in the source and destination
** addresses need to be dissected. This in order to make dissection of the data
/* STN with new tree to add the rest of the PMU block */
str = tvb_get_string_enc(wmem_packet_scope(), tvb, offset, CHNAM_LEN, ENC_ASCII);
- station_item = proto_tree_add_text(config_tree, tvb, offset, CHNAM_LEN, "Station #%i: \"%s\"", j + 1, str);
- station_tree = proto_item_add_subtree(station_item, ett_conf_station);
+ station_tree = proto_tree_add_subtree_format(config_tree, tvb, offset, CHNAM_LEN,
+ ett_conf_station, &station_item, "Station #%i: \"%s\"", j + 1, str);
offset += CHNAM_LEN;
/* IDCODE */
for (i = 0; i < wmem_array_get_count(conf->config_blocks); i++) {
config_block *block = (config_block*)wmem_array_index(conf->config_blocks, i);
- proto_item *block_item = proto_tree_add_text(data_tree, tvb, offset, BLOCKSIZE(*block),
- "Station: \"%s\"", block->name);
- proto_tree *block_tree = proto_item_add_subtree(block_item, ett_data_block);
+ proto_item *block_item;
+ proto_tree *block_tree = proto_tree_add_subtree_format(data_tree, tvb, offset, BLOCKSIZE(*block),
+ ett_data_block, &block_item, "Station: \"%s\"", block->name);
/* STAT */
proto_item *temp_item = proto_tree_add_text(block_tree, tvb, offset, 2, "Flags");
return offset;
length = wmem_array_get_count(block->phasors) * (floating_point == block->format_ph ? 8 : 4);
- temp_item = proto_tree_add_text(tree, tvb, offset, length, "Phasors (%u)", cnt);
- phasor_tree = proto_item_add_subtree(temp_item, ett_data_phasors);
+ phasor_tree = proto_tree_add_subtree_format(tree, tvb, offset, length, ett_data_phasors, NULL, "Phasors (%u)", cnt);
/* dissect a phasor for every phasor_info saved in the config_block */
for (j = 0; j < cnt; j++) {
return offset;
length = wmem_array_get_count(block->analogs) * (floating_point == block->format_an ? 4 : 2);
- temp_item = proto_tree_add_text(tree, tvb, offset, length, "Analog values (%u)", cnt);
-
- analog_tree = proto_item_add_subtree(temp_item, ett_data_analog);
+ analog_tree = proto_tree_add_subtree_format(tree, tvb, offset, length, ett_data_analog, NULL, "Analog values (%u)", cnt);
for (j = 0; j < cnt; j++) {
analog_info *ai = (analog_info *)wmem_array_index(block->analogs, j);
/* used by 'dissect_data_frame()' to dissect the DIGITAL field */
static gint dissect_DIGITAL(tvbuff_t *tvb, proto_tree *tree, config_block *block, gint offset)
{
- proto_item *digital_item = NULL;
gint j,
cnt = block->num_dg; /* number of digital status words to dissect */
if (0 == cnt)
return offset;
- digital_item = proto_tree_add_text(tree, tvb, offset, cnt * 2, "Digital status words (%u)", cnt);
- tree = proto_item_add_subtree(digital_item, ett_data_digital);
+ tree = proto_tree_add_subtree_format(tree, tvb, offset, cnt * 2, ett_data_digital, NULL, "Digital status words (%u)", cnt);
for (j = 0; j < cnt; j++) {
guint16 tmp = tvb_get_ntohs(tvb, offset);
/* used by 'dissect_config_frame()' to dissect the PHUNIT field */
static gint dissect_PHUNIT(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt)
{
- proto_item *temp_item = NULL;
- proto_tree *temp_tree = NULL;
+ proto_tree *temp_tree;
int i;
if (0 == cnt)
return offset;
- temp_item = proto_tree_add_text(tree, tvb, offset, 4 * cnt, "Phasor conversation factors (%u)", cnt);
- temp_tree = proto_item_add_subtree(temp_item, ett_conf_phconv);
+ temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 * cnt, ett_conf_phconv, NULL, "Phasor conversation factors (%u)", cnt);
/* Conversion factor for phasor channels. Four bytes for each phasor.
* MSB: 0 = voltage, 1 = current
/* used by 'dissect_config_frame()' to dissect the ANUNIT field */
static gint dissect_ANUNIT(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt)
{
- proto_item *temp_item = NULL;
- proto_tree *temp_tree = NULL;
+ proto_item *temp_item;
+ proto_tree *temp_tree;
int i;
if (0 == cnt)
return offset;
- temp_item = proto_tree_add_text(tree, tvb, offset, 4 * cnt, "Analog values conversation factors (%u)", cnt);
- temp_tree = proto_item_add_subtree(temp_item, ett_conf_anconv);
+ temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 * cnt, ett_conf_anconv, NULL, "Analog values conversation factors (%u)", cnt);
/* Conversation factor for analog channels. Four bytes for each analog value.
* MSB: see 'synphasor_conf_anconvnames' in 'synphasor_strings.c'
/* used by 'dissect_config_frame()' to dissect the DIGUNIT field */
static gint dissect_DIGUNIT(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt)
{
- proto_item *temp_item = NULL;
- proto_tree *temp_tree = NULL;
+ proto_item *temp_item;
+ proto_tree *temp_tree;
int i;
if (0 == cnt)
return offset;
- temp_item = proto_tree_add_text(tree, tvb, offset, 4 * cnt, "Masks for digital status words (%u)", cnt);
- temp_tree = proto_item_add_subtree(temp_item, ett_conf_dgmask);
+ temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 * cnt, ett_conf_dgmask, NULL, "Masks for digital status words (%u)", cnt);
/* Mask words for digital status words. Two 16-bit words for each digital word. The first
* inidcates the normal status of the inputs, the second indicated the valid bits in
/* used by 'dissect_config_frame()' to dissect the "channel name"-fields */
static gint dissect_CHNAM(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt, const char *prefix)
{
- proto_item *temp_item = NULL;
- proto_tree *temp_tree = NULL;
+ proto_tree *temp_tree;
int i;
if (0 == cnt)
return offset;
- temp_item = proto_tree_add_text(tree, tvb, offset, CHNAM_LEN * cnt, "%ss (%u)", prefix, cnt);
- temp_tree = proto_item_add_subtree(temp_item, ett_conf_phnam);
+ temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, CHNAM_LEN * cnt, ett_conf_phnam, NULL, "%ss (%u)", prefix, cnt);
/* dissect the 'cnt' channel names */
for (i = 0; i < cnt; i++) {
git.samba.org / metze / wireshark / wip.git / commitdiff