自学教程：C++ tvb_new_subset_length函数代码示例

/* M2TP Message */static voiddissect_m2tp_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_item *m2tp_item, proto_tree *m2tp_tree, proto_tree *tree){  gint offset, length, padding_length, total_length;  tvbuff_t *common_header_tvb, *parameter_tvb;  offset = 0;  /* extract and process the common header */  common_header_tvb = tvb_new_subset_length(message_tvb, offset, COMMON_HEADER_LENGTH);  dissect_m2tp_common_header(common_header_tvb, pinfo, m2tp_tree);  offset += COMMON_HEADER_LENGTH;  /* extract zero or more parameters and process them individually */  while(tvb_reported_length_remaining(message_tvb, offset) > 0) {    length         = tvb_get_ntohs(message_tvb, offset + PARAMETER_LENGTH_OFFSET);    padding_length = nr_of_padding_bytes(length);    total_length   = length + padding_length;    /* create a tvb for the parameter including the padding bytes */    parameter_tvb    = tvb_new_subset_length(message_tvb, offset, total_length);    dissect_m2tp_parameter(parameter_tvb, pinfo, m2tp_tree, m2tp_item, tree);    /* get rid of the handled parameter */    offset += total_length;  }}

/** Checksums the data. */static tvbuff_t *checksum_data(tvbuff_t *tvb, proto_tree *tree){    proto_item *hidden_item;    int len = tvb_length(tvb) - 2;    if (len < 0)        return tvb;    if (tree) {        guint16 actual_fcs = tvb_get_letohs(tvb, len);        guint16 calculated_fcs = crc16_ccitt_tvb(tvb, len);        if (calculated_fcs == actual_fcs) {            proto_tree_add_uint_format(tree, hf_sir_fcs,                                       tvb, len, 2, actual_fcs,                                       "Frame check sequence: 0x%04x (correct)",                                       actual_fcs);        } else {            hidden_item = proto_tree_add_boolean(tree,                                                 hf_sir_fcs_bad, tvb, len, 2, TRUE);            PROTO_ITEM_SET_HIDDEN(hidden_item);            proto_tree_add_uint_format(tree, hf_sir_fcs,                                       tvb, len, 2, actual_fcs,                                       "Frame check sequence: 0x%04x "                                       "(incorrect, should be 0x%04x)",                                       actual_fcs, calculated_fcs);        }    }    return tvb_new_subset_length(tvb, 0, len);}

static voiddissect_lapbether(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){    proto_tree *lapbether_tree, *ti;    int         len;    tvbuff_t   *next_tvb;    col_set_str(pinfo->cinfo, COL_PROTOCOL, "LAPBETHER");    col_clear(pinfo->cinfo, COL_INFO);    len = tvb_get_guint8(tvb, 0) + tvb_get_guint8(tvb, 1) * 256;    if (tree) {      ti = proto_tree_add_protocol_format(tree, proto_lapbether, tvb, 0, 2,                                          "LAPBETHER");      lapbether_tree = proto_item_add_subtree(ti, ett_lapbether);      proto_tree_add_uint_format(lapbether_tree, hf_lapbether_length, tvb, 0, 2,                                 len, "Length: %u", len);    }    next_tvb = tvb_new_subset_length(tvb, 2, len);    call_dissector(lapb_handle, next_tvb, pinfo, tree);}

static void dissect_ss_info_ie(tvbuff_t *tvb, packet_info *pinfo, guint offset, guint len, proto_tree *tree){	guint saved_offset;	gint8 appclass;	gboolean pc;	gboolean ind = FALSE;	guint32 component_len = 0;	guint32 header_end_offset;	guint32 header_len;	asn1_ctx_t asn1_ctx;	tvbuff_t *ss_tvb = NULL;	static gint comp_type_tag;	asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);	saved_offset = offset;	col_append_str(pinfo->cinfo, COL_PROTOCOL, "/");	col_set_fence(pinfo->cinfo, COL_PROTOCOL);	while (len > (offset - saved_offset)) {		/* get the length of the component. there can be multiple components in one message */		header_end_offset = get_ber_identifier(tvb, offset, &appclass, &pc, &comp_type_tag);		header_end_offset = get_ber_length(tvb, header_end_offset, &component_len, &ind);		header_len = header_end_offset -offset;		component_len += header_len;		ss_tvb = tvb_new_subset_length(tvb, offset, component_len);		col_append_str(pinfo->cinfo, COL_INFO, "(GSM MAP) ");		col_set_fence(pinfo->cinfo, COL_INFO);		call_dissector(gsm_map_handle, ss_tvb, pinfo, tree);		offset += component_len;	}}

