GTK: Wrap static preference labels.
[metze/wireshark/wip.git] / epan / dissectors / packet-mbtcp.c
1 /* packet-mbtcp.c
2  * Routines for Modbus/TCP and Modbus/UDP dissection
3  * By Riaan Swart <rswart@cs.sun.ac.za>
4  * Copyright 2001, Institute for Applied Computer Science
5  *                   University of Stellenbosch
6  *
7  * See http://www.modbus.org/ for information on Modbus/TCP.
8  *
9  * Updated to v1.1b of the Modbus Application Protocol specification
10  *   Michael Mann * Copyright 2011
11  *
12  *****************************************************************************************************
13  * A brief explanation of the distinction between Modbus/TCP and Modbus RTU over TCP:
14  *
15  * Consider a Modbus poll message: Unit 01, Scan Holding Register Address 0 for 30 Registers
16  *
17  * The Modbus/TCP message structure will follow the pattern below:
18  * 00 00 00 00 00 06 01 03 00 00 00 1E
19  * AA AA BB BB CC CC DD EE FF FF GG GG
20  *
21  * A = 16-bit Transaction Identifier (typically increments, or is locked at zero)
22  * B = 16-bit Protocol Identifier (typically zero)
23  * C = 16-bit Length of data payload following (and inclusive of) the length byte
24  * D = 8-bit Unit / Slave ID
25  * E = 8-bit Modbus Function Code
26  * F = 16-bit Reference Number / Register Base Address
27  * G = 16-bit Word Count / Number of Registers to scan
28  *
29  * A identical Modbus RTU (or Modbus RTU over TCP) message will overlay partially with the msg above
30  * and contain 16-bit CRC at the end:
31  * 00 00 00 00 00 06 01 03 00 00 00 1E -- -- (Modbus/TCP message, repeated from above)
32  * -- -- -- -- -- -- 01 03 00 00 00 1E C5 C2 (Modbus RTU over TCP message, includes 16-bit CRC footer)
33  * AA AA BB BB CC CC DD EE FF FF GG GG HH HH
34  *
35  * A = Not present in Modbus RTU message
36  * B = Not present in Modbus RTU message
37  * C = Not present in Modbus RTU message
38  * D = 8-bit Unit / Slave ID
39  * E = 8-bit Modbus Function Code
40  * F = 16-bit Reference Number / Register Base Address
41  * G = 16-bit Word Count / Number of Registers to scan
42  * H = 16-bit CRC
43  *
44  *****************************************************************************************************
45  * Wireshark - Network traffic analyzer
46  * By Gerald Combs <gerald@wireshark.org>
47  * Copyright 1998 Gerald Combs
48  *
49  * This program is free software; you can redistribute it and/or
50  * modify it under the terms of the GNU General Public License
51  * as published by the Free Software Foundation; either version 2
52  * of the License, or (at your option) any later version.
53  *
54  * This program is distributed in the hope that it will be useful,
55  * but WITHOUT ANY WARRANTY; without even the implied warranty of
56  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
57  * GNU General Public License for more details.
58  *
59  * You should have received a copy of the GNU General Public License
60  * along with this program; if not, write to the Free Software
61  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
62  */
63
64 #include "config.h"
65
66 #include <epan/packet.h>
67 #include "packet-tcp.h"
68 #include "packet-mbtcp.h"
69 #include <epan/prefs.h>
70 #include <epan/expert.h>
71 #include <epan/crc16-tvb.h> /* For CRC verification */
72 #include <epan/proto_data.h>
73
74 void proto_register_modbus(void);
75 void proto_reg_handoff_mbtcp(void);
76 void proto_reg_handoff_mbrtu(void);
77
78 /* Initialize the protocol and registered fields */
79 static int proto_mbtcp = -1;
80 static int proto_mbudp = -1;
81 static int proto_mbrtu = -1;
82 static int proto_modbus = -1;
83 static int hf_mbtcp_transid = -1;
84 static int hf_mbtcp_protid = -1;
85 static int hf_mbtcp_len = -1;
86 static int hf_mbtcp_unitid = -1;
87 static int hf_modbus_request_frame = -1;
88 static int hf_modbus_functioncode = -1;
89 static int hf_modbus_reference = -1;
90 static int hf_modbus_padding = -1;
91 static int hf_modbus_lreference = -1;
92 static int hf_modbus_reftype = -1;
93 static int hf_modbus_readref = -1;
94 static int hf_modbus_writeref = -1;
95 static int hf_modbus_wordcnt = -1;
96 static int hf_modbus_readwordcnt = -1;
97 static int hf_modbus_writewordcnt = -1;
98 static int hf_modbus_bytecnt = -1;
99 static int hf_modbus_lbytecnt = -1;
100 static int hf_modbus_bitcnt = -1;
101 static int hf_modbus_exceptioncode = -1;
102 static int hf_modbus_diag_sf = -1;
103 static int hf_modbus_diag_return_query_data_request = -1;
104 static int hf_modbus_diag_return_query_data_echo = -1;
105 static int hf_modbus_diag_restart_communication_option = -1;
106 static int hf_modbus_diag_return_diag_register = -1;
107 static int hf_modbus_diag_ascii_input_delimiter = -1;
108 static int hf_modbus_diag_clear_ctr_diag_reg = -1;
109 static int hf_modbus_diag_return_bus_message_count = -1;
110 static int hf_modbus_diag_return_bus_comm_error_count = -1;
111 static int hf_modbus_diag_return_bus_exception_error_count = -1;
112 static int hf_modbus_diag_return_slave_message_count = -1;
113 static int hf_modbus_diag_return_no_slave_response_count = -1;
114 static int hf_modbus_diag_return_slave_nak_count = -1;
115 static int hf_modbus_diag_return_slave_busy_count = -1;
116 static int hf_modbus_diag_return_bus_char_overrun_count = -1;
117 static int hf_modbus_status = -1;
118 static int hf_modbus_event = -1;
119 static int hf_modbus_event_count = -1;
120 static int hf_modbus_message_count = -1;
121 static int hf_modbus_event_recv_comm_err = -1;
122 static int hf_modbus_event_recv_char_over = -1;
123 static int hf_modbus_event_recv_lo_mode = -1;
124 static int hf_modbus_event_recv_broadcast = -1;
125 static int hf_modbus_event_send_read_ex = -1;
126 static int hf_modbus_event_send_slave_abort_ex = -1;
127 static int hf_modbus_event_send_slave_busy_ex = -1;
128 static int hf_modbus_event_send_slave_nak_ex = -1;
129 static int hf_modbus_event_send_write_timeout = -1;
130 static int hf_modbus_event_send_lo_mode = -1;
131 static int hf_modbus_andmask = -1;
132 static int hf_modbus_ormask = -1;
133 static int hf_modbus_data = -1;
134 static int hf_modbus_mei = -1;
135 static int hf_modbus_read_device_id = -1;
136 static int hf_modbus_object_id = -1;
137 static int hf_modbus_num_objects = -1;
138 static int hf_modbus_list_object_len = -1;
139 static int hf_modbus_conformity_level = -1;
140 static int hf_modbus_more_follows = -1;
141 static int hf_modbus_next_object_id = -1;
142 static int hf_modbus_object_str_value = -1;
143 static int hf_modbus_object_value = -1;
144 static int hf_modbus_reg16 = -1;
145 static int hf_modbus_reg32 = -1;
146 static int hf_mbrtu_unitid = -1;
147 static int hf_mbrtu_crc16 = -1;
148 static int hf_mbrtu_crc16_status = -1;
149
150 /* Initialize the subtree pointers */
151 static gint ett_mbtcp = -1;
152 static gint ett_mbrtu = -1;
153 static gint ett_modbus_hdr = -1;
154 static gint ett_group_hdr = -1;
155 static gint ett_events = -1;
156 static gint ett_events_recv = -1;
157 static gint ett_events_send = -1;
158 static gint ett_device_id_objects = -1;
159 static gint ett_device_id_object_items = -1;
160
161 static expert_field ei_mbrtu_crc16_incorrect = EI_INIT;
162 static expert_field ei_modbus_data_decode = EI_INIT;
163 static expert_field ei_mbtcp_cannot_classify = EI_INIT;
164
165 static dissector_handle_t modbus_handle;
166 static dissector_handle_t mbtcp_handle;
167 static dissector_handle_t mbudp_handle;
168 static dissector_handle_t mbrtu_handle;
169
170 static dissector_table_t   modbus_data_dissector_table;
171 static dissector_table_t   modbus_dissector_table;
172
173
174 /* Globals for Modbus/TCP Preferences */
175 static gboolean mbtcp_desegment = TRUE;
176 static guint global_mbus_tcp_port = PORT_MBTCP; /* Port 502, by default */
177 static guint global_mbus_udp_port = PORT_MBTCP; /* Port 502, by default */
178
179 /* Globals for Modbus RTU over TCP Preferences */
180 static gboolean mbrtu_desegment = TRUE;
181 static guint global_mbus_tcp_rtu_port = PORT_MBRTU; /* 0, by default        */
182 static guint global_mbus_udp_rtu_port = PORT_MBRTU; /* 0, by default        */
183 static gboolean mbrtu_crc = FALSE;
184
185 /* Globals for Modbus Preferences */
186 static gint global_mbus_register_format = MODBUS_PREF_REGISTER_FORMAT_UINT16;
187
188 static int
189 classify_mbtcp_packet(packet_info *pinfo, guint port)
190 {
191     /* see if nature of packets can be derived from src/dst ports */
192     /* if so, return as found */
193     /*                        */
194     /* XXX Update Oct 2012 - It can be difficult to determine if a packet is a query or response; some way to track  */
195     /* the Modbus/TCP transaction ID for each pair of messages would allow for detection based on a new seq. number. */
196     /* Otherwise, we can stick with this method; a configurable port option has been added to allow for usage of     */
197     /* user ports either than the default of 502.                                                                    */
198     if (( pinfo->srcport == port ) && ( pinfo->destport != port ))
199         return RESPONSE_PACKET;
200     if (( pinfo->srcport != port ) && ( pinfo->destport == port ))
201         return QUERY_PACKET;
202
203     /* else, cannot classify */
204     return CANNOT_CLASSIFY;
205 }
206
207 static int
208 classify_mbrtu_packet(packet_info *pinfo, tvbuff_t *tvb, guint port)
209 {
210     guint8 func, len;
211
212     func = tvb_get_guint8(tvb, 1);
213     len = tvb_reported_length(tvb);
214
215     /* see if nature of packets can be derived from src/dst ports */
216     /* if so, return as found */
217     if (( pinfo->srcport == port ) && ( pinfo->destport != port ))
218         return RESPONSE_PACKET;
219     if (( pinfo->srcport != port ) && ( pinfo->destport == port ))
220         return QUERY_PACKET;
221
222
223     /* We may not have an Ethernet header or unique ports. */
224     /* Dig into these a little deeper to try to guess the message type */
225
226     /* The 'exception' bit is set, so this is a response */
227     if (func & 0x80) {
228         return RESPONSE_PACKET;
229     }
230     switch (func) {
231         case READ_COILS:
232         case READ_DISCRETE_INPUTS:
233             /* Only possible to get a response message of 8 bytes with Discrete or Coils */
234             if (len == 8) {
235                 /* If this is, in fact, a response then the data byte count will be 3 */
236                 /* This will correctly identify all messages except for those that are discrete or coil polls */
237                 /* where the base address range happens to have 0x03 in the upper 16-bit address register     */
238                 if (tvb_get_guint8(tvb, 2) == 3) {
239                     return RESPONSE_PACKET;
240                 }
241                 else {
242                     return QUERY_PACKET;
243                 }
244             }
245             else {
246                 return RESPONSE_PACKET;
247             }
248             break;
249
250         case READ_HOLDING_REGS:
251         case READ_INPUT_REGS:
252         case WRITE_SINGLE_COIL:
253         case WRITE_SINGLE_REG:
254             if (len == 8) {
255                 return QUERY_PACKET;
256             }
257             else {
258                 return RESPONSE_PACKET;
259             }
260             break;
261
262         case WRITE_MULT_REGS:
263         case WRITE_MULT_COILS:
264             if (len == 8) {
265                 return RESPONSE_PACKET;
266             }
267             else {
268                 return QUERY_PACKET;
269             }
270             break;
271     }
272
273
274     /* else, cannot classify */
275     return CANNOT_CLASSIFY;
276 }
277
278 /* Translate function to string, as given on p6 of
279  * "Open Modbus/TCP Specification", release 1 by Andy Swales.
280  */
281 static const value_string function_code_vals[] = {
282     { READ_COILS,             "Read Coils" },
283     { READ_DISCRETE_INPUTS,   "Read Discrete Inputs" },
284     { READ_HOLDING_REGS,      "Read Holding Registers" },
285     { READ_INPUT_REGS,        "Read Input Registers" },
286     { WRITE_SINGLE_COIL,      "Write Single Coil" },
287     { WRITE_SINGLE_REG,       "Write Single Register" },
288     { READ_EXCEPT_STAT,       "Read Exception Status" },
289     { DIAGNOSTICS,            "Diagnostics" },
290     { GET_COMM_EVENT_CTRS,    "Get Comm. Event Counters" },
291     { GET_COMM_EVENT_LOG,     "Get Comm. Event Log" },
292     { WRITE_MULT_COILS,       "Write Multiple Coils" },
293     { WRITE_MULT_REGS,        "Write Multiple Registers" },
294     { REPORT_SLAVE_ID,        "Report Slave ID" },
295     { READ_FILE_RECORD,       "Read File Record" },
296     { WRITE_FILE_RECORD,      "Write File Record" },
297     { MASK_WRITE_REG,         "Mask Write Register" },
298     { READ_WRITE_REG,         "Read Write Register" },
299     { READ_FIFO_QUEUE,        "Read FIFO Queue" },
300     { ENCAP_INTERFACE_TRANSP, "Encapsulated Interface Transport" },
301     { UNITY_SCHNEIDER,        "Unity (Schneider)" },
302     { 0,                      NULL }
303 };
304
305 /* Translate exception code to string */
306 static const value_string exception_code_vals[] = {
307     { ILLEGAL_FUNCTION,    "Illegal function" },
308     { ILLEGAL_ADDRESS,     "Illegal data address" },
309     { ILLEGAL_VALUE,       "Illegal data value" },
310     { SLAVE_FAILURE,       "Slave device failure" },
311     { ACKNOWLEDGE,         "Acknowledge" },
312     { SLAVE_BUSY,          "Slave device busy" },
313     { MEMORY_ERR,          "Memory parity error" },
314     { GATEWAY_UNAVAILABLE, "Gateway path unavailable" },
315     { GATEWAY_TRGT_FAIL,   "Gateway target device failed to respond" },
316     { 0,                    NULL }
317 };
318
319 /* Translate Modbus Encapsulation Interface (MEI) code to string */
320 static const value_string encap_interface_code_vals[] = {
321     { CANOPEN_REQ_RESP, "CANopen Request/Response " },
322     { READ_DEVICE_ID,   "Read Device Identification" },
323     { 0,                NULL }
324 };
325
326 /* Translate Modbus Diagnostic subfunction code to string */
327 static const value_string diagnostic_code_vals[] = {
328     { RETURN_QUERY_DATA,                "Return Query Data" },
329     { RESTART_COMMUNICATION_OPTION,     "Restart Communications Option" },
330     { RETURN_DIAGNOSTIC_REGISTER,       "Return Diagnostic Register" },
331     { CHANGE_ASCII_INPUT_DELIMITER,     "Change ASCII Input Delimiter" },
332     { FORCE_LISTEN_ONLY_MODE,           "Force Listen Only Mode" },
333     { CLEAR_COUNTERS_AND_DIAG_REG,      "Clear Counters and Diagnostic Register" },
334     { RETURN_BUS_MESSAGE_COUNT,         "Return Bus Message Count" },
335     { RETURN_BUS_COMM_ERROR_COUNT,      "Return Bus Communication Error Count" },
336     { RETURN_BUS_EXCEPTION_ERROR_COUNT, "Return Bus Exception Error Count" },
337     { RETURN_SLAVE_MESSAGE_COUNT,       "Return Slave Message Count" },
338     { RETURN_SLAVE_NO_RESPONSE_COUNT,   "Return Slave No Response Count" },
339     { RETURN_SLAVE_NAK_COUNT,           "Return Slave NAK Count" },
340     { RETURN_SLAVE_BUSY_COUNT,          "Return Slave Busy Count" },
341     { RETURN_BUS_CHAR_OVERRUN_COUNT,    "Return Bus Character Overrun Count" },
342     { CLEAR_OVERRUN_COUNTER_AND_FLAG,   "Clear Overrun Counter and Flag" },
343     { 0,                                NULL }
344 };
345
346 static const value_string diagnostic_restart_communication_option_vals[] = {
347     { 0,        "Leave Log" },
348     { 0xFF,     "Clear Log" },
349     { 0,        NULL }
350 };
351
352 /* Translate read device code to string */
353 static const value_string read_device_id_vals[] = {
354     { 1,        "Basic Device Identification" },
355     { 2,        "Regular Device Identification"  },
356     { 3,        "Extended Device Identification"  },
357     { 4,        "Specific Identification Object"  },
358
359     { 0,        NULL             }
360 };
361
362 /* Translate read device code to string */
363 static const value_string object_id_vals[] = {
364     { 0,        "VendorName" },
365     { 1,        "ProductCode" },
366     { 2,        "MajorMinorRevision"  },
367     { 3,        "VendorURL"  },
368     { 4,        "ProductName"  },
369     { 5,        "ModelName"  },
370     { 6,        "UserApplicationName"  },
371
372     { 0,        NULL             }
373 };
374
375 static const value_string conformity_level_vals[] = {
376     { 0x01,     "Basic Device Identification (stream)" },
377     { 0x02,     "Regular Device Identification (stream)"  },
378     { 0x03,     "Extended Device Identification (stream)"  },
379     { 0x81,     "Basic Device Identification (stream and individual)" },
380     { 0x82,     "Regular Device Identification (stream and individual)"  },
381     { 0x83,     "Extended Device Identification (stream and individual)"  },
382
383     { 0,        NULL             }
384 };
385
386 static const enum_val_t mbus_register_format[] = {
387   { "UINT16     ", "UINT16     ",  MODBUS_PREF_REGISTER_FORMAT_UINT16  },
388   { "INT16      ", "INT16      ",  MODBUS_PREF_REGISTER_FORMAT_INT16   },
389   { "UINT32     ", "UINT32     ",  MODBUS_PREF_REGISTER_FORMAT_UINT32  },
390   { "INT32      ", "INT32      ",  MODBUS_PREF_REGISTER_FORMAT_INT32  },
391   { "IEEE FLT   ", "IEEE FLT   ",  MODBUS_PREF_REGISTER_FORMAT_IEEE_FLOAT  },
392   { "MODICON FLT", "MODICON FLT",  MODBUS_PREF_REGISTER_FORMAT_MODICON_FLOAT  },
393   { NULL, NULL, 0 }
394 };
395
396 /* Code to dissect Modbus/TCP packets */
397 static int
398 dissect_mbtcp_pdu_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int proto, guint port)
399 {
400 /* Set up structures needed to add the protocol subtree and manage it */
401     proto_item    *mi;
402     proto_tree    *mbtcp_tree;
403     int           offset, packet_type;
404     tvbuff_t      *next_tvb;
405     const char    *func_string = "";
406     const char    *pkt_type_str = "";
407     const char    *err_str = "";
408     guint16       transaction_id, protocol_id, len;
409     guint8        unit_id, function_code, exception_code, subfunction_code;
410
411     transaction_id = tvb_get_ntohs(tvb, 0);
412     protocol_id = tvb_get_ntohs(tvb, 2);
413     len = tvb_get_ntohs(tvb, 4);
414
415     unit_id = tvb_get_guint8(tvb, 6);
416     function_code = tvb_get_guint8(tvb, 7) & 0x7F;
417
418     offset = 0;
419
420     /* "Request" or "Response" */
421     packet_type = classify_mbtcp_packet(pinfo, port);
422
423     switch ( packet_type ) {
424         case QUERY_PACKET :
425             pkt_type_str="Query";
426             break;
427         case RESPONSE_PACKET :
428             pkt_type_str="Response";
429             break;
430         case CANNOT_CLASSIFY :
431             err_str="Unable to classify as query or response.";
432             pkt_type_str="unknown";
433             break;
434         default :
435             break;
436     }
437
438     /* Find exception - last bit set in function code */
439     if (tvb_get_guint8(tvb, 7) & 0x80) {
440         exception_code = tvb_get_guint8(tvb, offset + 8);
441     }
442     else {
443         exception_code = 0;
444     }
445
446     if ((function_code == ENCAP_INTERFACE_TRANSP) && (exception_code == 0))  {
447         func_string = val_to_str_const(tvb_get_guint8(tvb, offset + 8), encap_interface_code_vals, "Encapsulated Interface Transport");
448         subfunction_code = 1;
449     }
450     else if ((function_code == DIAGNOSTICS) && (exception_code == 0))  {
451         func_string = val_to_str_const(tvb_get_ntohs(tvb, offset + 8), diagnostic_code_vals, "Diagnostics");
452         subfunction_code = 1;
453     }
454     else {
455         func_string = val_to_str(function_code, function_code_vals, "Unknown function (%d)");
456         subfunction_code = 0;
457     }
458
459     if ( exception_code != 0 )
460         err_str="Exception returned ";
461
462     /* Make entries in Info column on summary display */
463     if (subfunction_code == 0) {
464         if (strlen(err_str) > 0) {
465             col_add_fstr(pinfo->cinfo, COL_INFO,
466                     "%8s: Trans: %5u; Unit: %3u, Func: %3u: %s. %s",
467                     pkt_type_str, transaction_id, unit_id,
468                     function_code, func_string, err_str);
469         }
470         else {
471             col_add_fstr(pinfo->cinfo, COL_INFO,
472                     "%8s: Trans: %5u; Unit: %3u, Func: %3u: %s",
473                     pkt_type_str, transaction_id, unit_id,
474                     function_code, func_string);
475         }
476     }
477     else {
478         if (strlen(err_str) > 0) {
479             col_add_fstr(pinfo->cinfo, COL_INFO,
480                     "%8s: Trans: %5u; Unit: %3u, Func: %3u/%3u: %s. %s",
481                     pkt_type_str, transaction_id, unit_id,
482                     function_code, subfunction_code, func_string, err_str);
483         }
484         else {
485             col_add_fstr(pinfo->cinfo, COL_INFO,
486                     "%8s: Trans: %5u; Unit: %3u, Func: %3u/%3u: %s",
487                     pkt_type_str, transaction_id, unit_id,
488                     function_code, subfunction_code, func_string);
489         }
490     }
491
492     /* Create protocol tree */
493     mi = proto_tree_add_item(tree, proto, tvb, offset, len+6, ENC_NA);
494     mbtcp_tree = proto_item_add_subtree(mi, ett_mbtcp);
495
496     if (packet_type == CANNOT_CLASSIFY)
497         expert_add_info(pinfo, mi, &ei_mbtcp_cannot_classify);
498
499     /* Add items to protocol tree specific to Modbus/TCP */
500     proto_tree_add_uint(mbtcp_tree, hf_mbtcp_transid, tvb, offset, 2, transaction_id);
501     proto_tree_add_uint(mbtcp_tree, hf_mbtcp_protid, tvb, offset + 2, 2, protocol_id);
502     proto_tree_add_uint(mbtcp_tree, hf_mbtcp_len, tvb, offset + 4, 2, len);
503     proto_tree_add_uint(mbtcp_tree, hf_mbtcp_unitid, tvb, offset + 6, 1, unit_id);
504
505     /* dissect the Modbus PDU */
506     next_tvb = tvb_new_subset_length( tvb, offset+7, len-1);
507
508     /* Continue with dissection of Modbus data payload following Modbus/TCP frame */
509     if( tvb_reported_length_remaining(tvb, offset) > 0 )
510         call_dissector_with_data(modbus_handle, next_tvb, pinfo, tree, &packet_type);
511
512     return tvb_captured_length(tvb);
513 }
514
515 static int
516 dissect_mbtcp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
517 {
518     /* Make entries in Protocol column on summary display */
519     col_set_str(pinfo->cinfo, COL_PROTOCOL, "Modbus/TCP");
520     col_clear(pinfo->cinfo, COL_INFO);
521
522     return dissect_mbtcp_pdu_common(tvb, pinfo, tree, proto_mbtcp, global_mbus_tcp_port);
523 }
524
525 /* Code to dissect Modbus RTU */
526 static int
527 dissect_mbrtu_pdu_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint port)
528 {
529 /* Set up structures needed to add the protocol subtree and manage it */
530     proto_item    *mi;
531     proto_tree    *mbrtu_tree;
532     int           offset, packet_type;
533     tvbuff_t      *next_tvb;
534     const char    *func_string = "";
535     const char    *pkt_type_str = "";
536     const char    *err_str = "";
537     guint16       len, calc_crc16;
538     guint8        unit_id, function_code, exception_code, subfunction_code;
539
540     /* Make entries in Protocol column on summary display */
541     col_set_str(pinfo->cinfo, COL_PROTOCOL, "Modbus RTU");
542     col_clear(pinfo->cinfo, COL_INFO);
543
544     len = tvb_reported_length(tvb);
545
546     unit_id = tvb_get_guint8(tvb, 0);
547     function_code = tvb_get_guint8(tvb, 1) & 0x7F;
548
549     offset = 0;
550
551     /* "Request" or "Response" */
552     packet_type = classify_mbrtu_packet(pinfo, tvb, port);
553
554     switch ( packet_type ) {
555         case QUERY_PACKET :
556             pkt_type_str="Query";
557             break;
558         case RESPONSE_PACKET :
559             pkt_type_str="Response";
560             break;
561         case CANNOT_CLASSIFY :
562             err_str="Unable to classify as query or response.";
563             pkt_type_str="unknown";
564             break;
565         default :
566             break;
567     }
568
569     /* Find exception - last bit set in function code */
570     if (tvb_get_guint8(tvb, 1) & 0x80) {
571         exception_code = tvb_get_guint8(tvb, offset + 2);
572     }
573     else {
574         exception_code = 0;
575     }
576
577     if ((function_code == ENCAP_INTERFACE_TRANSP) && (exception_code == 0))  {
578         func_string = val_to_str_const(tvb_get_guint8(tvb, offset + 2), encap_interface_code_vals, "Encapsulated Interface Transport");
579         subfunction_code = 1;
580     }
581     else if ((function_code == DIAGNOSTICS) && (exception_code == 0))  {
582         func_string = val_to_str_const(tvb_get_ntohs(tvb, offset + 2), diagnostic_code_vals, "Diagnostics");
583         subfunction_code = 1;
584     }
585     else {
586         func_string = val_to_str(function_code, function_code_vals, "Unknown function (%d)");
587         subfunction_code = 0;
588     }
589
590     if ( exception_code != 0 )
591         err_str="Exception returned ";
592
593     /* Make entries in Info column on summary display */
594     if (subfunction_code == 0) {
595         if (strlen(err_str) > 0) {
596             col_add_fstr(pinfo->cinfo, COL_INFO,
597                     "%8s: Unit: %3u, Func: %3u: %s. %s",
598                     pkt_type_str, unit_id,
599                     function_code, func_string, err_str);
600         }
601         else {
602             col_add_fstr(pinfo->cinfo, COL_INFO,
603                     "%8s: Unit: %3u, Func: %3u: %s",
604                     pkt_type_str, unit_id,
605                     function_code, func_string);
606         }
607     }
608     else {
609         if (strlen(err_str) > 0) {
610             col_add_fstr(pinfo->cinfo, COL_INFO,
611                     "%8s: Unit: %3u, Func: %3u/%3u: %s. %s",
612                     pkt_type_str, unit_id,
613                     function_code, subfunction_code, func_string, err_str);
614         }
615         else {
616             col_add_fstr(pinfo->cinfo, COL_INFO,
617                     "%8s: Unit: %3u, Func: %3u/%3u: %s",
618                     pkt_type_str, unit_id,
619                     function_code, subfunction_code, func_string);
620         }
621     }
622
623     /* Create protocol tree */
624     mi = proto_tree_add_protocol_format(tree, proto_mbrtu, tvb, offset,
625             len, "Modbus RTU");
626     mbrtu_tree = proto_item_add_subtree(mi, ett_mbrtu);
627
628     /* Add items to protocol tree specific to Modbus RTU */
629     proto_tree_add_uint(mbrtu_tree, hf_mbrtu_unitid, tvb, offset, 1, unit_id);
630
631     /* CRC validation */
632     if (mbrtu_crc)
633     {
634         calc_crc16 = crc16_plain_tvb_offset_seed(tvb, offset, len-2, 0xFFFF);
635         proto_tree_add_checksum(mbrtu_tree, tvb, len-2, hf_mbrtu_crc16, hf_mbrtu_crc16_status, &ei_mbrtu_crc16_incorrect, pinfo, g_htons(calc_crc16), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
636     }
637     else
638     {
639         proto_tree_add_checksum(mbrtu_tree, tvb, len-2, hf_mbrtu_crc16, hf_mbrtu_crc16_status, &ei_mbrtu_crc16_incorrect, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
640     }
641
642     /* when determining payload length, make sure to ignore the unit ID header & CRC-16 footer bytes */
643     len = len - 3;
644
645     /* dissect the Modbus PDU                      */
646     next_tvb = tvb_new_subset_length( tvb, offset+1, len);
647
648     /* Continue with dissection of Modbus data payload following Modbus RTU frame */
649     if( tvb_reported_length_remaining(tvb, offset) > 0 )
650         call_dissector_with_data(modbus_handle, next_tvb, pinfo, tree, &packet_type);
651
652     return tvb_captured_length(tvb);
653 }
654
655 /* Code to dissect Modbus RTU over TCP packets */
656 static int
657 dissect_mbrtu_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
658 {
659     return dissect_mbrtu_pdu_common(tvb, pinfo, tree, global_mbus_tcp_rtu_port);
660 }
661
662 /* Return length of Modbus/TCP message */
663 static guint
664 get_mbtcp_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_)
665 {
666     guint16 plen;
667
668     /*
669      * Get the length of the data from the encapsulation header.
670      */
671     plen = tvb_get_ntohs(tvb, offset + 4);
672
673     /*
674      * That length doesn't include the encapsulation header itself;
675      * add that in.
676      */
677     return plen + 6;
678 }
679
680 /* Return length of Modbus RTU over TCP message */
681 static guint
682 get_mbrtu_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb,
683                   int offset _U_, void *data _U_)
684 {
685     int packet_type;
686     guint8 function_code;
687
688     function_code = tvb_get_guint8(tvb, 1);
689
690     /* Modbus RTU requests do not contain a length field but they are typically a consistent size.
691        Responses do contain a usable 'length' byte at offset 2
692        XXX - Note that only some function codes are supported by this lookup function;
693              the rest can be added as pcap examples are made available */
694
695     /* Determine "Query" or "Response" */
696     packet_type = classify_mbrtu_packet(pinfo, tvb, global_mbus_tcp_rtu_port);
697
698     switch ( packet_type ) {
699         case QUERY_PACKET :
700             switch (function_code) {
701                 case READ_COILS:   /* Query messages of these types are always 8 bytes */
702                 case READ_DISCRETE_INPUTS:
703                 case READ_HOLDING_REGS:
704                 case READ_INPUT_REGS:
705                 case WRITE_SINGLE_COIL:
706                 case WRITE_SINGLE_REG:
707                     return 8;
708                     break;
709                 case WRITE_MULT_REGS:
710                 case WRITE_MULT_COILS:
711                     return tvb_get_guint8(tvb, 6) + 9; /* Reported size does not include 2 header, 4 FC15/16-specific, 1 size byte or 2 CRC16 bytes */
712                     break;
713                 default :
714                     return tvb_captured_length(tvb);  /* Fall back on tvb length */
715                     break;
716             }
717         case RESPONSE_PACKET :
718             /* The 'exception' bit is set, so this is a 5-byte response */
719             if (function_code & 0x80) {
720                 return 5;
721             }
722
723             switch (function_code) {
724                 case READ_COILS:
725                 case READ_DISCRETE_INPUTS:
726                 case READ_HOLDING_REGS:
727                 case READ_INPUT_REGS:
728                 case WRITE_SINGLE_COIL:
729                 case WRITE_SINGLE_REG:
730                     return tvb_get_guint8(tvb, 2) + 5;  /* Reported size does not include 2 header, 1 size byte, 2 CRC16 bytes */
731                     break;
732                 case WRITE_MULT_REGS:  /* Response messages of FC15/16 are always 8 bytes */
733                 case WRITE_MULT_COILS:
734                     return 8;
735                     break;
736                 default :
737                     return tvb_captured_length(tvb);  /* Fall back on tvb length */
738                     break;
739             }
740         case CANNOT_CLASSIFY :
741         default :
742             return tvb_captured_length(tvb);  /* Fall back on tvb length */
743             break;
744     }
745
746 }
747
748
749 /* Code to dissect Modbus/TCP messages */
750 static int
751 dissect_mbtcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
752 {
753
754     /* Make sure there's at least enough data to determine it's a Modbus TCP packet */
755     if (!tvb_bytes_exist(tvb, 0, 8))
756         return 0;
757
758     /* check that it actually looks like Modbus/TCP */
759     /* protocol id == 0 */
760     if(tvb_get_ntohs(tvb, 2) != 0 ){
761         return 0;
762     }
763     /* length is at least 2 (unit_id + function_code) */
764     if(tvb_get_ntohs(tvb, 4) < 2 ){
765         return 0;
766     }
767
768     /* build up protocol tree and iterate over multiple packets */
769     tcp_dissect_pdus(tvb, pinfo, tree, mbtcp_desegment, 6,
770                      get_mbtcp_pdu_len, dissect_mbtcp_pdu, data);
771
772     return tvb_captured_length(tvb);
773 }
774
775 static int
776 dissect_mbudp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
777 {
778
779     /* Make sure there's at least enough data to determine it's a Modbus UDP packet */
780     if (!tvb_bytes_exist(tvb, 0, 8))
781         return 0;
782
783     /* check that it actually looks like Modbus/TCP */
784     /* protocol id == 0 */
785     if(tvb_get_ntohs(tvb, 2) != 0 ){
786         return 0;
787     }
788     /* length is at least 2 (unit_id + function_code) */
789     if(tvb_get_ntohs(tvb, 4) < 2 ){
790         return 0;
791     }
792
793     /* Make entries in Protocol column on summary display */
794     col_set_str(pinfo->cinfo, COL_PROTOCOL, "Modbus/UDP");
795     col_clear(pinfo->cinfo, COL_INFO);
796
797     return dissect_mbtcp_pdu_common(tvb, pinfo, tree, proto_mbudp, global_mbus_udp_port);
798 }
799
800 /* Code to dissect Modbus RTU over TCP messages */
801 static int
802 dissect_mbrtu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
803 {
804
805     /* Make sure there's at least enough data to determine it's a Modbus packet */
806     /* 5 bytes is the smallest possible valid message (exception response) */
807     if (!tvb_bytes_exist(tvb, 0, 5))
808         return 0;
809
810     /* For Modbus RTU mode, confirm that the first byte is a valid address (non-zero), */
811     /* so we can eliminate false-posititves on Modbus TCP messages loaded as RTU       */
812     if(tvb_get_guint8(tvb, 0) == 0 )
813         return 0;
814
815     /* build up protocol tree and iterate over multiple packets */
816     tcp_dissect_pdus(tvb, pinfo, tree, mbrtu_desegment, 5,
817                      get_mbrtu_pdu_len, dissect_mbrtu_pdu, data);
818
819     return tvb_captured_length(tvb);
820 }
821
822 static int
823 dissect_mbrtu_udp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
824 {
825
826     /* Make sure there's at least enough data to determine it's a Modbus packet */
827     /* 5 bytes is the smallest possible valid message (exception response) */
828     if (tvb_reported_length(tvb) < 5)
829         return 0;
830
831     return dissect_mbrtu_pdu_common(tvb, pinfo, tree, global_mbus_udp_rtu_port);
832 }
833
834
835 /* Code to allow further dissection of Modbus data payload */
836 /* Common to both Modbus/TCP and Modbus RTU dissectors     */
837 static void
838 dissect_modbus_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint8 function_code,
839                     gint payload_start, gint payload_len, gint register_format, guint16 reg_base)
840 {
841     gint reported_len, data_offset;
842     gint16  data16s;
843     gint32  data32s;
844     guint16 data16, modflt_lo, modflt_hi, reg_num=reg_base;
845     guint32 data32, modflt_comb;
846     gfloat data_float, modfloat;
847     proto_item    *register_item = NULL;
848     tvbuff_t *next_tvb;
849
850     reported_len = tvb_reported_length_remaining(tvb, payload_start);
851     data_offset = 0;
852
853     if ( payload_start < 0 || ( payload_len + payload_start ) == 0 )
854         return;
855
856     /* If calculated length from remaining tvb data != bytes in packet, do not attempt to decode      */
857     if ( payload_len != reported_len ) {
858         proto_tree_add_item(tree, hf_modbus_data, tvb, payload_start, reported_len, ENC_NA);
859         return;
860     }
861
862     /* If data type of payload is Holding or Input registers */
863     /* AND */
864     /* if payload length is not a multiple of 4, don't attempt to decode anything in 32-bit format */
865     if ((function_code == READ_HOLDING_REGS) || (function_code == READ_INPUT_REGS) || (function_code == WRITE_MULT_REGS)) {
866         if ((payload_len % 4 != 0) && ( (register_format == MODBUS_PREF_REGISTER_FORMAT_UINT32) ||
867             (register_format == MODBUS_PREF_REGISTER_FORMAT_IEEE_FLOAT) ||
868             (register_format == MODBUS_PREF_REGISTER_FORMAT_MODICON_FLOAT) ) ) {
869             register_item = proto_tree_add_item(tree, hf_modbus_data, tvb, payload_start, payload_len, ENC_NA);
870             expert_add_info(pinfo, register_item, &ei_modbus_data_decode);
871             return;
872         }
873     }
874
875     /* Build a new tvb containing just the data payload   */
876     next_tvb = tvb_new_subset_length_caplen(tvb, payload_start, payload_len, reported_len);
877
878     switch ( function_code ) {
879
880         case READ_HOLDING_REGS:
881         case READ_INPUT_REGS:
882         case WRITE_MULT_REGS:
883             while (data_offset < payload_len) {
884                 /* Use "Preferences" options to determine decoding format of register data, as no format is implied by the protocol itself. */
885                 /* Based on a standard register size of 16-bits, use decoding format preference to step through each register and display  */
886                 /* it in an appropriate fashion. */
887                 switch (register_format) {
888                     case MODBUS_PREF_REGISTER_FORMAT_UINT16: /* Standard-size unsigned integer 16-bit register */
889                         data16 = tvb_get_ntohs(next_tvb, data_offset);
890                         proto_tree_add_uint_format(tree, hf_modbus_reg16, next_tvb, data_offset, 2, reg_num,
891                                                     "Register %u (UINT16): %u", reg_num, data16);
892                         data_offset += 2;
893                         reg_num += 1;
894                         break;
895                     case MODBUS_PREF_REGISTER_FORMAT_INT16: /* Standard-size signed integer 16-bit register */
896                         data16s = tvb_get_ntohs(next_tvb, data_offset);
897                         proto_tree_add_uint_format(tree, hf_modbus_reg16, next_tvb, data_offset, 2, reg_num,
898                                                     "Register %u (INT16): %d", reg_num, data16s);
899                         data_offset += 2;
900                         reg_num += 1;
901                         break;
902                     case MODBUS_PREF_REGISTER_FORMAT_UINT32: /* Double-size unsigned integer 2 x 16-bit registers */
903                         data32 = tvb_get_ntohl(next_tvb, data_offset);
904                         proto_tree_add_uint_format(tree, hf_modbus_reg32, next_tvb, data_offset, 4, reg_num,
905                                                     "Register %u (UINT32): %u", reg_num, data32);
906                         data_offset += 4;
907                         reg_num += 2;
908                         break;
909                     case MODBUS_PREF_REGISTER_FORMAT_INT32: /* Double-size signed integer 2 x 16-bit registers */
910                         data32s = tvb_get_ntohl(next_tvb, data_offset);
911                         proto_tree_add_uint_format(tree, hf_modbus_reg32, next_tvb, data_offset, 4, reg_num,
912                                                     "Register %u (INT32): %d", reg_num, data32s);
913                         data_offset += 4;
914                         reg_num += 2;
915                         break;
916                     case MODBUS_PREF_REGISTER_FORMAT_IEEE_FLOAT: /* IEEE Floating Point, 2 x 16-bit registers */
917                         data_float = tvb_get_ntohieee_float(next_tvb, data_offset);
918
919                         proto_tree_add_uint_format(tree, hf_modbus_reg32, next_tvb, data_offset, 4, reg_num,
920                                                     "Register %u (IEEE Float): %f", reg_num, data_float);
921                         data_offset += 4;
922                         reg_num += 2;
923                         break;
924                     case MODBUS_PREF_REGISTER_FORMAT_MODICON_FLOAT: /* Modicon Floating Point (word-swap), 2 x 16-bit registers */
925                         /* Modicon-style Floating Point values are stored in reverse-word order.                     */
926                         /* ie: a standard IEEE float value 59.991459 is equal to 0x426ff741                          */
927                         /*     while the Modicon equivalent to this value is 0xf741426f                              */
928                         /* To re-assemble a proper IEEE float, we must retrieve the 2 x 16-bit words, bit-shift the  */
929                         /* "hi" component by 16-bits and then OR them together into a combined 32-bit int.           */
930                         /* Following that operation, use some memcpy magic to copy the 4 raw data bytes from the     */
931                         /* 32-bit integer into a standard float.  Not sure if there is a cleaner way possible using  */
932                         /* the Wireshark libraries, but this seems to work OK.                                        */
933
934                         modflt_lo = tvb_get_ntohs(next_tvb, data_offset);
935                         modflt_hi = tvb_get_ntohs(next_tvb, data_offset+2);
936                         modflt_comb = (guint32)(modflt_hi<<16) | modflt_lo;
937                         memcpy(&modfloat, &modflt_comb, 4);
938
939                         proto_tree_add_uint_format(tree, hf_modbus_reg32, next_tvb, data_offset, 4, reg_num,
940                                                     "Register %u (Modicon Float): %f", reg_num, modfloat);
941                         data_offset += 4;
942                         reg_num += 2;
943                         break;
944                     default:
945                         /* Avoid any chance of an infinite loop */
946                         data_offset = payload_len;
947                         break;
948                     } /* register format switch */
949
950                 } /* while loop */
951
952                 break;
953
954         default:
955             if ( ! dissector_try_string(modbus_data_dissector_table, "data", next_tvb, pinfo, tree, NULL) )
956                 proto_tree_add_item(tree, hf_modbus_data, tvb, payload_start, payload_len, ENC_NA);
957             break;
958         }
959 }
960
961 /* Code to dissect Modbus request message */
962 static int
963 dissect_modbus_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *modbus_tree, guint8 function_code, gint payload_start, gint payload_len)
964 {
965     proto_tree    *group_tree;
966     gint          byte_cnt, group_offset, ii;
967     gint          register_format = MODBUS_PREF_REGISTER_FORMAT_UINT16;  /* Default value for register formatting.. */
968     guint8        mei_code;
969     guint16       reg_base=0, diagnostic_code;
970     guint32       group_byte_cnt, group_word_cnt;
971
972     modbus_conversation   *conv;
973
974     /* See if we have any context */
975     conv = (modbus_conversation *)p_get_proto_data(wmem_file_scope(), pinfo, proto_modbus, 0);
976
977     if (conv) {
978         register_format = conv->register_format;
979     }
980
981     switch (function_code) {
982
983         case READ_COILS:
984         case READ_DISCRETE_INPUTS:
985             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
986             proto_tree_add_item(modbus_tree, hf_modbus_bitcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
987             break;
988
989         case READ_HOLDING_REGS:
990         case READ_INPUT_REGS:
991             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
992             proto_tree_add_item(modbus_tree, hf_modbus_wordcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
993             break;
994
995         case WRITE_SINGLE_COIL:
996             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
997             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 2, 1, register_format, reg_base);
998             proto_tree_add_item(modbus_tree, hf_modbus_padding, tvb, payload_start + 3, 1, ENC_NA);
999             break;
1000
1001         case WRITE_SINGLE_REG:
1002             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1003             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 2, 2, register_format, reg_base);
1004             break;
1005
1006         case READ_EXCEPT_STAT:
1007             /* Do Nothing  */
1008             break;
1009
1010         case DIAGNOSTICS:
1011             diagnostic_code = tvb_get_ntohs(tvb, payload_start);
1012             proto_tree_add_uint(modbus_tree, hf_modbus_diag_sf, tvb, payload_start, 2, diagnostic_code);
1013             switch(diagnostic_code)
1014             {
1015                 case RETURN_QUERY_DATA:
1016                     if (payload_len > 2)
1017                         proto_tree_add_item(modbus_tree, hf_modbus_diag_return_query_data_request, tvb, payload_start+2, payload_len-2, ENC_NA);
1018                     break;
1019                 case RESTART_COMMUNICATION_OPTION:
1020                     proto_tree_add_item(modbus_tree, hf_modbus_diag_restart_communication_option, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1021                     break;
1022                 case CHANGE_ASCII_INPUT_DELIMITER:
1023                     proto_tree_add_item(modbus_tree, hf_modbus_diag_ascii_input_delimiter, tvb, payload_start+2, 1, ENC_BIG_ENDIAN);
1024                     break;
1025                 case RETURN_DIAGNOSTIC_REGISTER:           /* 00 00 Data Field */
1026                 case FORCE_LISTEN_ONLY_MODE:               /* 00 00 Data Field */
1027                 case CLEAR_COUNTERS_AND_DIAG_REG:          /* 00 00 Data Field */
1028                 case RETURN_BUS_MESSAGE_COUNT:             /* 00 00 Data Field */
1029                 case RETURN_BUS_COMM_ERROR_COUNT:          /* 00 00 Data Field */
1030                 case RETURN_BUS_EXCEPTION_ERROR_COUNT:     /* 00 00 Data Field */
1031                 case RETURN_SLAVE_MESSAGE_COUNT:           /* 00 00 Data Field */
1032                 case RETURN_SLAVE_NO_RESPONSE_COUNT:       /* 00 00 Data Field */
1033                 case RETURN_SLAVE_NAK_COUNT:               /* 00 00 Data Field */
1034                 case RETURN_SLAVE_BUSY_COUNT:              /* 00 00 Data Field */
1035                 case RETURN_BUS_CHAR_OVERRUN_COUNT:        /* 00 00 Data Field */
1036                 case CLEAR_OVERRUN_COUNTER_AND_FLAG:
1037                 default:
1038                     if (payload_len > 2)
1039                         dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start+2, payload_len-2, register_format, reg_base);
1040                     break;
1041             }
1042             break;
1043         case WRITE_MULT_COILS:
1044             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1045             proto_tree_add_item(modbus_tree, hf_modbus_bitcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1046             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start + 4);
1047             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start + 4, 1, byte_cnt);
1048             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 5, byte_cnt, register_format, reg_base);
1049             break;
1050
1051         case WRITE_MULT_REGS:
1052             reg_base = tvb_get_ntohs(tvb, payload_start);
1053             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1054             proto_tree_add_item(modbus_tree, hf_modbus_wordcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1055             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start + 4);
1056             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start + 4, 1, byte_cnt);
1057             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 5, byte_cnt, register_format, reg_base);
1058             break;
1059
1060         case READ_FILE_RECORD:
1061             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1062             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1,
1063                     byte_cnt);
1064
1065             /* add subtrees to describe each group of packet */
1066             group_offset = payload_start + 1;
1067             for (ii = 0; ii < byte_cnt / 7; ii++) {
1068                 group_tree = proto_tree_add_subtree_format( modbus_tree, tvb, group_offset, 7,
1069                         ett_group_hdr, NULL, "Group %u", ii);
1070                 proto_tree_add_item(group_tree, hf_modbus_reftype, tvb, group_offset, 1, ENC_BIG_ENDIAN);
1071                 proto_tree_add_item(group_tree, hf_modbus_lreference, tvb, group_offset + 1, 4, ENC_BIG_ENDIAN);
1072                 proto_tree_add_item(group_tree, hf_modbus_wordcnt, tvb, group_offset + 5, 2, ENC_BIG_ENDIAN);
1073                 group_offset += 7;
1074             }
1075             break;
1076
1077         case WRITE_FILE_RECORD:
1078             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1079             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1, byte_cnt);
1080
1081             /* add subtrees to describe each group of packet */
1082             group_offset = payload_start + 1;
1083             ii = 0;
1084             while (byte_cnt > 0) {
1085                 group_word_cnt = tvb_get_ntohs(tvb, group_offset + 5);
1086                 group_byte_cnt = (2 * group_word_cnt) + 7;
1087                 group_tree = proto_tree_add_subtree_format( modbus_tree, tvb, group_offset,
1088                         group_byte_cnt, ett_group_hdr, NULL, "Group %u", ii);
1089                 proto_tree_add_item(group_tree, hf_modbus_reftype, tvb, group_offset, 1, ENC_BIG_ENDIAN);
1090                 proto_tree_add_item(group_tree, hf_modbus_lreference, tvb, group_offset + 1, 4, ENC_BIG_ENDIAN);
1091                 proto_tree_add_uint(group_tree, hf_modbus_wordcnt, tvb, group_offset + 5, 2, group_word_cnt);
1092                 dissect_modbus_data(tvb, pinfo, group_tree, function_code, group_offset + 7, group_byte_cnt - 7, register_format, reg_base);
1093                 group_offset += group_byte_cnt;
1094                 byte_cnt -= group_byte_cnt;
1095                 ii++;
1096             }
1097             break;
1098
1099         case MASK_WRITE_REG:
1100             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1101             proto_tree_add_item(modbus_tree, hf_modbus_andmask, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1102             proto_tree_add_item(modbus_tree, hf_modbus_ormask, tvb, payload_start + 4, 2, ENC_BIG_ENDIAN);
1103             break;
1104
1105         case READ_WRITE_REG:
1106             proto_tree_add_item(modbus_tree, hf_modbus_readref, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1107             proto_tree_add_item(modbus_tree, hf_modbus_readwordcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1108             proto_tree_add_item(modbus_tree, hf_modbus_writeref, tvb, payload_start + 4, 2, ENC_BIG_ENDIAN);
1109             proto_tree_add_item(modbus_tree, hf_modbus_writewordcnt, tvb, payload_start + 6, 2, ENC_BIG_ENDIAN);
1110             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start + 8);
1111             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start + 8, 1, byte_cnt);
1112             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 9, byte_cnt, register_format, reg_base);
1113             break;
1114
1115         case READ_FIFO_QUEUE:
1116             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1117             break;
1118
1119         case ENCAP_INTERFACE_TRANSP:
1120             proto_tree_add_item(modbus_tree, hf_modbus_mei, tvb, payload_start, 1, ENC_BIG_ENDIAN);
1121             mei_code = tvb_get_guint8(tvb, payload_start);
1122             switch (mei_code)
1123             {
1124                 case READ_DEVICE_ID:
1125                     proto_tree_add_item(modbus_tree, hf_modbus_read_device_id, tvb, payload_start+1, 1, ENC_BIG_ENDIAN);
1126                     proto_tree_add_item(modbus_tree, hf_modbus_object_id, tvb, payload_start+2, 1, ENC_BIG_ENDIAN);
1127                     break;
1128
1129                 case CANOPEN_REQ_RESP:
1130                     /* CANopen protocol not part of the Modbus/TCP specification */
1131                 default:
1132                     if (payload_len > 1)
1133                         dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start, payload_len-1, register_format, reg_base);
1134                     break;
1135             }
1136
1137             break;
1138
1139         case REPORT_SLAVE_ID:
1140         default:
1141             if (payload_len > 0)
1142                 dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start, payload_len, register_format, reg_base);
1143             break;
1144
1145     } /* Function Code */
1146
1147     return tvb_captured_length(tvb);
1148 }
1149
1150 /* Code to dissect Modbus Response message */
1151 static int
1152 dissect_modbus_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *modbus_tree, guint8 function_code, gint payload_start, gint payload_len)
1153 {
1154
1155     proto_tree    *group_tree, *event_tree, *event_item_tree, *device_objects_tree, *device_objects_item_tree;
1156     proto_item    *mei;
1157     gint          byte_cnt, group_offset, event_index, object_index, object_len, num_objects, ii;
1158     gint          register_format = MODBUS_PREF_REGISTER_FORMAT_UINT16;  /* Default value for register formatting.. */
1159     guint8        object_type, mei_code, event_code;
1160     guint16       reg_base=0, diagnostic_code;
1161     guint32       group_byte_cnt, group_word_cnt;
1162
1163     /* Conversation tracking */
1164     proto_item            *request_frame_item;
1165     modbus_conversation   *conv;
1166     guint8                req_function_code;
1167     guint32               req_frame_num;
1168     gboolean              request_found = FALSE;
1169     modbus_request_info_t *request_data;
1170
1171     /* See if we have any context */
1172     conv = (modbus_conversation *)p_get_proto_data(wmem_file_scope(), pinfo, proto_modbus, 0);
1173
1174     if (conv) {
1175
1176         wmem_list_frame_t *frame = wmem_list_head(conv->modbus_request_frame_data);
1177         /* Step backward through all logged instances of request frames, looking for a request frame number that
1178            occurred immediately prior to current frame number that has a matching function code */
1179         while (frame && !request_found) {
1180             request_data = (modbus_request_info_t *)wmem_list_frame_data(frame);
1181             req_frame_num = request_data->fnum;
1182             req_function_code = request_data->function_code;
1183             if ((pinfo->num > req_frame_num) && (req_function_code == function_code)) {
1184                 request_frame_item = proto_tree_add_uint(modbus_tree, hf_modbus_request_frame, tvb, 0, 0, req_frame_num);
1185                 reg_base = request_data->base_address;
1186                 PROTO_ITEM_SET_GENERATED(request_frame_item);
1187                 request_found = TRUE;
1188             }
1189             frame = wmem_list_frame_next(frame);
1190         }
1191
1192         register_format = conv->register_format;
1193     } /* conv */
1194
1195     switch (function_code) {
1196
1197         case READ_COILS:
1198         case READ_DISCRETE_INPUTS:
1199             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1200             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1, byte_cnt);
1201             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 1, byte_cnt, register_format, reg_base);
1202             break;
1203
1204         case READ_HOLDING_REGS:
1205         case READ_INPUT_REGS:
1206             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1207             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1, byte_cnt);
1208             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 1, byte_cnt, register_format, reg_base);
1209             break;
1210
1211         case WRITE_SINGLE_COIL:
1212             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1213             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 2, 1, register_format, reg_base);
1214             proto_tree_add_item(modbus_tree, hf_modbus_padding, tvb, payload_start + 3, 1, ENC_NA);
1215             break;
1216
1217         case WRITE_SINGLE_REG:
1218             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1219             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 2, 2, register_format, reg_base);
1220             break;
1221
1222         case READ_EXCEPT_STAT:
1223             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start, 1, register_format, reg_base);
1224             break;
1225
1226         case DIAGNOSTICS:
1227             diagnostic_code = tvb_get_ntohs(tvb, payload_start);
1228             proto_tree_add_uint(modbus_tree, hf_modbus_diag_sf, tvb, payload_start, 2, diagnostic_code);
1229             switch(diagnostic_code)
1230             {
1231                 case RETURN_QUERY_DATA: /* Echo of Request */
1232                     if (payload_len > 2)
1233                         proto_tree_add_item(modbus_tree, hf_modbus_diag_return_query_data_echo, tvb, payload_start+2, payload_len-2, ENC_NA);
1234                     break;
1235                 case RESTART_COMMUNICATION_OPTION:  /* Echo of Request */
1236                     proto_tree_add_item(modbus_tree, hf_modbus_diag_restart_communication_option, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1237                     break;
1238                 case RETURN_DIAGNOSTIC_REGISTER:
1239                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_diag_register, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1240                     break;
1241                 case CHANGE_ASCII_INPUT_DELIMITER:   /* XXX - Do we expect this to ever be a response? */
1242                     proto_tree_add_item(modbus_tree, hf_modbus_diag_ascii_input_delimiter, tvb, payload_start+2, 1, ENC_BIG_ENDIAN);
1243                     break;
1244                 case CLEAR_COUNTERS_AND_DIAG_REG:   /* Echo of Request */
1245                     proto_tree_add_item(modbus_tree, hf_modbus_diag_clear_ctr_diag_reg, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1246                     break;
1247                 case RETURN_BUS_MESSAGE_COUNT:
1248                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_bus_message_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1249                     break;
1250                 case RETURN_BUS_COMM_ERROR_COUNT:
1251                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_bus_comm_error_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1252                     break;
1253                 case RETURN_BUS_EXCEPTION_ERROR_COUNT:
1254                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_bus_exception_error_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1255                     break;
1256                 case RETURN_SLAVE_MESSAGE_COUNT:
1257                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_slave_message_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1258                     break;
1259                 case RETURN_SLAVE_NO_RESPONSE_COUNT:
1260                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_no_slave_response_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1261                     break;
1262                 case RETURN_SLAVE_NAK_COUNT:
1263                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_slave_nak_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1264                     break;
1265                 case RETURN_SLAVE_BUSY_COUNT:
1266                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_slave_busy_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1267                     break;
1268                 case RETURN_BUS_CHAR_OVERRUN_COUNT:
1269                     proto_tree_add_item(modbus_tree, hf_modbus_diag_return_bus_char_overrun_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1270                     break;
1271                 case CLEAR_OVERRUN_COUNTER_AND_FLAG:        /* Echo of Request */
1272                 case FORCE_LISTEN_ONLY_MODE:                /* No response anticipated */
1273                 default:
1274                     if (payload_len > 2)
1275                         dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start+2, payload_len-2, register_format, reg_base);
1276                     break;
1277             } /* diagnostic_code */
1278             break;
1279
1280         case GET_COMM_EVENT_CTRS:
1281             proto_tree_add_item(modbus_tree, hf_modbus_status, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1282             proto_tree_add_item(modbus_tree, hf_modbus_event_count, tvb, payload_start+2, 2, ENC_BIG_ENDIAN);
1283             break;
1284
1285         case GET_COMM_EVENT_LOG:
1286             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1287             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1, byte_cnt);
1288             proto_tree_add_item(modbus_tree, hf_modbus_status, tvb, payload_start+1, 2, ENC_BIG_ENDIAN);
1289             proto_tree_add_item(modbus_tree, hf_modbus_event_count, tvb, payload_start+3, 2, ENC_BIG_ENDIAN);
1290             proto_tree_add_item(modbus_tree, hf_modbus_message_count, tvb, payload_start+5, 2, ENC_BIG_ENDIAN);
1291             if (byte_cnt-6 > 0) {
1292                 byte_cnt -= 6;
1293                 event_index = 0;
1294                 event_tree = proto_tree_add_subtree(modbus_tree, tvb, payload_start+7, byte_cnt, ett_events, NULL, "Events");
1295                 while (byte_cnt > 0) {
1296                     event_code = tvb_get_guint8(tvb, payload_start+7+event_index);
1297                     if (event_code == 0) {
1298                         proto_tree_add_uint_format(event_tree, hf_modbus_event, tvb, payload_start+7+event_index, 1, event_code, "Initiated Communication Restart");
1299                     }
1300                     else if (event_code == 4) {
1301                         proto_tree_add_uint_format(event_tree, hf_modbus_event, tvb, payload_start+7+event_index, 1, event_code, "Entered Listen Only Mode");
1302                     }
1303                     else if (event_code & REMOTE_DEVICE_RECV_EVENT_MASK) {
1304                         mei = proto_tree_add_uint_format(event_tree, hf_modbus_event, tvb, payload_start+7+event_index, 1,
1305                                     event_code, "Receive Event: 0x%02X", event_code);
1306                         event_item_tree = proto_item_add_subtree(mei, ett_events_recv);
1307
1308                         /* add subtrees to describe each event bit */
1309                         proto_tree_add_item(event_item_tree, hf_modbus_event_recv_comm_err,
1310                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1311                         proto_tree_add_item(event_item_tree, hf_modbus_event_recv_char_over,
1312                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1313                         proto_tree_add_item(event_item_tree, hf_modbus_event_recv_lo_mode,
1314                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1315                         proto_tree_add_item(event_item_tree, hf_modbus_event_recv_broadcast,
1316                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1317                     }
1318                     else if ((event_code & REMOTE_DEVICE_SEND_EVENT_MASK) == REMOTE_DEVICE_SEND_EVENT_VALUE) {
1319                         mei = proto_tree_add_uint_format(event_tree, hf_modbus_event, tvb, payload_start+7+event_index, 1,
1320                                     event_code, "Send Event: 0x%02X", event_code);
1321                         event_item_tree = proto_item_add_subtree(mei, ett_events_send);
1322
1323                         /* add subtrees to describe each event bit */
1324                         proto_tree_add_item(event_item_tree, hf_modbus_event_send_read_ex,
1325                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1326                         proto_tree_add_item(event_item_tree, hf_modbus_event_send_slave_abort_ex,
1327                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1328                         proto_tree_add_item(event_item_tree, hf_modbus_event_send_slave_busy_ex,
1329                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1330                         proto_tree_add_item(event_item_tree, hf_modbus_event_send_slave_nak_ex,
1331                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1332                         proto_tree_add_item(event_item_tree, hf_modbus_event_send_write_timeout,
1333                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1334                         proto_tree_add_item(event_item_tree, hf_modbus_event_send_lo_mode,
1335                           tvb, payload_start+7+event_index, 1, ENC_LITTLE_ENDIAN );
1336                     }
1337                     else {
1338                         proto_tree_add_uint_format(event_tree, hf_modbus_event, tvb, payload_start+7+event_index, 1, event_code, "Unknown Event");
1339                     }
1340
1341                     byte_cnt--;
1342                     event_index++;
1343                 }
1344             }
1345             break;
1346
1347         case WRITE_MULT_COILS:
1348             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1349             proto_tree_add_item(modbus_tree, hf_modbus_bitcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1350             break;
1351
1352         case WRITE_MULT_REGS:
1353             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1354             proto_tree_add_item(modbus_tree, hf_modbus_wordcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1355             break;
1356
1357         case READ_FILE_RECORD:
1358             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1359             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1,
1360                     byte_cnt);
1361
1362             /* add subtrees to describe each group of packet */
1363             group_offset = payload_start + 1;
1364             ii = 0;
1365             while (byte_cnt > 0) {
1366                 group_byte_cnt = (guint32)tvb_get_guint8(tvb, group_offset);
1367                 group_tree = proto_tree_add_subtree_format( modbus_tree, tvb, group_offset, group_byte_cnt + 1,
1368                         ett_group_hdr, NULL, "Group %u", ii);
1369                 proto_tree_add_uint(group_tree, hf_modbus_bytecnt, tvb, group_offset, 1,
1370                         group_byte_cnt);
1371                 proto_tree_add_item(group_tree, hf_modbus_reftype, tvb, group_offset + 1, 1, ENC_BIG_ENDIAN);
1372                 dissect_modbus_data(tvb, pinfo, group_tree, function_code, group_offset + 2, group_byte_cnt - 1, register_format, reg_base);
1373                 group_offset += (group_byte_cnt + 1);
1374                 byte_cnt -= (group_byte_cnt + 1);
1375                 ii++;
1376             }
1377             break;
1378
1379         case WRITE_FILE_RECORD:   /* Normal response is echo of request */
1380             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1381             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1, byte_cnt);
1382
1383             /* add subtrees to describe each group of packet */
1384             group_offset = payload_start + 1;
1385             ii = 0;
1386             while (byte_cnt > 0) {
1387                 group_word_cnt = tvb_get_ntohs(tvb, group_offset + 5);
1388                 group_byte_cnt = (2 * group_word_cnt) + 7;
1389                 group_tree = proto_tree_add_subtree_format( modbus_tree, tvb, group_offset,
1390                         group_byte_cnt, ett_group_hdr, NULL, "Group %u", ii);
1391                 proto_tree_add_item(group_tree, hf_modbus_reftype, tvb, group_offset, 1, ENC_BIG_ENDIAN);
1392                 proto_tree_add_item(group_tree, hf_modbus_lreference, tvb, group_offset + 1, 4, ENC_BIG_ENDIAN);
1393                 proto_tree_add_uint(group_tree, hf_modbus_wordcnt, tvb, group_offset + 5, 2, group_word_cnt);
1394                 dissect_modbus_data(tvb, pinfo, group_tree, function_code, group_offset + 7, group_byte_cnt - 7, register_format, reg_base);
1395                 group_offset += group_byte_cnt;
1396                 byte_cnt -= group_byte_cnt;
1397                 ii++;
1398             }
1399             break;
1400
1401         case MASK_WRITE_REG:      /* Normal response is echo of request */
1402             proto_tree_add_item(modbus_tree, hf_modbus_reference, tvb, payload_start, 2, ENC_BIG_ENDIAN);
1403             proto_tree_add_item(modbus_tree, hf_modbus_andmask, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1404             proto_tree_add_item(modbus_tree, hf_modbus_ormask, tvb, payload_start + 4, 2, ENC_BIG_ENDIAN);
1405             break;
1406
1407         case READ_WRITE_REG:
1408             byte_cnt = (guint32)tvb_get_guint8(tvb, payload_start);
1409             proto_tree_add_uint(modbus_tree, hf_modbus_bytecnt, tvb, payload_start, 1, byte_cnt);
1410             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 1, byte_cnt, register_format, reg_base);
1411             break;
1412
1413         case READ_FIFO_QUEUE:
1414             byte_cnt = (guint32)tvb_get_ntohs(tvb, payload_start);
1415             proto_tree_add_uint(modbus_tree, hf_modbus_lbytecnt, tvb, payload_start, 2, byte_cnt);
1416             proto_tree_add_item(modbus_tree, hf_modbus_wordcnt, tvb, payload_start + 2, 2, ENC_BIG_ENDIAN);
1417             dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start + 4, byte_cnt - 2, register_format, reg_base);
1418             break;
1419
1420         case ENCAP_INTERFACE_TRANSP:
1421             proto_tree_add_item(modbus_tree, hf_modbus_mei, tvb, payload_start, 1, ENC_BIG_ENDIAN);
1422             mei_code = tvb_get_guint8(tvb, payload_start);
1423             switch (mei_code)
1424             {
1425                 case READ_DEVICE_ID:
1426                     proto_tree_add_item(modbus_tree, hf_modbus_read_device_id, tvb, payload_start+1, 1, ENC_BIG_ENDIAN);
1427                     proto_tree_add_item(modbus_tree, hf_modbus_conformity_level, tvb, payload_start+2, 1, ENC_BIG_ENDIAN);
1428                     proto_tree_add_item(modbus_tree, hf_modbus_more_follows, tvb, payload_start+3, 1, ENC_BIG_ENDIAN);
1429                     proto_tree_add_item(modbus_tree, hf_modbus_next_object_id, tvb, payload_start+4, 1, ENC_BIG_ENDIAN);
1430                     num_objects = tvb_get_guint8(tvb, payload_start+5);
1431                     proto_tree_add_uint(modbus_tree, hf_modbus_num_objects, tvb, payload_start+5, 1, num_objects);
1432                     device_objects_tree = proto_tree_add_subtree(modbus_tree, tvb, payload_start+6, payload_len-6,
1433                                                                     ett_device_id_objects, NULL, "Objects");
1434
1435                     object_index = 0;
1436                     for (ii = 0; ii < num_objects; ii++)
1437                     {
1438                         /* add each "object item" as its own subtree */
1439
1440                         /* compute length of object */
1441                         object_type = tvb_get_guint8(tvb, payload_start+6+object_index);
1442                         object_len = tvb_get_guint8(tvb, payload_start+6+object_index+1);
1443
1444                         device_objects_item_tree = proto_tree_add_subtree_format(device_objects_tree, tvb, payload_start+6+object_index, 2+object_len,
1445                                                     ett_device_id_object_items, NULL, "Object #%d", ii+1);
1446
1447                         proto_tree_add_item(device_objects_item_tree, hf_modbus_object_id, tvb, payload_start+6+object_index, 1, ENC_BIG_ENDIAN);
1448                         object_index++;
1449
1450                         proto_tree_add_uint(device_objects_item_tree, hf_modbus_list_object_len, tvb, payload_start+6+object_index, 1, object_len);
1451                         object_index++;
1452
1453                         if (object_type < 7)
1454                         {
1455                             proto_tree_add_item(device_objects_item_tree, hf_modbus_object_str_value, tvb, payload_start+6+object_index, object_len, ENC_ASCII|ENC_NA);
1456                         }
1457                         else
1458                         {
1459                             if (object_len > 0)
1460                                 proto_tree_add_item(device_objects_item_tree, hf_modbus_object_value, tvb, payload_start+6+object_index, object_len, ENC_NA);
1461                         }
1462                         object_index += object_len;
1463                     } /* for ii */
1464                     break;
1465
1466                 case CANOPEN_REQ_RESP:
1467                     /* CANopen protocol not part of the Modbus/TCP specification */
1468                 default:
1469                     if (payload_len > 1)
1470                         dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start, payload_len-1, register_format, reg_base);
1471                     break;
1472             } /* mei_code */
1473             break;
1474
1475         case REPORT_SLAVE_ID:
1476         default:
1477             if (payload_len > 0)
1478                 dissect_modbus_data(tvb, pinfo, modbus_tree, function_code, payload_start, payload_len, register_format, reg_base);
1479             break;
1480
1481     } /* function code */
1482
1483     return tvb_captured_length(tvb);
1484 }
1485
1486
1487 /* Dissect the Modbus Payload.  Called from either Modbus/TCP or Modbus RTU Dissector */
1488 static int
1489 dissect_modbus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
1490 {
1491     proto_tree    *modbus_tree;
1492     proto_item    *mi;
1493     int           offset = 0;
1494     int*          packet_type = (int*)data;
1495     gint          payload_start, payload_len, len;
1496     guint8        function_code, exception_code;
1497
1498     /* Reject the packet if data passed from the mbrtu or mbtcp dissector is NULL */
1499     if (packet_type == NULL)
1500         return 0;
1501
1502     len = tvb_captured_length(tvb);
1503
1504     /* If the packet is zero-length, we should not attempt to dissect any further */
1505     if (len == 0)
1506         return 0;
1507
1508     /* Add items to protocol tree specific to Modbus */
1509     mi = proto_tree_add_protocol_format(tree, proto_modbus, tvb, offset, len, "Modbus");
1510     modbus_tree = proto_item_add_subtree(mi, ett_modbus_hdr);
1511
1512     function_code = tvb_get_guint8(tvb, offset) & 0x7F;
1513     proto_tree_add_item(modbus_tree, hf_modbus_functioncode, tvb, offset, 1, ENC_BIG_ENDIAN);
1514
1515     /* Conversation support */
1516     if (!pinfo->fd->flags.visited) {
1517         conversation_t       *conversation = NULL;
1518         modbus_conversation  *modbus_conv_data = NULL;
1519
1520         /* Find a conversation, create a new if no one exists */
1521         conversation = find_or_create_conversation(pinfo);
1522         modbus_conv_data = (modbus_conversation *)conversation_get_proto_data(conversation, proto_modbus);
1523
1524         if (modbus_conv_data == NULL){
1525            modbus_conv_data = wmem_new(wmem_file_scope(), modbus_conversation);
1526            modbus_conv_data->modbus_request_frame_data = wmem_list_new(wmem_file_scope());
1527            modbus_conv_data->register_format = global_mbus_register_format;
1528            conversation_add_proto_data(conversation, proto_modbus, (void *)modbus_conv_data);
1529         }
1530
1531         p_add_proto_data(wmem_file_scope(), pinfo, proto_modbus, 0, modbus_conv_data);
1532
1533         if (*packet_type == QUERY_PACKET) {
1534             /*create the modbus_request frame. It holds the request information.*/
1535             modbus_request_info_t    *frame_ptr = wmem_new(wmem_file_scope(), modbus_request_info_t);
1536
1537             /* load information into the modbus request frame */
1538             frame_ptr->fnum = pinfo->num;
1539             frame_ptr->function_code = function_code;
1540             frame_ptr->base_address = tvb_get_ntohs(tvb, 1);
1541             frame_ptr->num_reg = tvb_get_ntohs(tvb, 3);
1542
1543             wmem_list_prepend(modbus_conv_data->modbus_request_frame_data, frame_ptr);
1544         }
1545
1546     } /* !visited */
1547
1548     /* Find exception - last bit set in function code */
1549     if (tvb_get_guint8(tvb, offset) & 0x80 ) {
1550         exception_code = tvb_get_guint8(tvb, offset+1);
1551     }
1552     else {
1553         exception_code = 0;
1554     }
1555
1556     payload_start = offset + 1;
1557     payload_len = len - 1;
1558
1559     if (exception_code != 0) {
1560         proto_item_set_text(mi, "Function %u:  %s.  Exception: %s",
1561                             function_code,
1562                             val_to_str_const(function_code, function_code_vals, "Unknown Function"),
1563                             val_to_str(exception_code,
1564                                        exception_code_vals,
1565                                        "Unknown Exception Code (%u)"));
1566         proto_tree_add_uint(modbus_tree, hf_modbus_exceptioncode, tvb, payload_start, 1,
1567                             exception_code);
1568     }
1569     else {
1570
1571         /* Follow different dissection path depending on whether packet is query or response */
1572         if (*packet_type == QUERY_PACKET) {
1573             dissect_modbus_request(tvb, pinfo, modbus_tree, function_code, payload_start, payload_len);
1574         }
1575         else if (*packet_type == RESPONSE_PACKET) {
1576             dissect_modbus_response(tvb, pinfo, modbus_tree, function_code, payload_start, payload_len);
1577         }
1578
1579     }
1580
1581     return tvb_captured_length(tvb);
1582 }
1583
1584 static void
1585 apply_mbtcp_prefs(void)
1586 {
1587     /* Modbus/RTU uses the port preference to determine request/response */
1588     global_mbus_tcp_port = prefs_get_uint_value("mbtcp", "tcp.port");
1589     global_mbus_udp_port = prefs_get_uint_value("mbudp", "udp.port");
1590 }
1591
1592 static void
1593 apply_mbrtu_prefs(void)
1594 {
1595     /* Modbus/RTU uses the port preference to determine request/response */
1596     global_mbus_tcp_rtu_port = prefs_get_uint_value("mbrtu", "tcp.port");
1597     global_mbus_udp_rtu_port = prefs_get_uint_value("mbrtu", "udp.port");
1598 }
1599
1600 /* Register the protocol with Wireshark */
1601 void
1602 proto_register_modbus(void)
1603 {
1604     /* Modbus/TCP header fields */
1605     static hf_register_info mbtcp_hf[] = {
1606         { &hf_mbtcp_transid,
1607             { "Transaction Identifier", "mbtcp.trans_id",
1608             FT_UINT16, BASE_DEC, NULL, 0x0,
1609             NULL, HFILL }
1610         },
1611         { &hf_mbtcp_protid,
1612             { "Protocol Identifier", "mbtcp.prot_id",
1613             FT_UINT16, BASE_DEC, NULL, 0x0,
1614             NULL, HFILL }
1615         },
1616         { &hf_mbtcp_len,
1617             { "Length", "mbtcp.len",
1618             FT_UINT16, BASE_DEC, NULL, 0x0,
1619             NULL, HFILL }
1620         },
1621         { &hf_mbtcp_unitid,
1622             { "Unit Identifier", "mbtcp.unit_id",
1623             FT_UINT8, BASE_DEC, NULL, 0x0,
1624             NULL, HFILL }
1625         },
1626     };
1627
1628     static ei_register_info mbtcp_ei[] = {
1629         { &ei_mbtcp_cannot_classify,
1630           { "mbtcp.cannot_classify", PI_PROTOCOL, PI_WARN,
1631             "Cannot classify packet type. Try setting Modbus/TCP Port preference to this destination or source port", EXPFILL }
1632         },
1633     };
1634
1635     /* Modbus RTU header fields */
1636     static hf_register_info mbrtu_hf[] = {
1637         { &hf_mbrtu_unitid,
1638             { "Unit ID", "mbrtu.unit_id",
1639             FT_UINT8, BASE_DEC, NULL, 0x0,
1640             NULL, HFILL }
1641         },
1642         { &hf_mbrtu_crc16,
1643             { "CRC-16", "mbrtu.crc16",
1644             FT_UINT16, BASE_HEX, NULL, 0x0,
1645             NULL, HFILL }
1646         },
1647         { &hf_mbrtu_crc16_status,
1648             { "CRC-16 Status", "mbrtu.crc16.status",
1649             FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
1650             NULL, HFILL }
1651         },
1652     };
1653
1654     static ei_register_info mbrtu_ei[] = {
1655         { &ei_mbrtu_crc16_incorrect,
1656           { "mbrtu.crc16.incorrect", PI_CHECKSUM, PI_WARN,
1657             "Incorrect CRC", EXPFILL }
1658         },
1659     };
1660
1661     /* Modbus header fields */
1662     static hf_register_info hf[] = {
1663         { &hf_modbus_request_frame,
1664             { "Request Frame", "modbus.request_frame",
1665             FT_FRAMENUM, BASE_NONE,
1666             NULL, 0x0,
1667             NULL, HFILL }
1668         },
1669         { &hf_modbus_functioncode,
1670             { "Function Code", "modbus.func_code",
1671             FT_UINT8, BASE_DEC, VALS(function_code_vals), 0x7F,
1672             NULL, HFILL }
1673         },
1674         { &hf_modbus_reference,
1675             { "Reference Number", "modbus.reference_num",
1676             FT_UINT16, BASE_DEC, NULL, 0x0,
1677             NULL, HFILL }
1678         },
1679         { &hf_modbus_padding,
1680             { "Padding", "modbus.padding",
1681             FT_UINT8, BASE_HEX, NULL, 0x0,
1682             NULL, HFILL }
1683         },
1684         { &hf_modbus_lreference,
1685             { "Reference Number (32 bit)", "modbus.reference_num_32",
1686             FT_UINT32, BASE_DEC, NULL, 0x0,
1687             NULL, HFILL }
1688         },
1689         { &hf_modbus_reftype,
1690             { "Reference Type", "modbus.reference_type",
1691             FT_UINT8, BASE_DEC, NULL, 0x0,
1692             NULL, HFILL }
1693         },
1694         { &hf_modbus_readref,
1695             { "Read Reference Number", "modbus.read_reference_num",
1696             FT_UINT16, BASE_DEC, NULL, 0x0,
1697             NULL, HFILL }
1698         },
1699         { &hf_modbus_writeref,
1700             { "Write Reference Number", "modbus.write_reference_num",
1701             FT_UINT16, BASE_DEC, NULL, 0x0,
1702             NULL, HFILL }
1703         },
1704         { &hf_modbus_wordcnt,
1705             { "Word Count", "modbus.word_cnt",
1706             FT_UINT16, BASE_DEC, NULL, 0x0,
1707             NULL, HFILL }
1708         },
1709         { &hf_modbus_readwordcnt,
1710             { "Read Word Count", "modbus.read_word_cnt",
1711             FT_UINT16, BASE_DEC, NULL, 0x0,
1712             NULL, HFILL }
1713         },
1714         { &hf_modbus_writewordcnt,
1715             { "Write Word Count", "modbus.write_word_cnt",
1716             FT_UINT16, BASE_DEC, NULL, 0x0,
1717             NULL, HFILL }
1718         },
1719         { &hf_modbus_bitcnt,
1720             { "Bit Count", "modbus.bit_cnt",
1721             FT_UINT16, BASE_DEC, NULL, 0x0,
1722             NULL, HFILL }
1723         },
1724         { &hf_modbus_bytecnt,
1725             { "Byte Count", "modbus.byte_cnt",
1726             FT_UINT8, BASE_DEC, NULL, 0x0,
1727             NULL, HFILL }
1728         },
1729         { &hf_modbus_lbytecnt,
1730             { "Byte Count (16-bit)", "modbus.byte_cnt_16",
1731             FT_UINT8, BASE_DEC, NULL, 0x0,
1732             NULL, HFILL }
1733         },
1734         { &hf_modbus_exceptioncode,
1735             { "Exception Code", "modbus.exception_code",
1736             FT_UINT8, BASE_DEC, VALS(exception_code_vals), 0x0,
1737             NULL, HFILL }
1738         },
1739         { &hf_modbus_diag_sf,
1740             { "Diagnostic Code", "modbus.diagnostic_code",
1741             FT_UINT16, BASE_DEC, VALS(diagnostic_code_vals), 0x0,
1742             NULL, HFILL }
1743         },
1744         { &hf_modbus_diag_return_query_data_request,
1745             { "Request Data", "modbus.diagnostic.return_query_data.request",
1746             FT_BYTES, BASE_NONE, NULL, 0x0,
1747             NULL, HFILL }
1748         },
1749         { &hf_modbus_diag_return_query_data_echo,
1750             { "Echo Data", "modbus.diagnostic.return_query_data.echo",
1751             FT_BYTES, BASE_NONE, NULL, 0x0,
1752             NULL, HFILL }
1753         },
1754         { &hf_modbus_diag_restart_communication_option,
1755             { "Restart Communication Option", "modbus.diagnostic.restart_communication_option",
1756             FT_UINT16, BASE_HEX, VALS(diagnostic_restart_communication_option_vals), 0x0,
1757             NULL, HFILL }
1758         },
1759         { &hf_modbus_diag_return_diag_register,
1760             { "Diagnostic Register Contents", "modbus.diagnostic.return_diag_register",
1761             FT_UINT16, BASE_HEX, NULL, 0x0,
1762             NULL, HFILL }
1763         },
1764         { &hf_modbus_diag_ascii_input_delimiter,
1765             { "CHAR", "modbus.diagnostic.ascii_input_delimiter",
1766             FT_UINT8, BASE_HEX, NULL, 0x0,
1767             NULL, HFILL }
1768         },
1769         { &hf_modbus_diag_clear_ctr_diag_reg,
1770             { "Clear Counters & Diag Register Echo", "modbus.diagnostic.clear_ctr_diag_reg",
1771             FT_UINT16, BASE_DEC, NULL, 0x0,
1772             NULL, HFILL }
1773         },
1774         { &hf_modbus_diag_return_bus_message_count,
1775             { "Total Message Count", "modbus.diagnostic.bus_message_count",
1776             FT_UINT16, BASE_DEC, NULL, 0x0,
1777             NULL, HFILL }
1778         },
1779         { &hf_modbus_diag_return_bus_comm_error_count,
1780             { "CRC Error Count", "modbus.diagnostic.bus_comm_error_count",
1781             FT_UINT16, BASE_DEC, NULL, 0x0,
1782             NULL, HFILL }
1783         },
1784         { &hf_modbus_diag_return_bus_exception_error_count,
1785             { "Exception Error Count", "modbus.diagnostic.bus_exception_error_count",
1786             FT_UINT16, BASE_DEC, NULL, 0x0,
1787             NULL, HFILL }
1788         },
1789         { &hf_modbus_diag_return_slave_message_count,
1790             { "Slave Message Count", "modbus.diagnostic.slave_message_count",
1791             FT_UINT16, BASE_DEC, NULL, 0x0,
1792             NULL, HFILL }
1793         },
1794         { &hf_modbus_diag_return_no_slave_response_count,
1795             { "Slave No Response Count", "modbus.diagnostic.no_slave_response_count",
1796             FT_UINT16, BASE_DEC, NULL, 0x0,
1797             NULL, HFILL }
1798         },
1799         { &hf_modbus_diag_return_slave_nak_count,
1800             { "Slave NAK Count", "modbus.diagnostic.slave_nak_count",
1801             FT_UINT16, BASE_DEC, NULL, 0x0,
1802             NULL, HFILL }
1803         },
1804         { &hf_modbus_diag_return_slave_busy_count,
1805             { "Slave Device Busy Count", "modbus.diagnostic.slave_busy_count",
1806             FT_UINT16, BASE_DEC, NULL, 0x0,
1807             NULL, HFILL }
1808         },
1809         { &hf_modbus_diag_return_bus_char_overrun_count,
1810             { "Slave Character Overrun Count", "modbus.diagnostic.bus_char_overrun_count",
1811             FT_UINT16, BASE_DEC, NULL, 0x0,
1812             NULL, HFILL }
1813         },
1814         { &hf_modbus_status,
1815             { "Status", "modbus.ev_status",
1816             FT_UINT16, BASE_HEX, NULL, 0x0,
1817             NULL, HFILL }
1818         },
1819         { &hf_modbus_event,
1820             { "Event", "modbus.event",
1821             FT_UINT8, BASE_DEC, NULL, 0x0,
1822             NULL, HFILL }
1823         },
1824         { &hf_modbus_event_count,
1825             { "Event Count", "modbus.ev_count",
1826             FT_UINT16, BASE_DEC, NULL, 0x0,
1827             NULL, HFILL }
1828         },
1829         { &hf_modbus_message_count,
1830             { "Message Count", "modbus.ev_msg_count",
1831             FT_UINT16, BASE_DEC, NULL, 0x0,
1832             NULL, HFILL }
1833         },
1834         { &hf_modbus_event_recv_comm_err,
1835             { "Communication Error", "modbus.ev_recv_comm_err",
1836             FT_UINT8, BASE_DEC, NULL, 0x02,
1837             NULL, HFILL }
1838         },
1839         { &hf_modbus_event_recv_char_over,
1840             { "Character Overrun", "modbus.ev_recv_char_over",
1841             FT_UINT8, BASE_DEC, NULL, 0x10,
1842             NULL, HFILL }
1843         },
1844         { &hf_modbus_event_recv_lo_mode,
1845             { "Currently in Listen Only Mode", "modbus.ev_recv_lo_mode",
1846             FT_UINT8, BASE_DEC, NULL, 0x20,
1847             NULL, HFILL }
1848         },
1849         { &hf_modbus_event_recv_broadcast,
1850             { "Broadcast Received", "modbus.ev_recv_broadcast",
1851             FT_UINT8, BASE_DEC, NULL, 0x40,
1852             NULL, HFILL }
1853         },
1854         { &hf_modbus_event_send_read_ex,
1855             { "Read Exception Sent", "modbus.ev_send_read_ex",
1856             FT_UINT8, BASE_DEC, NULL, 0x01,
1857             NULL, HFILL }
1858         },
1859         { &hf_modbus_event_send_slave_abort_ex,
1860             { "Slave Abort Exception Sent", "modbus.ev_send_slave_abort_ex",
1861             FT_UINT8, BASE_DEC, NULL, 0x02,
1862             NULL, HFILL }
1863         },
1864         { &hf_modbus_event_send_slave_busy_ex,
1865             { "Slave Busy Exception Sent", "modbus.ev_send_slave_busy_ex",
1866             FT_UINT8, BASE_DEC, NULL, 0x04,
1867             NULL, HFILL }
1868         },
1869         { &hf_modbus_event_send_slave_nak_ex,
1870             { "Slave Program NAK Exception Sent", "modbus.ev_send_slave_nak_ex",
1871             FT_UINT8, BASE_DEC, NULL, 0x08,
1872             NULL, HFILL }
1873         },
1874         { &hf_modbus_event_send_write_timeout,
1875             { "Write Timeout Error Occurred", "modbus.ev_send_write_timeout",
1876             FT_UINT8, BASE_DEC, NULL, 0x10,
1877             NULL, HFILL }
1878         },
1879         { &hf_modbus_event_send_lo_mode,
1880             { "Currently in Listen Only Mode", "modbus.ev_send_lo_mode",
1881             FT_UINT8, BASE_DEC, NULL, 0x20,
1882             NULL, HFILL }
1883         },
1884         { &hf_modbus_andmask,
1885             { "AND mask", "modbus.and_mask",
1886             FT_UINT16, BASE_HEX, NULL, 0x0,
1887             NULL, HFILL }
1888         },
1889         { &hf_modbus_ormask,
1890             { "OR mask", "modbus.or_mask",
1891             FT_UINT16, BASE_HEX, NULL, 0x0,
1892             NULL, HFILL }
1893         },
1894         { &hf_modbus_data,
1895             { "Data",  "modbus.data",
1896             FT_BYTES,  BASE_NONE, NULL,    0x0, NULL, HFILL }
1897         },
1898         { &hf_modbus_mei,
1899             { "MEI type", "modbus.mei",
1900             FT_UINT8, BASE_DEC, VALS(encap_interface_code_vals), 0x0,
1901             NULL, HFILL }
1902         },
1903         { &hf_modbus_read_device_id,
1904             { "Read Device ID", "modbus.read_device_id",
1905             FT_UINT8, BASE_DEC, VALS(read_device_id_vals), 0x0,
1906             NULL, HFILL }
1907         },
1908         { &hf_modbus_object_id,
1909             { "Object ID", "modbus.object_id",
1910             FT_UINT8, BASE_DEC, VALS(object_id_vals), 0x0,
1911             NULL, HFILL }
1912         },
1913         { &hf_modbus_num_objects,
1914             { "Number of Objects", "modbus.num_objects",
1915             FT_UINT8, BASE_DEC, NULL, 0x0,
1916             NULL, HFILL }
1917         },
1918         { &hf_modbus_list_object_len,
1919             { "Object length", "modbus.objects_len",
1920             FT_UINT8, BASE_DEC, NULL, 0x0,
1921             NULL, HFILL }
1922         },
1923         { &hf_modbus_conformity_level,
1924             { "Conformity Level", "modbus.conformity_level",
1925             FT_UINT8, BASE_HEX, VALS(conformity_level_vals), 0x0,
1926             NULL, HFILL }
1927         },
1928         { &hf_modbus_more_follows,
1929             { "More Follows", "modbus.more_follows",
1930             FT_UINT8, BASE_HEX, NULL, 0x0,
1931             NULL, HFILL }
1932         },
1933         { &hf_modbus_next_object_id,
1934             { "Next Object ID", "modbus.next_object_id",
1935             FT_UINT8, BASE_DEC, NULL, 0x0,
1936             NULL, HFILL }
1937         },
1938         { &hf_modbus_object_str_value,
1939             { "Object String Value", "modbus.object_str_value",
1940             FT_STRING, BASE_NONE, NULL, 0x0,
1941             NULL, HFILL }
1942         },
1943         { &hf_modbus_object_value,
1944             { "Object Value", "modbus.object_value",
1945             FT_BYTES, BASE_NONE, NULL, 0x0,
1946             NULL, HFILL }
1947         },
1948         { &hf_modbus_reg16,
1949             { "Register Value (16-bit)", "modbus.reg16",
1950             FT_UINT16, BASE_DEC, NULL, 0x0,
1951             NULL, HFILL }
1952         },
1953         { &hf_modbus_reg32,
1954             { "Register Value (32-bit)", "modbus.reg32",
1955             FT_UINT32, BASE_DEC, NULL, 0x0,
1956             NULL, HFILL }
1957         },
1958     };
1959
1960     /* Setup protocol subtree array */
1961     static gint *ett[] = {
1962         &ett_mbtcp,
1963         &ett_mbrtu,
1964         &ett_modbus_hdr,
1965         &ett_group_hdr,
1966         &ett_events,
1967         &ett_events_recv,
1968         &ett_events_send,
1969         &ett_device_id_objects,
1970         &ett_device_id_object_items
1971     };
1972
1973     static ei_register_info ei[] = {
1974         { &ei_modbus_data_decode,
1975           { "modbus.data.decode", PI_PROTOCOL, PI_WARN,
1976             "Invalid decoding options, register data not a multiple of 4!", EXPFILL }
1977         },
1978     };
1979     module_t *mbtcp_module;
1980     module_t *mbrtu_module;
1981     module_t *modbus_module;
1982     expert_module_t* expert_mbtcp;
1983     expert_module_t* expert_mbrtu;
1984     expert_module_t* expert_modbus;
1985
1986     /* Register the protocol name and description */
1987     proto_mbtcp = proto_register_protocol("Modbus/TCP", "Modbus/TCP", "mbtcp");
1988     proto_mbudp = proto_register_protocol("Modbus/UDP", "Modbus/UDP", "mbudp");
1989     proto_mbrtu = proto_register_protocol("Modbus RTU", "Modbus RTU", "mbrtu");
1990     proto_modbus = proto_register_protocol("Modbus", "Modbus", "modbus");
1991
1992     /* Registering protocol to be called by another dissector */
1993     modbus_handle = register_dissector("modbus", dissect_modbus, proto_modbus);
1994     mbtcp_handle = register_dissector("mbtcp", dissect_mbtcp, proto_mbtcp);
1995     mbrtu_handle = register_dissector("mbrtu", dissect_mbrtu, proto_mbrtu);
1996     mbudp_handle = register_dissector("mbudp", dissect_mbudp, proto_mbudp);
1997
1998     /* Registering subdissectors table */
1999     modbus_data_dissector_table = register_dissector_table("modbus.data", "Modbus Data", proto_modbus, FT_STRING, BASE_NONE);
2000     modbus_dissector_table = register_dissector_table("mbtcp.prot_id", "Modbus/TCP protocol identifier", proto_mbtcp, FT_UINT16, BASE_DEC);
2001
2002     /* Required function calls to register the header fields and subtrees used */
2003     proto_register_field_array(proto_mbtcp, mbtcp_hf, array_length(mbtcp_hf));
2004     proto_register_field_array(proto_mbrtu, mbrtu_hf, array_length(mbrtu_hf));
2005     proto_register_field_array(proto_modbus, hf, array_length(hf));
2006     proto_register_subtree_array(ett, array_length(ett));
2007     expert_mbtcp = expert_register_protocol(proto_mbtcp);
2008     expert_register_field_array(expert_mbtcp, mbtcp_ei, array_length(mbtcp_ei));
2009     expert_mbrtu = expert_register_protocol(proto_mbrtu);
2010     expert_register_field_array(expert_mbrtu, mbrtu_ei, array_length(mbrtu_ei));
2011     expert_modbus = expert_register_protocol(proto_modbus);
2012     expert_register_field_array(expert_modbus, ei, array_length(ei));
2013
2014
2015     /* Register required preferences for Modbus Protocol variants */
2016     mbtcp_module = prefs_register_protocol(proto_mbtcp, apply_mbtcp_prefs);
2017     mbrtu_module = prefs_register_protocol(proto_mbrtu, apply_mbrtu_prefs);
2018     modbus_module = prefs_register_protocol(proto_modbus, NULL);
2019
2020     /* Modbus RTU Preference - Desegment, defaults to TRUE for TCP desegmentation */
2021     prefs_register_bool_preference(mbtcp_module, "desegment",
2022                                   "Desegment all Modbus RTU packets spanning multiple TCP segments",
2023                                   "Whether the Modbus RTU dissector should desegment all messages spanning multiple TCP segments",
2024                                   &mbtcp_desegment);
2025
2026     /* Modbus RTU Preference - Desegment, defaults to TRUE for TCP desegmentation */
2027     prefs_register_bool_preference(mbrtu_module, "desegment",
2028                                   "Desegment all Modbus RTU packets spanning multiple TCP segments",
2029                                   "Whether the Modbus RTU dissector should desegment all messages spanning multiple TCP segments",
2030                                   &mbrtu_desegment);
2031
2032     /* Modbus RTU Preference - CRC verification, defaults to FALSE (no verification)*/
2033     prefs_register_bool_preference(mbrtu_module, "crc_verification",
2034                                   "Validate CRC",
2035                                   "Whether to validate the CRC",
2036                                   &mbrtu_crc);
2037
2038     /* Modbus Preference - Holding/Input Register format, this allows for deeper dissection of response data */
2039     prefs_register_enum_preference(modbus_module, "mbus_register_format",
2040                                     "Holding/Input Register Format",
2041                                     "Register Format",
2042                                     &global_mbus_register_format,
2043                                     mbus_register_format,
2044                                     FALSE);
2045
2046     /* Obsolete Preferences */
2047     prefs_register_obsolete_preference(mbtcp_module, "mbus_register_addr_type");
2048     prefs_register_obsolete_preference(mbtcp_module, "mbus_register_format");
2049     prefs_register_obsolete_preference(mbrtu_module, "mbus_register_addr_type");
2050     prefs_register_obsolete_preference(mbrtu_module, "mbus_register_format");
2051
2052 }
2053
2054
2055 /* If this dissector uses sub-dissector registration add a registration routine.
2056    This format is required because a script is used to find these routines and
2057    create the code that calls these routines.
2058  */
2059 void
2060 proto_reg_handoff_mbtcp(void)
2061 {
2062     dissector_add_uint_with_preference("tcp.port", PORT_MBTCP, mbtcp_handle);
2063     dissector_add_uint_with_preference("udp.port", PORT_MBTCP, mbudp_handle);
2064
2065     dissector_add_uint("mbtcp.prot_id", MODBUS_PROTOCOL_ID, modbus_handle);
2066
2067 }
2068
2069 void
2070 proto_reg_handoff_mbrtu(void)
2071 {
2072     dissector_handle_t mbrtu_udp_handle = create_dissector_handle(dissect_mbrtu_udp, proto_mbrtu);
2073
2074     /* Make sure to use Modbus RTU Preferences field to determine default TCP port */
2075     dissector_add_for_decode_as_with_preference("udp.port", mbrtu_udp_handle);
2076     dissector_add_for_decode_as_with_preference("tcp.port", mbrtu_handle);
2077
2078     dissector_add_uint("mbtcp.prot_id", MODBUS_PROTOCOL_ID, modbus_handle);
2079     dissector_add_for_decode_as("rtacser.data", mbrtu_handle);
2080     dissector_add_for_decode_as("usb.device", mbrtu_handle);
2081     dissector_add_for_decode_as("usb.product", mbrtu_handle);
2082     dissector_add_for_decode_as("usb.protocol", mbrtu_handle);
2083
2084 }
2085
2086 /*
2087  * Editor modelines
2088  *
2089  * Local Variables:
2090  * c-basic-offset: 4
2091  * tab-width: 8
2092  * indent-tabs-mode: nil
2093  * End:
2094  *
2095  * ex: set shiftwidth=4 tabstop=8 expandtab:
2096  * :indentSize=4:tabSize=8:noTabs=true:
2097  */