variables.
This file is compiled to give in depth information on Wireshark.
-It is by no means all inclusive and complete. Please feel free to send
+It is by no means all inclusive and complete. Please feel free to send
remarks and patches to the developer mailing list.
0. Prerequisites.
-Before starting to develop a new dissector, a "running" Wireshark build
-environment is required - there's no such thing as a standalone "dissector
-build toolkit".
+Before starting to develop a new dissector, a "running" Wireshark build
+environment is required - there's no such thing as a standalone "dissector
+build toolkit".
-How to setup such an environment is platform dependant, detailed information
+How to setup such an environment is platform dependant, detailed information
about these steps can be found in the "Developer's Guide" (available from:
-http://www.wireshark.org) and in the INSTALL and README files of the sources
+http://www.wireshark.org) and in the INSTALL and README files of the sources
root dir.
0.1. General README files.
- README.stats_tree - a tree statistics counting specific packets
- README.tapping - "tap" a dissector to get protocol specific events
- README.xml-output - how to work with the PDML exported output
-- wiretap/README.developer - how to add additional capture file types to
+- wiretap/README.developer - how to add additional capture file types to
Wiretap
0.2. Dissector related README files.
-You'll find additional dissector related information in the following README
+You'll find additional dissector related information in the following README
files:
- README.binarytrees - fast access to large data collections
done:
}
-
+
will not work with all compilers - you have to do
if (...) {
Don't use "ntohs()", "ntohl()", "htons()", or "htonl()"; the header
files required to define or declare them differ between platforms, and
you might be able to get away with not including the appropriate header
-file on your platform but that might not work on other platforms.
+file on your platform but that might not work on other platforms.
Instead, use "g_ntohs()", "g_ntohl()", "g_htons()", and "g_htonl()";
those are declared by <glib.h>, and you'll need to include that anyway,
as Wireshark header files that all dissectors must include use stuff from
In addition, that also means that when opening or creating a binary
file, you must use "open()" (with O_CREAT and possibly O_TRUNC if the
-file is to be created if it doesn't exist), and OR in the O_BINARY flag.
+file is to be created if it doesn't exist), and OR in the O_BINARY flag.
That flag is not present on most, if not all, UNIX systems, so you must
also do
#define DBG(args) printf args
snprintf() -> g_snprintf()
-snprintf() is not available on all platforms, so it's a good idea to use the
+snprintf() is not available on all platforms, so it's a good idea to use the
g_snprintf() function declared by <glib.h> instead.
tmpnam() -> mkstemp()
1.1.2 String handling
Do not use functions such as strcat() or strcpy().
-A lot of work has been done to remove the existing calls to these functions and
+A lot of work has been done to remove the existing calls to these functions and
we do not want any new callers of these functions.
Instead use g_snprintf() since that function will if used correctly prevent
When using a buffer to create a string, do not use a buffer stored on the stack.
I.e. do not use a buffer declared as
char buffer[1024];
-instead allocate a buffer dynamically using the emem routines (see
+instead allocate a buffer dynamically using the emem routines (see
README.malloc) such as
char *buffer=NULL;
...
...
g_snprintf(buffer, MAX_BUFFER, ...
-This avoids the stack from being corrupted in case there is a bug in your code
+This avoids the stack from being corrupted in case there is a bug in your code
that accidentally writes beyond the end of the buffer.
-If you write a routine that will create and return a pointer to a filled in
-string and if that buffer will not be further processed or appended to after
-the routine returns (except being added to the proto tree),
-do not preallocate the buffer to fill in and pass as a parameter instead
+If you write a routine that will create and return a pointer to a filled in
+string and if that buffer will not be further processed or appended to after
+the routine returns (except being added to the proto tree),
+do not preallocate the buffer to fill in and pass as a parameter instead
pass a pointer to a pointer to the function and return a pointer to an
emem allocated buffer that will be automatically freed. (see README.malloc)
proto_tree_add_text(... *buffer ...
Use ep_ allocated buffers. They are very fast and nice. These buffers are all
-automatically free()d when the dissection of the current packet ends so you
+automatically free()d when the dissection of the current packet ends so you
don't have to worry about free()ing them explicitly in order to not leak memory.
Please read README.malloc.
Here are some suggestions for making dissectors more robust in the face
of incorrectly-formed packets:
-Do *NOT* use "g_assert()" or "g_assert_not_reached()" in dissectors.
+Do *NOT* use "g_assert()" or "g_assert_not_reached()" in dissectors.
*NO* value in a packet's data should be considered "wrong" in the sense
that it's a problem with the dissector if found; if it cannot do
anything else with a particular value from a packet's data, the
If you're fetching into such a chunk of memory a 2-byte Unicode string
from the buffer, and the string has a specified size, you can use
-"tvb_get_ephemeral_faked_unicode()", which will check whether the entire
-string is present before allocating a buffer for the string, and will also
-put a trailing '\0' at the end of the buffer. The resulting string will be
+"tvb_get_ephemeral_faked_unicode()", which will check whether the entire
+string is present before allocating a buffer for the string, and will also
+put a trailing '\0' at the end of the buffer. The resulting string will be
a sequence of single-byte characters; the only Unicode characters that
will be handled correctly are those in the ASCII range. (Wireshark's
ability to handle non-ASCII strings is limited; it needs to be
in question will be interpreted as packets for that protocol by
Wireshark). If there's no maximum length of string data to be fetched,
routines such as "tvb_get_*_string()" are safer, as they allocate a buffer
-large enough to hold the string. (Note that some variants of this call
+large enough to hold the string. (Note that some variants of this call
require you to free the string once you're finished with it.)
If you have gotten a pointer using "tvb_get_ptr()", you must make sure
overflowing.
sprintf() -> g_snprintf()
-Prevent yourself from using the sprintf() function, as it does not test the
-length of the given output buffer and might be writing into memory areas not
-intended for. This function is one of the main causes of security problems
-like buffer exploits and many other bugs that are very hard to find. It's
+Prevent yourself from using the sprintf() function, as it does not test the
+length of the given output buffer and might be writing into memory areas not
+intended for. This function is one of the main causes of security problems
+like buffer exploits and many other bugs that are very hard to find. It's
much better to use the g_snprintf() function declared by <glib.h> instead.
-You should test your dissector against incorrectly-formed packets. This
+You should test your dissector against incorrectly-formed packets. This
can be done using the randpkt and editcap utilities that come with the
Wireshark distribution. Testing using randpkt can be done by generating
output at the same layer as your protocol, and forcing Wireshark/TShark
randpkt -c 50000 -t dns randpkt.pcap
tshark -nVr randpkt.pcap -d udp.port==53,<myproto>
-
+
Testing using editcap can be done using preexisting capture files and the
"-E" flag, which introduces errors in a capture file. E.g.:
1.2 Skeleton code.
-Wireshark requires certain things when setting up a protocol dissector.
+Wireshark requires certain things when setting up a protocol dissector.
Below is skeleton code for a dissector that you can copy to a file and
fill in. Your dissector should follow the naming convention of packet-
followed by the abbreviated name for the protocol. It is recommended
Usually, you will put your newly created dissector file into the directory
epan/dissectors, just like all the other packet-....c files already in there.
-Also, please add your dissector file to the corresponding makefile,
+Also, please add your dissector file to the corresponding makefile,
described in section "1.9 Editing Makefile.common to add your dissector" below.
Dissectors that use the dissector registration to register with a lower level
is needed only if you are using a function from libpcre, e.g. the
"pcre_compile()" function.
-The "$Id$" in the comment will be updated by Subversion when the file is
+The "$Id$" in the comment will be updated by Subversion when the file is
checked in.
When creating a new file, it is fine to just write "$Id$" as Subversion will
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
return 0;
/* 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, "PROTOABBREV");
-
+
/* This field shows up as the "Info" column in the display; you should use
it, if possible, to summarize what's in the packet, so that a user looking
at the list of packets can tell what type of packet it is. See section 1.5
for more information.
Before changing the contents of a column you should make sure the column is
- active by calling "check_col(pinfo->cinfo, COL_*)". If it is not active
+ active by calling "check_col(pinfo->cinfo, COL_*)". If it is not active
don't bother setting it.
-
- If you are setting the column to a constant string, use "col_set_str()",
+
+ If you are setting the column to a constant string, use "col_set_str()",
as it's more efficient than the other "col_set_XXX()" calls.
If you're setting it to a string you've constructed, or will be
past the end of the packet, so that the Info column doesn't have data
left over from the previous dissector; do
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_clear(pinfo->cinfo, COL_INFO);
*/
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_set_str(pinfo->cinfo, COL_INFO, "XXX Request");
/* A protocol dissector can be called in 2 different ways:
void
proto_register_PROTOABBREV(void)
-{
+{
module_t *PROTOABBREV_module;
/* Setup list of header fields See Section 1.6.1 for details*/
static hf_register_info hf[] = {
{ &hf_PROTOABBREV_FIELDABBREV,
{ "FIELDNAME", "PROTOABBREV.FIELDABBREV",
- FIELDTYPE, FIELDBASE, FIELDCONVERT, BITMASK,
+ FIELDTYPE, FIELDBASE, FIELDCONVERT, BITMASK,
"FIELDDESCR", HFILL }
}
};
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_PROTOABBREV, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
-
+
/* Register preferences module (See Section 2.6 for more on preferences) */
- PROTOABBREV_module = prefs_register_protocol(proto_PROTOABBREV,
+ PROTOABBREV_module = prefs_register_protocol(proto_PROTOABBREV,
proto_reg_handoff_PROTOABBREV);
-
+
/* Register a sample preference */
- prefs_register_bool_preference(PROTOABBREV_module, "showHex",
+ prefs_register_bool_preference(PROTOABBREV_module, "showHex",
"Display numbers in Hex",
"Enable to display numerical values in hexadecimal.",
&gPREF_HEX);
/* 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 and create the code that calls these routines.
-
- This function is also called by preferences whenever "Apply" is pressed
- (see prefs_register_protocol above) so it should accommodate being called
+
+ This function is also called by preferences whenever "Apply" is pressed
+ (see prefs_register_protocol above) so it should accommodate being called
more than once.
*/
void
proto_reg_handoff_PROTOABBREV(void)
{
static gboolean inited = FALSE;
-
+
if (!inited) {
dissector_handle_t PROTOABBREV_handle;
PROTOABBREV_handle = new_create_dissector_handle(dissect_PROTOABBREV,
proto_PROTOABBREV);
dissector_add("PARENT_SUBFIELD", ID_VALUE, PROTOABBREV_handle);
-
+
inited = TRUE;
}
-
- /*
+
+ /*
If you perform registration functions which are dependant upon
prefs the you should de-register everything which was associated
with the previous settings and re-register using the new prefs
currentPort = gPortPref;
dissector_add("tcp.port", currentPort, PROTOABBREV_handle);
-
+
*/
}
PROTOSHORTNAME An abbreviated name for the protocol; this is displayed
in the "Preferences" dialog box if your dissector has
any preferences, in the dialog box of enabled protocols,
- and in the dialog box for filter fields when constructing
+ and in the dialog box for filter fields when constructing
a filter expression.
PROTOABBREV A name for the protocol for use in filter expressions;
it shall contain only lower-case letters, digits, and
register itself with the lower level dissector, or if the protocol dissector
wants/needs to expose code to other subdissectors.
-The dissector must declared as exactly as follows in the file
+The dissector must declared as exactly as follows in the file
packet-PROTOABBREV.h:
int
buffer will lead to memory leaks.
tvb_get_ephemeral_string() returns a buffer allocated from a special heap
with a lifetime until the next packet is dissected. You do not need to
-free() this buffer, it will happen automatically once the next packet is
+free() this buffer, it will happen automatically once the next packet is
dissected.
buffer will lead to memory leaks.
tvb_get_ephemeral_stringz() returns a buffer allocated from a special heap
with a lifetime until the next packet is dissected. You do not need to
-free() this buffer, it will happen automatically once the next packet is
+free() this buffer, it will happen automatically once the next packet is
dissected.
tvb_fake_unicode() returns a buffer allocated by g_malloc() so you must
g_free() it when you are finished with the string. Failure to g_free() this
buffer will lead to memory leaks.
-tvb_get_ephemeral_faked_unicode() returns a buffer allocated from a special
+tvb_get_ephemeral_faked_unicode() returns a buffer allocated from a special
heap with a lifetime until the next packet is dissected. You do not need to
-free() this buffer, it will happen automatically once the next packet is
+free() this buffer, it will happen automatically once the next packet is
dissected.
Returns a buffer, allocated with "g_malloc()", containing the specified
length's worth of data from the specified tvbuff, starting at the
-specified offset. The ephemeral variant is freed automatically after the
+specified offset. The ephemeral variant is freed automatically after the
packet is dissected.
Pointer-retrieval:
* another copy of the packet data. Furthermore, it's dangerous because once
* this pointer is given to the user, there's no guarantee that the user will
* honor the 'length' and not overstep the boundaries of the buffer.
- */
+ */
guint8* tvb_get_ptr(tvbuff_t*, gint offset, gint length);
The reason that tvb_get_ptr() might have to allocate a copy of its data
-only occurs with TVBUFF_COMPOSITES, data that spans multiple tvbuffers.
+only occurs with TVBUFF_COMPOSITES, data that spans multiple tvbuffers.
If the user request a pointer to a range of bytes that spans the member
tvbuffs that make up the TVBUFF_COMPOSITE, the data will have to be
copied to another memory region to assure that all the bytes are
field, typically giving an abbreviated name for the protocol (but not
the all-lower-case abbreviation used elsewhere) is COL_PROTOCOL, and the
COL_ value for the "Info" field, giving a summary of the contents of the
-packet for that protocol, is COL_INFO.
+packet for that protocol, is COL_INFO.
A value for a column should only be added if the user specified that it
be displayed; to check whether a given column is to be displayed, call
For example, to set the "Protocol" column
to "PROTOABBREV":
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PROTOABBREV");
string containing the type of the request in the packet and "n" is an
unsigned integer containing the number of bytes in the request:
- if (check_col(pinfo->cinfo, COL_INFO))
+ if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s request, %u bytes",
reqtype, n);
to the tree.
When a packet is selected in the packet-list pane, or a packet popup
-window is created, a new logical protocol tree (proto_tree) is created.
+window is created, a new logical protocol tree (proto_tree) is created.
The pointer to the proto_tree (in this case, 'protocol tree'), is passed
to the top-level protocol dissector, and then to all subsequent protocol
dissectors for that packet, and then the GUI tree is drawn via
the file containing a dissector's "register" routine must be
added to "DISSECTOR_SRC" in "epan/dissectors/Makefile.common";
-
+
the "register" routine must have a name of the form
"proto_register_XXX";
-
+
the "register" routine must take no argument, and return no
value;
-
+
the "register" routine's name must appear in the source file
either at the beginning of the line, or preceded only by "void "
at the beginning of the line (that would typically be the
definition) - other white space shouldn't cause a problem, e.g.:
-
+
void proto_register_XXX(void) {
-
+
...
-
+
}
-
+
and
-
+
void
proto_register_XXX( void )
{
-
+
...
-
+
}
-
+
and so on should work.
For every protocol or field that a dissector wants to register, a variable of
name
----
A string representing the name of the field. This is the name
-that will appear in the graphical protocol tree.
+that will appear in the graphical protocol tree. It must be a non-empty
+string.
abbrev
------
has multiple error fields, so the abbreviations follow this pattern:
"trmac.errors.iso", "trmac.errors.noniso", etc.
-The abbreviation is the identifier used in a display filter.
+The abbreviation is the identifier used in a display filter. If it is
+an empty string then the field will not be filterable.
type
----
in standard IPv6 address format.
FT_IPXNET An IPX address displayed in hex as a 6-byte
network number followed by a 6-byte station
- address.
+ address.
FT_GUID A Globally Unique Identifier
FT_OID An ASN.1 Object Identifier
BASE_HEX_DEC
BASE_DEC, BASE_HEX, and BASE_OCT are decimal, hexadecimal, and octal,
-respectively. BASE_DEC_HEX and BASE_HEX_DEC display value in two bases
+respectively. BASE_DEC_HEX and BASE_HEX_DEC display value in two bases
(the 1st representation followed by the 2nd in parenthesis)
For FT_BOOLEAN fields that are also bitfields, 'display' is used to tell
value of a field. You could think of those fields as having an
enumerated data type, rather than an integral data type.
-A 'value_string' structure is a way to map values to strings.
+A 'value_string' structure is a way to map values to strings.
typedef struct _value_string {
guint32 value;
For fields of that type, you would declare an array of "value_string"s:
static const value_string valstringname[] = {
- { INTVAL1, "Descriptive String 1" },
- { INTVAL2, "Descriptive String 2" },
+ { INTVAL1, "Descriptive String 1" },
+ { INTVAL2, "Descriptive String 2" },
{ 0, NULL }
};
For fields of that type, you would declare an array of "range_string"s:
static const range_string rvalstringname[] = {
- { INTVAL_MIN1, INTVALMAX1, "Descriptive String 1" },
- { INTVAL_MIN2, INTVALMAX2, "Descriptive String 2" },
+ { INTVAL_MIN1, INTVALMAX1, "Descriptive String 1" },
+ { INTVAL_MIN2, INTVALMAX2, "Descriptive String 2" },
{ 0, 0, NULL }
};
-If INTVAL_MIN equals INTVAL_MAX for a given entry the range_string
-behavior collapses to the one of value_string.
+If INTVAL_MIN equals INTVAL_MAX for a given entry the range_string
+behavior collapses to the one of value_string.
For FT_(U)INT* fields that need a 'range_string' struct, the 'strings' field
would be set to 'RVALS(rvalstringname)'. Furthermore, 'display' field must be
ORed with 'BASE_RANGE_STRING' (e.g. BASE_DEC|BASE_RANGE_STRING).
Its two fields are pointers to the string representing truth, and the
string representing falsehood. For FT_BOOLEAN fields that need a
'true_false_string' struct, the 'strings' field would be set to
-'TFS(&boolstringname)'.
+'TFS(&boolstringname)'.
If the Boolean field is to be displayed as "False" or "True", the
'strings' field would be set to NULL.
to have the compiler compute the array length for you at compile time.
If you don't have any fields to register, do *NOT* create a zero-length
-"hf" array; not all compilers used to compile Wireshark support them.
+"hf" array; not all compilers used to compile Wireshark support them.
Just omit the "hf" array, and the "proto_register_field_array()" call,
entirely.
proto_tree_add_item()
---------------------
-proto_tree_add_item is used when you wish to do no special formatting.
+proto_tree_add_item is used when you wish to do no special formatting.
The item added to the GUI tree will contain the name (as passed in the
proto_register_*() function) and a value. The value will be fetched
from the tvbuff by proto_tree_add_item(), based on the type of the field
and bitshifting, so it does the work of masking and shifting for us!
This also means that you no longer have to create value_string structs
with the values bitshifted. The value_string for FID looks like this,
-even though the FID value is actually contained in the high nibble.
+even though the FID value is actually contained in the high nibble.
(You'd expect the values to be 0x0, 0x10, 0x20, etc.)
/* Format Identifier */
included in a tree so that the packet can be filtered on this field, but
the representation of that field in the tree is not appropriate. An
example is the token-ring routing information field (RIF). The best way
-to show the RIF in a GUI is by a sequence of ring and bridge numbers.
+to show the RIF in a GUI is by a sequence of ring and bridge numbers.
Rings are 3-digit hex numbers, and bridges are single hex digits:
RIF: 001-A-013-9-C0F-B-555
protocol when the dissector routines wants complete control over how the
field and value will be represented on the GUI tree. The ID value for
the protocol is passed in as the "id" argument; the rest of the
-arguments are a "printf"-style format and any arguments for that format.
+arguments are a "printf"-style format and any arguments for that format.
The caller must include the name of the protocol in the format; it is
not added automatically as in proto_tree_add_item().
dissector routines wants complete control over how the value will be
represented on the GUI tree. The argument giving the value is the same
as the corresponding proto_tree_add_XXX() function; the rest of the
-arguments are a "printf"-style format and any arguments for that format.
+arguments are a "printf"-style format and any arguments for that format.
With these routines, unlike the proto_tree_add_XXX_format() routines,
the name of the field is added automatically as in the
proto_tree_add_XXX() functions; only the value is added with the format.
proto_tree_add_text()
---------------------
proto_tree_add_text() is used to add a label to the GUI tree. It will
-contain no value, so it is not searchable in the display filter process.
+contain no value, so it is not searchable in the display filter process.
This function was needed in the transition from the old-style proto_tree
to this new-style proto_tree so that Wireshark would still decode all
-protocols w/o being able to filter on all protocols and fields.
+protocols w/o being able to filter on all protocols and fields.
Otherwise we would have had to cripple Wireshark's functionality while we
converted all the old-style proto_tree calls to the new-style proto_tree
calls.
'proto_tree_add_text()', a 'printf'-style format string, and a set of
arguments corresponding to '%' format items in that string, and replaces
the text for the item created by 'proto_tree_add_text()' with the result
-of applying the arguments to the format string.
+of applying the arguments to the format string.
'proto_item_append_text()' is similar, but it appends to the text for
the item the result of applying the arguments to the format string.
proto_item_set_text(ti, "%s: %s", type, value);
-after the "type" and "value" fields have been extracted and dissected.
+after the "type" and "value" fields have been extracted and dissected.
<label> would be a label giving what information about the subtree is
available without dissecting any of the data in the subtree.
This function provides an easy to use and convenient helper function
to manage many types of common bitmasks that occur in protocols.
-This function will dissect a 1/2/3/4 byte large bitmask into its individual
+This function will dissect a 1/2/3/4 byte large bitmask into its individual
fields.
-header is an integer type and must be of type FT_[U]INT{8|16|24|32} and
+header is an integer type and must be of type FT_[U]INT{8|16|24|32} and
represents the entire width of the bitmask.
'header' and 'ett' are the hf fields and ett field respectively to create an
Each of the entries in '**fields' will be dissected as an item under the
'header' expansion and also IF the field is a booelan and IF it is set to 1,
then the name of that boolean field will be printed on the 'header' expansion
-line. For integer type subfields that have a value_string defined, the
+line. For integer type subfields that have a value_string defined, the
matched string from that value_string will be printed on the expansion line as well.
Example: (from the scsi dissector)
If the value 'val' is found in the 'value_string' table pointed to by
'vs', 'val_to_str' will return the corresponding string; otherwise, it
will use 'fmt' as an 'sprintf'-style format, with 'val' as an argument,
-to generate a string, and will return a pointer to that string.
+to generate a string, and will return a pointer to that string.
(Currently, it has three 64-byte static buffers, and cycles through
them; this permits the results of up to three calls to 'val_to_str' to
be passed as arguments to a routine using those strings.)
If the value 'val' is found in the 'range_string' table pointed to by
'rs', 'rval_to_str' will return the corresponding string; otherwise, it
will use 'fmt' as an 'sprintf'-style format, with 'val' as an argument,
-to generate a string, and will return a pointer to that string. Please
+to generate a string, and will return a pointer to that string. Please
note that its base behavior is inherited from match_strval().
1.8 Calling Other Dissectors.
tvbuff_t *next_tvb;
int reported_length, available_length;
-
+
/* Make the next tvbuff */
/* IPX does have a length value in the header, so calculate report_length */
*/
reported_length = ipx_length - IPX_HEADER_LEN;
-/* Calculate the available data in the packet,
+/* Calculate the available data in the packet,
set this to -1 to use all the data in the tv_buffer
*/
available_length = tvb_length(tvb) - IPX_HEADER_LEN;
described at <http://wiki.wireshark.org/FuzzTesting>.
- Subscribe to <mailto:wireshark-dev[AT]wireshark.org> by sending an email to
- <mailto:wireshark-dev-request[AT]wireshark.org?body="help"> or visiting
+ <mailto:wireshark-dev-request[AT]wireshark.org?body="help"> or visiting
<http://www.wireshark.org/lists/>.
-
+
- 'svn add' all the files of your new dissector.
-
+
- 'svn diff' the workspace and save the result to a file.
-
- - Edit the diff file - remove any changes unrelated to your new dissector,
+
+ - Edit the diff file - remove any changes unrelated to your new dissector,
e.g. changes in config.nmake
-
+
- Send a note with the attached diff file requesting its inclusion to
<mailto:wireshark-dev[AT]wireshark.org>. You can also use this procedure for
providing patches to your dissector or any other part of Wireshark.
- - Create a Wiki page on the protocol at <http://wiki.wireshark.org>.
+ - Create a Wiki page on the protocol at <http://wiki.wireshark.org>.
A template is provided so it is easy to setup in a consistent style.
- If possible, add sample capture files to the sample captures page at
If the NO_ADDR_B flag was specified to "find_conversation()", the
"addr_b" address will be treated as matching any "wildcarded" address;
if the NO_PORT_B flag was specified, the "port_b" port will be treated
-as matching any "wildcarded" port. If both flags are specified, i.e.
+as matching any "wildcarded" port. If both flags are specified, i.e.
NO_ADDR_B|NO_PORT_B, the "addr_b" address will be treated as matching
any "wildcarded" address and the "port_b" port will be treated as
matching any "wildcarded" port.
Where:
conversation_t *conv = the conversation in question
int proto = registered protocol number
-
+
"conversation" is the conversation created with conversation_new. "proto"
is a unique protocol number created with proto_register_protocol,
typically in the proto_register_XXXX portion of a dissector. The function
The conversation_delete_proto_data prototype:
void conversation_delete_proto_data(conversation_t *conv, int proto);
-
+
Where:
conversation_t *conv = the conversation in question
int proto = registered protocol number
identifier that is used to define the request. In this case the
conversation and the identifier are required to find the data storage
pointer. You can use the conversation data structure index value to
-uniquely define the conversation.
+uniquely define the conversation.
See packet-afs.c for an example of how to use the conversation index. In
this dissector multiple requests are sent in the same conversation. To store
information for each request the dissector has an internal hash table based
-upon the conversation index and values inside the request packets.
+upon the conversation index and values inside the request packets.
/* in the dissector routine */
NULL, 0);
}
- request_key.conversation = conversation->index;
+ request_key.conversation = conversation->index;
request_key.service = pntohs(&rxh->serviceId);
request_key.callnumber = pntohl(&rxh->callNumber);
registration.
For protocols that negotiate a secondary port connection, for example
-packet-msproxy.c, a conversation can install a dissector to handle
+packet-msproxy.c, a conversation can install a dissector to handle
the secondary protocol dissection. After the conversation is created
for the negotiated ports use the conversation_set_dissector to define
the dissection routine.
Before we create these conversations or assign a dissector to them we should
first check that the conversation does not already exist and if it exists
whether it is registered to our protocol or not.
-We should do this because is uncommon but it does happen that multiple
-different protocols can use the same socketpair during different stages of
+We should do this because is uncommon but it does happen that multiple
+different protocols can use the same socketpair during different stages of
an application cycle. By keeping track of the frame number a conversation
was started in wireshark can still tell these different protocols apart.
register_dissector takes as arguments a string giving a name for the
dissector, a pointer to the dissector function, and a protocol ID.
-The protocol ID is the ID for the protocol dissected by the function.
+The protocol ID is the ID for the protocol dissected by the function.
The function will not be called if the protocol has been disabled by the
user; instead, the data for the protocol will be dissected as raw data.
/* if conversation has a data field, create it and load structure */
-/* First check if a conversation already exists for this
+/* First check if a conversation already exists for this
socketpair
*/
- conversation = find_conversation(pinfo->fd->num,
- &pinfo->src, &pinfo->dst, protocol,
+ conversation = find_conversation(pinfo->fd->num,
+ &pinfo->src, &pinfo->dst, protocol,
src_port, dst_port, new_conv_info, 0);
-/* If there is no such conversation, or if there is one but for
+/* If there is no such conversation, or if there is one but for
someone else's protocol then we just create a new conversation
and assign our protocol to it.
*/
new_conv_info->data1 = value1;
/* create the conversation for the dynamic port */
- conversation = conversation_new(pinfo->fd->num,
+ conversation = conversation_new(pinfo->fd->num,
&pinfo->src, &pinfo->dst, protocol,
src_port, dst_port, new_conv_info, 0);
void
proto_register_PROTOABBREV(void)
-{
+{
...
sub_dissector_handle = create_dissector_handle(sub_dissector,
For protocols that define a server address and port for a secondary
protocol, a conversation can be used to link a protocol dissector to
-the server port and address. The key is to create the new
+the server port and address. The key is to create the new
conversation with the second address and port set to the "accept
-any" values.
+any" values.
-Some server applications can use the same port for different protocols during
+Some server applications can use the same port for different protocols during
different stages of a transaction. For example it might initially use SNMP
to perform some discovery and later switch to use TFTP using the same port.
-In order to handle this properly we must first check whether such a
+In order to handle this properly we must first check whether such a
conversation already exists or not and if it exists we also check whether the
registered dissector_handle for that conversation is "our" dissector or not.
-If not we create a new conversation on top of the previous one and set this new
+If not we create a new conversation on top of the previous one and set this new
conversation to use our protocol.
Since wireshark keeps track of the frame number where a conversation started
wireshark will still be able to keep the packets apart even though they do use
(See packet-tftp.c and packet-snmp.c for examples of this)
There are two support routines that will allow the second port and/or
-address to be set latter.
+address to be set latter.
conversation_set_port2( conversation_t *conv, guint32 port);
conversation_set_addr2( conversation_t *conv, address addr);
/* NOTE: The second address and port values don't matter because the */
/* NO_ADDR2 and NO_PORT2 options are set. */
-/* First check if a conversation already exists for this
+/* First check if a conversation already exists for this
IP/protocol/port
*/
- conversation = find_conversation(pinfo->fd->num,
- &server_src_addr, 0, protocol,
+ conversation = find_conversation(pinfo->fd->num,
+ &server_src_addr, 0, protocol,
server_src_port, 0, NO_ADDR2 | NO_PORT_B);
-/* If there is no such conversation, or if there is one but for
+/* If there is no such conversation, or if there is one but for
someone else's protocol then we just create a new conversation
and assign our protocol to it.
*/
if ( (conversation == NULL) ||
(conversation->dissector_handle != sub_dissector_handle) ) {
- conversation = conversation_new(pinfo->fd->num,
+ conversation = conversation_new(pinfo->fd->num,
&server_src_addr, 0, protocol,
server_src_port, 0, new_conv_info, NO_ADDR2 | NO_PORT2);
void *
p_get_proto_data(frame_data *fd, int proto)
-Where:
+Where:
fd - The fd pointer in the pinfo structure, pinfo->fd
proto - Protocol id returned by the proto_register_protocol call
during initialization
should not include the protocol name, as the name in
the preference file will already have it
title - Field title in the preferences dialog
- description - Comments added to the preference file above the
+ description - Comments added to the preference file above the
preference value
var - pointer to the storage location that is updated when the
field is changed in the preference dialog box
max_value - The maximum allowed value for a range (0 is the minimum).
An example from packet-beep.c -
-
+
proto_beep = proto_register_protocol("Blocks Extensible Exchange Protocol",
"BEEP", "beep");
" than the default of 10288)",
10, &global_beep_tcp_port);
- prefs_register_bool_preference(beep_module, "strict_header_terminator",
- "BEEP Header Requires CRLF",
+ prefs_register_bool_preference(beep_module, "strict_header_terminator",
+ "BEEP Header Requires CRLF",
"Specifies that BEEP requires CRLF as a "
"terminator, and not just CR or LF",
&global_beep_strict_term);
2.7 Reassembly/desegmentation for protocols running atop TCP.
There are two main ways of reassembling a Protocol Data Unit (PDU) which
-spans across multiple TCP segments. The first approach is simpler, but
-assumes you are running atop of TCP when this occurs (but your dissector
-might run atop of UDP, too, for example), and that your PDUs consist of a
-fixed amount of data that includes enough information to determine the PDU
-length, possibly followed by additional data. The second method is more
+spans across multiple TCP segments. The first approach is simpler, but
+assumes you are running atop of TCP when this occurs (but your dissector
+might run atop of UDP, too, for example), and that your PDUs consist of a
+fixed amount of data that includes enough information to determine the PDU
+length, possibly followed by additional data. The second method is more
generic but requires more code and is less efficient.
2.7.1 Using tcp_dissect_pdus().
get_dns_pdu_len, dissect_dns_tcp_pdu);
}
-(The dissect_dns_tcp_pdu function acts similarly to dissect_dns_udp.)
+(The dissect_dns_tcp_pdu function acts similarly to dissect_dns_udp.)
The arguments to tcp_dissect_pdus are:
the tvbuff pointer, packet_info pointer, and proto_tree pointer
2.7.2 Modifying the pinfo struct.
-The second reassembly mode is preferred when the dissector cannot determine
-how many bytes it will need to read in order to determine the size of a PDU.
+The second reassembly mode is preferred when the dissector cannot determine
+how many bytes it will need to read in order to determine the size of a PDU.
It may also be useful if your dissector needs to support reassembly from
protocols other than TCP.
pinfo->desegment_offset = offset;
pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
return;
- }
+ }
if (check_col(pinfo->cinfo, COL_INFO)) {
col_set_str(pinfo->cinfo, COL_INFO, "C String");
}
len += 1; /* Add one for the '\0' */
-
+
if (tree) {
proto_tree_add_item(tree, hf_cstring, tvb, offset, len, FALSE);
}
3. Delete the ptvcursor with ptvcursor_free()
To use the ptvcursor API, include the "ptvcursor.h" file. The PGM dissector
-is an example of how to use it. You don't need to look at it as a guide;
+is an example of how to use it. You don't need to look at it as a guide;
instead, the API description here should be good enough.
2.8.1 ptvcursor API.
*/
/*
- * The PN-IO protocol is a field bus protocol related to decentralized
- * periphery and is developed by the PROFIBUS Nutzerorganisation e.V. (PNO),
+ * The PN-IO protocol is a field bus protocol related to decentralized
+ * periphery and is developed by the PROFIBUS Nutzerorganisation e.V. (PNO),
* see: www.profibus.com
*
*
- * PN-IO is based on the common DCE-RPC and the "lightweight" PN-RT
+ * PN-IO is based on the common DCE-RPC and the "lightweight" PN-RT
* (ethernet type 0x8892) protocols.
*
- * The context manager (CM) part is handling context information
- * (like establishing, ...) and is using DCE-RPC as it's underlying
+ * The context manager (CM) part is handling context information
+ * (like establishing, ...) and is using DCE-RPC as it's underlying
* protocol.
*
- * The actual cyclic data transfer and acyclic notification uses the
+ * The actual cyclic data transfer and acyclic notification uses the
* "lightweight" PN-RT protocol.
*
- * There are some other related PROFINET protocols (e.g. PN-DCP, which is
+ * There are some other related PROFINET protocols (e.g. PN-DCP, which is
* handling addressing topics).
*
* Please note: the PROFINET CBA protocol is independant of the PN-IO protocol!
static int hf_pn_io_subslot = -1;
static int hf_pn_io_number_of_slots = -1;
static int hf_pn_io_number_of_subslots = -1;
-
+
static int hf_pn_io_maintenance_required_drop_budget = -1;
static int hf_pn_io_maintenance_demanded_drop_budget = -1;
static int hf_pn_io_error_drop_budget = -1;
static const value_string pn_io_index[] = {
/*0x0008 - 0x7FFF user specific */
-
+
/* subslot specific */
{ 0x8000, "ExpectedIdentificationData for one subslot" },
{ 0x8001, "RealIdentificationData for one subslot" },
* As the byte representation of these layers are different, this has to be handled
* in a somewhat different way than elsewhere. */
- dissect_dcerpc_uint8(tvb, offset+(0^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(0^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code, &u8ErrorCode);
- dissect_dcerpc_uint8(tvb, offset+(1^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(1^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_decode, &u8ErrorDecode);
switch(u8ErrorDecode) {
case(0x80): /* PNIORW */
- dissect_dcerpc_uint8(tvb, offset+(2^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(2^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code1_pniorw, &u8ErrorCode1);
error_code1_vals = pn_io_error_code1_pniorw;
/* u8ErrorCode2 for PNIORW is always user specific */
- dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code2_pniorw, &u8ErrorCode2);
error_code2_vals = pn_io_error_code2_pniorw;
break;
case(0x81): /* PNIO */
- dissect_dcerpc_uint8(tvb, offset+(2^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(2^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code1_pnio, &u8ErrorCode1);
error_code1_vals = pn_io_error_code1_pnio;
switch(u8ErrorCode1) {
case(22):
- dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code2_pnio_22, &u8ErrorCode2);
error_code2_vals = pn_io_error_code2_pnio_22;
break;
case(253):
- dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code2_pnio_253, &u8ErrorCode2);
error_code2_vals = pn_io_error_code2_pnio_253;
break;
default:
/* don't know this u8ErrorCode1 for PNIO, use defaults */
- dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code2, &u8ErrorCode2);
expert_add_info_format(pinfo, sub_item, PI_UNDECODED, PI_WARN,
"Unknown ErrorCode1 0x%x (for ErrorDecode==PNIO)", u8ErrorCode1);
}
break;
default:
- dissect_dcerpc_uint8(tvb, offset+(2^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(2^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code1, &u8ErrorCode1);
if(u8ErrorDecode!=0) {
expert_add_info_format(pinfo, sub_item, PI_UNDECODED, PI_WARN,
error_code1_vals = pn_io_error_code1;
/* don't know this u8ErrorDecode, use defaults */
- dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset+(3^bytemask), pinfo, sub_tree, drep,
hf_pn_io_error_code2, &u8ErrorCode2);
if(u8ErrorDecode != 0) {
expert_add_info_format(pinfo, sub_item, PI_UNDECODED, PI_WARN,
if (check_col(pinfo->cinfo, COL_INFO))
col_append_str(pinfo->cinfo, COL_INFO, ", OK");
} else {
- proto_item_append_text(sub_item, ": Error: \"%s\", \"%s\", \"%s\", \"%s\"",
+ proto_item_append_text(sub_item, ": Error: \"%s\", \"%s\", \"%s\", \"%s\"",
val_to_str(u8ErrorCode, pn_io_error_code, "(0x%x)"),
val_to_str(u8ErrorDecode, pn_io_error_decode, "(0x%x)"),
val_to_str(u8ErrorCode1, error_code1_vals, "(0x%x)"),
sub_item = proto_tree_add_item(tree, hf_pn_io_alarm_specifier, tvb, offset, 2, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_pdu_type);
- dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarm_specifier_sequence, &u16AlarmSpecifierSequence);
u16AlarmSpecifierSequence &= 0x07FF;
- dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarm_specifier_channel, &u16AlarmSpecifierChannel);
u16AlarmSpecifierChannel = (u16AlarmSpecifierChannel &0x0800) >> 11;
- dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarm_specifier_manufacturer, &u16AlarmSpecifierManufacturer);
u16AlarmSpecifierManufacturer = (u16AlarmSpecifierManufacturer &0x1000) >> 12;
- dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarm_specifier_submodule, &u16AlarmSpecifierSubmodule);
u16AlarmSpecifierSubmodule = (u16AlarmSpecifierSubmodule & 0x2000) >> 13;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarm_specifier_ardiagnosis, &u16AlarmSpecifierAR);
u16AlarmSpecifierAR = (u16AlarmSpecifierAR & 0x8000) >> 15;
- proto_item_append_text(sub_item, ", Sequence: %u, Channel: %u, Manuf: %u, Submodule: %u AR: %u",
- u16AlarmSpecifierSequence, u16AlarmSpecifierChannel,
+ proto_item_append_text(sub_item, ", Sequence: %u, Channel: %u, Manuf: %u, Submodule: %u AR: %u",
+ u16AlarmSpecifierSequence, u16AlarmSpecifierChannel,
u16AlarmSpecifierManufacturer, u16AlarmSpecifierSubmodule, u16AlarmSpecifierAR);
return offset;
guint16 u16SlotNr;
guint16 u16SubslotNr;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_alarm_type, &u16AlarmType);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
proto_item_append_text(item, ", %s, API:%u, Slot:0x%x/0x%x",
u32Api, u16SlotNr, u16SubslotNr);
if (check_col(pinfo->cinfo, COL_INFO))
- col_append_fstr(pinfo->cinfo, COL_INFO, ", %s, Slot: 0x%x/0x%x",
+ col_append_fstr(pinfo->cinfo, COL_INFO, ", %s, Slot: 0x%x/0x%x",
val_to_str(u16AlarmType, pn_io_alarm_type, "(0x%x)"),
u16SlotNr, u16SubslotNr);
static int
dissect_AlarmUserStructure(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree, proto_item *item, guint8 *drep,
+ packet_info *pinfo, proto_tree *tree, proto_item *item, guint8 *drep,
guint16 *body_length, guint16 u16UserStructureIdentifier)
{
guint16 u16ChannelNumber;
col_append_str(pinfo->cinfo, COL_INFO, ", Alarm Notification");*/
offset = dissect_Alarm_header(tvb, offset, pinfo, tree, item, drep);
-
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_module_ident_number, &u32ModuleIdentNumber);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_submodule_ident_number, &u32SubmoduleIdentNumber);
offset = dissect_Alarm_specifier(tvb, offset, pinfo, tree, drep);
/* x8 VendorIDHigh */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_vendor_id_high, &u8VendorIDHigh);
/* x8 VendorIDLow */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_vendor_id_low, &u8VendorIDLow);
/* c8[20] OrderID */
pOrderID = ep_alloc(20+1);
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_hardware_revision, &u16IMHardwareRevision);
/* c8 SWRevisionPrefix */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_revision_prefix, &u8SWRevisionPrefix);
/* x8 IM_SWRevision_Functional_Enhancement */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_sw_revision_functional_enhancement, &u8IMSWRevisionFunctionalEnhancement);
/* x8 IM_SWRevision_Bug_Fix */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_revision_bugfix, &u8IMSWRevisionBugFix);
/* x8 IM_SWRevision_Internal_Change */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_sw_revision_internal_change, &u8IMSWRevisionInternalChange);
/* x16 IM_Revision_Counter */
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_profile_specific_type, &u16IMProfileSpecificType);
/* x8 IM_Version_Major (values) */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_version_major, &u8IMVersionMajor);
/* x8 IM_Version_Minor (values) */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_im_version_minor, &u8IMVersionMinor);
/* x16 IM_Supported (bitfield) */
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
/* NumberOfAPIs */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
while(u16NumberOfAPIs--) {
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
/* NumberOfModules */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_modules, &u16NumberOfModules);
while(u16NumberOfModules--) {
u32ModuleStart = offset;
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* ModuleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_module_ident_number, &u32ModuleIdentNumber);
/* NumberOfSubmodules */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_number_of_submodules, &u16NumberOfSubmodules);
proto_item_append_text(module_item, ": Slot:%u, Ident:0x%x Submodules:%u",
subslot_tree = proto_item_add_subtree(subslot_item, ett_pn_io_subslot);
/* SubslotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, subslot_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, subslot_tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* SubmoduleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, subslot_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, subslot_tree, drep,
hf_pn_io_submodule_ident_number, &u32SubmoduleIdentNumber);
proto_item_append_text(subslot_item, ": Number:0x%x, Ident:0x%x",
proto_item *subslot_item;
proto_tree *subslot_tree;
-
+
if(u8BlockVersionLow == 1) {
/* NumberOfAPIs */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
}
while(u16NumberOfAPIs--) {
if(u8BlockVersionLow == 1) {
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
}
/* NumberOfSlots */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_slots, &u16NumberOfSlots);
proto_item_append_text(item, ", Slots:%u", u16NumberOfSlots);
u32SlotStart = offset;
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, slot_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, slot_tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* ModuleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, slot_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, slot_tree, drep,
hf_pn_io_module_ident_number, &u32ModuleIdentNumber);
/* NumberOfSubslots */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, slot_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, slot_tree, drep,
hf_pn_io_number_of_subslots, &u16NumberOfSubslots);
- proto_item_append_text(slot_item, ": SlotNr:%u Ident:0x%x Subslots:%u",
+ proto_item_append_text(slot_item, ": SlotNr:%u Ident:0x%x Subslots:%u",
u16SlotNr, u32ModuleIdentNumber, u16NumberOfSubslots);
while(u16NumberOfSubslots--) {
subslot_tree = proto_item_add_subtree(subslot_item, ett_pn_io_subslot);
/* SubslotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, subslot_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, subslot_tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* SubmoduleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, subslot_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, subslot_tree, drep,
hf_pn_io_submodule_ident_number, &u32SubmoduleIdentNumber);
proto_item_append_text(subslot_item, ": Number:0x%x, Ident:0x%x",
guint16 u16SubstitutionMode;
/* SubstitutionMode */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubstitutionMode);
-
-
+
+
/* SubstituteDataItem */
/* IOCS */
offset = dissect_PNIO_IOxS(tvb, offset, pinfo, tree, drep, hf_pn_io_iocs);
/* LengthIOCS */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_iocs, &u8LengthIOCS);
/* IOCS */
offset = dissect_PNIO_IOxS(tvb, offset, pinfo, tree, drep, hf_pn_io_iocs);
/* LengthIOPS */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_iops, &u8LengthIOPS);
/* IOPS */
offset = dissect_PNIO_IOxS(tvb, offset, pinfo, tree, drep, hf_pn_io_iops);
/* LengthData */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_data, &u16LengthData);
/* Data */
offset = dissect_pn_user_data(tvb, offset, pinfo, tree, u16LengthData, "Data");
/* SubstituteActiveFlag */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_substitute_active_flag, &u16SubstituteActiveFlag);
/* LengthIOCS */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_iocs, &u8LengthIOCS);
/* LengthIOPS */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_iops, &u8LengthIOPS);
/* LengthData */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_data, &u16LengthData);
/* DataItem (IOCS, Data, IOPS) */
offset = dissect_PNIO_IOxS(tvb, offset, pinfo, tree, drep, hf_pn_io_iocs);
guint16 u16SubslotNr;
guint16 u16SeqNr;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_seq_number, &u16SeqNr);
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_uuid, aruuid);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* padding doesn't match offset required for align4 */
- offset = dissect_pn_padding(tvb, offset, pinfo, tree, 2);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_pn_padding(tvb, offset, pinfo, tree, 2);
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_index, u16Index);
proto_item_append_text(item, ": Seq:%u, Api:0x%x, Slot:0x%x/0x%x",
if (check_col(pinfo->cinfo, COL_INFO))
col_append_fstr(pinfo->cinfo, COL_INFO, ", Api:0x%x, Slot:0x%x/0x%x, Index:%s",
- u32Api, u16SlotNr, u16SubslotNr,
+ u32Api, u16SlotNr, u16SubslotNr,
val_to_str(*u16Index, pn_io_index, "(0x%x)"));
return offset;
offset = dissect_ReadWrite_header(tvb, offset, pinfo, tree, item, drep, u16Index, &aruuid);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_record_data_length, u32RecDataLen);
memset(&null_uuid, 0, sizeof(e_uuid_t));
if(memcmp(&aruuid, &null_uuid, sizeof (e_uuid_t)) == 0) {
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_target_ar_uuid, &aruuid);
}
offset = dissect_ReadWrite_header(tvb, offset, pinfo, tree, item, drep, u16Index, &aruuid);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_record_data_length, u32RecDataLen);
memset(&null_uuid, 0, sizeof(e_uuid_t));
if(memcmp(&aruuid, &null_uuid, sizeof (e_uuid_t)) == 0) {
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_target_ar_uuid, &aruuid);
offset = dissect_pn_padding(tvb, offset, pinfo, tree, 8);
} else {
offset = dissect_ReadWrite_header(tvb, offset, pinfo, tree, item, drep, u16Index, &aruuid);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_record_data_length, u32RecDataLen);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_add_val1, &u16AddVal1);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_add_val2, &u16AddVal2);
offset = dissect_pn_padding(tvb, offset, pinfo, tree, 16);
- proto_item_append_text(item, ", Len:%u, AddVal1:%u, AddVal2:%u",
+ proto_item_append_text(item, ", Len:%u, AddVal1:%u, AddVal2:%u",
*u32RecDataLen, u16AddVal1, u16AddVal2);
if (check_col(pinfo->cinfo, COL_INFO) && *u32RecDataLen != 0)
offset = dissect_ReadWrite_header(tvb, offset, pinfo, tree, item, drep, u16Index, &aruuid);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_record_data_length, u32RecDataLen);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_add_val1, &u16AddVal1);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_add_val2, &u16AddVal2);
offset = dissect_pn_padding(tvb, offset, pinfo, tree, 20);
- proto_item_append_text(item, ", Len:%u, AddVal1:%u, AddVal2:%u",
+ proto_item_append_text(item, ", Len:%u, AddVal1:%u, AddVal2:%u",
*u32RecDataLen, u16AddVal1, u16AddVal2);
if (check_col(pinfo->cinfo, COL_INFO) && *u32RecDataLen != 0)
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_reserved16, NULL);
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_uuid, &ar_uuid);
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
proto_item_append_text(item, ": Slot:0x%x/0x%x", u16SlotNr, u16SubslotNr);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* LengthOwnPortID */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_own_port_id, &u8LengthOwnPortID);
/* OwnPortID */
pOwnPortID = ep_alloc(u8LengthOwnPortID+1);
offset += u8LengthOwnPortID;
/* NumberOfPeers */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_peers, &u8NumberOfPeers);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
u8I = u8NumberOfPeers;
while(u8I--) {
/* LengthPeerPortID */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_peer_port_id, &u8LengthPeerPortID);
/* PeerPortID */
pPeerPortID = ep_alloc(u8LengthPeerPortID+1);
offset += u8LengthPeerPortID;
/* LengthPeerChassisID */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_peer_chassis_id, &u8LengthPeerChassisID);
/* PeerChassisID */
pPeerChassisID = ep_alloc(u8LengthPeerChassisID+1);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* LineDelay */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_line_delay, &u32LineDelay);
/* PeerMACAddress */
- offset = dissect_pn_mac(tvb, offset, pinfo, tree,
+ offset = dissect_pn_mac(tvb, offset, pinfo, tree,
hf_pn_io_peer_macadd, mac);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
}
/* MAUType */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mau_type, &u16MAUType);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* DomainBoundary */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_domain_boundary, &u32DomainBoundary);
/* MulticastBoundary */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_multicast_boundary, &u32MulticastBoundary);
/* PortState */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_port_state, &u16PortState);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MediaType */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_media_type, &u32MediaType);
- proto_item_append_text(item, ": Slot:0x%x/0x%x, OwnPortID:%s, Peers:%u PortState:%s MediaType:%s",
+ proto_item_append_text(item, ": Slot:0x%x/0x%x, OwnPortID:%s, Peers:%u PortState:%s MediaType:%s",
u16SlotNr, u16SubslotNr, pOwnPortID, u8NumberOfPeers,
val_to_str(u16PortState, pn_io_port_state, "0x%x"),
val_to_str(u32MediaType, pn_io_media_type, "0x%x"));
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MRP_DomainUUID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_domain_uuid, &uuid);
/* MRP_Role */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_role, &u16Role);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* XXX - these fields will be added later */
/* MRP_LengthDomainName */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_length_domain_name, &u8LengthDomainName);
/* MRP_DomainName */
pDomainName = ep_alloc(u8LengthDomainName+1);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
-
+
offset = dissect_blocks(tvb, offset, pinfo, tree, drep);
return offset;
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MRP_DomainUUID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_domain_uuid, &uuid);
/* MRP_Role */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_role, &u16Role);
/* MRP_Version */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_version, &u16Version);
offset = dissect_blocks(tvb, offset, pinfo, tree, drep);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MRP_DomainUUID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_domain_uuid, &uuid);
/* MRP_Check */
/* XXX - this field is 32bit in the spec but 16 bit in the implementation */
/* this will be fixed in the next implementation release */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_check, &u16Check);
return offset;
}
-static int
+static int
dissect_PDPortMrpData_block(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item _U_, guint8 *drep)
{
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MRP_DomainUUID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_domain_uuid, &uuid);
return offset;
}
-static int
+static int
dissect_MrpManagerParams_block(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, proto_item *item _U_, guint8 *drep)
{
/* MRP_Prio */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_prio, &u16Prio);
/* MRP_TOPchgT */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_topchgt, &u16TOPchgT);
/* MRP_TOPNRmax */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_topnrmax, &u16TOPNRmax);
/* MRP_TSTshortT */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_tstshortt, &u16TSTshortT);
/* MRP_TSTdefaultT */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_tstdefaultt, &u16TSTdefaultT);
/* MSP_TSTNRmax */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_tstnrmax, &u16TSTNRmax);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
sub_item = proto_tree_add_item(tree, hf_pn_io_mrp_rtmode, tvb, offset, 4, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_mrp_rtmode);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_mrp_rtmode_reserved2, &u32RTMode);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_mrp_rtmode_reserved1, &u32RTMode);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_mrp_rtmode_rtclass3, &u32RTMode);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_mrp_rtmode_rtclass12, &u32RTMode);
return offset;
/* MSP_TSTNRmax */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_tstnrmax, &u16TSTNRmax);
/* MRP_TSTdefaultT */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_tstdefaultt, &u16TSTdefaultT);
/* Padding */
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MRP_RingState */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_ring_state, &u16RingState);
return offset;
/* MRP_RTState */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_rt_state, &u16RTState);
return offset;
/* MRP_LNKdownT */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_lnkdownt, &u16MRP_LNKdownT);
/* MRP_LNKupT */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_lnkupt, &u16MRP_LNKupT);
/* MRP_LNKNRmax u16 */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mrp_lnknrmax, &u16MRP_LNKNRmax);
return offset;
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* Boundary */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_domain_boundary, &u32DomainBoundary);
/* AdjustProperties */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_adjust_properties, &u16AdjustProperties);
- proto_item_append_text(item, ": Boundary:0x%x, Properties:0x%x",
+ proto_item_append_text(item, ": Boundary:0x%x, Properties:0x%x",
u32DomainBoundary, u16AdjustProperties);
return offset;
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* Boundary */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_multicast_boundary, &u32MulticastBoundary);
/* AdjustProperties */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_adjust_properties, &u16AdjustProperties);
- proto_item_append_text(item, ": Boundary:0x%x, Properties:0x%x",
+ proto_item_append_text(item, ": Boundary:0x%x, Properties:0x%x",
u32MulticastBoundary, u16AdjustProperties);
return offset;
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* MAUType */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mau_type, &u16MAUType);
/* AdjustProperties */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_adjust_properties, &u16AdjustProperties);
- proto_item_append_text(item, ": MAUType:%s, Properties:0x%x",
+ proto_item_append_text(item, ": MAUType:%s, Properties:0x%x",
val_to_str(u16MAUType, pn_io_mau_type, "0x%x"),
u16AdjustProperties);
/* MAUType */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mau_type, &u16MAUType);
- proto_item_append_text(item, ": MAUType:%s",
+ proto_item_append_text(item, ": MAUType:%s",
val_to_str(u16MAUType, pn_io_mau_type, "0x%x"));
return offset;
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* LineDelay */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_line_delay, &u32LineDelay);
proto_item_append_text(item, ": LineDelay:%uns", u32LineDelay);
/* NumberOfPeers */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_peers, &u8NumberOfPeers);
u8I = u8NumberOfPeers;
while(u8I--) {
/* LengthPeerPortID */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_peer_port_id, &u8LengthPeerPortID);
/* PeerPortID */
pPeerPortID = ep_alloc(u8LengthPeerPortID+1);
offset += u8LengthPeerPortID;
/* LengthPeerChassisID */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_peer_chassis_id, &u8LengthPeerChassisID);
/* PeerChassisID */
pPeerChassisID = ep_alloc(u8LengthPeerChassisID+1);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* PortState */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_port_state, &u16PortState);
/* AdjustProperties */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_adjust_properties, &u16AdjustProperties);
- proto_item_append_text(item, ": PortState:%s, Properties:0x%x",
+ proto_item_append_text(item, ": PortState:%s, Properties:0x%x",
val_to_str(u16PortState, pn_io_port_state, "0x%x"),
u16AdjustProperties);
/* PortState */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_port_state, &u16PortState);
- proto_item_append_text(item, ": %s",
+ proto_item_append_text(item, ": %s",
val_to_str(u16PortState, pn_io_port_state, "0x%x"));
return offset;
}
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* FiberOpticType */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_fiber_optic_type, &u32FiberOpticType);
/* FiberOpticCableType */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_fiber_optic_cable_type, &u32FiberOpticCableType);
/* optional: FiberOpticManufacturerSpecific */
/* x8 VendorIDHigh */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_vendor_id_high, &u8VendorIDHigh);
/* x8 VendorIDLow */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_vendor_id_low, &u8VendorIDLow);
/* VendorBlockType */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_vendor_block_type, &u16VendorBlockType);
/* Data */
offset = dissect_pn_user_data(tvb, offset, pinfo, tree, u16BodyLength-4, "Data");
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* FiberOpticType */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_fiber_optic_type, &u32FiberOpticType);
/* FiberOpticCableType */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_fiber_optic_cable_type, &u32FiberOpticCableType);
/*
- proto_item_append_text(item, ": %s",
+ proto_item_append_text(item, ": %s",
val_to_str(u16PortState, pn_io_port_state, "0x%x"));*/
return offset;
/* MaintenanceRequiredPowerBudget */
/* XXX - decode the u32FiberOpticPowerBudget better */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_maintenance_required_power_budget, &u32FiberOpticPowerBudget);
/* MaintenanceDemandedPowerBudget */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_maintenance_demanded_power_budget, &u32FiberOpticPowerBudget);
/* ErrorPowerBudget */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_error_power_budget, &u32FiberOpticPowerBudget);
/*
- proto_item_append_text(item, ": %s",
+ proto_item_append_text(item, ": %s",
val_to_str(u16PortState, pn_io_port_state, "0x%x"));*/
return offset;
/* MaintenanceRequiredDropBudget */
/* XXX - decode the u32NCDropBudget better */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_maintenance_required_drop_budget, &u32NCDropBudget);
/* MaintenanceDemandedDropBudget */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_maintenance_demanded_drop_budget, &u32NCDropBudget);
/* ErrorDropBudget */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_error_drop_budget, &u32NCDropBudget);
/*
- proto_item_append_text(item, ": %s",
+ proto_item_append_text(item, ": %s",
val_to_str(u16PortState, pn_io_port_state, "0x%x"));*/
return offset;
/* LengthOwnChassisID */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_length_own_chassis_id, &u8LengthOwnChassisID);
/* OwnChassisID */
pOwnChassisID = ep_alloc(u8LengthOwnChassisID+1);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* PTCPSubdomainID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ptcp_subdomain_id, &uuid);
/* IRDataID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ir_data_id, &uuid);
/* ReservedIntervalBegin */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_reserved_interval_begin, &u32ReservedIntervalBegin);
/* ReservedIntervalEnd */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_reserved_interval_end, &u32ReservedIntervalEnd);
/* PLLWindow enum */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_pllwindow, &u32PLLWindow);
/* SyncSendFactor 32 enum */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_sync_send_factor, &u32SyncSendFactor);
/* SendClockFactor 16 */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_send_clock_factor, &u16SendClockFactor);
/* SyncProperties 16 bitfield */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_sync_properties, &u16SyncProperties);
/* SyncFrameAddress 16 bitfield */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_sync_frame_address, &u16SyncFrameAddress);
/* PTCPTimeoutFactor 16 enum */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_ptcp_timeout_factor, &u16PTCPTimeoutFactor);
proto_item_append_text(item, ": Slot:0x%x/0x%x, Interval:%u-%u, PLLWin:%u, Send:%u, Clock:%u",
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
proto_item_append_text(item, ": Slot:0x%x/0x%x",
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* IRDataID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ir_data_id, &uuid);
return offset;
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* FrameSendOffset */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_frame_send_offset, &u32FrameSendOffset);
/* DataLength */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_data_length, &u16DataLength);
/* ReductionRatio */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_reduction_ratio, &u16ReductionRatio);
/* Phase */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_phase, &u16Phase);
/* FrameID */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_frame_id, &u16FrameID);
/* Ethertype */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_ethertype, &u16Ethertype);
/* RxPort */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_rx_port, &u8RXPort);
/* FrameDetails */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_frame_details, &u8FrameDetails);
/* TxPortGroup */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, tree, drep,
hf_pn_io_nr_of_tx_port_groups, &u8NumberOfTxPortGroups);
/* dissect the DiagnosisData block */
static int
dissect_DiagnosisData_block(tvbuff_t *tvb, int offset,
- packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, guint8 *drep _U_, guint16 body_length,
+ packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, guint8 *drep _U_, guint16 body_length,
guint8 u8BlockVersionLow)
{
guint32 u32Api;
if(u8BlockVersionLow == 1) {
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
body_length-=4;
}
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* ChannelNumber */
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_channel_number, &u16ChannelNumber);
- /* ChannelProperties */
+ /* ChannelProperties */
offset = dissect_ChannelProperties(tvb, offset, pinfo, tree, item, drep);
body_length-=8;
/* the rest of the block contains optional: [MaintenanceItem] and/or [AlarmItem] */
while(body_length) {
- offset = dissect_AlarmUserStructure(tvb, offset, pinfo, tree, item, drep,
+ offset = dissect_AlarmUserStructure(tvb, offset, pinfo, tree, item, drep,
&body_length, u16UserStructureIdentifier);
}
sub_item = proto_tree_add_item(tree, hf_pn_io_ar_properties, tvb, offset, 4, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_ar_properties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_pull_module_alarm_allowed, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_reserved, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_achnowledge_companion_ar, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_companion_ar, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_device_access, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_reserved_1, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_data_rate, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_parametrization_server, &u32ARProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_supervisor_takeover_allowed, &u32ARProperties);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_ar_properties_state, &u32ARProperties);
-
+
return offset;
}
sub_item = proto_tree_add_item(tree, hf_pn_io_iocr_properties, tvb, offset, 4, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_iocr_properties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_iocr_properties_reserved_2, &u32IOCRProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_iocr_properties_media_redundancy, &u32IOCRProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_iocr_properties_reserved_1, &u32IOCRProperties);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_iocr_properties_rtclass, &u32IOCRProperties);
return offset;
proto_tree *iocr_tree;
guint32 u32IOCRStart;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_ars, &u16NumberOfARs);
while(u16NumberOfARs--) {
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_uuid, &aruuid);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_type, &u16ARType);
offset = dissect_ARProperties(tvb, offset, pinfo, tree, item, drep);
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_cminitiator_objectuuid, &uuid);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_station_name_length, &u16NameLength);
pStationName = ep_alloc(u16NameLength+1);
tvb_memcpy(tvb, (guint8 *) pStationName, offset, u16NameLength);
proto_tree_add_string (tree, hf_pn_io_cminitiator_station_name, tvb, offset, u16NameLength, pStationName);
offset += u16NameLength;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_iocrs, &u16NumberOfIOCRs);
while(u16NumberOfIOCRs--) {
iocr_tree = proto_item_add_subtree(iocr_item, ett_pn_io_iocr);
u32IOCRStart = offset;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
hf_pn_io_iocr_type, &u16IOCRType);
offset = dissect_IOCRProperties(tvb, offset, pinfo, iocr_tree, drep);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
hf_pn_io_frame_id, &u16FrameID);
proto_item_append_text(iocr_item, ": FrameID:0x%x", u16FrameID);
/* add cycle counter */
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
hf_pn_io_cycle_counter, &u16CycleCounter);
-
+
u8DataStatus = tvb_get_guint8(tvb, offset);
u8TransferStatus = tvb_get_guint8(tvb, offset+1);
/* add data status subtree */
- ds_item = proto_tree_add_uint_format(iocr_tree, hf_pn_io_data_status,
+ ds_item = proto_tree_add_uint_format(iocr_tree, hf_pn_io_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",
/* add transfer status */
if (u8TransferStatus) {
proto_tree_add_uint_format(iocr_tree, hf_pn_io_transfer_status, tvb,
- offset, 1, u8TransferStatus,
+ offset, 1, u8TransferStatus,
"TransferStatus: 0x%02x (ignore this frame)", u8TransferStatus);
} else {
proto_tree_add_uint_format(iocr_tree, hf_pn_io_transfer_status, tvb,
- offset, 1, u8TransferStatus,
+ offset, 1, u8TransferStatus,
"TransferStatus: 0x%02x (OK)", u8TransferStatus);
}
offset++;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
hf_pn_io_cminitiator_udprtport, &u16UDPRTPort);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, iocr_tree, drep,
hf_pn_io_cmresponder_udprtport, &u16UDPRTPort);
proto_item_set_len(iocr_item, offset - u32IOCRStart);
}
/* AlarmCRType */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_alarmcr_type, &u16AlarmCRType);
/* LocalAlarmReference */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_localalarmref, &u16LocalAlarmReference);
/* RemoteAlarmReference */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_remotealarmref, &u16RemoteAlarmReference);
/* ParameterServerObjectUUID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_parameter_server_objectuuid, &uuid);
/* StationNameLength */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_station_name_length, &u16NameLength);
/* ParameterServerStationName */
pStationName = ep_alloc(u16NameLength+1);
proto_tree_add_string (tree, hf_pn_io_parameter_server_station_name, tvb, offset, u16NameLength, pStationName);
offset += u16NameLength;
/* NumberOfAPIs */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
}
/* NumberOfAPIs */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
while(u16NumberOfAPIs--) {
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
}
/* ActualLocalTimeStamp */
- offset = dissect_dcerpc_uint64(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint64(tvb, offset, pinfo, tree, drep,
hf_pn_io_actual_local_time_stamp, &u64ActualLocaltimeStamp);
/* NumberOfLogEntries */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_log_entries, &u16NumberOfLogEntries);
while(u16NumberOfLogEntries--) {
/* LocalTimeStamp */
- offset = dissect_dcerpc_uint64(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint64(tvb, offset, pinfo, tree, drep,
hf_pn_io_local_time_stamp, &u64LocaltimeStamp);
/* ARUUID */
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_uuid, &aruuid);
/* PNIOStatus */
offset = dissect_PNIO_status(tvb, offset, pinfo, tree, drep);
/* EntryDetail */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_entry_detail, &u32EntryDetail);
}
char *pStationName;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_type, &u16ARType);
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_uuid, &uuid);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_sessionkey, &u16SessionKey);
- offset = dissect_pn_mac(tvb, offset, pinfo, tree,
+ offset = dissect_pn_mac(tvb, offset, pinfo, tree,
hf_pn_io_cminitiator_macadd, mac);
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_cminitiator_objectuuid, &uuid);
offset = dissect_ARProperties(tvb, offset, pinfo, tree, item, drep);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_cminitiator_activitytimeoutfactor, &u16TimeoutFactor); /* XXX - special values */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_cminitiator_udprtport, &u16UDPRTPort);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_station_name_length, &u16NameLength);
pStationName = ep_alloc(u16NameLength+1);
guint16 u16UDPRTPort;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_type, &u16ARType);
- offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
hf_pn_io_ar_uuid, &uuid);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_sessionkey, &u16SessionKey);
- offset = dissect_pn_mac(tvb, offset, pinfo, tree,
+ offset = dissect_pn_mac(tvb, offset, pinfo, tree,
hf_pn_io_cmresponder_macadd, mac);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_cmresponder_udprtport, &u16UDPRTPort);
proto_item_append_text(item, ": %s, Session:%u, MAC:%02x:%02x:%02x:%02x:%02x:%02x, Port:0x%x",
val_to_str(u16ARType, pn_io_ar_type, "0x%x"),
- u16SessionKey,
+ u16SessionKey,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
u16UDPRTPort);
guint32 u32SubStart;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_iocr_type, &u16IOCRType);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_iocr_reference, &u16IOCRReference);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_lt, &u16LT);
offset = dissect_IOCRProperties(tvb, offset, pinfo, tree, drep);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_data_length, &u16DataLength);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_frame_id, &u16FrameID);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_send_clock_factor, &u16SendClockFactor);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_reduction_ratio, &u16ReductionRatio);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_phase, &u16Phase);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_sequence, &u16Sequence);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_frame_send_offset, &u32FrameSendOffset);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_watchdog_factor, &u16WatchdogFactor);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_data_hold_factor, &u16DataHoldFactor);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_iocr_tag_header, &u16IOCRTagHeader);
- offset = dissect_pn_mac(tvb, offset, pinfo, tree,
+ offset = dissect_pn_mac(tvb, offset, pinfo, tree,
hf_pn_io_iocr_multicast_mac_add, mac);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
proto_item_append_text(item, ": %s, Ref:0x%x, Len:%u, FrameID:0x%x, Clock:%u, Ratio:%u, Phase:%u APIs:%u",
val_to_str(u16IOCRType, pn_io_iocr_type, "0x%x"),
- u16IOCRReference, u16DataLength, u16FrameID,
+ u16IOCRReference, u16DataLength, u16FrameID,
u16SendClockFactor, u16ReductionRatio, u16Phase, u16NumberOfAPIs);
while(u16NumberOfAPIs--) {
u32ApiStart = offset;
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_api, &u32Api);
/* NumberOfIODataObjects */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_number_of_io_data_objects, &u16NumberOfIODataObjects);
u16Tmp = u16NumberOfIODataObjects;
u32SubStart = offset;
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* IODataObjectFrameOffset */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_io_data_object_frame_offset, &u16IODataObjectFrameOffset);
- proto_item_append_text(sub_item, ": Slot: 0x%x, Subslot: 0x%x FrameOffset: %u",
+ proto_item_append_text(sub_item, ": Slot: 0x%x, Subslot: 0x%x FrameOffset: %u",
u16SlotNr, u16SubslotNr, u16IODataObjectFrameOffset);
proto_item_set_len(sub_item, offset - u32SubStart);
}
/* NumberOfIOCS */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_number_of_iocs, &u16NumberOfIOCS);
u16Tmp = u16NumberOfIOCS;
u32SubStart = offset;
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* IOCSFrameOffset */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_iocs_frame_offset, &u16IOCSFrameOffset);
- proto_item_append_text(sub_item, ": Slot: 0x%x, Subslot: 0x%x FrameOffset: %u",
+ proto_item_append_text(sub_item, ": Slot: 0x%x, Subslot: 0x%x FrameOffset: %u",
u16SlotNr, u16SubslotNr, u16IOCSFrameOffset);
proto_item_set_len(sub_item, offset - u32SubStart);
}
- proto_item_append_text(api_item, ": %u, NumberOfIODataObjects: %u NumberOfIOCS: %u",
+ proto_item_append_text(api_item, ": %u, NumberOfIODataObjects: %u NumberOfIOCS: %u",
u32Api, u16NumberOfIODataObjects, u16NumberOfIOCS);
proto_item_set_len(api_item, offset - u32ApiStart);
proto_tree *sub_tree;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_alarmcr_type, &u16AlarmCRType);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_lt, &u16LT);
-
+
sub_item = proto_tree_add_item(tree, hf_pn_io_alarmcr_properties, tvb, offset, 4, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_alarmcr_properties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarmcr_properties_reserved, &u32AlarmCRProperties);
- dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarmcr_properties_transport, &u32AlarmCRProperties);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_alarmcr_properties_priority, &u32AlarmCRProperties);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_rta_timeoutfactor, &u16RTATimeoutFactor);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_rta_retries, &u16RTARetries);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_localalarmref, &u16LocalAlarmReference);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_maxalarmdatalength, &u16MaxAlarmDataLength);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_alarmcr_tagheaderhigh, &u16AlarmCRTagHeaderHigh);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_alarmcr_tagheaderlow, &u16AlarmCRTagHeaderLow);
proto_item_append_text(item, ": %s, LT:0x%x, TFactor:%u, Retries:%u, Ref:0x%x, Len:%u Tag:0x%x/0x%x",
guint16 u16MaxAlarmDataLength;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_alarmcr_type, &u16AlarmCRType);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_localalarmref, &u16LocalAlarmReference);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_maxalarmdatalength, &u16MaxAlarmDataLength);
proto_item_append_text(item, ": %s, Ref:0x%04x, MaxDataLen:%u",
guint16 u16FrameID;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_iocr_type, &u16IOCRType);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_iocr_reference, &u16IOCRReference);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_frame_id, &u16FrameID);
proto_item_append_text(item, ": %s, Ref:0x%04x, FrameID:0x%04x",
char *pStationName;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_iocr_reference, &u16IOCRReference);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_address_resolution_properties, &u32AddressResolutionProperties);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_mci_timeout_factor, &u16MCITimeoutFactor);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_station_name_length, &u16NameLength);
pStationName = ep_alloc(u16NameLength+1);
tvb_memcpy(tvb, (guint8 *) pStationName, offset, u16NameLength);
pStationName[u16NameLength] = '\0';
proto_tree_add_string (tree, hf_pn_io_provider_station_name, tvb, offset, u16NameLength, pStationName);
- offset += u16NameLength;
+ offset += u16NameLength;
proto_item_append_text(item, ", CRRef:%u, Properties:0x%x, TFactor:%u, Station:%s",
u16IOCRReference, u32AddressResolutionProperties, u16MCITimeoutFactor, pStationName);
u32SubStart = offset;
/* DataDescription */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_data_description, &u16DataDescription);
/* SubmoduleDataLength */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_submodule_data_length, &u16SubmoduleDataLength);
/* LengthIOCS */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_length_iocs, &u8LengthIOCS);
/* LengthIOPS */
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_length_iops, &u8LengthIOPS);
- proto_item_append_text(sub_item, ": %s, SubmoduleDataLength: %u, LengthIOCS: %u, u8LengthIOPS: %u",
- val_to_str(u16DataDescription, pn_io_data_description, "(0x%x)"),
+ proto_item_append_text(sub_item, ": %s, SubmoduleDataLength: %u, LengthIOCS: %u, u8LengthIOPS: %u",
+ val_to_str(u16DataDescription, pn_io_data_description, "(0x%x)"),
u16SubmoduleDataLength, u8LengthIOCS, u8LengthIOPS);
proto_item_set_len(sub_item, offset - u32SubStart);
guint32 u32SubStart;
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
proto_item_append_text(item, ": APIs:%u", u16NumberOfAPIs);
u32ApiStart = offset;
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_api, &u32Api);
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* ModuleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_module_ident_number, &u32ModuleIdentNumber);
/* ModuleProperties */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_module_properties, &u16ModuleProperties);
/* NumberOfSubmodules */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_number_of_submodules, &u16NumberOfSubmodules);
- proto_item_append_text(api_item, ": %u, Slot:0x%x, IdentNumber:0x%x Properties:0x%x Submodules:%u",
+ proto_item_append_text(api_item, ": %u, Slot:0x%x, IdentNumber:0x%x Properties:0x%x Submodules:%u",
u32Api, u16SlotNr, u32ModuleIdentNumber, u16ModuleProperties, u16NumberOfSubmodules);
proto_item_append_text(item, ", Submodules:%u", u16NumberOfSubmodules);
u32SubStart = offset;
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* SubmoduleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_submodule_ident_number, &u32SubmoduleIdentNumber);
/* SubmoduleProperties */
submodule_item = proto_tree_add_item(sub_tree, hf_pn_io_submodule_properties, tvb, offset, 2, FALSE);
submodule_tree = proto_item_add_subtree(submodule_item, ett_pn_io_submodule_properties);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_properties_reserved, &u16SubmoduleProperties);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_properties_discard_ioxs, &u16SubmoduleProperties);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_properties_reduce_output_submodule_data_length, &u16SubmoduleProperties);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_properties_reduce_input_submodule_data_length, &u16SubmoduleProperties);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_properties_shared_input, &u16SubmoduleProperties);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_properties_type, &u16SubmoduleProperties);
switch(u16SubmoduleProperties & 0x03) {
break;
}
- proto_item_append_text(sub_item, ": Subslot:0x%x, Ident:0x%x Properties:0x%x",
+ proto_item_append_text(sub_item, ": Subslot:0x%x, Ident:0x%x Properties:0x%x",
u16SubslotNr, u32SubmoduleIdentNumber, u16SubmoduleProperties);
proto_item_set_len(sub_item, offset - u32SubStart);
}
/* NumberOfAPIs */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_number_of_apis, &u16NumberOfAPIs);
proto_item_append_text(item, ": APIs:%u", u16NumberOfAPIs);
-
+
while(u16NumberOfAPIs--) {
api_item = proto_tree_add_item(tree, hf_pn_io_api_tree, tvb, offset, 0, FALSE);
api_tree = proto_item_add_subtree(api_item, ett_pn_io_api);
u32ApiStart = offset;
/* API */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_api, &u32Api);
/* NumberOfModules */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, api_tree, drep,
hf_pn_io_number_of_modules, &u16NumberOfModules);
- proto_item_append_text(api_item, ": %u, Modules: %u",
+ proto_item_append_text(api_item, ": %u, Modules: %u",
u32Api, u16NumberOfModules);
proto_item_append_text(item, ", Modules:%u", u16NumberOfModules);
u32ModuleStart = offset;
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* ModuleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_module_ident_number, &u32ModuleIdentNumber);
/* ModuleState */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_module_state, &u16ModuleState);
/* NumberOfSubmodules */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, module_tree, drep,
hf_pn_io_number_of_submodules, &u16NumberOfSubmodules);
- proto_item_append_text(module_item, ": Slot 0x%x, Ident: 0x%x State: %s Submodules: %u",
- u16SlotNr, u32ModuleIdentNumber,
- val_to_str(u16ModuleState, pn_io_module_state, "(0x%x)"),
+ proto_item_append_text(module_item, ": Slot 0x%x, Ident: 0x%x State: %s Submodules: %u",
+ u16SlotNr, u32ModuleIdentNumber,
+ val_to_str(u16ModuleState, pn_io_module_state, "(0x%x)"),
u16NumberOfSubmodules);
proto_item_append_text(item, ", Submodules:%u", u16NumberOfSubmodules);
u32SubStart = offset;
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* SubmoduleIdentNumber */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_submodule_ident_number, &u32SubmoduleIdentNumber);
/* SubmoduleState */
submodule_item = proto_tree_add_item(sub_tree, hf_pn_io_submodule_state, tvb, offset, 2, FALSE);
submodule_tree = proto_item_add_subtree(submodule_item, ett_pn_io_submodule_state);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_format_indicator, &u16SubmoduleState);
if(u16SubmoduleState & 0x8000) {
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_ident_info, &u16SubmoduleState);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_ar_info, &u16SubmoduleState);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_diag_info, &u16SubmoduleState);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_maintenance_demanded, &u16SubmoduleState);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_maintenance_required, &u16SubmoduleState);
- dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_qualified_info, &u16SubmoduleState);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_add_info, &u16SubmoduleState);
} else {
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, submodule_tree, drep,
hf_pn_io_submodule_state_detail, &u16SubmoduleState);
}
- proto_item_append_text(sub_item, ": Subslot 0x%x, IdentNumber: 0x%x, State: 0x%x",
+ proto_item_append_text(sub_item, ": Subslot 0x%x, IdentNumber: 0x%x, State: 0x%x",
u16SubslotNr, u32SubmoduleIdentNumber, u16SubmoduleState);
proto_item_set_len(sub_item, offset - u32SubStart);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
/* SlotNumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
/* Subslotnumber */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
/* ControllerApplicationCycleFactor */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_controller_appl_cycle_factor, &u16ControllerApplicationCycleFactor);
/* TimeDataCycle */
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_time_data_cycle, &u16TimeDataCycle);
/* TimeIOInput (ns) */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_time_io_input, &u32TimeIOInput);
/* TimeIOOutput (ns) */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_time_io_output, &u32TimeIOOutput);
/* TimeIOInputValid (ns) */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_time_io_input_valid, &u32TimeIOInputValid);
/* TimeIOOutputValid (ns) */
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_time_io_output_valid, &u32TimeIOOutputValid);
offset = dissect_pn_align4(tvb, offset, pinfo, tree);
- offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_api, &u32Api);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_slot_nr, &u16SlotNr);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, tree, drep,
hf_pn_io_subslot_nr, &u16SubslotNr);
- proto_item_append_text(item, ": Api:0x%x Slot:%u Subslot:0x%x",
+ proto_item_append_text(item, ": Api:0x%x Slot:%u Subslot:0x%x",
u32Api, u16SlotNr, u16SubslotNr);
tvb_new = tvb_new_subset(tvb, offset, u16BodyLength-10, u16BodyLength-10);
/* dissect the RecordDataReadQuery block */
static int
dissect_RecordDataReadQuery_block(tvbuff_t *tvb, int offset,
- packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, guint8 *drep _U_,
+ packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, guint8 *drep _U_,
guint16 u16Index, guint16 u16BodyLength)
{
const gchar *userProfile;
header_item = proto_tree_add_item(sub_tree, hf_pn_io_block_header, tvb, offset, 6, FALSE);
header_tree = proto_item_add_subtree(header_item, ett_pn_io_block_header);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, header_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, header_tree, drep,
hf_pn_io_block_type, &u16BlockType);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, header_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, header_tree, drep,
hf_pn_io_block_length, &u16BlockLength);
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, header_tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, header_tree, drep,
hf_pn_io_block_version_high, &u8BlockVersionHigh);
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, header_tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, header_tree, drep,
hf_pn_io_block_version_low, &u8BlockVersionLow);
- proto_item_append_text(header_item, ": Type=%s, Length=%u(+4), Version=%u.%u",
+ proto_item_append_text(header_item, ": Type=%s, Length=%u(+4), Version=%u.%u",
val_to_str(u16BlockType, pn_io_block_type, "Unknown (0x%04x)"),
u16BlockLength, u8BlockVersionHigh, u8BlockVersionLow);
- proto_item_append_text(sub_item, "%s",
+ proto_item_append_text(sub_item, "%s",
val_to_str(u16BlockType, pn_io_block_type, "Unknown (0x%04x)"));
if (check_col(pinfo->cinfo, COL_INFO))
break;
case(0x0207):
dissect_PDIRFrameData_block(tvb, offset, pinfo, sub_tree, sub_item, drep);
- break;
+ break;
case(0x0209):
dissect_AdjustDomainBoundary_block(tvb, offset, pinfo, sub_tree, sub_item, drep);
break;
{
guint16 u16Index = 0;
guint32 u32RecDataLen;
-
+
while(tvb_length(tvb) > (guint) offset) {
offset = dissect_block(tvb, offset, pinfo, tree, drep, &u16Index, &u32RecDataLen);
col_add_str(pinfo->cinfo, COL_PROTOCOL, "PNIO-CM");
/* args_max */
- offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_args_max, &u32ArgsMax);
/* args_len */
- offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_args_len, &u32ArgsLen);
sub_item = proto_tree_add_item(tree, hf_pn_io_array, tvb, offset, 0, FALSE);
u32SubStart = offset;
/* RPC array header */
- offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_array_max_count, &u32MaxCount);
- offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_array_offset, &u32Offset);
- offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_array_act_count, &u32ArraySize);
- proto_item_append_text(sub_item, ": Max: %u, Offset: %u, Size: %u",
+ proto_item_append_text(sub_item, ": Max: %u, Offset: %u, Size: %u",
u32MaxCount, u32Offset, u32ArraySize);
proto_item_set_len(sub_item, offset - u32SubStart);
offset = dissect_PNIO_status(tvb, offset, pinfo, tree, drep);
/* args_len */
- offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, drep,
hf_pn_io_args_len, &u32ArgsLen);
sub_item = proto_tree_add_item(tree, hf_pn_io_array, tvb, offset, 0, FALSE);
u32SubStart = offset;
/* RPC array header */
- offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_array_max_count, &u32MaxCount);
- offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_array_offset, &u32Offset);
- offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_ndr_uint32(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_array_act_count, &u32ArraySize);
- proto_item_append_text(sub_item, ": Max: %u, Offset: %u, Size: %u",
+ proto_item_append_text(sub_item, ": Max: %u, Offset: %u, Size: %u",
u32MaxCount, u32Offset, u32ArraySize);
proto_item_set_len(sub_item, offset - u32SubStart);
dissect_IPNIO_rqst(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree, guint8 *drep)
{
-
+
offset = dissect_IPNIO_rqst_header(tvb, offset, pinfo, tree, drep);
offset = dissect_blocks(tvb, offset, pinfo, tree, drep);
case(0x802f): /* PDPortDataAdjust */
case(0x8030): /* IsochronousModeData for one subslot */
case(0x8031): /* Expected PDSyncData for one subslot with SyncID value 1 */
- case(0x8032):
- case(0x8033):
- case(0x8034):
- case(0x8035):
- case(0x8036):
- case(0x8037):
- case(0x8038):
- case(0x8039):
- case(0x803a):
- case(0x803b):
- case(0x803c):
- case(0x803d):
- case(0x803e):
- case(0x803f):
+ case(0x8032):
+ case(0x8033):
+ case(0x8034):
+ case(0x8035):
+ case(0x8036):
+ case(0x8037):
+ case(0x8038):
+ case(0x8039):
+ case(0x803a):
+ case(0x803b):
+ case(0x803c):
+ case(0x803d):
+ case(0x803e):
+ case(0x803f):
case(0x8040): /* Expected PDSyncData for one subslot with SyncID value 2 ... 30 */
- case(0x8041):
- case(0x8042):
- case(0x8043):
- case(0x8044):
- case(0x8045):
- case(0x8046):
- case(0x8047):
- case(0x8048):
- case(0x8049):
- case(0x804a):
- case(0x804b):
- case(0x804c):
- case(0x804d):
- case(0x804e):
+ case(0x8041):
+ case(0x8042):
+ case(0x8043):
+ case(0x8044):
+ case(0x8045):
+ case(0x8046):
+ case(0x8047):
+ case(0x8048):
+ case(0x8049):
+ case(0x804a):
+ case(0x804b):
+ case(0x804c):
+ case(0x804d):
+ case(0x804e):
case(0x804f): /* Expected PDSyncData for one subslot with SyncID value 31 */
case(0xc000): /* ExpectedIdentificationData for one slot */
/* add ioxs subtree */
ioxs_item = proto_tree_add_uint(tree, hfindex, tvb, offset, 1, u8IOxS);
proto_item_append_text(ioxs_item,
- " (%s%s)",
+ " (%s%s)",
(u8IOxS & 0x01) ? "another IOxS follows " : "",
(u8IOxS & 0x80) ? "good" : "bad");
ioxs_tree = proto_item_add_subtree(ioxs_item, ett_pn_io_ioxs);
if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_add_str(pinfo->cinfo, COL_PROTOCOL, "PNIO-AL");
- rta_item = proto_tree_add_protocol_format(tree, proto_pn_io, tvb, offset, tvb_length(tvb),
+ rta_item = proto_tree_add_protocol_format(tree, proto_pn_io, tvb, offset, tvb_length(tvb),
"PROFINET IO Alarm");
rta_tree = proto_item_add_subtree(rta_item, ett_pn_io_rta);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
hf_pn_io_alarm_dst_endpoint, &u16AlarmDstEndpoint);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
hf_pn_io_alarm_src_endpoint, &u16AlarmSrcEndpoint);
if (check_col(pinfo->cinfo, COL_INFO))
/* PDU type */
sub_item = proto_tree_add_item(rta_tree, hf_pn_io_pdu_type, tvb, offset, 1, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_pdu_type);
- dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_pdu_type_type, &u8PDUType);
u8PDUType &= 0x0F;
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_pdu_type_version, &u8PDUVersion);
u8PDUVersion >>= 4;
- proto_item_append_text(sub_item, ", Type: %s, Version: %u",
+ proto_item_append_text(sub_item, ", Type: %s, Version: %u",
val_to_str(u8PDUType, pn_io_pdu_type, "Unknown"),
u8PDUVersion);
/* additional flags */
sub_item = proto_tree_add_item(rta_tree, hf_pn_io_add_flags, tvb, offset, 1, FALSE);
sub_tree = proto_item_add_subtree(sub_item, ett_pn_io_add_flags);
- dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
+ dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_window_size, &u8WindowSize);
u8WindowSize &= 0x0F;
- offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
+ offset = dissect_dcerpc_uint8(tvb, offset, pinfo, sub_tree, drep,
hf_pn_io_tack, &u8Tack);
u8Tack >>= 4;
- proto_item_append_text(sub_item, ", Window Size: %u, Tack: %u",
+ proto_item_append_text(sub_item, ", Window Size: %u, Tack: %u",
u8WindowSize, u8Tack);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
hf_pn_io_send_seq_num, &u16SendSeqNum);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
hf_pn_io_ack_seq_num, &u16AckSeqNum);
- offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
+ offset = dissect_dcerpc_uint16(tvb, offset, pinfo, rta_tree, drep,
hf_pn_io_var_part_len, &u16VarPartLen);
switch(u8PDUType & 0x0F) {
/* possibly dissect a PN-IO related PN-RT packet */
static gboolean
-dissect_PNIO_heur(tvbuff_t *tvb,
+dissect_PNIO_heur(tvbuff_t *tvb,
packet_info *pinfo, proto_tree *tree)
{
guint8 drep_data = 0;
{ "IOCRReference", "pn_io.iocr_reference", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_pn_io_lt,
{ "LT", "pn_io.lt", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
-
+
{ &hf_pn_io_iocr_properties,
{ "IOCRProperties", "pn_io.iocr_properties", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_pn_io_iocr_properties_rtclass,
{ "ErrorCode2 ", "pn_io.error_code2", FT_UINT8, BASE_DEC, VALS(pn_io_error_code2_pnio_253), 0x0, "", HFILL }},
{ &hf_pn_io_block,
- { "", "pn_io.block", FT_NONE, BASE_NONE, NULL, 0x0, "", HFILL }},
+ { "Block", "pn_io.block", FT_NONE, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_pn_io_alarm_type,
{ "AlarmType", "pn_io.alarm_type", FT_UINT16, BASE_HEX, VALS(pn_io_alarm_type), 0x0, "", HFILL }},
{ &hf_pn_io_number_of_ars,
{ "NumberOfARs", "pn_io.number_of_ars", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
- { &hf_pn_io_cycle_counter,
+ { &hf_pn_io_cycle_counter,
{ "CycleCounter", "pn_io.cycle_counter", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
- { &hf_pn_io_data_status,
+ { &hf_pn_io_data_status,
{ "DataStatus", "pn_io.ds", FT_UINT8, BASE_HEX, 0, 0x0, "", HFILL }},
- { &hf_pn_io_data_status_res67,
+ { &hf_pn_io_data_status_res67,
{ "Reserved (should be zero)", "pn_io.ds_res67", FT_UINT8, BASE_HEX, 0, 0xc0, "", HFILL }},
- { &hf_pn_io_data_status_ok,
+ { &hf_pn_io_data_status_ok,
{ "StationProblemIndicator (1:Ok/0:Problem)", "pn_io.ds_ok", FT_UINT8, BASE_HEX, 0, 0x20, "", HFILL }},
- { &hf_pn_io_data_status_operate,
+ { &hf_pn_io_data_status_operate,
{ "ProviderState (1:Run/0:Stop)", "pn_io.ds_operate", FT_UINT8, BASE_HEX, 0, 0x10, "", HFILL }},
- { &hf_pn_io_data_status_res3,
+ { &hf_pn_io_data_status_res3,
{ "Reserved (should be zero)", "pn_io.ds_res3", FT_UINT8, BASE_HEX, 0, 0x08, "", HFILL }},
- { &hf_pn_io_data_status_valid,
+ { &hf_pn_io_data_status_valid,
{ "DataValid (1:Valid/0:Invalid)", "pn_io.ds_valid", FT_UINT8, BASE_HEX, 0, 0x04, "", HFILL }},
- { &hf_pn_io_data_status_res1,
+ { &hf_pn_io_data_status_res1,
{ "Reserved (should be zero)", "pn_io.ds_res1", FT_UINT8, BASE_HEX, 0, 0x02, "", HFILL }},
- { &hf_pn_io_data_status_primary,
+ { &hf_pn_io_data_status_primary,
{ "State (1:Primary/0:Backup)", "pn_io.ds_primary", FT_UINT8, BASE_HEX, 0, 0x01, "", HFILL }},
{ &hf_pn_io_transfer_status,
{ "TransferStatus", "pn_io.transfer_status", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_pn_io_mrp_domain_uuid,
{ "MRP_DomainUUID", "pn_io.mrp_domain_uuid", FT_GUID, BASE_NONE, NULL, 0x0, "", HFILL }},
- { &hf_pn_io_mrp_role,
+ { &hf_pn_io_mrp_role,
{ "MRP_Role", "pn_io.mrp_role", FT_UINT16, BASE_HEX, VALS(pn_io_mrp_role_vals), 0x0, "", HFILL }},
{ &hf_pn_io_mrp_length_domain_name,
{ "MRP_LengthDomainName", "pn_io.mrp_length_domain_name", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
git.samba.org / obnox / wireshark / wip.git / commitdiff