Remove executable bit, from not executable files.
[metze/wireshark/wip.git] / epan / dissectors / packet-rtitcp.c
1 /* packet-rtitcp.c
2  * Dissector for the RTI TCP Transport Protocol.
3  * Layer on top of TCP used to send Control messages
4  * to establish and maintain the connections as well as
5  * send RTPS data.
6  *
7  * (c) 2005-2015 Copyright, Real-Time Innovations, Inc.
8  * Real-Time Innovations, Inc.
9  * 232 East Java Drive
10  * Sunnyvale, CA 94089
11  *
12  * Wireshark - Network traffic analyzer
13  * By Gerald Combs <gerald@wireshark.org>
14  * Copyright 1998 Gerald Combs
15  *
16  * This program is free software; you can redistribute it and/or modify
17  * it under the terms of the GNU General Public License as published by
18  * the Free Software Foundation; either version 2 of the License, or
19  * (at your option) any later version.
20  *
21  * This program is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License along
27  * with this program; if not, write to the Free Software Foundation, Inc.,
28  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
29  */
30
31 #include "config.h"
32 #include <glib.h>
33
34 #include <epan/packet.h>
35 #include <epan/expert.h>
36 #include <epan/prefs.h>
37 #include <epan/addr_resolv.h>
38 #include <epan/wmem/wmem.h>
39 #include <epan/conversation.h>
40 #include <epan/dissectors/packet-tcp.h>
41
42 #define RTITCP_MAGIC_NUMBER             0xdd54dd55
43 #define RTPS_MAGIC_NUMBER               0x52545053
44 #define RTITCP_CONTROL_MAGIC_COOKIE     0x2112A442
45 #define RTITCP_CRC_MAGIC_NUMBER         0x43524332
46
47 /* A sample #define of the minimum length (in bytes) of the protocol data.
48  * If data is received with fewer than this many bytes it is rejected by
49  * the current dissector. */
50 #define RTITCP_MIN_LENGTH 8
51 #define NUMBER_2E30 1073741824
52
53 #define IDENTITY_BIND_REQUEST                           (0x0C01)
54 #define IDENTITY_BIND_INDICATION                        (0x0C11)
55 #define IDENTITY_BIND_RESPONSE                          (0x0D01)
56 #define IDENTITY_BIND_ERROR                             (0x0D11)
57
58 #define SERVER_LOGICAL_PORT_REQUEST                     (0x0C02)
59 #define SERVER_LOGICAL_PORT_INDICATION                  (0x0C12)
60 #define SERVER_LOGICAL_PORT_RESPONSE                    (0x0D02)
61 #define SERVER_LOGICAL_PORT_ERROR                       (0x0D12)
62
63 #define CLIENT_LOGICAL_PORT_REQUEST                     (0x0C03)
64 #define CLIENT_LOGICAL_PORT_INDICATION                  (0x0C13)
65 #define CLIENT_LOGICAL_PORT_RESPONSE                    (0x0D03)
66 #define CLIENT_LOGICAL_PORT_ERROR                       (0x0D13)
67
68 #define CONNECTION_BIND_REQUEST                         (0x0C04)
69 #define CONNECTION_BIND_INDICATION                      (0x0C14)
70 #define CONNECTION_BIND_RESPONSE                        (0x0D04)
71 #define CONNECTION_BIND_ERROR                           (0x0D14)
72
73 #define SESSION_ID_REQUEST                              (0x0C05)
74 #define SESSION_ID_INDICATION                           (0x0C15)
75 #define SESSION_ID_RESPONSE                             (0x0D05)
76 #define SESSION_ID_ERROR                                (0x0D15)
77
78 #define LIVELINESS_REQUEST                              (0x0C06)
79 #define LIVELINESS_RESPONSE                             (0x0D06)
80
81 #define FINALIZE_SESSION_REQUEST                        (0x0C0F)
82 #define FINALIZE_SESSION_INDICATION                     (0x0C1F)
83 #define FINALIZE_SESSION_RESPONSE                       (0x0D0F)
84 #define FINALIZE_SESSION_ERRROR                         (0x0D1F)
85
86 #define LOCATOR_KIND_IPV4                               (1)
87 #define LOCATOR_KIND_IPV6                               (2)
88
89 #define RTPS_LOCATOR_ADDRESS_ATTRIBUTE_TYPE             (0x3D01)
90 #define RTPS_LOCATOR_PORT_ATTRIBUTE_TYPE                (0x3D02)
91 #define CONNECTION_TYPE_ATTRIBUTE_TYPE                  (0x3D03)
92 #define CONNECTION_COOKIE_ATTRIBUTE_TYPE                (0x3D04)
93 #define PORT_OPTIONS_ATTRIBUTE_TYPE                     (0x3D05)
94 #define TRANSPORT_PRIORITY_ATTRIBUTE_TYPE               (0x3D06)
95 #define SESSION_ID_ATTRIBUTE_TYPE                       (0x3D07)
96
97 #define MAPPED_ADDRESS_ATTRIBUTE_TYPE                   (0x0001)
98 #define XOR_MAPPED_ADDRESS_ATTRIBUTE_TYPE               (0x0020)
99 #define ERROR_CODE_ATTRIBUTE_TYPE                       (0x0009)
100 #define UNKNOWN_ATTRIBUTES_ATTRIBUTE_TYPE               (0x000A)
101
102 #define SOFTWARE_ATTRIBUTE_TYPE                         (0x8022)
103 #define ALTERNATE_SERVER_ATTRIBUTE_TYPE                 (0x8023)
104
105 #define CLASS_ID_TCPV4_LAN                              (0x00)
106 #define CLASS_ID_TCPV4_WAN                              (0x40)
107 #define CLASS_ID_TLSV4_LAN                              (0x80)
108 #define CLASS_ID_TLSV4_WAN                              (0xC0)
109
110
111 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_OK                                              0
112 /* client requested a transport class not supported by the server */
113 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_TRANSPORT_CLASS_MISMATCH                  1
114 /* required attribute is missing */
115 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_ATTRIBUTE_MISSING                         2
116 /* no matching receive resource for requested port */
117 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_NO_MATCHING_RECVRESOURCE                  3
118 /* no matching cookie found on server */
119 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_NO_MATCH_COOKIE                           4
120 /* fatal internal processing error (caller is not responsible) */
121 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_INTERNAL                                  5
122 /* the operation should be retried at the first occurrence */
123 #define NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_RETRY                                     6
124 #define NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_BAD_REQUEST_ID                        400
125 #define NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_UNKNOWN_ATTRIBUTE_ID                  420
126 #define NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_ALLOCATION_MISMATCH_ID                437
127 #define NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_UNSUPPORTED_TRANSPORT_PROTOCOL_ID     442
128 #define NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_CONNECTION_ALREADY_EXISTS_ID          446
129 #define NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_SERVER_ERROR_ID                       500
130
131 /* Forward declaration that is needed below if using the
132  * proto_reg_handoff_rtitcp function as a callback for when protocol
133  * preferences get changed. For now we don't have preferences but we
134  * may have them in the future.*/
135
136 void proto_reg_handoff_rtitcp(void);
137 void proto_register_rtitcp(void);
138
139 /* Initialize the protocol and registered fields */
140 static gint proto_rtitcp                                         = -1;
141 static gint hf_rtitcp_header_control_byte                        = -1;
142 static gint hf_rtitcp_header_magic_number                        = -1;
143 static gint hf_rtitcp_header_message_length                      = -1;
144 static gint hf_rtitcp_control_transaction_id                     = -1;
145 static gint hf_rtitcp_control_kind                               = -1;
146 static gint hf_rtitcp_control_attribute_type                     = -1;
147 static gint hf_rtitcp_control_attribute_length                   = -1;
148 static gint hf_rtitcp_control_attribute_port                     = -1;
149 static gint hf_rtitcp_attributes_list_length                     = -1;
150 static gint hf_rtitcp_control_magic_cookie                       = -1;
151 static gint hf_rtitcp_control_attribute_connection_cookie        = -1;
152 static gint hf_rtitcp_control_attribute_connection_type          = -1;
153 static gint hf_rtitcp_control_attribute_session_id               = -1;
154 static gint hf_rtitcp_control_attribute_error_code_value         = -1;
155 static gint hf_rtitcp_control_attribute_error_code_description   = -1;
156 static gint hf_rtitcp_locator_ipv4                               = -1;
157 static gint hf_rtitcp_locator_port                               = -1;
158 static gint hf_rtitcp_locator_ipv6                               = -1;
159 static gint hf_rtitcp_locator_kind                               = -1;
160 static gint hf_rtitcp_crc_magic_cookie                           = -1;
161 static gint hf_rtitcp_control_crc_value                          = -1;
162
163 static gint hf_rtitcp_response_in                                = -1;
164 static gint hf_rtitcp_response_to                                = -1;
165 static gint hf_rtitcp_response_time                              = -1;
166
167 #define RTITCP_FLAG_NOT_REQUEST 0x0100
168
169 typedef struct _rtitcp_transaction_t {
170     guint32 req_frame;
171     guint32 rep_frame;
172     nstime_t req_time;
173 } rtitcp_transaction_t;
174
175 typedef struct _rtitcp_conv_info_t {
176     wmem_map_t *pdus;
177 } rtitcp_conv_info_t;
178
179 /* Subtree pointers */
180 static gint ett_rtitcp                              = -1;
181 static gint ett_rtitcp_signalling_protocol          = -1;
182 static gint ett_rtitcp_message                      = -1;
183 static gint ett_rtitcp_attributes_list              = -1;
184 static gint ett_rtitcp_attribute                    = -1;
185
186 static header_field_info *hfi_rtitcp                = NULL;
187 static heur_dissector_list_t heur_subdissector_list;
188
189 static const value_string ctrl_message_types_vals[] = {
190     { IDENTITY_BIND_REQUEST,                    "Identity Bind Request" },
191     { IDENTITY_BIND_INDICATION,                 "Identity Bind Indication" },
192     { IDENTITY_BIND_RESPONSE,                   "Identity Bind Response" },
193     { IDENTITY_BIND_ERROR,                      "Identity Bind Error" },
194     { SERVER_LOGICAL_PORT_REQUEST,              "Server Logical Port Request" },
195     { SERVER_LOGICAL_PORT_RESPONSE,             "Server Logical Port Response" },
196     { SERVER_LOGICAL_PORT_ERROR,                "Server Logical Port Error" },
197     { CLIENT_LOGICAL_PORT_REQUEST,              "Client Logical Port Request" },
198     { CLIENT_LOGICAL_PORT_RESPONSE,             "Client Logical Port Response" },
199     { CLIENT_LOGICAL_PORT_ERROR,                "Client Logical Port Error" },
200     { CONNECTION_BIND_REQUEST,                  "Connection Bind Request" },
201     { CONNECTION_BIND_RESPONSE,                 "Connection Bind Response" },
202     { CONNECTION_BIND_ERROR,                    "Connection Bind Error" },
203     { SESSION_ID_REQUEST,                       "Session ID Request" },
204     { SESSION_ID_INDICATION,                    "Session ID Indication" },
205     { SESSION_ID_RESPONSE,                      "Session ID Response" },
206     { SESSION_ID_ERROR,                         "Session ID Error" },
207     { LIVELINESS_REQUEST,                       "Liveliness Request" },
208     { LIVELINESS_RESPONSE,                      "Liveliness Response" },
209     { FINALIZE_SESSION_INDICATION,              "Finalize Session Indication" },
210     { 0, NULL }
211 };
212
213 static const value_string attribute_types_vals[] = {
214     { RTPS_LOCATOR_ADDRESS_ATTRIBUTE_TYPE,    "Locator Address" },
215     { RTPS_LOCATOR_PORT_ATTRIBUTE_TYPE,       "Locator Port" },
216     { CONNECTION_TYPE_ATTRIBUTE_TYPE,         "Connection Type" },
217     { CONNECTION_COOKIE_ATTRIBUTE_TYPE,       "Connection Cookie" },
218     { PORT_OPTIONS_ATTRIBUTE_TYPE,            "Port options" },
219     { TRANSPORT_PRIORITY_ATTRIBUTE_TYPE,      "Transport priority" },
220     { SESSION_ID_ATTRIBUTE_TYPE,              "Session ID" },
221     { MAPPED_ADDRESS_ATTRIBUTE_TYPE,          "Mapped Address" },
222     { XOR_MAPPED_ADDRESS_ATTRIBUTE_TYPE,      "XOR Mapped Address" },
223     { ERROR_CODE_ATTRIBUTE_TYPE,              "Error Code" },
224     { UNKNOWN_ATTRIBUTES_ATTRIBUTE_TYPE,      "Unknown attribute" },
225     { SOFTWARE_ATTRIBUTE_TYPE,                "Software" },
226     { ALTERNATE_SERVER_ATTRIBUTE_TYPE,        "Alternate Server" },
227     { 0, NULL }
228 };
229
230 static const value_string error_code_kind_vals[] = {
231     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_OK,
232       "PROTOCOL_OK" },
233     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_TRANSPORT_CLASS_MISMATCH,
234       "PROTOCOL_ERROR_TRANSPORT_CLASS_MISMATCH" },
235     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_ATTRIBUTE_MISSING,
236       "PROTOCOL_ERROR_ATTRIBUTE_MISSING" },
237     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_NO_MATCHING_RECVRESOURCE,
238       "PROTOCOL_ERROR_NO_MATCHING_RECVRESOURCE" },
239     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_NO_MATCH_COOKIE,
240       "PROTOCOL_ERROR_NO_MATCH_COOKIE" },
241     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_INTERNAL,
242       "PROTOCOL_ERROR_INTERNAL" },
243     { NDDS_TRANSPORT_TCPV4_CONTROL_PROTOCOL_ERROR_RETRY,
244       "PROTOCOL_ERROR_RETRY" },
245     { NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_BAD_REQUEST_ID,
246       "ERROR_CODE_ATTRIBUTE_BAD_REQUEST_ID" },
247     { NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_UNKNOWN_ATTRIBUTE_ID,
248       "ERROR_CODE_ATTRIBUTE_UNKNOWN_ATTRIBUTE_ID" },
249     { NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_ALLOCATION_MISMATCH_ID,
250       "ERROR_CODE_ATTRIBUTE_ALLOCATION_MISMATCH_ID" },
251     { NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_UNSUPPORTED_TRANSPORT_PROTOCOL_ID,
252       "ERROR_CODE_ATTRIBUTE_UNSUPPORTED_TRANSPORT_PROTOCOL_ID" },
253     { NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_CONNECTION_ALREADY_EXISTS_ID,
254       "ERROR_CODE_ATTRIBUTE_CONNECTION_ALREADY_EXISTS_ID" },
255     { NDDS_TRANSPORT_TCP_CONTROL_ERROR_CODE_ATTRIBUTE_SERVER_ERROR_ID,
256       "ERROR_CODE_ATTRIBUTE_SERVER_ERROR_ID" },
257     { 0, NULL }
258 };
259
260 static const value_string rtitcp_locator_kind_vals[] = {
261     { LOCATOR_KIND_IPV4,        "IPV4" },
262     { LOCATOR_KIND_IPV6,        "Unreachable peer" },
263     { 0, NULL }
264 };
265
266 static const value_string rtitcp_attribute_connection_type_vals[] = {
267     { CLASS_ID_TCPV4_LAN,        "TCPV4_LAN" },
268     { CLASS_ID_TCPV4_WAN,        "TCPV4_WAN" },
269     { CLASS_ID_TLSV4_LAN,        "TLSV4_LAN" },
270     { CLASS_ID_TLSV4_WAN,        "TLSV4_WAN" },
271     { 0, NULL }
272 };
273
274 static void rtitcp_util_add_error_attribute(proto_tree *attribute, tvbuff_t* tvb,
275                              gint offset, guint size) {
276     proto_tree_add_item(attribute, hf_rtitcp_control_attribute_error_code_value, tvb, offset, 4, ENC_BIG_ENDIAN);
277     proto_tree_add_item(attribute, hf_rtitcp_control_attribute_error_code_description, tvb, offset + 4,
278             size - 4, ENC_ASCII|ENC_NA);
279 }
280
281 static void rtitcp_util_add_locator_t(proto_tree *tree, packet_info *pinfo _U_, tvbuff_t * tvb,
282                              gint offset, gboolean little_endian,
283                              proto_item * rtitcp_message, gboolean * first_attribute) {
284     gint32  kind;
285     guint16 port;
286     kind = tvb_get_guint16(tvb, offset+8, little_endian ? ENC_LITTLE_ENDIAN : ENC_BIG_ENDIAN);
287
288     if (kind == 0xFFFF) {
289         kind = LOCATOR_KIND_IPV4;
290     } else {
291         kind = LOCATOR_KIND_IPV6;
292     }
293     proto_tree_add_uint(tree, hf_rtitcp_locator_kind, tvb, offset+8, 2, kind);
294
295     if (kind == LOCATOR_KIND_IPV4) {
296         proto_tree_add_item(tree, hf_rtitcp_locator_port, tvb, offset+10, 2, ENC_BIG_ENDIAN);
297         proto_tree_add_item(tree, hf_rtitcp_locator_ipv4, tvb, offset+12, 4, ENC_BIG_ENDIAN);
298
299         port = tvb_get_guint16(tvb, offset+10, little_endian ? ENC_LITTLE_ENDIAN : ENC_BIG_ENDIAN);
300         if (*first_attribute) {
301             proto_item_append_text(rtitcp_message," (");
302             col_append_str(pinfo->cinfo, COL_INFO, " (");
303         }
304         proto_item_append_text(rtitcp_message, "%s%s:%u",
305             *first_attribute ? "" : ", ", tvb_ip_to_str(tvb, offset + 12), port);
306         col_append_fstr(pinfo->cinfo, COL_INFO, "%s%s:%u",
307                 *first_attribute ? "" : ", ", tvb_ip_to_str(tvb, offset + 12), port);
308     } else {
309         proto_tree_add_item(tree, hf_rtitcp_locator_ipv6, tvb, offset, 16, ENC_NA);
310         if (*first_attribute) {
311             proto_item_append_text(rtitcp_message," (");
312             col_append_str(pinfo->cinfo, COL_INFO, " (");
313         }
314         proto_item_append_text(rtitcp_message, "%s%s",
315             *first_attribute ? "" : ", ", tvb_ip6_to_str(tvb, offset));
316         col_append_fstr(pinfo->cinfo, COL_INFO, "%s%s",
317                 *first_attribute ? "" : ", ", tvb_ip6_to_str(tvb, offset));
318     }
319 }
320
321 static guint dissect_attribute(tvbuff_t *tvb, packet_info *pinfo,
322         proto_tree *attributes_list, guint offset, guint attributes_list_offset,
323         proto_item * rtitcp_message, gboolean * first_attribute) {
324
325     guint16 attribute_length, attribute_type;
326     guint padding;
327     proto_item *attribute;
328
329     attribute_type = tvb_get_guint16(tvb, attributes_list_offset+offset, ENC_BIG_ENDIAN);
330     attribute_length = tvb_get_guint16(tvb, attributes_list_offset+offset+2, ENC_BIG_ENDIAN);
331
332     attribute = proto_tree_add_subtree_format(attributes_list, tvb,
333             attributes_list_offset+offset, attribute_length+4,
334             ett_rtitcp_attribute, NULL, "Unknown Attribute");
335
336     proto_tree_add_item(attribute, hf_rtitcp_control_attribute_type, tvb,
337             attributes_list_offset+offset, 2, ENC_BIG_ENDIAN);
338     proto_tree_add_item(attribute, hf_rtitcp_control_attribute_length, tvb,
339             attributes_list_offset+offset+2, 2, ENC_BIG_ENDIAN);
340     proto_item_set_text(attribute,"%s", val_to_str(attribute_type, attribute_types_vals, "Unknown attribute"));
341
342     switch (attribute_type) {
343         case RTPS_LOCATOR_PORT_ATTRIBUTE_TYPE: {
344             guint32 port;
345             port = tvb_get_guint32(tvb, attributes_list_offset+offset+4, ENC_BIG_ENDIAN);
346             if (*first_attribute) {
347                 proto_item_append_text(rtitcp_message," (");
348                 col_append_str(pinfo->cinfo, COL_INFO, " (");
349             }
350             proto_item_append_text(rtitcp_message, "%s%u",
351                     *first_attribute ? "" : ", ", port);
352             col_append_fstr(pinfo->cinfo, COL_INFO, "%s%u",
353                     *first_attribute ? "" : ", ", port);
354             (*first_attribute) = FALSE;
355             proto_item_append_text(attribute, " (Port = %u)", port);
356             proto_tree_add_item(attribute, hf_rtitcp_control_attribute_port, tvb,
357                     attributes_list_offset+offset+4, attribute_length, ENC_BIG_ENDIAN);
358             break;
359         }
360         case RTPS_LOCATOR_ADDRESS_ATTRIBUTE_TYPE: {
361             rtitcp_util_add_locator_t(attribute, pinfo, tvb, attributes_list_offset+offset+4,
362                                 ENC_BIG_ENDIAN, rtitcp_message, first_attribute);
363             (*first_attribute) = FALSE;
364             break;
365         }
366
367         case CONNECTION_COOKIE_ATTRIBUTE_TYPE: {
368             proto_tree_add_item(attribute, hf_rtitcp_control_attribute_connection_cookie,
369                     tvb, attributes_list_offset+offset+4, attribute_length, ENC_NA);
370             if (*first_attribute) {
371                 proto_item_append_text(rtitcp_message," (");
372                 col_append_str(pinfo->cinfo, COL_INFO, " (");
373             }
374             proto_item_append_text(rtitcp_message, "%s%s",
375                 (*first_attribute) ? "" : ", ",
376                 tvb_bytes_to_str(wmem_packet_scope(), tvb, attributes_list_offset+offset+4, 16));
377             col_append_fstr(pinfo->cinfo, COL_INFO, "%s%s",
378                 (*first_attribute) ? "" : ", ",
379                 tvb_bytes_to_str(wmem_packet_scope(), tvb, attributes_list_offset+offset+4, 16));
380             (*first_attribute) = FALSE;
381             break;
382         }
383         case CONNECTION_TYPE_ATTRIBUTE_TYPE: {
384             guint8 attribute_connection_type = tvb_get_guint8(tvb, attributes_list_offset+offset+4);
385             proto_tree_add_item(attribute, hf_rtitcp_control_attribute_connection_type, tvb,
386                     attributes_list_offset+offset+4, attribute_length, ENC_BIG_ENDIAN);
387             if (*first_attribute) {
388                 proto_item_append_text(rtitcp_message," (");
389                 col_append_str(pinfo->cinfo, COL_INFO, " (");
390             }
391             proto_item_append_text(rtitcp_message, "%s%s",
392                 (*first_attribute) ? "" : ", ",
393                 val_to_str(attribute_connection_type, rtitcp_attribute_connection_type_vals, "Unknown attribute"));
394             col_append_fstr(pinfo->cinfo, COL_INFO, "%s%s",
395                 (*first_attribute) ? "" : ", ",
396                 val_to_str(attribute_connection_type, rtitcp_attribute_connection_type_vals, "Unknown attribute"));
397             (*first_attribute) = FALSE;
398             break;
399         }
400         case SESSION_ID_ATTRIBUTE_TYPE: {
401             proto_tree_add_item(attribute, hf_rtitcp_control_attribute_session_id, tvb,
402                     attributes_list_offset+offset+4, attribute_length, ENC_NA);
403             break;
404         }
405         case ERROR_CODE_ATTRIBUTE_TYPE: {
406             rtitcp_util_add_error_attribute(attribute, tvb, attributes_list_offset+offset+4, attribute_length);
407             break;
408         }
409         default:
410             break;
411     }
412
413     padding = (4 - attribute_length%4)%4;
414     return (attribute_length+padding+4);
415 }
416 static proto_tree* print_header(proto_tree *tree, proto_tree *rtitcp_message, tvbuff_t *tvb, guint offset,
417                                     guint16 msg_length, gboolean printCRC, gboolean is_data) {
418     proto_item *ti;
419
420     if (is_data) {
421         rtitcp_message = proto_tree_add_subtree_format(tree, tvb, offset, msg_length,
422             ett_rtitcp_message, NULL, "RTI TCP Data Message");
423     } else {
424         rtitcp_message = proto_tree_add_subtree_format(tree, tvb, offset, msg_length,
425             ett_rtitcp_message, NULL, "RTI TCP Control Message");
426     }
427     if (is_data) {
428         guint32 msg_length32;
429         proto_tree_add_item(rtitcp_message, hf_rtitcp_header_control_byte, tvb, offset, 1, ENC_BIG_ENDIAN);
430         ti = proto_tree_add_item(rtitcp_message, hf_rtitcp_header_message_length,
431                 tvb, offset+1, 3, ENC_BIG_ENDIAN);
432         msg_length32 = tvb_get_guint32(tvb, offset, ENC_BIG_ENDIAN);
433         msg_length32 = msg_length32 % NUMBER_2E30;
434         proto_item_set_text(ti,"RTI TCP Message Length: %d", msg_length32);
435     } else {
436         proto_tree_add_item(rtitcp_message, hf_rtitcp_header_control_byte, tvb, offset, 2, ENC_BIG_ENDIAN);
437         proto_tree_add_item(rtitcp_message, hf_rtitcp_header_message_length, tvb, offset+2, 2, ENC_BIG_ENDIAN);
438     }
439     proto_tree_add_item(rtitcp_message, hf_rtitcp_header_magic_number, tvb, offset+4, 4, ENC_BIG_ENDIAN);
440     if (printCRC) {
441         proto_tree_add_item(rtitcp_message, hf_rtitcp_crc_magic_cookie, tvb, offset+8, 4, ENC_BIG_ENDIAN);
442         proto_tree_add_item(rtitcp_message, hf_rtitcp_control_crc_value, tvb, offset+12, 4, ENC_BIG_ENDIAN);
443     }
444
445     return rtitcp_message;
446 }
447 static guint16 dissect_control_message(proto_tree *rtitcp_tree, tvbuff_t *tvb, packet_info *pinfo,
448                                   guint offset) {
449
450    /* 0...2...........7...............15.............23...............31
451    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
452    * |            Not Used           |           msg_length          |
453    * +---------------+---------------+---------------+---------------+
454    * |                      RTITCP_MAGIC_NUMBER                      |
455    * +---------------+---------------+---------------+---------------+
456    * |      control_message_kind     |    attributes_list_length     |
457    * +---------------+---------------+---------------+---------------+
458    * |                   RTITCP_CONTROL_MAGIC_COOKIE                 |
459    * +---------------+---------------+---------------+---------------+
460    * |                                                               |
461    * |-                                                             -|
462    * |                         TRANSACTION_ID                        |
463    * |-                                                             -|
464    * |                                                               |
465    * +---------------+---------------+---------------+---------------+   ---------------------------------
466    * |       attribute_type          |       attribute_length ..         Repeat                          |
467    * +---------------+---------------+---------------+---------------+   until                           |
468    * |                       ATTRIBUTE (length)                      |   attributes_list_length expires  |
469    * +---------------+---------------+---------------+---------------+   --------------------------------*/
470
471     proto_tree  *attributes_list, *rtitcp_message = NULL;
472     guint16 msg_length, control_message_kind, attributes_list_length, header_length;
473     guint attributes_list_offset, attribute_offset, offset_header = offset;
474     guint attributes_count;
475     gboolean is_data = FALSE, printCRC = FALSE, first_attribute;
476     gchar * transaction_id_str;
477     guint64 seq_num;
478     conversation_t *conversation;
479     rtitcp_conv_info_t *rtitcp_info;
480     rtitcp_transaction_t *rtitcp_trans;
481     guint64 * conversation_info_key = NULL;
482
483     /* The header length is 8 if it doesn't contain optional fields */
484     header_length = 8;
485
486     msg_length = tvb_get_guint16(tvb, offset+2, ENC_BIG_ENDIAN);
487     offset += 8;
488
489     /* Check if CRC is present */
490     if (tvb_get_ntohl(tvb, offset) == RTITCP_CRC_MAGIC_NUMBER) {
491         printCRC = TRUE;
492         header_length += 8;
493         offset += 8; /* Because of 0xCRC32 + actual CRC (4 bytes) */
494     }
495
496     /* Time to print the header */
497     rtitcp_message = print_header(rtitcp_tree, rtitcp_message, tvb, offset_header, msg_length + header_length, printCRC, is_data);
498
499     /* Check the control message kind */
500     control_message_kind = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN);
501     col_append_sep_str(pinfo->cinfo, COL_INFO, ", ",
502                 val_to_str(control_message_kind,ctrl_message_types_vals, "Unknown control message"));
503     proto_tree_add_uint(rtitcp_message, hf_rtitcp_control_kind, tvb, offset, 2, control_message_kind);
504     proto_item_set_text(rtitcp_message,"RTI TCP Control Message , Kind: %s",
505             val_to_str(control_message_kind,ctrl_message_types_vals, "Unknown control message"));
506     offset += 2;
507
508     /* Take the length in bytes of the attributes list */
509     attributes_list_length = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN);
510     proto_tree_add_item(rtitcp_message, hf_rtitcp_attributes_list_length, tvb, offset, 2, ENC_BIG_ENDIAN);
511     offset += 2;
512
513     /* We expect now the RTI TCP Control Magic Cookie */
514     if (tvb_get_ntohl(tvb, offset) != RTITCP_CONTROL_MAGIC_COOKIE) {
515         return msg_length + header_length;
516     }
517     proto_tree_add_item(rtitcp_message, hf_rtitcp_control_magic_cookie, tvb, offset, 4, ENC_BIG_ENDIAN);
518     offset += 4;
519
520     /* Now we dissect the transaction id */
521     proto_tree_add_item(rtitcp_message, hf_rtitcp_control_transaction_id, tvb, offset, 12, ENC_NA);
522     transaction_id_str = tvb_bytes_to_str(wmem_packet_scope(), tvb, offset, 12);
523
524     /* Get the transaction identifier. Not the whole transaction but the middle part, which
525      * shouldn't coincide */
526     seq_num = tvb_get_ntoh64(tvb, offset);
527
528     /*
529      * We need to track some state for this protocol on a per conversation
530      * basis so we can do neat things like request/response tracking
531      */
532     conversation = find_or_create_conversation(pinfo);
533
534     rtitcp_info = (rtitcp_conv_info_t *)conversation_get_proto_data(conversation, proto_rtitcp);
535     if (!rtitcp_info) {
536         /*
537          * No.  Attach that information to the conversation, and add
538          * it to the list of information structures.
539          */
540         rtitcp_info = wmem_new(wmem_file_scope(), rtitcp_conv_info_t);
541         rtitcp_info->pdus=wmem_map_new(wmem_file_scope(), g_int64_hash, g_int64_equal);
542
543         conversation_add_proto_data(conversation, proto_rtitcp, rtitcp_info);
544     }
545     if (!pinfo->fd->flags.visited) {
546         if (!(control_message_kind & RTITCP_FLAG_NOT_REQUEST)) {
547             /* This is a request */
548             rtitcp_trans=wmem_new(wmem_file_scope(), rtitcp_transaction_t);
549             rtitcp_trans->req_frame = pinfo->num;
550             rtitcp_trans->rep_frame = 0;
551             rtitcp_trans->req_time = pinfo->abs_ts;
552             conversation_info_key = (guint64*)wmem_alloc0(wmem_file_scope(), sizeof(guint64));
553             *conversation_info_key = seq_num;
554             wmem_map_insert(rtitcp_info->pdus, conversation_info_key, (void *)rtitcp_trans);
555         } else {
556             conversation_info_key = &seq_num;
557             rtitcp_trans=(rtitcp_transaction_t *)wmem_map_lookup(rtitcp_info->pdus, conversation_info_key);
558             if (rtitcp_trans) {
559                 rtitcp_trans->rep_frame = pinfo->num;
560             }
561         }
562     } else {
563         conversation_info_key = &seq_num;
564         rtitcp_trans=(rtitcp_transaction_t *)wmem_map_lookup(rtitcp_info->pdus, conversation_info_key);
565     }
566     if (!rtitcp_trans) {
567             /* create a "fake" rtitcp_trans structure */
568             rtitcp_trans=wmem_new(wmem_packet_scope(), rtitcp_transaction_t);
569             rtitcp_trans->req_frame = 0;
570             rtitcp_trans->rep_frame = 0;
571             rtitcp_trans->req_time = pinfo->abs_ts;
572     }
573
574     /* print state tracking in the tree */
575     if (!(control_message_kind & RTITCP_FLAG_NOT_REQUEST)) {
576         /* This is a request */
577         if (rtitcp_trans->rep_frame) {
578             proto_item *it;
579             it = proto_tree_add_uint(rtitcp_message, hf_rtitcp_response_in,
580                             tvb, 0, 0, rtitcp_trans->rep_frame);
581             PROTO_ITEM_SET_GENERATED(it);
582         }
583     } else {
584         /* This is a reply */
585         if (rtitcp_trans->req_frame) {
586             proto_item *it;
587             nstime_t ns;
588             it = proto_tree_add_uint(rtitcp_message, hf_rtitcp_response_to,
589                             tvb, 0, 0, rtitcp_trans->req_frame);
590             PROTO_ITEM_SET_GENERATED(it);
591
592             nstime_delta(&ns, &pinfo->abs_ts, &rtitcp_trans->req_time);
593             it = proto_tree_add_time(rtitcp_message, hf_rtitcp_response_time, tvb, 0, 0, &ns);
594             PROTO_ITEM_SET_GENERATED(it);
595         }
596     }
597
598     /* End of feature */
599     offset += 12;
600
601     /* Finally, dissect the list of attributes */
602     attributes_list_offset = 0;
603     attributes_list = proto_tree_add_subtree_format(rtitcp_message, tvb,
604             attributes_list_offset+offset, attributes_list_length,
605             ett_rtitcp_attributes_list, NULL, "Attributes List");
606
607     attributes_count = 0;
608     first_attribute = TRUE;
609     while (attributes_list_offset < attributes_list_length) {
610         ++attributes_count;
611         attribute_offset = dissect_attribute(tvb, pinfo, attributes_list,
612           offset, attributes_list_offset, rtitcp_message, &first_attribute);
613         attributes_list_offset += attribute_offset;
614     }
615     if (!first_attribute) {
616         proto_item_append_text(rtitcp_message,")");
617         col_append_str(pinfo->cinfo, COL_INFO, ")");
618     }
619     /* Now that we have the number of attributes, update the text to show it */
620     proto_item_set_text(attributes_list, "Attributes list [%d attribute%s",
621         attributes_count, attributes_count > 1 ? "s]" : "]");
622
623     proto_item_append_text(rtitcp_message,", Transaction ID: %s, Len: %d",
624             transaction_id_str, msg_length);
625
626     return msg_length + header_length;
627 }
628
629 /* This function dissects all the control messages found */
630 static guint dissect_rtitcp_control_protocol(proto_tree *rtitcp_tree, tvbuff_t *tvb, packet_info *pinfo) {
631     guint messages_count, offset;
632     guint16 msg_length;
633     guint32 tvb_len;
634
635     offset = 0;
636     tvb_len = tvb_reported_length(tvb);
637
638     messages_count = 0;
639
640     while (offset < tvb_len) {
641         msg_length = dissect_control_message(rtitcp_tree, tvb, pinfo, offset);
642         offset += msg_length;
643         ++messages_count;
644     }
645
646     return offset;
647 }
648
649 static gint dissect_rtitcp_common(tvbuff_t *tvb, packet_info *pinfo,
650                             proto_tree *tree, void *data _U_) {
651
652    /*                   FORMAT OF THE CONTROL MESSAGE
653
654      0...2...........7...............15.............23...............31
655    * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
656    * |         control bytes         |    RTI TCP message length     |
657    * +---------------+---------------+---------------+---------------+
658    * |                     RTITCP_MAGIC_NUMBER                       |
659    * +---------------+---------------+---------------+---------------+
660    * |      control_message_kind     |    attributes_list_length     |
661    * +---------------+---------------+---------------+---------------+
662    * |                    RTITCP_CONTROL_MAGIC_COOKIE                |
663    * +---------------+---------------+---------------+---------------+
664    * |                                                               |
665    * |-                                                             -|
666    * |                         TRANSACTION_ID                        |
667    * |-                                                             -|
668    * |                                                               |
669    * +---------------+---------------+---------------+---------------+   ---------------------------------
670    * |       attribute_type          |       attribute_length ..         Repeat                          |
671    * +---------------+---------------+---------------+---------------+   until                           |
672    * |                       ATTRIBUTE (length)                      |   attributes_list_length expires  |
673    * +---------------+---------------+---------------+---------------+   --------------------------------*/
674
675     proto_item   *ti;
676     proto_tree   *rtitcp_tree, *rtitcp_message = NULL;
677     guint offset, offset_header;
678     guint16 rtitcp_msg_length, header_length;
679     guint32 tvb_len, rtitcp_rtps_msg_length;
680     gboolean printCRC = FALSE, is_data = FALSE;
681     tvbuff_t *next_tvb;
682     heur_dtbl_entry_t *hdtbl_entry;
683
684     offset = 0;
685     tvb_len = tvb_reported_length(tvb);
686
687     /* From this point, we can consider that this is a RTI TCP message */
688     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RTI-TCP");
689
690     rtitcp_msg_length = tvb_get_guint16(tvb, offset+2, ENC_BIG_ENDIAN);
691
692     ti = proto_tree_add_item(tree, proto_rtitcp, tvb, offset, -1, ENC_NA);
693     rtitcp_tree = proto_item_add_subtree(ti, ett_rtitcp);
694
695     offset_header = 0; /* Remember the offset that delimits the header */
696     header_length = 8; /* the header is 8 bytes length + 8 optional (CRC) */
697     offset += 2; /* First two bytes are CTRL bytes */
698     offset += 2; /* rtitcp_msg_length */
699     offset += 4; /* RTITCP_MAGIC_NUMBER has already been checked */
700
701     /* if bytes 8 to 12 are RTITCP_CRC_MAGIC_NUMBER, we got a CRC */
702     if (tvb_get_ntohl(tvb, offset) == RTITCP_CRC_MAGIC_NUMBER) {
703         printCRC = TRUE; /* To specify later that CRC must be printed */
704         header_length += 8; /* header increases in 8 bytes */
705         offset += 8; /* Because of 0xCRC32 + actual CRC (4 bytes) */
706     }
707     proto_item_set_len(ti, rtitcp_msg_length + header_length);
708
709     /* At this point, offset is 8 or 16 bytes and we have now data.
710        This data can be RTPS or RTI TCP Signaling messages */
711     if (tvb_get_ntohl(tvb, offset) == RTPS_MAGIC_NUMBER) {
712
713         /* IMPORTANT NOTE: We assume always one RTPS message per RTITCP message */
714         /* If the TCP layer has provided us with garbage at the end of the buffer,
715            process only the length specified by rtitcp_msg_length */
716         if (tvb_len > (guint32)(rtitcp_msg_length + header_length)) {
717             tvb_set_reported_length(tvb, (rtitcp_msg_length + header_length));
718         }
719
720         /* When we encapsulate RTPS, packet length is given by the 30 less
721            significant bits of the first four bytes */
722         rtitcp_rtps_msg_length = tvb_get_guint32(tvb, 0, ENC_BIG_ENDIAN);
723         rtitcp_rtps_msg_length = rtitcp_rtps_msg_length % NUMBER_2E30;
724         /* Add RTI TCP Data Message subtree and print header */
725         is_data = TRUE;
726         rtitcp_message = print_header(rtitcp_tree, rtitcp_message, tvb, offset_header,
727                                         rtitcp_rtps_msg_length + header_length, printCRC, is_data);
728
729         proto_item_set_text(rtitcp_message,"RTI TCP Data Message, Len: %d",
730                                 rtitcp_rtps_msg_length);
731
732         /* Take the payload and call the registered sub-dissectors. So far, RTPS */
733         next_tvb = tvb_new_subset_remaining(tvb, offset);
734         dissector_try_heuristic(heur_subdissector_list, next_tvb, pinfo, tree, &hdtbl_entry, NULL);
735         return tvb_captured_length(tvb);
736
737     } else {
738         return dissect_rtitcp_control_protocol(rtitcp_tree, tvb, pinfo);
739     }
740 }
741
742 static guint get_rtitcp_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb,
743         gint offset, void * data _U_) {
744     guint16 plen;
745     guint16 header_length = 8;
746     /*
747     * Get the length of the RTITCP packet.
748     */
749     plen = tvb_get_guint16(tvb, offset+2, ENC_BIG_ENDIAN);
750     /*
751     * That length doesn't include the header field itself; add that in.
752     */
753     if (tvb_get_ntohl(tvb, offset+8) == RTITCP_CRC_MAGIC_NUMBER)
754         header_length += 8;
755     /* We don't expect plen to be greater than 0xfff8 since adding the header
756      * exceeds the size */
757     if (plen >= 0xfff8)
758         return 1;
759
760     return plen + header_length;
761 }
762 static gint dissect_rtitcp(tvbuff_t *tvb, packet_info *pinfo,
763                             proto_tree *tree, void *data _U_) {
764
765     gboolean desegmentation = TRUE;
766
767     if (tvb_captured_length(tvb) < 8)
768         return 0;
769
770     /* Check if the RTITCP_MAGIC_NUMBER is here */
771     if (tvb_get_ntohl(tvb, 4) != RTITCP_MAGIC_NUMBER)
772         return 0;
773
774     col_clear(pinfo->cinfo, COL_INFO);
775
776     tcp_dissect_pdus(tvb, pinfo, tree, desegmentation, RTITCP_MIN_LENGTH,
777             get_rtitcp_pdu_len, dissect_rtitcp_common, data);
778
779     return tvb_captured_length(tvb);
780
781 }
782
783
784 /* Register the protocol with Wireshark.
785  *
786  * This format is required because a script is used to build the C function that
787  * calls all the protocol registration.
788  */
789 void
790 proto_register_rtitcp(void)
791 {
792     /* module_t *rtitcp_module; */
793     /* expert_module_t* expert_rtitcp; */
794
795     static hf_register_info hf[] = {
796
797         { &hf_rtitcp_header_control_byte, {
798             "Control Byte", "rtitcp.header.control_byte",
799             FT_UINT8, BASE_HEX, NULL, 0,
800             0, HFILL }
801         },
802
803         { &hf_rtitcp_header_message_length, {
804             "Message Length", "rtitcp.header.message_length",
805             FT_UINT16, BASE_DEC, NULL, 0,
806             0, HFILL }
807         },
808
809         { &hf_rtitcp_header_magic_number, {
810             "Magic Cookie", "rtitcp.header.magic_cookie",
811             FT_UINT32, BASE_HEX, NULL, 0,
812             0, HFILL }
813         },
814
815         { &hf_rtitcp_crc_magic_cookie, {
816             "CRC Magic Cookie", "rtitcp.header.crc_magic_cookie",
817             FT_UINT32, BASE_HEX, NULL, 0,
818             0, HFILL }
819         },
820
821         { &hf_rtitcp_control_kind,
822           { "Kind", "rtitcp.control.kind",
823             FT_UINT16, BASE_HEX, VALS(ctrl_message_types_vals), 0,
824             NULL, HFILL }
825         },
826
827         { &hf_rtitcp_control_magic_cookie, {
828             "Control Magic Cookie", "rtitcp.control.magic_cookie",
829             FT_UINT32, BASE_HEX, NULL, 0,
830             0, HFILL }
831         },
832
833         { &hf_rtitcp_control_transaction_id, {
834             "Transaction ID", "rtitcp.control.transaction_id",
835             FT_BYTES, BASE_NONE, NULL, 0,
836             0, HFILL }
837         },
838
839         { &hf_rtitcp_control_attribute_session_id, {
840             "Session ID", "rtitcp.control.attribute.session_id",
841             FT_BYTES, BASE_NONE, NULL, 0,
842             0, HFILL }
843         },
844
845         { &hf_rtitcp_control_attribute_type,
846           { "Attribute Type", "rtitcp.control.attribute_type",
847             FT_UINT16, BASE_HEX, VALS(attribute_types_vals), 0,
848             NULL, HFILL }
849         },
850
851         { &hf_rtitcp_control_attribute_error_code_value,
852           { "Kind", "rtitcp.control.attribute.error_code",
853             FT_UINT32, BASE_HEX, VALS(error_code_kind_vals), 0,
854             NULL, HFILL }
855         },
856
857         { &hf_rtitcp_control_attribute_error_code_description, {
858             "Description", "rtitcp.control.attribute.error_code.description",
859             FT_STRING, BASE_NONE, NULL, 0,
860             0, HFILL }
861         },
862
863         { &hf_rtitcp_control_attribute_connection_cookie, {
864             "Connection Cookie", "rtitcp.control.attribute.connection_cookie",
865             FT_BYTES, BASE_NONE, NULL, 0,
866             0, HFILL }
867         },
868
869         { &hf_rtitcp_control_attribute_connection_type, {
870             "Class ID", "rtitcp.control_attribute.connection_type",
871             FT_UINT8, BASE_HEX, VALS(rtitcp_attribute_connection_type_vals), 0,
872             0, HFILL }
873         },
874
875         { &hf_rtitcp_attributes_list_length, {
876             "Attributes list length", "rtitcp.attributes_list_length",
877             FT_UINT16, BASE_DEC, NULL, 0,
878             0,
879             HFILL }
880         },
881
882         { &hf_rtitcp_control_attribute_length, {
883             "Attribute Length", "rtitcp.control.attribute.length",
884             FT_UINT16, BASE_DEC, NULL, 0,
885             0, HFILL }
886         },
887
888         { &hf_rtitcp_control_attribute_port, {
889             "Port", "rtitcp.control.attribute_port",
890             FT_UINT32, BASE_DEC, NULL, 0,
891             0, HFILL }
892         },
893
894         { &hf_rtitcp_locator_kind,
895           { "Kind", "rtitcp.locator.kind",
896             FT_UINT16, BASE_DEC, VALS(rtitcp_locator_kind_vals), 0,
897             NULL, HFILL }
898         },
899
900         { &hf_rtitcp_locator_ipv4,
901           { "Address", "rtitcp.locator.ipv4",
902             FT_IPv4, BASE_NONE, NULL, 0,
903             NULL, HFILL }
904         },
905
906         { &hf_rtitcp_locator_port,
907           { "Port", "rtitcp.locator.port",
908             FT_UINT16, BASE_DEC, NULL, 0,
909             NULL, HFILL }
910         },
911
912         { &hf_rtitcp_locator_ipv6,
913           { "Address", "rtitcp.locator.ipv6",
914             FT_IPv6, BASE_NONE, NULL, 0,
915             NULL, HFILL }
916         },
917
918         { &hf_rtitcp_control_crc_value, {
919          "CRC", "rtitcp.control.crc",
920          FT_UINT32, BASE_HEX, NULL, 0,
921          0, HFILL }
922         },
923
924         { &hf_rtitcp_response_in, {
925          "Response In", "rtitcp.response_in",
926          FT_FRAMENUM, BASE_NONE, NULL, 0x0,
927          "The response to this RTITCP request is in this frame", HFILL }
928         },
929
930         { &hf_rtitcp_response_to, {
931          "Request In", "rtitcp.response_to",
932          FT_FRAMENUM, BASE_NONE, NULL, 0x0,
933          "This is a response to the RTITCP request in this frame", HFILL }
934         },
935
936         { &hf_rtitcp_response_time, {
937          "Response Time", "rtitcp.response_time",
938          FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0,
939          "The time between the Request and the Reply", HFILL }
940         },
941
942     };
943
944     static gint *ett[] = {
945         &ett_rtitcp,
946         &ett_rtitcp_signalling_protocol,
947         &ett_rtitcp_message,
948         &ett_rtitcp_attributes_list,
949         &ett_rtitcp_attribute
950     };
951
952     /* Setup protocol expert items */
953     /* static ei_register_info ei[] = {}; */
954
955     /* Register the protocol name and description */
956     proto_rtitcp = proto_register_protocol("RTI TCP Transport Protocol",
957             "RTITCP", "rtitcp");
958
959     hfi_rtitcp = proto_registrar_get_nth(proto_rtitcp);
960     /* Required function calls to register the header fields and subtrees */
961     proto_register_field_array(proto_rtitcp, hf, array_length(hf));
962     proto_register_subtree_array(ett, array_length(ett));
963
964     /* Required function calls to register expert items */
965     /* expert_rtitcp = expert_register_protocol(proto_rtitcp);
966      expert_register_field_array(expert_rtitcp, ei, array_length(ei)); */
967
968     register_dissector("rtitcp", dissect_rtitcp, proto_rtitcp);
969     heur_subdissector_list = register_heur_dissector_list("rtitcp", proto_rtitcp);
970
971 }
972
973 /* Simpler form of proto_reg_handoff_rtitcp which can be used if there are
974  * no prefs-dependent registration function calls. */
975 void
976 proto_reg_handoff_rtitcp(void)
977 {
978     heur_dissector_add("tcp", dissect_rtitcp, "RTI TCP Layer" , "rtitcp", proto_rtitcp, HEURISTIC_ENABLE);
979 }
980
981 /*
982  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
983  *
984  * Local variables:
985  * c-basic-offset: 4
986  * tab-width: 8
987  * indent-tabs-mode: nil
988  * End:
989  *
990  * vi: set shiftwidth=4 tabstop=8 expandtab:
991  * :indentSize=4:tabSize=8:noTabs=true:
992  */