/*
* create the ansi_map protocol tree
*/
- ansi_map_item = proto_tree_add_item(tree, proto_ansi_map, tvb, 0, -1, FALSE);
+ ansi_map_item = proto_tree_add_item(tree, proto_ansi_map, tvb, 0, -1, ENC_NA);
ansi_map_tree = proto_item_add_subtree(ansi_map_item, ett_ansi_map);
ansi_map_is_invoke = FALSE;
is683_ota = FALSE;
/* create display subtree for the protocol */
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_ansi_tcap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_ansi_tcap, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_tcap);
tcap_stat_item=item;
tcap_stat_tree=tree;
static enum_val_t ansi_tcap_response_matching_type_values[] = {
{"Only Transaction ID will be used in Invoke/response matching", "Transaction ID only", 0},
- {"Transaction ID and Source will be used in Invoke/response matching", "Transaction ID and Source", 1},
+ {"Transaction ID and Source will be used in Invoke/response matching", "Transaction ID and Source", 1},
{"Transaction ID Source and Destination will be used in Invoke/response matching", "Transaction ID Source and Destination", 2},
{NULL, NULL, -1}
};
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
* References: ETSI 300 374
*/
-/*
- * Indentation logic: this file is indented with 2 spaces indentation.
+/*
+ * Indentation logic: this file is indented with 2 spaces indentation.
* there are no tabs.
*/
#ifdef HAVE_CONFIG_H
/* ROSE context */
static rose_ctx_t camel_rose_ctx;
-static int hf_digit = -1;
+static int hf_digit = -1;
static int hf_camel_extension_code_local = -1;
static int hf_camel_error_code_local = -1;
static int hf_camel_cause_indicator = -1;
{ 12, "spare"},
{ 13, "spare"},
{ 0, NULL}};
-
-
+
+
static const value_string camel_nature_of_addr_indicator_values[] = {
{ 0x00, "unknown" },
{ 0x01, "International Number" },
/*
* 24.011 8.2.5.4
- */
+ */
static guint8
dissect_RP_cause_ie(tvbuff_t *tvb, guint32 offset, _U_ guint len,
proto_tree *tree, int hf_cause_value, guint8 *cause_value)
guint8 oct;
guint32 curr_offset;
static char a_bigbuf[1024];
-
+
curr_offset = offset;
oct = tvb_get_guint8(tvb, curr_offset);
- *cause_value = oct & 0x7f;
-
+ *cause_value = oct & 0x7f;
+
other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
proto_tree_add_uint_format(tree, hf_cause_value,
tvb, curr_offset, 1, *cause_value,
"%s : %s",
a_bigbuf,
- val_to_str(*cause_value, camel_RP_Cause_values,
+ val_to_str(*cause_value, camel_RP_Cause_values,
"Unknown Cause (%u), treated as (41) \"Temporary failure\" for MO-SMS or (111) \"Protocol error,unspecified\" for MT-SMS"));
curr_offset++;
-
+
if ((oct & 0x80)) {
oct = tvb_get_guint8(tvb, curr_offset);
proto_tree_add_uint_format(tree, hf_cause_value,
opcode = 0;
application_context_version = 0;
if (actx->pinfo->private_data != NULL){
- p_private_tcap=actx->pinfo->private_data;
-
+ p_private_tcap=actx->pinfo->private_data;
+
if (p_private_tcap->acv==TRUE ){
version_ptr = strrchr(p_private_tcap->oid,'.');
if (version_ptr)
application_context_version = atoi(version_ptr+1);
}
- gp_camelsrt_info->tcap_context=p_private_tcap->context;
+ gp_camelsrt_info->tcap_context=p_private_tcap->context;
if (p_private_tcap->context)
gp_camelsrt_info->tcap_session_id
/* create display subtree for the protocol */
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_camel, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_camel, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_camel);
}
/* camelsrt reset counter, and initialise global pointer
to store service response time related data */
gp_camelsrt_info=camelsrt_razinfo();
dissect_camel_camelPDU(FALSE, tvb, 0, &asn1_ctx , tree, -1);
-
+
/* If a Tcap context is associated to this transaction */
if (gcamel_HandleSRT &&
gp_camelsrt_info->tcap_context ) {
register_ber_oid_dissector_handle("0.4.0.0.1.21.3.61",camel_handle, proto_camel, "cap3-sms-AC" );
register_ber_oid_dissector_handle("0.4.0.0.1.23.3.4",camel_handle, proto_camel, "capssf-scfGenericAC" );
register_ber_oid_dissector_handle("0.4.0.0.1.23.3.61",camel_handle, proto_camel, "cap4-sms-AC" );
-
+
#include "packet-camel-dis-tab.c"
} else {
ssn_range = range_copy(global_ssn_range);
range_foreach(ssn_range, range_add_callback);
-
+
}
void proto_register_camel(void) {
{ "RP Cause", "camel.RP_Cause",
FT_UINT8, BASE_DEC, NULL, 0,
"RP Cause Value", HFILL }},
-
+
{ &hf_camel_CAMEL_AChBillingChargingCharacteristics,
{ "CAMEL-AChBillingChargingCharacteristics", "camel.CAMEL_AChBillingChargingCharacteristics",
FT_UINT32, BASE_DEC, VALS(camel_CAMEL_AChBillingChargingCharacteristics_vals), 0,
- NULL, HFILL }},
-
+ NULL, HFILL }},
+
{ &hf_camel_CAMEL_FCIBillingChargingCharacteristics,
{ "CAMEL-FCIBillingChargingCharacteristics", "camel.CAMEL_FCIBillingChargingCharacteristics",
FT_UINT32, BASE_DEC, VALS(camel_CAMEL_FCIBillingChargingCharacteristics_vals), 0,
rose_ctx_init(&camel_rose_ctx);
/* Register dissector tables */
- camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg",
- "CAMEL Operation Argument (local opcode)",
- FT_UINT32, BASE_HEX);
- camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res",
- "CAMEL Operation Result (local opcode)",
- FT_UINT32, BASE_HEX);
- camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err",
- "CAMEL Error (local opcode)",
- FT_UINT32, BASE_HEX);
+ camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg",
+ "CAMEL Operation Argument (local opcode)",
+ FT_UINT32, BASE_HEX);
+ camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res",
+ "CAMEL Operation Result (local opcode)",
+ FT_UINT32, BASE_HEX);
+ camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err",
+ "CAMEL Error (local opcode)",
+ FT_UINT32, BASE_HEX);
/* Register our configuration options, particularly our ssn:s */
/* Set default SSNs */
prefs_register_enum_preference(camel_module, "date.format", "Date Format",
"The date format: (DD/MM) or (MM/DD)",
&date_format, date_options, FALSE);
-
-
+
+
prefs_register_range_preference(camel_module, "tcap.ssn",
"TCAP SSNs",
"TCAP Subsystem numbers used for Camel",
"Persistent stats for SRT",
"Statistics for Response Time",
&gcamel_PersistentSRT);
-
- /* Routine for statistic */
+
+ /* Routine for statistic */
register_init_routine(&camelsrt_init_routine);
camel_tap=register_tap(PSNAME);
}
}
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_cmip, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_cmip, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_cmip);
}
register_ber_oid_dissector("2.9.0.0.2", dissect_cmip, proto_cmip, "cmip");
register_ber_oid_dissector("2.9.1.1.4", dissect_cmip, proto_cmip, "joint-iso-itu-t(2) ms(9) cmip(1) cmip-pci(1) abstractSyntax(4)");
- oid_add_from_string("2.9.3.2.3.1","managedObjectClass(3) alarmRecord(1)");
+ oid_add_from_string("2.9.3.2.3.1","managedObjectClass(3) alarmRecord(1)");
oid_add_from_string("2.9.3.2.3.2","managedObjectClass(3) attributeValueChangeRecord(2)");
oid_add_from_string("2.9.3.2.3.3","managedObjectClass(3) discriminator(3)");
oid_add_from_string("2.9.3.2.3.4","managedObjectClass(3) eventForwardingDiscriminator(4)");
col_set_str(pinfo->cinfo, COL_INFO, "PKIXCMP");
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_cmp);
}
if (pdu_type < 10) {
/* RFC2510 TCP transport */
- ti = proto_tree_add_item(tree, proto_cmp, tvb, offset, 5, FALSE);
+ ti = proto_tree_add_item(tree, proto_cmp, tvb, offset, 5, ENC_NA);
tcptrans_tree = proto_item_add_subtree(ti, ett_cmp);
proto_tree_add_item(tree, hf_cmp_tcptrans_len, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
col_set_str(pinfo->cinfo, COL_INFO, "PKIXCMP");
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_cmp);
}
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
if (parent_tree){
- item = proto_tree_add_item(parent_tree, proto_goose, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_goose, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_goose);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, PNAME);
dissector_handle_t goose_handle;
goose_handle = find_dissector("goose");
-
+
dissector_add_uint("ethertype", ETHERTYPE_IEC61850_GOOSE, goose_handle);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "H.248");
if (tree) {
- h248_item = proto_tree_add_item(tree, proto_h248, tvb, 0, -1, FALSE);
+ h248_item = proto_tree_add_item(tree, proto_h248, tvb, 0, -1, ENC_NA);
h248_tree = proto_item_add_subtree(h248_item, ett_h248);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- ti = proto_tree_add_item(tree, proto_h282, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_h282, tvb, 0, -1, ENC_NA);
h282_tree = proto_item_add_subtree(ti, ett_h282);
return dissect_RDCPDU_PDU(tvb, pinfo, h282_tree);
}
/*--- proto_reg_handoff_h282 -------------------------------------------*/
-void proto_reg_handoff_h282(void)
+void proto_reg_handoff_h282(void)
{
}
#include "packet-h283-ett.c"
/* Subdissectors */
-static dissector_handle_t rdc_pdu_handle;
-static dissector_handle_t rdc_device_list_handle;
-static dissector_handle_t data_handle;
+static dissector_handle_t rdc_pdu_handle;
+static dissector_handle_t rdc_device_list_handle;
+static dissector_handle_t data_handle;
static gboolean info_is_set;
info_is_set = FALSE;
- ti = proto_tree_add_item(tree, proto_h283, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_h283, tvb, 0, -1, ENC_NA);
h283_tree = proto_item_add_subtree(ti, ett_h283);
return dissect_LCTPDU_PDU(tvb, pinfo, h283_tree);
}
/*--- proto_reg_handoff_h283 -------------------------------------------*/
-void proto_reg_handoff_h283(void)
+void proto_reg_handoff_h283(void)
{
- dissector_handle_t h283_udp_handle;
+ dissector_handle_t h283_udp_handle;
h283_udp_handle = find_dissector(PFNAME);
- dissector_add_handle("udp.port", h283_udp_handle);
+ dissector_add_handle("udp.port", h283_udp_handle);
rdc_pdu_handle = find_dissector("rdc");
rdc_device_list_handle = find_dissector("rdc.device_list");
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- ti = proto_tree_add_item(tree, proto_h501, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_h501, tvb, 0, -1, ENC_NA);
h501_tree = proto_item_add_subtree(ti, ett_h501);
return dissect_Message_PDU(tvb, pinfo, h501_tree);
}
/*--- proto_reg_handoff_h501 -------------------------------------------*/
-void proto_reg_handoff_h501(void)
+void proto_reg_handoff_h501(void)
{
static gboolean h501_prefs_initialized = FALSE;
static dissector_handle_t h501_udp_handle;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HNBAP");
/* create the hnbap protocol tree */
- hnbap_item = proto_tree_add_item(tree, proto_hnbap, tvb, 0, -1, FALSE);
+ hnbap_item = proto_tree_add_item(tree, proto_hnbap, tvb, 0, -1, ENC_NA);
hnbap_tree = proto_item_add_subtree(hnbap_item, ett_hnbap);
dissect_HNBAP_PDU_PDU(tvb, pinfo, hnbap_tree);
top_tree=parent_tree;
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_idmp, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_idmp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_idmp);
}
/* create display subtree for the protocol */
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_inap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_inap, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_inap);
}
inap_pdu_type = tvb_get_guint8(tvb, offset)&0x0f;
/* Make wrappers around exported functions for now */
int
dissect_krb5_Checksum(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx _U_)
-{
+{
return dissect_kerberos_Checksum(FALSE, tvb, offset, actx, tree, hf_kerberos_cksum);
-
+
}
int
}
-int
+int
dissect_krb5_cname(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx _U_)
{
return dissect_kerberos_PrincipalName(FALSE, tvb, offset, actx, tree, hf_kerberos_cname);
}
-int
+int
dissect_krb5_realm(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx _U_)
{
return dissect_kerberos_Realm(FALSE, tvb, offset, actx, tree, hf_kerberos_realm);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "KRB5");
}
if (tree) {
- item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, ENC_NA);
kerberos_tree = proto_item_add_subtree(item, ett_kerberos);
}
show_krb_recordmark(kerberos_tree, tvb, offset, krb_rm);
col_clear(pinfo->cinfo, COL_INFO);
}
if (tree) {
- item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, ENC_NA);
kerberos_tree = proto_item_add_subtree(item, ett_kerberos);
}
}
* References:
* ETSI TS 129 171 V9.2.0 (2010-10)
*/
-
+
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
col_set_str(pinfo->cinfo, COL_PROTOCOL, "LCSAP");
/* create the lcsap protocol tree */
- lcsap_item = proto_tree_add_item(tree, proto_lcsap, tvb, 0, -1, FALSE);
+ lcsap_item = proto_tree_add_item(tree, proto_lcsap, tvb, 0, -1, ENC_NA);
lcsap_tree = proto_item_add_subtree(lcsap_item, ett_lcsap);
-
+
dissect_LCS_AP_PDU_PDU(tvb, pinfo, lcsap_tree);
}
if (!Initialized) {
lcsap_handle = find_dissector("lcsap");
-
+
dissector_add_handle("sctp.port", lcsap_handle); /* for "decode-as" */
dissector_add_uint("sctp.ppi", LCS_AP_PAYLOAD_PROTOCOL_ID, lcsap_handle);
Initialized=TRUE;
/* Register dissector tables */
lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC);
-
+
lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
-
+
/* Register configuration options for ports */
lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_DL_CCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_DL_DCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_UL_CCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_UL_DCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_BCCH_BCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
}
-
+
static void
dissect_lte_rrc_BCCH_DL_SCH(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_BCCH_DL_SCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_mms, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_mms, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_mms);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MMS");
/*--- proto_register_mms -------------------------------------------*/
void proto_register_mms(void) {
-
+
/* List of fields */
static hf_register_info hf[] =
{
static gboolean
dissect_mms_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
-{
+{
/* must check that this really is an mms packet */
int offset = 0;
guint32 length = 0 ;
gint8 tmp_class;
gboolean tmp_pc;
gint32 tmp_tag;
-
+
/* first, check do we have at least 2 bytes (pdu) */
if (!tvb_bytes_exist(tvb, 0, 2))
return FALSE; /* no */
-
+
/* can we recognize MMS PDU ? Return FALSE if not */
/* get MMS PDU type */
offset = get_ber_identifier(tvb, offset, &tmp_class, &tmp_pc, &tmp_tag);
-
+
/* check MMS type */
-
- /* Class should be constructed */
+
+ /* Class should be constructed */
if (tmp_class!=BER_CLASS_CON)
return FALSE;
-
+
/* see if the tag is a valid MMS PDU */
match_strval_idx(tmp_tag, mms_MMSpdu_vals, &idx);
- if (idx == -1) {
+ if (idx == -1) {
return FALSE; /* no, it isn't an MMS PDU */
}
-
+
/* check MMS length */
oct = tvb_get_guint8(tvb, offset)& 0x7F;
if (oct==0)
/* MMS requires length after tag so not MMS if indefinite length*/
return FALSE;
-
+
offset = get_ber_length(tvb, offset, &length, NULL);
/* do we have enough bytes? */
if (!tvb_bytes_exist(tvb, offset, length))
- return FALSE;
-
+ return FALSE;
+
dissect_mms(tvb, pinfo, parent_tree);
- return TRUE;
+ return TRUE;
}
/*--- proto_reg_handoff_mms --- */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MPEG");
col_clear(pinfo->cinfo, COL_INFO);
if (tree)
- proto_tree_add_item(tree, proto_mpeg, tvb, 0, -1, FALSE);
+ proto_tree_add_item(tree, proto_mpeg, tvb, 0, -1, ENC_NA);
}
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "NBAP");
/* create the nbap protocol tree */
- nbap_item = proto_tree_add_item(tree, proto_nbap, tvb, 0, -1, FALSE);
+ nbap_item = proto_tree_add_item(tree, proto_nbap, tvb, 0, -1, ENC_NA);
nbap_tree = proto_item_add_subtree(nbap_item, ett_nbap);
-
+
dissect_NBAP_PDU_PDU(tvb, pinfo, nbap_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_nbap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("nbap", dissect_nbap, proto_nbap);
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_ocsp);
}
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_ocsp);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PCAP");
/* create the pcap protocol tree */
- pcap_item = proto_tree_add_item(tree, proto_pcap, tvb, 0, -1, FALSE);
+ pcap_item = proto_tree_add_item(tree, proto_pcap, tvb, 0, -1, ENC_NA);
pcap_tree = proto_item_add_subtree(pcap_item, ett_pcap);
-
+
dissect_PCAP_PDU_PDU(tvb, pinfo, pcap_tree);
}
proto_register_subtree_array(ett, array_length(ett));
pcap_module = prefs_register_protocol(proto_pcap, proto_reg_handoff_pcap);
-
+
/* Register dissector */
register_dissector("pcap", dissect_pcap, proto_pcap);
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_pkixtsp);
}
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_pkixtsp);
}
return offset;
service = get_service(opcode);
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), ENC_NA);
qsig_tree = proto_item_add_subtree(ti, ett_qsig);
proto_tree_add_uint(qsig_tree, hf_qsig_operation, tvb, 0, 0, opcode);
return offset;
service = get_service(opcode);
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), ENC_NA);
qsig_tree = proto_item_add_subtree(ti, ett_qsig);
proto_tree_add_uint(qsig_tree, hf_qsig_operation, tvb, 0, 0, opcode);
if (!err_ptr)
return offset;
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), ENC_NA);
qsig_tree = proto_item_add_subtree(ti, ett_qsig);
proto_tree_add_uint(qsig_tree, hf_qsig_error, tvb, 0, 0, errcode);
offset = 0;
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, -1, ENC_NA);
PROTO_ITEM_SET_HIDDEN(ti);
ie_type = tvb_get_guint8(tvb, offset);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RANAP");
/* create the ranap protocol tree */
- ranap_item = proto_tree_add_item(tree, proto_ranap, tvb, 0, -1, FALSE);
+ ranap_item = proto_tree_add_item(tree, proto_ranap, tvb, 0, -1, ENC_NA);
ranap_tree = proto_item_add_subtree(ranap_item, ett_ranap);
dissect_RANAP_PDU_PDU(tvb, pinfo, ranap_tree);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RRC");
/* create the rrc protocol tree */
- rrc_item = proto_tree_add_item(tree, proto_rrc, tvb, 0, -1, FALSE);
+ rrc_item = proto_tree_add_item(tree, proto_rrc, tvb, 0, -1, ENC_NA);
rrc_tree = proto_item_add_subtree(rrc_item, ett_rrc);
if (rrcinf) {
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RUA");
/* create the rua protocol tree */
- rua_item = proto_tree_add_item(tree, proto_rua, tvb, 0, -1, FALSE);
+ rua_item = proto_tree_add_item(tree, proto_rua, tvb, 0, -1, ENC_NA);
rua_tree = proto_item_add_subtree(rua_item, ett_rua);
-
+
dissect_RUA_PDU_PDU(tvb, pinfo, rua_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_rua, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("rua", dissect_rua, proto_rua);
rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
-
+
rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua);
prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "S1AP");
/* create the s1ap protocol tree */
- s1ap_item = proto_tree_add_item(tree, proto_s1ap, tvb, 0, -1, FALSE);
+ s1ap_item = proto_tree_add_item(tree, proto_s1ap, tvb, 0, -1, ENC_NA);
s1ap_tree = proto_item_add_subtree(s1ap_item, ett_s1ap);
-
+
dissect_S1AP_PDU_PDU(tvb, pinfo, s1ap_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_s1ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("s1ap", dissect_s1ap, proto_s1ap);
s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
-
+
/* Register configuration options for ports */
s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap);
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
/* create the sbap protocol tree */
- sabp_item = proto_tree_add_item(tree, proto_sabp, tvb, 0, -1, FALSE);
+ sabp_item = proto_tree_add_item(tree, proto_sabp, tvb, 0, -1, ENC_NA);
sabp_tree = proto_item_add_subtree(sabp_item, ett_sabp);
dissect_SABP_PDU_PDU(tvb, pinfo, sabp_tree);
return 0;
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_smrse, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_smrse, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_smrse);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SMUX");
if (tree) {
- item = proto_tree_add_item(tree, proto_smux, tvb, 0, -1, ENC_BIG_ENDIAN);
+ item = proto_tree_add_item(tree, proto_smux, tvb, 0, -1, ENC_NA);
smux_tree = proto_item_add_subtree(item, ett_smux);
}
item = proto_tree_add_item(tree, proto_spnego, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
subtree = proto_item_add_subtree(item, ett_spnego);
/*
}
item = proto_tree_add_item(parent_tree, proto_spnego, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
subtree = proto_item_add_subtree(item, ett_spnego);
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
if (parent_tree){
- item = proto_tree_add_item(parent_tree, proto_sv, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_sv, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_sv);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, PNAME);
void register_t124_sd_dissector(packet_info *pinfo _U_, guint32 channelId, dissector_t dissector, int proto)
{
/* XXX: we should keep the sub-dissectors list per conversation
- as the same channels may be used.
+ as the same channels may be used.
While we are just using RDP over T.124, then we can get away with it.
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, "T.125");
col_clear(pinfo->cinfo, COL_INFO);
- item = proto_tree_add_item(parent_tree, proto_t124, tvb, 0, tvb_length(tvb), FALSE);
+ item = proto_tree_add_item(parent_tree, proto_t124, tvb, 0, tvb_length(tvb), ENC_NA);
tree = proto_item_add_subtree(item, ett_t124);
asn1_ctx_init(&asn1_ctx, ASN1_ENC_PER, TRUE, pinfo);
(void) dissect_per_sequence(tvb, 0, &asn1_ctx, NULL, -1, -1, t124Heur_sequence);
- if((t124Identifier != NULL) &&
+ if((t124Identifier != NULL) &&
(strcmp(t124Identifier, "0.0.20.124.0.1") == 0)) {
dissect_t124(tvb, pinfo, parent_tree);
/* suppress some warnings */
warning_suppressor = dissect_t124_GCCPDU;
warning_suppressor = dissect_t124_ConnectMCSPDU;
-
+
}
void
col_set_str(pinfo->cinfo, COL_PROTOCOL, "T.125");
col_clear(pinfo->cinfo, COL_INFO);
- item = proto_tree_add_item(parent_tree, proto_t125, tvb, 0, tvb_length(tvb), FALSE);
+ item = proto_tree_add_item(parent_tree, proto_t125, tvb, 0, tvb_length(tvb), ENC_NA);
tree = proto_item_add_subtree(item, ett_t125);
get_ber_identifier(tvb, 0, &class, &pc, &tag);
/* or PER */
dissect_per_constrained_integer(tvb, 0, &asn1_ctx,
NULL, hf_t125_heur, 0, 42,
- &choice_index, FALSE);
+ &choice_index, FALSE);
/* is this strong enough ? */
if ( ((class==BER_CLASS_APP) && ((tag>=101) && (tag<=104))) ||
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
- * Ref:
+ * Ref:
* 3GPP TS 36.423 V9.2.0 (2010-03)
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, "X2AP");
/* create the x2ap protocol tree */
- x2ap_item = proto_tree_add_item(tree, proto_x2ap, tvb, 0, -1, FALSE);
+ x2ap_item = proto_tree_add_item(tree, proto_x2ap, tvb, 0, -1, ENC_NA);
x2ap_tree = proto_item_add_subtree(x2ap_item, ett_x2ap);
-
+
dissect_X2AP_PDU_PDU(tvb, pinfo, x2ap_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_x2ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("x2ap", dissect_x2ap, proto_x2ap);
proto_tree *tree_2dparityfec = NULL;
gint offset = 0;
- ti = proto_tree_add_item(tree, proto_2dparityfec, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_2dparityfec, tvb, 0, -1, ENC_NA);
tree_2dparityfec = proto_item_add_subtree(ti, ett_2dparityfec);
proto_tree_add_item(tree_2dparityfec, hf_2dparityfec_snbase_low, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2;
if (tree) {
ti = proto_tree_add_item(tree, proto_njack, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
njack_tree = proto_item_add_subtree(ti, ett_njack);
proto_tree_add_item(njack_tree, hf_njack_magic, tvb, offset, 5,
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_3com_xns, tvb, 0, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_3com_xns, tvb, 0, 4, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_3com_xns);
}
};
proto_3com_xns = proto_register_protocol("3Com XNS Encapsulation", "3COMXNS", "3comxns");
- proto_register_field_array(proto_3com_xns, hf, array_length(hf));
+ proto_register_field_array(proto_3com_xns, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
tvb_ip_to_str(tvb, 12));
if (tree) {
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* type */
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
tvb_ip_to_str(tvb, 8));
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
tvb_get_guint8(tvb,3));
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
tvb_ip_to_str(tvb, 8));
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
tvb_get_guint8(tvb,3));
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
tvb_ip_to_str(tvb, 12));
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
tvb_ip_to_str(tvb, 8));
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_a11, tvb, offset, -1, ENC_NA);
a11_tree = proto_item_add_subtree(ti, ett_a11);
/* Type */
if (tree) {
ti = proto_tree_add_item(tree, proto_acap, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
acap_tree = proto_item_add_subtree(ti, ett_acap);
if (is_request) {
if (tree)
{
/* Create our actrace subtree */
- ti = proto_tree_add_item(tree,proto_actrace,tvb,0,-1, FALSE);
+ ti = proto_tree_add_item(tree,proto_actrace,tvb,0,-1, ENC_NA);
actrace_tree = proto_item_add_subtree(ti, ett_actrace);
}
if(!tree)
return;
- /*t_item = proto_tree_add_item(tree, proto_agentx, tvb, 0, -1, FALSE);*/
+ /*t_item = proto_tree_add_item(tree, proto_agentx, tvb, 0, -1, ENC_NA);*/
t_item = proto_tree_add_protocol_format(tree, proto_agentx, tvb, 0, -1,
"Agent Extensibility (AgentX) Protocol: %s, sid=%d, tid=%d, packid=%d, plen=%d",
val_to_str(type, type_values, "unknown"),
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_airopeek, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_airopeek, tvb, 0, -1, ENC_NA);
airopeek_tree = proto_item_add_subtree(ti, ett_airopeek);
proto_tree_add_item(airopeek_tree, hf_airopeek_unknown1, tvb, 0, 2, ENC_NA);
col_set_str(pinfo->cinfo, COL_PROTOCOL, alcap_proto_name_short);
if (tree) {
- proto_item *alcap_item = proto_tree_add_item(tree, proto_alcap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ proto_item *alcap_item = proto_tree_add_item(tree, proto_alcap, tvb, 0, -1, ENC_NA);
alcap_tree = proto_item_add_subtree(alcap_item, ett_alcap);
}
col_append_str(pinfo->cinfo, COL_INFO, strbuf->str);
col_set_fence(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_NA);
amqp_tree = proto_item_add_subtree(ti, ett_amqp_init);
proto_tree_add_item(amqp_tree, hf_amqp_init_protocol, tvb, 0, 4, ENC_ASCII|ENC_NA);
proto_tree_add_item(amqp_tree, hf_amqp_init_id_major, tvb, 4, 1, ENC_BIG_ENDIAN);
}
/* Protocol frame */
- ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_NA);
amqp_tree = proto_item_add_subtree(ti, ett_amqp);
proto_tree_add_item(amqp_tree, hf_amqp_0_10_format, tvb, 0, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(amqp_tree, hf_amqp_0_10_position, tvb, 0, 1, ENC_BIG_ENDIAN);
col_append_str(pinfo->cinfo, COL_INFO, strbuf->str);
col_set_fence(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_NA);
amqp_tree = proto_item_add_subtree(ti, ett_amqp_init);
proto_tree_add_item(amqp_tree, hf_amqp_init_protocol, tvb, 0, 4, ENC_ASCII|ENC_NA);
proto_tree_add_item(amqp_tree, hf_amqp_init_id_major, tvb, 4, 1, ENC_BIG_ENDIAN);
return;
}
- ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_amqp, tvb, 0, -1, ENC_NA);
amqp_tree = proto_item_add_subtree(ti, ett_amqp);
frame_type = tvb_get_guint8(tvb, 0);
proto_tree_add_item(amqp_tree, hf_amqp_0_9_type, tvb, 0, 1, ENC_BIG_ENDIAN);
ti = proto_tree_add_item(amqp_tree, hf_amqp_method_arguments,
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Connection.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Connection.%s",
val_to_str( method_id, amqp_method_connection_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
switch (method_id) {
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Channel.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Channel.%s",
val_to_str( method_id, amqp_method_channel_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
ti = proto_tree_add_item(amqp_tree, hf_amqp_method_arguments,
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Exchange.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Exchange.%s",
val_to_str( method_id, amqp_method_exchange_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
switch (method_id) {
ti = proto_tree_add_item(amqp_tree, hf_amqp_method_arguments,
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Queue.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Queue.%s",
val_to_str( method_id, amqp_method_queue_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Basic.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Basic.%s",
val_to_str( method_id, amqp_method_basic_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "File.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "File.%s",
val_to_str( method_id, amqp_method_file_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Stream.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Stream.%s",
val_to_str( method_id, amqp_method_stream_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Tx.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Tx.%s",
val_to_str( method_id, amqp_method_tx_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
tvb, 11, length - 4, ENC_NA);
args_tree = proto_item_add_subtree(ti, ett_args);
- col_append_fstr(pinfo->cinfo, COL_INFO, "Dtx.%s",
+ col_append_fstr(pinfo->cinfo, COL_INFO, "Dtx.%s",
val_to_str( method_id, amqp_method_dtx_methods, "Unknown (%u)"));
col_set_fence(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_amr, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_amr, tvb, 0, -1, ENC_NA);
amr_tree = proto_item_add_subtree(ti, ett_amr);
proto_tree_add_text(amr_tree, tvb, offset, -1, "Payload decoded as %s",
proto_tree *ancp_tree = NULL;
guint8 byte;
- ti = proto_tree_add_item(tree, proto_ancp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ancp, tvb, 0, -1, ENC_NA);
ancp_tree = proto_item_add_subtree(ti, ett_ancp_len);
seq_num, sender_id, ether_to_str(team_id));
if (tree) {
- ti = proto_tree_add_item(tree, proto_ans, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_ans, tvb, 0, -1, ENC_NA);
ans_tree = proto_item_add_subtree(ti, ett_ans);
proto_tree_add_item(ans_tree, hf_ans_app_id, tvb, 0, 2, ENC_BIG_ENDIAN);
/*
* create the ansi_map protocol tree
*/
- ansi_map_item = proto_tree_add_item(tree, proto_ansi_map, tvb, 0, -1, FALSE);
+ ansi_map_item = proto_tree_add_item(tree, proto_ansi_map, tvb, 0, -1, ENC_NA);
ansi_map_tree = proto_item_add_subtree(ansi_map_item, ett_ansi_map);
ansi_map_is_invoke = FALSE;
is683_ota = FALSE;
/* create display subtree for the protocol */
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_ansi_tcap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_ansi_tcap, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_tcap);
tcap_stat_item=item;
tcap_stat_tree=tree;
static enum_val_t ansi_tcap_response_matching_type_values[] = {
{"Only Transaction ID will be used in Invoke/response matching", "Transaction ID only", 0},
- {"Transaction ID and Source will be used in Invoke/response matching", "Transaction ID and Source", 1},
+ {"Transaction ID and Source will be used in Invoke/response matching", "Transaction ID and Source", 1},
{"Transaction ID Source and Destination will be used in Invoke/response matching", "Transaction ID Source and Destination", 2},
{NULL, NULL, -1}
};
col_clear(pinfo->cinfo, COL_INFO);
if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_aoe, tvb, 0, -1, ENC_BIG_ENDIAN);
+ item = proto_tree_add_item(parent_tree, proto_aoe, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_aoe);
}
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
proto_item *ti;
asn1_ctx_t asn1_ctx;
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
-
+
col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "(application/pkix-cert)");
if (tree) {
- ti = proto_tree_add_item(tree, proto_cert, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cert, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_cert);
}
proto_cert = proto_register_protocol(
"PKIX CERT File Format",
"PKIX Certificate",
- "pkix-cert"
+ "pkix-cert"
);
/* Required function calls to register the header fields
if ( tree ) {
proto_item *ti;
- ti = proto_tree_add_item( tree, proto_applemidi, tvb, 0, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_applemidi, tvb, 0, -1, ENC_NA );
applemidi_tree = proto_item_add_subtree( ti, ett_applemidi );
proto_tree_add_item( applemidi_tree, hf_applemidi_signature, tvb, offset, 2, ENC_BIG_ENDIAN );
SET_ADDRESS(&pinfo->dl_dst, AT_ARCNET, 1, tvb_get_ptr(tvb, 1, 1));
SET_ADDRESS(&pinfo->dst, AT_ARCNET, 1, tvb_get_ptr(tvb, 1, 1));
- ti = proto_tree_add_item (tree, proto_arcnet, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_arcnet, tvb, 0, -1, ENC_NA);
arcnet_tree = proto_item_add_subtree (ti, ett_arcnet);
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_armagetronad, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_armagetronad, tvb, 0, -1, ENC_NA);
armagetronad_tree = proto_item_add_subtree(ti, ett_armagetronad);
/* For each message in the frame */
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_artnet, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_artnet, tvb, offset, -1, ENC_NA);
artnet_tree = proto_item_add_subtree(ti, ett_artnet);
hi = proto_tree_add_item(artnet_tree,
if (tree) {
- ti = proto_tree_add_item(tree, proto_aruba_adp, tvb, 0, 0, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_aruba_adp, tvb, 0, 0, ENC_NA);
aruba_adp_tree = proto_item_add_subtree(ti, ett_aruba_adp);
proto_tree_add_item(aruba_adp_tree, hf_adp_version, tvb, 0, 2, ENC_BIG_ENDIAN);
col_set_str(pinfo->cinfo, COL_INFO, PROTO_SHORT_NAME ":");
if (tree) {
- ti = proto_tree_add_item(tree, proto_aruba_erm, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_aruba_erm, tvb, 0, -1, ENC_NA);
aruba_erm_tree = proto_item_add_subtree(ti, ett_aruba_erm);
ts.secs = tvb_get_ntohl(tvb, 0);
if (tree) {
- ti = proto_tree_add_item(tree, proto_papi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_papi, tvb, 0, -1, ENC_NA);
papi_tree = proto_item_add_subtree(ti, ett_papi);
val_to_str(type, asf_type_vals, "Unknown (0x%02x)"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_asf, tvb, 0, 8,ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_asf, tvb, 0, 8,ENC_NA);
asf_tree = proto_item_add_subtree(ti, ett_asf);
proto_tree_add_item(asf_tree, hf_asf_iana, tvb, 0, 4,ENC_BIG_ENDIAN);
proto_tree_add_item(asf_tree, hf_asf_type, tvb, 4, 1,ENC_BIG_ENDIAN);
if (tree)
{
- r3_item = proto_tree_add_item (tree, proto_r3, tvb, 0, -1, TRUE);
+ r3_item = proto_tree_add_item (tree, proto_r3, tvb, 0, -1, ENC_NA);
r3_tree = proto_item_add_subtree (r3_item, ett_r3);
}
val_to_str(function, rtmp_function_vals, "Unknown function (%02x)"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_rtmp, tvb, 0, 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rtmp, tvb, 0, 1, ENC_NA);
rtmp_tree = proto_item_add_subtree(ti, ett_rtmp);
proto_tree_add_uint(rtmp_tree, hf_rtmp_function, tvb, 0, 1, function);
net, nodelen_bits, node);
if (tree) {
- ti = proto_tree_add_item(tree, proto_rtmp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rtmp, tvb, offset, -1, ENC_NA);
rtmp_tree = proto_item_add_subtree(ti, ett_rtmp);
proto_tree_add_uint(rtmp_tree, hf_rtmp_net, tvb, offset, 2, net);
val_to_str(op, nbp_op_vals, "Unknown (0x%01x)"), count);
if (tree) {
- ti = proto_tree_add_item(tree, proto_nbp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_nbp, tvb, offset, -1, ENC_NA);
nbp_tree = proto_item_add_subtree(ti, ett_nbp);
info_item = proto_tree_add_uint_format(nbp_tree, hf_nbp_info, tvb, offset, 1,
col_append_str(pinfo->cinfo, COL_INFO, " [fragment]");
if (tree) {
- ti = proto_tree_add_item(tree, proto_atp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_atp, tvb, offset, -1, ENC_NA);
atp_tree = proto_item_add_subtree(ti, ett_atp);
proto_item_set_len(atp_tree, aspinfo.release?8:ATP_HDRSIZE -1);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_pap, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_pap, tvb, offset, -1, ENC_NA);
pap_tree = proto_item_add_subtree(ti, ett_pap);
}
val_to_str_ext(fn, &asp_func_vals_ext, "Unknown (0x%01x)"), aspinfo->seq);
if (tree) {
- ti = proto_tree_add_item(tree, proto_asp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_asp, tvb, offset, -1, ENC_NA);
asp_tree = proto_item_add_subtree(ti, ett_asp);
}
if (!aspinfo->reply) {
if (!tree)
return;
- ti = proto_tree_add_item(tree, proto_zip, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_zip, tvb, offset, -1, ENC_NA);
zip_tree = proto_item_add_subtree(ti, ett_zip);
if (!aspinfo->reply) {
if (!tree)
return;
- ti = proto_tree_add_item(tree, proto_zip, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_zip, tvb, 0, -1, ENC_NA);
zip_tree = proto_item_add_subtree(ti, ett_zip);
proto_tree_add_item(zip_tree, hf_zip_function, tvb, offset, 1,ENC_BIG_ENDIAN);
if (tree) {
ti = proto_tree_add_item(tree, proto_ddp, tvb, 0, DDP_SHORT_HEADER_SIZE,
- ENC_BIG_ENDIAN);
+ ENC_NA);
ddp_tree = proto_item_add_subtree(ti, ett_ddp);
}
len = tvb_get_ntohs(tvb, 0);
if (tree) {
ti = proto_tree_add_item(tree, proto_ddp, tvb, 0, DDP_HEADER_SIZE,
- ENC_BIG_ENDIAN);
+ ENC_NA);
ddp_tree = proto_item_add_subtree(ti, ett_ddp);
hidden_item = proto_tree_add_string(ddp_tree, hf_ddp_src, tvb,
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_llap, tvb, 0, 3, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_llap, tvb, 0, 3, ENC_NA);
llap_tree = proto_item_add_subtree(ti, ett_llap);
}
case AAL_1:
col_set_str(pinfo->cinfo, COL_PROTOCOL, "AAL1");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_aal1, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_aal1, tvb, offset, -1, ENC_NA);
aal_tree = proto_item_add_subtree(ti, ett_aal1);
octet = tvb_get_guint8(tvb, offset);
proto_tree_add_text(aal_tree, tvb, offset, 1, "CSI: %u", octet >> 7);
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, "AAL3/4");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_aal3_4, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_aal3_4, tvb, offset, -1, ENC_NA);
aal_tree = proto_item_add_subtree(ti, ett_aal3_4);
aal3_4_hdr = tvb_get_ntohs(tvb, offset);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s, sequence number = %u",
col_set_str(pinfo->cinfo, COL_PROTOCOL, "OAM AAL");
col_clear(pinfo->cinfo, COL_INFO);
}
- ti = proto_tree_add_item(tree, proto_oamaal, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_oamaal, tvb, offset, -1, ENC_NA);
aal_tree = proto_item_add_subtree(ti, ett_oamaal);
octet = tvb_get_guint8(tvb, offset);
if (NULL == pwpd || pwpd->enable_fill_columns_by_atm_dissector)
}
if (tree) {
- atm_ti = proto_tree_add_item(tree, proto_atm, tvb, 0, -1, ENC_BIG_ENDIAN);
+ atm_ti = proto_tree_add_item(tree, proto_atm, tvb, 0, -1, ENC_NA);
atm_tree = proto_item_add_subtree(atm_ti, ett_atm);
if (!pseudowire_mode) {
guint16 holdtime;
offset = 0;
- ti = proto_tree_add_item(tree, proto_auto_rp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_auto_rp, tvb, offset, -1, ENC_NA);
auto_rp_tree = proto_item_add_subtree(ti, ett_auto_rp);
tv = proto_tree_add_text(auto_rp_tree, tvb, offset, 1, "Version: %s, Packet type: %s",
{
proto_item *ti;
proto_tree *ax4000_tree;
-
+
guint8 ax_port;
guint8 ax_chassis;
guint16 ax_index;
ax_index = tvb_get_ntohs(tvb, 2) & 0x0FFF;
ax_timestamp = tvb_get_letohl(tvb, 6);
ax_seq = tvb_get_letohl(tvb, 10);
-
+
col_append_fstr(pinfo->cinfo, COL_INFO,
"Chss:%u Prt:%u Idx:%u Seq:0x%08x TS:%.6f[msec]",
ax_chassis, ax_port, ax_index, ax_seq, ax_timestamp*1e-5);
-
+
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_ax4000, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ax4000, tvb, 0, -1, ENC_NA);
ax4000_tree = proto_item_add_subtree(ti, ett_ax4000);
case 7: /* buffer-ready */
/* deprecated
- while ((tvb_reported_length_remaining(tvb, offset) > 0)&&(offset>lastoffset)) {
+ while ((tvb_reported_length_remaining(tvb, offset) > 0)&&(offset>lastoffset)) {
lastoffset = offset;
switch (fTagNo(tvb, offset)) {
case 0:
default:
break;
}
-
+
/* Closing tag for parameter choice */
offset += fTagHeaderTree(tvb, subtree, offset, &tag_no, &tag_info, &lvt);
return offset;
save_fragmented = pinfo->fragmented;
- ti = proto_tree_add_item(tree, proto_bacapp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bacapp, tvb, offset, -1, ENC_NA);
bacapp_tree = proto_item_add_subtree(ti, ett_bacapp);
if (!fragment)
i = 0;
/* I don't know the length of the NPDU yet; Setting the length after dissection */
- ti = proto_tree_add_item(tree, proto_bacnet, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bacnet, tvb, 0, -1, ENC_NA);
bacnet_tree = proto_item_add_subtree(ti, ett_bacnet);
if (tree) {
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_banana, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_banana, tvb, 0, -1, ENC_NA);
banana_tree = proto_item_add_subtree(ti, ett_banana);
offset = 0;
"B.A.T.M.A.N., Orig: %s (%s)",
get_hostname(orig), ip_to_str(batman_packeth->orig.data));
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE, ENC_NA);
}
bat_batman_tree = proto_item_add_subtree(ti, ett_bat_batman);
}
"B.A.T.M.A.N. HNA: %s/%d",
tvb_ip_to_str(tvb, 0), hna_netmask);
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 5, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 5, ENC_NA);
}
bat_batman_hna_tree = proto_item_add_subtree(ti, ett_bat_batman_hna);
"B.A.T.M.A.N. GW [%s]",
val_to_str(gw_packeth->type, gw_packettypenames, "Unknown (0x%02x)"));
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 1, ENC_NA);
}
bat_gw_entry_tree = proto_item_add_subtree(ti, ett_bat_gw);
"B.A.T.M.A.N. Vis, Src: %s (%s)",
get_hostname(sender_ip), ip_to_str(vis_packeth->sender_ip.data));
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, VIS_PACKET_V22_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, VIS_PACKET_V22_SIZE, ENC_NA);
}
bat_vis_tree = proto_item_add_subtree(ti, ett_bat_vis);
val_to_str(vis_datah->type, vis_packettypenames, "Unknown (0x%02x)"),
get_hostname(ip), ip_to_str(vis_datah->ip.data));
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 7, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 7, ENC_NA);
}
bat_vis_entry_tree = proto_item_add_subtree(ti, ett_bat_vis_entry);
"B.A.T.M.A.N. Vis, Src: %s (%s)",
get_hostname(sender_ip), ip_to_str(vis_packeth->sender_ip.data));
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, VIS_PACKET_V23_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, VIS_PACKET_V23_SIZE, ENC_NA);
}
bat_vis_tree = proto_item_add_subtree(ti, ett_bat_vis);
val_to_str(vis_datah->type, vis_packettypenames, "Unknown (0x%02x)"),
get_hostname(ip), ip_to_str(vis_datah->ip.data));
} else {
- ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 7, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 7, ENC_NA);
}
bat_vis_entry_tree = proto_item_add_subtree(ti, ett_bat_vis_entry);
"B.A.T.M.A.N., Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE, ENC_NA);
}
batadv_batman_tree = proto_item_add_subtree(ti, ett_batadv_batman);
}
"B.A.T.M.A.N., Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V7_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V7_SIZE, ENC_NA);
}
batadv_batman_tree = proto_item_add_subtree(ti, ett_batadv_batman);
}
"B.A.T.M.A.N., Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V9_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V9_SIZE, ENC_NA);
}
batadv_batman_tree = proto_item_add_subtree(ti, ett_batadv_batman);
}
"B.A.T.M.A.N., Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V10_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V10_SIZE, ENC_NA);
}
batadv_batman_tree = proto_item_add_subtree(ti, ett_batadv_batman);
}
"B.A.T.M.A.N., Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V11_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V11_SIZE, ENC_NA);
}
batadv_batman_tree = proto_item_add_subtree(ti, ett_batadv_batman);
}
"B.A.T.M.A.N., Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, offset, BATMAN_PACKET_V14_SIZE, ENC_NA);
}
batadv_batman_tree = proto_item_add_subtree(ti, ett_batadv_batman);
}
"B.A.T.M.A.N. TT: %s (%s)",
get_ether_name(tt), ether_to_str(tt));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, 6, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, 6, ENC_NA);
}
batadv_batman_tt_tree = proto_item_add_subtree(ti, ett_batadv_batman_tt);
}
"B.A.T.M.A.N. Bcast, Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, BCAST_PACKET_V6_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, BCAST_PACKET_V6_SIZE, ENC_NA);
}
batadv_bcast_tree = proto_item_add_subtree(ti, ett_batadv_bcast);
}
"B.A.T.M.A.N. Bcast, Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, BCAST_PACKET_V10_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, BCAST_PACKET_V10_SIZE, ENC_NA);
}
batadv_bcast_tree = proto_item_add_subtree(ti, ett_batadv_bcast);
}
"B.A.T.M.A.N. Bcast, Orig: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, BCAST_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, BCAST_PACKET_V14_SIZE, ENC_NA);
}
batadv_bcast_tree = proto_item_add_subtree(ti, ett_batadv_bcast);
}
"B.A.T.M.A.N. ICMP, Orig: %s (%s), Dst: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr), get_ether_name(dst_addr), ether_to_str(dst_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ICMP_PACKET_V6_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ICMP_PACKET_V6_SIZE, ENC_NA);
}
batadv_icmp_tree = proto_item_add_subtree(ti, ett_batadv_icmp);
}
"B.A.T.M.A.N. ICMP, Orig: %s (%s), Dst: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr), get_ether_name(dst_addr), ether_to_str(dst_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ICMP_PACKET_V7_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ICMP_PACKET_V7_SIZE, ENC_NA);
}
batadv_icmp_tree = proto_item_add_subtree(ti, ett_batadv_icmp);
}
"B.A.T.M.A.N. ICMP, Orig: %s (%s), Dst: %s (%s)",
get_ether_name(orig_addr), ether_to_str(orig_addr), get_ether_name(dst_addr), ether_to_str(dst_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ICMP_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ICMP_PACKET_V14_SIZE, ENC_NA);
}
batadv_icmp_tree = proto_item_add_subtree(ti, ett_batadv_icmp);
}
"B.A.T.M.A.N. Unicast, Dst: %s (%s)",
get_ether_name(dest_addr), ether_to_str(dest_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_PACKET_V6_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_PACKET_V6_SIZE, ENC_NA);
}
batadv_unicast_tree = proto_item_add_subtree(ti, ett_batadv_unicast);
}
"B.A.T.M.A.N. Unicast, Dst: %s (%s)",
get_ether_name(dest_addr), ether_to_str(dest_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_PACKET_V14_SIZE, ENC_NA);
}
batadv_unicast_tree = proto_item_add_subtree(ti, ett_batadv_unicast);
}
"B.A.T.M.A.N. Unicast Fragment, Dst: %s (%s)",
get_ether_name(dest_addr), ether_to_str(dest_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_FRAG_PACKET_V12_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_FRAG_PACKET_V12_SIZE, ENC_NA);
}
batadv_unicast_frag_tree = proto_item_add_subtree(ti, ett_batadv_unicast_frag);
}
"B.A.T.M.A.N. Unicast Fragment, Dst: %s (%s)",
get_ether_name(dest_addr), ether_to_str(dest_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_FRAG_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, UNICAST_FRAG_PACKET_V14_SIZE, ENC_NA);
}
batadv_unicast_frag_tree = proto_item_add_subtree(ti, ett_batadv_unicast_frag);
}
"B.A.T.M.A.N. Vis, Orig: %s (%s)",
get_ether_name(vis_orig_addr), ether_to_str(vis_orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_PACKET_V6_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_PACKET_V6_SIZE, ENC_NA);
}
batadv_vis_tree = proto_item_add_subtree(ti, ett_batadv_vis);
}
"B.A.T.M.A.N. Vis, Orig: %s (%s)",
get_ether_name(vis_orig_addr), ether_to_str(vis_orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_PACKET_V10_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_PACKET_V10_SIZE, ENC_NA);
}
batadv_vis_tree = proto_item_add_subtree(ti, ett_batadv_vis);
}
"B.A.T.M.A.N. Vis, Orig: %s (%s)",
get_ether_name(vis_orig_addr), ether_to_str(vis_orig_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_PACKET_V14_SIZE, ENC_NA);
}
batadv_vis_tree = proto_item_add_subtree(ti, ett_batadv_vis);
}
"VIS Entry: %s (%s)",
get_ether_name(dst), ether_to_str(dst));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_ENTRY_V6_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_ENTRY_V6_SIZE, ENC_NA);
}
batadv_vis_entry_tree = proto_item_add_subtree(ti, ett_batadv_vis_entry);
}
"VIS Entry: %s (%s)",
get_ether_name(dst), ether_to_str(dst));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_ENTRY_V8_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, VIS_ENTRY_V8_SIZE, ENC_NA);
}
batadv_vis_entry_tree = proto_item_add_subtree(ti, ett_batadv_vis_entry);
}
"B.A.T.M.A.N. TT Query, Dst: %s (%s)",
get_ether_name(dst_addr), ether_to_str(dst_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, TT_QUERY_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, TT_QUERY_PACKET_V14_SIZE, ENC_NA);
}
batadv_tt_query_tree = proto_item_add_subtree(ti, ett_batadv_tt_query);
}
"TT Entry: %s (%s)",
get_ether_name(entry), ether_to_str(entry));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, TT_ENTRY_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, TT_ENTRY_V14_SIZE, ENC_NA);
}
batadv_tt_entry_tree = proto_item_add_subtree(ti, ett_batadv_tt_entry);
}
"B.A.T.M.A.N. Roam: %s (%s)",
get_ether_name(client_addr), ether_to_str(client_addr));
} else {
- ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ROAM_ADV_PACKET_V14_SIZE, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_batadv_plugin, tvb, 0, ROAM_ADV_PACKET_V14_SIZE, ENC_NA);
}
batadv_roam_adv_tree = proto_item_add_subtree(ti, ett_batadv_roam_adv);
}
*
* Ref ITU-T Rec. Q.1990 (07/2001)
*/
-
+
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
static void dissect_bctp(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree) {
- proto_item* pi = proto_tree_add_item(tree, proto_bctp, tvb,0,2, FALSE);
+ proto_item* pi = proto_tree_add_item(tree, proto_bctp, tvb,0,2, ENC_NA);
proto_tree* pt = proto_item_add_subtree(pi,ett_bctp);
tvbuff_t* sub_tvb = tvb_new_subset_remaining(tvb, 2);
guint8 tpi = tvb_get_guint8(tvb,1) & 0x3f;
-
+
proto_tree_add_item(pt, hf_bctp_bvei, tvb,0,2, ENC_BIG_ENDIAN);
proto_tree_add_item(pt, hf_bctp_bvi, tvb,0,2, ENC_BIG_ENDIAN);
proto_tree_add_item(pt, hf_bctp_tpei, tvb,0,2, ENC_BIG_ENDIAN);
proto_tree_add_item(pt, hf_bctp_tpi, tvb,0,2, ENC_BIG_ENDIAN);
-
+
if ( dissector_try_uint(bctp_dissector_table, tpi, sub_tvb, pinfo, tree) ) {
return;
} else if (tpi <= 0x22) {
/* "tvb_format_text()" is passed a value that won't go past the end
- * of the packet, so it won't throw an exception.
+ * of the packet, so it won't throw an exception.
*/
col_add_str(pinfo->cinfo, COL_INFO, tvb_format_text(tvb, offset, tvb_length_remaining(tvb, offset)));
if (tree) { /* Build the tree info ... */
- ti = proto_tree_add_item(tree, proto_beep, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_beep, tvb, offset, -1, ENC_NA);
beep_tree = proto_item_add_subtree(ti, ett_beep);
* Detect IPv4 prefixes conform to BGP Additional Path but NOT conform to standard BGP
*
* A real BGP speaker would rely on the BGP Additional Path in the BGP Open messages.
- * But it is not suitable for a packet analyse because the BGP sessions are not supposed to
+ * But it is not suitable for a packet analyse because the BGP sessions are not supposed to
* restart very often, and Open messages from both sides of the session would be needed
* to determine the result of the capability negociation.
* Code inspired from the decode_prefix4 function
plen = tvb_get_ntohs(tvb,offset);
rd_type=tvb_get_ntohs(tvb,offset+2);
- /* RFC6074 Section 7 BGP-AD and VPLS-BGP Interoperability
+ /* RFC6074 Section 7 BGP-AD and VPLS-BGP Interoperability
Both BGP-AD and VPLS-BGP [RFC4761] use the same AFI/SAFI. In order
for both BGP-AD and VPLS-BGP to co-exist, the NLRI length must be
used as a demultiplexer.
if( detect_add_path_prefix4(tvb, o, end) ) {
/* IPv4 prefixes with Path Id */
while (o < end) {
- i = decode_path_prefix4(subtree, hf_bgp_nlri_path_id, hf_bgp_withdrawn_prefix, tvb, o,
+ i = decode_path_prefix4(subtree, hf_bgp_nlri_path_id, hf_bgp_withdrawn_prefix, tvb, o,
"Withdrawn route");
if (i < 0)
return;
length = tvb_get_guint8(tvb, k++);
/* Check for invalid ASN */
- for (d = 0; d < length; d++)
+ for (d = 0; d < length; d++)
{
if(tvb_get_ntohs(tvb, k) == 0)
asn_is_null = 1;
k += 2;
}
- }
+ }
if(k != end || unknown_segment_type || asn_is_null)
asn_len = 4;
}
if( detect_add_path_prefix4(tvb, o, end) ) {
/* IPv4 prefixes with Path Id */
while (o < end) {
- i = decode_path_prefix4(subtree, hf_bgp_nlri_path_id, hf_bgp_nlri_prefix, tvb, o,
+ i = decode_path_prefix4(subtree, hf_bgp_nlri_path_id, hf_bgp_nlri_prefix, tvb, o,
"NLRI");
if (i < 0)
return;
col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", typ);
if (tree) {
- ti = proto_tree_add_item(tree, proto_bgp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bgp, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, " - %s", typ);
/* add a different tree for each message type */
* If we skipped any bytes, mark it as a BGP continuation.
*/
if (offset > 0) {
- ti = proto_tree_add_item(tree, proto_bgp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bgp, tvb, 0, -1, ENC_NA);
bgp_tree = proto_item_add_subtree(ti, ett_bgp);
proto_tree_add_text(bgp_tree, tvb, 0, offset, "Continuation");
col_set_str(pinfo->cinfo, COL_INFO, "BitTorrent ");
- ti = proto_tree_add_item (tree, proto_bittorrent, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_bittorrent, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(ti, ett_bittorrent);
if (tvb_get_guint8(tvb, 0) == 19 &&
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_bofl, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bofl, tvb, 0, -1, ENC_NA);
bofl_tree = proto_item_add_subtree(ti, ett_bofl);
}
* OK, now build the protocol tree.
*/
- ti = proto_tree_add_item(tree, proto_bootp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bootp, tvb, 0, -1, ENC_NA);
bp_tree = proto_item_add_subtree(ti, ett_bootp);
proto_tree_add_uint(bp_tree, hf_bootp_type, tvb,
if (tree) { /* we are being asked for details */
/* Here we add our tree/subtree so we can have a collapsible branch. */
- brp_item = proto_tree_add_item( tree, proto_brp, tvb, 0, -1, ENC_BIG_ENDIAN );
+ brp_item = proto_tree_add_item( tree, proto_brp, tvb, 0, -1, ENC_NA );
brp_tree = proto_item_add_subtree( brp_item, ett_brp);
/* We use tvb_get_guint8 to get our type value out. */
proto_brp = proto_register_protocol ("BRP Protocol", "BRP", "brp");
proto_register_field_array (proto_brp, hf, array_length (hf));
proto_register_subtree_array (ett, array_length (ett));
-
+
/* Register preferences module */
brp_module = prefs_register_protocol(proto_brp, proto_reg_handoff_brp);
/*
* create the bssap protocol tree
*/
- hidden_item = proto_tree_add_item(tree, proto_bssap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ hidden_item = proto_tree_add_item(tree, proto_bssap, tvb, 0, -1, ENC_NA);
PROTO_ITEM_SET_HIDDEN(hidden_item);
bssap_item = proto_tree_add_text(tree, tvb, 0, -1, (bssap_or_bsap_global == BSSAP) ? "BSSAP" : "BSAP");
bssap_tree = proto_item_add_subtree(bssap_item, ett_bssap);
pinfo->sccp_info->data.co.assoc->payload = SCCP_PLOAD_BSSAP;
/* create the BSSAP+ protocol tree */
- bssap_item = proto_tree_add_item(tree, proto_bssap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ bssap_item = proto_tree_add_item(tree, proto_bssap, tvb, 0, -1, ENC_NA);
bssap_tree = proto_item_add_subtree(bssap_item, ett_bssap);
message_type = tvb_get_guint8(tvb,offset);
if(tree)
{
proto_item *ti;
- ti = proto_tree_add_item(tree, proto_bt_utp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bt_utp, tvb, 0, -1, ENC_NA);
sub_tree = proto_item_add_subtree(ti, ett_bt_utp);
}
}
if(tree){
- ti=proto_tree_add_item(tree, proto_btamp, tvb, offset, -1, FALSE);
+ ti=proto_tree_add_item(tree, proto_btamp, tvb, offset, -1, ENC_NA);
btamp_tree=proto_item_add_subtree(ti, ett_btamp);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HCI_ACL");
if(tree){
- ti=proto_tree_add_item(tree, proto_btacl, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti=proto_tree_add_item(tree, proto_btacl, tvb, offset, -1, ENC_NA);
btacl_tree = proto_item_add_subtree(ti, ett_btacl);
}
proto_tree *opcode_tree;
if(tree){
- ti_cmd = proto_tree_add_item(tree, proto_bthci_cmd, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti_cmd = proto_tree_add_item(tree, proto_bthci_cmd, tvb, offset, -1, ENC_NA);
bthci_cmd_tree = proto_item_add_subtree(ti_cmd, ett_bthci_cmd);
}
int offset=0;
if(tree){
- ti=proto_tree_add_item(tree, proto_bthci_evt, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti=proto_tree_add_item(tree, proto_bthci_evt, tvb, offset, -1, ENC_NA);
bthci_evt_tree=proto_item_add_subtree(ti, ett_bthci_evt);
}
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
/* Code to actually dissect the packets */
-static void
+static void
dissect_btsco(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item *ti;
proto_tree *btsco_tree;
int offset=0;
- ti = proto_tree_add_item(tree, proto_btsco, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_btsco, tvb, offset, -1, ENC_NA);
btsco_tree = proto_item_add_subtree(ti, ett_btsco);
-
+
proto_tree_add_item(btsco_tree, hf_btsco_chandle, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset+=2;
void
proto_register_btsco(void)
-{
+{
static hf_register_info hf[] = {
{ &hf_btsco_chandle,
{ "Connection Handle", "bthci_sco.chandle",
- FT_UINT16, BASE_HEX, NULL, 0x0FFF,
+ FT_UINT16, BASE_HEX, NULL, 0x0FFF,
NULL, HFILL }
},
{ &hf_btsco_length,
{ "Data Total Length", "bthci_sco.length",
- FT_UINT8, BASE_DEC, NULL, 0x0,
+ FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btsco_data,
{ "Data", "bthci_sco.data",
- FT_NONE, BASE_NONE, NULL, 0x0,
+ FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
};
}
-void
+void
proto_reg_handoff_btsco(void)
{
dissector_handle_t bthci_sco_handle;
}
if(tree){
- ti=proto_tree_add_item(tree, proto_btl2cap, tvb, offset, -1, FALSE);
+ ti=proto_tree_add_item(tree, proto_btl2cap, tvb, offset, -1, ENC_NA);
btl2cap_tree=proto_item_add_subtree(ti, ett_btl2cap);
}
/* fully dissectable packet ready */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "OBEX");
- ti = proto_tree_add_item(tree, proto_btobex, next_tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_btobex, next_tvb, 0, -1, ENC_NA);
st = proto_item_add_subtree(ti, ett_btobex);
/* op/response code */
guint16 frame_len;
dlci_state_t *dlci_state = NULL;
- ti = proto_tree_add_item(tree, proto_btrfcomm, tvb, offset, -1, ENC_LITTLE_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_btrfcomm, tvb, offset, -1, ENC_NA);
rfcomm_tree = proto_item_add_subtree(ti, ett_btrfcomm);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RFCOMM");
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HANDSFREE");
- ti = proto_tree_add_item(tree, proto_bthf, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_bthf, tvb, 0, -1, ENC_NA);
st = proto_item_add_subtree(ti, ett_bthf);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s \"%s\"",
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DUN");
- ti = proto_tree_add_item(tree, proto_btdun, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_btdun, tvb, 0, -1, ENC_NA);
st = proto_item_add_subtree(ti, ett_btdun);
is_at_cmd = TRUE;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SPP");
- ti = proto_tree_add_item(tree, proto_btspp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_btspp, tvb, 0, -1, ENC_NA);
st = proto_item_add_subtree(ti, ett_btspp);
length = MIN(length,60);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SDP");
- ti = proto_tree_add_item(tree, proto_btsdp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_btsdp, tvb, 0, -1, ENC_NA);
st = proto_item_add_subtree(ti, ett_btsdp);
/* pdu id */
return tvb_reported_length(tvb); /* XXX - reject? */
}
ti = proto_tree_add_item(tree, proto_bvlc, tvb, 0,
- bvlc_length, FALSE);
+ bvlc_length, ENC_NA);
bvlc_tree = proto_item_add_subtree(ti, ett_bvlc);
proto_tree_add_uint(bvlc_tree, hf_bvlc_type, tvb, offset, 1,
bvlc_type);
offset ++;
if (length_remaining != packet_length)
proto_tree_add_uint_format_value(bvlc_tree, hf_bvlc_length, tvb, offset,
- 2, bvlc_length,
+ 2, bvlc_length,
"%d of %d bytes (invalid length - expected %d bytes)",
bvlc_length, packet_length, length_remaining);
- else
+ else
proto_tree_add_uint_format_value(bvlc_tree, hf_bvlc_length, tvb, offset,
2, bvlc_length, "%d of %d bytes BACnet packet length",
bvlc_length, packet_length);
case 0x03: /* Read-Broadcast-Distribution-Table-Ack */
/* List of BDT Entries: N*10-octet */
ti_bdt = proto_tree_add_item(bvlc_tree, proto_bvlc, tvb,
- offset, bvlc_length-4, FALSE);
+ offset, bvlc_length-4, ENC_NA);
bdt_tree = proto_item_add_subtree(ti_bdt, ett_bdt);
/* List of BDT Entries: N*10-octet */
while ((bvlc_length - offset) > 9) {
* the registrant's FDT entry if no re-registration occurs.
*/
ti_fdt = proto_tree_add_item(bvlc_tree, proto_bvlc, tvb,
- offset, bvlc_length -4, FALSE);
+ offset, bvlc_length -4, ENC_NA);
fdt_tree = proto_item_add_subtree(ti_fdt, ett_fdt);
/* List of FDT Entries: N*10-octet */
while ((bvlc_length - offset) > 9) {
static gboolean bvlc_initialized = FALSE;
static dissector_handle_t bvlc_handle;
static guint additional_bvlc_udp_port;
-
+
if (!bvlc_initialized)
{
bvlc_handle = find_dissector("bvlc");
necessary to generate protocol tree items. */
if (tree) {
/* create the calcappprotocol protocol tree */
- calcappprotocol_item = proto_tree_add_item(tree, proto_calcappprotocol, message_tvb, 0, -1, ENC_BIG_ENDIAN);
+ calcappprotocol_item = proto_tree_add_item(tree, proto_calcappprotocol, message_tvb, 0, -1, ENC_NA);
calcappprotocol_tree = proto_item_add_subtree(calcappprotocol_item, ett_calcappprotocol);
} else {
calcappprotocol_tree = NULL;
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
* References: ETSI 300 374
*/
-/*
- * Indentation logic: this file is indented with 2 spaces indentation.
+/*
+ * Indentation logic: this file is indented with 2 spaces indentation.
* there are no tabs.
*/
#ifdef HAVE_CONFIG_H
/* ROSE context */
static rose_ctx_t camel_rose_ctx;
-static int hf_digit = -1;
+static int hf_digit = -1;
static int hf_camel_extension_code_local = -1;
static int hf_camel_error_code_local = -1;
static int hf_camel_cause_indicator = -1;
{ 12, "spare"},
{ 13, "spare"},
{ 0, NULL}};
-
-
+
+
static const value_string camel_nature_of_addr_indicator_values[] = {
{ 0x00, "unknown" },
{ 0x01, "International Number" },
/*
* 24.011 8.2.5.4
- */
+ */
static guint8
dissect_RP_cause_ie(tvbuff_t *tvb, guint32 offset, _U_ guint len,
proto_tree *tree, int hf_cause_value, guint8 *cause_value)
guint8 oct;
guint32 curr_offset;
static char a_bigbuf[1024];
-
+
curr_offset = offset;
oct = tvb_get_guint8(tvb, curr_offset);
- *cause_value = oct & 0x7f;
-
+ *cause_value = oct & 0x7f;
+
other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
proto_tree_add_uint_format(tree, hf_cause_value,
tvb, curr_offset, 1, *cause_value,
"%s : %s",
a_bigbuf,
- val_to_str(*cause_value, camel_RP_Cause_values,
+ val_to_str(*cause_value, camel_RP_Cause_values,
"Unknown Cause (%u), treated as (41) \"Temporary failure\" for MO-SMS or (111) \"Protocol error,unspecified\" for MT-SMS"));
curr_offset++;
-
+
if ((oct & 0x80)) {
oct = tvb_get_guint8(tvb, curr_offset);
proto_tree_add_uint_format(tree, hf_cause_value,
opcode = 0;
application_context_version = 0;
if (actx->pinfo->private_data != NULL){
- p_private_tcap=actx->pinfo->private_data;
-
+ p_private_tcap=actx->pinfo->private_data;
+
if (p_private_tcap->acv==TRUE ){
version_ptr = strrchr(p_private_tcap->oid,'.');
if (version_ptr)
application_context_version = atoi(version_ptr+1);
}
- gp_camelsrt_info->tcap_context=p_private_tcap->context;
+ gp_camelsrt_info->tcap_context=p_private_tcap->context;
if (p_private_tcap->context)
gp_camelsrt_info->tcap_session_id
/* create display subtree for the protocol */
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_camel, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_camel, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_camel);
}
/* camelsrt reset counter, and initialise global pointer
to store service response time related data */
gp_camelsrt_info=camelsrt_razinfo();
dissect_camel_camelPDU(FALSE, tvb, 0, &asn1_ctx , tree, -1);
-
+
/* If a Tcap context is associated to this transaction */
if (gcamel_HandleSRT &&
gp_camelsrt_info->tcap_context ) {
register_ber_oid_dissector_handle("0.4.0.0.1.21.3.61",camel_handle, proto_camel, "cap3-sms-AC" );
register_ber_oid_dissector_handle("0.4.0.0.1.23.3.4",camel_handle, proto_camel, "capssf-scfGenericAC" );
register_ber_oid_dissector_handle("0.4.0.0.1.23.3.61",camel_handle, proto_camel, "cap4-sms-AC" );
-
+
/*--- Included file: packet-camel-dis-tab.c ---*/
ssn_range = range_copy(global_ssn_range);
range_foreach(ssn_range, range_add_callback);
-
+
}
void proto_register_camel(void) {
{ "RP Cause", "camel.RP_Cause",
FT_UINT8, BASE_DEC, NULL, 0,
"RP Cause Value", HFILL }},
-
+
{ &hf_camel_CAMEL_AChBillingChargingCharacteristics,
{ "CAMEL-AChBillingChargingCharacteristics", "camel.CAMEL_AChBillingChargingCharacteristics",
FT_UINT32, BASE_DEC, VALS(camel_CAMEL_AChBillingChargingCharacteristics_vals), 0,
- NULL, HFILL }},
-
+ NULL, HFILL }},
+
{ &hf_camel_CAMEL_FCIBillingChargingCharacteristics,
{ "CAMEL-FCIBillingChargingCharacteristics", "camel.CAMEL_FCIBillingChargingCharacteristics",
FT_UINT32, BASE_DEC, VALS(camel_CAMEL_FCIBillingChargingCharacteristics_vals), 0,
rose_ctx_init(&camel_rose_ctx);
/* Register dissector tables */
- camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg",
- "CAMEL Operation Argument (local opcode)",
- FT_UINT32, BASE_HEX);
- camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res",
- "CAMEL Operation Result (local opcode)",
- FT_UINT32, BASE_HEX);
- camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err",
- "CAMEL Error (local opcode)",
- FT_UINT32, BASE_HEX);
+ camel_rose_ctx.arg_local_dissector_table = register_dissector_table("camel.ros.local.arg",
+ "CAMEL Operation Argument (local opcode)",
+ FT_UINT32, BASE_HEX);
+ camel_rose_ctx.res_local_dissector_table = register_dissector_table("camel.ros.local.res",
+ "CAMEL Operation Result (local opcode)",
+ FT_UINT32, BASE_HEX);
+ camel_rose_ctx.err_local_dissector_table = register_dissector_table("camel.ros.local.err",
+ "CAMEL Error (local opcode)",
+ FT_UINT32, BASE_HEX);
/* Register our configuration options, particularly our ssn:s */
/* Set default SSNs */
prefs_register_enum_preference(camel_module, "date.format", "Date Format",
"The date format: (DD/MM) or (MM/DD)",
&date_format, date_options, FALSE);
-
-
+
+
prefs_register_range_preference(camel_module, "tcap.ssn",
"TCAP SSNs",
"TCAP Subsystem numbers used for Camel",
"Persistent stats for SRT",
"Statistics for Response Time",
&gcamel_PersistentSRT);
-
- /* Routine for statistic */
+
+ /* Routine for statistic */
register_init_routine(&camelsrt_init_routine);
camel_tap=register_tap(PSNAME);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "CAPWAP");
col_set_str(pinfo->cinfo, COL_INFO, "CAPWAP-Control");
- ti = proto_tree_add_item(tree, proto_capwap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_capwap, tvb, 0, -1, ENC_NA);
capwap_control_tree = proto_item_add_subtree(ti, ett_capwap);
/* CAPWAP Preamble */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "CAPWAP");
col_set_str(pinfo->cinfo, COL_INFO, "CAPWAP-Data");
- ti = proto_tree_add_item(tree, proto_capwap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_capwap, tvb, 0, -1, ENC_NA);
capwap_data_tree = proto_item_add_subtree(ti, ett_capwap);
/* CAPWAP Preamble */
/* In the interest of speed, if "tree" is NULL, don't do any work not
* necessary to generate protocol tree items. */
if (tree) {
- ti = proto_tree_add_item(tree, proto_cast, tvb, offset, hdr_data_length+8, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cast, tvb, offset, hdr_data_length+8, ENC_NA);
cast_tree = proto_item_add_subtree(ti, ett_cast);
proto_tree_add_uint(cast_tree, hf_cast_data_length, tvb, offset, 4, hdr_data_length);
proto_tree_add_uint(cast_tree, hf_cast_reserved, tvb, offset+4, 4, hdr_marker);
/* Create root (protocol) tree. */
if (tree) {
- ti = proto_tree_add_item(tree, proto_catapult_dct2000, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_catapult_dct2000, tvb, offset, -1, ENC_NA);
dct2000_tree = proto_item_add_subtree(ti, ett_catapult_dct2000);
}
else
length = ccsds_length;
- ccsds_packet = proto_tree_add_item(tree, proto_ccsds, tvb, 0, length, FALSE);
+ ccsds_packet = proto_tree_add_item(tree, proto_ccsds, tvb, 0, length, ENC_NA);
ccsds_tree = proto_item_add_subtree(ccsds_packet, ett_ccsds);
/* build the ccsds primary header tree */
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cdp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_cdp, tvb, offset, -1, ENC_NA);
cdp_tree = proto_item_add_subtree(ti, ett_cdp);
/* CDP header */
proto_tree *cfm_tree;
/* isolate the payload of the packet */
- ti = proto_tree_add_item(tree, proto_cfm, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cfm, tvb, 0, -1, ENC_NA);
/* report type of CFM packet to base of dissection tree */
if (tree) {
ti = proto_tree_add_item(tree, proto_cgmp, tvb, offset, -1,
- FALSE);
+ ENC_NA);
cgmp_tree = proto_item_add_subtree(ti, ett_cgmp);
proto_tree_add_item(cgmp_tree, hf_cgmp_version, tvb, offset, 1,
proto = tvb_get_ntohs(tvb, 2);
if (tree) {
- ti = proto_tree_add_item(tree, proto_chdlc, tvb, 0, 4, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_chdlc, tvb, 0, 4, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_chdlc);
proto_tree_add_uint(fh_tree, hf_chdlc_addr, tvb, 0, 1, addr);
code = tvb_get_ntohl(tvb, 0);
if (tree) {
- ti = proto_tree_add_item(tree, proto_slarp, tvb, 0, 14, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_slarp, tvb, 0, 14, ENC_NA);
slarp_tree = proto_item_add_subtree(ti, ett_slarp);
}
if (tree)
{
/* create display subtree for the protocol */
- cimd_item = proto_tree_add_item(tree, proto_cimd, tvb, 0, etxp + 1, ENC_LITTLE_ENDIAN);
+ cimd_item = proto_tree_add_item(tree, proto_cimd, tvb, 0, etxp + 1, ENC_NA);
cimd_tree = proto_item_add_subtree(cimd_item, ett_cimd);
proto_tree_add_uint(cimd_tree, hf_cimd_opcode_indicator, tvb, CIMD_OC_OFFSET, CIMD_OC_LENGTH, OC);
proto_tree_add_uint(cimd_tree, hf_cimd_packet_number_indicator, tvb, CIMD_PN_OFFSET, CIMD_PN_LENGTH, PN);
mstp_frame_source, mstp_frame_destination,
mstp_frame_type_text(mstp_frame_type));
#else
- ti = proto_tree_add_item(tree, proto_cimetrics_mstp, tvb, offset, 9, FALSE);
+ ti = proto_tree_add_item(tree, proto_cimetrics_mstp, tvb, offset, 9, ENC_NA);
#endif
subtree = proto_item_add_subtree(ti, ett_cimetrics_mstp);
proto_tree_add_item(subtree, hf_cimetrics_mstp_timer, tvb,
register_dissector("cimetrics", dissect_cimetrics_mstp,
proto_cimetrics_mstp);
-
+
llc_add_oui(OUI_CIMETRICS, "llc.cimetrics_pid",
"Cimetrics OUI PID", hf2);
}
if( tree )
{
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_cip_class_generic, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cip_class_generic, tvb, 0, -1, ENC_NA);
class_tree = proto_item_add_subtree( ti, ett_cip_class_generic );
dissect_cip_generic_data( class_tree, tvb, 0, tvb_length(tvb), pinfo, ti );
if( tree )
{
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_cip_class_mr, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cip_class_mr, tvb, 0, -1, ENC_NA);
class_tree = proto_item_add_subtree( ti, ett_cip_class_mr );
dissect_cip_mr_data( class_tree, tvb, 0, tvb_length(tvb), pinfo );
if( tree )
{
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_cip_class_cm, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cip_class_cm, tvb, 0, -1, ENC_NA);
class_tree = proto_item_add_subtree( ti, ett_cip_class_cm );
dissect_cip_cm_data( class_tree, tvb, 0, tvb_length(tvb), pinfo );
if( tree )
{
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_cip_class_cco, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cip_class_cco, tvb, 0, -1, ENC_NA);
class_tree = proto_item_add_subtree( ti, ett_cip_class_cco );
dissect_cip_cco_data( class_tree, tvb, 0, tvb_length(tvb), pinfo );
p_add_proto_data(pinfo->fd, proto_cip, preq_info);
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(item_tree, proto_cip, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(item_tree, proto_cip, tvb, 0, -1, ENC_NA);
cip_tree = proto_item_add_subtree( ti, ett_cip );
/* Add Service code & Request/Response tree */
/* Create display subtree for the protocol by creating an item and then
* creating a subtree from the item, the subtree must have been registered
* in proto_register_cipmotion already */
- proto_item_top = proto_tree_add_item( tree, proto_cipmotion, tvb, 0, -1, ENC_LITTLE_ENDIAN );
+ proto_item_top = proto_tree_add_item( tree, proto_cipmotion, tvb, 0, -1, ENC_NA );
proto_tree_top = proto_item_add_subtree( proto_item_top, ett_cipmotion );
/* Add the CIP class 1 sequence number to the tree */
* 0000030: 1002 0001 0000 0380 <-- ERSPAN header (01: erspan-id)
* 0000040: 00d0 b7a7 7480 0015 c721 75c0 0800 4500 <-- Ethernet packet
* ...
- *
+ *
*
*/
if (tree) {
ti = proto_tree_add_item(tree, proto_erspan, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
erspan_tree = proto_item_add_subtree(ti, ett_erspan);
version = tvb_get_ntohs(tvb, offset) >> 12;
col_add_fstr(pinfo->cinfo, COL_INFO, "Cisco SM Packet (%s)",
val_to_str(sm_message_type, sm_message_type_value_info,"reserved"));
- ti = proto_tree_add_item(tree, proto_sm, tvb, offset, 0, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_sm, tvb, offset, 0, ENC_NA);
sm_tree = proto_item_add_subtree(ti, ett_sm);
proto_tree_add_uint_format(sm_tree, hf_sm_sm_msg_type, tvb, offset, 4, sm_message_type,
cwids_tree = NULL;
while(tvb_length_remaining(tvb, offset) > 0) {
- ti = proto_tree_add_item(tree, proto_cwids, tvb, offset, 28, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cwids, tvb, offset, 28, ENC_NA);
cwids_tree = proto_item_add_subtree(ti, ett_cwids);
proto_tree_add_item(cwids_tree, hf_cwids_version, tvb, offset, 2, ENC_BIG_ENDIAN);
if (tree) {
guint transaction_id_first_word;
- ti = proto_tree_add_item(tree, proto_classicstun, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_classicstun, tvb, 0, -1, ENC_NA);
classicstun_tree = proto_item_add_subtree(ti, ett_classicstun);
if (cnf_proto_id == NLPID_NULL) {
col_set_str(pinfo->cinfo, COL_INFO, "Inactive subset");
if (tree) {
- ti = proto_tree_add_item(tree, proto_clnp, tvb, P_CLNP_PROTO_ID, 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_clnp, tvb, P_CLNP_PROTO_ID, 1, ENC_NA);
clnp_tree = proto_item_add_subtree(ti, ett_clnp);
proto_tree_add_uint_format(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
cnf_proto_id,
opt_len = cnf_hdr_len;
if (tree) {
- ti = proto_tree_add_item(tree, proto_clnp, tvb, 0, cnf_hdr_len, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_clnp, tvb, 0, cnf_hdr_len, ENC_NA);
clnp_tree = proto_item_add_subtree(ti, ett_clnp);
proto_tree_add_uint(clnp_tree, hf_clnp_id, tvb, P_CLNP_PROTO_ID, 1,
cnf_proto_id);
}
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_cmip, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_cmip, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_cmip);
}
register_ber_oid_dissector("2.9.0.0.2", dissect_cmip, proto_cmip, "cmip");
register_ber_oid_dissector("2.9.1.1.4", dissect_cmip, proto_cmip, "joint-iso-itu-t(2) ms(9) cmip(1) cmip-pci(1) abstractSyntax(4)");
- oid_add_from_string("2.9.3.2.3.1","managedObjectClass(3) alarmRecord(1)");
+ oid_add_from_string("2.9.3.2.3.1","managedObjectClass(3) alarmRecord(1)");
oid_add_from_string("2.9.3.2.3.2","managedObjectClass(3) attributeValueChangeRecord(2)");
oid_add_from_string("2.9.3.2.3.3","managedObjectClass(3) discriminator(3)");
oid_add_from_string("2.9.3.2.3.4","managedObjectClass(3) eventForwardingDiscriminator(4)");
col_set_str(pinfo->cinfo, COL_INFO, "PKIXCMP");
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_cmp);
}
if (pdu_type < 10) {
/* RFC2510 TCP transport */
- ti = proto_tree_add_item(tree, proto_cmp, tvb, offset, 5, FALSE);
+ ti = proto_tree_add_item(tree, proto_cmp, tvb, offset, 5, ENC_NA);
tcptrans_tree = proto_item_add_subtree(ti, ett_cmp);
proto_tree_add_item(tree, hf_cmp_tcptrans_len, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
col_set_str(pinfo->cinfo, COL_INFO, "PKIXCMP");
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_cmp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_cmp);
}
if (tree)
{
- ti = proto_tree_add_item(tree, proto_cmpp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cmpp, tvb, 0, -1, ENC_NA);
cmpp_tree = proto_item_add_subtree(ti, ett_cmpp);
offset = 0;
/* Take whole packet for now, we'll adjust it later */
- ti = proto_tree_add_item(tree, proto_cnip, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cnip, tvb, offset, -1, ENC_NA);
cnip_tree = proto_item_add_subtree(ti, ett_cnip);
proto_tree_add_item(cnip_tree, hf_cnip_len, tvb, offset, 2, ENC_BIG_ENDIAN);
coap_content_type = NULL;
coap_content_type_value = ~0;
- coap_root = proto_tree_add_item(parent_tree, proto_coap, tvb, offset, -1, FALSE);
+ coap_root = proto_tree_add_item(parent_tree, proto_coap, tvb, offset, -1, ENC_NA);
coap_tree = proto_item_add_subtree(coap_root, ett_coap);
proto_tree_add_item(coap_tree, hf_coap_version, tvb, offset, 1, ENC_BIG_ENDIAN);
size = tvb_reported_length(tvb);
/* create the collectd protocol tree */
- pi = proto_tree_add_item(tree, proto_collectd, tvb, 0, -1, FALSE);
+ pi = proto_tree_add_item(tree, proto_collectd, tvb, 0, -1, ENC_NA);
collectd_tree = proto_item_add_subtree(pi, ett_collectd);
memset (&tap_data, 0, sizeof (tap_data));
association_item = proto_tree_add_text(message_tree, message_tvb, offset, COMPONENTASSOCIATION_LENGTH,
"Association #%d", i++);
association_tree = proto_item_add_subtree(association_item, ett_association);
- association_tvb = tvb_new_subset(message_tvb, offset,
+ association_tvb = tvb_new_subset(message_tvb, offset,
MIN(COMPONENTASSOCIATION_LENGTH, tvb_length_remaining(message_tvb, offset)),
COMPONENTASSOCIATION_LENGTH);
necessary to generate protocol tree items. */
if (tree) {
/* create the componentstatusprotocol protocol tree */
- componentstatusprotocol_item = proto_tree_add_item(tree, proto_componentstatusprotocol, message_tvb, 0, -1, ENC_BIG_ENDIAN);
+ componentstatusprotocol_item = proto_tree_add_item(tree, proto_componentstatusprotocol, message_tvb, 0, -1, ENC_NA);
componentstatusprotocol_tree = proto_item_add_subtree(componentstatusprotocol_item, ett_componentstatusprotocol);
} else {
componentstatusprotocol_tree = NULL;
guint8 ver_flags;
gint garbage;
- ti = proto_tree_add_item(tree, proto_cops, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_cops, tvb, offset, -1, ENC_NA);
cops_tree = proto_item_add_subtree(ti, ett_cops);
/* Version and flags share the same byte, put them in a subtree */
necessary to generate protocol tree items. */
if (tree) {
/* create the protocol tree */
- cpfi_item = proto_tree_add_item(tree, proto_cpfi, message_tvb, 0, -1, ENC_BIG_ENDIAN);
+ cpfi_item = proto_tree_add_item(tree, proto_cpfi, message_tvb, 0, -1, ENC_NA);
cpfi_tree = proto_item_add_subtree(cpfi_item, ett_cpfi);
}
hdr.ha_protocol_ver, opcode2str_short(opcode));
if (tree) {
- ti = proto_tree_add_item(tree, proto_cphap, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cphap, tvb, offset, -1, ENC_NA);
cpha_tree = proto_item_add_subtree(ti, ett_cphap);
}
if (tree) {
if (tree) {
- ti = proto_tree_add_item(tree, proto_csm_encaps, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_csm_encaps, tvb, 0, -1, ENC_NA);
csm_encaps_tree = proto_item_add_subtree(ti, ett_csm_encaps);
if (tree) {
ti = proto_tree_add_item(tree, proto_cups, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
cups_tree = proto_item_add_subtree(ti, ett_cups);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_daap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_daap, tvb, 0, -1, ENC_NA);
daap_tree = proto_item_add_subtree(ti, ett_daap);
dissect_daap_one_tag(daap_tree, tvb);
}
offset += 8;
- len = reported_length - offset; /* should be >= 0 since no exception above */
+ len = reported_length - offset; /* should be >= 0 since no exception above */
DISSECTOR_ASSERT(len >= 0);
if (tagsize <= (unsigned)len) {
len = tagsize;
/* now playing */
/* bytes 4-7 contain uint32 playlist id */
/* bytes 12-15 contain uint32 track id */
- proto_item_append_text(ti,
+ proto_item_append_text(ti,
"; unknown: %d, playlist id: %d, unknown: %d, track id: %d",
tvb_get_ntohl(tvb, offset),
tvb_get_ntohl(tvb, offset+4),
daap_handle = create_dissector_handle(dissect_daap, proto_daap);
http_dissector_add(TCP_PORT_DAAP, daap_handle);
-
+
png_handle = find_dissector("png");
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_daytime, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_daytime, tvb, 0, -1, ENC_NA);
daytime_tree = proto_item_add_subtree(ti, ett_daytime);
proto_tree_add_text(daytime_tree, tvb, 0, 0,
col_set_str (pinfo->cinfo, COL_PROTOCOL, PSNAME_DISC);
col_set_str (pinfo->cinfo, COL_INFO, PNAME_DISC);
- db_lsp_item = proto_tree_add_item (tree, proto_db_lsp_disc, tvb, offset, -1, ENC_BIG_ENDIAN);
+ db_lsp_item = proto_tree_add_item (tree, proto_db_lsp_disc, tvb, offset, -1, ENC_NA);
db_lsp_tree = proto_item_add_subtree (db_lsp_item, ett_db_lsp);
proto_tree_add_item (db_lsp_tree, hf_text, tvb, offset, -1, ENC_ASCII|ENC_NA);
if (tree) {
ti = proto_tree_add_item(tree, proto_dcc, tvb, offset, -1,
- FALSE);
+ ENC_NA);
dcc_tree = proto_item_add_subtree(ti, ett_dcc);
proto_tree_add_item(dcc_tree, hf_dcc_len, tvb,
val_to_str(dccph->type, dccp_packet_type_vals, "Unknown Type"),
dccph->seq);
} else {
- dccp_item = proto_tree_add_item(tree, proto_dccp, tvb, offset, 8, ENC_BIG_ENDIAN);
+ dccp_item = proto_tree_add_item(tree, proto_dccp, tvb, offset, 8, ENC_NA);
}
dccp_tree = proto_item_add_subtree(dccp_item, ett_dccp);
offset = start_offset;
tvb_ensure_bytes_exist(tvb, offset, 16);
if (tree) {
- ti = proto_tree_add_item (tree, proto_dcerpc, tvb, offset, hdr.frag_len, FALSE);
+ ti = proto_tree_add_item (tree, proto_dcerpc, tvb, offset, hdr.frag_len, ENC_NA);
dcerpc_tree = proto_item_add_subtree (ti, ett_dcerpc);
}
hdr.serial_lo = tvb_get_guint8 (tvb, offset++);
if (tree) {
- ti = proto_tree_add_item (tree, proto_dcerpc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_dcerpc, tvb, 0, -1, ENC_NA);
if (ti) {
dcerpc_tree = proto_item_add_subtree(ti, ett_dcerpc);
proto_item_append_text(ti, " %s, Seq: %u, Serial: %u, Frag: %u, FragLen: %u",
return offset;
}
- dcm_pitem = proto_tree_add_item(tree, proto_dcm, tvb, offset, -1, FALSE);
+ dcm_pitem = proto_tree_add_item(tree, proto_dcm, tvb, offset, -1, ENC_NA);
dcm_ptree = proto_item_add_subtree(dcm_pitem, ett_dcm);
pdu_type = tvb_get_guint8(tvb, offset);
if(tree) {
proto_item *ti = NULL;
- ti = proto_tree_add_item (tree, proto_dcp_etsi, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_dcp_etsi, tvb, 0, -1, ENC_NA);
dcp_tree = proto_item_add_subtree (ti, ett_edcp);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DCP-PFT");
if (tree) { /* we are being asked for details */
- ti = proto_tree_add_item (tree, proto_pft, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_pft, tvb, 0, -1, ENC_NA);
pft_tree = proto_item_add_subtree (ti, ett_pft);
proto_tree_add_item (pft_tree, hf_edcp_sync, tvb, offset, 2, ENC_ASCII|ENC_NA);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DCP-AF");
if (tree) { /* we are being asked for details */
- ti = proto_tree_add_item (tree, proto_af, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_af, tvb, 0, -1, ENC_NA);
af_tree = proto_item_add_subtree (ti, ett_af);
proto_tree_add_item (af_tree, hf_edcp_sync, tvb, offset, 2, ENC_ASCII|ENC_NA);
}
if(tree) {
proto_item *ti = NULL;
- ti = proto_tree_add_item (tree, proto_tpl, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_tpl, tvb, 0, -1, ENC_NA);
tpl_tree = proto_item_add_subtree (ti, ett_tpl);
}
while(offset<tvb_length(tvb)) {
col_clear (pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_ddtp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ddtp, tvb, 0, -1, ENC_NA);
ddtp_tree = proto_item_add_subtree(ti, ett_ddtp);
proto_tree_add_item(ddtp_tree, hf_ddtp_version, tvb, 0, 4, ENC_BIG_ENDIAN);
if (tree) {
ti = proto_tree_add_item(tree, proto_dec_bpdu, tvb, 0, DEC_BPDU_SIZE,
- ENC_BIG_ENDIAN);
+ ENC_NA);
bpdu_tree = proto_item_add_subtree(ti, ett_dec_bpdu);
proto_tree_add_item(bpdu_tree, hf_dec_bpdu_proto_id, tvb,
offset += 2;
msg_flags = tvb_get_guint8(tvb, offset);
ti = proto_tree_add_item(tree, proto_dec_rt, tvb, 0, -1,
- TRUE);
+ ENC_NA);
rt_tree = proto_item_add_subtree(ti, ett_dec_rt);
/* When padding, the first byte after the padding has
the real routing flags */
return;
}
- ti=proto_tree_add_item(tree, proto_dect, tvb, 0, -1, FALSE);
+ ti=proto_tree_add_item(tree, proto_dect, tvb, 0, -1, ENC_NA);
DectTree=proto_item_add_subtree(ti, ett_dect);
proto_tree_add_item(DectTree, hf_dect_transceivermode, tvb, offset, 1, ENC_BIG_ENDIAN);
length = tvb_get_ntohs(tvb, offset);
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_dhcpfo, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_dhcpfo, tvb, 0, -1, ENC_NA);
dhcpfo_tree = proto_item_add_subtree(ti, ett_dhcpfo);
col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str(msgtype, msgtype_vals, "Message Type %u"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_dhcpv6, tvb, off, eoff - off, FALSE);
+ ti = proto_tree_add_item(tree, proto_dhcpv6, tvb, off, eoff - off, ENC_NA);
bp_tree = proto_item_add_subtree(ti, ett_dhcpv6);
}
pd_save = pinfo->private_data;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DIAMETER");
- pi = proto_tree_add_item(tree,proto_diameter,tvb,0,-1,FALSE);
+ pi = proto_tree_add_item(tree,proto_diameter,tvb,0,-1,ENC_NA);
diam_tree = proto_item_add_subtree(pi,ett_diameter);
c->tree = diam_tree;
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
static int
dissect_distcc_argv(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, gint parameter)
{
- char argv[256];
+ char argv[256];
int argv_len;
gint len=parameter;
static int
dissect_distcc_serr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, gint parameter)
{
- char argv[256];
+ char argv[256];
int argv_len;
gint len=parameter;
static int
dissect_distcc_sout(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, gint parameter)
{
- char argv[256];
+ char argv[256];
int argv_len;
gint len=parameter;
proto_item *item=NULL;
char token[4];
guint32 parameter;
-
+
col_set_str(pinfo->cinfo, COL_PROTOCOL, "DISTCC ");
if (parent_tree) {
item = proto_tree_add_item(parent_tree, proto_distcc, tvb, offset,
- -1, ENC_BIG_ENDIAN);
+ -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_distcc);
}
while(1){
- /* we must have at least 12 bytes so we can read the
+ /* we must have at least 12 bytes so we can read the
token and the parameter */
if(tvb_length_remaining(tvb, offset)<12){
return;
} else {
call_dissector(data_handle, tvb, pinfo, tree);
return;
- }
+ }
}
offset = 0;
item = proto_tree_add_item(parent_tree, proto_dlm3, tvb, offset,
- -1, ENC_LITTLE_ENDIAN);
+ -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_dlm3);
sub_item = proto_tree_add_uint(tree,
if (tree)
{
- ti = proto_tree_add_item(tree, proto_dlsw, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_dlsw, tvb, 0, -1, ENC_NA);
dlsw_tree = proto_item_add_subtree(ti, ett_dlsw);
hlen=tvb_get_guint8(tvb,1);
col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "len=%u, %s", dl_len, func_code_str);
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_dnp3, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_dnp3, tvb, offset, -1, ENC_NA);
dnp3_tree = proto_item_add_subtree(ti, ett_dnp3);
/* Create Subtree for Data Link Layer */
proto_tree *dplay_data = NULL;
gint offset = 0;
- dplay_item = proto_tree_add_item(tree, proto_dplay, tvb, 0, -1, ENC_BIG_ENDIAN);
+ dplay_item = proto_tree_add_item(tree, proto_dplay, tvb, 0, -1, ENC_NA);
dplay_tree = proto_item_add_subtree(dplay_item, ett_dplay);
header_item = proto_tree_add_text(dplay_tree, tvb, offset, DPLAY_HEADER_OFFSET, "DirectPlay header");
dplay_header = proto_item_add_subtree(header_item, ett_dplay_header);
proto_tree *data_tree = NULL;
gint offset = 0;
- dplay_item = proto_tree_add_item(tree, proto_dplay, tvb, offset, -1, ENC_BIG_ENDIAN);
+ dplay_item = proto_tree_add_item(tree, proto_dplay, tvb, offset, -1, ENC_NA);
dplay_tree = proto_item_add_subtree(dplay_item, ett_dplay);
data_item = proto_tree_add_text(dplay_tree, tvb, offset, -1, "Message content");
data_tree = proto_item_add_subtree(data_item, ett_dplay_data);
col_set_str(pinfo->cinfo, COL_DEF_SRC, uton?"TE":"NT");
col_set_str(pinfo->cinfo, COL_DEF_DST, uton?"NT":"TE");
- item = proto_tree_add_item(tree, proto_dpnss_link, tvb, 0, -1, ENC_BIG_ENDIAN);
+ 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);
if (tree) {
- ti = proto_tree_add_item(tree, proto_dsi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_dsi, tvb, 0, -1, ENC_NA);
dsi_tree = proto_item_add_subtree(ti, ett_dsi);
proto_tree_add_uint(dsi_tree, hf_dsi_flags, tvb,
/* Create display subtree for SSL as a whole */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_dtls, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_dtls, tvb, 0, -1, ENC_NA);
dtls_tree = proto_item_add_subtree(ti, ett_dtls);
}
more_frags = TRUE;
}
ci = proto_tree_add_item(tree, proto_tcp_conv, tvb,
- frame_offset, -1, FALSE);
+ frame_offset, -1, ENC_NA);
conv_proto_tree = proto_item_add_subtree(ci, ett_tcp_conv);
dissect_tcp_convergence_data_header(tvb, conv_proto_tree);
proto_item *ti;
ti = proto_tree_add_item(tree, proto_bundle, tvb,
- frame_offset, -1, FALSE);
+ frame_offset, -1, ENC_NA);
bundle_tree = proto_item_add_subtree(ti, ett_bundle);
new_tvb = process_reassembled_data(tvb,
frame_offset + convergence_hdr_size,
if(frame_offset == 0) {
ci = proto_tree_add_item(tree, proto_tcp_conv, tvb,
- frame_offset, -1, FALSE);
+ frame_offset, -1, ENC_NA);
conv_proto_tree = proto_item_add_subtree(ci, ett_tcp_conv);
}
/* Clear out stuff in the info column */
col_clear(pinfo->cinfo,COL_INFO);
- ti = proto_tree_add_item(tree, proto_bundle, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bundle, tvb, 0, -1, ENC_NA);
bundle_tree = proto_item_add_subtree(ti, ett_bundle);
primary_item = proto_tree_add_text(bundle_tree, tvb, 0, -1,
timestamp_sequence = evaluate_sdnv(tvb, offset, &sdnv_length);
timestamp_sequence_item = proto_tree_add_text(admin_record_tree, tvb, offset, sdnv_length, " ");
-
+
if(timestamp_sequence < 0) {
gint64 ts_seq;
timestamp_sequence = evaluate_sdnv(tvb, offset, &sdnv_length);
timestamp_sequence_item = proto_tree_add_text(admin_record_tree, tvb, offset, sdnv_length, " ");
-
+
if(timestamp_sequence < 0) {
gint64 ts_seq;
col_set_str(pinfo->cinfo, COL_INFO, "Dynamic Trunking Protocol");
if (tree) {
- ti = proto_tree_add_item(tree, proto_dtp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_dtp, tvb, offset, -1, ENC_NA);
dtp_tree = proto_item_add_subtree(ti, ett_dtp);
}
type = tvb_get_ntohs(tvb, offset);
length = tvb_get_ntohs(tvb, offset + 2);
valuelength = (length-4);
-
+
/* make sure still in valid tlv */
if ((valuelength < 1) || ( length > tvb_length_remaining(tvb, offset) ))
break;
- ti = proto_tree_add_text(dtp_tree, tvb, offset, length, "%s",
+ ti = proto_tree_add_text(dtp_tree, tvb, offset, length, "%s",
val_to_str(type, dtp_tlv_type_vals, "Unknown TLV type: 0x%02x"));
tlv_tree = proto_item_add_subtree(ti, ett_dtp_tlv);
{
static hf_register_info hf[] = {
{ &hf_dtp_version,
- { "Version", "dtp.version", FT_UINT8, BASE_HEX,
+ { "Version", "dtp.version", FT_UINT8, BASE_HEX,
NULL, 0x0, NULL, HFILL }},
{ &hf_dtp_tlvtype,
- { "Type", "dtp.tlv_type", FT_UINT16, BASE_HEX,
+ { "Type", "dtp.tlv_type", FT_UINT16, BASE_HEX,
VALS(dtp_tlv_type_vals), 0x0, NULL, HFILL }},
{ &hf_dtp_tlvlength,
- { "Length", "dtp.tlv_len", FT_UINT16, BASE_DEC,
+ { "Length", "dtp.tlv_len", FT_UINT16, BASE_DEC,
NULL, 0x0, NULL, HFILL }},
{ &hf_dtp_some_mac,
- { "Neighbor", "dtp.neighbor", FT_ETHER, BASE_NONE,
+ { "Neighbor", "dtp.neighbor", FT_ETHER, BASE_NONE,
NULL, 0x0, "MAC Address of neighbor", HFILL }},
};
if (tree) {
dtpt_item = proto_tree_add_item(tree, proto_dtpt,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
if (dtpt_item)
dtpt_tree = proto_item_add_subtree(dtpt_item, ett_dtpt);
}
if (tree) {
dtpt_item = proto_tree_add_item(tree, proto_dtpt,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
if (dtpt_item)
dtpt_tree = proto_item_add_subtree(dtpt_item, ett_dtpt);
}
tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
- while ((tvb_reported_length_remaining(tvb, offset)>=4)
- && (neighbor_count>0)) {
+ while ((tvb_reported_length_remaining(tvb, offset)>=4)
+ && (neighbor_count>0)) {
proto_tree_add_item(parent_tree, hf_neighbor,
tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
return offset+tvb_length_remaining(tvb, offset);
}
- item = proto_tree_add_item(parent_tree, proto_dvmrp, tvb, offset, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_dvmrp, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_dvmrp);
proto_item *ti = NULL;
proto_tree *e100_tree = NULL;
- ti = proto_tree_add_item(tree, proto_e100, tvb, 0, e100_encap_len, FALSE);
+ ti = proto_tree_add_item(tree, proto_e100, tvb, 0, e100_encap_len, ENC_NA);
e100_tree = proto_item_add_subtree(ti, ett_e100);
proto_tree_add_item(e100_tree, hf_e100_header, tvb,
/* OpCode (1 byte), MS-CHAPv2-ID (1 byte), MS-Length (2 bytes), Data */
opcode = tvb_get_guint8(tvb, offset);
proto_tree_add_text(eap_tree, tvb, offset, 1,
- "OpCode: %d (%s)",
+ "OpCode: %d (%s)",
opcode, val_to_str(opcode, opcodes, "Unknown"));
offset++;
left--;
subtype = tvb_get_guint8(tvb, offset);
proto_tree_add_text(eap_tree, tvb, offset, 1,
- "subtype: %d (%s)",
+ "subtype: %d (%s)",
subtype, val_to_str(subtype, subtypes, "Unknown"));
offset++;
aleft = 4 * length;
pi = proto_tree_add_text(eap_tree, tvb, aoffset, aleft,
- "Attribute: %s",
+ "Attribute: %s",
val_to_str(type, attributes,
"Unknown %u"));
attr_tree = proto_item_add_subtree(pi, ett_eap_sim_attr);
subtype = tvb_get_guint8(tvb, offset);
proto_tree_add_text(eap_tree, tvb, offset, 1,
- "subtype: %d (%s)",
+ "subtype: %d (%s)",
subtype, val_to_str(subtype, subtypes, "Unknown"));
offset++;
aleft = 4 * length;
pi = proto_tree_add_text(eap_tree, tvb, aoffset, aleft,
- "Attribute: %s",
+ "Attribute: %s",
val_to_str(type, attributes,
"Unknown %u"));
attr_tree = proto_item_add_subtree(pi, ett_eap_aka_attr);
len = eap_len;
if (tree) {
- ti = proto_tree_add_item(tree, proto_eap, tvb, 0, len, FALSE);
+ ti = proto_tree_add_item(tree, proto_eap, tvb, 0, len, ENC_NA);
eap_tree = proto_item_add_subtree(ti, ett_eap);
proto_tree_add_uint(eap_tree, hf_eap_code, tvb, 0, 1, eap_code);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_eapol, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_eapol, tvb, 0, -1, ENC_NA);
eapol_tree = proto_item_add_subtree(ti, ett_eapol);
proto_tree_add_item(eapol_tree, hf_eapol_version, tvb, offset, 1, ENC_BIG_ENDIAN);
if (tree) {
- ti = proto_tree_add_item(tree, proto_echo, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_echo, tvb, offset, -1, ENC_NA);
echo_tree = proto_item_add_subtree(ti, ett_echo);
if (request) {
col_set_str(pinfo->cinfo, COL_PROTOCOL, "eDonkey");
if (tree) {
- ti = proto_tree_add_item(tree, proto_edonkey, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_edonkey, tvb, 0, -1, ENC_NA);
edonkey_tree = proto_item_add_subtree(ti, ett_edonkey);
}
col_set_str(pinfo->cinfo, COL_INFO, "eDonkey UDP Message");
if (tree) {
- ti = proto_tree_add_item(tree, proto_edonkey, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_edonkey, tvb, 0, -1, ENC_NA);
edonkey_tree = proto_item_add_subtree(ti, ett_edonkey);
}
memset(&egd_time, 0, sizeof(nstime_t));
offset = 0;
- ti = proto_tree_add_item(tree, proto_egd, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_egd, tvb, 0, -1, ENC_NA);
egd_tree = proto_item_add_subtree(ti, ett_egd);
proto_tree_add_item(egd_tree, hf_egd_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset++;
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
* The AOS/LOS packet data zone is only 2 bytes in
* length and only 2 bits in the first byte are
* meaningful -- Ku band or S band and AOS or LOS
- *
+ *
* 7-2 - unused
* 1-0 - band + AOS/LOS indicator
*
col_set_str(pinfo->cinfo, COL_PROTOCOL, "EHS");
col_set_str(pinfo->cinfo, COL_INFO, "EHS");
- ehs_packet = proto_tree_add_item ( tree, proto_ehs, tvb, 0, -1, FALSE );
+ ehs_packet = proto_tree_add_item ( tree, proto_ehs, tvb, 0, -1, ENC_NA );
ehs_tree = proto_item_add_subtree ( ehs_packet, ett_ehs );
/* build the ehs primary header tree */
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_enttec, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_enttec, tvb, offset, -1, ENC_NA);
enttec_tree = proto_item_add_subtree(ti, ett_enttec);
}
if (tree)
{
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_epl, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_epl, tvb, 0, -1, ENC_NA);
epl_tree = proto_item_add_subtree(ti, ett_epl);
proto_tree_add_item(epl_tree,
if(tree){
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_epl_v1, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_epl_v1, tvb, 0, -1, ENC_NA);
epl_v1_tree = proto_item_add_subtree(ti, ett_epl_v1);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- ti = proto_tree_add_item(tree, proto_epmd, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_epmd, tvb, 0, -1, ENC_NA);
epmd_tree = proto_item_add_subtree(ti, ett_epmd);
if (pinfo->match_port == pinfo->destport) {
/* check the value in bit flds */
aug_n_index = ((bit_flds >> (2 *i))& 0x3) +1;
}
- else
+ else
{
aug_n_index = 0;
}
int i = 0;
int cur_len = 0, print_index = 0;
guint8 is_printed = 0;
- static char* g_vc_size_strings[] = {
+ static char* g_vc_size_strings[] = {
"unknown", /* 0x0 */
"VC3", /*0x1*/
"VC4", /*0x2*/
}
g_snprintf(out_string+print_index, maxstrlen, ")");
return;
-}
+}
static void
dissect_channelised_ex_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *pseudo_hdr_tree, int idx)
}
if (tree) {
- erf_item = proto_tree_add_item(tree, proto_erf, tvb, 0, -1, FALSE);
+ erf_item = proto_tree_add_item(tree, proto_erf, tvb, 0, -1, ENC_NA);
erf_tree = proto_item_add_subtree(erf_item, ett_erf);
dissect_erf_pseudo_header(tvb, pinfo, erf_tree);
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- ti = proto_tree_add_item(tree, proto_erldp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_erldp, tvb, 0, -1, ENC_NA);
erldp_tree = proto_item_add_subtree(ti, ett_erldp);
if (is_handshake(tvb, 0)) {
static gboolean
is_esio_pdu(tvbuff_t *tvb)
{
- /* we need at least 8 bytes to determine whether this is
+ /* we need at least 8 bytes to determine whether this is
Ether-S-I/O or not*/
/* minimal length is 20 bytes*/
if (tvb_length(tvb) < 20) {
/* create display subtree for the protocol */
if (tree) {
offset =0;
- ti = proto_tree_add_item(tree, proto_esio, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_esio, tvb, offset, -1, ENC_NA);
esio_tree = proto_item_add_subtree(ti, ett_esio);
/*Add subtree for Ether-S-I/O header*/
et = proto_tree_add_text(esio_tree, tvb, offset, 12, "Ether-S-I/O header");
tvb_memcpy(tvb, (guint8 *)&ehdr, 0, sizeof ehdr);
if (tree) {
- ti = proto_tree_add_item(tree, proto_esis, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_esis, tvb, 0, -1, ENC_NA);
esis_tree = proto_item_add_subtree(ti, ett_esis);
if (ehdr.esis_version != ESIS_REQUIRED_VERSION){
get_ether_name(dst_addr), ether_to_str(dst_addr));
}
else {
- ti = proto_tree_add_item(parent_tree, proto_eth, tvb, 0, ETH_HEADER_SIZE, FALSE);
+ ti = proto_tree_add_item(parent_tree, proto_eth, tvb, 0, ETH_HEADER_SIZE, ENC_NA);
}
fh_tree = proto_item_add_subtree(ti, ett_ether2);
}
len = tvb_length(tvb);
- item = proto_tree_add_item(tree, proto_evrc, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_evrc, tvb, 0, -1, ENC_NA);
evrc_tree = proto_item_add_subtree(item, ett_evrc);
}
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_exec, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_exec, tvb, 0, -1, ENC_NA);
exec_tree = proto_item_add_subtree(ti, ett_exec);
/* If this packet doesn't end with a null terminated string,
if (tree) {
ti = proto_tree_add_item(tree, proto_edp, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
edp_tree = proto_item_add_subtree(ti, ett_edp);
proto_tree_add_item(edp_tree, hf_edp_version, tvb, offset, 1,
guint16 clen;
guint8 plen;
- ti = proto_tree_add_item(tree, proto_fcgi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_fcgi, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, " (%s)",
val_to_str(type, record_types, "Unknown (%u)"));
fcgi_tree = proto_item_add_subtree(ti, ett_fcgi);
proto_item *flags_ti;
proto_tree *flags_tree;
- ti = proto_tree_add_item(tree, proto_fefd, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_fefd, tvb, offset, -1, ENC_NA);
fefd_tree = proto_item_add_subtree(ti, ett_fefd);
/* FEFD header */
length = tvb_get_ntohl(tvb, 8);
if(tree) {
- ti = proto_tree_add_item(tree, proto_ff, tvb, offset, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_ff, tvb, offset, length, ENC_NA);
sub_tree = proto_item_add_subtree(ti, ett_ff);
}
if (fix_marker(tvb, 0) != 0) {
/* not a fix packet start but it's a fix packet */
col_set_str(pinfo->cinfo, COL_INFO, "[FIX continuation]");
- ti = proto_tree_add_item(tree, proto_fix, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_fix, tvb, 0, -1, ENC_NA);
fix_tree = proto_item_add_subtree(ti, ett_fix);
proto_tree_add_item(fix_tree, hf_fix_data, tvb, 0, -1, ENC_NA);
return;
}
pdu_len = tvb_reported_length(tvb);
- ti = proto_tree_add_item(tree, proto_fix, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_fix, tvb, 0, -1, ENC_NA);
fix_tree = proto_item_add_subtree(ti, ett_fix);
/* begin string */
}
else {
ti = proto_tree_add_item(tree, proto_flip, flip_tvb, 0,
- flip_len, FALSE);
+ flip_len, ENC_NA);
}
flip_tree = proto_item_add_subtree(ti, ett_flip);
/* Clear out stuff in the info column */
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_fmtp, tvb, 0, -1, ENC_LITTLE_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_fmtp, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", %s",
val_to_str(packet_type, packet_type_names, "Unknown (0x%02x)"));
channel_type = tvb_get_guint8(tvb, 3);
if (tree) {
- ti = proto_tree_add_item(tree, proto_fp_hint, tvb, 0, hdrlen, TRUE);
+ ti = proto_tree_add_item(tree, proto_fp_hint, tvb, 0, hdrlen, ENC_NA);
fph_tree = proto_item_add_subtree(ti, ett_fph);
proto_tree_add_uint(fph_tree, hf_fph_frametype, tvb, 2, 1, frame_type);
proto_tree_add_uint(fph_tree, hf_fph_channeltype, tvb, 3, 1, channel_type);
necessary to generate protocol tree items. */
if (tree) {
/* create the fractalgeneratorprotocol protocol tree */
- fractalgeneratorprotocol_item = proto_tree_add_item(tree, proto_fractalgeneratorprotocol, message_tvb, 0, -1, FALSE);
+ fractalgeneratorprotocol_item = proto_tree_add_item(tree, proto_fractalgeneratorprotocol, message_tvb, 0, -1, ENC_NA);
fractalgeneratorprotocol_tree = proto_item_add_subtree(fractalgeneratorprotocol_item, ett_fractalgeneratorprotocol);
} else {
fractalgeneratorprotocol_tree = NULL;
if (tree) {
ti = proto_tree_add_item(tree, proto_ftp, tvb, offset, -1,
- FALSE);
+ ENC_NA);
ftp_tree = proto_item_add_subtree(ti, ett_ftp);
if (is_request) {
data_length = tvb_length(tvb);
ti = proto_tree_add_item(tree, proto_ftp_data, tvb, 0, -1,
- FALSE);
+ ENC_NA);
ftp_data_tree = proto_item_add_subtree(ti, ett_ftp_data);
/*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
static const value_string g723_frame_size_and_codec_type_value[] = {
- {0, "High-rate speech (6.3 kb/s)"},
+ {0, "High-rate speech (6.3 kb/s)"},
{1, "Low-rate speech (5.3 kb/s)"}, /* Not coded */
{2, "SID frame"},
{3, "Reserved"},
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "G.723.1");
if (tree) {
- ti = proto_tree_add_item(tree, proto_g723, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_g723, tvb, 0, -1, ENC_NA);
g723_tree = proto_item_add_subtree(ti, ett_g723);
octet = tvb_get_guint8(tvb,offset);
proto_tree_add_item(g723_tree, hf_g723_frame_size_and_codec, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(g723_tree, hf_g723_lpc_B5_B0, tvb, offset, 1, ENC_BIG_ENDIAN);
-
+
if ((octet & 0x1) == 1 ) /* Low rate */
- return;
+ return;
}/* if tree */
}
proto_reg_handoff_g723(void)
{
dissector_handle_t g723_handle;
-
+
g723_handle = create_dissector_handle(dissect_g723, proto_g723);
dissector_add_uint("rtp.pt", PT_G723, g723_handle);
void
proto_register_g723(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_g723_frame_size_and_codec,
{ "Frame size and codec type", "g723.frame_size_and_codec",
- FT_UINT8, BASE_HEX, VALS(g723_frame_size_and_codec_type_value), 0x03,
+ FT_UINT8, BASE_HEX, VALS(g723_frame_size_and_codec_type_value), 0x03,
"RATEFLAG_B0", HFILL }
},
{ &hf_g723_lpc_B5_B0,
{ "LPC_B5...LPC_B0", "g723.lpc.b5b0",
- FT_UINT8, BASE_HEX, NULL, 0xfc,
+ FT_UINT8, BASE_HEX, NULL, 0xfc,
NULL, HFILL }
},
gdsdb_tree = NULL; /* So the opcode functions can check on if(tree) */
nopi.cinfo = NULL;
- if (tvb_length(tvb) < 4)
+ if (tvb_length(tvb) < 4)
return 0;
opcode = tvb_get_ntohl(tvb, 0);
if (tree) {
ti = proto_tree_add_item(tree, proto_gdsdb, tvb, 0, -1,
- FALSE);
+ ENC_NA);
gdsdb_tree = proto_item_add_subtree(ti, ett_gdsdb);
proto_tree_add_item(gdsdb_tree, hf_gdsdb_opcode, tvb,
0, 4, ENC_BIG_ENDIAN);
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
line = tvb_get_ptr(tvb, offset, linelen);
/* set "Info" column text */
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s",
is_request ? "Request" : "Response",
format_text(line, linelen));
/* if tree != NULL, build protocol tree */
if (tree) {
- ti = proto_tree_add_item(tree, proto_gift, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_gift, tvb, 0, -1, ENC_NA);
gift_tree = proto_item_add_subtree(ti, ett_gift);
if (is_request) {
}
PROTO_ITEM_SET_HIDDEN(hidden_item);
- ti = proto_tree_add_text(gift_tree, tvb, offset, next_offset - offset, "%s",
+ ti = proto_tree_add_text(gift_tree, tvb, offset, next_offset - offset, "%s",
tvb_format_text(tvb, offset, next_offset - offset));
cmd_tree = proto_item_add_subtree(ti, ett_gift_cmd);
}
if (tree)
{
- ti = proto_tree_add_item (tree, proto_giop, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_giop, tvb, 0, -1, ENC_NA);
clnp_tree = proto_item_add_subtree (ti, ett_giop);
proto_tree_add_text (clnp_tree, giop_header_tvb, 0, -1,
"Version %u.%u not supported",
if (tree)
{
- ti = proto_tree_add_item (tree, proto_giop, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_giop, tvb, 0, -1, ENC_NA);
clnp_tree = proto_item_add_subtree (ti, ett_giop);
proto_tree_add_text (clnp_tree, giop_header_tvb, offset, 4,
"Magic number: %s", GIOP_MAGIC);
col_set_str(pinfo->cinfo, COL_INFO, "Git Smart Protocol");
- ti = proto_tree_add_item(tree, proto_git, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_git, tvb, offset, -1, ENC_NA);
git_tree = proto_item_add_subtree(ti, ett_git);
if (!tvb_get_packet_length(tvb, 0, &plen))
proto_tree_add_uint(git_tree, hf_git_packet_len, tvb, offset,
4, plen);
- proto_tree_add_item(git_tree, hf_git_packet_data, tvb, offset+4,
+ proto_tree_add_item(git_tree, hf_git_packet_data, tvb, offset+4,
plen-4, ENC_NA);
}
}
col_add_fstr(pinfo->cinfo, COL_INFO, "G: %d", group);
if (tree) {
- ti = proto_tree_add_item(tree, proto_glbp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_glbp, tvb, 0, -1, ENC_NA);
glbp_tree = proto_item_add_subtree(ti, ett_glbp);
/* glbp header? */
length = tvb_get_guint8(tvb, offset); /* Length of the Gigamon header */
if (tree) {
- ti = proto_tree_add_item(tree, proto_gmhdr, tvb, offset, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_gmhdr, tvb, offset, length, ENC_NA);
if (gmhdr_summary_in_tree) {
proto_item_append_text(ti, ", Length: %u", length);
/* OK: We appear to have a Gigamon trailer */
if (tree) {
- ti = proto_tree_add_item(tree, proto_gmhdr, tvb, offset, length + 5, FALSE);
+ ti = proto_tree_add_item(tree, proto_gmhdr, tvb, offset, length + 5, ENC_NA);
if (gmhdr_summary_in_tree) {
proto_item_append_text(ti, ", Length: %u, Checksum: 0x%x", length, cksum);
if (tree)
{
- ti = proto_tree_add_item(tree, proto_gmrp, tvb, 0, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_gmrp, tvb, 0, length, ENC_NA);
gmrp_tree = proto_item_add_subtree(ti, ett_gmrp);
tvb,
0,
-1,
- FALSE);
+ ENC_NA);
gnutella_tree = proto_item_add_subtree(ti, ett_gnutella);
size = tvb_get_letohl(
tvb,
0,
-1,
- FALSE);
+ ENC_NA);
gnutella_tree = proto_item_add_subtree(ti,
ett_gnutella);
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
if (parent_tree){
- item = proto_tree_add_item(parent_tree, proto_goose, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_goose, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_goose);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, PNAME);
dissector_handle_t goose_handle;
goose_handle = find_dissector("goose");
-
+
dissector_add_uint("ethertype", ETHERTYPE_IEC61850_GOOSE, goose_handle);
}
if (tree) {
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_gopher, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_gopher, tvb, 0, -1, ENC_NA);
gopher_tree = proto_item_add_subtree(ti, ett_gopher);
if (client) {
guint32 count;
if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_gpef, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_gpef, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_gpef);
}
col_append_str(pinfo->cinfo, COL_PROTOCOL, "/BSSLAP");
if (tree) {
octet = tvb_get_guint8(tvb, offset);
- item = proto_tree_add_item(tree, proto_gsm_bsslap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_gsm_bsslap, tvb, 0, -1, ENC_NA);
sub_tree = proto_item_add_subtree(item, ett_gsm_bsslap);
/* Message Type IE / 5.1 M V 1 */
#include <epan/prefs.h>
/* http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xml
- *
+ *
* exlm-agent 3002
* cgms 3003
* ii-admin 3006
- * vrml-multi-use 4200-4299
+ * vrml-multi-use 4200-4299
* commplex-main 5000
*/
#define IPA_TCP_PORTS "3002,3003,3006,4249,4250,5000"
val_to_str(msg_type, ipaccess_msgtype_vals,
"unknown 0x%02x"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_ipaccess, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_ipaccess, tvb, 0, -1, ENC_NA);
ipaccess_tree = proto_item_add_subtree(ti, ett_ipaccess);
proto_tree_add_item(ipaccess_tree, hf_ipaccess_msgtype,
tvb, 0, 1, ENC_BIG_ENDIAN);
if ( prevent_subdissectors_changing_columns && col_get_writable(pinfo->cinfo) ) {
disallow_write = TRUE;
col_set_writable(pinfo->cinfo, FALSE);
- }
+ }
if ( port_number_udh_means_wsp ) {
call_dissector (wsp_handle, sm_tvb, pinfo, top_tree);
}
}
}
-
+
if ( disallow_write )
col_set_writable(pinfo->cinfo, TRUE);
} else { /* No ports IE */
{
proto_item *ti;
proto_tree *subtree;
- ti = proto_tree_add_item(tree, proto_gsm_sms_ud, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_gsm_sms_ud, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_gsm_sms);
parse_gsm_sms_ud_message(subtree, tvb, pinfo, tree);
}
if (tree) {
const char *channel;
- ti = proto_tree_add_item(tree, proto_gsm_um, tvb, 0, 0, FALSE);
+ ti = proto_tree_add_item(tree, proto_gsm_um, tvb, 0, 0, ENC_NA);
gsm_um_tree = proto_item_add_subtree(ti, ett_gsm_um);
switch( pinfo->pseudo_header->gsm_um.channel ) {
}
item = proto_tree_add_item(
- tree, proto_gssapi, tvb, offset, -1, FALSE);
+ tree, proto_gssapi, tvb, offset, -1, ENC_NA);
subtree = proto_item_add_subtree(item, ett_gssapi);
col_add_str(pinfo->cinfo, COL_INFO, val_to_str_ext_const(gtp_hdr.message, &message_type_ext, "Unknown"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_gtp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_gtp, tvb, 0, -1, ENC_NA);
gtp_tree = proto_item_add_subtree(ti, ett_gtp);
tf = proto_tree_add_uint(gtp_tree, hf_gtp_flags, tvb, 0, 1, gtp_hdr.flags);
/* proto_tree_add_uint(gtp_tree, hf_gtp_next, tvb, offset, 1, next_hdr); */
offset++;
-
+
/* Change to while? */
if (next_hdr) {
/* TODO Add support for more than one extension header */
-
+
noOfExtHdrs++;
-
+
tf = proto_tree_add_uint(gtp_tree, hf_gtp_ext_hdr, tvb, offset, 4, next_hdr);
ext_tree = proto_item_add_subtree(tf, ett_gtp_ext_hdr);
* Wireshark Note: TS 29.060 does not define bit 5-6 as spare, so no check is possible unless a preference is used.
*/
if (next_hdr == GTP_EXT_HDR_PDCP_SN) {
-
+
/* First byte is length (should be 1) */
ext_hdr_length = tvb_get_guint8(tvb, offset);
if (ext_hdr_length != 1) {
proto_tree_add_item(ext_tree, hf_gtp_ext_hdr_pdcpsn, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
-
+
/* Last is next_hdr */
next_hdr = tvb_get_guint8(tvb, offset);
item = proto_tree_add_item(ext_tree, hf_gtp_ext_hdr_next, tvb, offset, 1, ENC_BIG_ENDIAN);
if (next_hdr) {
expert_add_info_format(pinfo, item, PI_UNDECODED, PI_WARN, "Can't decode more than one extension header.");
}
- offset++;
+ offset++;
}
- }
+ }
}
break;
default:
col_add_str(pinfo->cinfo, COL_INFO, val_to_str(message_type, gtpv2_message_type_vals, "Unknown"));
- proto_tree_add_item(tree, proto_gtpv2, tvb, offset, -1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(tree, proto_gtpv2, tvb, offset, -1, ENC_NA);
if (tree) {
ti = proto_tree_add_text(tree, tvb, offset, -1, "%s", val_to_str(message_type, gtpv2_message_type_vals, "Unknown"));
proto_item *ti = NULL;
proto_tree *gvcp_tree = NULL;
- ti = proto_tree_add_item(tree, proto_gvcp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_gvcp, tvb, 0, -1, ENC_NA);
gvcp_tree = proto_item_add_subtree(ti, ett_gvcp);
proto_tree_add_item(gvcp_tree, hf_gvcp_type, tvb, 0, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(gvcp_tree, hf_gvcp_opcode, tvb, 2, 2, ENC_BIG_ENDIAN);
if (tree)
{
- ti = proto_tree_add_item(tree, proto_gvrp, tvb, 0, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_gvrp, tvb, 0, length, ENC_NA);
gvrp_tree = proto_item_add_subtree(ti, ett_gvrp);
col_set_str(pinfo->cinfo, COL_INFO, "S5: ");
if (tree)
{
- ti = proto_tree_add_item (tree, proto_h1, tvb, offset, 16, FALSE);
+ ti = proto_tree_add_item (tree, proto_h1, tvb, offset, 16, ENC_NA);
h1_tree = proto_item_add_subtree (ti, ett_h1);
proto_tree_add_uint (h1_tree, hf_h1_header, tvb, offset, 2,
tvb_get_ntohs(tvb,offset));
/* add the 'h223' tree to the main tree */
if (tree) {
- h223_item = proto_tree_add_item (tree, proto_h223, tvb, 0, -1, FALSE);
+ h223_item = proto_tree_add_item (tree, proto_h223, tvb, 0, -1, ENC_NA);
h223_tree = proto_item_add_subtree (h223_item, ett_h223);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "H.248");
if (tree) {
- h248_item = proto_tree_add_item(tree, proto_h248, tvb, 0, -1, FALSE);
+ h248_item = proto_tree_add_item(tree, proto_h248, tvb, 0, -1, ENC_NA);
h248_tree = proto_item_add_subtree(h248_item, ett_h248);
}
col_set_str(pinfo->cinfo, COL_INFO, "H.261 message");
if ( tree ) {
- ti = proto_tree_add_item( tree, proto_h261, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_h261, tvb, offset, -1, ENC_NA );
h261_tree = proto_item_add_subtree( ti, ett_h261 );
/* SBIT 1st octet, 3 bits */
proto_tree_add_uint( h261_tree, hf_h261_sbit, tvb, offset, 1, tvb_get_guint8( tvb, offset ) >> 5 );
proto_tree_add_bits_item(tree, hf_h263_gbsc, tvb, offset_in_bits, 1, ENC_BIG_ENDIAN);
offset_in_bits++;
}else{
- /* Group of Block Start Code (GBSC) (17 bits)
+ /* Group of Block Start Code (GBSC) (17 bits)
* A word of 17 bits. Its value is 0000 0000 0000 0000 1.
*/
proto_tree_add_bits_item(tree, hf_h263_gbsc, tvb, offset_in_bits, 17, ENC_BIG_ENDIAN);
offset_in_bits = offset_in_bits +17;
}
- /*
+ /*
* Group Number (GN) (5 bits)
*/
proto_tree_add_bits_item(tree, hf_h263_GN, tvb, offset_in_bits, 5, ENC_BIG_ENDIAN);
/* 5.2.4 GOB Sub-Bitstream Indicator (GSBI) (2 bits)
* A fixed length codeword of 2 bits that is only present if CPM is "1" in the picture header.
*/
- /*
+ /*
* 5.2.5 GOB Frame ID (GFID) (2 bits)
*/
/*
guint64 pei;
if(is_rfc4626){
- /* PC 1000 00xx */
+ /* PC 1000 00xx */
proto_tree_add_bits_item(tree, hf_h263_psc, tvb, offset_in_bits, 6, ENC_BIG_ENDIAN);
offset_in_bits = offset_in_bits +6;
}else{
- /* Check for PSC, PSC is a word of 22 bits.
+ /* Check for PSC, PSC is a word of 22 bits.
* Its value is 0000 0000 0000 0000' 1000 00xx xxxx xxxx.
*/
proto_tree_add_bits_item(tree, hf_h263_psc, tvb, offset_in_bits, 22, ENC_BIG_ENDIAN);
proto_tree_add_bits_item(tree, hf_h263_TR, tvb, offset_in_bits, 8, ENC_BIG_ENDIAN);
offset_in_bits = offset_in_bits +8;
/*
- * Bit 1: Always "1", in order to avoid start code emulation.
+ * Bit 1: Always "1", in order to avoid start code emulation.
* Bit 2: Always "0", for distinction with Recommendation H.261.
*/
offset_in_bits = offset_in_bits +2;
proto_tree_add_bits_ret_val( tree, hf_h263_PB_frames_mode, tvb, offset_in_bits, 1, &PB_frames_mode, ENC_BIG_ENDIAN);
offset_in_bits++;
}else{
- /* Extended PTYPE
+ /* Extended PTYPE
* Update Full Extended PTYPE (UFEP) (3 bits)
*/
/* .... ..xx x... .... */
proto_tree_add_bits_ret_val( tree, hf_h263_UFEP, tvb, offset_in_bits, 3, &ufep, ENC_BIG_ENDIAN);
offset_in_bits = offset_in_bits +3;
if(ufep==1){
- /* The Optional Part of PLUSPTYPE (OPPTYPE) (18 bits)
+ /* The Optional Part of PLUSPTYPE (OPPTYPE) (18 bits)
*/
/* .xxx xxxx xxxx xxxx xxx. .... */
opptype_item = proto_tree_add_bits_item( tree, hf_h263_opptype, tvb, offset_in_bits, 18, ENC_BIG_ENDIAN);
*/
proto_tree_add_bits_item( h263_opptype_tree, hf_h263_ext_source_format, tvb, offset_in_bits, 3, ENC_BIG_ENDIAN);
offset_in_bits+=3;
-
+
/*
* Bit 4 Optional Custom PCF, "0" CIF PCF, "1" custom PCF;
*/
*/
offset_in_bits++;
proto_tree_add_bits_item( h263_opptype_tree, hf_h263_not_dissected, tvb, saved_bit_offset, offset_in_bits-saved_bit_offset, ENC_NA);
-
+
}
/*
* 5.1.4.3 The mandatory part of PLUSPTYPE when PLUSPTYPE present (MPPTYPE) (9 bits)
offset_in_bits++;
proto_tree_add_bits_item( tree, hf_h263_not_dissected, tvb, saved_bit_offset, offset_in_bits-saved_bit_offset, ENC_NA);
/* The picture header location of CPM (1 bit) and PSBI (2 bits)
- * the picture header depends on whether or not PLUSPTYPE is present
+ * the picture header depends on whether or not PLUSPTYPE is present
* (see 5.1.20 and 5.1.21). If PLUSPTYPE is present, then CPM follows
* immediately after PLUSPTYPE in the picture header.
*/
offset_in_bits++;
while(pei==1)
{
- /*5.1.25 Supplemental Enhancement Information (PSUPP) (0/8/16 ... bits)
+ /*5.1.25 Supplemental Enhancement Information (PSUPP) (0/8/16 ... bits)
* If PEI is set to "1", then 9 bits follow consisting of 8 bits of data (PSUPP) and then another PEI bit
* to indicate if a further 9 bits follow and so on. Encoders shall use PSUPP as specified in Annex L.
*/
col_append_str( pinfo->cinfo, COL_INFO, "H263 payload ");
if( tree ) {
- h263_payload_item = proto_tree_add_item( tree, proto_h263_data, tvb, offset, -1, FALSE );
+ h263_payload_item = proto_tree_add_item( tree, proto_h263_data, tvb, offset, -1, ENC_NA );
h263_payload_tree = proto_item_add_subtree( h263_payload_item, ett_h263_payload );
}
/* Check for PSC, PSC is a word of 22 bits. Its value is 0000 0000 0000 0000' 1000 00xx xxxx xxxx. */
data = tvb_get_ntohl(tvb, offset);
-
- if (( data & 0xffff8000) == 0x00008000 ) {
+
+ if (( data & 0xffff8000) == 0x00008000 ) {
/* Start Code found
*
* Startc code holds bit 17 -23 of the codeword
if (startcode & 0x80){
switch(startcode){
case 0xf8:
- /* End Of Sub-Bitstream code (EOSBS)
+ /* End Of Sub-Bitstream code (EOSBS)
* ( 1111 100. )
*/
break;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "H.263 RFC4629 ");
if ( tree ) {
- ti = proto_tree_add_item( tree, proto_h263P, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_h263P, tvb, offset, -1, ENC_NA );
h263P_tree = proto_item_add_subtree( ti, ett_h263P );
-
+
data16 = tvb_get_ntohs(tvb,offset);
proto_tree_add_item( h263P_tree, hf_h263P_rr, tvb, offset, 2, ENC_BIG_ENDIAN );
proto_tree_add_item( h263P_tree, hf_h263P_pbit, tvb, offset, 2, ENC_BIG_ENDIAN );
*/
if ((data16&0x0200)==0x0200){
- /* V bit = 1
+ /* V bit = 1
* The format of the VRC header extension is as follows:
*
* 0 1 2 3 4 5 6 7
*
* S: 1 bit
*
- * A bit that indicates that the packet content is for a sync frame.
+ * A bit that indicates that the packet content is for a sync frame.
* :
*/
proto_tree_add_item( h263P_tree, hf_h263P_tid, tvb, offset, 1, ENC_BIG_ENDIAN );
extra_hdr_item = proto_tree_add_item( h263P_tree, hf_h263P_extra_hdr, tvb, offset, plen, ENC_NA );
h263P_extr_hdr_tree = proto_item_add_subtree( extra_hdr_item, ett_h263P_extra_hdr );
dissect_h263_picture_layer( tvb, pinfo, h263P_extr_hdr_tree, offset, plen, TRUE);
- offset += plen;
+ offset += plen;
}
if ((data16&0x0400)!=0){
/* P bit = 1 */
*/
switch(startcode){
case 0xf8:
- /* End Of Sub-Bitstream code (EOSBS)
+ /* End Of Sub-Bitstream code (EOSBS)
* EOSBS codes shall be byte aligned
* ( 1111 100. )
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- ti = proto_tree_add_item(tree, proto_h282, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_h282, tvb, 0, -1, ENC_NA);
h282_tree = proto_item_add_subtree(ti, ett_h282);
return dissect_RDCPDU_PDU(tvb, pinfo, h282_tree);
}
/*--- proto_reg_handoff_h282 -------------------------------------------*/
-void proto_reg_handoff_h282(void)
+void proto_reg_handoff_h282(void)
{
}
#line 48 "../../asn1/h283/packet-h283-template.c"
/* Subdissectors */
-static dissector_handle_t rdc_pdu_handle;
-static dissector_handle_t rdc_device_list_handle;
-static dissector_handle_t data_handle;
+static dissector_handle_t rdc_pdu_handle;
+static dissector_handle_t rdc_device_list_handle;
+static dissector_handle_t data_handle;
static gboolean info_is_set;
info_is_set = FALSE;
- ti = proto_tree_add_item(tree, proto_h283, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_h283, tvb, 0, -1, ENC_NA);
h283_tree = proto_item_add_subtree(ti, ett_h283);
return dissect_LCTPDU_PDU(tvb, pinfo, h283_tree);
}
/*--- proto_reg_handoff_h283 -------------------------------------------*/
-void proto_reg_handoff_h283(void)
+void proto_reg_handoff_h283(void)
{
- dissector_handle_t h283_udp_handle;
+ dissector_handle_t h283_udp_handle;
h283_udp_handle = find_dissector(PFNAME);
- dissector_add_handle("udp.port", h283_udp_handle);
+ dissector_add_handle("udp.port", h283_udp_handle);
rdc_pdu_handle = find_dissector("rdc");
rdc_device_list_handle = find_dissector("rdc.device_list");
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- ti = proto_tree_add_item(tree, proto_h501, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_h501, tvb, 0, -1, ENC_NA);
h501_tree = proto_item_add_subtree(ti, ett_h501);
return dissect_Message_PDU(tvb, pinfo, h501_tree);
}
/*--- proto_reg_handoff_h501 -------------------------------------------*/
-void proto_reg_handoff_h501(void)
+void proto_reg_handoff_h501(void)
{
static gboolean h501_prefs_initialized = FALSE;
static dissector_handle_t h501_udp_handle;
type = pinfo->pseudo_header->bthci.channel;
if(tree){
- ti = proto_tree_add_item(tree, proto_hci_h1, tvb, 0, 0, FALSE);
+ ti = proto_tree_add_item(tree, proto_hci_h1, tvb, 0, 0, ENC_NA);
hci_h1_tree = proto_item_add_subtree(ti, ett_hci_h1);
if(pinfo->p2p_dir == P2P_DIR_SENT ||
type = tvb_get_guint8(tvb, 0);
if(tree){
- ti = proto_tree_add_item(tree, proto_hci_h4, tvb, 0, 1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hci_h4, tvb, 0, 1, ENC_NA);
hci_h4_tree = proto_item_add_subtree(ti, ett_hci_h4);
}
proto_item *ti = NULL;
proto_tree *hdfs_tree = NULL;
- ti = proto_tree_add_item(tree, proto_hdfs, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_hdfs, tvb, 0, -1, ENC_NA);
hdfs_tree = proto_item_add_subtree(ti, ett_hdfs);
/* Response */
/* token id = amount of bytes in previous */
proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_tokenid, tvb, *offset, len, ENC_ASCII|ENC_NA);
*offset += len;
-
+
len = tvb_get_guint8(tvb, *offset);
proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_tokenlen, tvb, *offset, 1, ENC_BIG_ENDIAN);
*offset += 1;
*offset += len;
len = tvb_get_guint8(tvb, *offset);
- proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_tokenlen, tvb, *offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_tokenlen, tvb, *offset, 1, ENC_BIG_ENDIAN);
*offset += 1;
/* token service = amount of bytes in previous; */
{
/* 8 bytes = start offset */
- proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_startoffset, tvb, *offset, 8, ENC_BIG_ENDIAN);
+ proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_startoffset, tvb, *offset, 8, ENC_BIG_ENDIAN);
*offset += 8;
/* 8 bytes = block length */
- proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_blocklen, tvb, *offset, 8, ENC_BIG_ENDIAN);
+ proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_blocklen, tvb, *offset, 8, ENC_BIG_ENDIAN);
*offset += 8;
}
/* decodes the write response messages */
static void
-dissect_write_response(tvbuff_t *tvb, proto_tree *hdfsdata_tree, int offset)
+dissect_write_response(tvbuff_t *tvb, proto_tree *hdfsdata_tree, int offset)
{
/* 4 bytes = packetsize */
proto_tree_add_item(hdfsdata_tree, hf_hdfsdata_packetsize, tvb, offset, 4, ENC_BIG_ENDIAN);
proto_item *ti = NULL;
proto_tree *hdfsdata_tree = NULL;
- ti = proto_tree_add_item(tree, proto_hdfsdata, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_hdfsdata, tvb, offset, -1, ENC_NA);
hdfsdata_tree = proto_item_add_subtree(ti, ett_hdfsdata);
/* if only 1 bytes packet must just contain just the pipeline status */
/* write responses store the data length in the first 4 bytes. This length does not
include 21 bits of header */
- } else if (tvb_reported_length(tvb) >= 4 && tvb_get_ntohl(tvb, 0) ==
+ } else if (tvb_reported_length(tvb) >= 4 && tvb_get_ntohl(tvb, 0) ==
tvb_reported_length(tvb) - WRITE_RESP_HEAD_LEN) {
dissect_write_response(tvb, hdfsdata_tree, offset);
/* populate a tree in the second pane with the status of the link layer (i.e. none) */
if(tree) {
- ti = proto_tree_add_item(tree, proto_hip, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hip, tvb, 0, -1, ENC_NA);
hip_tree = proto_item_add_subtree(ti, ett_hip);
proto_tree_add_item(hip_tree, hf_hip_proto, tvb, offset, 1, ENC_BIG_ENDIAN);
/* Locator */
proto_tree_add_item(ti_loc, hf_hip_tlv_locator_address,
tvb, newoffset, 16, ENC_NA);
- newoffset += 16;
+ newoffset += 16;
tlv_len -= 24;
} else if (locator_type == 1) {
/* Locator types 1 and 0 RFC 5206 section 4.2.*/
/* Locator */
proto_tree_add_item(ti_loc, hf_hip_tlv_locator_address,
tvb, newoffset, 16, ENC_NA);
- newoffset += 16;
+ newoffset += 16;
tlv_len -= 28;
} else if (locator_type == 2) {
/* Locator type 2 RFC 5770 section 5.7. */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HNBAP");
/* create the hnbap protocol tree */
- hnbap_item = proto_tree_add_item(tree, proto_hnbap, tvb, 0, -1, FALSE);
+ hnbap_item = proto_tree_add_item(tree, proto_hnbap, tvb, 0, -1, ENC_NA);
hnbap_tree = proto_item_add_subtree(hnbap_item, ett_hnbap);
dissect_HNBAP_PDU_PDU(tvb, pinfo, hnbap_tree);
col_set_str(pinfo->cinfo, COL_INFO, "MAC Management");
if (tree) {
- ti = proto_tree_add_item(tree, proto_homeplug_av, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_homeplug_av, tvb, 0, -1, ENC_NA);
homeplug_av_tree = proto_item_add_subtree(ti, ett_homeplug_av);
}
homeplug_offset = 0;
if (tree) {
- it = proto_tree_add_item(tree, proto_homeplug, tvb, homeplug_offset, -1, FALSE);
+ it = proto_tree_add_item(tree, proto_homeplug, tvb, homeplug_offset, -1, ENC_NA);
homeplug_tree = proto_item_add_subtree(it, ett_homeplug);
cursor = ptvcursor_new(homeplug_tree, tvb, 0);
}
* "Traffic Mirroring" in Appendix B of the HP manual
* "Management and Configuration Guide for the ProCurve Series
* 3500, 3500yl, 5400zl, 6200yl, 6600, and 8200zl Switches (September 2009)"
- *
+ *
* Format:
* The above manual indicates that the encapsulatedmirrored frame is transmitted
* on the network as a [UDP] packet which has 54 bytes preceding the mirrored frame.
- * Examining a sample capture shows that this means that the data payload
- * of the UDP packet consists of a 12 byte "header" followed by the
+ * Examining a sample capture shows that this means that the data payload
+ * of the UDP packet consists of a 12 byte "header" followed by the
* byes of the mirrored frame.
- *
+ *
*/
#ifdef HAVE_CONFIG_H
col_set_str(pinfo->cinfo, COL_INFO, PROTO_SHORT_NAME ":");
if (tree) {
- ti = proto_tree_add_item(tree, proto_hp_erm, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hp_erm, tvb, 0, -1, ENC_NA);
hp_erm_tree = proto_item_add_subtree(ti, ett_hp_erm);
proto_tree_add_item(hp_erm_tree, hf_hp_erm_unknown, tvb, 0, 12, ENC_NA);
}
sxsap = tvb_get_ntohs(tvb, 5);
if (tree) {
- ti = proto_tree_add_item(tree, proto_hpext, tvb, 0, 7, FALSE);
+ ti = proto_tree_add_item(tree, proto_hpext, tvb, 0, 7, ENC_NA);
hpext_tree = proto_item_add_subtree(ti, ett_hpext);
proto_tree_add_text(hpext_tree, tvb, 0, 3, "Reserved");
proto_tree_add_uint(hpext_tree, hf_hpext_dxsap, tvb, 3,
if (tree) {
guint16 offset =0;
- ti = proto_tree_add_item(tree, proto_hpsw, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hpsw, tvb, 0, -1, ENC_NA);
hp_tree = proto_item_add_subtree(ti, ett_hpsw);
proto_tree_add_uint(hp_tree, hf_hpsw_version, tvb, 0, 1, version);
offset++;
strPtr = ether_to_str(mac_addr);
HP_Mac = "03:00:c7:00:00:ee";
/*
- * Check to see if SNAP frame is a HP Teaming frame or
+ * Check to see if SNAP frame is a HP Teaming frame or
* if it is really just SNAP
*/
if (memcmp(strPtr, HP_Mac, 17) == 0) {
col_append_fstr(pinfo->cinfo, COL_INFO, "Port MAC = %s ", strPtr);
if (tree) { /* we are being asked for details */
- hpteam_item = proto_tree_add_item(tree, proto_hpteam, tvb, 0, -1, FALSE);
+ hpteam_item = proto_tree_add_item(tree, proto_hpteam, tvb, 0, -1, ENC_NA);
hpteam_tree = proto_item_add_subtree(hpteam_item, ett_hpteam);
proto_tree_add_item(hpteam_tree, hf_hpteam, tvb, offset, 58, ENC_NA);
}
proto_hpteam = proto_register_protocol ("HP NIC Teaming Heartbeat", "HPTEAM", "hpteam");
- /*Tied into the LLC dissector so register the OUI with LLC*/
+ /*Tied into the LLC dissector so register the OUI with LLC*/
llc_add_oui(OUI_HP_2, "llc.hpteam_pid", "Hewlett Packard OUI PID", &hf_pid);
proto_register_field_array(proto_hpteam, hf_data, array_length(hf_data));
proto_register_subtree_array(ett, array_length(ett));
gchar auth_buf[8 + 1];
offset = 0;
- ti = proto_tree_add_item(tree, proto_hsrp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hsrp, tvb, offset, -1, ENC_NA);
hsrp_tree = proto_item_add_subtree(ti, ett_hsrp);
proto_tree_add_item(hsrp_tree, hf_hsrp_version, tvb, offset, 1, ENC_BIG_ENDIAN);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "HSRPv2");
if (tree) {
- ti = proto_tree_add_item(tree, proto_hsrp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hsrp, tvb, offset, -1, ENC_NA);
hsrp_tree = proto_item_add_subtree(ti, ett_hsrp);
}
/* Simple Service Discovery Protocol
* SSDP is implemented atop HTTP (yes, it really *does* run over UDP).
- * SSDP is the discovery protocol of Universal Plug and Play
+ * SSDP is the discovery protocol of Universal Plug and Play
* UPnP http://www.upnp.org/specs/arch/UPnP-arch-DeviceArchitecture-v1.1.pdf
*/
#define TCP_PORT_SSDP 1900
orig_offset = offset;
if (tree) {
ti = proto_tree_add_item(tree, proto_http, tvb, offset, -1,
- FALSE);
+ ENC_NA);
http_tree = proto_item_add_subtree(ti, ett_http);
}
* Create a proxy-connect subtree
*/
if(tree) {
- item = proto_tree_add_item(tree, proto_http, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_http, tvb, 0, -1, ENC_NA);
proxy_tree = proto_item_add_subtree(item, ett_http);
item = proto_tree_add_string(proxy_tree, hf_http_proxy_connect_host,
col_append_str(pinfo->cinfo, COL_INFO, " (message/http)");
if (tree) {
ti = proto_tree_add_item(tree, proto_message_http,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_message_http);
while (tvb_reported_length_remaining(tvb, offset) != 0) {
len = tvb_find_line_end(tvb, offset,
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- * Copyright 2002 Richard Sharpe <rsharpe@richardsharpe.com>
+ * Copyright 2002 Richard Sharpe <rsharpe@richardsharpe.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
static int hf_hs_lastfrag = -1;
static int hf_hs_fragno = -1;
-static gint ett_hyperscsi = -1;
+static gint ett_hyperscsi = -1;
static gint ett_hs_hdr = -1;
static gint ett_hs_pdu = -1;
#define HSCSI_OPCODE_REMOTE_REPLY 0x35
static const value_string hscsi_opcodes[] = {
- { HSCSI_OPCODE_REQUEST, "Command Block Encap Request"},
+ { HSCSI_OPCODE_REQUEST, "Command Block Encap Request"},
{ HSCSI_OPCODE_REPLY, "Command Block Encap Reply"},
{ HSCSI_OPCODE_DEV_DISCOVERY, "Device Discovery Reply"},
{ HSCSI_OPCODE_ADN_REQUEST, "Auth/Device Neg Request"},
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_hyperscsi, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_hyperscsi, tvb, offset, -1, ENC_NA);
hs_tree = proto_item_add_subtree(ti, ett_hyperscsi);
- }
+ }
hs_hdr1 = tvb_get_guint8(tvb, offset);
offset++;
}
- /*
- * Now, add the PDU
+ /*
+ * Now, add the PDU
*/
hs_ver = tvb_get_guint8(tvb, offset++);
{
static hf_register_info hf[] = {
- { &hf_hs_res,
- { "Reserved", "hyperscsi.reserved", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { &hf_hs_res,
+ { "Reserved", "hyperscsi.reserved", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL}},
{ &hf_hs_tagno,
{ &hf_hs_lastfrag,
{ "Last Fragment", "hyperscsi.lastfrag", FT_BOOLEAN, 8, TFS(&tfs_lastfrag), 0x04, NULL, HFILL}},
- { &hf_hs_fragno,
+ { &hf_hs_fragno,
{ "Fragment No", "hyperscsi.fragno", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}},
{ &hf_hs_ver,
- { "HyperSCSI Version", "hyperscsi.version", FT_UINT8, BASE_DEC, NULL,
+ { "HyperSCSI Version", "hyperscsi.version", FT_UINT8, BASE_DEC, NULL,
0x0, NULL, HFILL}},
{ &hf_hs_cmd,
- { "HyperSCSI Command", "hyperscsi.cmd", FT_UINT8, BASE_DEC, VALS(hscsi_opcodes), 0x0,
+ { "HyperSCSI Command", "hyperscsi.cmd", FT_UINT8, BASE_DEC, VALS(hscsi_opcodes), 0x0,
NULL, HFILL}},
};
&ett_hs_hdr,
&ett_hs_pdu,
};
-
+
proto_hyperscsi = proto_register_protocol("HyperSCSI", "HyperSCSI", "hyperscsi");
proto_register_field_array(proto_hyperscsi, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
if (tree)
{
- ti = proto_tree_add_item(tree, proto_iapp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_iapp, tvb, 0, -1, ENC_NA);
iapp_tree = proto_item_add_subtree(ti, ett_iapp);
/* common header for all IAPP frames */
/* add the 'iax2' tree to the main tree */
if (tree)
{
- iax2_item = proto_tree_add_item (tree, proto_iax2, tvb, offset, -1, FALSE);
+ iax2_item = proto_tree_add_item (tree, proto_iax2, tvb, offset, -1, ENC_NA);
iax2_tree = proto_item_add_subtree (iax2_item, ett_iax2);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_icap, tvb, offset, -1,
- FALSE);
+ ENC_NA);
icap_tree = proto_item_add_subtree(ti, ett_icap);
}
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_icep, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_icep, tvb, 0, -1, ENC_NA);
icep_tree = proto_item_add_subtree(ti, ett_icep);
if (be_ts < MSPERDAY && le_ts < MSPERDAY) {
guint32 saved_be_ts = be_ts;
- guint32 saved_le_ts = le_ts;
+ guint32 saved_le_ts = le_ts;
/* Is this a rollover to a new day, clocks not synchronized, different
* timezones between originate and receive/transmit, .. what??? */
length = tvb_length(tvb);
reported_length = tvb_reported_length(tvb);
- ti = proto_tree_add_item(tree, proto_icmp, tvb, 0, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_icmp, tvb, 0, length, ENC_NA);
icmp_tree = proto_item_add_subtree(ti, ett_icmp);
ti = proto_tree_add_item(icmp_tree, hf_icmp_type, tvb, 0, 1, ENC_BIG_ENDIAN);
}
}
- /* Make sure we have enough bytes in the payload before trying to
+ /* Make sure we have enough bytes in the payload before trying to
* see if the data looks like a timestamp; otherwise we'll get
* malformed packets as we try to access data that isn't there. */
if (tvb_length_remaining(tvb, 8) < 8) {
/* Interpret the first 8 bytes of the icmp data as a timestamp
* But only if it does look like it's a timestamp.
- *
+ *
* FIXME:
* Timestamps could be in different formats depending on the OS
*/
{
guint32 frame_ts, orig_ts;
- frame_ts = ((pinfo->fd->abs_ts.secs * 1000) +
+ frame_ts = ((pinfo->fd->abs_ts.secs * 1000) +
(pinfo->fd->abs_ts.nsecs / 1000000)) % 86400000;
-
+
orig_ts = get_best_guess_mstimeofday(tvb, 8, frame_ts);
proto_tree_add_text(icmp_tree, tvb, 8, 4,
"Originate timestamp: %s after midnight UTC",
offset = 0;
if (tree) {
- ti = proto_tree_add_item(tree, proto_icmpv6, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_icmpv6, tvb, offset, -1, ENC_NA);
icmp6_tree = proto_item_add_subtree(ti, ett_icmpv6);
/* Type */
if (tree)
{
- ti = proto_tree_add_item(tree,proto_icp, tvb, 0, message_length, FALSE);
+ ti = proto_tree_add_item(tree,proto_icp, tvb, 0, message_length, ENC_NA);
icp_tree = proto_item_add_subtree(ti, ett_icp);
proto_tree_add_uint(icp_tree,hf_icp_opcode, tvb, 0, 1, opcode);
top_tree=parent_tree;
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_idmp, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_idmp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_idmp);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_idp, tvb, 0, IDP_HEADER_LEN, FALSE);
+ ti = proto_tree_add_item(tree, proto_idp, tvb, 0, IDP_HEADER_LEN, ENC_NA);
idp_tree = proto_item_add_subtree(ti, ett_idp);
}
gboolean OFF;
gboolean ON;
- gboolean UP;
+ gboolean UP;
gboolean DOWN;
/* QOC qualifier-bits */
/*** *** DISSECT 'Packet Details' *** ***/
- it104 = proto_tree_add_item(tree, proto_iec104asdu, tvb, 0, -1, FALSE);
+ it104 = proto_tree_add_item(tree, proto_iec104asdu, tvb, 0, -1, ENC_NA);
/* 'Packet Details': ROOT ITEM */
proto_item_append_text(it104, ": %s'%s'", res->str, Len >= ASDU_HEAD_LEN ? val_to_str(asduh->TypeId, asdu_lngtypes, "<Unknown TypeId>") : "");
case C_CS_NA_1:
/* create subtree for the signal values ... */
- itSignal = proto_tree_add_item( trHead, proto_iec104asdu, tvb, offset, -1, FALSE );
+ itSignal = proto_tree_add_item( trHead, proto_iec104asdu, tvb, offset, -1, ENC_NA );
proto_item_append_text(itSignal, ": Value");
trSignal = proto_item_add_subtree( itSignal, ett_asdu );
/*** *** DISSECT 'Packet Details' *** ***/
- it104 = proto_tree_add_item(tree, proto_iec104apci, tvb, 0, Off+ APCI_LEN, FALSE);
+ it104 = proto_tree_add_item(tree, proto_iec104apci, tvb, 0, Off+ APCI_LEN, ENC_NA);
/* 'Packet Details': ROOT ITEM */
proto_item_append_text(it104, ": %s", res->str);
col_set_str(pinfo->cinfo, COL_INFO, "AVB Transportation Protocol");
if (tree) {
- ti = proto_tree_add_item(tree, proto_1722, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_1722, tvb, 0, -1, ENC_NA);
ieee1722_tree = proto_item_add_subtree(ti, ett_1722);
- /* Add the CD and Subtype fields
+ /* Add the CD and Subtype fields
* CD field is 1 bit
* Subtype field is 7 bits
*/
proto_tree_add_item(ieee1722_tree, hf_1722_tufield, tvb,
IEEE_1722_TU_FIELD_OFFSET, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ieee1722_tree, hf_1722_stream_id, tvb,
+ proto_tree_add_item(ieee1722_tree, hf_1722_stream_id, tvb,
IEEE_1722_STREAM_ID_OFFSET, 8, ENC_BIG_ENDIAN);
proto_tree_add_item(ieee1722_tree, hf_1722_avbtp_timestamp, tvb,
proto_tree_add_item(ieee1722_tree, hf_1722_tag, tvb,
IEEE_1722_TAG_OFFSET, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ieee1722_tree, hf_1722_channel, tvb,
+ proto_tree_add_item(ieee1722_tree, hf_1722_channel, tvb,
IEEE_1722_TAG_OFFSET, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(ieee1722_tree, hf_1722_tcode, tvb,
+ proto_tree_add_item(ieee1722_tree, hf_1722_tcode, tvb,
IEEE_1722_TCODE_OFFSET, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ieee1722_tree, hf_1722_sy, tvb,
IEEE_1722_TCODE_OFFSET, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ieee1722_tree, hf_1722_syt, tvb,
IEEE_1722_SYT_OFFSET, 2, ENC_BIG_ENDIAN);
- /* Calculate the remaining size by subtracting the CIP header size
+ /* Calculate the remaining size by subtracting the CIP header size
from the value in the packet data length field */
datalen = tvb_get_ntohs(tvb, IEEE_1722_PKT_DATA_LENGTH_OFFSET);
datalen -= IEEE_1722_CIP_HEADER_SIZE;
/* Make the Audio sample tree. */
- ti = proto_tree_add_item(ieee1722_tree, hf_1722_data, tvb,
+ ti = proto_tree_add_item(ieee1722_tree, hf_1722_data, tvb,
IEEE_1722_DATA_OFFSET, datalen, ENC_NA);
audio_tree = proto_item_add_subtree(ti, ett_1722_audio);
}
/* Register the protocol with Wireshark */
-void proto_register_1722(void)
+void proto_register_1722(void)
{
static hf_register_info hf[] = {
{ &hf_1722_cdfield,
- { "Control/Data Indicator", "ieee1722.cdfield",
- FT_BOOLEAN, 8, NULL, IEEE_1722_CD_MASK, NULL, HFILL }
+ { "Control/Data Indicator", "ieee1722.cdfield",
+ FT_BOOLEAN, 8, NULL, IEEE_1722_CD_MASK, NULL, HFILL }
},
{ &hf_1722_subtype,
{ "AVBTP Subtype", "ieee1722.subtype",
- FT_UINT8, BASE_HEX, NULL, IEEE_1722_SUBTYPE_MASK, NULL, HFILL }
+ FT_UINT8, BASE_HEX, NULL, IEEE_1722_SUBTYPE_MASK, NULL, HFILL }
},
{ &hf_1722_svfield,
{ "AVBTP Stream ID Valid", "ieee1722.svfield",
- FT_BOOLEAN, 8, NULL, IEEE_1722_SV_MASK, NULL, HFILL }
+ FT_BOOLEAN, 8, NULL, IEEE_1722_SV_MASK, NULL, HFILL }
},
{ &hf_1722_verfield,
{ "AVBTP Version", "ieee1722.verfield",
- FT_UINT8, BASE_HEX, NULL, IEEE_1722_VER_MASK, NULL, HFILL }
+ FT_UINT8, BASE_HEX, NULL, IEEE_1722_VER_MASK, NULL, HFILL }
},
{ &hf_1722_mrfield,
{ "AVBTP Media Reset", "ieee1722.mrfield",
- FT_UINT8, BASE_DEC, NULL, IEEE_1722_MR_MASK, NULL, HFILL }
+ FT_UINT8, BASE_DEC, NULL, IEEE_1722_MR_MASK, NULL, HFILL }
},
{ &hf_1722_gvfield,
{ "AVBTP Gateway Info Valid", "ieee1722.gvfield",
- FT_BOOLEAN, 8, NULL, IEEE_1722_GV_MASK, NULL, HFILL }
+ FT_BOOLEAN, 8, NULL, IEEE_1722_GV_MASK, NULL, HFILL }
},
{ &hf_1722_tvfield,
{ "Source Timestamp Valid", "ieee1722.tvfield",
- FT_BOOLEAN, 8, NULL, IEEE_1722_TV_MASK, NULL, HFILL }
+ FT_BOOLEAN, 8, NULL, IEEE_1722_TV_MASK, NULL, HFILL }
},
{ &hf_1722_seqnum,
{ "Sequence Number", "ieee1722.seqnum",
proto_register_subtree_array(ett, array_length(ett));
}
-void proto_reg_handoff_1722(void)
+void proto_reg_handoff_1722(void)
{
dissector_handle_t avbtp_handle;
col_clear(pinfo->cinfo, COL_INFO);
if(tree) {
- ti = proto_tree_add_item(tree, proto_prism, tvb, 0, 144, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_prism, tvb, 0, 144, ENC_NA);
prism_tree = proto_item_add_subtree(ti, ett_prism);
}
pinfo->pseudo_header->ieee_802_11.signal_level);
if (tree) {
- ti = proto_tree_add_item(tree, proto_radio, tvb, 0, 0, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_radio, tvb, 0, 0, ENC_NA);
radio_tree = proto_item_add_subtree (ti, ett_radio);
proto_tree_add_uint64_format(radio_tree, hf_data_rate, tvb, 0, 0,
/* Dissect the AVS header */
if (tree) {
- ti = proto_tree_add_item(tree, proto_wlancap, tvb, 0, length, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_wlancap, tvb, 0, length, ENC_NA);
wlan_tree = proto_item_add_subtree(ti, ett_radio);
proto_tree_add_item(wlan_tree, hf_wlan_magic, tvb, offset, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(wlan_tree, hf_wlan_version, tvb, offset, 4, ENC_BIG_ENDIAN);
CHECK_DISPLAY_AS_X(data_handle,proto_wlan_mgt, tvb, pinfo, tree);
- ti = proto_tree_add_item (tree, proto_wlan_mgt, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_wlan_mgt, tvb, 0, -1, ENC_NA);
mgt_tree = proto_item_add_subtree (ti, ett_80211_mgt);
switch (COMPOSE_FRAME_TYPE(fcf))
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_ieee802a, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ieee802a, tvb, 0, -1, ENC_NA);
ieee802a_tree = proto_item_add_subtree(ti, ett_ieee802a);
} else
ieee802a_tree = NULL;
return offset + tvb_length_remaining(tvb, offset);
}
- item = proto_tree_add_item(parent_tree, proto_igap, tvb, offset, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_igap, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_igap);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IGAP");
unsigned char type;
guint32 dst;
- item = proto_tree_add_item(parent_tree, proto_igmp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ item = proto_tree_add_item(parent_tree, proto_igmp, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_igmp);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IGMP");
* items to the protocol tree.
*/
if (tree) {
- ti = proto_tree_add_item(tree, proto_gif, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_gif, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Version: %s", str);
gif_tree = proto_item_add_subtree(ti, ett_gif);
/* GIF signature */
if (tree) {
ti = proto_tree_add_item(tree, proto_jfif,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_jfif);
proto_tree_add_item(subtree, hf_marker, tvb, 0, 2, ENC_BIG_ENDIAN);
}
col_append_str(pinfo->cinfo, COL_INFO, " (PNG)");
if(parent_tree){
- ti=proto_tree_add_item(parent_tree, proto_png, tvb, offset, -1, FALSE);
+ ti=proto_tree_add_item(parent_tree, proto_png, tvb, offset, -1, ENC_NA);
tree=proto_item_add_subtree(ti, ett_png);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_imap, tvb, offset, -1,
- FALSE);
+ ENC_NA);
imap_tree = proto_item_add_subtree(ti, ett_imap);
if (is_request) {
col_clear(pinfo->cinfo, COL_INFO);
if(tree){
- item = proto_tree_add_item(tree, proto_imf, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_imf, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_imf);
}
/* create display subtree for the protocol */
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_inap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_inap, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_inap);
}
inap_pdu_type = tvb_get_guint8(tvb, offset)&0x0f;
}
/* Top Level Packet */
- infiniband_packet = proto_tree_add_item(tree, proto_infiniband, tvb, offset, -1, FALSE);
+ infiniband_packet = proto_tree_add_item(tree, proto_infiniband, tvb, offset, -1, ENC_NA);
/* Headers Level Tree */
all_headers_tree = proto_item_add_subtree(infiniband_packet, ett_all_headers);
}
/* Top Level Packet */
- infiniband_link_packet = proto_tree_add_item(tree, proto_infiniband_link, tvb, offset, -1, FALSE);
+ infiniband_link_packet = proto_tree_add_item(tree, proto_infiniband_link, tvb, offset, -1, ENC_NA);
/* Headers Level Tree */
link_tree = proto_item_add_subtree(infiniband_link_packet, ett_link);
if (tree) {
proto_item *il_item;
il_item = proto_tree_add_item(tree, proto_interlink,
- tvb, 0, 16, FALSE);
+ tvb, 0, 16, ENC_NA);
if (il_item)
il_tree = proto_item_add_subtree(il_item, ett_interlink);
}
hlen = lo_nibble(iph->ip_v_hl) * 4; /* IP header length, in bytes */
if (tree) {
- ti = proto_tree_add_item(tree, proto_ip, tvb, offset, hlen, FALSE);
+ ti = proto_tree_add_item(tree, proto_ip, tvb, offset, hlen, ENC_NA);
ip_tree = proto_item_add_subtree(ti, ett_ip);
proto_tree_add_uint(ip_tree, hf_ip_version, tvb, offset, 1,
if (!tree)
return;
- ti = proto_tree_add_item(tree, proto_ipdc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipdc, tvb, 0, -1, ENC_NA);
ipdc_tree = proto_item_add_subtree(ti, ett_ipdc);
proto_tree_add_item(ipdc_tree, hf_ipdc_nr, tvb, 0, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(ipdc_tree, hf_ipdc_ns, tvb, 1, 1, ENC_BIG_ENDIAN);
TEXT_UNDEFINED));
- ti = proto_tree_add_item(tree, proto_ipdc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipdc, tvb, 0, -1, ENC_NA);
ipdc_tree = proto_item_add_subtree(ti, ett_ipdc);
proto_tree_add_item(ipdc_tree, hf_ipdc_nr, tvb, 0, 1, ENC_BIG_ENDIAN);
current_pinfo = pinfo;
if (tree) {
- ti = proto_tree_add_item(tree, proto_ipmi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipmi, tvb, 0, -1, ENC_NA);
ipmi_tree = proto_item_add_subtree(ti, ett_ipmi);
}
/* populate a tree in the second pane with the IPNET header data */
if(tree) {
- ti = proto_tree_add_item (tree, proto_ipnet, tvb, 0, 24, FALSE);
+ ti = proto_tree_add_item (tree, proto_ipnet, tvb, 0, 24, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_raw);
proto_tree_add_item(fh_tree, hf_version, tvb, 0, 1, ENC_BIG_ENDIAN);
if (tree) {
ti = proto_tree_add_item(tree, proto_ipp, tvb, offset, -1,
- FALSE);
+ ENC_NA);
ipp_tree = proto_item_add_subtree(ti, ett_ipp);
proto_tree_add_text(ipp_tree, tvb, offset, 2, "Version: %u.%u",
ns.secs=tvb_get_ntohl(tvb, offset);
ns.nsecs=0;
proto_tree_add_time(tree, hf_ipp_timestamp, tvb, offset, 4, &ns);
- }
+ }
else if((name_length > 5) && name_val && !strcmp(name_val, "printer-state")){
guint32 printer_state_reason;
}
/*
- * TCP Encapsulation of IPsec Packets
+ * TCP Encapsulation of IPsec Packets
* as supported by the cisco vpn3000 concentrator series
*/
static int
/* If the first 4 bytes are 0x01f401f4 (udp src and dst port = 500)
we most likely have UDP (isakmp) traffic */
-
+
if (tvb_get_ntohl(tvb, 0) == 0x01f401f4) { /* UDP means ISAKMP */
protocol = TCP_ENCAP_P_UDP;
} else { /* Hopefully ESP */
}
if (tree) {
- tree_item = proto_tree_add_item(tree, proto_tcpencap, tvb, 0, -1, ENC_BIG_ENDIAN);
+ tree_item = proto_tree_add_item(tree, proto_tcpencap, tvb, 0, -1, ENC_NA);
tcpencap_tree = proto_item_add_subtree(tree_item, ett_tcpencap);
/* Dissect the trailer following the encapsulated IPSEC/ISAKMP packet */
guint addr_len = (guint)strlen(addr);
guint filter_len = (guint)strlen(filter);
- if(addr_len != filter_len)
+ if(addr_len != filter_len)
return FALSE;
/* No length specified */
{
for(i = 0; i < addr_len; i++)
{
- if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != addr[i]))
+ if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != addr[i]))
return FALSE;
}
return TRUE;
{
for(i = 0; i < (filter_len/4); i++)
{
- if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != addr[i]))
+ if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != addr[i]))
return FALSE;
}
- if(filter[i] == IPSEC_SA_WILDCARDS_ANY)
+ if(filter[i] == IPSEC_SA_WILDCARDS_ANY)
return TRUE;
else if (filter_len % 4 != 0)
{
return FALSE;
for(i = 0; filter[i]; i++)
- if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != spi[i]))
+ if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != spi[i]))
return FALSE;
return TRUE;
if (tree) {
/* !!! specify length */
- ti = proto_tree_add_item(tree, proto_ah, tvb, 0, advance, FALSE);
+ ti = proto_tree_add_item(tree, proto_ah, tvb, 0, advance, ENC_NA);
ah_tree = proto_item_add_subtree(ti, ett_ah);
proto_tree_add_text(ah_tree, tvb,
decrypt_dissect_ok = FALSE;
i = 0;
- ti = proto_tree_add_item(tree, proto_esp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_esp, tvb, 0, -1, ENC_NA);
esp_tree = proto_item_add_subtree(ti, ett_esp);
proto_tree_add_uint(esp_tree, hf_esp_spi, tvb,
offsetof(struct newesp, esp_spi), 4,
g_free(ip_src);
g_free(ip_dst);
- if(esp_auth_key_len != 0)
+ if(esp_auth_key_len != 0)
g_free(esp_auth_key);
- if(esp_crypt_key_len != 0)
+ if(esp_crypt_key_len != 0)
g_free(esp_crypt_key);
}
}
if (tree) {
tvbuff_t *data, *decomp;
- ti = proto_tree_add_item(tree, proto_ipcomp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipcomp, tvb, 0, -1, ENC_NA);
ipcomp_tree = proto_item_add_subtree(ti, ett_ipcomp);
proto_tree_add_text(ipcomp_tree, tvb,
};
static uat_field_t esp_uat_flds[] = {
- UAT_FLD_VS(uat_esp_sa_records, protocol, "Protocol", esp_proto_type_vals, "Protocol used"),
+ UAT_FLD_VS(uat_esp_sa_records, protocol, "Protocol", esp_proto_type_vals, "Protocol used"),
UAT_FLD_CSTRING(uat_esp_sa_records, srcIP, "Src IP", "Source Address"),
UAT_FLD_CSTRING(uat_esp_sa_records, dstIP, "Dest IP", "Destination Address"),
UAT_FLD_CSTRING(uat_esp_sa_records, spi, "SPI", "SPI"),
- UAT_FLD_VS(uat_esp_sa_records, encryption_algo, "Encryption", esp_encryption_type_vals, "Encryption algorithm"),
+ UAT_FLD_VS(uat_esp_sa_records, encryption_algo, "Encryption", esp_encryption_type_vals, "Encryption algorithm"),
UAT_FLD_CSTRING(uat_esp_sa_records, encryption_key, "Encryption Key", "Encryption Key"),
- UAT_FLD_VS(uat_esp_sa_records, authentication_algo, "Authentication", esp_authentication_type_vals, "Authentication algorithm"),
+ UAT_FLD_VS(uat_esp_sa_records, authentication_algo, "Authentication", esp_authentication_type_vals, "Authentication algorithm"),
UAT_FLD_CSTRING(uat_esp_sa_records, authentication_key, "Authentication Key", "Authentication Key"),
UAT_END_FIELDS
};
NULL, /* post update callback */
esp_uat_flds); /* UAT field definitions */
- prefs_register_uat_preference(esp_module,
+ prefs_register_uat_preference(esp_module,
"sa_table",
"ESP SAs",
"Preconfigured ESP Security Associations",
if (tree) {
- ti = proto_tree_add_item(tree, proto_ipsictl, tvb, offset, remaining_length, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipsictl, tvb, offset, remaining_length, ENC_NA);
ipsictl_tree = proto_item_add_subtree(ti, ett_ipsictl);
}
proto_item *ipv6_tc;
const char *name;
- ipv6_item = proto_tree_add_item(tree, proto_ipv6, tvb, offset, -1, FALSE);
+ ipv6_item = proto_tree_add_item(tree, proto_ipv6, tvb, offset, -1, ENC_NA);
ipv6_tree = proto_item_add_subtree(ipv6_item, ett_ipv6);
/* !!! warning: (4-bit) version, (6-bit) DSCP, (1-bit) ECN-ECT, (1-bit) ECN-CE and (20-bit) Flow */
guint8 cnt = 0;
int conn = 0;
- item = proto_tree_add_item(parent_tree, proto_ipvs_syncd, tvb, offset, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_ipvs_syncd, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_ipvs_syncd);
if (tree) {
- ti = proto_tree_add_item(tree, proto_ipx, tvb, 0, IPX_HEADER_LEN, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipx, tvb, 0, IPX_HEADER_LEN, ENC_NA);
ipx_tree = proto_item_add_subtree(ti, ett_ipx);
}
col_set_str(pinfo->cinfo, COL_INFO, "SPX");
if (tree) {
- ti = proto_tree_add_item(tree, proto_spx, tvb, 0, SPX_HEADER_LEN, FALSE);
+ ti = proto_tree_add_item(tree, proto_spx, tvb, 0, SPX_HEADER_LEN, ENC_NA);
spx_tree = proto_item_add_subtree(ti, ett_spx);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_ipxmsg, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipxmsg, tvb, 0, -1, ENC_NA);
msg_tree = proto_item_add_subtree(ti, ett_ipxmsg);
proto_tree_add_uint(msg_tree, hf_msg_conn, tvb, 0, 1, conn_number);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_ipxrip, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ipxrip, tvb, 0, -1, ENC_NA);
rip_tree = proto_item_add_subtree(ti, ett_ipxrip);
if (operation < 2) {
if (tree) {
ti = proto_tree_add_item(tree, proto_serialization, tvb, 0, -1,
- FALSE);
+ ENC_NA);
ser_tree = proto_item_add_subtree(ti, ett_serialization);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_sap, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sap, tvb, 0, -1, ENC_NA);
sap_tree = proto_item_add_subtree(ti, ett_ipxsap);
if (query.query_type >= 1 && query.query_type <= 4) {
if (tree) {
ti = proto_tree_add_item(tree, proto_ipxwan, tvb, 0, -1,
- FALSE);
+ ENC_NA);
ipxwan_tree = proto_item_add_subtree(ti, ett_ipxwan);
}
if (tree)
{
- ti = proto_tree_add_item(tree, proto_irc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_irc, tvb, 0, -1, ENC_NA);
irc_tree = proto_item_add_subtree(ti, ett_irc);
/*
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_isakmp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_isakmp, tvb, offset, -1, ENC_NA);
isakmp_tree = proto_item_add_subtree(ti, ett_isakmp);
}
pinfo->circuit_id = pinfo->pseudo_header->isdn.channel;
if (tree) {
- ti = proto_tree_add_item(tree, proto_isdn, tvb, 0, 0, FALSE);
+ ti = proto_tree_add_item(tree, proto_isdn, tvb, 0, 0, ENC_NA);
isdn_tree = proto_item_add_subtree(ti, ett_isdn);
proto_tree_add_uint(isdn_tree, hf_isdn_channel, tvb, 0, 0,
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_isis, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_isis, tvb, 0, -1, ENC_NA);
isis_tree = proto_item_add_subtree(ti, ett_isis);
}
s_offset.offset_bits = 0; /* initialise bit offset */
poffset = &s_offset;
- ismacryp_item = proto_tree_add_item(tree, proto_ismacryp, tvb, 0, -1, FALSE);
+ ismacryp_item = proto_tree_add_item(tree, proto_ismacryp, tvb, 0, -1, ENC_NA);
ismacryp_tree = proto_item_add_subtree(ismacryp_item, ett_ismacryp);
proto_item_append_text(tree, ", %s", "ismacryp packet"); /* add text to tree */
offset += 3; /* skip the weird stuff, for now */
if (tree) {
/* create display subtree for ismp */
- ti = proto_tree_add_item(tree, proto_ismp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ismp, tvb, offset, -1, ENC_NA);
ismp_tree = proto_item_add_subtree(ti, ett_ismp);
proto_item *tpayload;
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_isns, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_isns, tvb, 0, -1, ENC_NA);
isns_tree = proto_item_add_subtree(ti, ett_isns);
/* OK... Sort out the header */
* necessary to generate protocol tree items.
*/
if (tree) {
- ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
isup_tree = proto_item_add_subtree(ti, ett_isup);
* necessary to generate protocol tree items.
*/
if (tree) {
- ti = proto_tree_add_item(tree, proto_bicc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bicc, tvb, 0, -1, ENC_NA);
bicc_tree = proto_item_add_subtree(ti, ett_bicc);
/* In the interest of speed, if "tree" is NULL, don't do any work not
necessary to generate protocol tree items. */
if (tree) {
- ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
isup_tree = proto_item_add_subtree(ti, ett_isup);
}
if (tree)
{
- itdm_item = proto_tree_add_item(tree, proto_itdm, tvb, 0, -1, FALSE);
+ itdm_item = proto_tree_add_item(tree, proto_itdm, tvb, 0, -1, ENC_NA);
itdm_tree = proto_item_add_subtree(itdm_item, ett_itdm);
proto_tree_add_item(itdm_tree, hf_itdm_timestamp, tvb, offset, 2, ENC_BIG_ENDIAN);
if (tree)
{
- itdm_ctl_item = proto_tree_add_item(tree, proto_itdm, tvb, 0, -1, FALSE);
+ itdm_ctl_item = proto_tree_add_item(tree, proto_itdm, tvb, 0, -1, ENC_NA);
itdm_ctl_tree = proto_item_add_subtree(itdm_ctl_item, ett_itdm_ctl);
/* These eventually should go into a SFP.0 dissector... */
{
guint32 flowid;
- /* ZZZ for now, 125 usec mode and I-TDM control protocol
+ /* ZZZ for now, 125 usec mode and I-TDM control protocol
* need to add 1ms mode */
if (tvb_length(tvb) < 18)
return;
/* DDP/RDMA protocol tree */
ddp_rdma_item = proto_tree_add_item(tree, proto_iwarp_ddp_rdmap,
- tvb, offset, header_end, FALSE);
+ tvb, offset, header_end, ENC_NA);
ddp_rdma_tree = proto_item_add_subtree(ddp_rdma_item,
ett_iwarp_ddp_rdmap);
if (tree) {
mpa_item = proto_tree_add_item(tree, proto_iwarp_mpa, tvb, 0,
- -1, FALSE);
+ -1, ENC_NA);
mpa_tree = proto_item_add_subtree(mpa_item, ett_mpa);
if (message_type == MPA_REQUEST_FRAME) {
}
mpa_item = proto_tree_add_item(tree, proto_iwarp_mpa, tvb, 0,
- -1, FALSE);
+ -1, ENC_NA);
mpa_tree = proto_item_add_subtree(mpa_item, ett_mpa);
mpa_header_item = proto_tree_add_item(mpa_tree, hf_mpa_fpdu,
col_set_str(pinfo->cinfo, COL_INFO, "JPEG message");
if ( tree ) {
- ti = proto_tree_add_item( tree, proto_jpeg, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_jpeg, tvb, offset, -1, ENC_NA );
jpeg_tree = proto_item_add_subtree( ti, ett_jpeg );
ti = proto_tree_add_item(jpeg_tree, hf_rtp_jpeg_main_hdr, tvb, offset, 8, ENC_NA);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_json, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_json, tvb, 0, -1, ENC_NA);
json_tree = proto_item_add_subtree(ti, ett_json);
if (data_name)
kdp_tree = NULL;
flags_tree = NULL;
- ti = proto_tree_add_item(tree, proto_kdp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_kdp, tvb, 0, -1, ENC_NA);
kdp_tree = proto_item_add_subtree(ti, ett_kdp);
version = tvb_get_guint8(tvb, 0);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "KRB5");
}
if (tree) {
- item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, ENC_NA);
kerberos_tree = proto_item_add_subtree(item, ett_krb_kerberos);
}
show_krb_recordmark(kerberos_tree, tvb, offset, krb_rm);
col_clear(pinfo->cinfo, COL_INFO);
}
if (tree) {
- item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_kerberos, tvb, 0, -1, ENC_NA);
kerberos_tree = proto_item_add_subtree(item, ett_krb_kerberos);
}
}
}
/* create a tree for krb4 */
- item = proto_tree_add_item(parent_tree, proto_krb4, tvb, offset, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_krb4, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_krb4);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "KRB4");
}
/* Make the kink tree */
if(tree){
- ti = proto_tree_add_item(tree, proto_kink, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_kink, tvb, offset, -1, ENC_NA);
kink_tree = proto_item_add_subtree(ti, ett_kink);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_kismet, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_kismet, tvb, offset, -1, ENC_NA);
kismet_tree = proto_item_add_subtree(ti, ett_kismet);
}
}
offset = next_offset;
}
-
+
return TRUE;
}
{
static hf_register_info hf[] = {
{&hf_kismet_response,
- {"Response", "kismet.response", FT_BOOLEAN, BASE_NONE,
+ {"Response", "kismet.response", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, "TRUE if kismet response", HFILL}},
{&hf_kismet_request,
- {"Request", "kismet.request", FT_BOOLEAN, BASE_NONE,
+ {"Request", "kismet.request", FT_BOOLEAN, BASE_NONE,
NULL, 0x0, "TRUE if kismet request", HFILL}}
};
* Routines for kpasswd packet dissection
* Ronnie Sahlberg 2003
*
- * See RFC 3244
+ * See RFC 3244
*
* $Id$
*
static ber_old_sequence_t ChangePasswdData_sequence[] = {
{ BER_CLASS_CON, 0, 0,
dissect_kpasswd_newpassword },
- { BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL,
+ { BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL,
dissect_krb5_cname },
- { BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL,
+ { BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL,
dissect_krb5_realm },
{ 0, 0, 0, NULL }
};
proto_tree_add_uint(tree, hf_kpasswd_result, tvb, offset, 2, result);
offset+=2;
if (check_col(pinfo->cinfo, COL_INFO))
- col_add_str(pinfo->cinfo, COL_INFO,
+ col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(result, kpasswd_result_types, "Result: %u"));
-
+
/* optional result string */
if(tvb_length_remaining(tvb, offset)){
- proto_tree_add_item(tree, hf_kpasswd_result_string, tvb, offset, tvb_length_remaining(tvb, offset), ENC_ASCII|ENC_NA);
+ proto_tree_add_item(tree, hf_kpasswd_result_string, tvb, offset, tvb_length_remaining(tvb, offset), ENC_ASCII|ENC_NA);
offset+=tvb_length_remaining(tvb, offset);
}
version=tvb_get_ntohs(tvb, offset+2);
ap_req_len=tvb_get_ntohs(tvb, offset+4);
if(tree){
- kpasswd_item=proto_tree_add_item(tree, proto_kpasswd, tvb, offset-krb_rm_size, message_len+krb_rm_size, FALSE);
+ kpasswd_item=proto_tree_add_item(tree, proto_kpasswd, tvb, offset-krb_rm_size, message_len+krb_rm_size, ENC_NA);
kpasswd_tree=proto_item_add_subtree(kpasswd_item, ett_kpasswd);
if (have_rm) {
show_krb_recordmark(kpasswd_tree, tvb, offset-krb_rm_size, krb_rm);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Layer1");
if (check_col(pinfo->cinfo, COL_DEF_SRC))
- col_set_str(pinfo->cinfo, COL_DEF_SRC,
+ col_set_str(pinfo->cinfo, COL_DEF_SRC,
pinfo->pseudo_header->l1event.uton? "TE" : "NT");
if (check_col(pinfo->cinfo, COL_INFO)) {
len = tvb_find_line_end(tvb, 0,
tvb_ensure_length_remaining(tvb, 0),
&next_offset, FALSE);
- if(len>0)
- col_add_str(pinfo->cinfo, COL_INFO,
+ if(len>0)
+ col_add_str(pinfo->cinfo, COL_INFO,
tvb_format_text(tvb, 0, len));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_l1_events,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
if (data_name)
proto_item_append_text(ti, ": %s", data_name);
subtree = proto_item_add_subtree(ti, ett_l1_events);
sid = tvb_get_ntohl(tvb, idx);
if (tree) {
- l2tp_item = proto_tree_add_item(tree, proto_l2tp, tvb, 0, -1, FALSE);
+ l2tp_item = proto_tree_add_item(tree, proto_l2tp, tvb, 0, -1, ENC_NA);
l2tp_tree = proto_item_add_subtree(l2tp_item, ett_l2tp);
proto_item_append_text(l2tp_item, " version 3");
sid = tvb_get_ntohl(tvb, idx);
if (tree) {
- l2tp_item = proto_tree_add_item(tree, proto_l2tp, tvb, 0, -1, FALSE);
+ l2tp_item = proto_tree_add_item(tree, proto_l2tp, tvb, 0, -1, ENC_NA);
l2tp_tree = proto_item_add_subtree(l2tp_item, ett_l2tp);
proto_item_append_text(l2tp_item, " version 3");
}
if (tree) {
- l2tp_item = proto_tree_add_item(tree, proto_l2tp, tvb, 0, -1, FALSE);
+ l2tp_item = proto_tree_add_item(tree, proto_l2tp, tvb, 0, -1, ENC_NA);
l2tp_tree = proto_item_add_subtree(l2tp_item, ett_l2tp);
proto_item_append_text(l2tp_item, " version 3");
}
if (tree) {
- l2tp_item = proto_tree_add_item(tree,proto_l2tp, tvb, 0, -1, FALSE);
+ l2tp_item = proto_tree_add_item(tree,proto_l2tp, tvb, 0, -1, ENC_NA);
l2tp_tree = proto_item_add_subtree(l2tp_item, ett_l2tp);
ti = proto_tree_add_text(l2tp_tree, tvb, 0, 2,
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_lanforge, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lanforge, tvb, 0, -1, ENC_NA);
lanforge_tree = proto_item_add_subtree(ti, ett_lanforge);
proto_item *direction_ti;
lapd_ti = proto_tree_add_item(tree, proto_lapd, tvb, 0, -1,
- FALSE);
+ ENC_NA);
lapd_tree = proto_item_add_subtree(lapd_ti, ett_lapd);
/*
}
if (tree) {
- lapdm_ti = proto_tree_add_item(tree, proto_lapdm, tvb, 0, LAPDM_HEADER_LEN, FALSE);
+ lapdm_ti = proto_tree_add_item(tree, proto_lapdm, tvb, 0, LAPDM_HEADER_LEN, ENC_NA);
lapdm_tree = proto_item_add_subtree(lapdm_ti, ett_lapdm);
addr_ti = proto_tree_add_uint(lapdm_tree, hf_lapdm_address, tvb, 0, 1, addr);
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, udp_ident_string);
-
+
if (tree){
- ti = proto_tree_add_item(tree, proto_laplink, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_laplink, tvb, 0, -1, ENC_NA);
laplink_tree = proto_item_add_subtree(ti, ett_laplink);
proto_tree_add_uint(laplink_tree, hf_laplink_udp_ident, tvb, offset, 4, udp_ident);
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(tcp_ident, laplink_tcp_magic, "TCP TBA (%u)"));
}
-
+
if (tree){
- ti = proto_tree_add_item(tree, proto_laplink, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_laplink, tvb, 0, -1, ENC_NA);
laplink_tree = proto_item_add_subtree(ti, ett_laplink);
dissect_laplink_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
tcp_dissect_pdus(tvb, pinfo, tree, laplink_desegment,
- 6, get_laplink_pdu_len,
+ 6, get_laplink_pdu_len,
dissect_laplink_tcp_pdu);
}
void
proto_register_laplink(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_laplink_udp_ident,
{ "UDP Ident", "laplink.udp_ident",
- FT_UINT32, BASE_HEX, VALS(laplink_udp_magic), 0x0,
+ FT_UINT32, BASE_HEX, VALS(laplink_udp_magic), 0x0,
"Unknown magic", HFILL }
},
{ &hf_laplink_udp_name,
{ "UDP Name", "laplink.udp_name",
- FT_STRINGZ, BASE_NONE, NULL, 0x0,
+ FT_STRINGZ, BASE_NONE, NULL, 0x0,
"Machine name", HFILL }
},
{ &hf_laplink_tcp_ident,
{ "TCP Ident", "laplink.tcp_ident",
- FT_UINT32, BASE_HEX, VALS(laplink_tcp_magic), 0x0,
+ FT_UINT32, BASE_HEX, VALS(laplink_tcp_magic), 0x0,
"Unknown magic", HFILL }
},
{ &hf_laplink_tcp_length,
{ "TCP Data payload length", "laplink.tcp_length",
- FT_UINT16, BASE_DEC, NULL, 0x0,
+ FT_UINT16, BASE_DEC, NULL, 0x0,
"Length of remaining payload", HFILL }
},
{ &hf_laplink_tcp_data,
{ "Unknown TCP data", "laplink.tcp_data",
- FT_BYTES, BASE_NONE, NULL, 0x0,
+ FT_BYTES, BASE_NONE, NULL, 0x0,
"TCP data", HFILL }
},
};
* References:
* ETSI TS 129 171 V9.2.0 (2010-10)
*/
-
+
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
col_set_str(pinfo->cinfo, COL_PROTOCOL, "LCSAP");
/* create the lcsap protocol tree */
- lcsap_item = proto_tree_add_item(tree, proto_lcsap, tvb, 0, -1, FALSE);
+ lcsap_item = proto_tree_add_item(tree, proto_lcsap, tvb, 0, -1, ENC_NA);
lcsap_tree = proto_item_add_subtree(lcsap_item, ett_lcsap);
-
+
dissect_LCS_AP_PDU_PDU(tvb, pinfo, lcsap_tree);
}
if (!Initialized) {
lcsap_handle = find_dissector("lcsap");
-
+
dissector_add_handle("sctp.port", lcsap_handle); /* for "decode-as" */
dissector_add_uint("sctp.ppi", LCS_AP_PAYLOAD_PROTOCOL_ID, lcsap_handle);
Initialized=TRUE;
/* Register dissector tables */
lcsap_ies_dissector_table = register_dissector_table("lcsap.ies", "LCS-AP-PROTOCOL-IES", FT_UINT32, BASE_DEC);
-
+
lcsap_extension_dissector_table = register_dissector_table("lcsap.extension", "LCS-AP-PROTOCOL-EXTENSION", FT_UINT32, BASE_DEC);
lcsap_proc_imsg_dissector_table = register_dissector_table("lcsap.proc.imsg", "LCS-AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
lcsap_proc_sout_dissector_table = register_dissector_table("lcsap.proc.sout", "LCS-AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
lcsap_proc_uout_dissector_table = register_dissector_table("lcsap.proc.uout", "LCS-AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
-
+
/* Register configuration options for ports */
lcsap_module = prefs_register_protocol(proto_lcsap, proto_reg_handoff_lcsap);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti=proto_tree_add_item(tree, proto_ldp, tvb, 0, -1, FALSE);
+ ti=proto_tree_add_item(tree, proto_ldp, tvb, 0, -1, ENC_NA);
pdu_tree = proto_item_add_subtree(ti, ett_ldp);
proto_tree_add_item(pdu_tree, hf_ldp_version, tvb, offset, 2, ENC_BIG_ENDIAN);
* instead of just filling out the columns), then give more detail. */
if (tree) {
ti = proto_tree_add_item(tree, proto_ldss,
- tvb, 0, (tvb_length(tvb) > 72) ? tvb_length(tvb) : 72, FALSE);
+ tvb, 0, (tvb_length(tvb) > 72) ? tvb_length(tvb) : 72, ENC_NA);
ldss_tree = proto_item_add_subtree(ti, ett_ldss_broadcast);
proto_tree_add_item(ldss_tree, hf_ldss_message_id,
if (tree) {
ti = proto_tree_add_item(tree, proto_ldss,
- tvb, 0, tvb_reported_length(tvb), FALSE);
+ tvb, 0, tvb_reported_length(tvb), ENC_NA);
ldss_tree = proto_item_add_subtree(ti, ett_ldss_transfer);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_ldss,
- tvb, 0, tvb_reported_length(tvb), FALSE);
+ tvb, 0, tvb_reported_length(tvb), ENC_NA);
ldss_tree = proto_item_add_subtree(ti, ett_ldss_transfer);
proto_tree_add_bytes_format(ldss_tree, hf_ldss_file_data,
tvb, 0, tvb_length(tvb), NULL,
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "LGE Monitor");
- ti = proto_tree_add_item(tree, proto_lge_monitor, tvb, 0, LGEMON_PROTO_HEADER_LENGTH, FALSE);
+ ti = proto_tree_add_item(tree, proto_lge_monitor, tvb, 0, LGEMON_PROTO_HEADER_LENGTH, ENC_NA);
lge_monitor_tree = proto_item_add_subtree(ti, ett_lge_monitor);
proto_tree_add_text(lge_monitor_tree, tvb, offset, LGEMON_PROTO_HEADER_LENGTH, "LGE Monitor PDU");
proto_item *ti = NULL;
proto_tree *linx_tree = NULL;
- ti = proto_tree_add_item(tree, proto_linx, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_linx, tvb, 0, -1, ENC_NA);
linx_tree = proto_item_add_subtree(ti, ett_linx);
dword = tvb_get_ntohl(tvb, offset);
tvb_set_reported_length(tvb, size);
linx_tcp_tvb = tvb_new_subset(tvb, 0, size, size);
- ti = proto_tree_add_item(tree, proto_linx_tcp, linx_tcp_tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_linx_tcp, linx_tcp_tvb, 0, -1, ENC_NA);
linx_tcp_tree = proto_item_add_subtree(ti, ett_linx_tcp);
if (version != 3) {
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_lisp_data, tvb, 0,
- LISP_DATA_HEADER_LEN, FALSE);
+ LISP_DATA_HEADER_LEN, ENC_NA);
lisp_data_tree = proto_item_add_subtree(ti, ett_lisp_data);
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_lisp, tvb, 0,
- (type == LISP_ECM) ? LISP_ECM_HEADER_LEN : -1, FALSE);
+ (type == LISP_ECM) ? LISP_ECM_HEADER_LEN : -1, ENC_NA);
lisp_tree = proto_item_add_subtree(ti, ett_lisp);
format = tvb_get_guint8(tvb, 0);
if (tree) {
- ti = proto_tree_add_item(tree, proto_basicxid, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_basicxid, tvb, 0, -1, ENC_NA);
xid_tree = proto_item_add_subtree(ti, ett_llc_basicxid);
proto_tree_add_uint(xid_tree, hf_llc_xid_format, tvb, 0,
1, format);
dsap = tvb_get_guint8(tvb, 0);
if (tree) {
- ti = proto_tree_add_item(tree, proto_llc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_llc, tvb, 0, -1, ENC_NA);
llc_tree = proto_item_add_subtree(ti, ett_llc);
proto_tree_add_uint(llc_tree, hf_llc_dsap, tvb, 0,
1, dsap & SAP_MASK);
if (tree)
{
- ti = proto_tree_add_item(tree, proto_lldp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lldp, tvb, offset, -1, ENC_NA);
lldp_tree = proto_item_add_subtree(ti, ett_lldp);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_llt, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_llt, tvb, 0, -1, ENC_NA);
llt_tree = proto_item_add_subtree(ti, ett_llt);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lmi, tvb, 0, 3, FALSE);
+ ti = proto_tree_add_item(tree, proto_lmi, tvb, 0, 3, ENC_NA);
lmi_tree = proto_item_add_subtree(ti, ett_lmi_ele);
proto_tree_add_item(lmi_tree, hf_lmi_call_ref, tvb, 0, 1, ENC_BIG_ENDIAN);
if (tree) {
msg_length = tvb_get_ntohs(tvb, offset+4);
ti = proto_tree_add_item(tree, proto_lmp, tvb, offset, msg_length,
- FALSE);
+ ENC_NA);
lmp_tree = proto_item_add_subtree(ti, lmp_subtree[LMP_TREE_MAIN]);
ti = proto_tree_add_text(lmp_tree, tvb, offset, 12, "LMP Header. %s",
val_to_str(message_type, message_type_vals,
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_loop, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_loop, tvb, offset, -1, ENC_NA);
loop_tree = proto_item_add_subtree(ti, ett_loop);
proto_tree_add_item(loop_tree, hf_loop_skipcount, tvb, offset, 2, ENC_LITTLE_ENDIAN);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_lpd, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lpd, tvb, 0, -1, ENC_NA);
lpd_tree = proto_item_add_subtree(ti, ett_lpd);
if (lpr_packet_type == response) {
if (tree) {
/* Create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_lsc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lsc, tvb, 0, -1, ENC_NA);
lsc_tree = proto_item_add_subtree(ti, ett_lsc);
/* Add already fetched items to the tree */
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_DL_CCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_DL_DCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_UL_CCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_UL_DCCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_BCCH_BCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
}
-
+
static void
dissect_lte_rrc_BCCH_DL_SCH(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lte_rrc, tvb, 0, -1, ENC_NA);
lte_rrc_tree = proto_item_add_subtree(ti, ett_lte_rrc);
dissect_BCCH_DL_SCH_Message_PDU(tvb, pinfo, lte_rrc_tree);
}
return 0;
}
- ti = proto_tree_add_item(tree, proto_ltp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ltp, tvb, 0, -1, ENC_NA);
ltp_tree = proto_item_add_subtree(ti, ett_ltp);
/* Adding Header Subtree */
if (tree) {
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_lwapp_control, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
control_tree = proto_item_add_subtree(ti, ett_lwapp_control);
proto_tree_add_uint(control_tree, hf_lwapp_control_type,
if (tree) {
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_lwapp_l3, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
lwapp_tree = proto_item_add_subtree(ti, ett_lwapp_l3);
} else {
lwapp_tree = NULL;
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_lwapp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_lwapp, tvb, offset, -1, ENC_NA);
lwapp_tree = proto_item_add_subtree(ti, ett_lwapp);
if (have_destmac) {
if(tree)
{
- lwres_item = proto_tree_add_item(tree,proto_lwres, tvb,0, -1, FALSE);
+ lwres_item = proto_tree_add_item(tree,proto_lwres, tvb,0, -1, ENC_NA);
lwres_tree = proto_item_add_subtree(lwres_item, ett_lwres);
}
else return;
necessary to generate protocol tree items. */
if (tree) {
/* create the m2tp protocol tree */
- m2tp_item = proto_tree_add_item(tree, proto_m2tp, message_tvb, 0, -1, FALSE);
+ m2tp_item = proto_tree_add_item(tree, proto_m2tp, message_tvb, 0, -1, ENC_NA);
m2tp_tree = proto_item_add_subtree(m2tp_item, ett_m2tp);
} else {
m2tp_item = NULL;
default:
proto_item_append_text(pdu_subheader_ti, ", length=%u)",
pdu_lengths[number_of_headers]);
- proto_item_append_text(pdu_header_ti, " (%s:%u)",
+ proto_item_append_text(pdu_header_ti, " (%s:%u)",
val_to_str_const(lcids[number_of_headers],
(direction == DIRECTION_UPLINK) ? ulsch_lcid_vals : dlsch_lcid_vals,
"Unknown"),
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MAC-LTE");
/* Create protocol tree. */
- pdu_ti = proto_tree_add_item(tree, proto_mac_lte, tvb, offset, -1, FALSE);
+ pdu_ti = proto_tree_add_item(tree, proto_mac_lte, tvb, offset, -1, ENC_NA);
proto_item_append_text(pdu_ti, " ");
mac_lte_tree = proto_item_add_subtree(pdu_ti, ett_mac_lte);
for (n=0; n < p_mac_lte_info->number_of_srs; n++) {
proto_item *sr_ti;
proto_tree *sr_tree;
-
+
/* SR event is subtree */
sr_ti = proto_tree_add_item(mac_lte_tree, hf_mac_lte_oob_send_sr,
tvb, 0, 0, ENC_NA);
opcode = tvb_get_ntohs(tvb, 0);
if (tree) {
- ti = proto_tree_add_item(tree, proto_macctrl, tvb, 0, 46, FALSE);
+ ti = proto_tree_add_item(tree, proto_macctrl, tvb, 0, 46, ENC_NA);
macctrl_tree = proto_item_add_subtree(ti, ett_macctrl);
proto_tree_add_uint(macctrl_tree, hf_macctrl_opcode, tvb, 0, 2, opcode);
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MANOLITO");
- ti = proto_tree_add_item(tree, proto_manolito, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_manolito, tvb, 0, -1, ENC_NA);
manolito_tree = proto_item_add_subtree(ti, ett_manolito);
if (tree) {
if ( (bytes = tvb_length(tvb)) > 0 )
{
- ti = proto_tree_add_item(tree, proto_media, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_media, tvb, 0, -1, ENC_NA);
media_tree = proto_item_add_subtree(ti, ett_media);
if (pinfo->private_data) {
/* Build the info tree if we've been given a root */
/* Create megaco subtree */
- ti = proto_tree_add_item(tree,proto_megaco,tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree,proto_megaco,tvb, 0, -1, ENC_NA);
megaco_tree = proto_item_add_subtree(ti, ett_megaco);
/* Format of 'message' is = MegacopToken SLASH Version SEP mId SEP messageBody */
break;
default :
- ti = proto_tree_add_item(tree,proto_megaco,tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree,proto_megaco,tvb, 0, -1, ENC_NA);
megaco_tree = proto_item_add_subtree(ti, ett_megaco);
proto_tree_add_text(megaco_tree, tvb, 0, -1,
"Sorry, can't understand errorDescriptor / transactionList = %s, can't parse it pos %u",
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *ti;
proto_tree *mesh_tree;
- guint8 mesh_ttl;
- guint16 mesh_e2eseq;
-
+ guint8 mesh_ttl;
+ guint16 mesh_e2eseq;
+
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Mesh");
-
+
if (tree) {
- ti = proto_tree_add_item(tree, proto_mesh, tvb, 0, 5, FALSE);
+ ti = proto_tree_add_item(tree, proto_mesh, tvb, 0, 5, ENC_NA);
mesh_tree = proto_item_add_subtree(ti, ett_mesh);
/* add an item to the subtree, see section 1.6 for more information */
mesh_ttl = tvb_get_guint8(tvb, 2);
proto_tree_add_uint(mesh_tree, hf_mesh_ttl, tvb, 2, 1, mesh_ttl);
-
+
mesh_e2eseq = tvb_get_ntohs(tvb, 3);
proto_tree_add_uint(mesh_tree, hf_mesh_e2eseq, tvb, 3, 2, mesh_e2eseq);
}
-
+
/* Return the amount of data this dissector was able to dissect */
return 5;
}
void
proto_register_mesh(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_mesh_ttl,
reserved = tvb_get_letohs(tvb, 6);
if (tree) {
- ti = proto_tree_add_item(tree, proto_meta, tvb, 0, hdrlen + 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_meta, tvb, 0, hdrlen + 4, ENC_NA);
meta_tree = proto_item_add_subtree(ti, ett_meta);
proto_tree_add_uint(meta_tree, hf_meta_schema, tvb, 0, 2, schema);
proto_tree_add_uint(meta_tree, hf_meta_hdrlen, tvb, 2, 2, hdrlen);
if (tree)
{
/* Create our mgcp subtree */
- ti = proto_tree_add_item(tree,proto_mgcp,tvb,0,0, FALSE);
+ ti = proto_tree_add_item(tree,proto_mgcp,tvb,0,0, ENC_NA);
mgcp_tree = proto_item_add_subtree(ti, ett_mgcp);
}
payload = -1;
if (tree) {
- ti = proto_tree_add_item(tree, proto_mikey, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mikey, tvb, 0, -1, ENC_NA);
mikey_tree = proto_item_add_subtree(ti, ett_mikey);
}
dswid, dsswid, dlid);
}
} else {
- ti = proto_tree_add_item( tree, proto_fp, tvb, 0, -1, FALSE ) ;
+ ti = proto_tree_add_item( tree, proto_fp, tvb, 0, -1, ENC_NA ) ;
}
fp_tree = proto_item_add_subtree( ti, ett_mim ) ;
/* XXX, COL_INFO */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MIME_FILE");
- item = proto_tree_add_item(tree, proto_mime_encap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_mime_encap, tvb, 0, -1, ENC_NA);
/* frames with nsec >= 1000000000 means errors :) */
if (pinfo->fd->abs_ts.nsecs >= 1000000000) {
version_major, version_minor);
if (tree)
{
- ti = proto_tree_add_item (tree, proto_miop, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_miop, tvb, 0, -1, ENC_NA);
miop_tree = proto_item_add_subtree (ti, ett_miop);
proto_tree_add_text (miop_tree, tvb, 0, -1,
"Version %u.%u",
if (tree)
{
- ti = proto_tree_add_item (tree, proto_miop, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_miop, tvb, 0, -1, ENC_NA);
miop_tree = proto_item_add_subtree (ti, ett_miop);
/* XXX - Should we bail out if we don't have the right magic number? */
tvb_ip_to_str(tvb, 12));
if (tree) {
- ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, ENC_NA);
mip_tree = proto_item_add_subtree(ti, ett_mip);
/* type */
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, ENC_NA);
mip_tree = proto_item_add_subtree(ti, ett_mip);
/* Type */
if (tree) {
/* Add Subtree */
- ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, ENC_NA);
mip_tree = proto_item_add_subtree(ti, ett_mip);
/* Type */
tvb_ip_to_str(tvb, 12));
if (tree) {
- ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, ENC_NA);
mip_tree = proto_item_add_subtree(ti, ett_mip);
/* type */
tvb_ip_to_str(tvb, 4));
if (tree) {
- ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mip, tvb, offset, -1, ENC_NA);
mip_tree = proto_item_add_subtree(ti, ett_mip);
/* type */
len = (tvb_get_guint8(tvb, MIP6_HLEN_OFF) + 1) * 8;
pproto = tvb_get_guint8(tvb, MIP6_PROTO_OFF);
if (tree) {
- ti = proto_tree_add_item(tree, proto_mip6, tvb, 0, len, FALSE);
+ ti = proto_tree_add_item(tree, proto_mip6, tvb, 0, len, ENC_NA);
mip6_tree = proto_item_add_subtree(ti, ett_mip6);
/* Process header fields */
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_mms, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_mms, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_mms);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MMS");
/*--- proto_register_mms -------------------------------------------*/
void proto_register_mms(void) {
-
+
/* List of fields */
static hf_register_info hf[] =
{
static gboolean
dissect_mms_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
-{
+{
/* must check that this really is an mms packet */
int offset = 0;
guint32 length = 0 ;
gint8 tmp_class;
gboolean tmp_pc;
gint32 tmp_tag;
-
+
/* first, check do we have at least 2 bytes (pdu) */
if (!tvb_bytes_exist(tvb, 0, 2))
return FALSE; /* no */
-
+
/* can we recognize MMS PDU ? Return FALSE if not */
/* get MMS PDU type */
offset = get_ber_identifier(tvb, offset, &tmp_class, &tmp_pc, &tmp_tag);
-
+
/* check MMS type */
-
- /* Class should be constructed */
+
+ /* Class should be constructed */
if (tmp_class!=BER_CLASS_CON)
return FALSE;
-
+
/* see if the tag is a valid MMS PDU */
match_strval_idx(tmp_tag, mms_MMSpdu_vals, &idx);
- if (idx == -1) {
+ if (idx == -1) {
return FALSE; /* no, it isn't an MMS PDU */
}
-
+
/* check MMS length */
oct = tvb_get_guint8(tvb, offset)& 0x7F;
if (oct==0)
/* MMS requires length after tag so not MMS if indefinite length*/
return FALSE;
-
+
offset = get_ber_length(tvb, offset, &length, NULL);
/* do we have enough bytes? */
if (!tvb_bytes_exist(tvb, offset, length))
- return FALSE;
-
+ return FALSE;
+
dissect_mms(tvb, pinfo, parent_tree);
- return TRUE;
+ return TRUE;
}
/*--- proto_reg_handoff_mms --- */
if (tree) {
DebugLog(("tree != NULL\n"));
- ti = proto_tree_add_item(tree, proto_mmse, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mmse, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Type: %s", message_type);
/* create display subtree for the protocol */
mmse_tree = proto_item_add_subtree(ti, ett_mmse);
if (tree) {
/* Header dissection */
ti = proto_tree_add_item(tree, proto_mndp, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
mndp_tree = proto_item_add_subtree(ti, ett_mndp);
proto_tree_add_item(mndp_tree, hf_mndp_header_unknown, tvb, offset, 2,
proto_tree *mp2t_af_tree = NULL;
proto_tree *mp2t_analysis_tree = NULL;
- ti = proto_tree_add_item( tree, proto_mp2t, tvb, offset, MP2T_PACKET_SIZE, FALSE );
+ ti = proto_tree_add_item( tree, proto_mp2t, tvb, offset, MP2T_PACKET_SIZE, ENC_NA );
mp2t_tree = proto_item_add_subtree( ti, ett_mp2t );
header = tvb_get_ntohl(tvb, offset);
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MP4V-ES");
if (tree) {
- item = proto_tree_add_item(tree, proto_mp4ves, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_mp4ves, tvb, 0, -1, ENC_NA);
mp4ves_tree = proto_item_add_subtree(item, ett_mp4ves);
/*
+------+------+------+------+
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MPEG");
col_clear(pinfo->cinfo, COL_INFO);
if (tree)
- proto_tree_add_item(tree, proto_mpeg, tvb, 0, -1, FALSE);
+ proto_tree_add_item(tree, proto_mpeg, tvb, 0, -1, ENC_NA);
}
}
if ( tree )
{
- ti = proto_tree_add_item( tree, proto_mpg, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_mpg, tvb, offset, -1, ENC_NA );
mpg_tree = proto_item_add_subtree( ti, ett_mpg );
proto_tree_add_uint( mpg_tree, hf_rtp_mpg_mbz, tvb, offset, 1, mpg_mbz );
((MSGTYPE_MPLS_ECHO(msgtype)) && (rem < 32)) ) {
col_set_str(pinfo->cinfo, COL_INFO, "Malformed Message");
if(tree) {
- ti = proto_tree_add_item(tree, proto_mpls_echo, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mpls_echo, tvb, 0, -1, ENC_NA);
mpls_echo_tree = proto_item_add_subtree(ti, ett_mpls_echo);
proto_tree_add_text(mpls_echo_tree, tvb, offset, rem,
"Error processing Message: length is %d, should be >= %u",
if (tree) {
/* Add subtree and dissect the fixed part of the message */
- ti = proto_tree_add_item(tree, proto_mpls_echo, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mpls_echo, tvb, 0, -1, ENC_NA);
mpls_echo_tree = proto_item_add_subtree(ti, ett_mpls_echo);
proto_tree_add_item(mpls_echo_tree,
res = tvb_get_guint8(tvb, 1);
channel_type = tvb_get_ntohs(tvb, 2);
if (tree) {
- ti = proto_tree_add_item(tree, proto_pw_ach, tvb, 0, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_pw_ach, tvb, 0, 4, ENC_NA);
mpls_pw_ach_tree = proto_item_add_subtree(ti, ett_mpls_pw_ach);
if (mpls_pw_ach_tree == NULL)
return;
length = tvb_get_guint8(tvb, 1) & 0x3F;
sequence_number = tvb_get_ntohs(tvb, 2);
if (tree) {
- ti = proto_tree_add_item(tree, proto_pw_mcw, tvb, 0, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_pw_mcw, tvb, 0, 4, ENC_NA);
mpls_pw_mcw_tree = proto_item_add_subtree(ti, ett_mpls_pw_mcw);
if (mpls_pw_mcw_tree == NULL)
return;
if (tree) {
- ti = proto_tree_add_item(tree, proto_mpls, tvb, offset, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_mpls, tvb, offset, 4, ENC_NA);
mpls_tree = proto_item_add_subtree(ti, ett_mpls);
proto_item_append_text(ti, ", Label: %u", label);
if (tree)
{
- ti = proto_tree_add_item(tree, proto_mqpcf, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mqpcf, tvb, offset, -1, ENC_NA);
proto_item_append_text(ti, " (%s)", val_to_str(iCommand, mqpcf_opcode_vals, "Unknown (0x%02x)"));
mqroot_tree = proto_item_add_subtree(ti, ett_mqpcf);
return offset+tvb_length_remaining(tvb, offset);
}
- item = proto_tree_add_item(parent_tree, proto_mrdisc, tvb, offset, 0, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_mrdisc, tvb, offset, 0, ENC_NA);
tree = proto_item_add_subtree(item, ett_mrdisc);
int msg_offset; /* Use when handling multiple messages. This points to current msg being decoded. */
int vect_offset; /* Use when handling multiple vector attributes. This points to the current vector attribute being decoded. */
- ti = proto_tree_add_item(tree, proto_msrp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_msrp, tvb, 0, -1, ENC_NA);
msrp_tree = proto_item_add_subtree(ti, ett_msrp);
proto_tree_add_item(msrp_tree, hf_msrp_proto_id, tvb, MSRP_PROTOCOL_VERSION_OFFSET, 1, ENC_BIG_ENDIAN);
/* Create MSMMS control protocol tree */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_msmms, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_msmms, tvb, offset, -1, ENC_NA);
msmms_tree = proto_item_add_subtree(ti, ett_msmms_command);
}
/* Create MSMMS data protocol tree */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_msmms, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_msmms, tvb, offset, -1, ENC_NA);
msmms_tree = proto_item_add_subtree(ti, ett_msmms_data);
}
/* Create MSMMS data protocol tree */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_msmms, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_msmms, tvb, offset, -1, ENC_NA);
msmms_tree = proto_item_add_subtree(ti, ett_msmms_data);
}
guint8 type;
guint16 length;
- ti = proto_tree_add_item(tree, proto_msdp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_msdp, tvb, 0, -1, ENC_NA);
msdp_tree = proto_item_add_subtree(ti, ett_msdp);
offset = 0;
/*
* Put the first line from the buffer into the summary.
*/
- col_add_str(pinfo->cinfo, COL_INFO,
+ col_add_str(pinfo->cinfo, COL_INFO,
format_text(line, linelen));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_msnms, tvb, offset, -1,
- FALSE);
+ ENC_NA);
msnms_tree = proto_item_add_subtree(ti, ett_msnms);
/*
return offset+tvb_length_remaining(tvb, offset);
}
- item = proto_tree_add_item(parent_tree, proto_msnip, tvb, offset, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_msnip, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_msnip);
col_set_str(pinfo->cinfo, COL_INFO, "MS NLB heartbeat");
if (tree) {
- ti = proto_tree_add_item(tree, proto_msnlb, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_msnlb, tvb, 0, -1, ENC_NA);
msnlb_tree = proto_item_add_subtree(ti, ett_msnlb);
type = tvb_get_guint8(tvb, offset);
if ( tree) {
ti = proto_tree_add_item( tree, proto_msproxy, tvb, 0, 0,
- FALSE );
+ ENC_NA );
msp_tree = proto_item_add_subtree(ti, ett_msproxy);
if (tree) { /* if proto tree, decode data */
ti = proto_tree_add_item( tree, proto_msproxy, tvb, 0, -1,
- FALSE );
+ ENC_NA );
msproxy_tree = proto_item_add_subtree(ti, ett_msproxy);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_msrp, tvb, 0, message_end_offset, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_msrp, tvb, 0, message_end_offset, ENC_NA);
msrp_tree = proto_item_add_subtree(ti, ett_msrp);
if (is_msrp_response){
mstp_frame_source, mstp_frame_destination,
mstp_frame_type_text(mstp_frame_type));
#else
- ti = proto_tree_add_item(tree, proto_mstp, tvb, offset, 8, FALSE);
+ ti = proto_tree_add_item(tree, proto_mstp, tvb, offset, 8, ENC_NA);
#endif
subtree = proto_item_add_subtree(ti, ett_bacnet_mstp);
proto_tree_add_item(subtree, hf_mstp_preamble_55, tvb,
if (tree) {
proto_item *type_ti;
ti = proto_tree_add_item(tree, proto_multipart,
- tvb, 0, -1, ENC_BIG_ENDIAN);
+ tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_multipart);
proto_item_append_text(ti, ", Type: %s, Boundary: \"%s\"",
m_info->type, m_info->boundary);
/*@param proto_mux27010: Protocol name*/
/*@param tvb: Buffer to dissect (data for protocol)*/
/*@param "0" and "-1": All data is for the protocol*/
- ti = proto_tree_add_item(tree, proto_mux27010, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_mux27010, tvb, 0, -1, ENC_NA);
/*Add a subtree to the protocol tree (child node)*/
mux27010_tree = proto_item_add_subtree(ti, ett_mux27010);
/* make entry in the Protocol column on summary display */
col_append_str(pinfo->cinfo, COL_PROTOCOL, "/NAS-EPS");
- item = proto_tree_add_item(tree, proto_nas_eps, tvb, 0, -1, ENC_BIG_ENDIAN);
+ item = proto_tree_add_item(tree, proto_nas_eps, tvb, 0, -1, ENC_NA);
nas_eps_tree = proto_item_add_subtree(item, ett_nas_eps);
/* Security header type Security header type 9.3.1 M V 1/2 */
/* Integrity protected and ciphered = 2, Integrity protected and ciphered with new EPS security context = 4 */
pd = tvb_get_guint8(tvb,offset)&0x0f;
#if 0
- /* Does not work see Bug https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=6348
+ /* Does not work see Bug https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=6348
* 9.2 Protocol discriminator
* :
- * The protocol discriminator in the header (see 3GPP TS 24.007 [12]) of a
+ * The protocol discriminator in the header (see 3GPP TS 24.007 [12]) of a
* security protected NAS message is encoded as "EPS mobility management messages".
* XXX Should we check for PD == 7?
*/
/* make entry in the Protocol column on summary display */
col_append_str(pinfo->cinfo, COL_PROTOCOL, "/NAS-EPS");
- item = proto_tree_add_item(tree, proto_nas_eps, tvb, 0, -1, ENC_BIG_ENDIAN);
+ item = proto_tree_add_item(tree, proto_nas_eps, tvb, 0, -1, ENC_NA);
nas_eps_tree = proto_item_add_subtree(item, ett_nas_eps);
pd = tvb_get_guint8(tvb,offset)&0x0f;
/* Initialize the subtree pointers */
static gint ett_nasdaq_soup = -1;
-static int hf_nasdaq_soup_packet_type = -1;
-static int hf_nasdaq_soup_message = -1;
-static int hf_nasdaq_soup_text = -1;
-static int hf_nasdaq_soup_packet_eol = -1;
-static int hf_nasdaq_soup_username = -1;
-static int hf_nasdaq_soup_password = -1;
-static int hf_nasdaq_soup_session = -1;
-static int hf_nasdaq_soup_seq_number = -1;
-static int hf_nasdaq_soup_reject_code = -1;
+static int hf_nasdaq_soup_packet_type = -1;
+static int hf_nasdaq_soup_message = -1;
+static int hf_nasdaq_soup_text = -1;
+static int hf_nasdaq_soup_packet_eol = -1;
+static int hf_nasdaq_soup_username = -1;
+static int hf_nasdaq_soup_password = -1;
+static int hf_nasdaq_soup_session = -1;
+static int hf_nasdaq_soup_seq_number = -1;
+static int hf_nasdaq_soup_reject_code = -1;
static void
dissect_nasdaq_soup_packet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, proto_tree *tree, int offset, int linelen)
}
counter++;
if (tree) {
- ti = proto_tree_add_item(tree, proto_nasdaq_soup, tvb, offset, linelen +1, FALSE);
+ ti = proto_tree_add_item(tree, proto_nasdaq_soup, tvb, offset, linelen +1, ENC_NA);
nasdaq_soup_tree = proto_item_add_subtree(ti, ett_nasdaq_soup);
}
dissect_nasdaq_soup_packet(tvb, pinfo, tree, nasdaq_soup_tree, offset, linelen);
dissector_add_uint("tcp.port", port, nasdaq_soup_handle);
}
-static void nasdaq_soup_prefs(void)
+static void nasdaq_soup_prefs(void)
{
range_foreach(nasdaq_soup_tcp_range, range_delete_nasdaq_soup_tcp_callback);
g_free(nasdaq_soup_tcp_range);
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
- { &hf_nasdaq_soup_packet_type,
+ { &hf_nasdaq_soup_packet_type,
{ "Packet Type", "nasdaq-soup.packet_type",
FT_UINT8, BASE_DEC, VALS(message_types_val), 0x0,
NULL, HFILL }},
length = tvb_get_guint8(tvb, offset+2);
ti = proto_tree_add_item(tree, proto_nb_rtpmux, tvb, offset,
- length+5, FALSE);
+ length+5, ENC_NA);
nb_rtpmux_tree = proto_item_add_subtree(ti, ett_nb_rtpmux);
/* XXX - what if the T bit is set? */
proto_tree_add_uint(nb_rtpmux_tree, hf_nb_rtpmux_dstport, tvb, offset, 2, dstport );
proto_tree_add_item(nb_rtpmux_tree,
hf_nb_rtpmux_length, tvb, offset+2, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(nb_rtpmux_tree, hf_nb_r_bit, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(nb_rtpmux_tree, hf_nb_r_bit, tvb, offset, 1, ENC_BIG_ENDIAN);
srcport = (tvb_get_ntohs(tvb, offset+3) & 0x7fff) << 1;
proto_tree_add_uint(nb_rtpmux_tree, hf_nb_rtpmux_srcport, tvb, offset+3, 2, srcport );
cmp_rtp_item = proto_tree_add_text( nb_rtpmux_tree, tvb, offset+5, 3, "Compressed RTP header" );
proto_tree_add_uint(nb_rtpmux_tree, hf_nb_rtpmux_dstport, tvb, offset, 2, dstport );
proto_tree_add_item(nb_rtpmux_tree,
hf_nb_rtpmux_length, tvb, offset+2, 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(nb_rtpmux_tree, hf_nb_r_bit, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(nb_rtpmux_tree, hf_nb_r_bit, tvb, offset, 1, ENC_BIG_ENDIAN);
srcport = (tvb_get_ntohs(tvb, offset+3) & 0x7fff) << 1;
proto_tree_add_uint(nb_rtpmux_tree, hf_nb_rtpmux_srcport, tvb, offset+3, 2, srcport );
{ "Sequence Number", "nb_rtpmux.cmp_rtp.sequence_no",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
- },
+ },
{ &hf_nb_rtpmux_cmp_rtp_timestamp,
{ "Timestamp", "nb_rtpmux.cmp_rtp.timestamp",
FT_UINT16, BASE_DEC, NULL, 0x00,
- NULL, HFILL }
+ NULL, HFILL }
},
{ &hf_nb_rtpmux_cmp_rtp_data,
{ "RTP Data", "nb_rtpmux.cmp_rtp.data",
col_set_str(pinfo->cinfo, COL_PROTOCOL, "NBAP");
/* create the nbap protocol tree */
- nbap_item = proto_tree_add_item(tree, proto_nbap, tvb, 0, -1, FALSE);
+ nbap_item = proto_tree_add_item(tree, proto_nbap, tvb, 0, -1, ENC_NA);
nbap_tree = proto_item_add_subtree(nbap_item, ett_nbap);
-
+
dissect_NBAP_PDU_PDU(tvb, pinfo, nbap_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_nbap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("nbap", dissect_nbap, proto_nbap);
col_clear(pinfo->cinfo, COL_INFO);
- item = proto_tree_add_item(parent_tree, proto_nbd, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_nbd, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_nbd);
if (tree) {
ti = proto_tree_add_item(tree, proto_nbipx, tvb, 0,
- -1, FALSE);
+ -1, ENC_NA);
nbipx_tree = proto_item_add_subtree(ti, ett_nbipx);
}
case NBIPX_DIRECTED_DATAGRAM:
if (check_col(pinfo->cinfo, COL_INFO)) {
- col_add_str(pinfo->cinfo, COL_INFO,
+ col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(packet_type, nbipx_data_stream_type_vals, "Unknown"));
}
dissect_conn_control(tvb, offset, nbipx_tree);
default:
if (check_col(pinfo->cinfo, COL_INFO)) {
- col_add_str(pinfo->cinfo, COL_INFO,
+ col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(packet_type, nbipx_data_stream_type_vals, "Unknown"));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_nmpi, tvb, offset, 68,
- FALSE);
+ ENC_NA);
nmpi_tree = proto_item_add_subtree(ti, ett_nmpi);
add_routers(nmpi_tree, tvb, offset);
if (tree) {
ti = proto_tree_add_item(tree, proto_nbns, tvb, offset, -1,
- FALSE);
+ ENC_NA);
nbns_tree = proto_item_add_subtree(ti, ett_nbns);
proto_tree_add_uint(nbns_tree, hf_nbns_transaction_id, tvb,
if (tree) {
ti = proto_tree_add_item(tree, proto_nbdgm, tvb, offset, -1,
- FALSE);
+ ENC_NA);
nbdgm_tree = proto_item_add_subtree(ti, ett_nbdgm);
proto_tree_add_uint(nbdgm_tree, hf_nbdgm_type, tvb,
msg_type = tvb_get_guint8(tvb, offset);
if (tree) {
- ti = proto_tree_add_item(tree, proto_nbss, tvb, offset, length + 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_nbss, tvb, offset, length + 4, ENC_NA);
nbss_tree = proto_item_add_subtree(ti, ett_nbss);
proto_tree_add_item(nbss_tree, hf_nbss_type, tvb, offset, 1, ENC_NA);
col_set_str(pinfo->cinfo, COL_INFO, "NBSS Continuation Message");
if (tree) {
- ti = proto_tree_add_item(tree, proto_nbss, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_nbss, tvb, 0, -1, ENC_NA);
nbss_tree = proto_item_add_subtree(ti, ett_nbss);
proto_tree_add_text(nbss_tree, tvb, 0, -1, "Continuation data");
}
ncp_hdr = &header;
- ti = proto_tree_add_item(tree, proto_ncp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ncp, tvb, 0, -1, ENC_NA);
ncp_tree = proto_item_add_subtree(ti, ett_ncp);
if (is_tcp) {
if (tvb_get_ntohl(tvb, hdr_offset) != NCPIP_RQST && tvb_get_ntohl(tvb, hdr_offset) != NCPIP_RPLY)
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-
-
+
+
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
{
proto_tree *ncs_tree = NULL;
proto_item *ti;
-
+
if (tree) {
- ti = proto_tree_add_item(tree, proto_ncs, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ncs, tvb, 0, -1, ENC_NA);
ncs_tree = proto_item_add_subtree(ti, ett_ncs);
}
* Add the record marker information to the tree
*/
if (tree) {
- ndmp_item = proto_tree_add_item(tree, proto_ndmp, tvb, 0, -1, FALSE);
+ ndmp_item = proto_tree_add_item(tree, proto_ndmp, tvb, 0, -1, ENC_NA);
ndmp_tree = proto_item_add_subtree(ndmp_item, ett_ndmp);
}
hdr_item = proto_tree_add_text(ndmp_tree, tvb, 0, 4,
col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDMP");
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ndmp_item = proto_tree_add_item(tree, proto_ndmp, tvb, 0, -1, FALSE);
+ ndmp_item = proto_tree_add_item(tree, proto_ndmp, tvb, 0, -1, ENC_NA);
ndmp_tree = proto_item_add_subtree(ndmp_item, ett_ndmp);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_ndps, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ndps, tvb, 0, -1, ENC_NA);
ndps_tree = proto_item_add_subtree(ti, ett_ndps);
}
dissect_ndps(tvb, pinfo, ndps_tree);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_ndps, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ndps, tvb, 0, -1, ENC_NA);
ndps_tree = proto_item_add_subtree(ti, ett_ndps);
}
ndps_defrag(tvb, pinfo, ndps_tree);
}
if ( tree) {
- ti = proto_tree_add_item(tree, proto_netbios, tvb, 0, hdr_len, FALSE);
+ ti = proto_tree_add_item(tree, proto_netbios, tvb, 0, hdr_len, ENC_NA);
netb_tree = proto_item_add_subtree(ti, ett_netb);
proto_tree_add_uint_format(netb_tree, hf_netb_hdr_len, tvb, offset, 2, hdr_len,
/* packet-netdump.c
* Routines for Netdump dissection
- * Copyright 2009, Neil Horman <nhorman@tuxdriver.com>
+ * Copyright 2009, Neil Horman <nhorman@tuxdriver.com>
*
* $Id$
*
if (tree) { /* we are being asked for details */
proto_item *ti = NULL;
proto_tree *netdump_tree = NULL;
- ti = proto_tree_add_item(tree, proto_netdump, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_netdump, tvb, 0, -1, ENC_NA);
netdump_tree = proto_item_add_subtree(ti, ett_netdump);
if (tvb_reported_length(tvb) == 24) {
/* Its a request format packet */
necessary to generate protocol tree items. */
if (tree) {
/* create the npmp protocol tree */
- npmp_item = proto_tree_add_item(tree, proto_npmp, message_tvb, 0, -1, FALSE);
+ npmp_item = proto_tree_add_item(tree, proto_npmp, message_tvb, 0, -1, ENC_NA);
npmp_tree = proto_item_add_subtree(npmp_item, ett_npmp);
} else {
npmp_tree = NULL;
return;
while (tvb_reported_length_remaining(tvb, offset) > 0) {
- ti = proto_tree_add_item(tree, proto_netsync, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_netsync, tvb, offset, -1, ENC_NA);
netsync_tree = proto_item_add_subtree(ti, ett_netsync);
version = tvb_get_guint8(tvb, offset);
* don't bother with the "Copied from" - you don't even need to put
* in a "Copied from" if you copied an existing dissector, especially
* if the bulk of the code in the new dissector is your code)
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
col_set_str(pinfo->cinfo, COL_INFO, "Microsoft Exchange new mail notification");
if (tree) {
- ti = proto_tree_add_item(tree, proto_newmail, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_newmail, tvb, 0, -1, ENC_NA);
newmail_tree = proto_item_add_subtree(ti, ett_newmail);
/* Register the protocol with Wireshark */
void
proto_register_newmail(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_newmail_payload,
{ "Notification payload", "newmail.notification_payload",
- FT_BYTES, BASE_NONE, NULL, 0x0,
+ FT_BYTES, BASE_NONE, NULL, 0x0,
"Payload requested by client in the MAPI register push notification packet", HFILL }
},
};
/* Register the dissector without a port yet */
register_dissector("newmail", dissect_newmail, proto_newmail);
-
+
/* Register preferences module */
newmail_module = prefs_register_protocol(proto_newmail,
proto_reg_handoff_newmail);
"Default UDP port (optional)",
"Always dissect this port's traffic as newmail notifications. Additional ports will be dynamically registered as they are seen in MAPI register push notification packets.",
10, &preference_default_port);
-
+
}
void
if (preference_default_port_last != 0) {
dissector_delete_uint("udp.port", preference_default_port_last, newmail_handle);
}
- }
+ }
- if(preference_default_port != 0) {
+ if(preference_default_port != 0) {
dissector_add_uint("udp.port", preference_default_port, newmail_handle);
}
preference_default_port_last = preference_default_port;
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_nlsp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_nlsp, tvb, 0, -1, ENC_NA);
nlsp_tree = proto_item_add_subtree(ti, ett_nlsp);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_nntp, tvb, offset, -1,
- FALSE);
+ ENC_NA);
nntp_tree = proto_item_add_subtree(ti, ett_nntp);
if (pinfo->match_uint == pinfo->destport) {
if (tree) {
bi.ti = proto_tree_add_item(tree, proto_nsip, tvb, 0, -1,
- FALSE);
+ ENC_NA);
nsip_tree = proto_item_add_subtree(bi.ti, ett_nsip);
proto_tree_add_uint_format(nsip_tree, hf_nsip_pdu_type, tvb, 0, 1,
pdu_type,
col_set_str(pinfo->cinfo, COL_INFO, "NSRP Protocol");
if (tree) {
- ti = proto_tree_add_item(tree, proto_nsrp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_nsrp, tvb, 0, -1, ENC_NA);
nsrp_tree = proto_item_add_subtree(ti, ett_nsrp);
if (tree) {
tf = proto_tree_add_item (tree,
proto_ntlmssp,
- tvb, offset, -1, FALSE);
+ tvb, offset, -1, ENC_NA);
ntlmssp_tree = proto_item_add_subtree (tf,
ett_ntlmssp);
dissect_ntlmssp(tvb, pinfo, parent_tree);
return TRUE;
}
-
+
return FALSE;
}
}
/* Adding NTP item and subtree */
- ti = proto_tree_add_item(tree, proto_ntp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_ntp, tvb, 0, -1, ENC_NA);
ntp_tree = proto_item_add_subtree(ti, ett_ntp);
/* Show version and mode in info column and NTP root */
*
* If it's an IRIX or UNICOS/mp DLT_NULL header, the upper 4 hex
* digits would be zero and the next 2 hex digits would not be zero.
- * Furthermore, the third hex digit from the bottom would be <
+ * Furthermore, the third hex digit from the bottom would be <
*/
if (!BYTES_ARE_IN_FRAME(0, len, 2)) {
ld->other++;
*/
if (null_header > IEEE_802_3_MAX_LEN) {
if (tree) {
- ti = proto_tree_add_item(tree, proto_null, tvb, 0, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_null, tvb, 0, 4, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_null);
proto_tree_add_uint(fh_tree, hf_null_etype, tvb, 0, 4,
(guint16) null_header);
/* populate a tree in the second pane with the status of the link
layer (ie none) */
if (tree) {
- ti = proto_tree_add_item(tree, proto_null, tvb, 0, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_null, tvb, 0, 4, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_null);
proto_tree_add_uint(fh_tree, hf_null_family, tvb, 0, 4, null_header);
}
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_ocsp);
}
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_ocsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_ocsp);
}
*
* OICQ is an IM software,which is popular in China. And,
* OICQ has more than 10 millions users at present.
- * The Protocol showed in this file, is found by investigating OICQ's
+ * The Protocol showed in this file, is found by investigating OICQ's
* Packets as a black box.
*
- * The OICQ client software is always changing,and the protocol of
+ * The OICQ client software is always changing,and the protocol of
* communication is also.
*
* Wireshark - Network traffic analyzer
Sequence Number: 16bit unsigned
OICQ Number: 32bit unsigned
Data: Variable Length data
-
+
*
*/
if (tree) {
- ti = proto_tree_add_item(tree, proto_oicq, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_oicq, tvb, 0, -1, ENC_NA);
oicq_tree = proto_item_add_subtree(ti, ett_oicq);
proto_tree_add_item(oicq_tree, hf_oicq_flag, tvb, offset, 1, ENC_BIG_ENDIAN);
offset += 1;
-
+
proto_tree_add_item(oicq_tree, hf_oicq_version, tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
proto_tree_add_item(oicq_tree, hf_oicq_qqid, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
-
+
proto_tree_add_item(oicq_tree, hf_oicq_data, tvb, offset, -1, ENC_ASCII|ENC_NA);
-
-
+
+
}
-
+
return tvb_length(tvb);
}
/*-----------------Fetching Info from IP Packet and Adding to Tree------------------------*/
if (tree) {
- ti = proto_tree_add_item(tree, proto_olsr, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_olsr, tvb, 0, -1, ENC_NA);
olsr_tree = proto_item_add_subtree(ti, ett_olsr);
proto_tree_add_item(olsr_tree, hf_olsr_packet_len, tvb, 0, 2, ENC_BIG_ENDIAN);
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_omapi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_omapi, tvb, 0, -1, ENC_NA);
omapi_tree = proto_item_add_subtree(ti, ett_omapi);
cursor = ptvcursor_new(omapi_tree, tvb, 0);
ptvcursor_add(cursor, hf_omapi_hlength, 4, FALSE);
col_set_str(pinfo->cinfo, COL_INFO, "Status message");
- proto_item_append_text(ti, ", Status message");
+ proto_item_append_text(ti, ", Status message");
return;
}
{
col_append_str(pinfo->cinfo, COL_INFO, "Status message");
}
- proto_item_append_text(ti, ", Status message");
+ proto_item_append_text(ti, ", Status message");
}
ptvcursor_add(cursor, hf_omapi_auth_id, 4, FALSE);
authlength = tvb_get_ntohl(tvb, ptvcursor_current_offset(cursor));
ptvcursor_add(cursor, hf_omapi_auth_len, 4, FALSE);
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
{
col_append_sep_str(pinfo->cinfo, COL_INFO, NULL,
val_to_str(tvb_get_ntohl(tvb, ptvcursor_current_offset(cursor)), omapi_opcode_vals, "Unknown opcode (0x%04x)"));
}
- proto_item_append_text(ti, ", Opcode: %s",
+ proto_item_append_text(ti, ", Opcode: %s",
val_to_str(tvb_get_ntohl(tvb, ptvcursor_current_offset(cursor)), omapi_opcode_vals, "Unknown opcode (0x%04x)"));
ptvcursor_add(cursor, hf_omapi_opcode, 4, FALSE);
else if (msglength == (guint32)~0)
{
proto_tree_add_text(omapi_tree, tvb, 0, 0, "No value");
- }
+ }
else
{
ptvcursor_add(cursor, hf_omapi_msg_value, msglength, FALSE);
else if (objlength == (guint32)~0)
{
proto_tree_add_text(omapi_tree, tvb, 0, 0, "No value");
- }
+ }
else
{
ptvcursor_add(cursor, hf_omapi_obj_value, objlength, FALSE);
}
if (tree) { /* we are being asked for details */
- ti = proto_tree_add_item(tree, proto_omron_fins, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_omron_fins, tvb, 0, -1, ENC_NA);
omron_tree = proto_item_add_subtree(ti, ett_omron);
ti = proto_tree_add_text(omron_tree, tvb, 0, 12, "Omron Header");
if ( tree )
{
/* create the opensafety protocol tree */
- opensafety_item = proto_tree_add_item(tree, proto_opensafety, message_tvb, frameOffset, frameLength, ENC_BIG_ENDIAN);
+ opensafety_item = proto_tree_add_item(tree, proto_opensafety, message_tvb, frameOffset, frameLength, ENC_NA);
opensafety_tree = proto_item_add_subtree(opensafety_item, ett_opensafety);
if ( dissect_opensafety_message(frameStart1, frameStart2, type, next_tvb, pinfo, opensafety_tree, found) == TRUE )
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_opsi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_opsi, tvb, 0, -1, ENC_NA);
opsi_tree = proto_item_add_subtree(ti, ett_opsi);
if (tvb_length(tvb) < 8 ) {
proto_tree_add_text(opsi_tree, tvb, 0, -1, "Too short OPSI packet!");
static void cotp_frame_end(void)
{
if (!cotp_last_fragment) {
- /* Last COTP in frame is not fragmented.
+ /* Last COTP in frame is not fragmented.
* No need for incrementing the dst_ref, so we decrement it here.
*/
cotp_dst_ref--;
src_ref, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu);
p_add_proto_data (pinfo->fd, proto_clnp, prev_dst_ref);
} else if (cotp_frame_reset) {
cotp_dst_ref = *prev_dst_ref;
- }
+ }
cotp_frame_reset = FALSE;
cotp_last_fragment = fragment;
dst_ref = cotp_dst_ref;
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
fragment_length = tvb_length(next_tvb);
if (check_col(pinfo->cinfo, COL_INFO)) {
if(fragment) {
- col_append_fstr(pinfo->cinfo, COL_INFO, " [COTP fragment, %u byte%s]",
+ col_append_fstr(pinfo->cinfo, COL_INFO, " [COTP fragment, %u byte%s]",
fragment_length, plurality(fragment_length, "", "s"));
} else {
col_append_fstr(pinfo->cinfo, COL_INFO, " EOT");
tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
item = proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu);
dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
tpdu_nr, dst_ref, cdt_in_ak);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
"EA TPDU (%u) dst-ref: 0x%04x", tpdu_nr, dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
}
col_append_fstr(pinfo->cinfo, COL_INFO, "ER TPDU dst-ref: 0x%04x", dst_ref);
if (tree) {
- ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cotp, tvb, offset, li + 1, ENC_NA);
cotp_tree = proto_item_add_subtree(ti, ett_cotp);
proto_tree_add_uint(cotp_tree, hf_cotp_li, tvb, offset, 1,li);
proto_tree_add_uint(cotp_tree, hf_cotp_type, tvb, offset + 1, 1, tpdu);
col_append_str(pinfo->cinfo, COL_INFO, "UD TPDU");
if (tree) {
- ti = proto_tree_add_item(tree, proto_cltp, tvb, offset, li + 1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_cltp, tvb, offset, li + 1, ENC_NA);
cltp_tree = proto_item_add_subtree(ti, ett_cltp);
proto_tree_add_uint(cltp_tree, hf_cltp_li, tvb, offset, 1,li);
}
if (tree) {
ospflen = tvb_get_ntohs(tvb, 2);
- ti = proto_tree_add_item(tree, proto_ospf, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ospf, tvb, 0, -1, ENC_NA);
ospf_tree = proto_item_add_subtree(ti, ett_ospf);
ti = proto_tree_add_text(ospf_tree, tvb, 0, ospf_header_length,
/* First fetch PDU Type */
pdu_type = tvb_get_guint8 (tvb, offset + 3) & 0x3F;
- ti = proto_tree_add_item (tree, proto_p_mul, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item (tree, proto_p_mul, tvb, offset, -1, ENC_NA);
proto_item_append_text (ti, ", %s", get_type (pdu_type));
p_mul_tree = proto_item_add_subtree (ti, ett_p_mul);
proto_tree *packetbb_tree = NULL;
guint offset;
- ti = proto_tree_add_item(tree, proto_packetbb, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_packetbb, tvb, 0, -1, ENC_NA);
packetbb_tree = proto_item_add_subtree(ti, ett_packetbb);
offset = dissect_pbb_header(tvb, packetbb_tree);
/* Detect if this TCP session is a Paltalk one */
/* TODO: Optimize detection logic if possible */
- if ((pinfo->net_src.type != AT_IPv4)
+ if ((pinfo->net_src.type != AT_IPv4)
|| (pinfo->net_dst.type != AT_IPv4)
|| (pinfo->net_src.len != 4)
|| (pinfo->net_dst.len != 4)
- || !pinfo->net_src.data
+ || !pinfo->net_src.data
|| !pinfo->net_dst.data)
return FALSE;
memcpy((guint8 *)&src32, pinfo->net_src.data, 4); /* *Network* order */
memcpy((guint8 *)&dst32, pinfo->net_dst.data, 4); /* *Network* order */
- if ( ((src32 & PALTALK_SERVERS_NETMASK) != PALTALK_SERVERS_ADDRESS)
+ if ( ((src32 & PALTALK_SERVERS_NETMASK) != PALTALK_SERVERS_ADDRESS)
&&
((dst32 & PALTALK_SERVERS_NETMASK) != PALTALK_SERVERS_ADDRESS))
return FALSE;
if (tree) /* we are being asked for details */
{
- ti = proto_tree_add_item(tree, proto_paltalk, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_paltalk, tvb, 0, -1, ENC_NA);
pt_tree = proto_item_add_subtree(ti, ett_paltalk);
proto_tree_add_item(pt_tree, hf_paltalk_pdu_type, tvb, 0, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(pt_tree, hf_paltalk_version, tvb, 2, 2, ENC_BIG_ENDIAN);
proto_register_paltalk(void)
{
static hf_register_info hf[] = {
- { &hf_paltalk_pdu_type, { "Packet Type", "paltalk.type",
+ { &hf_paltalk_pdu_type, { "Packet Type", "paltalk.type",
FT_UINT16, BASE_HEX, NULL, 0x00, NULL, HFILL }},
{ &hf_paltalk_version, { "Protocol Version", "paltalk.version",
FT_INT16, BASE_DEC, NULL, 0x00, NULL, HFILL }},
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PCAP");
/* create the pcap protocol tree */
- pcap_item = proto_tree_add_item(tree, proto_pcap, tvb, 0, -1, FALSE);
+ pcap_item = proto_tree_add_item(tree, proto_pcap, tvb, 0, -1, ENC_NA);
pcap_tree = proto_item_add_subtree(pcap_item, ett_pcap);
-
+
dissect_PCAP_PDU_PDU(tvb, pinfo, pcap_tree);
}
proto_register_subtree_array(ett, array_length(ett));
pcap_module = prefs_register_protocol(proto_pcap, proto_reg_handoff_pcap);
-
+
/* Register dissector */
register_dissector("pcap", dissect_pcap, proto_pcap);
col_append_fstr(pinfo->cinfo, COL_INFO, "%s", val_to_str(message_type, message_type_vals, "Unknown Message (%u). "));
}
- ti = proto_tree_add_item(tree, proto_pcep, tvb, offset, msg_length, FALSE);
+ ti = proto_tree_add_item(tree, proto_pcep, tvb, offset, msg_length, ENC_NA);
pcep_tree = proto_item_add_subtree(ti, tree_mode);
ti = proto_tree_add_text(pcep_tree, tvb, offset, 4, "%s Header", val_to_str(message_type, message_type_vals, "Unknown Message (%u). "));
static int ett_pcli = -1;
-/*
+/*
* Here are the global variables associated with the preferences
* for pcli
*/
/* A static handle for the ip dissector */
static dissector_handle_t ip_handle;
-static void
+static void
dissect_pcli(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
-
+
guint32 cccid;
proto_tree *ti,*pcli_tree;
tvbuff_t * next_tvb;
col_add_fstr(pinfo->cinfo, COL_INFO, "CCCID: %u",cccid);
}
- /*
+ /*
*If we have a non-null tree (ie we are building the proto_tree
* instead of just filling out the columns ), then add a PLCI
* tree node and put a CCCID header element under it.
*/
if(tree) {
- ti = proto_tree_add_item(tree,proto_pcli,tvb,0,0,FALSE);
+ ti = proto_tree_add_item(tree,proto_pcli,tvb,0,0,ENC_NA);
pcli_tree = proto_item_add_subtree(ti,ett_pcli);
proto_tree_add_uint(pcli_tree,hf_pcli_cccid,tvb,
0,4,cccid);
call_dissector(ip_handle,next_tvb,pinfo,tree);
}
-void
+void
proto_register_pcli(void) {
static hf_register_info hf[] = {
{ &hf_pcli_cccid,
}
udp_port_pcli = global_udp_port_pcli;
-
+
dissector_add_uint("udp.port",global_udp_port_pcli,pcli_handle);
}
/* Create pdcp tree. */
if (tree) {
- root_ti = proto_tree_add_item(tree, proto_pdcp_lte, tvb, offset, -1, FALSE);
+ root_ti = proto_tree_add_item(tree, proto_pdcp_lte, tvb, offset, -1, ENC_NA);
pdcp_tree = proto_item_add_subtree(root_ti, ett_pdcp);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PFLOG");
if (tree) {
- ti = proto_tree_add_item(tree, proto_pflog, tvb, offset, 0, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_pflog, tvb, offset, 0, ENC_NA);
pflog_tree = proto_item_add_subtree(ti, ett_pflog);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PFLOG-OLD");
if (tree) {
- ti = proto_tree_add_item(tree, proto_old_pflog, tvb, 0, 0, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_old_pflog, tvb, 0, 0, ENC_NA);
pflog_tree = proto_item_add_subtree(ti, ett_pflog);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIMv1");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, ENC_NA);
pim_tree = proto_item_add_subtree(ti, ett_pim);
/* Put IGMP type, 0x14, into the tree */
if (check_col(pinfo->cinfo, COL_INFO))
col_add_str(pinfo->cinfo, COL_INFO, typestr);
- ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, ENC_NA);
pim_tree = proto_item_add_subtree(ti, ett_pim);
proto_tree_add_item(pim_tree, hf_pim_version, tvb, offset, 1, ENC_BIG_ENDIAN);
necessary to generate protocol tree items. */
if (tree) {
/* create the pingpongprotocol protocol tree */
- pingpongprotocol_item = proto_tree_add_item(tree, proto_pingpongprotocol, message_tvb, 0, -1, FALSE);
+ pingpongprotocol_item = proto_tree_add_item(tree, proto_pingpongprotocol, message_tvb, 0, -1, ENC_NA);
pingpongprotocol_tree = proto_item_add_subtree(pingpongprotocol_item, ett_pingpongprotocol);
} else {
pingpongprotocol_tree = NULL;
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_pkixtsp);
}
if(parent_tree){
- item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, FALSE);
+ item=proto_tree_add_item(parent_tree, proto_pkixtsp, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_pkixtsp);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PKTC");
if (tree) {
- item = proto_tree_add_item(tree, proto_pktc, tvb, 0, 0, FALSE);
+ item = proto_tree_add_item(tree, proto_pktc, tvb, 0, 0, ENC_NA);
pktc_mtafqdn_tree = proto_item_add_subtree(item, ett_pktc_mtafqdn);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PKTC");
if (tree) {
- item = proto_tree_add_item(tree, proto_pktc, tvb, 0, 3, FALSE);
+ item = proto_tree_add_item(tree, proto_pktc, tvb, 0, 3, ENC_NA);
pktc_tree = proto_item_add_subtree(item, ett_pktc);
}
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_pktgen, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pktgen, tvb, 0, -1, ENC_NA);
pktgen_tree = proto_item_add_subtree(ti, ett_pktgen);
/* Lets add a subtree to our dissection to display the info */
- ti = proto_tree_add_item(tree, proto_pnrp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pnrp, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Message Type %s",
val_to_str(message_type, messageType, "Unknown (0x%02x)"));
/* Get a main tree for the whole protocol */
format_text(line, linelen));
}
- ti = proto_tree_add_item(tree, proto_pop, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pop, tvb, offset, -1, ENC_NA);
pop_tree = proto_item_add_subtree(ti, ett_pop);
if (is_continuation) {
if(tree)
{
- ti = proto_tree_add_item(tree, proto_vsncp, tvb, 0, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_vsncp, tvb, 0, length, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_vsncp);
proto_tree_add_text(fh_tree, tvb, 0, 1, "Code: %s (0x%02x)", val_to_str_const(code, cp_vals, "Unknown"), code);
proto_tree_add_text(fh_tree, tvb, 1, 1, "Identifier: 0x%02x", id);
if (tree) /* we are being asked for details */
{
- vsnp_item = proto_tree_add_item(tree, proto_vsnp, tvb, 0, -1, FALSE);
+ vsnp_item = proto_tree_add_item(tree, proto_vsnp, tvb, 0, -1, ENC_NA);
vsnp_tree = proto_item_add_subtree(vsnp_item, ett_vsnp);
proto_tree_add_item(vsnp_tree, hf_vsnp_pdnid, tvb, offset, 1, ENC_BIG_ENDIAN);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_bcp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_bcp, tvb, 0, -1, ENC_NA);
bcp_tree = proto_item_add_subtree(ti, ett_bcp);
}
val_to_str_const(type, bap_vals, "Unknown"));
if(tree) {
- ti = proto_tree_add_item(tree, proto_bap, tvb, 0, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_bap, tvb, 0, length, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_bap_options);
proto_tree_add_text(fh_tree, tvb, 0, 1, "Type: %s (0x%02x)",
val_to_str_const(type, bap_vals, "Unknown"), type);
col_set_str(pinfo->cinfo, COL_INFO, "Compressed data");
if (tree) {
- ti = proto_tree_add_item(tree, proto_comp_data, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_comp_data, tvb, 0, -1, ENC_NA);
comp_data_tree = proto_item_add_subtree(ti, ett_comp_data);
}
}
col_set_str(pinfo->cinfo, COL_INFO, "Compressed data");
if (tree) {
- proto_tree_add_item(tree, proto_comp_data, tvb, 0, -1, FALSE);
+ proto_tree_add_item(tree, proto_comp_data, tvb, 0, -1, ENC_NA);
}
}
#endif
length_remaining = tvb_reported_length(tvb);
if (tree) {
- ti = proto_tree_add_item(tree, proto_pppmux, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pppmux, tvb, 0, -1, ENC_NA);
mux_tree = proto_item_add_subtree(ti,ett_pppmux);
while (length_remaining > 0) {
col_set_str(pinfo->cinfo, COL_INFO, "PPP Multilink");
if (tree) {
- ti = proto_tree_add_item(tree, proto_mp, tvb, 0, mp_short_seqno ? 2 : 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_mp, tvb, 0, mp_short_seqno ? 2 : 4, ENC_NA);
mp_tree = proto_item_add_subtree(ti, ett_mp);
}
proto_tree *fh_tree = NULL;
if(tree) {
- ti = proto_tree_add_item(tree, proto_ppp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ppp, tvb, 0, -1, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_ppp);
}
/* load the top pane info. This should be overwritten by
the next protocol in the stack */
if(tree) {
- ti = proto_tree_add_item(tree, proto_ppp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ppp, tvb, 0, -1, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_ppp);
if (byte0 == 0xff) {
proto_tree_add_item(fh_tree, hf_ppp_address, tvb, 0, 1, ENC_BIG_ENDIAN);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PPP");
if (tree) {
- ti = proto_tree_add_item(tree, proto_ppp_hdlc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ppp_hdlc, tvb, 0, -1, ENC_NA);
bs_tree = proto_item_add_subtree(ti, ett_ppp_hdlc_data);
}
col_add_str(pinfo->cinfo, COL_INFO, val_to_str_const(code, pap_vals, "Unknown"));
if(tree) {
- ti = proto_tree_add_item(tree, proto_pap, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pap, tvb, 0, -1, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_pap);
/* Code */
proto_tree_add_item(fh_tree, hf_pap_code, tvb, offset, 1, ENC_BIG_ENDIAN);
if(tree) {
/* Create CHAP protocol tree */
- ti = proto_tree_add_item(tree, proto_chap, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_chap, tvb, 0, -1, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_chap);
/* Code */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_pppoed, tvb, 0, reported_payload_length+6, FALSE);
+ ti = proto_tree_add_item(tree, proto_pppoed, tvb, 0, reported_payload_length+6, ENC_NA);
pppoe_tree = proto_item_add_subtree(ti, ett_pppoed);
/* Dissect fixed fields */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_pppoes, tvb, 0, 6, FALSE);
+ ti = proto_tree_add_item(tree, proto_pppoes, tvb, 0, 6, ENC_NA);
pppoe_tree = proto_item_add_subtree(ti, ett_pppoe);
proto_tree_add_item(pppoe_tree, hf_pppoe_version, tvb, 0, 1, ENC_BIG_ENDIAN);
proto_item *ti, *item;
proto_tree *pptp_tree;
- ti = proto_tree_add_item(tree, proto_pptp, tvb, offset, len, FALSE);
+ ti = proto_tree_add_item(tree, proto_pptp, tvb, offset, len, ENC_NA);
pptp_tree = proto_item_add_subtree(ti, ett_pptp);
proto_tree_add_item(pptp_tree, hf_pptp_length, tvb, offset, 2, ENC_BIG_ENDIAN);
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_prp, tvb, 0, PRP_TOTAL_LENGTH,
- FALSE);
+ ENC_NA);
prp_tree = proto_item_add_subtree(ti, ett_prp_supervision_frame);
{
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_prp, tvb, trailer_offset - 4,
- trailer_offset, FALSE);
+ trailer_offset, ENC_NA);
prp_tree = proto_item_add_subtree(ti, ett_prp_redundancy_control_trailer);
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_ptp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ptp, tvb, 0, -1, ENC_NA);
ptp_tree = proto_item_add_subtree(ti, ett_ptp);
if (tree) {
- ti = proto_tree_add_item(tree, proto_ptp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ptp, tvb, 0, -1, ENC_NA);
ptp_tree = proto_item_add_subtree(ti, ett_ptp_v2);
}
} else {
if (string_data) {
- string_buffer_print =
+ string_buffer_print =
ep_strdup(format_text((guint8 *) string_buffer,
(int)strlen(string_buffer)));
} else {
if (parent_tree)
{
- item = proto_tree_add_item(parent_tree, proto_pvfs, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_pvfs, tvb, 0, -1, ENC_NA);
if (item)
pvfs_tree = proto_item_add_subtree(item, ett_pvfs);
if (tree)
{
proto_item* item;
- item = proto_tree_add_item(tree, proto_11_or_aal5_pdu, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_11_or_aal5_pdu, tvb, 0, -1, ENC_NA);
/*overwrite heading line*/
proto_item_set_text(item, proto_name_tree, 0/*-warn gcc 3.4.4*/);
pwc_item_append_text_n_items(item,cells,"good ATM cell");
if (tree)
{
proto_item* item;
- item = proto_tree_add_item(tree, proto_aal5_sdu, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_aal5_sdu, tvb, 0, -1, ENC_NA);
{
proto_tree* tree2;
tree2 = proto_item_add_subtree(item, ett_encaps);
if (tree)
{
proto_item* item;
- item = proto_tree_add_item(tree, proto_n1_cw, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_n1_cw, tvb, 0, -1, ENC_NA);
pwc_item_append_text_n_items(item,cells,"good ATM cell");
{
proto_tree* tree2;
if (tree)
{
proto_item* item;
- item = proto_tree_add_item(tree, proto_n1_nocw, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_n1_nocw, tvb, 0, -1, ENC_NA);
pwc_item_append_text_n_items(item,cells,"ATM cell");
{
proto_tree* tree2;
if (tree)
{
proto_item *item;
- item = proto_tree_add_item(tree, proto_control_word, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_control_word, tvb, 0, -1, ENC_NA);
expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
"Packet (size: %d) is too small to carry MPLS PW Control Word"
,(int)size);
if (tree)
{
proto_item* item_top;
- item_top = proto_tree_add_item(tree, proto_control_word, tvb, 0, -1, FALSE);
+ item_top = proto_tree_add_item(tree, proto_control_word, tvb, 0, -1, ENC_NA);
pwc_item_append_cw(item_top,tvb_get_ntohl(tvb, 0),FALSE);
{
item = proto_tree_add_item(tree, proto_cell_header, tvb
,0
,dissect_size
- ,FALSE);
+ ,ENC_NA);
if (PWATM_MODE_AAL5_PDU == pd->mode)
{
proto_item_set_text(item, "Third byte of Control Word"); /*overwrite heading line*/
if (tree)
{
proto_item* item;
- item = proto_tree_add_item(tree, proto_cell, tvb, 0, dissect_size, FALSE);
+ item = proto_tree_add_item(tree, proto_cell, tvb, 0, dissect_size, ENC_NA);
{
pwatm_private_data_t * pd;
pd = pinfo->private_data;
if (tree)
{
proto_item *item;
- item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, ENC_NA);
expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
"PW packet size (%d) is too small to carry sensible information"
,(int)packet_size);
{
proto_item* item;
- item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, ENC_NA);
pwc_item_append_cw(item,tvb_get_ntohl(tvb_original, 0),TRUE);
pwc_item_append_text_n_items(item,(int)payload_size,"octet");
{
{ 0x1, "Attachment Circuit Fault" },
{ 0, NULL }
};
-
+
const value_string
pwc_vals_cw_r_bit[] = {
gint size;
proto_item* item;
size = tvb_reported_length_remaining(tvb, 0);
- item = proto_tree_add_item(tree, proto_pw_padding, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_pw_padding, tvb, 0, -1, ENC_NA);
pwc_item_append_text_n_items(item,size,"byte");
{
proto_tree* tree_p;
tvb, 0, 0, TRUE);
PROTO_ITEM_SET_HIDDEN(ti);
ti = proto_tree_add_item(tree, proto_pw_eth_cw,
- tvb, 0, 4, FALSE);
+ tvb, 0, 4, ENC_NA);
pw_eth_tree = proto_item_add_subtree(ti, ett_pw_eth);
if (pw_eth_tree == NULL)
return;
if (tree)
{
proto_item *item;
- item = proto_tree_add_item(tree, proto_encaps, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_encaps, tvb, 0, -1, ENC_NA);
expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
"PW packet (%d) is smaller than PW encapsulation header (%d)"
,(int)packet_size,(int)encaps_size);
proto_item* item_headline;
proto_item* item;
- item_headline = proto_tree_add_item(tree, proto_encaps, tvb, 0, 4, FALSE);
+ item_headline = proto_tree_add_item(tree, proto_encaps, tvb, 0, 4, ENC_NA);
proto_item_append_text(item_headline, ": 0x%.8" G_GINT32_MODIFIER "x", tvb_get_ntohl(tvb, 0));
subtree = proto_item_add_subtree(item_headline, ett_encaps);
* ---------------------------------
* 02.03.2009 Initial implementation, supports:
* - HDLC mode (rfc4618 5.1), no CW, payload is PPP (PPP in HDLC-like Framing (rfc1662)).
- * - FR port mode (rfc4618 5.2), no CW.
+ * - FR port mode (rfc4618 5.2), no CW.
*
* [informative: Not supported yet:
* - All kinds of HDLC PW with CW.
addr = tvb_get_guint8(tvb, 0);
control = tvb_get_guint8(tvb, 1);
- item = proto_tree_add_item( tree, proto_pw_hdlc_nocw_hdlc_ppp, tvb, 0, 2, FALSE );
+ item = proto_tree_add_item( tree, proto_pw_hdlc_nocw_hdlc_ppp, tvb, 0, 2, ENC_NA );
tr = proto_item_add_subtree( item, ett_pw_hdlc );
if (tree)
{
proto_item *item;
- item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, ENC_NA);
expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR,
"PW packet size (%d) is too small to carry sensible information"
,(int)packet_size);
if (tree)
{
proto_item* item;
- item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto, tvb_original, 0, -1, ENC_NA);
pwc_item_append_cw(item,tvb_get_ntohl(tvb_original, 0),TRUE);
pwc_item_append_text_n_items(item,(int)payload_size,"octet");
{
if (tree) {
ti = proto_tree_add_item(tree, proto_q2931, tvb, offset, -1,
- FALSE);
+ ENC_NA);
q2931_tree = proto_item_add_subtree(ti, ett_q2931);
proto_tree_add_uint(q2931_tree, hf_q2931_discriminator, tvb, offset, 1, tvb_get_guint8(tvb, offset));
prot_discr = tvb_get_guint8(tvb, offset);
if (tree) {
ti = proto_tree_add_item(tree, proto_q931, tvb, offset, -1,
- FALSE);
+ ENC_NA);
q931_tree = proto_item_add_subtree(ti, ett_q931);
dissect_q931_protocol_discriminator(tvb, offset, q931_tree);
if (tree) {
ti = proto_tree_add_item(tree, proto_q933, tvb, offset, -1,
- FALSE);
+ ENC_NA);
q933_tree = proto_item_add_subtree(ti, ett_q933);
dissect_q933_protocol_discriminator(tvb, offset, q933_tree);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- qllc_ti = proto_tree_add_item(tree, proto_qllc, tvb, 0, -1, FALSE);
+ qllc_ti = proto_tree_add_item(tree, proto_qllc, tvb, 0, -1, ENC_NA);
qllc_tree = proto_item_add_subtree(qllc_ti, ett_qllc);
}
return offset;
service = get_service(opcode);
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), ENC_NA);
qsig_tree = proto_item_add_subtree(ti, ett_qsig);
proto_tree_add_uint(qsig_tree, hf_qsig_operation, tvb, 0, 0, opcode);
return offset;
service = get_service(opcode);
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), ENC_NA);
qsig_tree = proto_item_add_subtree(ti, ett_qsig);
proto_tree_add_uint(qsig_tree, hf_qsig_operation, tvb, 0, 0, opcode);
if (!err_ptr)
return offset;
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, tvb_length(tvb), ENC_NA);
qsig_tree = proto_item_add_subtree(ti, ett_qsig);
proto_tree_add_uint(qsig_tree, hf_qsig_error, tvb, 0, 0, errcode);
offset = 0;
- ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_qsig, tvb, offset, -1, ENC_NA);
PROTO_ITEM_SET_HIDDEN(ti);
ie_type = tvb_get_guint8(tvb, offset);
if (tree) {
proto_item *quake_item;
quake_item = proto_tree_add_item(tree, proto_quake,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
quake_tree = proto_item_add_subtree(quake_item, ett_quake);
}
if (tree) {
proto_item *quake2_item;
quake2_item = proto_tree_add_item(tree, proto_quake2,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
quake2_tree = proto_item_add_subtree(quake2_item, ett_quake2);
proto_tree_add_uint_format(quake2_tree,
direction == DIR_S2C ?
if (tree) {
proto_item *quake3_item;
quake3_item = proto_tree_add_item(tree, proto_quake3,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
quake3_tree = proto_item_add_subtree(quake3_item, ett_quake3);
dir_item = proto_tree_add_none_format(
if (tree) {
proto_item *quakeworld_item;
quakeworld_item = proto_tree_add_item(tree, proto_quakeworld,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
quakeworld_tree = proto_item_add_subtree(quakeworld_item, ett_quakeworld);
proto_tree_add_uint_format(quakeworld_tree,
direction == DIR_S2C ?
/* Forces load of header fields, if not already done so */
DISSECTOR_ASSERT(proto_registrar_get_byname("radius.code"));
- ti = proto_tree_add_item(tree,proto_radius, tvb, 0, rh.rh_pktlength, FALSE);
+ ti = proto_tree_add_item(tree,proto_radius, tvb, 0, rh.rh_pktlength, ENC_NA);
radius_tree = proto_item_add_subtree(ti, ett_radius);
proto_tree_add_uint(radius_tree,hf_radius_code, tvb, 0, 1, rh.rh_code);
proto_tree_add_uint_format(radius_tree,hf_radius_id, tvb, 1, 1, rh.rh_ident,
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RANAP");
/* create the ranap protocol tree */
- ranap_item = proto_tree_add_item(tree, proto_ranap, tvb, 0, -1, FALSE);
+ ranap_item = proto_tree_add_item(tree, proto_ranap, tvb, 0, -1, ENC_NA);
ranap_tree = proto_item_add_subtree(ranap_item, ett_ranap);
dissect_RANAP_PDU_PDU(tvb, pinfo, ranap_tree);
/* populate a tree in the second pane with the status of the link
layer (ie none) */
if (tree) {
- ti = proto_tree_add_item(tree, proto_raw, tvb, 0, 0, FALSE);
+ ti = proto_tree_add_item(tree, proto_raw, tvb, 0, 0, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_raw);
proto_tree_add_text(fh_tree, tvb, 0, 0, "No link information available");
}
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor
* Boston, MA 02110-1301, USA.
*/
-/*
+/*
* ANSI E1.20-2006, Entertainment Technology
* Remote Device Management over USITT DMX512, describes a method of
* bi-directional communications over a USITT DMX512/1990 data link
proto_item *item;
proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb,
- offset, -1, FALSE);
+ offset, -1, ENC_NA);
proto_tree *rdm_tree = proto_item_add_subtree(ti, ett_rdm);
proto_tree_add_item(rdm_tree, hf_rdm_start_code, tvb,
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDP");
col_clear(pinfo->cinfo, COL_INFO);
- item = proto_tree_add_item(parent_tree, proto_rdp, tvb, 0, tvb_length(tvb), FALSE);
+ item = proto_tree_add_item(parent_tree, proto_rdp, tvb, 0, tvb_length(tvb), ENC_NA);
tree = proto_item_add_subtree(item, ett_rdp);
return tree;
/* Create RDT protocol tree */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_rdt, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rdt, tvb, offset, -1, ENC_NA);
rdt_tree = proto_item_add_subtree(ti, ett_rdt);
}
/* Create subtree for flags fields */
if (tree)
{
- proto_tree_add_item(tree, proto_rdt, tvb, offset, -1, FALSE);
+ proto_tree_add_item(tree, proto_rdt, tvb, offset, -1, ENC_NA);
ti = proto_tree_add_string_format(tree, hf_rdt_aact_flags, tvb, offset, 1,
"",
"Length-included=%u, stream_id=%u",
l3off = tvb_get_ntohs(tvb, 22);
if (tree) {
- ti = proto_tree_add_item(tree, proto_redback, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_redback, tvb, 0, -1, ENC_NA);
rbtree = proto_item_add_subtree(ti, ett_redback);
proto_tree_add_item(rbtree, hf_redback_context, tvb, 0, 4, ENC_BIG_ENDIAN);
case 0x02:
/*
* This is ISIS - Either incoming with ethernet FCS
- * and CLNP - passed to the eth dissector or in case
+ * and CLNP - passed to the eth dissector or in case
* of outgoing its pure ISIS and the linecard attaches
* the ethernet and CLNP headers ...
*
/* XXX: ToDo: Validate the length (avplen) of the fixed length fields
before calling proto_tree_add_item().
- Note that the field lengths have been validated when
+ Note that the field lengths have been validated when
dissect_avp() is called from redbackli_dissect_heur().
*/
-
+
switch(avptype) {
case(RB_AVP_SEQNO):
proto_tree_add_item(st, hf_redbackli_seqno, tvb,
if (tree) {
ti = proto_tree_add_item(tree, proto_redbackli,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
redbackli_tree = proto_item_add_subtree(ti, ett_redbackli);
}
"Session Identifier", HFILL }},
{ &hf_redbackli_dir,
#if 0 /* XXX: If one goes by the heuristic then this field can be variable length ??
- In the absence of any documentation We'll assume that's the case
+ In the absence of any documentation We'll assume that's the case
(even though 'direction' sounds like a fixed length field */
{ "Direction", "redbackli.dir", FT_UINT8, BASE_DEC, NULL, 0x0,
#endif
reload_frame->req_time = pinfo->fd->abs_ts;
}
- ti = proto_tree_add_item(tree, proto_reload_framing, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_reload_framing, tvb, 0, -1, ENC_NA);
reload_framing_tree = proto_item_add_subtree(ti, ett_reload_framing);
conversation_add_proto_data(conversation, proto_reload, reload_info);
}
- ti = proto_tree_add_item(tree, proto_reload, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_reload, tvb, 0, -1, ENC_NA);
reload_tree = proto_item_add_subtree(ti, ett_reload);
retix_bpdu_tree = NULL;
if (tree) {
- ti = proto_tree_add_item(tree, proto_retix_bpdu, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_retix_bpdu, tvb, 0, -1, ENC_NA);
retix_bpdu_tree = proto_item_add_subtree(ti, ett_retix_bpdu);
}
static int hf_rfc2190_sbit = -1;
static int hf_rfc2190_ebit = -1;
static int hf_rfc2190_srcformat = -1;
-static int hf_rfc2190_picture_coding_type = -1;
+static int hf_rfc2190_picture_coding_type = -1;
static int hf_rfc2190_unrestricted_motion_vector = -1;
static int hf_rfc2190_syntax_based_arithmetic = -1;
static int hf_rfc2190_advanced_prediction = -1;
}
if ( tree ) {
- ti = proto_tree_add_item( tree, proto_rfc2190, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_rfc2190, tvb, offset, -1, ENC_NA );
rfc2190_tree = proto_item_add_subtree( ti, ett_rfc2190 );
-
+
/* FBIT 1st octet, 1 bit */
proto_tree_add_boolean( rfc2190_tree, hf_rfc2190_ftype, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x80 );
/* PBIT 1st octet, 1 bit */
proto_tree_add_boolean( rfc2190_tree, hf_rfc2190_syntax_based_arithmetic, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x04 );
/* A flag, 1 bit */
proto_tree_add_boolean( rfc2190_tree, hf_rfc2190_advanced_prediction, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x02 );
-
+
/* Reserved 2nd octect, 1 bit + 3rd octect 3 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_r, tvb, offset, 2, ( ( tvb_get_guint8( tvb, offset ) & 0x1 ) << 3 ) + ( ( tvb_get_guint8( tvb, offset + 1 ) & 0xe0 ) >> 5 ) );
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_dbq, tvb, offset, 1, ( tvb_get_guint8( tvb, offset ) & 0x18 ) >> 3 );
/* TRB 3 octect, 3 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_trb, tvb, offset, 1, ( tvb_get_guint8( tvb, offset ) & 0x07 ) );
-
+
offset++;
-
+
/* TR 4 octect, 8 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_tr, tvb, offset, 1, tvb_get_guint8( tvb, offset ) );
-
+
offset++;
} else { /* MODE B or MODE C */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_gobn, tvb, offset, 1, ( tvb_get_guint8( tvb, offset ) & 0xf8 ) >> 3);
/* MBA 3 octect, 3 bits + 4 octect 6 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_mba, tvb, offset, 2, ( ( tvb_get_guint8( tvb, offset ) & 0x7 ) << 6 ) + ( ( tvb_get_guint8( tvb, offset + 1 ) & 0xfc ) >> 2 ) );
-
+
offset++;
/* Reserved 4th octect, 2 bits */
proto_tree_add_boolean( rfc2190_tree, hf_rfc2190_syntax_based_arithmetic, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x20 );
/* A flag, 1 bit */
proto_tree_add_boolean( rfc2190_tree, hf_rfc2190_advanced_prediction, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x10 );
-
+
/* HMV1 5th octect, 4 bits + 6th octect 3 bits*/
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_hmv1, tvb, offset, 2,( ( tvb_get_guint8( tvb, offset ) & 0xf ) << 3 ) + ( ( tvb_get_guint8( tvb, offset+1 ) & 0xe0 ) >> 5) );
-
+
offset++;
-
+
/* VMV1 6th octect, 5 bits + 7th octect 2 bits*/
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_vmv1, tvb, offset, 2,( ( tvb_get_guint8( tvb, offset ) & 0x1f ) << 2 ) + ( ( tvb_get_guint8( tvb, offset+1 ) & 0xc0 ) >> 6) );
-
+
offset++;
/* HMV2 7th octect, 6 bits + 8th octect 1 bit*/
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_hmv2, tvb, offset, 2,( ( tvb_get_guint8( tvb, offset ) & 0x3f ) << 1 ) + ( ( tvb_get_guint8( tvb, offset+1 ) & 0xf0 ) >> 7) );
-
+
offset++;
/* VMV2 8th octect, 7 bits*/
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_vmv2, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x7f );
-
+
offset++;
if(rfc2190_version == 0x03) { /* MODE C */
/* Reserved 9th to 11th octect, 8 + 8 + 3 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_rr, tvb, offset, 3, ( tvb_get_guint8( tvb, offset ) << 11 ) + ( tvb_get_guint8( tvb, offset + 1 ) << 3 ) + ( ( tvb_get_guint8( tvb, offset + 2 ) & 0xe0 ) >> 5 ) );
-
+
offset+=2;
/* DBQ 11th octect, 2 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_dbq, tvb, offset, 1, ( tvb_get_guint8( tvb, offset ) & 0x18 ) >>3 );
/* TRB 11th octect, 3 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_trb, tvb, offset, 1, tvb_get_guint8( tvb, offset ) & 0x07 );
-
+
offset++;
-
+
/* TR 12th octect, 8 bits */
proto_tree_add_uint( rfc2190_tree, hf_rfc2190_tr, tvb, offset, 1, tvb_get_guint8( tvb, offset ) );
-
+
offset++;
} /* end mode c */
} /* end not mode a */
break;
}
}
-
-
+
+
/* The rest of the packet is the H.263 stream */
next_tvb = tvb_new_subset( tvb, offset, tvb_length(tvb) - offset, tvb_reported_length(tvb) - offset);
call_dissector(h263_handle,next_tvb,pinfo,tree);
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/*
- Based on RFC3488
+/*
+ Based on RFC3488
This is a setup for RGMP dissection, a simple protocol bolted on IGMP.
The trick is to have IGMP dissector call this function (which by itself is not
return offset + tvb_length_remaining(tvb, offset);
}
- item = proto_tree_add_item(parent_tree, proto_rgmp, tvb, offset, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_rgmp, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_rgmp);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RGMP");
type = tvb_get_guint8(tvb, offset);
if (check_col(pinfo->cinfo, COL_INFO)) {
- col_add_str(pinfo->cinfo, COL_INFO,
+ col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(type, rgmp_types, "Unknown Type: 0x%02x"));
}
proto_tree_add_uint(tree, hf_type, tvb, offset, 1, type);
val_to_str(command, command_vals, "Unknown command (%u)"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_rip, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rip, tvb, 0, -1, ENC_NA);
rip_tree = proto_item_add_subtree(ti, ett_rip);
proto_tree_add_uint(rip_tree, hf_rip_command, tvb, 0, 1, command);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_ripng, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ripng, tvb, offset, -1, ENC_NA);
ripng_tree = proto_item_add_subtree(ti, ett_ripng);
/* Command */
if (!createdChannel) {
/* Ahead of expected SN. Assume frames have been missed */
p_report_in_frame->state = SN_Missing;
-
+
p_report_in_frame->firstSN = expectedSequenceNumber;
p_report_in_frame->lastSN = (1024 + sequenceNumber-1) % 1024;
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RLC-LTE");
/* Create protocol tree. */
- top_ti = proto_tree_add_item(tree, proto_rlc_lte, tvb, offset, -1, FALSE);
+ top_ti = proto_tree_add_item(tree, proto_rlc_lte, tvb, offset, -1, ENC_NA);
rlc_lte_tree = proto_item_add_subtree(top_ti, ett_rlc_lte);
/* PCCH is always RLC TM */
if (tree) {
proto_item *ti;
- ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_rlc);
proto_item_append_text(ti, " TM (PCCH)");
}
if (!fpi) return; /* dissection failure */
if (tree) {
- ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_rlc);
}
if (!fpi) return; /* dissection failure */
if (tree) {
- ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_rlc);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_rlc);
}
if (!fpi || !rlci) return;
if (tree) {
- ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rlc, tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_rlc);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_rlc, rlc_tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rlc, rlc_tvb, 0, -1, ENC_NA);
subtree = proto_item_add_subtree(ti, ett_rlc);
}
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-
+
/*
* RLM is a proprietary Cisco protocol used for centralling managing
* many redundant NASes. I don't know much about the format, but you
* can read about the feature here:
- *
+ *
* http://www.cisco.com/en/US/docs/ios/12_0t/12_0t3/feature/guide/rlm_123.html
*
* RLM runs on a UDP port (default 3000) between the MGC and the NAS.
* On port N+1 (default 3001), a Q.931/LAPD/UDP connection is maintained.
* Both sides use the same local port number for the connection, so source
* and dest port are always the same.
- *
+ *
* In large networks, the links are typically split onto higher ports,
* so anything up to 3015 (or higher) could either be RLM or Q.931 traffic,
* although always the RLM has the one lower port number for that RLM group.
*
* Multiple RLM groups are possible on a single NAS.
- *
+ *
* I haven't been able to find the protocol documented, so I've
* guessed some of the fields based on the output of debug commands on
* cisco NASes.
- *
+ *
*/
#ifdef HAVE_CONFIG_H
/* #define ??? ?? */
-/*
+/*
Maybe this isn't the best place for it, but RLM goes hand in hand
with Q.931 traffic on a higher port.
*/
if (tree) {
/* proto_tree_add_protocol_format(tree, proto_rlm, tvb, 0,
16, "Cisco Session Management"); */
- ti = proto_tree_add_item(tree, proto_rlm, tvb, 0, 8, FALSE);
+ ti = proto_tree_add_item(tree, proto_rlm, tvb, 0, 8, ENC_NA);
rlm_tree = proto_item_add_subtree(ti, ett_rlm);
proto_tree_add_item(rlm_tree, hf_rlm_version, tvb, 0, 1, ENC_BIG_ENDIAN);
proto_tree_add_uint_format(rlm_tree, hf_rlm_type, tvb, 1, 1, rlm_type, "Type: %u (%s)", rlm_type, type_str);
static hf_register_info hf[] = {
{ &hf_rlm_version,
{ "Version", "rlm.version",
- FT_UINT8, BASE_DEC, NULL, 0x0,
+ FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_rlm_type,
{ "Type", "rlm.type",
- FT_UINT8, BASE_DEC, NULL, 0x0,
+ FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_rlm_unknown,
{ "Unknown", "rlm.unknown",
- FT_UINT16, BASE_HEX, NULL, 0x0,
+ FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_rlm_tid,
{ "Transaction ID", "rlm.tid",
- FT_UINT16, BASE_DEC, NULL, 0x0,
+ FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_rlm_unknown2,
{ "Unknown", "rlm.unknown2",
- FT_UINT16, BASE_HEX, NULL, 0x0,
+ FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
};
proto_item *user_info_item, *window_info_item;
/* Create rlogin subtree */
- ti = proto_tree_add_item(tree, proto_rlogin, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rlogin, tvb, 0, -1, ENC_NA);
rlogin_tree = proto_item_add_subtree(ti, ett_rlogin);
/* Return if data empty */
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_rmi, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rmi, tvb, 0, -1, ENC_NA);
rmi_tree = proto_item_add_subtree(ti, ett_rmi);
switch(rmitype) {
case RMI_OUTPUTSTREAM:
offset = 0;
if(tree) {
- ti = proto_tree_add_item(tree, proto_ser, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ser, tvb, 0, -1, ENC_NA);
ser_tree = proto_item_add_subtree(ti, ett_ser);
proto_tree_add_item(ser_tree, hf_ser_magic,
tvb, offset, 2, ENC_BIG_ENDIAN);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_rmp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rmp, tvb, 0, -1, ENC_NA);
rmp_tree = proto_item_add_subtree(ti, ett_rmp);
proto_tree_add_uint(rmp_tree, hf_rmp_type, tvb, 0, 1, type);
if (tree)
{
/* Create subtree for the ALC protocol */
- ti = proto_tree_add_item(tree, proto, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto, tvb, offset, -1, ENC_NA);
alc_tree = proto_item_add_subtree(ti, ett.main);
/* Fill the ALC subtree */
if (tree)
{
/* Create subtree for the NORM protocol */
- ti = proto_tree_add_item(tree, proto, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto, tvb, offset, -1, ENC_NA);
norm_tree = proto_item_add_subtree(ti, ett.main);
/* Fill the NORM subtree */
col_append_str(pinfo->cinfo, COL_INFO, " ");
}
/*if (tree) {*/
- ti = proto_tree_add_item(tree, proto_rohc, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rohc, tvb, 0, -1, ENC_NA);
rohc_tree = proto_item_add_subtree(ti, ett_rohc);
/* 1) If the first octet is a Padding Octet (11100000),
* strip away all initial Padding Octets and goto next step.
}
if (tree) {
- it = proto_tree_add_item(tree, proto_roofnet, tvb, offset, -1, FALSE);
+ it = proto_tree_add_item(tree, proto_roofnet, tvb, offset, -1, ENC_NA);
roofnet_tree = proto_item_add_subtree(it, ett_roofnet);
}
if (tree) {
rpc_item = proto_tree_add_item(tree, proto_rpc, tvb, 0, -1,
- FALSE);
+ ENC_NA);
rpc_tree = proto_item_add_subtree(rpc_item, ett_rpc);
proto_tree_add_text(rpc_tree, tvb, 0, -1, "Continuation data");
}
if (tree) {
rpc_item = proto_tree_add_item(tree, proto_rpc, tvb, 0, -1,
- FALSE);
+ ENC_NA);
rpc_tree = proto_item_add_subtree(rpc_item, ett_rpc);
if (is_tcp) {
}
if (tree) {
ti = proto_tree_add_item(tree, proto_rpl, tvb, 0,
- rpl_len, FALSE);
+ rpl_len, ENC_NA);
rpl_tree = proto_item_add_subtree(ti, ett_rpl);
hidden_item = proto_tree_add_uint(rpl_tree, hf_rpl_type, tvb, 2, 2,
rpl_type);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RRC");
/* create the rrc protocol tree */
- rrc_item = proto_tree_add_item(tree, proto_rrc, tvb, 0, -1, FALSE);
+ rrc_item = proto_tree_add_item(tree, proto_rrc, tvb, 0, -1, ENC_NA);
rrc_tree = proto_item_add_subtree(rrc_item, ett_rrc);
if (rrcinf) {
}
if (tree) {
ti = proto_tree_add_item(tree, proto_rsh, tvb, offset, -1,
- FALSE);
+ ENC_NA);
rsh_tree = proto_item_add_subtree(ti, ett_rsh);
/*
"Unknown Message Type (0x%0x)"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_rsip, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rsip, tvb, 0, -1, ENC_NA);
rsip_tree = proto_item_add_subtree(ti, ett_rsip);
ie_offset = offset;
- /* 3GPP TS 44.018 "Channel Description"
- * the whole of the 3GPP TS 44.018 element including the element identifier and
+ /* 3GPP TS 44.018 "Channel Description"
+ * the whole of the 3GPP TS 44.018 element including the element identifier and
* length should be included.
* XXX Hmm a type 3 IE (TV).
*/
top_tree = tree;
if (tree) {
- ti = proto_tree_add_item(tree, proto_rsl, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_rsl, tvb, 0, -1, ENC_NA);
rsl_tree = proto_item_add_subtree(ti, ett_rsl);
/* 9.1 Message discriminator */
message_type = tvb_get_guint8(tvb, 1);
ti = proto_tree_add_item(tree, proto_rsvp, tvb, offset, msg_length,
- FALSE);
+ ENC_NA);
rsvp_tree = proto_item_add_subtree(ti, tree_mode);
if (pinfo->ipproto == IP_PROTO_RSVPE2EI)
proto_item_append_text(rsvp_tree, " (E2E-IGNORE)");
conversation_set_dissector(conversation, rsync_handle);
- ti = proto_tree_add_item(tree, proto_rsync, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rsync, tvb, 0, -1, ENC_NA);
rsync_tree = proto_item_add_subtree(ti, ett_rsync);
*/
/*
- * The part of this dissector for IDMS XR blocks was written by
+ * The part of this dissector for IDMS XR blocks was written by
* Torsten Loebner (loebnert@googlemail.com) in the context of a graduation
* project with the research organization TNO in Delft, Netherland.
- * The extension is based on the RTCP XR block specified in
+ * The extension is based on the RTCP XR block specified in
* ETSI TS 182 063 v3.5.2 Annex W (http://www.etsi.org/deliver/etsi_ts/183000_183099/183063/),
- * which was registered by IANA as RTCP XR Block Type 12
+ * which was registered by IANA as RTCP XR Block Type 12
* (http://www.iana.org/assignments/rtcp-xr-block-types/rtcp-xr-block-types.xml).
*/
expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN,
"Invalid block length, should be 8");
return FALSE;
-
+
case RTCP_XR_IDMS:
if (block_len != 7)
expert_add_info_format(pinfo, ti, PI_PROTOCOL, PI_WARN,
"Invalid block length, should be 7");
return FALSE;
-
+
default:
break;
}
}
case RTCP_XR_IDMS:
offset -= 3;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_spst, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_spst, tvb, offset, 1, ENC_BIG_ENDIAN);
offset+=3;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_pt, tvb, offset, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_pt, tvb, offset, 1, ENC_BIG_ENDIAN);
offset+=4;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_msci, tvb, offset, 4, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_msci, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_source_ssrc, tvb, offset, 4, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_source_ssrc, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_ntp_rcv_ts_msw, tvb, offset, 4, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_ntp_rcv_ts_msw, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_ntp_rcv_ts_lsw, tvb, offset, 4, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_ntp_rcv_ts_lsw, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
item = proto_tree_add_item(content_tree, hf_rtcp_ntp, tvb, offset-8, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);
PROTO_ITEM_SET_GENERATED(item);
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_rtp_ts, tvb, offset, 4, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_rtp_ts, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
- proto_tree_add_item(content_tree, hf_rtcp_xr_idms_ntp_pres_ts, tvb, offset, 4, ENC_BIG_ENDIAN);
+ proto_tree_add_item(content_tree, hf_rtcp_xr_idms_ntp_pres_ts, tvb, offset, 4, ENC_BIG_ENDIAN);
offset+=4;
-
+
tmp_ts = tvb_get_ntohl(tvb,offset-4);
hour = ( (int) ( tmp_ts >> 16 ) ) / 3600;
- min = (( (int) ( tmp_ts >> 16 ) ) - hour * 3600) / 60;
+ min = (( (int) ( tmp_ts >> 16 ) ) - hour * 3600) / 60;
sec = (( (int) ( tmp_ts >> 16 ) ) - hour * 3600 - min * 60);
msec = ( (int) ( tmp_ts & 0x0000FFFF ) ) / 66;
-
+
item = proto_tree_add_text( content_tree, tvb, offset-4, 4, "short NTP timestamp of presentation: %d:%02d:%02d:%03d [h:m:s:ms] ", hour,min,sec,msec);
PROTO_ITEM_SET_GENERATED(item);
break;
packet_length = ( tvb_get_ntohs( tvb, offset + 2 ) + 1 ) * 4;
total_packet_length += packet_length;
- ti = proto_tree_add_item(tree, proto_rtcp, tvb, offset, packet_length, FALSE );
+ ti = proto_tree_add_item(tree, proto_rtcp, tvb, offset, packet_length, ENC_NA );
proto_item_append_text(ti, " (%s)",
val_to_str(packet_type,
rtcp_packet_type_vals,
if (tree)
{
- ti = proto_tree_add_item(tree, proto_rtmpt, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rtmpt, tvb, offset, -1, ENC_NA);
if (tp->id>RTMPT_ID_MAX) {
/* Dissect handshake */
}
if (root) {
- ti = proto_tree_add_item(root, proto_tdma, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(root, proto_tdma, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(ti, ett_tdma);
proto_item_append_text(ti, ", Version 1, %s",
}
if (root) {
- ti = proto_tree_add_item(root, proto_tdma, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(root, proto_tdma, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(ti, ett_tdma);
proto_item_append_text(ti, ", %s", val_to_str(msg, tdma_msg_vals, "Unknown (0x%04x)"));
dissector = data_handle;
if (tree) {
- ti = proto_tree_add_item(tree, proto_rtmac, tvb, offset, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_rtmac, tvb, offset, 4, ENC_NA);
rtmac_tree = proto_item_add_subtree(ti, ett_rtmac);
proto_item_append_text(ti, ", Version %d", ver);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_rtcfg, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rtcfg, tvb, offset, -1, ENC_NA);
rtcfg_tree = proto_item_add_subtree(ti, ett_rtcfg);
}
val_to_str( rtp_evt, rtp_event_type_values, "Unknown (%u)" ));
}
- ti = proto_tree_add_item( tree, proto_rtp_events, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_rtp_events, tvb, offset, -1, ENC_NA );
rtp_events_tree = proto_item_add_subtree( ti, ett_rtp_events );
proto_tree_add_uint ( rtp_events_tree, hf_rtp_events_event, tvb, offset, 1, rtp_evt);
/* The duration field indicates the duration of the event or segment
* being reported, in timestamp units.
*/
- rtp_event_info.info_duration = tvb_get_ntohs(tvb, offset);
+ rtp_event_info.info_duration = tvb_get_ntohs(tvb, offset);
proto_tree_add_item ( rtp_events_tree, hf_rtp_events_duration, tvb, offset, 2, ENC_BIG_ENDIAN);
/* set the end info for the tap */
"Unknown RTP version %u", version);
if ( tree ) {
- ti = proto_tree_add_item( tree, proto_rtp, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item( tree, proto_rtp, tvb, offset, -1, ENC_NA );
rtp_tree = proto_item_add_subtree( ti, ett_rtp );
proto_tree_add_uint( rtp_tree, hf_rtp_version, tvb,
if ( tree ) {
proto_tree *item;
/* Create RTP protocol tree */
- ti = proto_tree_add_item(tree, proto_rtp, tvb, offset, -1, FALSE );
+ ti = proto_tree_add_item(tree, proto_rtp, tvb, offset, -1, ENC_NA );
rtp_tree = proto_item_add_subtree(ti, ett_rtp );
/* Conversation setup info */
proto_tree *pkt_ccc_tree = NULL;
if ( tree ) {
- ti = proto_tree_add_item(tree, proto_pkt_ccc, tvb, 0, 12, FALSE);
+ ti = proto_tree_add_item(tree, proto_pkt_ccc, tvb, 0, 12, ENC_NA);
pkt_ccc_tree = proto_item_add_subtree(ti, ett_pkt_ccc);
proto_tree_add_item(pkt_ccc_tree, hf_pkt_ccc_id, tvb, 0, 4, ENC_BIG_ENDIAN);
if (tree) {
guint8 nddsPing[8];
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_rtps, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rtps, tvb, 0, -1, ENC_NA);
rtps_tree = proto_item_add_subtree(ti, ett_rtps);
/* Protocol Version */
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_rtps, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_rtps, tvb, 0, -1, ENC_NA);
rtps_tree = proto_item_add_subtree(ti, ett_rtps);
/* Protocol Version */
orig_offset = offset;
if (tree) {
ti = proto_tree_add_item(tree, proto_rtsp, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
rtsp_tree = proto_item_add_subtree(ti, ett_rtsp);
}
saved_rtsp_tcp_port = global_rtsp_tcp_port;
saved_rtsp_tcp_alternate_port = global_rtsp_tcp_alternate_port;
-
+
stats_tree_register("rtsp","rtsp","RTSP/Packet Counter", 0, rtsp_stats_tree_packet, rtsp_stats_tree_init, NULL );
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RUA");
/* create the rua protocol tree */
- rua_item = proto_tree_add_item(tree, proto_rua, tvb, 0, -1, FALSE);
+ rua_item = proto_tree_add_item(tree, proto_rua, tvb, 0, -1, ENC_NA);
rua_tree = proto_item_add_subtree(rua_item, ett_rua);
-
+
dissect_RUA_PDU_PDU(tvb, pinfo, rua_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_rua, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("rua", dissect_rua, proto_rua);
rua_proc_imsg_dissector_table = register_dissector_table("rua.proc.imsg", "RUA-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
rua_proc_sout_dissector_table = register_dissector_table("rua.proc.sout", "RUA-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
rua_proc_uout_dissector_table = register_dissector_table("rua.proc.uout", "RUA-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
-
+
rua_module = prefs_register_protocol(proto_rua, proto_reg_handoff_rua);
prefs_register_uint_preference(rua_module, "port", "RUA SCTP Port", "Set the port for RUA messages (Default of 29169)", 10, &global_sctp_port);
* dissector from here.
*
* Here are some links:
- *
+ *
* http://www.watersprings.org/pub/id/draft-ietf-sigtran-reliable-udp-00.txt
* http://www.javvin.com/protocolRUDP.html
* http://www.cisco.com/univercd/cc/td/doc/product/access/sc/rel7/omts/omts_apb.htm#30052
/* Disable rudp by default. The previously hardcoded value of
* 7000 (used by Cisco) collides with afs and as the draft states:
- * "RUDP doesn't place any restrictions on which UDP port numbers are used.
+ * "RUDP doesn't place any restrictions on which UDP port numbers are used.
* Valid port numbers are ports not defined in RFC 1700."
*/
/* FIXME: The proper solution would be to convert this dissector into
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_rudp, tvb, 0, hlen, FALSE);
+ ti = proto_tree_add_item(tree, proto_rudp, tvb, 0, hlen, ENC_NA);
rudp_tree = proto_item_add_subtree(ti, ett_rudp);
ti = proto_tree_add_item(rudp_tree, hf_rudp_flags, tvb, 0, 1, ENC_BIG_ENDIAN);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "S1AP");
/* create the s1ap protocol tree */
- s1ap_item = proto_tree_add_item(tree, proto_s1ap, tvb, 0, -1, FALSE);
+ s1ap_item = proto_tree_add_item(tree, proto_s1ap, tvb, 0, -1, ENC_NA);
s1ap_tree = proto_item_add_subtree(s1ap_item, ett_s1ap);
-
+
dissect_S1AP_PDU_PDU(tvb, pinfo, s1ap_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_s1ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("s1ap", dissect_s1ap, proto_s1ap);
s1ap_proc_imsg_dissector_table = register_dissector_table("s1ap.proc.imsg", "S1AP-ELEMENTARY-PROCEDURE InitiatingMessage", FT_UINT32, BASE_DEC);
s1ap_proc_sout_dissector_table = register_dissector_table("s1ap.proc.sout", "S1AP-ELEMENTARY-PROCEDURE SuccessfulOutcome", FT_UINT32, BASE_DEC);
s1ap_proc_uout_dissector_table = register_dissector_table("s1ap.proc.uout", "S1AP-ELEMENTARY-PROCEDURE UnsuccessfulOutcome", FT_UINT32, BASE_DEC);
-
+
/* Register configuration options for ports */
s1ap_module = prefs_register_protocol(proto_s1ap, proto_reg_handoff_s1ap);
pdu_size = tvb_get_ntohs(tvb, s5066_size_offset) + s5066_header_size;
- ti_s5066 = proto_tree_add_item(tree, proto_s5066, tvb, 0, -1, FALSE);
+ ti_s5066 = proto_tree_add_item(tree, proto_s5066, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti_s5066, ", PDU type %s", val_to_str(pdu_type, s5066_pdu_type, "Unknown (0x%02x)"));
s5066_tree = proto_item_add_subtree(ti_s5066, ett_s5066);
proto_tree_add_item(s5066_tree, hf_s5066_sync_word, tvb, offset, 2, ENC_BIG_ENDIAN); offset +=2;
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
/* create the sbap protocol tree */
- sabp_item = proto_tree_add_item(tree, proto_sabp, tvb, 0, -1, FALSE);
+ sabp_item = proto_tree_add_item(tree, proto_sabp, tvb, 0, -1, ENC_NA);
sabp_tree = proto_item_add_subtree(sabp_item, ett_sabp);
dissect_SABP_PDU_PDU(tvb, pinfo, sabp_tree);
}
if (tree) {
- si = proto_tree_add_item(tree, proto_sap, tvb, offset, -1, FALSE);
+ si = proto_tree_add_item(tree, proto_sap, tvb, offset, -1, ENC_NA);
sap_tree = proto_item_add_subtree(si, ett_sap);
sif = proto_tree_add_uint(sap_tree, hf_sap_flags, tvb, offset, 1, vers_flags);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SASP");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree,proto_sasp,tvb,offset,-1,FALSE);
+ ti = proto_tree_add_item(tree,proto_sasp,tvb,offset,-1,ENC_NA);
sasp_tree = proto_item_add_subtree(ti,ett_sasp_header);
hdr_type = tvb_get_ntohs(tvb, offset);
/* create display subtree for the protocol */
if (tree) {
- ti = proto_tree_add_item(tree, proto_sbus, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sbus, tvb, offset, -1, ENC_NA);
sbus_tree = proto_item_add_subtree(ti, ett_sbus);
/*Add subtree for Ether-S-Bus header*/
necessary to generate protocol tree items. */
if (tree) {
/* create the sccp protocol tree */
- sccp_item = proto_tree_add_item(tree, proto_sccp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ sccp_item = proto_tree_add_item(tree, proto_sccp, tvb, 0, -1, ENC_NA);
sccp_tree = proto_item_add_subtree(sccp_item, ett_sccp);
}
if (tree) {
/* create the sccpmg protocol tree */
sccpmg_item = proto_tree_add_item(tree, proto_sccpmg, tvb, 0,
- -1, FALSE);
+ -1, ENC_NA);
sccpmg_tree = proto_item_add_subtree(sccpmg_item, ett_sccpmg);
}
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, FALSE);
+ 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;
if (tree) {
sdlc_ti = proto_tree_add_item(tree, proto_sdlc, tvb, 0, -1,
- FALSE);
+ ENC_NA);
sdlc_tree = proto_item_add_subtree(sdlc_ti, ett_sdlc);
proto_tree_add_uint(sdlc_tree, hf_sdlc_address, tvb, 0, 1,
/* XXX: Needs description. */
col_append_str(pinfo->cinfo, COL_INFO, ", with session description");
- ti = proto_tree_add_item(tree, proto_sdp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sdp, tvb, offset, -1, ENC_NA);
sdp_tree = proto_item_add_subtree(ti, ett_sdp);
/*
if (tree) {
/* Adding Sebek item and subtree */
- ti = proto_tree_add_item(tree, proto_sebek, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sebek, tvb, 0, -1, ENC_NA);
sebek_tree = proto_item_add_subtree(ti, ett_sebek);
/* check for minimum length before deciding where to go*/
* Michael Mann * Copyright 2011
*
* $Id$
- *
+ *
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
* this data could be extracted from svc communication during CP2
*/
proto_tree_add_text(tree, tvb, 0, 0, "Service Channels");
-
+
proto_tree_add_text(tree, tvb, 0, 0, "Device Controls");
}
/* offsets of service channel, device status and connections are unknown
* this data could be extracted from svc communication during CP2
*/
- proto_tree_add_text(tree, tvb, 0, 0, "Service Channels");
+ proto_tree_add_text(tree, tvb, 0, 0, "Service Channels");
proto_tree_add_text(tree, tvb, 0, 0, "Device Status");
}
col_append_fstr(pinfo->cinfo, COL_INFO, "%s%u Channel=%s", tel_type, tel_no, tel_ch);
- ti = proto_tree_add_item(tree, proto_siii, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_siii, tvb, 0, -1, ENC_NA);
siii_tree = proto_item_add_subtree(ti, ett_siii);
val_to_str(type, ses_vals, "Unknown SPDU type (0x%02x)"));
if (tree) {
ti = proto_tree_add_item(tree, proto_clses, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
ses_tree = proto_item_add_subtree(ti, ett_ses);
proto_tree_add_uint(ses_tree, hf_ses_type, tvb,
offset, 1, type);
val_to_str(type, ses_category0_vals, "Unknown SPDU type (0x%02x)"));
if (tree) {
ti = proto_tree_add_item(tree, proto_ses, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
ses_tree = proto_item_add_subtree(ti, ett_ses);
proto_tree_add_uint(ses_tree, hf_ses_type_0, tvb,
offset, 1, type);
val_to_str(type, ses_vals, "Unknown SPDU type (0x%02x)"));
if (tree) {
ti = proto_tree_add_item(tree, proto_ses, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
ses_tree = proto_item_add_subtree(ti, ett_ses);
proto_tree_add_uint(ses_tree, hf_ses_type, tvb,
offset, 1, type);
break;
default:
/* acferen: November 10, 2010
- *
+ *
* We should never get here, but if we do we don't know
* the length for this address type. Not knowing the
* length this default case is doomed to failure. Might
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_sflow, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sflow, tvb, 0, -1, ENC_NA);
sflow_245_tree = proto_item_add_subtree(ti, ett_sflow_245);
/* Make entry in the Protocol column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME);
- item = proto_tree_add_item(tree, proto_sgsap, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_sgsap, tvb, 0, -1, ENC_NA);
sgsap_tree = proto_item_add_subtree(item, ett_sgsap);
/* Messge type IE*/
try_again:
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_sigcomp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_sigcomp, tvb, 0, -1, ENC_NA);
sigcomp_tree = proto_item_add_subtree(ti, ett_sigcomp);
i=0;
end_off_message = FALSE;
top_tree = tree;
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_sigcomp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_sigcomp, tvb, 0, -1, ENC_NA);
sigcomp_tree = proto_item_add_subtree(ti, ett_sigcomp);
return dissect_sigcomp_common(tvb, pinfo, sigcomp_tree);
int offset, next_offset, linelen;
if(tree) {
- ti = proto_tree_add_item(tree, proto_raw_sigcomp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_raw_sigcomp, tvb, 0, -1, ENC_NA);
raw_tree = proto_item_add_subtree(ti, ett_raw_text);
}
guint32 offset = 0;
guint32 msg_length;
- simulcrypt_item = proto_tree_add_item(tree, proto_simulcrypt, tvb, 0, -1, FALSE);
+ simulcrypt_item = proto_tree_add_item(tree, proto_simulcrypt, tvb, 0, -1, ENC_NA);
simulcrypt_tree = proto_item_add_subtree(simulcrypt_item, ett_simulcrypt);
proto_item_append_text(simulcrypt_item, ", Interface: %s", val_to_str(iftype, interfacenames, "Unknown (0x%02x)"));
}
if (tree) {
- ts = proto_tree_add_item(tree, proto_sip, tvb, offset, -1, FALSE);
+ ts = proto_tree_add_item(tree, proto_sip, tvb, offset, -1, ENC_NA);
sip_tree = proto_item_add_subtree(ts, ett_sip);
}
char *str;
if (tree) {
- ti = proto_tree_add_item(tree, proto_raw_sip, tvb, offset, length, FALSE);
+ ti = proto_tree_add_item(tree, proto_raw_sip, tvb, offset, length, ENC_NA);
raw_tree = proto_item_add_subtree(ti, ett_raw_text);
}
col_append_str(pinfo->cinfo, COL_INFO, ", with Sipfrag");
/* Create sipfrag tree. */
- ti = proto_tree_add_item(tree, proto_sipfrag, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sipfrag, tvb, offset, -1, ENC_NA);
sipfrag_tree = proto_item_add_subtree(ti, ett_sipfrag);
/* Show the sipfrag message a line at a time. */
/* In the interest of speed, if "tree" is NULL, don't do any work not
* necessary to generate protocol tree items. */
if (tree) {
- ti = proto_tree_add_item(tree, proto_skinny, tvb, offset, hdr_data_length+8, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_skinny, tvb, offset, hdr_data_length+8, ENC_NA);
skinny_tree = proto_item_add_subtree(ti, ett_skinny);
proto_tree_add_uint(skinny_tree, hf_skinny_data_length, tvb, offset, 4, hdr_data_length);
proto_tree_add_uint(skinny_tree, hf_skinny_hdr_version, tvb, offset+4, 4, hdr_version);
if (tree) {
- ti = proto_tree_add_item(tree, proto_slimp3, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_slimp3, tvb, offset, -1, ENC_NA);
slimp3_tree = proto_item_add_subtree(ti, ett_slimp3);
proto_tree_add_uint(slimp3_tree, hf_slimp3_opcode, tvb,
if (tree)
{
pdu_item = proto_tree_add_item(tree, proto_slow, tvb,
- 0, -1, FALSE);
+ 0, -1, ENC_NA);
pdu_tree = proto_item_add_subtree(pdu_item, ett_pdu);
/* Subtype */
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_slsk, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_slsk, tvb, 0, -1, ENC_NA);
slsk_tree = proto_item_add_subtree(ti, ett_slsk);
/* Continue adding tree items to process the packet here */
if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_smb_browse, tvb, offset, -1, TRUE);
+ item = proto_tree_add_item(parent_tree, proto_smb_browse, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_browse);
}
if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_smb_browse, tvb, offset, -1, TRUE);
+ item = proto_tree_add_item(parent_tree, proto_smb_browse, tvb, offset, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_browse);
}
if (tree) {
item = proto_tree_add_item(tree, proto_smb_logon, tvb,
- offset, -1, FALSE);
+ offset, -1, ENC_NA);
smb_logon_tree = proto_item_add_subtree(item, ett_smb_logon);
}
if(mshdr_tvb && setup_tvb){
if (parent_tree) {
item = proto_tree_add_item(parent_tree, proto_smb_msp,
- mshdr_tvb, 0, -1, FALSE);
+ mshdr_tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_smb_msp);
}
if (parent_tree) {
item = proto_tree_add_item(parent_tree, proto_smb_lanman,
- pd_tvb, 0, -1, FALSE);
+ pd_tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_lanman);
}
sp_len = 0;
if (tree) {
pipe_item = proto_tree_add_item(tree, proto_smb_pipe,
- sp_tvb, 0, sp_len, FALSE);
+ sp_tvb, 0, sp_len, ENC_NA);
pipe_tree = proto_item_add_subtree(pipe_item, ett_smb_pipe);
}
offset = 0;
if (parent_tree) {
item = proto_tree_add_item(parent_tree, proto_smb, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_smb);
hitem = proto_tree_add_text(tree, tvb, offset, 32,
return offset;
}
-static int
+static int
dissect_smb2_FSCTL_SET_OBJECT_ID(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, gboolean data_in)
{
if (parent_tree) {
item = proto_tree_add_item(parent_tree, proto_smb2, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_smb2);
}
* Create display subtree for the protocol
*/
if (tree) {
- ti = proto_tree_add_item (tree, proto_smpp, tvb, 0, tvb_length(tvb), FALSE);
+ ti = proto_tree_add_item (tree, proto_smpp, tvb, 0, tvb_length(tvb), ENC_NA);
smpp_tree = proto_item_add_subtree (ti, ett_smpp);
}
return 0;
if(parent_tree){
- item = proto_tree_add_item(parent_tree, proto_smrse, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_smrse, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_smrse);
}
}
if (tree) { /* Build the tree info ... */
- ti = proto_tree_add_item(tree, proto_smtp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_smtp, tvb, offset, -1, ENC_NA);
smtp_tree = proto_item_add_subtree(ti, ett_smtp);
}
/* Don't bother setting length. We'll set it later after we find
* the lengths of TH/RH/RU */
sna_ti = proto_tree_add_item(tree, proto_sna, tvb, 0, -1,
- FALSE);
+ ENC_NA);
sna_tree = proto_item_add_subtree(sna_ti, ett_sna);
}
/* Don't bother setting length. We'll set it later after we find
* the lengths of XID */
sna_ti = proto_tree_add_item(tree, proto_sna_xid, tvb, 0, -1,
- FALSE);
+ ENC_NA);
sna_tree = proto_item_add_subtree(sna_ti, ett_sna);
}
dissect_xid(tvb, pinfo, sna_tree, tree);
if (tree) {
snaeth_ti = proto_tree_add_item(tree, proto_snaeth, tvb, 0, 3,
- FALSE);
+ ENC_NA);
snaeth_tree = proto_item_add_subtree(snaeth_ti, ett_snaeth);
proto_tree_add_uint(snaeth_tree, hf_snaeth_len, tvb, 0, 2, len);
proto_tree_add_text(snaeth_tree, tvb, 2, 1, "Padding");
/* create display subtree for the protocol
*/
- ti = proto_tree_add_item(tree, proto_sndcp_xid, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sndcp_xid, tvb, 0, -1, ENC_NA);
sndcp_tree = proto_item_add_subtree(ti, ett_sndcp_xid);
l3_param_len = tvb_reported_length(tvb);
/* create display subtree for the protocol
*/
if (tree) {
- ti = proto_tree_add_item(tree, proto_sndcp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sndcp, tvb, 0, -1, ENC_NA);
sndcp_tree = proto_item_add_subtree(ti, ett_sndcp);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SMUX");
if (tree) {
- item = proto_tree_add_item(tree, proto_smux, tvb, 0, -1, ENC_BIG_ENDIAN);
+ item = proto_tree_add_item(tree, proto_smux, tvb, 0, -1, ENC_NA);
smux_tree = proto_item_add_subtree(item, ett_smux);
}
if (tree)
{
proto_tree *can_tree = NULL;
- proto_item *ti = proto_tree_add_item(tree, proto_can, tvb, 0, 1 , FALSE );
+ proto_item *ti = proto_tree_add_item(tree, proto_can, tvb, 0, 1 , ENC_NA );
can_tree = proto_item_add_subtree(ti, ett_can);
proto_tree_add_item(can_tree, hf_can_ident, tvb, 0, 4, ENC_BIG_ENDIAN );
if (tree) {
ti = proto_tree_add_item( tree, proto_socks, tvb, offset, -1,
- FALSE );
+ ENC_NA );
socks_tree = proto_item_add_subtree(ti, ett_socks);
item = proto_tree_add_item(tree, proto_spnego, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
subtree = proto_item_add_subtree(item, ett_spnego);
/*
}
item = proto_tree_add_item(parent_tree, proto_spnego, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
subtree = proto_item_add_subtree(item, ett_spnego);
col_set_str(pinfo->cinfo, COL_INFO, "SPP");
if (tree) {
- ti = proto_tree_add_item(tree, proto_spp, tvb, 0, SPP_HEADER_LEN, FALSE);
+ ti = proto_tree_add_item(tree, proto_spp, tvb, 0, SPP_HEADER_LEN, ENC_NA);
spp_tree = proto_item_add_subtree(ti, ett_spp);
}
if ( tree )
{
- ti = proto_tree_add_item(tree, proto_sqloracle, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_sqloracle, tvb, 0, -1, ENC_NA);
sqloracle_tree = proto_item_add_subtree(ti, ett_sqloracle);
proto_tree_add_uint(sqloracle_tree, hf_sqloracle_operation, tvb, offset, 1,header_operation);
if (func_type && header_operation !=NET8_TYPE_ROWTRANSFER)
/* add the 'ccsrl' tree to the main tree */
if (tree) {
- ccsrl_item = proto_tree_add_item (tree, proto_ccsrl, tvb, 0, -1, FALSE);
+ ccsrl_item = proto_tree_add_item (tree, proto_ccsrl, tvb, 0, -1, ENC_NA);
ccsrl_tree = proto_item_add_subtree (ccsrl_item, ett_ccsrl);
proto_tree_add_uint(ccsrl_tree,hf_ccsrl_ls,tvb,0,1,lastseg);
}
/* XXX add support for reassembly of fragments */
-
+
/* XXX currently, we always dissect as H245. It's not necessarily
that though.
*/
proto_item *hidden_item;
guint8 header = tvb_get_guint8(tvb,0);
-
+
/* add the 'srp' tree to the main tree */
if (tree) {
- srp_item = proto_tree_add_item (tree, proto_srp, tvb, 0, -1, FALSE);
+ srp_item = proto_tree_add_item (tree, proto_srp, tvb, 0, -1, ENC_NA);
srp_tree = proto_item_add_subtree (srp_item, ett_srp);
proto_tree_add_uint(srp_tree,hf_srp_header,tvb,0,1,header);
}
/* crc includes the header */
calc_crc = crc16_ccitt_tvb(tvb,crc_offset);
-
+
if( crc == calc_crc ) {
proto_tree_add_uint_format(srp_tree, hf_srp_crc, tvb,
crc_offset, 2, crc,
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(function, srvloc_functions, "Unknown Function (%u)"));
- ti = proto_tree_add_item(tree, proto_srvloc, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_srvloc, tvb, offset, -1, ENC_NA);
srvloc_tree = proto_item_add_subtree(ti, ett_srvloc);
proto_tree_add_uint(srvloc_tree, hf_srvloc_version, tvb, offset, 1,
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_srvloc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_srvloc, tvb, 0, -1, ENC_NA);
srvloc_tree = proto_item_add_subtree(ti, ett_srvloc);
}
dissect_srvloc(tvb, pinfo, srvloc_tree);
reported_length = tvb_reported_length(tvb); /* frame length */
if (tree) {
- sscf_item = proto_tree_add_item(tree, proto_sscf, tvb, 0, -1, FALSE);
+ sscf_item = proto_tree_add_item(tree, proto_sscf, tvb, 0, -1, ENC_NA);
sscf_tree = proto_item_add_subtree(sscf_item, ett_sscf);
}
}
}
if(tree) {
- ti = proto_tree_add_item(tree, proto_ssh, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ssh, tvb, offset, -1, ENC_NA);
ssh_tree = proto_item_add_subtree(ti, ett_ssh);
}
number = 0;
/* Create display subtree for SSL as a whole */
if (tree)
{
- ti = proto_tree_add_item(tree, proto_ssl, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_ssl, tvb, 0, -1, ENC_NA);
ssl_tree = proto_item_add_subtree(ti, ett_ssl);
}
/* iterate through the records in this tvbuff */
proto_tree *starteamroot_tree;
proto_item *ti;
- ti = proto_tree_add_item(tree, proto_starteam, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_starteam, tvb, offset, -1, ENC_NA);
if (bRequest) proto_item_append_text(ti, " (%s)",
val_to_str_ext(iCommand, &starteam_opcode_vals_ext, "Unknown (0x%02x)"));
starteamroot_tree = proto_item_add_subtree(ti, ett_starteam);
ti = proto_tree_add_item(
tree, proto_stun, tvb, 0,
CHANNEL_DATA_HDR_LEN,
- ENC_BIG_ENDIAN);
+ ENC_NA);
proto_item_append_text(ti, ", TURN ChannelData Message");
stun_tree = proto_item_add_subtree(ti, ett_stun);
proto_tree_add_item(stun_tree, hf_stun_channel, tvb, 0, 2, ENC_BIG_ENDIAN);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s",
msg_method_str, msg_class_str);
- ti = proto_tree_add_item(tree, proto_stun, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_stun, tvb, 0, -1, ENC_NA);
stun_tree = proto_item_add_subtree(ti, ett_stun);
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
if (parent_tree){
- item = proto_tree_add_item(parent_tree, proto_sv, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_sv, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_sv);
}
col_set_str(pinfo->cinfo, COL_PROTOCOL, PNAME);
guint16 framesize;
tvbuff_t *sub_tvb;
- temp_item = proto_tree_add_item(tree, proto_synphasor, tvb, 0, -1, FALSE);
+ temp_item = proto_tree_add_item(tree, proto_synphasor, tvb, 0, -1, ENC_NA);
proto_item_append_text(temp_item, ", %s", val_to_str(frame_type, typenames,
", invalid packet type"));
void register_t124_sd_dissector(packet_info *pinfo _U_, guint32 channelId, dissector_t dissector, int proto)
{
/* XXX: we should keep the sub-dissectors list per conversation
- as the same channels may be used.
+ as the same channels may be used.
While we are just using RDP over T.124, then we can get away with it.
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, "T.125");
col_clear(pinfo->cinfo, COL_INFO);
- item = proto_tree_add_item(parent_tree, proto_t124, tvb, 0, tvb_length(tvb), FALSE);
+ item = proto_tree_add_item(parent_tree, proto_t124, tvb, 0, tvb_length(tvb), ENC_NA);
tree = proto_item_add_subtree(item, ett_t124);
asn1_ctx_init(&asn1_ctx, ASN1_ENC_PER, TRUE, pinfo);
(void) dissect_per_sequence(tvb, 0, &asn1_ctx, NULL, -1, -1, t124Heur_sequence);
- if((t124Identifier != NULL) &&
+ if((t124Identifier != NULL) &&
(strcmp(t124Identifier, "0.0.20.124.0.1") == 0)) {
dissect_t124(tvb, pinfo, parent_tree);
/* suppress some warnings */
warning_suppressor = dissect_t124_GCCPDU;
warning_suppressor = dissect_t124_ConnectMCSPDU;
-
+
}
void
col_set_str(pinfo->cinfo, COL_PROTOCOL, "T.125");
col_clear(pinfo->cinfo, COL_INFO);
- item = proto_tree_add_item(parent_tree, proto_t125, tvb, 0, tvb_length(tvb), FALSE);
+ item = proto_tree_add_item(parent_tree, proto_t125, tvb, 0, tvb_length(tvb), ENC_NA);
tree = proto_item_add_subtree(item, ett_t125);
get_ber_identifier(tvb, 0, &class, &pc, &tag);
/* or PER */
dissect_per_constrained_integer(tvb, 0, &asn1_ctx,
NULL, hf_t125_heur, 0, 42,
- &choice_index, FALSE);
+ &choice_index, FALSE);
/* is this strong enough ? */
if ( ((class==BER_CLASS_APP) && ((tag>=101) && (tag<=104))) ||
char opcode[TALI_OPCODE_LENGTH+1]; /* TALI opcode */
guint16 length; /* TALI length */
tvbuff_t *payload_tvb = NULL;
-
+
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *tali_item = NULL;
proto_tree *tali_tree = NULL;
-
+
tvb_memcpy(tvb, (guint8*)opcode, TALI_SYNC_LENGTH, TALI_OPCODE_LENGTH);
opcode[TALI_OPCODE_LENGTH] = '\0';
length = tvb_get_letohs(tvb, TALI_SYNC_LENGTH + TALI_OPCODE_LENGTH);
/* Make entries in Protocol column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TALI");
-
+
if (check_col(pinfo->cinfo, COL_INFO)) {
col_set_str(pinfo->cinfo, COL_INFO, "");
col_append_fstr(pinfo->cinfo, COL_INFO, "[%s] packet, [%u] bytes in payload", opcode, length);
if (tree) {
/* create display subtree for the protocol */
- tali_item = proto_tree_add_item(tree, proto_tali, tvb, 0, TALI_HEADER_LENGTH, TRUE);
+ tali_item = proto_tree_add_item(tree, proto_tali, tvb, 0, TALI_HEADER_LENGTH, ENC_NA);
tali_tree = proto_item_add_subtree(tali_item, ett_tali);
proto_tree_add_string(tali_tree, hf_tali_sync_indicator, tvb, 0, TALI_SYNC_LENGTH, TALI_SYNC);
proto_tree_add_string(tali_tree, hf_tali_opcode_indicator, tvb, TALI_SYNC_LENGTH, TALI_OPCODE_LENGTH, opcode);
proto_tali = proto_register_protocol("Transport Adapter Layer Interface v1.0, RFC 3094", "TALI", "tali");
register_dissector("tali", dissect_tali, proto_tali);
tali_handle = create_dissector_handle(dissect_tali, proto_tali);
-
+
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_tali, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
if (tree) {
ti = proto_tree_add_item(tree, proto_tapa, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
tapa_discover_tree = proto_item_add_subtree(ti, ett_tapa_discover);
proto_tree_add_item(tapa_discover_tree, hf_tapa_discover_type, tvb, offset, 1,
if (tree) {
ti = proto_tree_add_item(tree, proto_tapa, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
tapa_tunnel_tree = proto_item_add_subtree(ti, ett_tapa_tunnel);
proto_tree_add_item(tapa_tunnel_tree, hf_tapa_tunnel_version, tvb, offset, 1,
get_tcp_port(tcph->th_dport), tcph->th_dport);
}
else {
- ti = proto_tree_add_item(tree, proto_tcp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_tcp, tvb, 0, -1, ENC_NA);
}
tcp_tree = proto_item_add_subtree(ti, ett_tcp);
pinfo->tcp_tree=tcp_tree;
}
}
}
-
+
if (tcph->th_flags & TH_ACK) {
if (tree) {
if (tcp_relative_seq){
packet_number = tvb_get_guint8(tvb, offset + 6);
/* create display subtree for the protocol */
- tds_item = proto_tree_add_item(tree, proto_tds, tvb, offset, -1, FALSE);
+ tds_item = proto_tree_add_item(tree, proto_tds, tvb, offset, -1, ENC_NA);
tds_tree = proto_item_add_subtree(tds_item, ett_tds);
proto_tree_add_item(tds_tree, hf_tds_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
tds_item = proto_tree_add_item(tds_tree, hf_tds_status, tvb, offset + 1, 1, ENC_LITTLE_ENDIAN);
if (tree) {
/* create display subtree for the protocol */
tds_item = proto_tree_add_item(tree, proto_tds,
- tvb, offset, -1, FALSE);
+ tvb, offset, -1, ENC_NA);
tds_tree = proto_item_add_subtree(tds_item,
ett_tds);
proto_item *ti = NULL;
proto_tree *ts2_tree = NULL;
- ti = proto_tree_add_item(tree, proto_ts2, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_ts2, tvb, 0, -1, ENC_NA);
ts2_tree = proto_item_add_subtree(ti, ett_ts2);
proto_tree_add_item(ts2_tree, hf_ts2_class, tvb, 0, 2, ENC_LITTLE_ENDIAN);
proto_tree *tei_tree = NULL;
proto_item *tei_ti;
guint8 message;
-
+
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TEI");
col_clear(pinfo->cinfo, COL_INFO);
-
+
if (tree) {
- tei_ti = proto_tree_add_item(tree, proto_tei, tvb, 0, 5, FALSE);
+ tei_ti = proto_tree_add_item(tree, proto_tei, tvb, 0, 5, ENC_NA);
tei_tree = proto_item_add_subtree(tei_ti, lm_subtree);
-
+
proto_tree_add_item(tei_tree, lm_entity_id, tvb, 0, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tei_tree, lm_reference, tvb, 1, 2, ENC_BIG_ENDIAN);
}
static gint *subtree[]={
&lm_subtree
};
-
+
static hf_register_info hf[] = {
{ &lm_entity_id,
{ "Entity", "tei.entity", FT_UINT8, BASE_HEX, NULL, 0x0,
telkonet_tree = NULL;
- ti = proto_tree_add_item(tree, proto_telkonet, tvb, 0, 8, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_telkonet, tvb, 0, 8, ENC_NA);
telkonet_tree = proto_item_add_subtree(ti, ett_telkonet);
proto_tree_add_item(telkonet_tree, hf_telkonet_type, tvb, 0, 8, ENC_NA);
is_tn3270 = find_tn3270_conversation(pinfo);
is_tn5250 = find_tn5250_conversation(pinfo);
- ti = proto_tree_add_item(tree, proto_telnet, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_telnet, tvb, offset, -1, ENC_NA);
telnet_tree = proto_item_add_subtree(ti, ett_telnet);
/*
guint8 th_cidlen;
guint8 th_authdlen;
guint8 th_nonce[8];
- guint8 th_conf;
+ guint8 th_conf;
- guint8 th_ip_v_hl;
+ guint8 th_ip_v_hl;
guint16 th_header;
guint16 th_orgport;
guint32 th_iporgaddr;
ti = proto_tree_add_item(tree, hf_teredo_auth, tvb, offset-4,
13 + idlen + aulen, ENC_NA);
tree = proto_item_add_subtree(ti, ett_teredo_auth);
-
+
proto_tree_add_item(tree, hf_teredo_auth_idlen, tvb,
offset - 2, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_teredo_auth_aulen, tvb,
if (dissector_try_uint(teredo_dissector_table, th_header, next_tvb, pinfo, tree))
return;
- call_dissector(data_handle,next_tvb, pinfo, tree);
+ call_dissector(data_handle,next_tvb, pinfo, tree);
}
static void
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_teredo, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_teredo, tvb, 0, -1, ENC_NA);
teredo_tree = proto_item_add_subtree(ti, ett_teredo);
}
else
teredoh->th_ip_v_hl = tvb_get_guint8(tvb, offset);
decode_teredo_ports(tvb, offset, pinfo, tree, teredoh->th_header /* , teredoh->th_orgport*/);
- tap_queue_packet(teredo_tap, pinfo, teredoh);
+ tap_queue_packet(teredo_tap, pinfo, teredoh);
}
val = tvb_get_ntohs(tvb, offset);
}
- /*
+ /*
* We have to check upper-layer packet a little bit otherwise we will
* match -almost- *ANY* packet.
* These checks are in the Teredo specification by the way.
{ "Teredo Authentication header", "teredo.auth",
FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
-
+
{ &hf_teredo_auth_idlen,
{ "Client identifier length", "teredo.auth.idlen",
FT_UINT8, BASE_DEC, NULL, 0x0,
guint8 word[6];
int length = tvb_length(tvb);
- /* Check if this is actually xml
+ /* Check if this is actually xml
* If there is less than 38 characters this is not XML
* <?xml version="1.0" encoding="UTF-8"?>
*/
if (tree) {
ti = proto_tree_add_item(tree, proto_text_lines,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
if (data_name)
proto_item_append_text(ti, ": %s", data_name);
subtree = proto_item_add_subtree(ti, ett_text_lines);
val_to_str(opcode, tftp_opcode_vals, "Unknown (0x%04x)"));
if (tree) {
- ti = proto_tree_add_item(tree, proto_tftp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_tftp, tvb, offset, -1, ENC_NA);
tftp_tree = proto_item_add_subtree(ti, ett_tftp);
if (tftp_info->source_file) {
if (tree) {
- ti = proto_tree_add_item(tree, proto_time, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_time, tvb, 0, -1, ENC_NA);
time_tree = proto_item_add_subtree(ti, ett_time);
proto_tree_add_text(time_tree, tvb, 0, 0,
break;
}
- ti = proto_tree_add_item(tree, proto_tipc, tipc_tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_tipc, tipc_tvb, offset, -1, ENC_NA);
tipc_tree = proto_item_add_subtree(ti, ett_tipc);
if (version == TIPCv2) {
dissect_tipc_v2(tipc_tvb, tipc_tree, pinfo, offset, user, msg_size, hdr_size, datatype_hdr);
* Copyright 1998 Gerald Combs
*
* Copied from README.developer
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TiVoConnect");
-
+
/* make a distinction between UDP and TCP packets */
proto_name = pinfo->ipproto == IP_PROTO_TCP ?
"Discovery Connection" :
gchar * field = NULL;
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_tivoconnect, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_tivoconnect, tvb, 0, -1, ENC_NA);
tivoconnect_tree = proto_item_add_subtree(ti, ett_tivoconnect);
/* Adjust "Info" column and top of tree into more useful info */
if (packet_machine) {
proto_item_append_text(ti, ", %s", packet_machine);
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s",
proto_name, packet_machine);
}
packet_machine ? " (%s)" : ", ID:%s",
packet_identity);
if (packet_machine) {
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s (%s)",
proto_name, packet_machine, packet_identity);
}
else {
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s ID:%s",
proto_name, packet_identity);
}
void
proto_register_tivoconnect(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_tivoconnect_flavor,
{ "Flavor", "tivoconnect.flavor",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"Protocol Flavor supported by the originator", HFILL }},
{ &hf_tivoconnect_method,
{ "Method", "tivoconnect.method",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"Packet was delivered via UDP(broadcast) or TCP(connected)", HFILL }},
{ &hf_tivoconnect_platform,
{ "Platform", "tivoconnect.platform",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"System platform, either tcd(TiVo) or pc(Computer)", HFILL }},
{ &hf_tivoconnect_machine,
{ "Machine", "tivoconnect.machine",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"Human-readable system name", HFILL }},
{ &hf_tivoconnect_identity,
{ "Identity", "tivoconnect.identity",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"Unique serial number for the system", HFILL }},
{ &hf_tivoconnect_services,
{ "Services", "tivoconnect.services",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"List of available services on the system", HFILL }},
{ &hf_tivoconnect_version,
{ "Version", "tivoconnect.version",
- FT_STRINGZ, BASE_NONE, NULL, 0,
+ FT_STRINGZ, BASE_NONE, NULL, 0,
"System software version", HFILL }},
};
tvbuff_t *next_tvb;
if(tree){
- item = proto_tree_add_item(tree, proto_tnef, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_tnef, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(item, ett_tnef);
}
if (tree)
{
- ti = proto_tree_add_item(tree, proto_tns, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_tns, tvb, 0, -1, ENC_NA);
tns_tree = proto_item_add_subtree(ti, ett_tns);
if (pinfo->match_uint == pinfo->destport)
col_set_str(pinfo->cinfo, COL_INFO, "Continuation");
if (tree) {
ti = proto_tree_add_item(tree, proto_tpkt, tvb,
- offset, -1, FALSE);
+ offset, -1, ENC_NA);
tpkt_tree = proto_item_add_subtree(ti, ett_tpkt);
proto_item_set_text(ti, "TPKT");
if (tree) {
ti = proto_tree_add_item(tree, proto_tpkt, tvb,
- offset, 8, FALSE);
+ offset, 8, ENC_NA);
tpkt_tree = proto_item_add_subtree(ti, ett_tpkt);
proto_item_set_text(ti, "TPKT");
col_set_str(pinfo->cinfo, COL_INFO, "Continuation");
if (tree) {
ti = proto_tree_add_item(tree, proto_tpkt, tvb,
- offset, -1, FALSE);
+ offset, -1, ENC_NA);
tpkt_tree = proto_item_add_subtree(ti, ett_tpkt);
proto_item_set_text(ti, "TPKT");
if (tree) {
ti = proto_tree_add_item(tree, proto_tpkt, tvb,
- offset, 4, FALSE);
+ offset, 4, ENC_NA);
tpkt_tree = proto_item_add_subtree(ti, ett_tpkt);
proto_item_set_text(ti, "TPKT");
}
if (tree) {
- item = proto_tree_add_item(tree, proto_tpncp, tvb, 0, -1, FALSE);
+ item = proto_tree_add_item(tree, proto_tpncp, tvb, 0, -1, ENC_NA);
tpncp_tree = proto_item_add_subtree(item, ett_tpncp);
proto_tree_add_uint(tpncp_tree, hf_tpncp_version, tvb, 0, 2, ver);
/* protocol analysis tree */
if (tree) {
/* Create Token-Ring Tree */
- ti = proto_tree_add_item(tree, proto_tr, tr_tvb, 0, TR_MIN_HEADER_LEN + actual_rif_bytes, FALSE);
+ ti = proto_tree_add_item(tree, proto_tr, tr_tvb, 0, TR_MIN_HEADER_LEN + actual_rif_bytes, ENC_NA);
tr_tree = proto_item_add_subtree(ti, ett_token_ring);
/* Create the Access Control bitfield tree */
/* TODO For now we will just add all the options into a byte field.
Later this should be parsed out into a sub-tree with all the option
details. */
-static int hf_trill_options= -1 ;
+static int hf_trill_options= -1 ;
static dissector_handle_t eth_dissector ;
op_len = tvb_get_bits( tvb, 5, 5, FALSE ) * TRILL_OP_LENGTH_BYTE_UNITS ;
if (tree) {
- ti = proto_tree_add_item( tree, proto_trill, tvb, 0, -1, FALSE ) ;
+ ti = proto_tree_add_item( tree, proto_trill, tvb, 0, -1, ENC_NA ) ;
trill_tree = proto_item_add_subtree( ti, ett_trill ) ;
/* Parse the bit fields, i.e. V, R, M, Op-Length, Hop Count. */
proto_tree_add_item( trill_tree, hf_trill_multi_dst, tvb, offset,
TRILL_BIT_FIELDS_LEN, ENC_BIG_ENDIAN ) ;
proto_tree_add_item( trill_tree, hf_trill_op_len, tvb, offset,
- TRILL_BIT_FIELDS_LEN, ENC_BIG_ENDIAN ) ;
+ TRILL_BIT_FIELDS_LEN, ENC_BIG_ENDIAN ) ;
proto_tree_add_item( trill_tree, hf_trill_hop_cnt, tvb, offset,
TRILL_BIT_FIELDS_LEN, ENC_BIG_ENDIAN ) ;
/* Parse the options field. */
offset += TRILL_NICKNAME_LEN ;
- if( op_len != 0 ) {
+ if( op_len != 0 ) {
proto_tree_add_item( trill_tree, hf_trill_options, tvb,
offset, op_len, ENC_NA ) ;
}
/* Register the protocol with Wireshark */
void
proto_register_trill(void)
-{
+{
static hf_register_info hf[] = {
{ &hf_trill_version,
{ "Version", "trill.version",
if (tree) {
mv_length = tvb_get_ntohs(tvb, 0);
- ti = proto_tree_add_item(tree, proto_trmac, tvb, 0, mv_length, FALSE);
+ ti = proto_tree_add_item(tree, proto_trmac, tvb, 0, mv_length, ENC_NA);
mac_tree = proto_item_add_subtree(ti, ett_tr_mac);
proto_tree_add_uint(mac_tree, hf_trmac_mv, tvb, 3, 1, mv_val);
if (tree) {
tsp_item = proto_tree_add_item(tree, proto_tsp,
- tvb, 0, -1, FALSE);
+ tvb, 0, -1, ENC_NA);
if (tsp_item)
tsp_tree = proto_item_add_subtree(tsp_item, ett_tsp);
}
/* Initialize the subtree pointers */
static gint ett_tte_pcf = -1;
-static const value_string pcf_type_str_vals[] =
+static const value_string pcf_type_str_vals[] =
{ {2, "integration frame"}
, {4, "coldstart frame"}
, {8, "coldstart ack frame"}
/* create display subtree for the protocol */
tte_pcf_root_item = proto_tree_add_item(tree, proto_tte_pcf, tvb, 0,
- TTE_PCF_LENGTH, FALSE);
+ TTE_PCF_LENGTH, ENC_NA);
tte_pcf_tree = proto_item_add_subtree(tte_pcf_root_item, ett_tte_pcf);
/* create display subtree for the protocol */
tte_root_item = proto_tree_add_item(tree, proto_tte, tvb, 0,
- TTE_HEADER_LENGTH, FALSE);
+ TTE_HEADER_LENGTH, ENC_NA);
tte_tree = proto_item_add_subtree(tte_root_item, ett_tte);
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_turbocell, tvb, 0, 20, FALSE);
+ ti = proto_tree_add_item(tree, proto_turbocell, tvb, 0, 20, ENC_NA);
turbocell_tree = proto_item_add_subtree(ti, ett_turbocell);
static int hf_turnchannel_id = -1;
static int hf_turnchannel_len = -1;
-#define TURNCHANNEL_HDR_LEN ((guint)4)
+#define TURNCHANNEL_HDR_LEN ((guint)4)
/* Initialize the subtree pointers */
static gint ett_turnchannel = -1;
static int
-dissect_turnchannel_message(tvbuff_t *tvb, packet_info *pinfo,
+dissect_turnchannel_message(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree)
{
guint len;
if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "Channel Id 0x%x", channel_id);
- ti = proto_tree_add_item(tree, proto_turnchannel, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_turnchannel, tvb, 0, -1, ENC_NA);
turnchannel_tree = proto_item_add_subtree(ti, ett_turnchannel);
proto_tree_add_uint(turnchannel_tree, hf_turnchannel_id, tvb, 0, 2, channel_id);
proto_tree_add_uint(turnchannel_tree, hf_turnchannel_len, tvb, 2, 2, data_len);
-
+
if (len > TURNCHANNEL_HDR_LEN) {
tvbuff_t *next_tvb;
guint reported_len, new_len;
new_len = tvb_length_remaining(tvb, TURNCHANNEL_HDR_LEN);
- reported_len = tvb_reported_length_remaining(tvb,
+ reported_len = tvb_reported_length_remaining(tvb,
TURNCHANNEL_HDR_LEN);
if (data_len < reported_len) {
reported_len = data_len;
}
- next_tvb = tvb_new_subset(tvb, TURNCHANNEL_HDR_LEN, new_len,
+ next_tvb = tvb_new_subset(tvb, TURNCHANNEL_HDR_LEN, new_len,
reported_len);
- if (!dissector_try_heuristic(heur_subdissector_list,
+ if (!dissector_try_heuristic(heur_subdissector_list,
next_tvb, pinfo, tree)) {
call_dissector(data_handle,next_tvb, pinfo, tree);
}
if (tree)
{
- ti = proto_tree_add_item(tree, proto_tuxedo, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_tuxedo, tvb, 0, -1, ENC_NA);
tuxedoroot_tree = proto_item_add_subtree(ti, ett_tuxedo);
proto_tree_add_item(tuxedoroot_tree, hf_tuxedo_magic, tvb, 0, 4, ENC_BIG_ENDIAN);
col_set_str(pinfo->cinfo, COL_INFO, "Continuation");
if (tree)
{
- proto_tree_add_item(tree, proto_tuxedo, tvb, 0, -1, FALSE);
+ proto_tree_add_item(tree, proto_tuxedo, tvb, 0, -1, ENC_NA);
}
}
}
if(pTree)
{
/* root element "UA Protocol, ..." */
- pRootUA = proto_tree_add_item(pTree, proto_ua, pTvb, 0, -1, FALSE);
+ pRootUA = proto_tree_add_item(pTree, proto_ua, pTvb, 0, -1, ENC_NA);
pSubTreeUA = proto_item_add_subtree(pRootUA, ett_ua);
/* NOE items */
col_set_str(pInfo->cinfo, COL_INFO, val_to_str_const(u8Opcode, szUaOpcode, "Unknown"));
/* opcode "UA/UDP Protocol, ..." */
- pUAUDP = proto_tree_add_item(pTree, proto_uaudp, pTvb, 0, -1, ENC_BIG_ENDIAN);
+ pUAUDP = proto_tree_add_item(pTree, proto_uaudp, pTvb, 0, -1, ENC_NA);
proto_item_append_text(pUAUDP, ", %s (%d)", val_to_str_const(u8Opcode, szUaOpcode, "Unknown"), u8Opcode);
pHeaderSubTree = proto_item_add_subtree(pUAUDP, ett_uaudp_header);
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_ucp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ucp, tvb, 0, -1, ENC_NA);
ucp_tree = proto_item_add_subtree(ti, ett_ucp);
/*
proto_item *flags_ti;
proto_tree *flags_tree;
- ti = proto_tree_add_item(tree, proto_udld, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_udld, tvb, offset, -1, ENC_NA);
udld_tree = proto_item_add_subtree(ti, ett_udld);
/* UDLD header */
"Port ID: %s ",
tvb_format_stringzpad(tvb, offset + 4, length - 4));
- if (tree) {
+ if (tree) {
tlvi = proto_tree_add_text(udld_tree, tvb, offset,
real_length, "Port ID: %s",
tvb_format_text(tvb, offset + 4, real_length - 4));
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UMA");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_uma, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_uma, tvb, 0, -1, ENC_NA);
uma_tree = proto_item_add_subtree(ti, ett_uma);
/* add an item to the subtree, see section 1.6 for more information */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UMA");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_uma, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_uma, tvb, 0, -1, ENC_NA);
uma_tree = proto_item_add_subtree(ti, ett_uma);
octet = tvb_get_guint8(tvb,offset);
#define COMMON_TIMING_ADJUSTMENT 2
#define COMMON_DL_SYNCHRONISATION 3
#define COMMON_UL_SYNCHRONISATION 4
-
+
#define COMMON_DL_NODE_SYNCHRONISATION 6
#define COMMON_UL_NODE_SYNCHRONISATION 7
#define COMMON_DYNAMIC_PUSCH_ASSIGNMENT 8
ext_rx_sync_ul_timing_deviation_present = TRUE;
proto_tree_add_item(new_ie_flags_tree, hf_fp_rach_ext_rx_sync_ul_timing_deviation_present,
tvb, offset, 1, ENC_BIG_ENDIAN);
-
+
break;
default:
/* Not defined */
case Division_TDD_768:
bits_to_extend = 2;
break;
-
+
default:
/* TODO: report unexpected division type */
bits_to_extend = 1;
maces_tree = proto_item_add_subtree(ti, ett_fp_edch_maces);
}
for (macd_idx = 0; macd_idx < subframes[n].number_of_mac_d_pdus[i]; macd_idx++) {
-
+
if (preferences_call_mac_dissectors) {
tvbuff_t *next_tvb;
pinfo->fd->subnum = macd_idx; /* set subframe number to current TB */
proto_item *macis_pdu_ti;
proto_tree *macis_pdu_tree;
-
+
/* Add subframe header subtree */
macis_pdu_ti = proto_tree_add_string_format(tree, hf_fp_edch_subframe_header, tvb, offset, 0,
"", "MAC-is PDU (SFN=%u PDU %u)",
if (!p_fp_info->srcport || !p_fp_info->destport) {
p_fp_info->srcport = pinfo->srcport;
p_fp_info->destport = pinfo->destport;
- }
+ }
/* discriminate 'lower' UDP layer from 'user data' UDP layer
* (i.e. if an FP over UDP packet contains a user UDP packet */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FP");
/* Create fp tree. */
- ti = proto_tree_add_item(tree, proto_fp, tvb, offset, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_fp, tvb, offset, -1, ENC_NA);
fp_tree = proto_item_add_subtree(ti, ett_fp);
top_level_tree = tree;
proto_item *channel_type;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MAC");
col_set_str(pinfo->cinfo, COL_INFO, "PCCH");
-
+
if (tree) {
proto_item *ti;
- ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_NA);
pch_tree = proto_item_add_subtree(ti, ett_mac_pch);
proto_item_append_text(ti, " (PCCH)");
channel_type = proto_tree_add_uint(pch_tree, hf_mac_channel, tvb, 0, 0, MAC_PCCH);
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(tctf, rach_fdd_tctf_vals, "Unknown TCTF"));
- ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_NA);
rach_tree = proto_item_add_subtree(ti, ett_mac_rach);
macinf = p_get_proto_data(pinfo->fd, proto_umts_mac);
col_add_str(pinfo->cinfo, COL_INFO,
val_to_str(tctf, fach_fdd_tctf_vals, "Unknown TCTF"));
- ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_NA);
fach_tree = proto_item_add_subtree(ti, ett_mac_fach);
macinf = p_get_proto_data(pinfo->fd, proto_umts_mac);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MAC");
- ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_NA);
dch_tree = proto_item_add_subtree(ti, ett_mac_dch);
macinf = p_get_proto_data(pinfo->fd, proto_umts_mac);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MAC");
- ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_NA);
edch_tree = proto_item_add_subtree(ti, ett_mac_edch);
- fpinf = p_get_proto_data(pinfo->fd, proto_fp);
+ fpinf = p_get_proto_data(pinfo->fd, proto_fp);
macinf = p_get_proto_data(pinfo->fd, proto_umts_mac);
pos = fpinf->cur_tb;
if (!macinf) {
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MAC");
- ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_umts_mac, tvb, 0, -1, ENC_NA);
hsdsch_tree = proto_item_add_subtree(ti, ett_mac_hsdsch);
fpinf = p_get_proto_data(pinfo->fd, proto_fp);
}
}
- item = proto_tree_add_item(tree,proto_user_encap,tvb,0,-1,FALSE);
+ item = proto_tree_add_item(tree,proto_user_encap,tvb,0,-1,ENC_NA);
if (!encap) {
char* msg = ep_strdup_printf("User encapsulation not handled: DLT=%d, "
"check your Preferences->Protocols->DLT_USER",
col_set_str(pinfo->cinfo, COL_PROTOCOL, "V52");
if (tree) {
- ti = proto_tree_add_item(tree, proto_v52, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_v52, tvb, offset, -1, ENC_NA);
v52_tree = proto_item_add_subtree(ti, ett_v52);
dissect_v52_protocol_discriminator(tvb, offset, v52_tree);
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_v5ua, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_v5ua, tvb, 0, -1, ENC_NA);
v5ua_tree = proto_item_add_subtree(ti, ett_v5ua);
}
else {
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_vicp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_vicp, tvb, 0, -1, ENC_NA);
vicp_tree = proto_item_add_subtree(ti, ett_vicp);
cursor = ptvcursor_new(vicp_tree, tvb, 0);
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_frp, tvb, 0, 2,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vines_frp_tree = proto_item_add_subtree(ti, ett_vines_frp);
vines_frp_ctrl = tvb_get_guint8(tvb, 0);
"Unknown protocol 0x%02x"));
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_llc, tvb, 0, 1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vines_llc_tree = proto_item_add_subtree(ti, ett_vines_llc);
proto_tree_add_text(vines_llc_tree, tvb, 0, 1,
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_ip, tvb,
offset, viph.vip_pktlen,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vip_tree = proto_item_add_subtree(ti, ett_vines_ip);
proto_tree_add_text(vip_tree, tvb, offset, 2,
"Packet checksum: 0x%04x",
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_echo, tvb, 0, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vines_echo_tree = proto_item_add_subtree(ti, ett_vines_echo);
proto_tree_add_text(vines_echo_tree, tvb, 0, -1, "Data");
}
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_ipc, tvb, offset,
- sizeof(viph), ENC_BIG_ENDIAN);
+ sizeof(viph), ENC_NA);
vipc_tree = proto_item_add_subtree(ti, ett_vines_ipc);
proto_tree_add_text(vipc_tree, tvb, offset, 2,
"Source port: 0x%04x", viph.vipc_sport);
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_spp, tvb, offset,
- sizeof(viph), ENC_BIG_ENDIAN);
+ sizeof(viph), ENC_NA);
vspp_tree = proto_item_add_subtree(ti, ett_vines_spp);
proto_tree_add_text(vspp_tree, tvb, offset, 2,
"Source port: 0x%04x", viph.vspp_sport);
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_arp, tvb, 0, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vines_arp_tree = proto_item_add_subtree(ti, ett_vines_arp);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_rtp, tvb, 0, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vines_rtp_tree = proto_item_add_subtree(ti, ett_vines_rtp);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_vines_icp, tvb, 0, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
vines_icp_tree = proto_item_add_subtree(ti, ett_vines_icp);
}
vlan_tree = NULL;
if (tree) {
- ti = proto_tree_add_item(tree, proto_vlan, tvb, 0, 4, FALSE);
+ ti = proto_tree_add_item(tree, proto_vlan, tvb, 0, 4, ENC_NA);
if (vlan_summary_in_tree) {
proto_item_append_text(ti, ", PRI: %u, CFI: %u, ID: %u",
col_set_str(pinfo->cinfo, COL_PROTOCOL, "VMLAB");
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_vmlab, tvb, 0, 24, FALSE);
+ ti = proto_tree_add_item(tree, proto_vmlab, tvb, 0, 24, ENC_NA);
vmlab_tree = proto_item_add_subtree(ti, ett_vmlab);
/* Flags*/
/* create display subtree for the protocol */
if(tree) {
- ti = proto_tree_add_item(tree, proto_vnc, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_vnc, tvb, 0, -1, ENC_NA);
vnc_tree = proto_item_add_subtree(ti, ett_vnc);
}
guint16 cksum, computed_cksum;
guint8 auth_buf[VRRP_AUTH_DATA_LEN + 1];
- ti = proto_tree_add_item(tree, proto_vrrp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_vrrp, tvb, 0, -1, ENC_NA);
vrrp_tree = proto_item_add_subtree(ti, ett_vrrp);
tv = proto_tree_add_uint_format(vrrp_tree, hf_vrrp_ver_type,
if (tree) {
ti = proto_tree_add_item(tree, proto_vtp, tvb, offset, -1,
- FALSE);
+ ENC_NA);
vtp_tree = proto_item_add_subtree(ti, ett_vtp);
proto_tree_add_item(vtp_tree, hf_vtp_version, tvb, offset, 1,
/* clear the info column */
col_clear( pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree, proto_vuze_dht, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_vuze_dht, tvb, 0, -1, ENC_NA);
sub_tree = proto_item_add_subtree(ti, ett_vuze_dht);
/*
if (tree) {
/* Header dissection */
ti = proto_tree_add_item(tree, proto_wassp, tvb, offset, -1,
- ENC_BIG_ENDIAN);
+ ENC_NA);
wassp_tree = proto_item_add_subtree(ti, ett_wassp);
proto_tree_add_item(wassp_tree, hf_wassp_version, tvb, offset, 1,
/* Add summary to INFO column if it is enabled */
if (check_col(pinfo->cinfo, COL_INFO))
col_append_fstr(pinfo->cinfo, COL_INFO, " (Unknown WBXML version 0x%02x)", version);
- ti = proto_tree_add_item (tree, proto_wbxml, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_wbxml, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Unknown version 0x%02x", version);
return;
}
col_append_fstr(pinfo->cinfo, COL_INFO, " (WBXML %s)", summary);
/* create display subtree for the protocol */
- ti = proto_tree_add_item (tree, proto_wbxml, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_wbxml, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Version: %s", summary);
g_free(summary);
/*
if(tree != NULL) {
wccp_tree_item = proto_tree_add_item(tree, proto_wccp, tvb, offset,
- -1, FALSE);
+ -1, ENC_NA);
wccp_tree = proto_item_add_subtree(wccp_tree_item, ett_wccp);
proto_tree_add_uint(wccp_tree, hf_wccp_message_type, tvb, offset,
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_wcp, tvb, 0, wcp_header_len, FALSE);
+ ti = proto_tree_add_item(tree, proto_wcp, tvb, 0, wcp_header_len, ENC_NA);
wcp_tree = proto_item_add_subtree(ti, ett_wcp);
cmd = tvb_get_guint8(tvb, 1);
if (tree) {
- ti = proto_tree_add_item(tree, proto_wfleet_hdlc, tvb, 0, 2, FALSE);
+ ti = proto_tree_add_item(tree, proto_wfleet_hdlc, tvb, 0, 2, ENC_NA);
fh_tree = proto_item_add_subtree(ti, ett_wfleet_hdlc);
proto_tree_add_uint(fh_tree, hf_wfleet_hdlc_addr, tvb, 0, 1, addr);
}
/*
- * Build a tvb of the piece past the first two bytes and call the
+ * Build a tvb of the piece past the first two bytes and call the
* ethernet dissector
*/
wfleet_hdlc_handle = find_dissector("wfleet_hdlc");
dissector_add_uint("wtap_encap", WTAP_ENCAP_WFLEET_HDLC, wfleet_hdlc_handle);
- /*
+ /*
* Find the eth dissector and save a ref to it
*/
if (tree) {
who_ti = proto_tree_add_item(tree, proto_who, tvb, offset, -1,
- FALSE);
+ ENC_NA);
who_tree = proto_item_add_subtree(who_ti, ett_who);
}
col_clear(pinfo->cinfo, COL_INFO);
if (parent_tree) {
- winsrepl_item = proto_tree_add_item(parent_tree, proto_winsrepl, tvb, offset, -1, FALSE);
+ winsrepl_item = proto_tree_add_item(parent_tree, proto_winsrepl, tvb, offset, -1, ENC_NA);
winsrepl_tree = proto_item_add_subtree(winsrepl_item, ett_winsrepl);
}
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_wlccp, tvb, 0, -1, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_wlccp, tvb, 0, -1, ENC_NA);
wlccp_tree = proto_item_add_subtree(ti, ett_wlccp);
proto_tree_add_item(wlccp_tree, hf_wlccp_version,
offset to the end of the packet. */
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_wol, tvb, 0, len, FALSE);
+ ti = proto_tree_add_item(tree, proto_wol, tvb, 0, len, ENC_NA);
proto_item_append_text(ti, ", MAC: %s (%s)", get_ether_name(mac),
ether_to_str(mac));
if ( passwd )
}
if(tree) {
- ti = proto_tree_add_item(tree, proto_wow, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_wow, tvb, 0, -1, ENC_NA);
wow_tree = proto_item_add_subtree(ti, ett_wow);
proto_tree_add_item(wow_tree, hf_wow_command, tvb, offset, 1,
if (tree) {
/* create display subtree for the protocol */
- ti = proto_tree_add_item(tree, proto_wsmp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_wsmp, tvb, 0, -1, ENC_NA);
wsmp_tree = proto_item_add_subtree(ti, ett_wsmp);
proto_tree_add_item(wsmp_tree,
hf_wsmp_acmlength, tvb, offset, 1, ENC_BIG_ENDIAN);
offset ++;
-
+
proto_tree_add_item(wsmp_tree, hf_wsmp_acm, tvb, offset, acmlength, ENC_ASCII|ENC_NA);
offset +=acmlength;
wsmlength = tvb_get_letohs( tvb, offset);
proto_tree_add_item(wsmp_tree,
hf_wsmp_wsmlength, tvb, offset, 2, ENC_LITTLE_ENDIAN);
- offset += 2;
-
+ offset += 2;
+
wsmdata_item = proto_tree_add_text (wsmp_tree, tvb, offset, wsmlength,
"Wave Short Message");
wsmdata_tree = proto_item_add_subtree(wsmdata_item, ett_wsmdata);
- /* TODO: Branch on the application context and display accordingly
+ /* TODO: Branch on the application context and display accordingly
* Default call the data dissector
*/
wsmdata_tvb = tvb_new_subset(tvb, offset,wsmlength, wsmlength);
void
proto_register_wsmp(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_wsmp_version,
- { "Version", "wsmp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "Version", "wsmp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_security,
- { "Security", "wsmp.security", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "Security", "wsmp.security", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_channel,
- { "Channel", "wsmp.channel", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "Channel", "wsmp.channel", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_rate,
- { "Rate", "wsmp.rate", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "Rate", "wsmp.rate", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_txpower,
- { "Transmit power", "wsmp.txpower", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "Transmit power", "wsmp.txpower", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_appclass,
- { "App class", "wsmp.appclass", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "App class", "wsmp.appclass", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_acmlength,
- { "Acm Length", "wsmp.acmlength", FT_UINT8, BASE_DEC, NULL, 0x0,
+ { "Acm Length", "wsmp.acmlength", FT_UINT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_wsmp_acm,
{ "Application Context Data", "wsmp.acm", FT_STRING,
BASE_NONE, NULL, 0x0, "Acm", HFILL }},
{ &hf_wsmp_wsmlength,
- { "WSM Length", "wsmp.wsmlength", FT_UINT16, BASE_DEC, NULL, 0x0,
+ { "WSM Length", "wsmp.wsmlength", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
};
&ett_wsmdata,
};
- /* Register the protocol name and description */
+ /* Register the protocol name and description */
proto_wsmp = proto_register_protocol("Wave Short Message Protocol(IEEE P1609.3)",
"WSMP", "wsmp");
}
/* If this dissector uses sub-dissector registration add a registration routine.
- This exact format is required because a script is used to find these routines
+ This exact format is required because a script is used to find these routines
and create the code that calls these routines.
*/
if (tree) {
ti = proto_tree_add_item(tree, proto_wtls, tvb, offset_wtls,
- -1, ENC_LITTLE_ENDIAN);
+ -1, ENC_NA);
wtls_tree = proto_item_add_subtree(ti, ett_wtls);
for (offset_wtls=0; offset_wtls < (tvb_reported_length(tvb)-1);) {
guint count;
guint i;
guint64 session_id;
- header_field_info *hfinfo;
+ header_field_info *hfinfo;
count = tvb_get_guint8(tvb, offset);
if (count == 0)
if (tree) {
ti = proto_tree_add_item(tree, proto_wtp,
- tvb, offCur, 1, ENC_LITTLE_ENDIAN);
+ tvb, offCur, 1, ENC_NA);
wtp_tree = proto_item_add_subtree(ti, ett_wtp_sub_pdu_tree);
proto_item_append_text(ti, ", PDU concatenation");
}
fprintf(stderr, "dissect_wtp: cbHeader = %d\n", cbHeader);
#endif
/* NOTE - Length will be set when we process the TPI */
- ti = proto_tree_add_item(tree, proto_wtp, tvb, offCur, 0, ENC_LITTLE_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_wtp, tvb, offCur, 0, ENC_NA);
#ifdef DEBUG
fprintf(stderr, "dissect_wtp: (7) Returned from proto_tree_add_item\n");
#endif
guint16 auth_proto_name_length, auth_proto_data_length;
gint left;
- ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Request, Initial connection request");
t = proto_item_add_subtree(ti, ett_x11);
proto_item *ti;
proto_tree *t;
- ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
proto_item_append_text(ti, ", Reply, Initial connection reply");
t = proto_item_add_subtree(ti, ett_x11);
next_offset = offset + length;
- ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
t = proto_item_add_subtree(ti, ett_x11);
if (PACKET_IS_NEW(pinfo))
* Give up.
*/
ti = proto_tree_add_item(tree, proto_x11, tvb, offset, -1,
- FALSE);
+ ENC_NA);
t = proto_item_add_subtree(ti, ett_x11);
proto_tree_add_text(t, tvb, offset, -1,
"Bogus request length (0)");
proto_item *ti;
proto_tree *t;
- ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
t = proto_item_add_subtree(ti, ett_x11);
proto_item *ti;
proto_tree *t;
- ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
t = proto_item_add_subtree(ti, ett_x11);
eventcode = tvb_get_guint8(tvb, 0);
proto_item *ti;
proto_tree *t;
- ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
t = proto_item_add_subtree(ti, ett_x11);
CARD8(error);
length = tvb_get_guint8(tvb, offset);
if (parent_tree) {
- item = proto_tree_add_item(parent_tree, proto_x224, tvb, offset, length+1, FALSE);
+ item = proto_tree_add_item(parent_tree, proto_x224, tvb, offset, length+1, ENC_NA);
tree = proto_item_add_subtree(item, ett_x224);
}
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_x25, tvb, 0, x25_pkt_len, FALSE);
+ ti = proto_tree_add_item(tree, proto_x25, tvb, 0, x25_pkt_len, ENC_NA);
x25_tree = proto_item_add_subtree(ti, ett_x25);
ti = proto_tree_add_item(x25_tree, hf_x25_gfi, tvb, 0, 2, ENC_BIG_ENDIAN);
gfi_tree = proto_item_add_subtree(ti, ett_x25_gfi);
*/
frag_key |= 0x10000;
}
- fd_head = fragment_add_seq_next(tvb, localoffset,
+ fd_head = fragment_add_seq_next(tvb, localoffset,
pinfo, frag_key,
x25_segment_table,
x25_reassembled_table,
proto_item *frag_tree_item;
/* This is the last packet */
- next_tvb = tvb_new_child_real_data(tvb, fd_head->data,
+ next_tvb = tvb_new_child_real_data(tvb, fd_head->data,
fd_head->len,
fd_head->len);
add_new_data_source(pinfo, next_tvb, "Reassembled X.25");
if (x25_tree) {
- show_fragment_seq_tree(fd_head,
- &x25_frag_items,
- x25_tree,
+ show_fragment_seq_tree(fd_head,
+ &x25_frag_items,
+ x25_tree,
pinfo, next_tvb, &frag_tree_item);
}
}
{ &hf_x25_segment_overlap,
{ "Fragment overlap", "x25.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment overlaps with other fragments", HFILL }},
-
+
{ &hf_x25_segment_overlap_conflict,
{ "Conflicting data in fragment overlap", "x25.fragment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Overlapping fragments contained conflicting data", HFILL }},
-
+
{ &hf_x25_segment_multiple_tails,
{ "Multiple tail fragments found", "x25.fragment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Several tails were found when defragmenting the packet", HFILL }},
-
+
{ &hf_x25_segment_too_long_segment,
{ "Fragment too long", "x25.fragment.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment contained data past end of packet", HFILL }},
-
+
{ &hf_x25_segment_error,
{ "Defragmentation error", "x25.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"Defragmentation error due to illegal fragments", HFILL }},
-
+
{ &hf_x25_segment_count,
{ "Fragment count", "x25.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
-
+
{ &hf_x25_reassembled_length,
{ "Reassembled X.25 length", "x25.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x0,
"The total length of the reassembled payload", HFILL }},
-
+
{ &hf_x25_segment,
{ "X.25 Fragment", "x25.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
"X25 Fragment", HFILL }},
-
+
{ &hf_x25_segments,
{ "X.25 Fragments", "x25.fragments", FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
if (tree) {
ti = proto_tree_add_item(tree, proto_x29, tvb, offset, -1,
- FALSE);
+ ENC_NA);
x29_tree = proto_item_add_subtree(ti, ett_x29);
}
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
- * Ref:
+ * Ref:
* 3GPP TS 36.423 V9.2.0 (2010-03)
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, "X2AP");
/* create the x2ap protocol tree */
- x2ap_item = proto_tree_add_item(tree, proto_x2ap, tvb, 0, -1, FALSE);
+ x2ap_item = proto_tree_add_item(tree, proto_x2ap, tvb, 0, -1, ENC_NA);
x2ap_tree = proto_item_add_subtree(x2ap_item, ett_x2ap);
-
+
dissect_X2AP_PDU_PDU(tvb, pinfo, x2ap_tree);
}
/* Register fields and subtrees */
proto_register_field_array(proto_x2ap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register dissector */
register_dissector("x2ap", dissect_x2ap, proto_x2ap);
/* Create display tree for the xcsl protocol */
if (tree) {
proto_item *xcsl_item;
- xcsl_item = proto_tree_add_item(tree, proto_xcsl, tvb, offset, -1, FALSE);
+ xcsl_item = proto_tree_add_item(tree, proto_xcsl, tvb, offset, -1, ENC_NA);
xcsl_tree = proto_item_add_subtree(xcsl_item, ett_xcsl);
}
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
- ti = proto_tree_add_item(tree, proto_xdmcp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_xdmcp, tvb, offset, -1, ENC_NA);
xdmcp_tree = proto_item_add_subtree(ti, ett_xdmcp);
proto_tree_add_uint(xdmcp_tree, hf_xdmcp_version, tvb,
}
}
- ti = proto_tree_add_item(tree, proto_xmcp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_xmcp, tvb, 0, -1, ENC_NA);
xmcp_tree = proto_item_add_subtree(ti, ett_xmcp);
ti = proto_tree_add_bitmask(xmcp_tree, tvb, 0, hf_xmcp_type, ett_xmcp_type,
/* packet-xmpp.c
* Routines for XMPP packet dissection
* Copyright 2003, Brad Hards <bradh@frogmouth.net>
- * Heavily based in packet-acap.c, which in turn is heavily based on
+ * Heavily based in packet-acap.c, which in turn is heavily based on
* packet-imap.c, Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
*
* $Id$
if (tree) {
ti = proto_tree_add_item(tree, proto_xmpp, tvb, offset, -1,
- ENC_BIG_ENDIAN) ;
+ ENC_NA) ;
xmpp_tree = proto_item_add_subtree(ti, ett_xmpp);
if (is_request) {
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_xtp, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_xtp, tvb, 0, -1, ENC_NA);
/** add summary **/
proto_item_append_text(ti,
", Key: 0x%016" G_GINT64_MODIFIER "X", xtph->key);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "XYPLEX");
if (tree) {
- ti = proto_tree_add_item(tree, proto_xyplex, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_xyplex, tvb, offset, -1, ENC_NA);
xyplex_tree = proto_item_add_subtree(ti, ett_xyplex);
}
if (tree) {
ti = proto_tree_add_item(tree, proto_yhoo, tvb, offset, -1,
- FALSE);
+ ENC_NA);
yhoo_tree = proto_item_add_subtree(ti, ett_yhoo);
proto_tree_add_item(yhoo_tree, hf_yhoo_version, tvb,
YAHOO_SERVICE_AUDIBLE = 0xd0,
YAHOO_SERVICE_Y7_PHOTO_SHARING = 0xd2,
YAHOO_SERVICE_Y7_CONTACT_DETAILS = 0xd3,/* YMSG13 */
- YAHOO_SERVICE_Y7_CHAT_SESSION = 0xd4,
+ YAHOO_SERVICE_Y7_CHAT_SESSION = 0xd4,
YAHOO_SERVICE_Y7_AUTHORIZATION = 0xd6, /* YMSG13 */
YAHOO_SERVICE_Y7_FILETRANSFER = 0xdc, /* YMSG13 */
YAHOO_SERVICE_Y7_FILETRANSFERINFO, /* YMSG13 */
{YAHOO_SERVICE_VOICECHAT, "Voice Chat"},
{YAHOO_SERVICE_NOTIFY, "Notify"},
{YAHOO_SERVICE_VERIFY, "Verify"},
- {YAHOO_SERVICE_P2PFILEXFER, "P2P File Transfer"},
+ {YAHOO_SERVICE_P2PFILEXFER, "P2P File Transfer"},
{YAHOO_SERVICE_PEERTOPEER, "Peer To Peer"},
{YAHOO_SERVICE_WEBCAM, "WebCam"},
{YAHOO_SERVICE_AUTHRESP, "Authentication Response"},
/* Not a Yahoo Messenger packet. */
return FALSE;
}
-
+
tcp_dissect_pdus(tvb, pinfo, tree, ymsg_desegment, 8, get_ymsg_pdu_len,
dissect_ymsg_pdu);
return TRUE;
}
if (tree) {
- ti = proto_tree_add_item(tree, proto_ymsg, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_ymsg, tvb, offset, -1, ENC_NA);
ymsg_tree = proto_item_add_subtree(ti, ett_ymsg);
offset += 4; /* skip the YMSG string */
/* Each entry consists of:
<key string> <delimiter> <value string> <delimiter>
*/
-
+
/* Parse and show each line of the contents */
for (;;)
{
proto_item *ti_2;
proto_tree *content_line_tree;
-
+
/* Don't continue unless there is room for another whole item.
(including 2 2-byte delimiters */
if (offset >= (headersize+content_len-4))
{
break;
}
-
+
/* Get the length of the key */
keylen = get_content_item_length(tvb, offset);
/* Extract the key */
}
if (tree) {
ti = proto_tree_add_item(tree, proto_zebra, tvb, offset, -1,
- FALSE);
+ ENC_NA);
zebra_tree = proto_item_add_subtree(ti, ett_zebra);
ti = proto_tree_add_boolean(zebra_tree, hf_zebra_request,
tvb, offset, 0, request);
giop_version_major, giop_version_minor);
if (tree)
{
- ti = proto_tree_add_item (tree, proto_ziop, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_ziop, tvb, 0, -1, ENC_NA);
ziop_tree = proto_item_add_subtree (ti, ett_ziop);
proto_tree_add_text (ziop_tree, tvb, 4, 2,
"Version %u.%u not supported",
gboolean little_endian;
emem_strbuf_t *flags_strbuf = ep_strbuf_new_label("none");
- ti = proto_tree_add_item (tree, proto_ziop, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item (tree, proto_ziop, tvb, 0, -1, ENC_NA);
ziop_tree = proto_item_add_subtree (ti, ett_ziop);
proto_tree_add_item(ziop_tree, hf_ziop_magic, tvb, offset, 4, ENC_ASCII|ENC_NA);
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
proto_item *ti, *anItem;
proto_tree *ams_tree = NULL, *ams_adstree, *ams_statetree;
gint offset = 0;
- guint ams_length = tvb_reported_length(tvb);
+ guint ams_length = tvb_reported_length(tvb);
guint16 stateflags = 0;
guint16 cmdId = 0;
-
+
char szText[200];
int nMax = sizeof(szText)-1;
if (tree)
{
- ti = proto_tree_add_item(tree, proto_ams, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_ams, tvb, 0, -1, ENC_NA);
ams_tree = proto_item_add_subtree(ti, ett_ams);
-
+
NetIdFormater(tvb, offset, szText, nMax);
proto_tree_add_string(ams_tree, hf_ams_targetnetid, tvb, offset, AmsNetId_Len, szText);
offset += AmsNetId_Len;
{
/* Request */
switch ( cmdId )
- {
+ {
case ADSSRVID_READ:
{
col_append_str(pinfo->cinfo, COL_INFO, "ADS Read Request");
{
/*guint32 cbLength;
guint32 nStamps;*/
-
+
anItem = proto_tree_add_item(ams_tree, hf_ams_adsdnrequest, tvb, offset, ams_length-offset, ENC_NA);
if( ams_length-offset >= TAdsDeviceNotificationReq_Len )
{
if( tree )
{
/* Create the mailbox sub tree */
- anItem = proto_tree_add_item(tree, proto_ecat_mailbox, tvb, 0, ETHERCAT_MBOX_HEADER_LEN+hdr.Length, TRUE);
+ anItem = proto_tree_add_item(tree, proto_ecat_mailbox, tvb, 0, ETHERCAT_MBOX_HEADER_LEN+hdr.Length, ENC_NA);
ecat_mailbox_tree = proto_item_add_subtree(anItem, ett_ecat_mailbox);
/* Create a mailbox header subtree */
{
guint16 flags;
- ti = proto_tree_add_item(tree, proto_esl, tvb, 0, SIZEOF_ESLHEADER, TRUE);
+ ti = proto_tree_add_item(tree, proto_esl, tvb, 0, SIZEOF_ESLHEADER, ENC_NA);
esl_header_tree = proto_item_add_subtree(ti, ett_esl);
offset+=6;
if( tree )
{
/* Create the EtherCAT datagram(s) subtree */
- ti = proto_tree_add_item(tree, proto_ecat_datagram, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_ecat_datagram, tvb, 0, -1, ENC_NA);
ecat_datagrams_tree = proto_item_add_subtree(ti, ett_ecat);
proto_item_append_text(ti,": %s", szText);
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
if (tree)
{
- ti = proto_tree_add_item(tree, proto_ethercat_frame, tvb, offset, EtherCATFrameParserHDR_Len, TRUE);
+ ti = proto_tree_add_item(tree, proto_ethercat_frame, tvb, offset, EtherCATFrameParserHDR_Len, ENC_NA);
ethercat_frame_tree = proto_item_add_subtree(ti, ett_ethercat_frame);
proto_tree_add_item(ethercat_frame_tree, hf_ethercat_frame_length, tvb, offset, EtherCATFrameParserHDR_Len, ENC_LITTLE_ENDIAN);
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
int nMax = sizeof(szText)-1;
guint ioraw_length = tvb_reported_length(tvb);
-
+
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IO-RAW");
col_clear(pinfo->cinfo, COL_INFO);
-
+
IoRawSummaryFormater(szText, nMax);
col_append_str(pinfo->cinfo, COL_INFO, szText);
- if (tree)
- {
- ti = proto_tree_add_item(tree, proto_ioraw, tvb, 0, -1, TRUE);
+ if (tree)
+ {
+ ti = proto_tree_add_item(tree, proto_ioraw, tvb, 0, -1, ENC_NA);
ioraw_tree = proto_item_add_subtree(ti, ett_ioraw);
proto_item_append_text(ti,": %s",szText);
offset+=IoRawParserHDR_Len;
proto_tree_add_item(ioraw_tree, hf_ioraw_data, tvb, offset, ioraw_length - offset, ENC_NA);
- }
+ }
}
void proto_register_ioraw(void)
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
tvb_get_guint8(tvb, nvOffset+2),
tvb_get_guint8(tvb, nvOffset+3),
tvb_get_guint8(tvb, nvOffset+4),
- tvb_get_guint8(tvb, nvOffset+5));
+ tvb_get_guint8(tvb, nvOffset+5));
}
static void NvVarHeaderFormater(tvbuff_t *tvb, gint offset, char *szText, int nMax)
-{
+{
g_snprintf ( szText, nMax, "Variable - Id = %d, Length = %d",
tvb_get_letohs(tvb, offset),
tvb_get_letohs(tvb, offset+4));
int nMax = sizeof(szText)-1;
gint i;
-
+
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TC-NV");
col_clear(pinfo->cinfo, COL_INFO);
-
+
NvSummaryFormater(tvb, offset, szText, nMax);
col_append_str(pinfo->cinfo, COL_INFO, szText);
- if (tree)
+ if (tree)
{
guint16 nv_count;
- ti = proto_tree_add_item(tree, proto_nv, tvb, 0, -1, TRUE);
+ ti = proto_tree_add_item(tree, proto_nv, tvb, 0, -1, ENC_NA);
nv_tree = proto_item_add_subtree(ti, ett_nv);
proto_item_append_text(ti,": %s",szText);
offset+=sizeof(guint16);
proto_tree_add_item(nv_var_tree, hf_nv_data, tvb, offset, var_length, ENC_NA);
- offset+=var_length;
+ offset+=var_length;
}
- }
+ }
}
void proto_register_nv(void)
{
dissector_handle_t nv_handle;
- nv_handle = create_dissector_handle(dissect_nv, proto_nv);
+ nv_handle = create_dissector_handle(dissect_nv, proto_nv);
dissector_add_uint("ecatf.type", 4, nv_handle);
}
}
if (!is_msgresp_add) {
- ti = proto_tree_add_item(tree, proto_gryphon, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_gryphon, tvb, 0, -1, ENC_NA);
gryphon_tree = proto_item_add_subtree(ti, ett_gryphon);
} else
gryphon_tree = tree;
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
if (root)
{
/* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(root, proto_ircomm, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_ircomm, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_ircomm);
proto_tree* ctrl_tree;
if (root)
{
/* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(root, proto_ircomm, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_ircomm, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_ircomm);
call_dissector(data_handle, tvb, pinfo, tree);
if (root)
{
/* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(root, proto_ttp, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_ttp, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_ttp);
if (data)
if (root)
{
/* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(root, proto_iap, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_iap, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_iap);
proto_tree* ctl_tree;
if (root)
{
/* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(root, proto_iap, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_iap, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_iap);
proto_tree* ctl_tree;
if (root)
{
/* create display subtree for the protocol */
- proto_item* ti = proto_tree_add_item(root, proto_irlmp, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_irlmp, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_irlmp);
proto_tree* dst_tree;
if (root)
{
- ti = proto_tree_add_item(root, proto_irlmp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(root, proto_irlmp, tvb, offset, -1, ENC_NA);
lmp_tree = proto_item_add_subtree(ti, ett_irlmp);
}
if (root)
{
- proto_item* ti = proto_tree_add_item(root, proto_log, tvb, 0, -1, FALSE);
+ proto_item* ti = proto_tree_add_item(root, proto_log, tvb, 0, -1, ENC_NA);
proto_tree* tree = proto_item_add_subtree(ti, ett_log);
if (pinfo->pseudo_header->irda.pkttype == IRDA_MISSED_MSG)
proto_item* addr_item;
/* create display subtree for the protocol */
- ti = proto_tree_add_item(root, proto_irlap, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(root, proto_irlap, tvb, 0, -1, ENC_NA);
tree = proto_item_add_subtree(ti, ett_irlap);
/* create subtree for the address field */
{ /* we are being asked for details */
- m2m_item = proto_tree_add_item(tree, proto_m2m, tvb, 0, -1, FALSE);
+ m2m_item = proto_tree_add_item(tree, proto_m2m, tvb, 0, -1, ENC_NA);
m2m_tree = proto_item_add_subtree(m2m_item, ett_m2m);
/* get the tvb reported length */
length = tvb_reported_length(tvb);
**
** Copyright (C) 2006-2007 ascolab GmbH. All Rights Reserved.
** Web: http://www.ascolab.com
-**
+**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or (at your option) any later version.
-**
+**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
+**
** Project: OpcUa Wireshark Plugin
**
** Description: OpcUa Protocol Decoder.
"OpcUa", /* short name */
"opcua" /* abbrev */
);
-
+
registerTransportLayerTypes(proto_opcua);
registerSecurityLayerTypes(proto_opcua);
registerApplicationLayerTypes(proto_opcua);
registerServiceTypes();
registerFieldTypes(proto_opcua);
- proto_register_subtree_array(ett, array_length(ett));
+ proto_register_subtree_array(ett, array_length(ett));
range_convert_str(&global_tcp_ports_opcua, ep_strdup_printf("%u", OPCUA_PORT), 65535);
{
msgtype = MSG_INVALID;
}
-
+
/* Clear out stuff in the info column */
col_set_str(pinfo->cinfo, COL_INFO, g_szMessageTypes[msgtype]);
proto_item *ti = NULL;
proto_tree *transport_tree = NULL;
- ti = proto_tree_add_item(tree, proto_opcua, tvb, 0, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_opcua, tvb, 0, -1, ENC_NA);
transport_tree = proto_item_add_subtree(ti, ett_opcua_transport);
/* call the transport message dissector */
{
opcua_handle = create_dissector_handle(dissect_opcua, proto_opcua);
opcua_initialized = TRUE;
- }
- else
- {
+ }
+ else
+ {
/* clean up ports and their lists */
if (tcp_ports_opcua != NULL)
{
/* packet-pn-mrp.c
- * Routines for PN-MRP (PROFINET Media Redundancy Protocol)
+ * Routines for PN-MRP (PROFINET Media Redundancy Protocol)
* packet dissection.
*
* $Id$
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
- *
+ *
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
static int
-dissect_PNMRP_Common(tvbuff_t *tvb, int offset,
+dissect_PNMRP_Common(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item)
{
guint16 sequence_id;
static int
-dissect_PNMRP_LinkUp(tvbuff_t *tvb, int offset,
+dissect_PNMRP_LinkUp(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item)
{
guint8 mac[6];
static int
-dissect_PNMRP_LinkDown(tvbuff_t *tvb, int offset,
+dissect_PNMRP_LinkDown(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item)
{
guint8 mac[6];
static int
-dissect_PNMRP_Test(tvbuff_t *tvb, int offset,
+dissect_PNMRP_Test(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item)
{
guint16 prio;
static int
-dissect_PNMRP_TopologyChange(tvbuff_t *tvb, int offset,
+dissect_PNMRP_TopologyChange(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item)
{
guint16 prio;
static int
-dissect_PNMRP_Option(tvbuff_t *tvb, int offset,
+dissect_PNMRP_Option(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item, guint8 length)
{
guint32 oui;
/* OUI (organizational unique id) */
offset = dissect_pn_oid(tvb, offset, pinfo,tree, hf_pn_mrp_oui, &oui);
length -= 3;
-
+
switch (oui)
{
case OUI_SIEMENS:
static int
-dissect_PNMRP_PDU(tvbuff_t *tvb, int offset,
+dissect_PNMRP_PDU(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item)
{
guint16 version;
{
proto_item *ti = NULL;
proto_tree *mrp_tree = NULL;
-
+
guint32 offset = 0;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PN-MRP");
-
+
/* Clear the information column on summary display */
col_clear(pinfo->cinfo, COL_INFO);
- if (tree)
+ if (tree)
{
- ti = proto_tree_add_item(tree, proto_pn_mrp, tvb, offset, -1, FALSE);
+ ti = proto_tree_add_item(tree, proto_pn_mrp, tvb, offset, -1, ENC_NA);
mrp_tree = proto_item_add_subtree(ti, ett_pn_mrp);
}
dissect_PNMRP_PDU(tvb, offset, pinfo, mrp_tree, ti);
-}
+}
void
static int hf_pn_rt_frag_data = -1;
-/*
+/*
* Define the trees for pn-rt
* We need one tree for pn-rt itself and one for the pn-rt data status subtree
*/
static int ett_pn_rt_frag = -1;
static int ett_pn_rt_frag_status = -1;
-/*
- * Here are the global variables associated with
+/*
+ * Here are the global variables associated with
* the various user definable characteristics of the dissection
*/
/* Place summary in proto tree */
proto_item *sub_item;
proto_tree *sub_tree;
- sub_item = proto_tree_add_uint_format(tree, hf_pn_rt_data_status,
+ sub_item = proto_tree_add_uint_format(tree, hf_pn_rt_data_status,
tvb, offset, 1, u8DataStatus,
- "DataStatus: 0x%02x (Frame: %s and %s, Provider: %s and %s)",
- u8DataStatus,
+ "DataStatus: 0x%02x (Frame: %s and %s, Provider: %s and %s)",
+ u8DataStatus,
(u8DataStatus & 0x04) ? "Valid" : "Invalid",
(u8DataStatus & 0x01) ? "Primary" : "Backup",
(u8DataStatus & 0x20) ? "Ok" : "Problem",
/* XXX - should this use u8FragDataLength? */
- proto_tree_add_none_format(sub_tree, hf_pn_rt_frag_data, tvb, offset, tvb_length(tvb) - offset,
+ proto_tree_add_none_format(sub_tree, hf_pn_rt_frag_data, tvb, offset, tvb_length(tvb) - offset,
"FragData: %d bytes", tvb_length(tvb) - offset);
/* note: the actual defragmentation implementation is still missing here */
/* Initialize variables */
pn_rt_tree = NULL;
ti = NULL;
-
+
/*
* Set the columns now, so that they'll be set correctly if we throw
* an exception. We can set them (or append things) later again ....
*/
-
+
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PN-RT");
col_set_str(pinfo->cinfo, COL_INFO, "PROFINET Real-Time");
ti = proto_tree_add_protocol_format(tree, proto_pn_rt, tvb, 0, pdu_len,
"PROFINET %s, %s", pszProtSummary, szFieldSummary);
} else {
- ti = proto_tree_add_item(tree, proto_pn_rt, tvb, 0, pdu_len, ENC_BIG_ENDIAN);
+ ti = proto_tree_add_item(tree, proto_pn_rt, tvb, 0, pdu_len, ENC_NA);
}
pn_rt_tree = proto_item_add_subtree(ti, ett_pn_rt);
/* add cycle counter */
proto_tree_add_uint_format(pn_rt_tree, hf_pn_rt_cycle_counter, tvb,
pdu_len - 4, 2, u16CycleCounter, "CycleCounter: %u", u16CycleCounter);
-
+
/* add data status subtree */
dissect_DataStatus(tvb, pdu_len - 2, tree, u8DataStatus);
/* add transfer status */
if (u8TransferStatus) {
proto_tree_add_uint_format(pn_rt_tree, hf_pn_rt_transfer_status, tvb,
- pdu_len - 1, 1, u8TransferStatus,
+ pdu_len - 1, 1, u8TransferStatus,
"TransferStatus: 0x%02x (ignore this frame)", u8TransferStatus);
} else {
proto_tree_add_uint_format(pn_rt_tree, hf_pn_rt_transfer_status, tvb,
- pdu_len - 1, 1, u8TransferStatus,
+ pdu_len - 1, 1, u8TransferStatus,
"TransferStatus: 0x%02x (OK)", u8TransferStatus);
}
}
}
-
+
/* update column info now */
col_add_str(pinfo->cinfo, COL_INFO, szFieldSummary);
col_set_str(pinfo->cinfo, COL_PROTOCOL, pszProtShort);
/* Register all the bits needed by the filtering engine */
-void
+void
proto_register_pn_rt(void)
{
static hf_register_info hf[] = {
{ &hf_pn_rt_frame_id, {
"FrameID", "pn_rt.frame_id", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_cycle_counter, {
+ { &hf_pn_rt_cycle_counter, {
"CycleCounter", "pn_rt.cycle_counter", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_data_status, {
+ { &hf_pn_rt_data_status, {
"DataStatus", "pn_rt.ds", FT_UINT8, BASE_HEX, 0, 0x0, NULL, HFILL }},
- { &hf_pn_rt_data_status_ignore, {
+ { &hf_pn_rt_data_status_ignore, {
"Ignore (1:Ignore/0:Evaluate)", "pn_rt.ds_ignore", FT_UINT8, BASE_HEX, 0, 0x80, NULL, HFILL }},
- { &hf_pn_rt_data_status_subframe_sender_mode, {
+ { &hf_pn_rt_data_status_subframe_sender_mode, {
"SubFrameSenderMode", "pn_rt.ds_subframe_sender_mode", FT_UINT8, BASE_HEX, 0, 0x40, NULL, HFILL }},
- { &hf_pn_rt_data_status_ok, {
+ { &hf_pn_rt_data_status_ok, {
"StationProblemIndicator (1:Ok/0:Problem)", "pn_rt.ds_ok", FT_UINT8, BASE_HEX, 0, 0x20, NULL, HFILL }},
- { &hf_pn_rt_data_status_operate, {
+ { &hf_pn_rt_data_status_operate, {
"ProviderState (1:Run/0:Stop)", "pn_rt.ds_operate", FT_UINT8, BASE_HEX, 0, 0x10, NULL, HFILL }},
- { &hf_pn_rt_data_status_res3, {
+ { &hf_pn_rt_data_status_res3, {
"Reserved (should be zero)", "pn_rt.ds_res3", FT_UINT8, BASE_HEX, 0, 0x08, NULL, HFILL }},
- { &hf_pn_rt_data_status_valid, {
+ { &hf_pn_rt_data_status_valid, {
"DataValid (1:Valid/0:Invalid)", "pn_rt.ds_valid", FT_UINT8, BASE_HEX, 0, 0x04, NULL, HFILL }},
- { &hf_pn_rt_data_status_res1, {
+ { &hf_pn_rt_data_status_res1, {
"Reserved (should be zero)", "pn_rt.ds_res1", FT_UINT8, BASE_HEX, 0, 0x02, NULL, HFILL }},
- { &hf_pn_rt_data_status_primary, {
+ { &hf_pn_rt_data_status_primary, {
"State (1:Primary/0:Backup)", "pn_rt.ds_primary", FT_UINT8, BASE_HEX, 0, 0x01, NULL, HFILL }},
{ &hf_pn_rt_transfer_status,
{ "TransferStatus", "pn_rt.transfer_status", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_sf, {
+ { &hf_pn_rt_sf, {
"SubFrame", "pn_rt.sf", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_sf_crc16, {
+ { &hf_pn_rt_sf_crc16, {
"CRC16", "pn_rt.sf.crc16", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_sf_position, {
+ { &hf_pn_rt_sf_position, {
"Position", "pn_rt.sf.position", FT_UINT8, BASE_DEC, NULL, 0x7F, NULL, HFILL }},
- { &hf_pn_rt_sf_position_control, {
+ { &hf_pn_rt_sf_position_control, {
"Control", "pn_rt.sf.position_control", FT_UINT8, BASE_DEC, VALS(pn_rt_position_control), 0x80, NULL, HFILL }},
- { &hf_pn_rt_sf_data_length, {
+ { &hf_pn_rt_sf_data_length, {
"DataLength", "pn_rt.sf.data_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_sf_cycle_counter, {
+ { &hf_pn_rt_sf_cycle_counter, {
"CycleCounter", "pn_rt.sf.cycle_counter", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_frag, {
+ { &hf_pn_rt_frag, {
"PROFINET Real-Time Fragment", "pn_rt.frag", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_frag_data_length, {
+ { &hf_pn_rt_frag_data_length, {
"FragDataLength", "pn_rt.frag_data_length", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_frag_status, {
+ { &hf_pn_rt_frag_status, {
"FragStatus", "pn_rt.frag_status", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }},
- { &hf_pn_rt_frag_status_more_follows, {
+ { &hf_pn_rt_frag_status_more_follows, {
"MoreFollows", "pn_rt.frag_status.more_follows", FT_UINT8, BASE_HEX, VALS(pn_rt_frag_status_more_follows), 0x80, NULL, HFILL }},
- { &hf_pn_rt_frag_status_error, {
+ { &hf_pn_rt_frag_status_error, {
"Error", "pn_rt.frag_status.error", FT_UINT8, BASE_HEX, VALS(pn_rt_frag_status_error), 0x40, NULL, HFILL }},
- { &hf_pn_rt_frag_status_fragment_number, {
+ { &hf_pn_rt_frag_status_fragment_number, {
"FragmentNumber (zero based)", "pn_rt.frag_status.fragment_number", FT_UINT8, BASE_DEC, NULL, 0x3F, NULL, HFILL }},
- { &hf_pn_rt_frag_data, {
+ { &hf_pn_rt_frag_data, {
"FragData", "pn_rt.frag_data", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL }},
};
static gint *ett[] = {
&ett_pn_rt_frag,
&ett_pn_rt_frag_status
};
- module_t *pn_rt_module;
+ module_t *pn_rt_module;
proto_pn_rt = proto_register_protocol("PROFINET Real-Time Protocol",
"PN-RT", "pn_rt");
dissector_add_uint("udp.port", 0x8892, pn_rt_handle);
heur_dissector_add("pn_rt", dissect_CSF_SDU_heur, proto_pn_rt);
- heur_dissector_add("pn_rt", dissect_FRAG_PDU_heur, proto_pn_rt);
+ heur_dissector_add("pn_rt", dissect_FRAG_PDU_heur, proto_pn_rt);
}
http_info_value_t* msgdata = ep_alloc0(sizeof(http_info_value_t));
tvbparse_elem_t* reqresp;
tpg_parser_data_t* tpg;
- proto_item* pi = proto_tree_add_item(tree,proto_http,tvb,0,-1,FALSE);
+ proto_item* pi = proto_tree_add_item(tree,proto_http,tvb,0,-1,ENC_NA);
proto_tree* pt = proto_item_add_subtree(pi,ett_http);
tpg = tpg_start(pt,tvb,0,-1,http_tpg_data.wanted_http_sp, msgdata);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "UNISTIM");
/* Clear out stuff in the info column */
col_clear(pinfo->cinfo, COL_INFO);
- ti = proto_tree_add_item(tree,proto_unistim,tvb,offset,-1,FALSE);
+ ti = proto_tree_add_item(tree,proto_unistim,tvb,offset,-1,ENC_NA);
overall_unistim_tree = proto_item_add_subtree(ti,ett_unistim);
ti1=proto_tree_add_text(overall_unistim_tree,tvb,offset,5,"Reliable UDP");
rudpm_tree=proto_item_add_subtree(ti1,ett_unistim);
{
packet_item = proto_tree_add_item(
tree, proto_wimaxasncp,
- tvb, 0, MIN(WIMAXASNCP_HEADER_LENGTH_END, tvb_length(tvb)), FALSE);
+ tvb, 0, MIN(WIMAXASNCP_HEADER_LENGTH_END, tvb_length(tvb)), ENC_NA);
wimaxasncp_tree = proto_item_add_subtree(
packet_item, ett_wimaxasncp);
git.samba.org / obnox / wireshark / wip.git / commitdiff