static voiddissect_v8_message_data(tvbuff_t *message_tvb, packet_info *pinfo, proto_item *m2pa_item, proto_tree *m2pa_tree, proto_tree *tree){  guint32 message_data_length;  guint8 type;  tvbuff_t *message_data_tvb;  message_data_length = tvb_get_ntohl(message_tvb, V8_LENGTH_OFFSET) - V8_HEADER_LENGTH;  if ((gint) message_data_length < 1) {    proto_tree_add_expert_format(m2pa_tree, pinfo, &ei_length, message_tvb, V8_LENGTH_OFFSET, 4,        "Invalid message data length: %u", message_data_length);    /* XXX - is this really necessary?  Can we just return since the expert info can       still find the "malformed" packet? */    THROW(ReportedBoundsError);  }  message_data_tvb    = tvb_new_subset_length(message_tvb, V8_MESSAGE_DATA_OFFSET, message_data_length);  type                = tvb_get_guint8(message_tvb, V8_TYPE_OFFSET);  switch(type) {  case V8_USER_DATA_TYPE:    dissect_v8_user_data_message(message_data_tvb, pinfo, m2pa_item, m2pa_tree, tree);    break;  case V8_LINK_STATUS_TYPE:    dissect_v8_link_status_message(message_data_tvb, pinfo, m2pa_tree);    break;  default:    dissect_unknown_message(message_data_tvb, m2pa_tree);  }}

static voiddissect_v8_message_data(tvbuff_t *message_tvb, packet_info *pinfo, proto_item *m2pa_item, proto_tree *m2pa_tree, proto_tree *tree){  guint32 message_data_length;  guint8 type;  tvbuff_t *message_data_tvb;  message_data_length = tvb_get_ntohl(message_tvb, V8_LENGTH_OFFSET) - V8_HEADER_LENGTH;  if ((gint) message_data_length < 1) {    proto_tree_add_expert_format(m2pa_tree, pinfo, &ei_length, message_tvb, V8_LENGTH_OFFSET, 4,        "Invalid message data length: %u", message_data_length);    return;  }  message_data_tvb    = tvb_new_subset_length(message_tvb, V8_MESSAGE_DATA_OFFSET, message_data_length);  type                = tvb_get_guint8(message_tvb, V8_TYPE_OFFSET);  switch(type) {  case V8_USER_DATA_TYPE:    dissect_v8_user_data_message(message_data_tvb, pinfo, m2pa_item, m2pa_tree, tree);    break;  case V8_LINK_STATUS_TYPE:    dissect_v8_link_status_message(message_data_tvb, pinfo, m2pa_tree);    break;  default:    dissect_unknown_message(message_data_tvb, m2pa_tree);  }}

/* MS-GPEF section 2.2.1.2.2 EfsKey*/static intdissect_gpef_efskey(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *parent_tree){	proto_item *item = NULL;	proto_tree *tree = NULL;	int old_offset = offset;	guint32 length1, sid_offset;	guint32 cert_length, cert_offset;	tvbuff_t *next_tvb;	asn1_ctx_t asn1_ctx;	asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);	if (parent_tree) {		item = proto_tree_add_item(parent_tree, hf_gpef_efskey, tvb, -1, -1, ENC_NA);		tree = proto_item_add_subtree(item, ett_gpef_efskey);	}	/* length 1 */	length1 = tvb_get_letohl(tvb, offset);	proto_tree_add_item(tree, hf_gpef_efskey_length1, tvb, offset, 4, ENC_LITTLE_ENDIAN);	offset += 4;	/* length 2 */	proto_tree_add_item(tree, hf_gpef_efskey_length2, tvb, offset, 4, ENC_LITTLE_ENDIAN);	offset += 4;	/* sid offset */	sid_offset = tvb_get_letohl(tvb, offset);	proto_tree_add_item(tree, hf_gpef_efskey_sid_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN);	offset += 4;	/* reserved */	offset += 4;	/* cert length */	cert_length = tvb_get_letohl(tvb, offset);	proto_tree_add_item(tree, hf_gpef_efskey_cert_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);	offset += 4;	/* cert offset */	cert_offset = tvb_get_letohl(tvb, offset);	proto_tree_add_item(tree, hf_gpef_efskey_cert_offset, tvb, offset, 4, ENC_LITTLE_ENDIAN);	/*offset += 4;*/	/* reserved, must be 0x20 0x00 0x00 0x00 */	/*offset += 4;*/	/* sid */	dissect_nt_sid(tvb, old_offset+4+sid_offset, tree, "sid", NULL, -1);	/* certificate */	next_tvb = tvb_new_subset_length(tvb, old_offset+4+cert_offset, cert_length);	(void)dissect_x509af_Certificate(FALSE, next_tvb, 0, &asn1_ctx, tree, hf_gpef_efskey_certificate);	offset = old_offset + length1;	proto_item_set_len(item, offset-old_offset);	return offset;}

