#define BITTORRENT_HEADER_LENGTH 4
-/*
+/*
* Azureus messages are specified by name so these are made up numbers
* for internal identification only.
*
- * Standard BT message types are a single byte, so these won't clash
+ * Standard BT message types are a single byte, so these won't clash
*/
#define AZUREUS_MESSAGE_HANDSHAKE 256
#define AZUREUS_MESSAGE_KEEP_ALIVE 257
}
if (treeadd==2) {
proto_item_append_text(ti, " Value: %s", format_text(ep_tvb_memdup(tvb, offset+used, stringlen), stringlen));
- }
+ }
}
return used+stringlen;
}
proto_tree_add_int(tree, hf_bittorrent_bint, tvb, offset, used, ival);
if (treeadd==2) {
proto_item_append_text(ti, " Value: %d", ival);
- }
+ }
}
return used;
}
return op2len;
}
-
+
if (dtree) {
ti = proto_tree_add_item(dtree, hf_bittorrent_bdict_entry, tvb, offset+used, op1len+op2len, FALSE);
itree = proto_item_add_subtree(ti, ett_bittorrent_bdict_entry);
dissect_bencoding_str(tvb, pinfo, offset+used, length, itree, ti, 1);
dissect_bencoding_rec(tvb, pinfo, offset+used+op1len, length-op1len, itree, level+1, ti, 2);
}
-
+
used += op1len+op2len;
length -= op1len+op2len;
}
if (op=='e') {
return used+1;
}
-
+
oplen = dissect_bencoding_rec(tvb, pinfo, offset+used, length, itree, level+1, ti, 0);
if (oplen<1) return oplen;
{
dissect_bencoding_rec(tvb, pinfo, offset, length, tree, 0, NULL, 0);
}
-
+
static void dissect_bittorrent_message (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
int offset = 0;
type = tvb_get_guint8(tvb, offset + BITTORRENT_HEADER_LENGTH);
if (type==BITTORRENT_MESSAGE_CHOKE && length>4) {
- /*
+ /*
* Choke messages have no payload, so this is likely an Azureus
* Messaging Protocol packet
*/
msgtype = match_strval(type, azureus_messages);
} */
if (msgtype == NULL) {
- proto_tree_add_text(tree, tvb, offset, -1, "Continuation data");
+ proto_tree_add_text(tree, tvb, offset, -1, "Continuation data");
if (check_col(pinfo->cinfo, COL_INFO)) {
col_set_str(pinfo->cinfo, COL_INFO, "Continuation data");
}
break;
case BITTORRENT_MESSAGE_BITFIELD:
- proto_tree_add_item(mtree, hf_bittorrent_bitfield_data, tvb, offset, length, FALSE);
+ proto_tree_add_item(mtree, hf_bittorrent_bitfield_data, tvb, offset, length, FALSE);
proto_item_append_text(ti, ", Len:0x%x", length);
if (check_col(pinfo->cinfo, COL_INFO)) {
col_append_fstr(pinfo->cinfo, COL_INFO, ", Len:0x%x", length);
int offset = 0;
int i;
char *version;
-
+
if (check_col(pinfo->cinfo, COL_INFO)) {
col_set_str(pinfo->cinfo, COL_INFO, "Handshake");
}
-
+
proto_tree_add_item(tree, hf_bittorrent_prot_name_len, tvb, offset, 1, FALSE); offset+=1;
proto_tree_add_item(tree, hf_bittorrent_prot_name, tvb, offset, 19, FALSE); offset += 19;
proto_tree_add_item(tree, hf_bittorrent_reserved, tvb, offset, 8, FALSE); offset += 8;
-
+
proto_tree_add_item(tree, hf_bittorrent_sha1_hash, tvb, offset, 20, FALSE);
offset += 20;
/* The version number is 4 numeric characters for the
client ids beginning with '-' and 3 characters for the
rest. */
- version = tvb_get_string(tvb, offset + strlen(peer_id[i].id),
+ version = tvb_get_ephemeral_string(tvb, offset + strlen(peer_id[i].id),
(peer_id[i].id[0] == '-') ? 4 : 3);
proto_tree_add_text(tree, tvb, offset, 20, "Client is %s v%s",
peer_id[i].name,
format_text((guchar*)version, (peer_id[i].id[0] == '-') ? 4 : 3));
- g_free(version);
break;
}
}
static void dissect_bittorrent_tcp_pdu (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *ti;
-
+
if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
col_set_str(pinfo->cinfo, COL_PROTOCOL, "BitTorrent");
}
-
+
if (check_col(pinfo->cinfo, COL_INFO)) {
col_set_str(pinfo->cinfo, COL_INFO, "BitTorrent ");
}
-
- ti = proto_tree_add_item (tree, proto_bittorrent, tvb, 0, -1, FALSE);
+
+ ti = proto_tree_add_item (tree, proto_bittorrent, tvb, 0, -1, FALSE);
tree = proto_item_add_subtree(ti, ett_bittorrent);
-
+
if (tvb_get_guint8(tvb, 0) == 19 &&
tvb_memeql(tvb, 1, "BitTorrent protocol", 19) == 0) {
dissect_bittorrent_welcome(tvb, pinfo, tree);
proto_register_bittorrent(void)
{
static hf_register_info hf[] = {
- { &hf_bittorrent_field_length,
+ { &hf_bittorrent_field_length,
{ "Field Length", "bittorrent.length", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }
},
{ &hf_bittorrent_prot_name_len,
{ &hf_bittorrent_peer_id,
{ "Peer ID", "bittorrent.peer_id", FT_BYTES, BASE_DEC, NULL, 0x0, "", HFILL }
},
- { &hf_bittorrent_msg,
+ { &hf_bittorrent_msg,
{ "Message", "bittorrent.msg", FT_NONE, BASE_NONE, NULL, 0x0, "", HFILL }
},
{ &hf_bittorrent_msg_len,
{ "Message Length", "bittorrent.msg.length", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }
- },
+ },
{ &hf_bittorrent_msg_type,
{ "Message Type", "bittorrent.msg.type", FT_UINT8, BASE_DEC, VALS(bittorrent_messages), 0x0, "", HFILL }
},
{ &hf_bittorrent_piece_begin,
{ "Begin offset of piece", "bittorrent.piece.begin", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }
},
- { &hf_bittorrent_piece_data,
+ { &hf_bittorrent_piece_data,
{ "Data in a piece", "bittorrent.piece.data", FT_BYTES, BASE_HEX, NULL, 0x0, "", HFILL }
},
{ &hf_bittorrent_piece_length,
}
} else {
/*
- * "tvb_get_string()" throws an exception if the entire string
+ * "tvb_get_ephemeral_string()" throws an exception if the entire string
* isn't in the tvbuff. If the length is bogus, this should
* keep us from trying to allocate an immensely large buffer.
* (It won't help if the length is *valid* but immensely large,
* if we had an immensely large tvbuff....)
*/
tvb_ensure_bytes_exist(tvb, offset, buffer_len);
- s = tvb_get_string(tvb, offset, buffer_len);
+ s = tvb_get_ephemeral_string(tvb, offset, buffer_len);
if (tree && buffer_len)
proto_tree_add_item(string_tree, hfindex, tvb, offset,
buffer_len, drep[0] & 0x10);
if (data)
*data = s;
- else
- g_free(s);
offset += buffer_len;
/* This function is aimed for PIDL useage and dissects a UNIQUE pointer to
* unicode string.
*/
-int
+int
PIDL_dissect_cvstring(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 *drep, int chsize, int hfindex, guint32 param)
{
dcerpc_info *di;
}
} else {
/*
- * "tvb_get_string()" throws an exception if the entire string
+ * "tvb_get_ephemeral_string()" throws an exception if the entire string
* isn't in the tvbuff. If the length is bogus, this should
* keep us from trying to allocate an immensely large buffer.
* (It won't help if the length is *valid* but immensely large,
* if we had an immensely large tvbuff....)
*/
tvb_ensure_bytes_exist(tvb, offset, buffer_len);
- s = tvb_get_string(tvb, offset, buffer_len);
+ s = tvb_get_ephemeral_string(tvb, offset, buffer_len);
if (tree && buffer_len)
proto_tree_add_item(string_tree, hfindex, tvb, offset,
buffer_len, drep[0] & 0x10);
if (data)
*data = s;
- else
- g_free(s);
offset += buffer_len;
return offset;
}
+
/* Dissect an varying string of chars.
This corresponds to IDL of the form '[string] char *foo'.
break;
case STRUCT_ID_STRING:
- id_string = tvb_get_string (tvb, offset, (gint) dmp_struct_length);
+ id_string = tvb_get_ephemeral_string (tvb, offset, (gint) dmp_struct_length);
g_snprintf (dmp.struct_id, MAX_STRUCT_ID_LEN, "%s", id_string);
- g_free (id_string);
tf = proto_tree_add_item (body_tree, hf_message_bodyid_string, tvb,
offset, dmp_struct_length, FALSE);
break;
case STRUCT_ID_ZSTRING:
- id_string = tvb_get_stringz (tvb, offset, &length);
+ id_string = tvb_get_ephemeral_stringz (tvb, offset, &length);
g_snprintf (dmp.struct_id, MAX_STRUCT_ID_LEN, "%s", id_string);
- g_free (id_string);
tf = proto_tree_add_item (body_tree, hf_message_bodyid_zstring, tvb,
offset, length, FALSE);
break;
if (dmp.body_format == FREE_TEXT_SUBJECT) {
len = tvb_strsize (tvb, offset);
if (dmp_subject_as_id) {
- subject = tvb_get_string (tvb, offset, len);
+ subject = tvb_get_ephemeral_string (tvb, offset, len);
g_snprintf (dmp.struct_id, MAX_STRUCT_ID_LEN, "%s", subject);
- g_free (subject);
}
proto_tree_add_item (message_tree, hf_message_subject, tvb, offset,
len, FALSE);
guint32 wstring_padding = 0;
wstring_length = tvb_get_letohl(tvb, offset);
- wstring_data = tvb_fake_unicode(tvb, offset+4, wstring_length, 1);
+ wstring_data = tvb_get_ephemeral_faked_unicode(tvb, offset+4, wstring_length, 1);
wstring_size = wstring_length;
if (wstring_size%4) {
wstring_padding = (4-wstring_size%4);
proto_tree_add_string(dtpt_wstring_tree, hf_dtpt_wstring_data,
tvb, offset+4, wstring_length, wstring_data);
if (wstring_padding)
- proto_tree_add_text(dtpt_wstring_tree, tvb,
+ proto_tree_add_text(dtpt_wstring_tree, tvb,
offset+4+wstring_length,wstring_padding, "Padding");
}
}
- if (wstring_data != NULL) {
- free(wstring_data);
- wstring_data = NULL;
- }
offset += 4+wstring_size;
return offset;
}
return offset;
}
-static int
+static int
dissect_dtpt_conversation(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint offset = 0;
guint32 offset2;
offset2 = offset + 24*num_addrs;
-
+
for (i=0;i<num_addrs;i++,offset+=24) {
proto_item *dtpt_addr1_item = NULL;
proto_tree *dtpt_addr1_tree = NULL;
}
offset2_start = offset2;
-
+
offset2 = dissect_dtpt_sockaddr(tvb, offset2, dtpt_addr2_tree, hf_dtpt_cs_addr_local, SOCKADDR_WITH_LEN);
offset2 = dissect_dtpt_sockaddr(tvb, offset2, dtpt_addr2_tree, hf_dtpt_cs_addr_remote, SOCKADDR_WITH_LEN);
if (dtpt_addr2_item)
- proto_item_set_len(dtpt_addr2_item,
+ proto_item_set_len(dtpt_addr2_item,
offset2 - offset2_start);
}
offset = offset2;
}
}
}
-
+
offset += 4+blob_rawsize;
if (dtpt_item)
* 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.
fc_ct_preamble cthdr;
/* Make entries in Protocol column and Info column on summary display */
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC_CT");
-
+
/*
cthdr.revision = tvb_get_guint8 (tvb, offset++);
cthdr.in_id = tvb_get_ntoh24 (tvb, offset);
offset += 3;
-
+
cthdr.gstype = tvb_get_guint8 (tvb, offset++);
cthdr.options = tvb_get_guint8 (tvb, offset++);
*/
tvb_memcpy (tvb, (guint8 *)&cthdr, offset, FCCT_PRMBL_SIZE);
cthdr.revision = tvb_get_guint8 (tvb, offset++);
cthdr.in_id = tvb_get_ntoh24 (tvb, offset);
- cthdr.opcode = ntohs (cthdr.opcode);
- cthdr.maxres_size = ntohs (cthdr.maxres_size);
+ cthdr.opcode = g_ntohs (cthdr.opcode);
+ cthdr.maxres_size = g_ntohs (cthdr.maxres_size);
if (check_col (pinfo->cinfo, COL_INFO)) {
if (cthdr.opcode < FCCT_MSG_REQ_MAX) {
}
else if (cthdr.opcode == FCCT_MSG_RJT) {
col_append_fstr (pinfo->cinfo, COL_INFO, " Reject (%s)",
- val_to_str (cthdr.rjt_code, fc_ct_rjt_code_vals, "0x%x"));
+ val_to_str (cthdr.rjt_code, fc_ct_rjt_code_vals, "0x%x"));
}
else {
col_append_str (pinfo->cinfo, COL_INFO, " Reserved");
}
}
-
+
in_id = cthdr.in_id;
- in_id = htonl (in_id) >> 8;
+ in_id = g_htonl (in_id) >> 8;
/* Determine server */
server = get_gs_server (cthdr.gstype, cthdr.gssubtype);
-
+
if (tree) {
offset = 0;
ti = proto_tree_add_protocol_format (tree, proto_fcct, tvb, 0, FCCT_PRMBL_SIZE,
proto_tree_add_string (fcct_tree, hf_fcct_inid, tvb, offset, 3,
fc_to_str ((guint8 *)&in_id));
offset += 3; /* sizeof FC address */
-
+
proto_tree_add_item (fcct_tree, hf_fcct_gstype, tvb, offset++,
sizeof (guint8), 0);
proto_tree_add_item (fcct_tree, hf_fcct_gssubtype, tvb, offset,
void
proto_register_fcct(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_fcct_revision,
- {"Revision", "fcct.revision", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL}},
+ {"Revision", "fcct.revision", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL}},
{ &hf_fcct_inid,
{"IN_ID", "fcct.in_id", FT_STRING, BASE_HEX, NULL, 0x0, "", HFILL}},
{ &hf_fcct_gstype,
* 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.
flags = tvb_get_ntohl (tvb, offset);
if(parent_tree){
- item=proto_tree_add_uint(parent_tree, hfindex,
+ item=proto_tree_add_uint(parent_tree, hfindex,
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_cos_flags);
}
"t is NOT set"
};
-/* The feature routines just decode FCP's FC-4 features field
+/* The feature routines just decode FCP's FC-4 features field
* based on the flahs in offset and the type in offset+1
*/
static void
flags = tvb_get_guint8(tvb, offset);
type = tvb_get_guint8(tvb, offset+1);
if(parent_tree){
- item=proto_tree_add_uint(parent_tree, hf_fcdns_fc4features,
+ item=proto_tree_add_uint(parent_tree, hf_fcdns_fc4features,
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_fc4features);
}
proto_tree_add_item (tree, hf_fcdns_req_fc4type, tvb, offset+1, 1, 0);
}
-/* The feature routines just decode FCP's FC-4 features field
+/* The feature routines just decode FCP's FC-4 features field
*/
static void
dissect_fc4features (proto_tree *parent_tree, tvbuff_t *tvb, int offset)
flags = tvb_get_guint8(tvb, offset);
if(parent_tree){
- item=proto_tree_add_uint(parent_tree, hf_fcdns_fc4features,
+ item=proto_tree_add_uint(parent_tree, hf_fcdns_fc4features,
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_fc4features);
}
flags = tvb_get_ntohl (tvb, offset+4);
-
+
proto_tree_add_boolean(tree, hf_fcdns_fc4type_swils, tvb, offset+4, 4, flags);
if (flags&0x0010){
proto_item_append_text(item, " SW_ILS");
offset+12, 1, 0);
if (!tvb_offset_exists (tvb, 29+len))
return;
-
+
if (len) {
proto_tree_add_item (req_tree, hf_fcdns_rply_spname, tvb,
offset+13, len, 0);
}
else {
len = tvb_get_guint8 (tvb, offset);
- proto_tree_add_item (req_tree, hf_fcdns_rply_spnamelen,
+ proto_tree_add_item (req_tree, hf_fcdns_rply_spnamelen,
tvb, offset, 1, 0);
proto_tree_add_string (req_tree, hf_fcdns_rply_spname, tvb,
offset+1, len,
tvb, offset+1, 3,
fc_to_str (tvb_get_ptr (tvb, offset+1,
3)));
- proto_tree_add_string (req_tree, hf_fcdns_req_nname, tvb,
+ proto_tree_add_string (req_tree, hf_fcdns_req_nname, tvb,
offset+4, 8,
fcwwn_to_str (tvb_get_ptr (tvb, offset+4,
8)));
proto_tree_add_item (req_tree, hf_fcdns_req_spnamelen, tvb,
offset+4, 1, 0);
len = tvb_get_guint8 (tvb, offset+4);
-
+
proto_tree_add_item (req_tree, hf_fcdns_req_spname, tvb, offset+5,
len, 0);
}
len = tvb_length (tvb) - offset - 36;
offset += 36;
-
+
while (len > 0) {
dlen = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (req_tree, hf_fcdns_req_fdesclen, tvb, offset,
proto_tree_add_string (zmbr_tree, hf_fcdns_zone_mbrid, tvb,
offset+4, idlen,
"Unknown member type format");
-
+
}
}
objfmt = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (tree, hf_fcdns_sw2_objfmt, tvb, offset, 1, 0);
- proto_tree_add_string (tree, hf_fcdns_rply_ownerid, tvb, offset+1,
+ proto_tree_add_string (tree, hf_fcdns_rply_ownerid, tvb, offset+1,
3, fc_to_str (tvb_get_ptr (tvb, offset+1,
3)));
proto_tree_add_item (tree, hf_fcdns_rply_ptype, tvb, offset+4,
proto_tree_add_item (tree, hf_fcdns_num_fc4desc, tvb,
offset+129, 1, 0);
}
- offset += 388; /* FC4 desc is 260 bytes, maybe padded */
+ offset += 388; /* FC4 desc is 260 bytes, maybe padded */
}
}
}
tvb_memcpy (tvb, (guint8 *)&cthdr, offset, FCCT_PRMBL_SIZE);
cthdr.revision = tvb_get_guint8 (tvb, offset);
cthdr.in_id = tvb_get_ntoh24 (tvb, offset+1);
- cthdr.opcode = ntohs (cthdr.opcode);
+ cthdr.opcode = g_ntohs (cthdr.opcode);
opcode = cthdr.opcode;
- cthdr.maxres_size = ntohs (cthdr.maxres_size);
+ cthdr.maxres_size = g_ntohs (cthdr.maxres_size);
/* Determine the type of server the request/response is for */
if (check_col(pinfo->cinfo, COL_PROTOCOL)) {
pinfo->ptype, pinfo->oxid,
pinfo->rxid, NO_PORT2);
}
-
+
ckey.conv_idx = conversation->index;
-
+
cdata = (fcdns_conv_data_t *)g_hash_table_lookup (fcdns_req_hash,
&ckey);
if (cdata) {
/* Since we never free the memory used by an exchange, this maybe a
* case of another request using the same exchange as a previous
- * req.
+ * req.
*/
cdata->opcode = opcode;
}
else {
req_key = se_alloc (sizeof(fcdns_conv_key_t));
req_key->conv_idx = conversation->index;
-
+
cdata = se_alloc (sizeof(fcdns_conv_data_t));
cdata->opcode = opcode;
-
+
g_hash_table_insert (fcdns_req_hash, req_key, cdata);
}
if (check_col (pinfo->cinfo, COL_INFO)) {
else
failed_opcode = cdata->opcode;
}
-
+
if (check_col (pinfo->cinfo, COL_INFO)) {
if (opcode != FCCT_MSG_RJT) {
col_add_fstr (pinfo->cinfo, COL_INFO, "ACC (%s)",
"0x%x"));
}
}
-
+
if (tree) {
if ((cdata == NULL) && (opcode != FCCT_MSG_RJT)) {
/* No record of what this accept is for. Can't decode */
proto_tree_add_item (fcdns_tree, hf_fcdns_maxres_size, tvb, offset+10,
2, 0);
}
-
+
switch (opcode) {
case FCCT_MSG_RJT:
dissect_fcdns_rjt (tvb, fcdns_tree);
void
proto_register_fcdns (void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{"Class of Service Supported", "fcdns.reply.cos", FT_UINT32, BASE_HEX,
NULL, 0x0, "", HFILL}},
{ &hf_fcdns_req_cos,
- {"Requested Class of Service", "fcdns.req.class", FT_UINT32, BASE_HEX,
+ {"Requested Class of Service", "fcdns.req.class", FT_UINT32, BASE_HEX,
NULL, 0x0, "", HFILL}},
{ &hf_fcdns_cos_f,
{"F", "fcdns.cos.f", FT_BOOLEAN, 32,
{"FC-4 Types Supported", "fcdns.rply.fc4type", FT_NONE, BASE_HEX,
NULL, 0x0, "", HFILL}},
{ &hf_fcdns_req_fc4types,
- {"FC-4 Types Supported", "fcdns.req.fc4types", FT_NONE, BASE_HEX,
+ {"FC-4 Types Supported", "fcdns.req.fc4types", FT_NONE, BASE_HEX,
NULL, 0x0, "", HFILL}},
{ &hf_fcdns_fc4type,
- {"FC-4 Types", "fcdns.req.fc4type", FT_NONE, BASE_HEX,
+ {"FC-4 Types", "fcdns.req.fc4type", FT_NONE, BASE_HEX,
NULL, 0x0, "", HFILL}},
{ &hf_fcdns_fc4features,
{"FC-4 Feature Bits", "fcdns.fc4features", FT_UINT8,
&ett_fc4flags,
&ett_fc4features,
};
-
+
/* Register the protocol name and description */
proto_fcdns = proto_register_protocol("Fibre Channel Name Server",
"FC-dNS", "fcdns");
* 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.
dissect_fcfzs_zoneset (tvbuff_t *tvb, proto_tree *tree, int offset)
{
int numzones, nummbrs, i, j, len;
-
+
/* The zoneset structure has the following format */
/* zoneset name (len[not including pad], name, pad),
* number of zones,
*/
if (tree) {
- /* Zoneset Name */
+ /* Zoneset Name */
len = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (tree, hf_fcfzs_zonesetnmlen, tvb, offset,
1, 0);
len, 0);
offset += 4 + len + (4-(len % 4));
-
- /* Number of zones */
+
+ /* Number of zones */
numzones = tvb_get_ntohl (tvb, offset);
proto_tree_add_item (tree, hf_fcfzs_numzones, tvb, offset, 4, 0);
offset += 4;
-
- /* For each zone... */
+
+ /* For each zone... */
for (i = 0; i < numzones; i++) {
len = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (tree, hf_fcfzs_zonenmlen, tvb, offset,
offset += 4;
for (j = 0; j < nummbrs; j++) {
proto_tree_add_item (tree, hf_fcfzs_mbrtype, tvb, offset, 1, 0);
-
+
switch (tvb_get_guint8 (tvb, offset)) {
case FC_FZS_ZONEMBR_PWWN:
case FC_FZS_ZONEMBR_NWWN:
guint8 flags;
proto_item *item=NULL;
proto_tree *tree=NULL;
-
+
flags = tvb_get_guint8 (tvb, offset);
if(parent_tree){
item=proto_tree_add_uint(parent_tree, hf_fcfzs_gzc_flags, tvb, offset, 1, flags);
guint8 flags;
proto_item *item=NULL;
proto_tree *tree=NULL;
-
+
flags = tvb_get_guint8 (tvb, offset);
if(parent_tree){
item=proto_tree_add_uint(parent_tree, hf_fcfzs_zone_state, tvb, offset, 1, flags);
{
int numrec, i, len;
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (!isreq) {
numrec = tvb_get_ntohl (tvb, offset);
{
int numrec, i, len;
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (isreq) {
len = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (tree, hf_fcfzs_numzoneattrs, tvb, offset,
4, 0);
-
+
offset += 4;
for (i = 0; i < numrec; i++) {
len = tvb_get_guint8 (tvb, offset);
{
int numrec, i, len;
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (isreq) {
len = tvb_get_guint8 (tvb, offset);
dissect_fcfzs_gazs (tvbuff_t *tvb, proto_tree *tree, guint8 isreq)
{
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (!isreq) {
dissect_fcfzs_zoneset (tvb, tree, offset);
{
int offset = 16; /* past the fc_ct header */
int len;
-
+
if (tree) {
if (isreq) {
len = tvb_get_guint8 (tvb, offset);
dissect_fcfzs_adzs (tvbuff_t *tvb, proto_tree *tree, guint8 isreq)
{
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (isreq) {
dissect_fcfzs_zoneset (tvb, tree, offset);
dissect_fcfzs_azsd (tvbuff_t *tvb, proto_tree *tree, guint8 isreq)
{
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (isreq) {
dissect_fcfzs_zoneset (tvb, tree, offset);
{
int offset = 16; /* past the fc_ct header */
int len;
-
+
if (tree) {
if (isreq) {
len = tvb_get_guint8 (tvb, offset);
{
int numrec, i, len, plen;
int offset = 16; /* past the fc_ct header */
-
+
if (tree) {
if (isreq) {
len = tvb_get_guint8 (tvb, offset);
{
int offset = 16; /* past the fc_ct header */
int len;
-
+
if (tree) {
if (isreq) {
len = tvb_get_guint8 (tvb, offset);
len, 0);
len += (len % 4);
offset += len;
-
+
len = tvb_get_guint8 (tvb, offset);
proto_tree_add_item (tree, hf_fcfzs_zonenmlen, tvb, offset, 1, 0);
proto_tree_add_item (tree, hf_fcfzs_zonename, tvb, offset+4,
if (tree) {
proto_tree_add_item (tree, hf_fcfzs_reason, tvb, offset+13, 1, 0);
proto_tree_add_item (tree, hf_fcfzs_rjtdetail, tvb, offset+14, 1, 0);
- proto_tree_add_item (tree, hf_fcfzs_rjtvendor, tvb, offset+15, 1, 0);
+ proto_tree_add_item (tree, hf_fcfzs_rjtvendor, tvb, offset+15, 1, 0);
}
}
guint8 isreq = 1;
/* Make entries in Protocol column and Info column on summary display */
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "Zone Server");
-
-
+
+
tvb_memcpy (tvb, (guint8 *)&cthdr, offset, FCCT_PRMBL_SIZE);
cthdr.revision = tvb_get_guint8 (tvb, offset+1);
cthdr.in_id = tvb_get_ntoh24 (tvb, offset);
- cthdr.opcode = ntohs (cthdr.opcode);
+ cthdr.opcode = g_ntohs (cthdr.opcode);
opcode = cthdr.opcode;
- cthdr.maxres_size = ntohs (cthdr.maxres_size);
+ cthdr.maxres_size = g_ntohs (cthdr.maxres_size);
if (tree) {
ti = proto_tree_add_protocol_format (tree, proto_fcfzs, tvb, 0,
proto_tree_add_item (fcfzs_tree, hf_fcfzs_maxres_size, tvb, offset+10,
2, 0);
}
-
+
if ((opcode != FCCT_MSG_ACC) && (opcode != FCCT_MSG_RJT)) {
conversation = find_conversation (pinfo->fd->num, &pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->oxid,
pinfo->ptype, pinfo->oxid,
pinfo->rxid, NO_PORT2);
}
-
+
ckey.conv_idx = conversation->index;
-
+
cdata = (fcfzs_conv_data_t *)g_hash_table_lookup (fcfzs_req_hash,
&ckey);
if (cdata) {
/* Since we never free the memory used by an exchange, this maybe a
* case of another request using the same exchange as a previous
- * req.
+ * req.
*/
cdata->opcode = opcode;
}
else {
req_key = se_alloc (sizeof(fcfzs_conv_key_t));
req_key->conv_idx = conversation->index;
-
+
cdata = se_alloc (sizeof(fcfzs_conv_data_t));
cdata->opcode = opcode;
-
+
g_hash_table_insert (fcfzs_req_hash, req_key, cdata);
}
if (check_col (pinfo->cinfo, COL_INFO)) {
else
failed_opcode = cdata->opcode;
}
-
+
if (check_col (pinfo->cinfo, COL_INFO)) {
if (opcode != FCCT_MSG_RJT) {
col_add_fstr (pinfo->cinfo, COL_INFO, "MSG_ACC (%s)",
fc_fzs_opcode_val, "0x%x"));
}
}
-
+
if (tree) {
if ((cdata == NULL) && (opcode != FCCT_MSG_RJT)) {
/* No record of what this accept is for. Can't decode */
void
proto_register_fcfzs(void)
-{
+{
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
* 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_swils_interconnect_element_info (tvbuff_t *tvb, proto_tree *tree, int offset)
{
-
+
int len, max_len = MAX_INTERCONNECT_ELEMENT_INFO_LEN;
-
+
if (tree) {
proto_tree_add_item (tree, hf_swils_interconnect_list_len, tvb, offset+3, 1, 0);
len = tvb_strsize (tvb, offset+4);
break;
}
}
-
+
return;
}
type);
capinfo_tree = proto_item_add_subtree (ti, ett_fcswils_capinfo);
}
-
+
proto_tree_add_item (capinfo_tree, hf_swils_ess_cap_type, tvb, offset, 1, 0);
proto_tree_add_item (capinfo_tree, hf_swils_ess_cap_subtype, tvb, offset+1,
1, 0);
subtype = tvb_get_guint8 (tvb, offset+1);
-
+
if (type != FCCT_GSTYPE_VENDOR) {
srvr_type = get_gs_server (type, subtype);
proto_tree_add_uint (capinfo_tree, hf_swils_ess_cap_svc, tvb, offset, 2,
offset+3, 1, 0);
offset += 4;
len += 4;
-
+
while ((num_entries > 0) && tvb_bytes_exist (tvb, offset, 8)) {
dissect_swils_ess_capability (tvb, capinfo_tree, offset, srvr_type);
num_entries--;
static void
dissect_swils_elp (tvbuff_t *tvb, proto_tree *elp_tree, guint8 isreq _U_)
{
-
+
/* Set up structures needed to add the protocol subtree and manage it */
int offset = 0;
const gchar *flags;
/* Response i.e. SW_ACC for an ELP has the same format as the request */
/* We skip the initial 4 bytes as we don't care about the opcode */
tvb_memcpy (tvb, (guint8 *)&elp, 4, FC_SWILS_ELP_SIZE);
-
+
elp.r_a_tov = g_ntohl (elp.r_a_tov);
elp.e_d_tov = g_ntohl (elp.e_d_tov);
- elp.isl_flwctrl_mode = ntohs (elp.isl_flwctrl_mode);
- elp.flw_ctrl_parmlen = ntohs (elp.flw_ctrl_parmlen);
-
+ elp.isl_flwctrl_mode = g_ntohs (elp.isl_flwctrl_mode);
+ elp.flw_ctrl_parmlen = g_ntohs (elp.flw_ctrl_parmlen);
+
if (elp_tree) {
offset += 4;
proto_tree_add_item (elp_tree, hf_swils_elp_rev, tvb, offset++, 1, 0);
} else {
flags="Class F Invld";
}
- proto_tree_add_bytes_format (elp_tree, hf_swils_elp_clsf_svcp, tvb, offset, 6,
+ proto_tree_add_bytes_format (elp_tree, hf_swils_elp_clsf_svcp, tvb, offset, 6,
&elp.clsf_svcparm[0], "Class F Svc Parameters: (%s)", flags);
offset += 6;
else {
flags="Class 1 Invalid";
}
-
+
proto_tree_add_bytes_format (elp_tree, hf_swils_elp_cls1_svcp, tvb, offset, 2,
tvb_get_ptr (tvb, offset, 2),
"Class 1 Svc Parameters: (%s)", flags);
else {
flags="Class 2 Invld";
}
-
+
proto_tree_add_bytes_format (elp_tree, hf_swils_elp_cls2_svcp, tvb, offset, 2,
&elp.cls2_svcparm[0],
"Class 2 Svc Parameters: (%s)", flags);
offset += 2;
-
+
if (elp.cls2_svcparm[0] & 0x80) {
proto_tree_add_item (elp_tree, hf_swils_elp_cls2_rcvsz, tvb, offset, 2, 0);
}
offset += 2;
-
+
flags="";
if (elp.cls3_svcparm[0] & 0x80) {
if (elp.cls3_svcparm[0] & 0x08) {
offset = 0;
fcswils_efp efp;
guint8 rec_type;
-
+
offset += 1;
efp.reclen = tvb_get_guint8 (tvb, offset);
if (efp_tree)
"Unknown record type (0x%02x)"));
lrec_tree = proto_item_add_subtree (subti, ett_fcswils_efplist);
proto_tree_add_uint (lrec_tree, hf_swils_efp_rec_type, tvb, offset, 1,
- rec_type);
+ rec_type);
switch (rec_type) {
case FC_SWILS_LRECTYPE_DOMAIN:
- proto_tree_add_item (lrec_tree, hf_swils_efp_dom_id, tvb, offset+1, 1, 0);
+ proto_tree_add_item (lrec_tree, hf_swils_efp_dom_id, tvb, offset+1, 1, 0);
proto_tree_add_string (lrec_tree, hf_swils_efp_switch_name, tvb, offset+8, 8,
fcwwn_to_str (tvb_get_ptr(tvb, offset+8, 8)));
break;
/* Set up structures needed to add the protocol subtree and manage it */
int offset = 0;
int i, plen, numrec;
-
+
if (rdi_tree) {
plen = tvb_get_ntohs (tvb, offset+2);
-
+
proto_tree_add_item (rdi_tree, hf_swils_rdi_payload_len, tvb, offset+2, 2, 0);
proto_tree_add_string (rdi_tree, hf_swils_rdi_req_sname, tvb, offset+4,
8, fcwwn_to_str (tvb_get_ptr (tvb, offset+4, 8)));
{
proto_item *subti;
proto_tree *fspfh_tree;
-
+
if (tree) {
/* 20 is the size of FSPF header */
subti = proto_tree_add_text (tree, tvb, offset, 20, "FSPF Header");
if (tree) {
for (j = 0; j < num_lsrec; j++) {
- num_ldrec = tvb_get_ntohs (tvb, offset+26);
+ num_ldrec = tvb_get_ntohs (tvb, offset+26);
subti = proto_tree_add_text (tree, tvb, offset, (28+num_ldrec*16),
"Link State Record %d (Domain %d)", j,
tvb_get_guint8 (tvb, offset+15));
lsrec_tree = proto_item_add_subtree (subti, ett_fcswils_lsrec);
-
+
subti = proto_tree_add_text (lsrec_tree, tvb, offset, 24,
"Link State Record Header");
lsrechdr_tree = proto_item_add_subtree (subti,
- ett_fcswils_lsrechdr);
-
+ ett_fcswils_lsrechdr);
+
dissect_swils_fspf_lsrechdr (tvb, lsrechdr_tree, offset);
proto_tree_add_text (tree, tvb, offset+26, 2, "Number of Links: %d",
num_ldrec);
offset += 28;
-
+
for (i = 0; i < num_ldrec; i++) {
subti1 = proto_tree_add_text (lsrec_tree, tvb, offset, 16,
"Link Descriptor %d "
"Link State Record Header (Domain %d)",
tvb_get_guint8 (tvb, offset+15));
lsrechdr_tree = proto_item_add_subtree (subti,
- ett_fcswils_lsrechdr);
+ ett_fcswils_lsrechdr);
dissect_swils_fspf_lsrechdr (tvb, lsrechdr_tree, offset);
offset += 24;
}
int addrfmt, evtype;
int numrec, i;
proto_item *subti;
-
+
if (rscn_tree) {
if (!isreq)
return;
-
+
evtype = tvb_get_guint8 (tvb, offset+4);
addrfmt = evtype & 0x0F;
evtype = evtype >> 4;
proto_tree_add_item (rscn_tree, hf_swils_rscn_detectfn, tvb,
offset+8, 4, 0);
numrec = tvb_get_ntohl (tvb, offset+12);
-
+
if (!tvb_bytes_exist (tvb, offset+16, FC_SWILS_RSCN_DEVENTRY_SIZE*numrec)) {
/* Some older devices do not include device entry information. */
return;
}
-
+
proto_tree_add_text (rscn_tree, tvb, offset+12, 4, "Num Entries: %d",
numrec);
proto_tree_add_string (zmbr_tree, hf_swils_zone_mbrid, tvb,
offset+4, idlen,
"Unknown member type format");
-
+
}
}
proto_item *subti;
objtype = tvb_get_guint8 (tvb, offset);
-
+
proto_tree_add_item (zobj_tree, hf_swils_zone_objtype, tvb, offset,
1, 0);
proto_tree_add_item (zobj_tree, hf_swils_zone_protocol, tvb,
if (mr_tree) {
if (isreq) {
- /* zonesetlen is the size of the zoneset including the zone name */
+ /* zonesetlen is the size of the zoneset including the zone name */
zonesetlen = tvb_get_ntohs (tvb, offset+2);
proto_tree_add_text (mr_tree, tvb, offset+2, 2,
"Active ZoneSet Length: %u", zonesetlen);
proto_tree_add_string (mr_tree, hf_swils_zone_activezonenm, tvb,
offset+4, ZONENAME_LEN (tvb, offset+4),
str);
-
- /* objlistlen gives the size of the active zoneset object list */
+
+ /* objlistlen gives the size of the active zoneset object list */
objlistlen = zonesetlen - ZONENAME_LEN (tvb, offset+4);
/* Offset = start of the active zoneset zoning object list */
offset = offset + (4 + ZONENAME_LEN (tvb, offset+4));
numrec = tvb_get_ntohl (tvb, offset);
-
+
subti = proto_tree_add_text (mr_tree, tvb, offset, objlistlen,
"Active Zone Set");
zobjlist_tree = proto_item_add_subtree (subti,
ett_fcswils_zoneobjlist);
-
+
proto_tree_add_text (zobjlist_tree, tvb, offset, 4,
"Number of zoning objects: %d", numrec);
else {
offset += 4;
}
-
+
zonesetlen = tvb_get_ntohl (tvb, offset);
proto_tree_add_text (mr_tree, tvb, offset, 4,
"Full Zone Set Length: %d", zonesetlen);
/* Offset = start of the active zoneset zoning object list */
offset += 4;
numrec = tvb_get_ntohl (tvb, offset);
-
+
subti = proto_tree_add_text (mr_tree, tvb, offset, objlistlen,
"Full Zone Set");
-
+
zobjlist_tree = proto_item_add_subtree (subti,
ett_fcswils_zoneobjlist);
proto_tree_add_text (zobjlist_tree, tvb, offset, 4,
"Domain ID List Length: %d", plen);
numrec = plen/4;
offset = 4;
-
+
for (i = 0; i < numrec; i++) {
proto_tree_add_uint_format (aca_tree, hf_swils_aca_domainid,
- tvb, offset+3, 1,
+ tvb, offset+3, 1,
tvb_get_guint8 (tvb, offset+3),
"Domain ID %d: %d", i,
tvb_get_guint8 (tvb, offset+3));
proto_tree_add_string (sfc_tree, hf_swils_sfc_zonenm, tvb,
offset+4, ZONENAME_LEN (tvb, offset+4),
str);
-
- /* objlistlen gives the size of the active zoneset object list */
+
+ /* objlistlen gives the size of the active zoneset object list */
objlistlen = zonesetlen - ZONENAME_LEN (tvb, offset+4);
/* Offset = start of the active zoneset zoning object list */
offset = offset + (4 + ZONENAME_LEN (tvb, offset+4));
numrec = tvb_get_ntohl (tvb, offset);
-
+
subti = proto_tree_add_text (sfc_tree, tvb, offset, objlistlen,
"Zone Set");
zobjlist_tree = proto_item_add_subtree (subti,
ett_fcswils_zoneobjlist);
-
+
proto_tree_add_text (zobjlist_tree, tvb, offset, 4,
"Number of zoning objects: %d", numrec);
/* Offset = start of the active zoneset zoning object list */
offset += 4;
numrec = tvb_get_ntohl (tvb, offset);
-
+
subti = proto_tree_add_text (sfc_tree, tvb, offset, objlistlen,
"Full Zone Set");
-
+
zobjlist_tree = proto_item_add_subtree (subti,
ett_fcswils_zoneobjlist);
proto_tree_add_text (zobjlist_tree, tvb, offset, 4,
{
int offset = 0;
-
+
if (!tree) {
return;
}
4, 0);
}
-
+
}
static fcswils_func_table_t fcswils_func_table[FC_SWILS_MAXCODE] = {
tvbuff_t *next_tvb;
/* Make entries in Protocol column and Info column on summary display */
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SW_ILS");
/* decoding of this is done by each individual opcode handler */
opcode = tvb_get_guint8 (tvb, 0);
-
+
if (tree) {
ti = proto_tree_add_protocol_format (tree, proto_fcswils, tvb, 0,
tvb_length (tvb), "SW_ILS");
pinfo->ptype, pinfo->oxid,
pinfo->rxid, NO_PORT2);
}
-
+
ckey.conv_idx = conversation->index;
-
+
cdata = (fcswils_conv_data_t *)g_hash_table_lookup (fcswils_req_hash,
&ckey);
if (cdata) {
/* Since we never free the memory used by an exchange, this maybe a
* case of another request using the same exchange as a previous
- * req.
+ * req.
*/
cdata->opcode = opcode;
}
else {
req_key = se_alloc (sizeof(fcswils_conv_key_t));
req_key->conv_idx = conversation->index;
-
+
cdata = se_alloc (sizeof(fcswils_conv_data_t));
cdata->opcode = opcode;
-
+
g_hash_table_insert (fcswils_req_hash, req_key, cdata);
}
}
else
failed_opcode = cdata->opcode;
}
-
+
if (tree) {
if ((cdata == NULL) && (opcode != FC_SWILS_SWRJT)) {
/* No record of what this accept is for. Can't decode */
fcswils_func_table[opcode].func (tvb, swils_tree, isreq);
} else if (opcode == FC_SWILS_AUTH_ILS) {
/* This is treated differently */
- if (isreq && fcsp_handle)
+ if (isreq && fcsp_handle)
call_dissector (fcsp_handle, tvb, pinfo, swils_tree);
} else {
/* data dissector */
{"Event Type", "swils.rscn.evtype", FT_UINT8, BASE_DEC,
VALS (fc_swils_rscn_portstate_val), 0xF0, "", HFILL}},
{ &hf_swils_rscn_addrfmt,
- {"Address Format", "swils.rscn.addrfmt", FT_UINT8, BASE_DEC,
+ {"Address Format", "swils.rscn.addrfmt", FT_UINT8, BASE_DEC,
VALS (fc_swils_rscn_addrfmt_val), 0x0F, "", HFILL}},
{ &hf_swils_rscn_affectedport,
{"Affected Port ID", "swils.rscn.affectedport", FT_STRING, BASE_HEX,
FT_BOOLEAN, BASE_HEX, NULL, 0x20, "", HFILL}},
{ &hf_swils_ess_fzs_adc_supp,
{"Active Direct Command Supported",
- "swils.ess.capability.fzs.adcsupp", FT_BOOLEAN, BASE_HEX, NULL,
+ "swils.ess.capability.fzs.adcsupp", FT_BOOLEAN, BASE_HEX, NULL,
0x40, "", HFILL}},
{ &hf_swils_ess_fzs_hardzone,
{"Hard Zoning Supported", "swils.ess.capability.fzs.hardzone",
int i;
for (i=0; i<interface_anzahl; i++) {
- free(p_interfaces[i]);
+ g_free(p_interfaces[i]);
}
interface_anzahl = 0;
}
return;
/* Save the request URI for various later uses */
- request_uri = (gchar *)tvb_get_string(tvb, offset, tokenlen);
+ request_uri = (gchar *)tvb_get_ephemeral_string(tvb, offset, tokenlen);
stat_info->request_uri = ep_strdup(request_uri);
conv_data->request_uri = se_strdup(request_uri);
next_tvb, 0, 0, strings[0]);
PROTO_ITEM_SET_GENERATED(item);
- item = proto_tree_add_uint(sub_tree, hf_http_proxy_connect_port,
+ item = proto_tree_add_uint(sub_tree, hf_http_proxy_connect_port,
next_tvb, 0, 0, strtol(strings[1], NULL, 10) );
PROTO_ITEM_SET_GENERATED(item);
len = first_colon - offset;
proto_tree_add_item(ct_tree, hf_imf_content_type_type, tvb, offset, len, FALSE);
if(type)
- /* this string must be freed */
- (*type) = tvb_get_string(tvb, offset, len);
+ /* This string will be automatically freed */
+ (*type) = tvb_get_ephemeral_string(tvb, offset, len);
len = length - (first_colon + 1 - offset);
proto_tree_add_item(ct_tree, hf_imf_content_type_parameters, tvb, first_colon + 1, len, FALSE);
if(parameters)
- /* this string must be freed */
- (*parameters) = tvb_get_string(tvb, first_colon + 1, len);
+ /* This string will be automatically freed */
+ (*parameters) = tvb_get_ephemeral_string(tvb, first_colon + 1, len);
}
}
dissected = dissector_try_string(media_type_dissector_table, content_type_str, next_tvb, pinfo, tree);
- g_free(content_type_str);
- content_type_str = NULL;
-
- if(parameters) {
- g_free(parameters);
- parameters = NULL;
- }
} else {
/* just show the lines or highlight the rest of the buffer as message text */
guint8 indicator;
gint gen_name_length;
char *gen_name=NULL;
-
+
gen_name=ep_alloc(MAXGNAME + 1);
gen_name[0] = '\0';
gen_name_length = tvb_length(parameter_tvb) - 1;
proto_tree_add_uint(parameter_tree, hf_isup_generic_name_presentation, parameter_tvb, 1, 1, indicator);
proto_tree_add_boolean(parameter_tree, hf_isup_generic_name_availability, parameter_tvb, 1, 1, indicator);
proto_tree_add_uint(parameter_tree, hf_isup_generic_name_type, parameter_tvb, 1, 1, indicator);
- gen_name = tvb_get_string(parameter_tvb,1,gen_name_length);
+ gen_name = tvb_get_ephemeral_string(parameter_tvb,1,gen_name_length);
gen_name[gen_name_length] = '\0';
proto_tree_add_string(parameter_tree, hf_isup_generic_name_ia5, parameter_tvb, 2, gen_name_length, gen_name);
proto_item_set_text(parameter_item, "Generic name: %s", gen_name);
-
+
}
-
+
/* ------------------------------------------------------------------
Dissector Parameter Generic digits
*/
* 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.
p_add_proto_data(pinfo->fd, proto_msrp, p_conv_packet_data);
}
- }
+ }
}
/* Create setup info subtree with summary info. */
}
}
-/* This code is modeled on the code in packet-sip.c
+/* This code is modeled on the code in packet-sip.c
* ABNF code for the MSRP header:
* The following syntax specification uses the augmented Backus-Naur
* Form (BNF) as described in RFC-2234 [6].
* Examples:
* "MSRP 1234 SEND(CRLF)"
* "MSRP 1234 200 OK(CRLF)
- */
+ */
static gboolean
check_msrp_header(tvbuff_t *tvb)
-{
+{
gint offset = 0;
gint linelen;
gint space_offset;
if ( !check_msrp_header(tvb)){
return 0;
}
- /* We have a MSRP header with at least three tokens
+ /* We have a MSRP header with at least three tokens
*
* Note that "tvb_find_line_end()" will return a value that
* is not longer than what's in the buffer, so the
}
/* Make entries in Protocol column and Info column on summary display */
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "MSRP");
if (is_msrp_response){
if (check_col(pinfo->cinfo, COL_INFO)) {
reqresp_tree = proto_item_add_subtree(th, ett_msrp_reqresp);
proto_tree_add_item(reqresp_tree,hf_msrp_transactionID,tvb,token_2_start,token_2_len,FALSE);
proto_tree_add_uint(reqresp_tree,hf_msrp_status_code,tvb,token_3_start,token_3_len,
- atoi(tvb_get_string(tvb, token_3_start, token_3_len)));
+ atoi(tvb_get_ephemeral_string(tvb, token_3_start, token_3_len)));
}else{
th = proto_tree_add_item(msrp_tree,hf_msrp_request_line,tvb,0,linelen,FALSE);
msrp_headers_item = proto_tree_add_item(msrp_tree, hf_msrp_msg_hdr, tvb, offset,(end_line_offset - offset), FALSE);
msrp_hdr_tree = proto_item_add_subtree(msrp_headers_item, ett_msrp_hdr);
- /*
+ /*
* Process the headers
*/
while (tvb_reported_length_remaining(tvb, offset) > 0 && offset < end_line_offset ) {
msrp_end_tree = proto_item_add_subtree(ti, ett_msrp_end_line);
proto_tree_add_item(msrp_end_tree,hf_msrp_transactionID,tvb,end_line_offset + 7,token_2_len,FALSE);
- /* continuation-flag */
+ /* continuation-flag */
proto_tree_add_item(msrp_end_tree,hf_msrp_cnt_flg,tvb,end_line_offset+end_line_len-1,1,FALSE);
-
+
if (global_msrp_raw_text){
ti = proto_tree_add_text(tree, tvb, 0, -1,"Message Session Relay Protocol(as raw text)");
raw_tree = proto_item_add_subtree(ti, ett_msrp);
}
if (mysql_showquery) {
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, " { %s } ",tvb_get_string(tvb, offset, strlen));
+ col_append_fstr(pinfo->cinfo, COL_INFO, " { %s } ",
+ tvb_get_ephemeral_string(tvb, offset, strlen));
}
offset+= strlen;
conn_data->state= RESPONSE_TABULAR;
strlen= my_tvb_strsize(tvb, offset);
if (req_tree) {
proto_tree_add_text(req_tree, tvb, offset, strlen, "Table name: %s",
- tvb_get_string(tvb, offset, strlen));
+ tvb_get_ephemeral_string(tvb, offset, strlen));
}
offset+= strlen;
conn_data->state= RESPONSE_TABULAR;
/*
* ASCII.
*/
- string = tvb_get_string(tvb, foffset, str_length);
+ string = tvb_get_ephemeral_string(tvb, foffset, str_length);
} else {
/*
* Unicode.
{ Request_PDU, "Request PDU" },
{ Reject_PDU, "Reject PDU" },
{ Release_PDU, "Release PDU" },
- { 0, NULL }
+ { 0, NULL }
};
static enum_val_t decode_options[] = {
/* Checksum */
len = tvb_length (tvb);
- value = tvb_get_string (tvb, 0, len);
+ value = tvb_get_ephemeral_string (tvb, 0, len);
checksum1 = checksum (value, len, offset);
checksum2 = tvb_get_ntohs (tvb, offset);
- g_free (value);
en = proto_tree_add_item (p_mul_tree, hf_checksum, tvb, offset, 2, FALSE);
if (checksum1 == checksum2) {
proto_item_append_text (en, " (correct)");
message_id = tvb_get_ntohl (tvb, offset);
proto_tree_add_item (p_mul_tree, hf_message_id, tvb, offset, 4, FALSE);
offset += 4;
-
+
proto_item_append_text (ti, ", MSID: %u", message_id);
if (check_col (pinfo->cinfo, COL_INFO))
col_append_fstr (pinfo->cinfo, COL_INFO, ", MSID: %u", message_id);
pppoe_tree = proto_item_add_subtree(ti, ett_pppoed_tags);
tagstart = offset;
-
+
/* Loop until all data seen or End-Of-List tag found */
while (tagstart <= payload_length-2 )
{
proto_tree_add_item(pppoe_tree, hf_pppoed_tag, tvb, tagstart, 2, FALSE);
proto_tree_add_item(pppoe_tree, hf_pppoed_tag_length, tvb, tagstart+2, 2, FALSE);
}
-
+
/* Show tag data */
switch (poe_tag)
{
if (check_col(pinfo->cinfo,COL_INFO))
{
col_append_fstr(pinfo->cinfo, COL_INFO, " AC-Name='%s'",
- tvb_get_string(tvb, tagstart+4, poe_tag_length));
+ tvb_get_ephemeral_string(tvb, tagstart+4, poe_tag_length));
}
break;
case PPPOE_TAG_HOST_UNIQ:
proto_tree_add_item(pppoe_tree, hf_pppoe_session_id, tvb, 2, 2, FALSE);
proto_tree_add_item(pppoe_tree, hf_pppoe_payload_length, tvb, 4, 2, FALSE);
}
-
+
/* Now dissect any tags */
if (reported_payload_length > 0)
{
NULL, 0x0, "", HFILL
}
},
-
+
/* Discovery tag fields */
{ &hf_pppoed_tags,
{ "PPPoE Tags", "pppoed.tags", FT_NONE, BASE_NONE,
# include "inet_v6defs.h"
#endif
-#include <glib.h>
+#include <glib.h>
#include <epan/packet.h>
#include <epan/conversation.h>
#include <epan/strutil.h>
* Find the end of the line.
*/
linelen = tvb_find_line_end_unquoted(tvb, offset, -1, &next_offset);
-
-
-
+
+
+
/*
* Line must contain at least e.g. "v=".
*/
call_sdp_subdissector(tvb_new_subset(tvb,offset+tokenoffset,
linelen-tokenoffset,
linelen-tokenoffset),
- pinfo,
+ pinfo,
hf,sub_ti,&transport_info),
offset = next_offset;
}
}
if(transport_info.media_proto[n]!=NULL) {
/* Check if media protocol is RTP
- * and stream decoding is enabled in preferences
+ * and stream decoding is enabled in preferences
*/
if(global_sdp_establish_conversation){
/* Check if media protocol is RTP */
is_msrp = (strcmp(transport_info.media_proto[n],"msrp/tcp")==0);
}
}
-
+
if(transport_info.connection_address!=NULL) {
if(transport_info.connection_type!=NULL) {
g_snprintf(sdp_pi->summary_str, 50, "%s %s", sdp_pi->summary_str, str_dyn_pt);
else
g_snprintf(sdp_pi->summary_str, 50, "%s %d", sdp_pi->summary_str, transport_info.media[n].pt[i]);
- } else
+ } else
g_snprintf(sdp_pi->summary_str, 50, "%s %s", sdp_pi->summary_str, val_to_str(transport_info.media[n].pt[i], rtp_payload_type_short_vals, "%u"));
}
/* Free the hash table if we did't assigned it to a conv use it */
- if (set_rtp == FALSE)
+ if (set_rtp == FALSE)
rtp_free_hash_dyn_payload(transport_info.media[n].rtp_dyn_payload);
/* Create the T38 summary str for the Voip Call analysis */
- if (is_t38) g_snprintf(sdp_pi->summary_str, 50, "%s t38", sdp_pi->summary_str);
+ if (is_t38) g_snprintf(sdp_pi->summary_str, 50, "%s t38", sdp_pi->summary_str);
}
/* Free the remainded hash tables not used */
key_tree = proto_item_add_subtree(ti, ett_sdp_key_mgmt);
next_offset = tvb_find_guint8(tvb,offset,-1,' ');
-
+
if (next_offset == -1)
return;
-
+
tokenlen = next_offset - offset;
prtcl_id = tvb_get_ephemeral_string(tvb, offset, tokenlen);
proto_tree *sdp_session_attribute_tree;
gint offset, next_offset, tokenlen;
guint8 *field_name;
-
+
offset = 0;
next_offset = 0;
tokenlen = 0;
tvb, offset, tokenlen, FALSE);
field_name = tvb_get_ephemeral_string(tvb, offset, tokenlen);
-
+
offset = next_offset + 1;
if (strcmp((char*)field_name, "ipbcp") == 0) {
if (offset == -1)
return;
-
+
next_offset = tvb_find_guint8(tvb,offset,-1,' ');
-
+
if (next_offset == -1)
return;
-
+
tokenlen = next_offset - offset;
-
+
proto_tree_add_item(sdp_session_attribute_tree,hf_ipbcp_version,tvb,offset,tokenlen,FALSE);
offset = tvb_pbrk_guint8(tvb,offset,-1,(guint8 *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
return;
tokenlen = tvb_find_line_end(tvb,offset,-1, &next_offset, FALSE);
-
- if (tokenlen == -1)
+
+ if (tokenlen == -1)
return;
-
+
proto_tree_add_item(sdp_session_attribute_tree,hf_ipbcp_type,tvb,offset,tokenlen,FALSE);
} else if (strcmp((char*)field_name, "key-mgmt") == 0) {
tvbuff_t *key_tvb;
transport_info->media_port[transport_info->media_count] = (char*)tvb_get_ephemeral_string(tvb, offset, tokenlen);
proto_tree_add_uint(sdp_media_tree, hf_media_port, tvb, offset, tokenlen,
- atoi((char*)tvb_get_string(tvb, offset, tokenlen)));
+ atoi((char*)tvb_get_ephemeral_string(tvb, offset, tokenlen)));
offset = next_offset + 1;
next_offset = tvb_find_guint8(tvb,offset, -1, ' ');
if(next_offset == -1)
/* XXX Remember Port */
proto_tree_add_uint(sdp_media_tree, hf_media_port, tvb, offset, tokenlen,
- atoi((char*)tvb_get_string(tvb, offset, tokenlen)));
+ atoi((char*)tvb_get_ephemeral_string(tvb, offset, tokenlen)));
offset = next_offset + 1;
}
} else {
tokenlen = next_offset - offset;
}
-
+
if (strcmp(transport_info->media_proto[transport_info->media_count],
"RTP/AVP") == 0) {
media_format = tvb_get_ephemeral_string(tvb, offset, tokenlen);
/*
14496-2, Annex G, Table G-1.
-Table G-1 FLC table for profile_and_level_indication Profile/Level Code
+Table G-1 FLC table for profile_and_level_indication Profile/Level Code
*/
static const value_string mpeg4es_level_indication_vals[] =
{
/* Reserved 01110011 - 10000000 */
{ 0x81, "Hybrid Profile/Level 1" },
{ 0x82, "Hybrid Profile/Level 2" },
- /* Reserved 10000011 - 10010000 */
+ /* Reserved 10000011 - 10010000 */
{ 0x91, "Advanced Real Time Simple Profile/Level 1" },
{ 0x92, "Advanced Real Time Simple Profile/Level 2" },
{ 0x93, "Advanced Real Time Simple Profile/Level 3" },
{ 0, NULL },
};
-/*
+/*
* TODO: Make this a more generic routine to dissect fmtp parameters depending on media types
*/
static void
{ "rtpmap"}, /* 1 */
{ "fmtp"}, /* 2 */
{ "path"}, /* 3 */
- { "h248item"}, /* 4 */
+ { "h248item"}, /* 4 */
};
static gint find_sdp_media_attribute_names(tvbuff_t *tvb, int offset, guint len)
offset = next_offset + 1;
/* Value is the remainder of the line */
- attribute_value = tvb_get_string(tvb, offset, tvb_length_remaining(tvb, offset));
+ attribute_value = tvb_get_ephemeral_string(tvb, offset, tvb_length_remaining(tvb, offset));
m=audio 49172 RTP/AVP 97 101
a=rtpmap:97 G726-24/8000
- The Media attributes ("a="s) after the "m=" only apply for that "m=".
+ The Media attributes ("a="s) after the "m=" only apply for that "m=".
If there is an "a=" before the first "m=", that attribute applies for
all the session (all the "m="s).
*/
/* so, if this "a=" appear before any "m=", we add it to all the dynamic
* hash tables
- */
+ */
if (transport_info->media_count == 0) {
for (n=0; n < SDP_MAX_RTP_CHANNELS; n++) {
if (n==0)
offset, tokenlen, FALSE);
fmtp_tree = proto_item_add_subtree(fmtp_item, ett_sdp_fmtp);
-
+
decode_sdp_fmtp(fmtp_tree, tvb, offset, tokenlen,
(guint8 *)transport_info->encoding_name);
case SDP_H248_ITEM:
/* Decode h248 item ITU-T Rec. H.248.12 (2001)/Amd.1 (11/2002)*/
if (strncmp((char*)attribute_value, h324ext_h223lcparm, strlen(msrp_res)) == 0){
- /* A.5.1.3 H.223 Logical channel parameters
+ /* A.5.1.3 H.223 Logical channel parameters
* This property indicates the H.245
* H223LogicalChannelsParameters structure encoded by applying the PER specified in
* ITU-T Rec. X.691. Value encoded as per A.5.1.2. For text encoding the mechanism defined
asn1_ctx_init(&actx, ASN1_ENC_PER, TRUE, pinfo);
dissect_h245_H223LogicalChannelParameters(h245_tvb, 0, &actx, sdp_media_attribute_tree, hf_SDPh223LogicalChannelParameters);
}
-
+
}
break;
default:
"Specifies that RTP/RTCP/T.38/MSRP/etc streams are decoded based "
"upon port numbers found in SIP/SDP payload",
&global_sdp_establish_conversation);
-
+
/*
* Register the dissector by name, so other dissectors can
* grab it by name rather than just referring to it directly.
git.samba.org / obnox / wireshark / wip.git / commitdiff