diff --git a/epan/dissectors/packet-rtps.c b/epan/dissectors/packet-rtps.c index d62e669644..6a40166022 100644 --- a/epan/dissectors/packet-rtps.c +++ b/epan/dissectors/packet-rtps.c @@ -59,6 +59,7 @@ void proto_reg_handoff_rtps(void); #define MAX_GUID_PREFIX_SIZE (128) #define MAX_GUID_SIZE (160) +#define GUID_SIZE (16) #define MAX_VENDOR_ID_SIZE (128) #define MAX_PARAM_SIZE (256) #define MAX_TIMESTAMP_SIZE (128) @@ -83,6 +84,15 @@ void proto_reg_handoff_rtps(void); #define UUID_SIZE (9) #define LONG_ADDRESS_SIZE (16) +#define INSTANCE_STATE_DATA_RESPONSE_NUM_ELEMENTS 7 +#define SEQUENCE_100_IINSTANCE_TRANSITION_DATA_BOUND 100 +#define INSTANCE_TRANSITION_DATA_NUM_ELEMENTS 4 +#define GUID_T_NUM_ELEMENTS 1 +#define VALUE_NUM_ELEMENTS 16 +#define KEY_HAS_VALUE_NUM_ELEMENTS 16 +#define NTPTIME_T_NUM_ELEMENTS 2 +#define SEQUENCE_NUMBER_T_NUM_ELEMENTS 2 + typedef struct _union_member_mapping { guint64 union_type_id; guint64 member_type_id; @@ -219,6 +229,7 @@ static const value_string type_object_kind [] = { }; static wmem_map_t * dissection_infos = NULL; +static wmem_map_t * builtin_dissection_infos = NULL; static wmem_map_t * union_member_mappings = NULL; static wmem_map_t * mutable_member_mappings = NULL; @@ -473,6 +484,7 @@ static dissector_table_t rtps_type_name_table; #define RTI_SERVICE_REQUEST_ID_UNKNOWN 0 #define RTI_SERVICE_REQUEST_ID_TOPIC_QUERY 1 #define RTI_SERVICE_REQUEST_ID_LOCATOR_REACHABILITY 2 +#define RTI_SERVICE_REQUEST_ID_INSTANCE_STATE 3 /* Predefined EntityId */ #define ENTITYID_UNKNOWN (0x00000000) @@ -494,6 +506,29 @@ static dissector_table_t rtps_type_name_table; #define ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_SECURE_WRITER (0xff010182) #define ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_SECURE_READER (0xff010187) + +#define ENTITYID_RESERVED_META_CST_GROUP_WRITER (0xcb) +#define ENTITYID_RESERVED_META_GROUP_WRITER (0xcc) +#define ENTITYID_RESERVED_META_GROUP_READER (0xcd) +#define ENTITYID_RESERVED_META_CST_GROUP_READER (0xce) +#define ENTITYID_OBJECT_NORMAL_META_CST_READER (0x87) +#define ENTITYID_OBJECT_NORMAL_META_WRITER_GROUP (0x88) +#define ENTITYID_OBJECT_NORMAL_META_READER_GROUP (0x89) +#define ENTITYID_OBJECT_NORMAL_META_TOPIC (0x8a) +#define ENTITYID_NORMAL_META_CST_GROUP_WRITER (0x8b) +#define ENTITYID_NORMAL_META_GROUP_WRITER (0x8c) +#define ENTITYID_NORMAL_META_GROUP_READER (0x8d) +#define ENTITYID_NORMAL_META_CST_GROUP_READER (0x8e) +#define ENTITYID_RESERVED_USER_CST_GROUP_WRITER (0x4b) +#define ENTITYID_RESERVED_USER_GROUP_WRITER (0x4c) +#define ENTITYID_RESERVED_USER_GROUP_READER (0x4d) +#define ENTITYID_RESERVED_USER_CST_GROUP_READER (0x4e) +#define ENTITYID_NORMAL_USER_CST_GROUP_WRITER (0x0b) +#define ENTITYID_NORMAL_USER_GROUP_WRITER (0x0c) +#define ENTITYID_NORMAL_USER_GROUP_READER (0x0d) +#define ENTITYID_NORMAL_USER_CST_GROUP_READER (0x0e) + + /* Secure DDS */ #define ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER (0x000201c3) #define ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER (0x000201c4) @@ -1304,6 +1339,9 @@ static int hf_rtps_message_length = -1; static int hf_rtps_header_extension_checksum = -1; static int hf_rtps_uextension = -1; static int hf_rtps_wextension = -1; +static int hf_rtps_writer_group_oid = -1; +static int hf_rtps_reader_group_oid = -1; +static int hf_rtps_writer_session_id = -1; /* Subtree identifiers */ static gint ett_rtps_dissection_tree = -1; @@ -1386,6 +1424,7 @@ static gint ett_rtps_decompressed_type_object = -1; static gint ett_rtps_info_remaining_items = -1; static gint ett_rtps_data_encapsulation_options = -1; static gint ett_rtps_decompressed_serialized_data = -1; +static gint ett_rtps_instance_transition_data = -1; static expert_field ei_rtps_sm_octets_to_next_header_error = EI_INIT; static expert_field ei_rtps_port_invalid = EI_INIT; @@ -1494,6 +1533,27 @@ static const value_string entity_kind_vals [] = { { ENTITYKIND_RTI_BUILTIN_WRITER_NO_KEY, "RTI Built-in writer (no key)" }, { ENTITYKIND_RTI_BUILTIN_READER_WITH_KEY, "RTI Built-in reader (with key)" }, { ENTITYKIND_RTI_BUILTIN_READER_NO_KEY, "RTI Built-in reader (no key)" }, + { ENTITYID_OBJECT_NORMAL_META_CST_READER, "Object normal meta CST reader" }, + { ENTITYID_OBJECT_NORMAL_META_WRITER_GROUP, "Object normal meta writer group" }, + { ENTITYID_OBJECT_NORMAL_META_READER_GROUP, "Object normal meta reader group" }, + { ENTITYID_OBJECT_NORMAL_META_TOPIC, "Object normal meta topic" }, + + { ENTITYID_RESERVED_META_CST_GROUP_WRITER, "Reserved meta CST group writer" }, + { ENTITYID_RESERVED_META_GROUP_WRITER, "Reserved meta group writer" }, + { ENTITYID_RESERVED_META_GROUP_READER, "Reserved meta group reader" }, + { ENTITYID_RESERVED_META_CST_GROUP_READER, "Reserved meta CST group reader" }, + { ENTITYID_NORMAL_META_CST_GROUP_WRITER, "Normal meta CST group writer" }, + { ENTITYID_NORMAL_META_GROUP_WRITER, "Normal meta group writer" }, + { ENTITYID_NORMAL_META_GROUP_READER, "Normal meta group reader" }, + { ENTITYID_NORMAL_META_CST_GROUP_READER, "Normal meta CST group reader" }, + { ENTITYID_RESERVED_USER_CST_GROUP_WRITER, "Reserved user CST group writer" }, + { ENTITYID_RESERVED_USER_GROUP_WRITER, "Reserved user group writer" }, + { ENTITYID_RESERVED_USER_GROUP_READER, "Reserved user group reader" }, + { ENTITYID_RESERVED_USER_CST_GROUP_READER, "Reserved user CST group reader" }, + { ENTITYID_NORMAL_USER_CST_GROUP_WRITER, "Normal user CST group writer" }, + { ENTITYID_NORMAL_USER_GROUP_WRITER, "Normal user writer" }, + { ENTITYID_NORMAL_USER_GROUP_READER, "Normal user reader" }, + { ENTITYID_NORMAL_USER_CST_GROUP_READER, "Normal user CST group reader" }, { 0, NULL } }; @@ -1970,7 +2030,7 @@ static const value_string type_consistency_kind_vals[] = { static const value_string service_request_kind[] = { { RTI_SERVICE_REQUEST_ID_UNKNOWN, "RTI_SERVICE_REQUEST_ID_UNKNOWN" }, { RTI_SERVICE_REQUEST_ID_TOPIC_QUERY, "RTI_SERVICE_REQUEST_ID_TOPIC_QUERY" }, - { RTI_SERVICE_REQUEST_ID_LOCATOR_REACHABILITY, "RTI_SERVICE_REQUEST_ID_LOCATOR_REACHABILITY" }, + { RTI_SERVICE_REQUEST_ID_INSTANCE_STATE, "RTI_SERVICE_REQUEST_ID_INSTANCE_STATE" }, { 0, NULL } }; /* Vendor specific: RTI */ @@ -2652,6 +2712,48 @@ static wmem_map_t * registry = NULL; static reassembly_table rtps_reassembly_table; static wmem_map_t *discovered_participants_domain_ids; + +typedef struct { + type_mapping instance_state_data_response_type_mapping; +} builtin_types_type_mappings; + +typedef struct { + dissection_info instance_state_data_response_dissection_info; + dissection_info alive_instances_dissection_info; + dissection_info disposed_instances_dissection_info; + dissection_info unregistered_instances_dissection_info; + dissection_info guid_t_dissection_info; + dissection_info value_dissection_info; + dissection_info instance_transition_data_dissection_info; + dissection_info key_hash_value_dissection_info; + dissection_info array_16_byte_dissection_info; + dissection_info ntptime_t_dissection_info; + dissection_info sequence_number_t_dissection_info; + dissection_info serialized_key_dissection_info; + dissection_info payload_dissection_info; +} builtin_types_dissection_infos; + + +/* Dissection info of types that are sent as user data but doesn't pubish discovery data */ +typedef struct { + builtin_types_type_mappings type_mappings; + builtin_types_dissection_infos dissection_infos; +} builtin_types_dissection_data_t; + +static builtin_types_dissection_data_t builtin_types_dissection_data; + +/* +static type_mapping instance_state_data_response_type_mapping; +static dissection_info instance_state_data_response_dissection_info; +static dissection_info alive_instances_dissection_info; +static dissection_info disposed_instances_dissection_info; +static dissection_info unregistered_instances_dissection_info; +static dissection_info writer_guid_dissection_info; +static dissection_info reader_guid_dissection_info; +static dissection_info value_dissection_info; +*/ + + static const fragment_items rtps_frag_items = { &ett_rtps_fragment, &ett_rtps_fragments, @@ -2830,6 +2932,18 @@ static gint get_encapsulation_version(gint encapsulation_id) encapsulation_id == ENCAPSULATION_PL_CDR2_LE) ? 2 : 1; } + +dissection_info* lookup_dissection_info_in_custom_and_builtin_types(guint64 type_id) { + dissection_info* info = NULL; + if (dissection_infos != NULL) { + info = (dissection_info*)wmem_map_lookup(dissection_infos, &(type_id)); + if (info == NULL && builtin_dissection_infos != NULL) { + info = (dissection_info*)wmem_map_lookup(builtin_dissection_infos, &(type_id)); + } + } + return info; +} + /* this is a recursive function. _info may or may not be NULL depending on the use iteration */ static gint dissect_user_defined(proto_tree *tree, tvbuff_t * tvb, gint offset, guint encoding, guint encoding_version, dissection_info * _info, guint64 type_id, gchar * name, @@ -2845,7 +2959,7 @@ static gint dissect_user_defined(proto_tree *tree, tvbuff_t * tvb, gint offset, info = _info; member_kind = info->member_kind; } else { - info = (dissection_info *) wmem_map_lookup(dissection_infos, &(type_id)); + info = lookup_dissection_info_in_custom_and_builtin_types(type_id); if (info != NULL) { member_kind = info->member_kind; } else { @@ -3020,12 +3134,12 @@ static gint dissect_user_defined(proto_tree *tree, tvbuff_t * tvb, gint offset, gint first_skipped_element_offset = 0; if (info != NULL) { - bound = (guint)info->bound; - } - /* In case this array is not shown and is a native type. We get the sze length for calculating - * the whole array length */ - array_kind_length = get_native_type_cdr_length(info->base_type_id); + bound = (guint)info->bound; + /* In case this array is not shown and is a native type. We get the sze length for calculating + * the whole array length */ + array_kind_length = get_native_type_cdr_length(info->base_type_id); + } /* Do not add any information to the tree if it is not shown */ if (show) { aux_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_rtps_dissection_tree, @@ -3132,7 +3246,7 @@ static gint dissect_user_defined(proto_tree *tree, tvbuff_t * tvb, gint offset, break; } } - if (info->base_type_id > 0) + if (info != NULL && info->base_type_id > 0) offset = dissect_user_defined(aux_tree, tvb, offset, encoding, encoding_version, NULL, info->base_type_id, temp_buff, EXTENSIBILITY_INVALID, offset_zero, 0, 0, show_current_element); } @@ -3223,68 +3337,71 @@ static gint dissect_user_defined(proto_tree *tree, tvbuff_t * tvb, gint offset, guint num_elements = 0; gint first_skipped_element_offset = 0; - if (show) { + if (info != NULL) { + if (show) { aux_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_rtps_dissection_tree, - NULL, name); - } - if (info != NULL && info->extensibility == EXTENSIBILITY_MUTABLE) { + NULL, name); + } + if (info->extensibility == EXTENSIBILITY_MUTABLE) { gboolean is_end = FALSE; /* Don't know beforehand the number of elements. Need to count them */ while (!is_end) { - if (!(show && shown_elements < rtps_max_data_type_elements) && show_current_element) { - show_current_element = FALSE; - /* Updated only once */ - first_skipped_element_offset = offset; - } - offset = dissect_mutable_member(aux_tree, tvb, offset, encoding, encoding_version, info, &is_end, show_current_element); - ++num_elements; - if (show_current_element) { - ++shown_elements; - } + if (!(show && shown_elements < rtps_max_data_type_elements) && show_current_element) { + show_current_element = FALSE; + /* Updated only once */ + first_skipped_element_offset = offset; + } + offset = dissect_mutable_member(aux_tree, tvb, offset, encoding, encoding_version, info, &is_end, show_current_element); + ++num_elements; + if (show_current_element) { + ++shown_elements; + } } - } else { + } + else { if (info->base_type_id > 0) { - if (show) { - proto_item_append_text(tree, "(BaseId: 0x%016" PRIx64 ")", info->base_type_id); - } - offset = dissect_user_defined(aux_tree, tvb, offset, encoding, encoding_version, NULL, - info->base_type_id, info->member_name, EXTENSIBILITY_INVALID, - offset, 0, 0, show); + if (show) { + proto_item_append_text(tree, "(BaseId: 0x%016" PRIx64 ")", info->base_type_id); + } + offset = dissect_user_defined(aux_tree, tvb, offset, encoding, encoding_version, NULL, + info->base_type_id, info->member_name, EXTENSIBILITY_INVALID, + offset, 0, 0, show); } /* Get the maximun number of elements to be shown depending if enable_max_data_type_elements is enabled */ shown_elements = (enable_max_data_type_elements) - ? MIN(info->num_elements, rtps_max_data_type_elements) - : info->num_elements; + ? MIN(info->num_elements, rtps_max_data_type_elements) + : info->num_elements; for (i = 0; i < info->num_elements; i++) { - if (info->elements[i].type_id > 0) { - /* A member is shown if the parent cluster is shown and the position is in the - * range of maximun number of elements shown */ - if (!(show && i < shown_elements) && show_current_element) { - show_current_element = FALSE; - /* Updated only once */ - first_skipped_element_offset = offset; - } - /* If a member is not shown all it children will inherit the "show_current_element" value */ - offset = dissect_user_defined(aux_tree, tvb, offset, encoding, encoding_version, NULL, - info->elements[i].type_id, info->elements[i].member_name, info->extensibility, - offset_zero, info->elements[i].flags, info->elements[i].member_id, show_current_element); + if (info->elements[i].type_id > 0) { + /* A member is shown if the parent cluster is shown and the position is in the + * range of maximun number of elements shown */ + if (!(show && i < shown_elements) && show_current_element) { + show_current_element = FALSE; + /* Updated only once */ + first_skipped_element_offset = offset; } + /* If a member is not shown all it children will inherit the "show_current_element" value */ + offset = dissect_user_defined(aux_tree, tvb, offset, encoding, encoding_version, NULL, + info->elements[i].type_id, info->elements[i].member_name, info->extensibility, + offset_zero, info->elements[i].flags, info->elements[i].member_id, show_current_element); + } } num_elements = info->num_elements; - } - /* If reached the limit and there are remaining elements we need to show the message and - * assign the length of the ramining elements to this */ - if (enable_max_array_data_type_elements && show && !show_current_element) { + } + /* If reached the limit and there are remaining elements we need to show the message and + * assign the length of the ramining elements to this */ + if (enable_max_array_data_type_elements && show && !show_current_element) { proto_tree_add_subtree_format( - aux_tree, - tvb, - first_skipped_element_offset, - offset - first_skipped_element_offset, - ett_rtps_info_remaining_items, - NULL, - DISSECTION_INFO_REMAINING_ELEMENTS_STR_d, - num_elements - shown_elements); + aux_tree, + tvb, + first_skipped_element_offset, + offset - first_skipped_element_offset, + ett_rtps_info_remaining_items, + NULL, + DISSECTION_INFO_REMAINING_ELEMENTS_STR_d, + num_elements - shown_elements); + } } break; } @@ -6350,7 +6467,16 @@ static type_mapping * rtps_util_get_topic_info(endpoint_guid * guid) { /* At this point, we know the boolean enable_topic_info is true */ type_mapping * result = NULL; if (guid) { - if (guid->fields_present == GUID_HAS_ALL) + guint entity_id_low = 0xFF & guid->entity_id; + /* If the entity guid low is ENTITYID_NORMAL_META_GROUP_READER or ENTITYID_NORMAL_META_GROUP_WRITER then + * is a builtin endpoint that uses the type InstaneStateResponseData. The type_mapping for this type is not + * available through discovery. It is defined by code in + * initialize_instance_state_data_response_dissection_info function. + */ + if (entity_id_low == ENTITYID_NORMAL_META_GROUP_READER || entity_id_low == ENTITYID_NORMAL_META_GROUP_WRITER) { + result = &builtin_types_dissection_data.type_mappings.instance_state_data_response_type_mapping; + } + else if (guid->fields_present == GUID_HAS_ALL) result = (type_mapping *)wmem_map_lookup(registry, guid); } return result; @@ -6372,18 +6498,26 @@ static void rtps_util_topic_info_add_tree(proto_tree *tree, tvbuff_t *tvb, if (enable_topic_info) { proto_tree * topic_info_tree; proto_item * ti; + gboolean is_builtin_type = FALSE; type_mapping * type_mapping_object = rtps_util_get_topic_info(guid); + /* If it is a builtin type mapping then the information is not taken from discovery data */ + is_builtin_type = (type_mapping_object == &builtin_types_dissection_data.type_mappings.instance_state_data_response_type_mapping); if (type_mapping_object != NULL) { + const gchar* topic_information_text = (!is_builtin_type) ? + "[Topic Information (from Discovery)]": + "[Topic Information (BuiltIn type)]"; topic_info_tree = proto_tree_add_subtree(tree, tvb, offset, 0, - ett_rtps_topic_info, NULL, "[Topic Information (from Discovery)]"); - ti = proto_tree_add_string(topic_info_tree, hf_rtps_param_topic_name, tvb, offset, 0, - type_mapping_object->topic_name); - proto_item_set_generated(ti); + ett_rtps_topic_info, NULL, topic_information_text); ti = proto_tree_add_string(topic_info_tree, hf_rtps_param_type_name, tvb, offset, 0, type_mapping_object->type_name); proto_item_set_generated(ti); - ti = proto_tree_add_uint(topic_info_tree, hf_rtps_dcps_publication_data_frame_number, + if (!is_builtin_type) { + ti = proto_tree_add_string(topic_info_tree, hf_rtps_param_topic_name, tvb, offset, 0, + type_mapping_object->topic_name); + proto_item_set_generated(ti); + ti = proto_tree_add_uint(topic_info_tree, hf_rtps_dcps_publication_data_frame_number, tvb, 0, 0, type_mapping_object->dcps_publication_frame_number); + } proto_item_set_generated(ti); } } @@ -6543,11 +6677,14 @@ static gboolean rtps_util_topic_info_add_column_info( static gboolean rtps_util_topic_info_add_column_info_and_try_dissector(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, gint offset, endpoint_guid * guid, rtps_dissector_data * data, guint encoding, guint encoding_version, gboolean try_dissection_from_type_object) { + + if (enable_topic_info) { type_mapping * type_mapping_object = rtps_util_get_topic_info(guid); if (type_mapping_object != NULL) { gchar * dissector_name = NULL; tvbuff_t *next_tvb; + dissection_info* info = NULL; rtps_util_topic_info_add_column_info(pinfo, guid, data); /* This part shows information available for the sample @@ -6558,7 +6695,7 @@ static gboolean rtps_util_topic_info_add_column_info_and_try_dissector(proto_tre */ if (try_dissection_from_type_object && enable_user_data_dissection) { - dissection_info * info = (dissection_info *) wmem_map_lookup(dissection_infos, &(type_mapping_object->type_id)); + info = lookup_dissection_info_in_custom_and_builtin_types(type_mapping_object->type_id); if (info != NULL) { proto_item_append_text(tree, " (TypeId: 0x%016" PRIx64 ")", info->type_id); return dissect_user_defined(tree, tvb, offset, encoding, encoding_version, info, @@ -6726,6 +6863,36 @@ static gint rtps_util_add_rti_locator_reachability_service_request(proto_tree * return offset; } +static gint rtps_util_add_instance_state_request_data(proto_tree* tree, tvbuff_t* tvb, + gint offset, const guint encoding) { + proto_tree* instance_state_request_tree = NULL; + proto_item* ti = NULL; + /* The sum of all fields */ + const guint instance_state_request_data_len = 8 + GUID_SIZE + (4 * 3); + instance_state_request_tree = proto_tree_add_subtree( + tree, + tvb, + offset, + instance_state_request_data_len, + ett_rtps_instance_transition_data, + &ti, + "Instance State Request Data"); + rtps_util_add_seq_number(instance_state_request_tree, tvb, offset, encoding, "seqNumber"); + offset += 8; + rtps_util_add_generic_guid_v2(instance_state_request_tree, tvb, offset, hf_rtps_pgm_dst_endpoint_guid, + hf_rtps_param_host_id, hf_rtps_param_app_id, hf_rtps_param_instance_id, + hf_rtps_param_entity, hf_rtps_param_entity_key, hf_rtps_param_hf_entity_kind, + NULL); + offset += GUID_SIZE; + proto_tree_add_item(instance_state_request_tree, hf_rtps_writer_group_oid, tvb, offset, 4, encoding); + offset += 4; + proto_tree_add_item(instance_state_request_tree, hf_rtps_reader_group_oid, tvb, offset, 4, encoding); + offset += 4; + proto_tree_add_item(instance_state_request_tree, hf_rtps_writer_session_id, tvb, offset, 4, encoding); + offset += 4; + return offset; +} + static gint rtps_util_add_rti_service_request(proto_tree * tree, packet_info *pinfo, tvbuff_t * tvb, gint offset, const guint encoding, guint32 service_id) { switch (service_id) { @@ -6746,6 +6913,12 @@ static gint rtps_util_add_rti_service_request(proto_tree * tree, packet_info *pi offset = check_offset_addition(offset, 4, tree, NULL, tvb); break; } + case RTI_SERVICE_REQUEST_ID_INSTANCE_STATE: { + /* First four after the sequence size are not needed */ + offset += 8; + offset = rtps_util_add_instance_state_request_data(tree, tvb, offset, encoding); + break; + } } return offset; } @@ -11539,7 +11712,8 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu */ int min_len; gint old_offset = offset; - guint32 wid; /* Writer EntityID */ + guint32 writer_wid; /* Writer EntityID */ + guint32 reader_wid = 0; guint32 status_info = 0xffffffff; gboolean from_builtin_writer; proto_item *octet_item; @@ -11576,14 +11750,14 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu /* readerEntityId */ rtps_util_add_entity_id(tree, tvb, offset, hf_rtps_sm_rdentity_id, hf_rtps_sm_rdentity_id_key, - hf_rtps_sm_rdentity_id_kind, ett_rtps_rdentity, "readerEntityId", NULL); + hf_rtps_sm_rdentity_id_kind, ett_rtps_rdentity, "readerEntityId", &reader_wid); offset += 4; /* writerEntityId */ rtps_util_add_entity_id(tree, tvb, offset, hf_rtps_sm_wrentity_id, hf_rtps_sm_wrentity_id_key, - hf_rtps_sm_wrentity_id_kind, ett_rtps_wrentity, "writerEntityId", &wid); + hf_rtps_sm_wrentity_id_kind, ett_rtps_wrentity, "writerEntityId", &writer_wid); offset += 4; - guid->entity_id = wid; + guid->entity_id = writer_wid; guid->fields_present |= GUID_HAS_ENTITY_ID; rtps_util_topic_info_add_tree(tree, tvb, offset, guid); @@ -11611,7 +11785,7 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu /* SerializedData */ if (((flags & FLAG_RTPS_DATA_D) != 0) || ((flags & FLAG_RTPS_DATA_K) != 0)) { - if (wid == ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER) { + if (writer_wid == ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER) { /* Dissect the serialized data as ParticipantMessageData: * struct ParticipantMessageData { * KeyHashPrefix_t participantGuidPrefix; @@ -11651,7 +11825,7 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu rtps_util_add_seq_octets(rtps_pm_tree, pinfo, tvb, offset, encoding, octets_to_next_header - (offset - old_offset) + 4, hf_rtps_data_serialize_data); - } else if (wid == ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER || wid == ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER) { + } else if (writer_wid == ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER || writer_wid == ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER) { /* PGM stands for Participant Generic Message */ proto_tree * rtps_pgm_tree, * guid_tree, * message_identity_tree; proto_item *ti; @@ -11739,7 +11913,7 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu rtps_util_add_data_holder_seq(rtps_pgm_tree, tvb, pinfo, offset, encoding, alignment_zero); - } else if (wid == ENTITYID_RTI_BUILTIN_LOCATOR_PING_WRITER) { + } else if (writer_wid == ENTITYID_RTI_BUILTIN_LOCATOR_PING_WRITER) { proto_tree * locator_ping_tree, *guid_tree; proto_item *ti; guint32 encapsulation_id, encapsulation_opt; @@ -11768,7 +11942,7 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu rtps_util_add_locator_t(locator_ping_tree, pinfo, tvb, offset, encoding, "Destination Locator"); - } else if (wid == ENTITYID_RTI_BUILTIN_SERVICE_REQUEST_WRITER) { + } else if (writer_wid == ENTITYID_RTI_BUILTIN_SERVICE_REQUEST_WRITER) { /* struct ServiceRequest { long service_id; //@key @@ -11819,12 +11993,12 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu label = ""; } - from_builtin_writer = (((wid & ENTITYKIND_BUILTIN_WRITER_WITH_KEY) == ENTITYKIND_BUILTIN_WRITER_WITH_KEY) - || ((wid & ENTITYKIND_BUILTIN_WRITER_NO_KEY) == ENTITYKIND_BUILTIN_WRITER_NO_KEY) - || (wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_BOOTSTRAP_WRITER) - || (wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_WRITER)) - || (wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_SECURE_WRITER) - || (wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_SECURE_READER) ? TRUE : FALSE; + from_builtin_writer = (((writer_wid & ENTITYKIND_BUILTIN_WRITER_WITH_KEY) == ENTITYKIND_BUILTIN_WRITER_WITH_KEY) + || ((writer_wid & ENTITYKIND_BUILTIN_WRITER_NO_KEY) == ENTITYKIND_BUILTIN_WRITER_NO_KEY) + || (writer_wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_BOOTSTRAP_WRITER) + || (writer_wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_WRITER)) + || (writer_wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_SECURE_WRITER) + || (writer_wid == ENTITYID_RTI_BUILTIN_PARTICIPANT_CONFIG_SECURE_READER) ? TRUE : FALSE; /* At the end still dissect the rest of the bytes as raw data */ dissect_serialized_data(tree, pinfo, tvb, offset, octets_to_next_header - (offset - old_offset) + 4, @@ -11832,7 +12006,7 @@ static void dissect_RTPS_DATA(tvbuff_t *tvb, packet_info *pinfo, gint offset, gu } } rtps_util_detect_coherent_set_end_empty_data_case(&coherent_set_entity_info_object); - append_status_info(pinfo, wid, status_info); + append_status_info(pinfo, writer_wid, status_info); } /* *********************************************************************** */ @@ -13562,6 +13736,312 @@ static int dissect_simple_rtps(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tr return tvb_captured_length(tvb); } +/* + * Type InstanceStateDataresponse is sent as user user data but there is no discovery data for it. + * So it is necessary to add it manually so Wireshark can dissect it + */ +static void initialize_instance_state_data_response_dissection_info(builtin_types_dissection_data_t *_builtin_types_dissection_data) { + guint32 element = 0; + const guint64 InstanceStateDataResponse_type_id = 0x9d6d4c879b0e6aa9; + const guint64 sequence_100_InstanceTransitionData_type_id = 0x2dac07d5577caaf6; + const guint64 guid_t_type_id = 0x36d940c4ed806097; + const guint64 value_type_id = 0x974064b1120169ed; + const guint64 instancetransitiondata_type_id = 0xceb6f5e405f4bde7; + const guint64 KeyHashValue_type_id = 0x48725f37453310ed; + const guint64 SerializedKey_type_id = 0x3fd77a8ff43c7e55; + const guint64 payload_type_id = 0x0d0ecc8d34a5c3ab; + const guint64 ntptime_t_type_id = 0x842c59af7e962a4c; + const guint64 sequencenumber_t_type_id = 0xb933efe30d85453b; + /* + * @appendable @nested + * struct GUID_t { + * octet value[16]; + * }; + * @appendable @nested + * struct SequenceNumber_t { + * long high; + * unsigned long low; + * }; + * + * @final @nested + * struct NtpTime_t { + * int32 sec; + * uint32 frac; + * }; + * @final @nested + * struct SerializedKey { + * sequence payload; + * }; + * typedef octet KeyHashValue[16]; + * + * struct InstanceTransitionData { + * @optional KeyHashValue key_hash; + * @optional SerializedKey serialized_key; + * NtpTime_t last_update_timestamp; + * SequenceNumber_t transition_sequence_number; + * }; + */ + + /* All dissection_infos are added to the "dissction_infos" map */ + + /* value */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.value_dissection_info.member_name, "value", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.value_dissection_info.num_elements = VALUE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.value_dissection_info.bound = VALUE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.value_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_ARRAY_TYPE; + _builtin_types_dissection_data->dissection_infos.value_dissection_info.base_type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_BYTE_TYPE; + _builtin_types_dissection_data->dissection_infos.value_dissection_info.type_id = value_type_id; + _builtin_types_dissection_data->dissection_infos.value_dissection_info.bound = VALUE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.value_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, GUID_T_NUM_ELEMENTS); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.value_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.value_dissection_info)); + + /* GUID_t */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.member_name, "GUID_t", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.num_elements = GUID_T_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_STRUCTURE_TYPE; + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.type_id = guid_t_type_id; + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, GUID_T_NUM_ELEMENTS); + /* octet value[16] */ + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.elements[0].flags = 0; + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.elements[0].member_id = 0; + _builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.elements[0].type_id = value_type_id; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.elements[0].member_name, "value", MAX_TOPIC_AND_TYPE_LENGTH); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.guid_t_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.guid_t_dissection_info)); + + /* Payload */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.payload_dissection_info.member_name, "payload", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.payload_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_SEQUENCE_TYPE; + _builtin_types_dissection_data->dissection_infos.payload_dissection_info.base_type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_BYTE_TYPE; + _builtin_types_dissection_data->dissection_infos.payload_dissection_info.type_id = payload_type_id; + _builtin_types_dissection_data->dissection_infos.payload_dissection_info.bound = -1; + _builtin_types_dissection_data->dissection_infos.payload_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, GUID_T_NUM_ELEMENTS); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.payload_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.payload_dissection_info)); + + /* KeyHashValue */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.member_name, "KeyHashValue", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.num_elements = KEY_HAS_VALUE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.bound = KEY_HAS_VALUE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_ARRAY_TYPE; + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.base_type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_BYTE_TYPE; + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.type_id = KeyHashValue_type_id; + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.bound = KEY_HAS_VALUE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, GUID_T_NUM_ELEMENTS); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.key_hash_value_dissection_info)); + + /* SerializedKey */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.member_name, "SerializedKey", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.num_elements = GUID_T_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_STRUCTURE_TYPE; + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.type_id = SerializedKey_type_id; + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, GUID_T_NUM_ELEMENTS); + /* sequence payload */ + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.elements[0].flags = 0; + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.elements[0].member_id = 0; + _builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.elements[0].type_id = payload_type_id; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.elements[0].member_name, "payload", MAX_TOPIC_AND_TYPE_LENGTH); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.serialized_key_dissection_info)); + + /* NtpTime_t */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.member_name, "NtpTime_t", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.num_elements = NTPTIME_T_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_STRUCTURE_TYPE; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.type_id = ntptime_t_type_id; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, NTPTIME_T_NUM_ELEMENTS); + /* int32 sec */ + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[0].flags = 0; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[0].member_id = 0; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[0].type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_INT_32_TYPE; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[0].member_name, "sec", MAX_TOPIC_AND_TYPE_LENGTH); + /* uint32 frac */ + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[1].flags = 0; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[1].member_id = 1; + _builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[1].type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_INT_32_TYPE; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.elements[1].member_name, "frac", MAX_TOPIC_AND_TYPE_LENGTH); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.ntptime_t_dissection_info)); + + /* SequenceNumber_t */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.member_name, "SequenceNumber_t", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.num_elements = SEQUENCE_NUMBER_T_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_STRUCTURE_TYPE; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.type_id = sequencenumber_t_type_id; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, SEQUENCE_NUMBER_T_NUM_ELEMENTS); + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[0].flags = 0; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[0].member_id = 0; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[0].type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_INT_32_TYPE; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[0].member_name, "high", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[1].flags = 0; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[1].member_id = 1; + _builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[1].type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_UINT_32_TYPE; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.elements[1].member_name, "low", MAX_TOPIC_AND_TYPE_LENGTH); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.sequence_number_t_dissection_info)); + + /* Instance transition Data */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.member_name, "InstanceTransitionData", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.num_elements = INSTANCE_TRANSITION_DATA_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_STRUCTURE_TYPE; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.type_id = instancetransitiondata_type_id; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, INSTANCE_TRANSITION_DATA_NUM_ELEMENTS); + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info)); + + for (element = 0; element < _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.num_elements; ++element) { + switch (element) { + case 0: + /* @optional KeyHashValue key_hash */ + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].flags = MEMBER_OPTIONAL; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_id = element; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].type_id = KeyHashValue_type_id; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_name, "key_hash", MAX_TOPIC_AND_TYPE_LENGTH); + break; + case 1: + /* @optional SerializedKey serialized_key */ + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].flags = MEMBER_OPTIONAL; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_id = element; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].type_id = SerializedKey_type_id; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_name, "serialized_key", MAX_TOPIC_AND_TYPE_LENGTH); + break; + case 2: + /* NtpTime_t last_update_timestamp */ + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].flags = 0; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_id = element; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].type_id = ntptime_t_type_id; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_name, "last_update_timestamp", MAX_TOPIC_AND_TYPE_LENGTH); + break; + case 3: + /* SequenceNumber_t transition_sequence_number */ + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].flags = 0; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_id = element; + _builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].type_id = sequencenumber_t_type_id; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_transition_data_dissection_info.elements[element].member_name, "transition_sequence_number", MAX_TOPIC_AND_TYPE_LENGTH); + break; + } + } + + /* InstanceStateDataResponse + * struct InstanceStateDataResponse { + * @optional sequence alive_instances; + * @optional sequence disposed_instances; + * @optional sequence unregistered_instances; + * GUID_t writer_guid; + * GUID_t reader_guid; + * uint32 reader_group_oid; + * boolean complete_snapshot; + * }; + */ + + /* This type mapping is not available in the "registry" map. It is used in the function + * rtps_util_get_topic_info when the endopint GUID determines that the type is InstanceStateDataResponse + */ + _builtin_types_dissection_data->type_mappings.instance_state_data_response_type_mapping.type_id = InstanceStateDataResponse_type_id; + _builtin_types_dissection_data->type_mappings.instance_state_data_response_type_mapping.guid.entity_id = ENTITYID_NORMAL_META_GROUP_READER; + _builtin_types_dissection_data->type_mappings.instance_state_data_response_type_mapping.guid.fields_present = GUID_HAS_ALL; + _builtin_types_dissection_data->type_mappings.instance_state_data_response_type_mapping.fields_visited = TOPIC_INFO_ALL_SET; + g_strlcpy(_builtin_types_dissection_data->type_mappings.instance_state_data_response_type_mapping.topic_name, "InstanceStateDataResponse", MAX_TOPIC_AND_TYPE_LENGTH); + g_strlcpy(_builtin_types_dissection_data->type_mappings.instance_state_data_response_type_mapping.type_name, "InstanceStateDataResponse", MAX_TOPIC_AND_TYPE_LENGTH); + + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.member_name, "InstanceStateDataResponse", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.num_elements = INSTANCE_STATE_DATA_RESPONSE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.bound = INSTANCE_STATE_DATA_RESPONSE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_STRUCTURE_TYPE; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements = wmem_alloc_array(wmem_epan_scope(), dissection_element, INSTANCE_STATE_DATA_RESPONSE_NUM_ELEMENTS); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.base_type_id = 0; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.type_id = InstanceStateDataResponse_type_id; + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info)); + + /* sequence_100_InstanceTransitionData */ + g_strlcpy(_builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.member_name, "sequence_100_InstanceTransitionData", MAX_TOPIC_AND_TYPE_LENGTH); + _builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.num_elements = INSTANCE_STATE_DATA_RESPONSE_NUM_ELEMENTS; + _builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.bound = SEQUENCE_100_IINSTANCE_TRANSITION_DATA_BOUND; + _builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.member_kind = RTI_CDR_TYPE_OBJECT_TYPE_KIND_SEQUENCE_TYPE; + _builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.base_type_id = instancetransitiondata_type_id; + _builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.type_id = sequence_100_InstanceTransitionData_type_id; + wmem_map_insert( + builtin_dissection_infos, + &(_builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info.type_id), + (void*)&(_builtin_types_dissection_data->dissection_infos.alive_instances_dissection_info)); + + /* @optional sequence alive_instances */ + for (element = 0; element < _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.num_elements; ++element) { + switch (element) { + case 0: + /* @optional sequence alive_instances */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = MEMBER_OPTIONAL; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "alive_instances", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = sequence_100_InstanceTransitionData_type_id; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + case 1: + /* @optional sequence disposed_instances */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = MEMBER_OPTIONAL; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "disposed_instances", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = sequence_100_InstanceTransitionData_type_id; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + case 2: + /* @optional sequence unregistered_instances */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = MEMBER_OPTIONAL; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "unregistered_instances", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = sequence_100_InstanceTransitionData_type_id; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + case 3: + /* GUID_t writer_guid */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = 0; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "writer_gid", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = guid_t_type_id; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + case 4: + /* GUID_t reader_guid */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = 0; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "reader_gid", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = guid_t_type_id; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + case 5: + /* uint32 reader_group_oid */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = 0; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "reader_group_oid", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_UINT_32_TYPE; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + case 6: + /* boolean complete_snapshot */ + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].flags = 0; + g_strlcpy(_builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_name, "complete_snapshot", MAX_MEMBER_NAME); + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].type_id = RTI_CDR_TYPE_OBJECT_TYPE_KIND_BOOLEAN_TYPE; + _builtin_types_dissection_data->dissection_infos.instance_state_data_response_dissection_info.elements[element].member_id = element; + break; + } + } +} + void proto_register_rtps(void) { static hf_register_info hf[] = { @@ -16298,6 +16778,18 @@ void proto_register_rtps(void) { "Cloud Discovery Service Announcer", "rtps.flag.cloud_discovery_service_announcer", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000040, NULL, HFILL } }, + { &hf_rtps_writer_group_oid, { + "Writer Group OID", "rtps.writer_group_oid", + FT_UINT32, BASE_DEC, NULL, 0, "Decimal representing the writer group OID", HFILL } + }, + { &hf_rtps_reader_group_oid, { + "Reader Group OID", "rtps.reader_group_oid", + FT_UINT32, BASE_DEC, NULL, 0, "Decimal representing the reader group OID", HFILL } + }, + { &hf_rtps_writer_session_id,{ + "Writer Session ID", "rtps.writer_session_id", + FT_UINT32, BASE_DEC, NULL, 0, "Decimal representing the writer session ID", HFILL } + }, { &hf_rtps_flag_participant_config_writer,{ "Participant Config Writer", "rtps.flag.participant_config_writer", FT_BOOLEAN, 32, TFS(&tfs_set_notset), VENDOR_BUILTIN_ENDPOINT_SET_FLAG_PARTICIPANT_CONFIG_WRITER, NULL, HFILL } @@ -16428,7 +16920,8 @@ void proto_register_rtps(void) { &ett_rtps_dissection_tree, &ett_rtps_info_remaining_items, &ett_rtps_data_encapsulation_options, - &ett_rtps_decompressed_serialized_data + &ett_rtps_decompressed_serialized_data, + &ett_rtps_instance_transition_data }; static ei_register_info ei[] = { @@ -16519,12 +17012,15 @@ void proto_register_rtps(void) { mutable_member_mappings = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), g_int64_hash, g_int64_equal); coherent_set_tracking.entities_using_map = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), hash_by_guid, compare_by_guid); coherent_set_tracking.coherent_set_registry_map = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), coherent_set_key_hash_by_key, compare_by_coherent_set_key); + builtin_dissection_infos = wmem_map_new_autoreset(wmem_epan_scope(), wmem_epan_scope(), g_int64_hash, g_int64_equal); coherent_set_tracking.entities_using_map = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), hash_by_guid, compare_by_guid); discovered_participants_domain_ids = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), hash_by_participant_guid, compare_by_participant_guid); /* In order to get this dissector from other dissectors */ register_dissector("rtps", dissect_simple_rtps, proto_rtps); + initialize_instance_state_data_response_dissection_info(&builtin_types_dissection_data); + reassembly_table_register(&rtps_reassembly_table, &addresses_reassembly_table_functions); }