/* Dissection */static voiddissect_macmgmt (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree){  const guint8 *src, *dst;  guint16 msg_len;  proto_item *mgt_hdr_it;  proto_tree *mgt_hdr_tree;  tvbuff_t *payload_tvb;  guint8 type;  col_set_str (pinfo->cinfo, COL_PROTOCOL, "DOCSIS MGMT");  col_clear(pinfo->cinfo, COL_INFO);  src = tvb_get_ptr (tvb, 6, 6);  dst = tvb_get_ptr (tvb, 0, 6);  SET_ADDRESS (&pinfo->dl_src, AT_ETHER, 6, src);  SET_ADDRESS (&pinfo->src, AT_ETHER, 6, src);  SET_ADDRESS (&pinfo->dl_dst, AT_ETHER, 6, dst);  SET_ADDRESS (&pinfo->dst, AT_ETHER, 6, dst);  if (tree)    {      mgt_hdr_it =        proto_tree_add_protocol_format (tree, proto_docsis_mgmt, tvb, 0, 20,                                        "Mac Management");      mgt_hdr_tree = proto_item_add_subtree (mgt_hdr_it, ett_docsis_mgmt);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_dst_addr, tvb, 0, 6,                           ENC_NA);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_src_addr, tvb, 6, 6,                           ENC_NA);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_msg_len, tvb, 12, 2,                           ENC_BIG_ENDIAN);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_dsap, tvb, 14, 1,                           ENC_BIG_ENDIAN);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_ssap, tvb, 15, 1,                           ENC_BIG_ENDIAN);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_control, tvb, 16, 1,                           ENC_BIG_ENDIAN);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_version, tvb, 17, 1,                           ENC_BIG_ENDIAN);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_type, tvb, 18, 1,                           ENC_BIG_ENDIAN);      proto_tree_add_item (mgt_hdr_tree, hf_docsis_mgt_rsvd, tvb, 19, 1,                           ENC_BIG_ENDIAN);    }  /* Code to Call subdissector */  /* sub-dissectors are based on the type field */  type = tvb_get_guint8 (tvb, 18);  msg_len = tvb_get_ntohs (tvb, 12);  payload_tvb = tvb_new_subset_length (tvb, 20, msg_len - 6);  if (dissector_try_uint      (docsis_mgmt_dissector_table, type, payload_tvb, pinfo, tree))    return;  else    call_dissector (data_handle, payload_tvb, pinfo, tree);}

/* Code to actually dissect the packets */static voiddissect_dpnss_link(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){	proto_item *item;	proto_tree *dpnss_link_tree;	guint8      octet;	tvbuff_t   *protocol_data_tvb;	guint16     protocol_data_length;	gboolean    uton;	uton = pinfo->pseudo_header->l1event.uton;	/* Make entries in src and dst column */	col_set_str(pinfo->cinfo, COL_DEF_SRC, uton?"TE":"NT");	col_set_str(pinfo->cinfo, COL_DEF_DST, uton?"NT":"TE");	/* Make entries in Protocol column and Info column on summary display */	col_set_str(pinfo->cinfo, COL_PROTOCOL, "DPNSS");	item = proto_tree_add_item(tree, proto_dpnss_link, tvb, 0, -1, ENC_NA);	dpnss_link_tree = proto_item_add_subtree(item, ett_dpnss_link);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address_framegroup,			    tvb, 0, 1, ENC_BIG_ENDIAN);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address_crbit,			    tvb, 0, 1, ENC_BIG_ENDIAN);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address_extension,			    tvb, 0, 1, ENC_BIG_ENDIAN);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address2_reserved,			    tvb, 1, 1, ENC_BIG_ENDIAN);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address2_dlcId,			    tvb, 1, 1, ENC_BIG_ENDIAN);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address2_dlcIdNr,			    tvb, 1, 1, ENC_BIG_ENDIAN);	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_address2_extension,			    tvb, 1, 1, ENC_BIG_ENDIAN);	/*	 * XXX - DPNSS's layer 2 protocol appears to be Yet Another	 * HDLC Derivative; should this use the xDLC control field	 * dissector code?	 */	proto_tree_add_item(dpnss_link_tree, hf_dpnss_link_control_frameType,			    tvb, 2, 1, ENC_BIG_ENDIAN);	octet = tvb_get_guint8(tvb, 2);	switch (octet){	case FRAME_TYPE_UI_EVEN:	case FRAME_TYPE_UI_ODD:	    protocol_data_length=tvb_length(tvb)-LINK_HEADER_SIZE;	    protocol_data_tvb=tvb_new_subset_length(tvb, LINK_HEADER_SIZE,					     protocol_data_length);	    if (dpnss_handle && protocol_data_length>0) {		call_dissector(dpnss_handle, protocol_data_tvb, pinfo, tree);	    }	    break;	default:	    break;	}}

static void dissect_wimax_pdu_decoder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){	guint offset;	guint mac_ht, mac_ec;	guint first_byte, length;	guint mac_hcs, mac_hcs_calculated;	proto_item *pdu_item = NULL;	proto_tree *pdu_tree = NULL;#ifndef STATIC_DATA	/* generate the table of CRC32  remainders for all possible bytes */	wimax_mac_gen_crc32_table();	/* generate the table of CRC8 remainders for all possible bytes */	wimax_mac_gen_crc8_table();#endif	/* parsing the PDU burst */	for(offset = 0; offset < tvb_reported_length(tvb); )	{		if (offset == 0)		{			first_gmh = TRUE;		}		else		{			first_gmh = FALSE;		}		/* get the length of the remainder */		length = tvb_reported_length_remaining(tvb, offset);		/* get the first byte at offset */		first_byte = tvb_get_guint8(tvb, offset);		/* check for padding */		if(first_byte == WIMAX_PDU_PADDING_MASK)		{	/* Padding */			/* display message */			pdu_item = proto_tree_add_protocol_format(tree, proto_wimax_pdu_decoder, tvb, offset, length, "Padding (%u bytes)", length);			/* add subtree */			pdu_tree = proto_item_add_subtree(pdu_item, ett_wimax_pdu_decoder);			/* display the padding in Hex */			proto_tree_add_item(pdu_tree, hf_wimax_value_bytes, tvb, offset, length, ENC_NA);			break;		}		else if((first_byte & WIMAX_MAP_TYPE_MASK) == WIMAX_HARQ_MAP_MSG_IND)		{	/* HARQ MAP message (no mac header) */			/* get the HARQ MAp Message Length */			length = ((tvb_get_ntohs(tvb, offset) & WIMAX_HARQ_MAP_MSG_LENGTH_MASK1) >> 2);			if (length == 0)			{				length = 3;	/* At least 3 bytes.  This prevents endless loop */			}			call_dissector(wimax_harq_map_handle, tvb_new_subset_length(tvb,offset,length), pinfo, tree);			offset += length;			continue;		}		else if((first_byte & WIMAX_MAP_TYPE_MASK) == WIMAX_COMPRESSED_DL_MAP_IND)

/* Decode and display the FCH burst */static void fch_burst_decoder(proto_tree *tree, tvbuff_t *tvb, gint offset, gint length, packet_info *pinfo){	if(wimax_fch_burst_handle)	{	/* call FCH dissector */		call_dissector(wimax_fch_burst_handle, tvb_new_subset_length(tvb, offset, length), pinfo, tree);	}	else	/* display FCH info */	{	/* update the info column */		col_append_str(pinfo->cinfo, COL_INFO, "FCH Burst: DL Frame Prefix");	}}

/* Decode and display the CDMA Code Attribute */static void cdma_code_decoder(proto_tree *tree, tvbuff_t *tvb, gint offset, gint length, packet_info *pinfo){	if(wimax_cdma_code_burst_handle)	{	/* call CDMA dissector */		call_dissector(wimax_cdma_code_burst_handle, tvb_new_subset_length(tvb, offset, length), pinfo, tree);	}	else	/* display CDMA Code Attribute info */	{	/* update the info column */		col_append_str(pinfo->cinfo, COL_INFO, "CDMA Code Attribute");	}}

/* Decode and display the PDU Burst */static void pdu_burst_decoder(proto_tree *tree, tvbuff_t *tvb, gint offset, gint length, packet_info *pinfo, gint burst_number, gint frag_type, gint frag_number){	fragment_head *pdu_frag;	tvbuff_t *pdu_tvb = NULL;	/* update the info column */	switch (frag_type)	{		case TLV_FIRST_FRAG:			col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "First TLV Fragment (%d)", frag_number);		break;		case TLV_LAST_FRAG:			col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "Last TLV Fragment (%d)", frag_number);		break;		case TLV_MIDDLE_FRAG:			col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "Middle TLV Fragment %d", frag_number);		break;	}	if(frag_type == TLV_NO_FRAG)	{	/* not fragmented PDU */		pdu_tvb =  tvb_new_subset_length(tvb, offset, length);	}	else	/* fragmented PDU */	{	/* add the fragment */		pdu_frag = fragment_add_seq(&pdu_reassembly_table, tvb, offset, pinfo, burst_number, NULL, frag_number - 1, length, ((frag_type==TLV_LAST_FRAG)?0:1), 0);		if(pdu_frag && frag_type == TLV_LAST_FRAG)		{			/* create the new tvb for defragmented frame */			pdu_tvb = tvb_new_chain(tvb, pdu_frag->tvb_data);			/* add the defragmented data to the data source list */			add_new_data_source(pinfo, pdu_tvb, "Reassembled WiMax PDU Frame");		}		else		{			pdu_tvb = NULL;			if(frag_type == TLV_LAST_FRAG)			{	/* update the info column */				col_append_sep_str(pinfo->cinfo, COL_INFO, ", ", "Incomplete PDU frame");			}		}	}	/* process the defragmented PDU burst */	if(pdu_tvb)	{		if(wimax_pdu_burst_handle)		{/* decode and display PDU Burst */			call_dissector(wimax_pdu_burst_handle, pdu_tvb, pinfo, tree);		}		else	/* display PDU Burst info */		{	/* update the info column */			col_append_str(pinfo->cinfo, COL_INFO, "PDU Burst");		}	}}

static voiddissect_dsmcc_adaptation_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){    tvbuff_t   *sub_tvb;    guint       offset = 0;    proto_item *pi;    proto_tree *sub_tree;    guint8      type, tmp;    guint16     ca_len;    type = tvb_get_guint8(tvb, offset);    if (1 == type) {        sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_dsmcc_adaptation_header, NULL, "Adaptation Header");        proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_type, tvb,            offset, 1, ENC_BIG_ENDIAN);        offset +=1;        tmp = tvb_get_guint8(tvb, offset);        pi = proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_ca_reserved, tvb,            offset, 1, ENC_BIG_ENDIAN);        if (0xff != tmp) {            expert_add_info_format(pinfo, pi, &ei_dsmcc_invalid_value,                        "Invalid value - should be 0xff");        }        offset +=1;        proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_ca_system_id, tvb,            offset, 2, ENC_BIG_ENDIAN);        offset += 2;        ca_len = tvb_get_ntohs(tvb, offset);        proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_ca_length, tvb,            offset, 2, ENC_BIG_ENDIAN);        offset += 2;        sub_tvb = tvb_new_subset_length(tvb, offset, ca_len);        call_dissector(data_handle, sub_tvb, pinfo, tree);    } else if (2 == type) {        sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_dsmcc_adaptation_header, NULL, "Adaptation Header");        proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_type, tvb,            offset, 1, ENC_BIG_ENDIAN);        offset +=1;        tmp = tvb_get_guint8(tvb, offset);        pi = proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_user_id_reserved, tvb,            offset, 1, ENC_BIG_ENDIAN);        if (0xff != tmp) {            expert_add_info_format(pinfo, pi, &ei_dsmcc_invalid_value,                        "Invalid value - should be 0xff");        }        /*offset +=1;*/        /* TODO: handle the userId */    } else {        sub_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_dsmcc_adaptation_header, NULL, "Unknown Adaptation Header");        proto_tree_add_item(sub_tree, hf_dsmcc_adaptation_type, tvb,            offset, 1, ENC_BIG_ENDIAN);    }}

/* Decode and display the Fast Feedback Burst */static void fast_feedback_burst_decoder(proto_tree *tree, tvbuff_t *tvb, gint offset, gint length, packet_info *pinfo){	if(wimax_ffb_burst_handle)	{	/* display the TLV Fast Feedback Burst dissector info */		call_dissector(wimax_ffb_burst_handle, tvb_new_subset_length(tvb, offset, length), pinfo, tree);	}	else	/* display the Fast Feedback Burst info */	{	/* update the info column */		col_append_str(pinfo->cinfo, COL_INFO, "Fast Feedback Burst");	}}

static void harq_ack_bursts_decoder(proto_tree *tree, tvbuff_t *tvb, gint offset, gint length, packet_info *pinfo){	if(wimax_hack_burst_handle)	{	/* call the TLV HARQ ACK Bursts dissector */		call_dissector(wimax_hack_burst_handle, tvb_new_subset_length(tvb, offset, length), pinfo, tree);	}	else	/* display the TLV HARQ ACK Bursts info */	{	/* update the info column */		col_append_str(pinfo->cinfo, COL_INFO, "HARQ ACK Bursts");	}}

static voiddissect_cwids(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){	tvbuff_t *wlan_tvb;	proto_tree *ti, *cwids_tree;	volatile int offset = 0;	guint16 capturelen;	col_set_str(pinfo->cinfo, COL_PROTOCOL, "CWIDS");	col_set_str(pinfo->cinfo, COL_INFO, "Cwids: ");	/* FIXME: col_set_fence(pinfo->cinfo, all-cols, only addr-cols?); */	cwids_tree = NULL;	while(tvb_reported_length_remaining(tvb, offset) > 0) {		struct ieee_802_11_phdr phdr;		ti = proto_tree_add_item(tree, proto_cwids, tvb, offset, 28, ENC_NA);		cwids_tree = proto_item_add_subtree(ti, ett_cwids);		phdr.fcs_len = 0;	/* no FCS */		phdr.decrypted = FALSE;		phdr.datapad = FALSE;		phdr.presence_flags = PHDR_802_11_HAS_CHANNEL;		proto_tree_add_item(cwids_tree, hf_cwids_version, tvb, offset, 2, ENC_BIG_ENDIAN);		offset += 2;		proto_tree_add_item(cwids_tree, hf_cwids_unknown1, tvb, offset, 7, ENC_NA);		offset += 7;		phdr.channel = tvb_get_guint8(tvb, offset);		proto_tree_add_item(cwids_tree, hf_cwids_channel, tvb, offset, 1, ENC_BIG_ENDIAN);		offset += 1;		proto_tree_add_item(cwids_tree, hf_cwids_unknown2, tvb, offset, 6, ENC_NA);		offset += 6;		proto_tree_add_item(cwids_tree, hf_cwids_reallength, tvb, offset, 2, ENC_BIG_ENDIAN);		offset += 2;		capturelen = tvb_get_ntohs(tvb, offset);		proto_tree_add_item(cwids_tree, hf_cwids_capturelen, tvb, offset, 2, ENC_BIG_ENDIAN);		offset += 2;		proto_tree_add_item(cwids_tree, hf_cwids_unknown3, tvb, offset, 8, ENC_NA);		offset += 8;		wlan_tvb = tvb_new_subset_length(tvb, offset, capturelen);		/* Continue after ieee80211 dissection errors */		TRY {			call_dissector_with_data(ieee80211_radio_handle, wlan_tvb, pinfo, tree, &phdr);		} CATCH_BOUNDS_ERRORS {			show_exception(wlan_tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE);			expert_add_info(pinfo, ti, &ie_ieee80211_subpacket);		} ENDTRY;		offset += capturelen;	}}

static void physical_attributes_decoder(proto_tree *tree, tvbuff_t *tvb, gint offset, gint length, packet_info *pinfo){	if(wimax_phy_attributes_burst_handle)	{	/* call the TLV PDU Burst Physical Attributes dissector */		call_dissector(wimax_phy_attributes_burst_handle, tvb_new_subset_length(tvb, offset, length), pinfo, tree);	}	else	/* display the TLV PDU Burst Physical Attributes info */	{	/* update the info column */		col_append_str(pinfo->cinfo, COL_INFO, "PHY-attr");	}}

/** Checksums the data. */static tvbuff_t *checksum_data(tvbuff_t *tvb, proto_tree *tree){	int len = tvb_reported_length(tvb) - 2;	if (len < 0)		return tvb;	proto_tree_add_checksum(tree, tvb, len, hf_sir_fcs, hf_sir_fcs_status, NULL, NULL, crc16_ccitt_tvb(tvb, len),								ENC_LITTLE_ENDIAN, PROTO_CHECKSUM_VERIFY);	return tvb_new_subset_length(tvb, 0, len);}

static void dissect_nwmtp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){	gint offset = 0;	col_set_str(pinfo->cinfo, COL_PROTOCOL, "NW MTP");	col_clear(pinfo->cinfo, COL_INFO);	while (tvb_reported_length_remaining(tvb, offset) > 0) {		const gchar *type;		proto_item *ti;		proto_item *nwmtp_tree;		guint32 len;		tvbuff_t *next_tvb;		/* update the info column */		type = val_to_str_const(tvb_get_guint8(tvb, offset + 1),					nwmtp_data_type_vals, "Unknown");		col_set_str(pinfo->cinfo, COL_INFO, type);		len = tvb_get_ntohl(tvb, offset + 8);		if (tree) {			ti = proto_tree_add_protocol_format(tree, proto_nwmtp,					tvb, offset, len + 12,					"NexusWare C7 UDP Protocol");			nwmtp_tree = proto_item_add_subtree(ti, ett_mwmtp);			proto_tree_add_item(nwmtp_tree, hf_nwmtp_transp_type,					    tvb, offset, 1, ENC_BIG_ENDIAN);			proto_tree_add_item(nwmtp_tree, hf_nwmtp_data_type,					    tvb, offset + 1, 1, ENC_BIG_ENDIAN);			proto_tree_add_item(nwmtp_tree, hf_nwmtp_data_index,					    tvb, offset + 2, 2, ENC_BIG_ENDIAN);			proto_tree_add_item(nwmtp_tree, hf_nwmtp_user_context,					    tvb, offset + 4, 4, ENC_BIG_ENDIAN);			proto_tree_add_item(nwmtp_tree, hf_nwmtp_data_length,					    tvb, offset + 8, 4, ENC_BIG_ENDIAN);		}		next_tvb = tvb_new_subset_length(tvb, offset + 12, len);		if (tvb_length(next_tvb) > 0)			call_dissector(mtp_handle, next_tvb, pinfo, tree);		/* Check for overflows, which probably can't happen, but better		 * safe than sorry. See		 * https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=8169		 */		DISSECTOR_ASSERT(len < G_MAXUINT32 - 11);		DISSECTOR_ASSERT((guint64)offset + len + 12 < G_MAXINT);		offset += len + 12;	}}

static voiddissect_error_causes(tvbuff_t *error_causes_tvb, proto_tree *parameter_tree){  guint16 length, total_length;  gint offset;  tvbuff_t *error_cause_tvb;  offset = 0;  while(tvb_reported_length_remaining(error_causes_tvb, offset) > 0) {    length          = tvb_get_ntohs(error_causes_tvb, offset + CAUSE_LENGTH_OFFSET);    total_length    = ADD_PADDING(length);    error_cause_tvb = tvb_new_subset_length(error_causes_tvb, offset , total_length);    dissect_error_cause(error_cause_tvb, parameter_tree);    offset += total_length;  }}

static void dissect_srp_command(tvbuff_t * tvb, packet_info * pinfo, proto_tree * srp_tree){    tvbuff_t *next_tvb;    guint payload_len;    if( srp_tree )        proto_tree_add_item(srp_tree,hf_srp_seqno,tvb,1,1,ENC_BIG_ENDIAN);    payload_len = tvb_reported_length_remaining(tvb,4);    next_tvb = tvb_new_subset_length(tvb, 2, payload_len);    /* XXX currently, we always dissect as CCSRL. It's only that in     * H324/Annex C though.     */    call_dissector(ccsrl_handle, next_tvb, pinfo, srp_tree );}

static voiddissect_protocol_data_parameter(tvbuff_t *parameter_tvb, proto_item *parameter_item, packet_info *pinfo, proto_tree *tree){  guint16 protocol_data_length;  tvbuff_t *protocol_data_tvb;  protocol_data_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;  protocol_data_tvb    = tvb_new_subset_length(parameter_tvb, PROTOCOL_DATA_OFFSET, protocol_data_length);  if(dpnss_handle){    call_dissector(dpnss_handle, protocol_data_tvb, pinfo, tree);    return;  }  call_dissector(data_handle, protocol_data_tvb, pinfo, tree);  proto_item_append_text(parameter_item, " (%u byte%s)", protocol_data_length, plurality(protocol_data_length, "", "s"));}

/* 3GPP TS 23.041 version 11.4.0 * 9.4.2.2.5 CB Data */static voiddissect_sabp_cb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree){  proto_item *cbs_page_item;  proto_tree *subtree;  tvbuff_t *page_tvb, *unpacked_tvb;  int offset = 0;  int n;  guint8 nr_pages, len, cb_inf_msg_len;  /* Octet 1 Number-of-Pages */  nr_pages = tvb_get_guint8(tvb, offset);  proto_tree_add_item(tree, hf_sabp_no_of_pages, tvb, offset, 1, ENC_BIG_ENDIAN);  offset++;  /*   * NOTE: n equal to or less than 15   */  if(nr_pages > 15){    /* Error */    return;  }  for (n = 0; n < nr_pages; n++) {    subtree = proto_tree_add_subtree_format(tree, tvb, offset, 83, ett_sabp_cbs_page, NULL,                "CB page %u data",  n+1);    /* octet 2 - 83 CBS-Message-Information-Page 1  */    cbs_page_item = proto_tree_add_item(subtree, hf_sabp_cb_msg_inf_page, tvb, offset, 82, ENC_NA);    cb_inf_msg_len = tvb_get_guint8(tvb,offset+82);    page_tvb = tvb_new_subset_length(tvb, offset, cb_inf_msg_len);    unpacked_tvb = dissect_cbs_data(sms_encoding, page_tvb, subtree, pinfo, 0);    len = tvb_captured_length(unpacked_tvb);    if (unpacked_tvb != NULL){      if (tree != NULL){        proto_tree *cbs_page_subtree = proto_item_add_subtree(cbs_page_item, ett_sabp_cbs_page_content);        proto_tree_add_item(cbs_page_subtree, hf_sabp_cbs_page_content, unpacked_tvb, 0, len, ENC_UTF_8|ENC_NA);      }    }    offset = offset+82;    /* 84 CBS-Message-Information-Length 1 */    proto_tree_add_item(subtree, hf_sabp_cb_inf_len, tvb, offset, 1, ENC_BIG_ENDIAN);    offset++;  }}

static voiddissect_parameters(tvbuff_t *parameters_tvb, proto_tree *tree){  gint offset, length, total_length, remaining_length;  tvbuff_t *parameter_tvb;  offset = 0;  while((remaining_length = tvb_reported_length_remaining(parameters_tvb, offset)) > 0) {    length       = tvb_get_ntohs(parameters_tvb, offset + PARAMETER_LENGTH_OFFSET);    total_length = ADD_PADDING(length);    if (remaining_length >= length)      total_length = MIN(total_length, remaining_length);    /* create a tvb for the parameter including the padding bytes */    parameter_tvb  = tvb_new_subset_length(parameters_tvb, offset, total_length);    dissect_parameter(parameter_tvb, tree);    /* get rid of the handled parameter */    offset += total_length;  }}

/* Protocol Data */static voiddissect_m2tp_protocol_data_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, packet_info *pinfo, proto_item *m2tp_item, proto_tree *tree){  guint16 length, protocol_data_length, padding_length;  tvbuff_t *mtp2_tvb;  length               = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);  padding_length       = nr_of_padding_bytes(length);  protocol_data_length = length - PARAMETER_HEADER_LENGTH;  mtp2_tvb = tvb_new_subset_length(parameter_tvb, PARAMETER_VALUE_OFFSET, protocol_data_length);  call_dissector(mtp2_handle, mtp2_tvb, pinfo, tree);  if (parameter_tree) {    proto_item_set_text(parameter_item, "Protocol data (SS7 message)");    proto_item_set_len(parameter_item, proto_item_get_len(parameter_item) - protocol_data_length - padding_length);    proto_item_set_len(m2tp_item,      proto_item_get_len(m2tp_item)      - protocol_data_length - padding_length);  }}

static voiddissect_cbsp_content_ie(tvbuff_t *tvb, packet_info *pinfo, guint offset, gint len, proto_tree *tree,			guint8 sms_encoding, proto_item *ti){	proto_item *cbs_page_item;	tvbuff_t *next_tvb, *unpacked_tvb;	const guint8 *pstr;	proto_tree_add_item(tree, hf_cbsp_user_info_length, tvb, offset, 1, ENC_NA);	cbs_page_item = proto_tree_add_item(tree, hf_cbsp_cb_msg_page, tvb, offset+1, len-1, ENC_NA);	next_tvb = tvb_new_subset_length(tvb, offset+1, len-1);	unpacked_tvb = dissect_cbs_data(sms_encoding, next_tvb, tree, pinfo, 0);	if (tree) {		guint captured_len = tvb_captured_length(unpacked_tvb);		proto_tree *cbs_page_subtree = proto_item_add_subtree(cbs_page_item, ett_cbsp_cbs_page_content);		proto_tree_add_item_ret_string(cbs_page_subtree, hf_cbsp_cbs_page_content, unpacked_tvb,						0, captured_len, ENC_UTF_8|ENC_NA, wmem_packet_scope(),						&pstr);		proto_item_append_text(ti, ": '%s'", pstr);	}}

static intdissect_eth_frame(tvbuff_t *tvb, packet_info *pinfo, proto_tree *mint_tree,	volatile guint32 offset, guint32 length){	tvbuff_t *eth_tvb;#ifdef MINT_DEVELOPMENT	col_set_writable(pinfo->cinfo, FALSE);#endif	eth_tvb = tvb_new_subset_length(tvb, offset, length);	/* Continue after Ethernet dissection errors */	TRY {		call_dissector(eth_handle, eth_tvb, pinfo, mint_tree);	} CATCH_NONFATAL_ERRORS {		show_exception(eth_tvb, pinfo, mint_tree, EXCEPT_CODE, GET_MESSAGE);	} ENDTRY;	offset += length;#ifdef MINT_DEVELOPMENT	col_set_writable(pinfo->cinfo, TRUE);#endif	return offset;}