/* packet-ged125.c * Routines for ged125 dissection * Copyright June/July 2008, Martin Corraine * Assistance was provided by the following: * Paul Antinori * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * SPDX-License-Identifier: GPL-2.0-or-later * * GED125 * This is Cisco's protocol that runs atop TCP (ged125 is in the payload of TCP). * The protocol serves as a way for the ICM and the VRU to communicate to each * other in Cisco's CVP. The spec sheet that was used to write this dissector was * Revision 3.1a of November 26, 2007. * * Protocol Structure * * All messages have an eight byte header. The first 4 bytes represent the package * length. This length doesn't include the length of the base header. Next, is the * message base type which is also 4 bytes. All ged125 messages have this format * unless a message spans across several packets. The most common message is the * service control type. This message type will have its own header and with in * that header have a few other things. One of these things is a sub-message type. */ #include "config.h" #include #include #include #include "packet-tcp.h" void proto_register_ged125(void); void proto_reg_handoff_ged125(void); static int proto_ged125 = -1; static gint hf_ged125_length = -1; static gint hf_ged125_value = -1; static gint hf_ged125_service_control_value = -1; static gint hf_ged125_DialogueID_num = -1; static gint hf_ged125_SendSeqNo_num = -1; static gint hf_ged125_CurrentTime_num = -1; static gint hf_ged125_TimeZoneDelta = -1; static gint hf_ged125_OperationalStatus = -1; static gint hf_ged125_StatusVariable = -1; static gint hf_ged125_InvokeID = -1; static gint hf_ged125_Status = -1; static gint hf_ged125_VersionNumber = -1; static gint hf_ged125_IdleTimeout = -1; static gint hf_ged125_UseEventFeed = -1; static gint hf_ged125_UsePolledFeed = -1; static gint hf_ged125_UseCallRouting = -1; static gint hf_ged125_UseTimeSynch = -1; static gint hf_ged125_UseServiceControl = -1; static gint hf_ged125_TrunkGroupID = -1; static gint hf_ged125_TrunkCount = -1; static gint hf_ged125_CallsInToday = -1; static gint hf_ged125_CallsOutToday = -1; static gint hf_ged125_InServiceTimeToday = -1; static gint hf_ged125_InUseInboundTimeToday = -1; static gint hf_ged125_InUseOutboundTimeToday = -1; static gint hf_ged125_AllTrunksInUseTimeToday = -1; static gint hf_ged125_TrunkNumber = -1; static gint hf_ged125_TrunkStatus = -1; static gint hf_ged125_ServiceID = -1; static gint hf_ged125_AvailableNow = -1; static gint hf_ged125_CallsInNow = -1; static gint hf_ged125_CallsOutNow = -1; static gint hf_ged125_CallsHandledToday = -1; static gint hf_ged125_HandleTimeToday = -1; static gint hf_ged125_DivertedInToday = -1; static gint hf_ged125_DivertedOutToday = -1; static gint hf_ged125_StartOfDay = -1; static gint hf_ged125_InitDataTime = -1; static gint hf_ged125_CallID = -1; static gint hf_ged125_floating = -1; static gint hf_ged125_floating_CauseCode = -1; static gint hf_ged125_ServiceFeatures = -1; static gint hf_ged125_floating_payload_strg = -1; static gint hf_ged125_floating_payload_uint = -1; static gint hf_ged125_floating_payload_bool = -1; static gint hf_ged125_floating_payload_ECC_tag = -1; static gint hf_ged125_ResultCode = -1; static gint hf_ged125_LabelType = -1; static gint hf_ged125_Cause_just_for_release_message = -1; static gint hf_ged125_EventID = -1; static gint hf_ged125_ErrorCode = -1; static gint hf_ged125_InService = -1; static gint hf_ged125_ServiceAvailable = -1; static gint hf_ged125_RequestID = -1; static gint hf_ged125_ToBeContinued = -1; static gint hf_ged125_Barge_In_Allowed = -1; static gint hf_ged125_floating_cause_code = -1; static gint hf_ged125_DTMF_Termination_Key = -1; static gint hf_ged125_No_Entry_Timeout = -1; static gint hf_ged125_Interdigit_Timeout = -1; static gint hf_ged125_Number_of_No_Entry_Tries = -1; static gint hf_ged125_Number_of_Invalid_Entry_Tries = -1; static gint hf_ged125_Min_Length = -1; static gint hf_ged125_Max_Length = -1; static gint hf_ged125_ASR_Allowed = -1; static gint hf_ged125_DTMF_Menu_Keys = -1; static gint hf_ged125_Microapp_Error_Code = -1; static gint hf_ged125_ConferenceCallID = -1; static gint hf_ged125_PrimaryCallID = -1; static gint hf_ged125_SecondaryCallID = -1; static gint hf_ged125_NewServiceID = -1; static gint hf_ged125_NewCallID = -1; static gint hf_ged125_simulator_reset_event = -1; static gint hf_ged125_CrossRefID = -1; static gint hf_ged125_VRUTimeLag = -1; static gint hf_ged125_CallVarsMask = -1; static gint hf_ged125_floating_payload_unspec = -1; static gint hf_ged125_floating_uchar_array_index = -1; static gint hf_ged125_floating_media_protocol = -1; static gint hf_ged125_floating_library_designator = -1; static gint hf_ged125_Data_Playback_Type = -1; static gint hf_ged125_Data_Playback_Formats = -1; static gint ett_ged125 = -1; static gint ett_ged125_header = -1; static gint ett_ged125_message = -1; static gint ett_ged125_floating = -1; static gint ett_ged125_float_field = -1; static gint ett_ged125_service_control_header = -1; static gint ett_ged125_service_control_data = -1; static expert_field ei_ged125_OperationalStatus_normal = EI_INIT; static expert_field ei_ged125_OperationalStatus_loss_redundant_component = EI_INIT; static expert_field ei_ged125_OperationalStatus_degraded_call_processing = EI_INIT; static expert_field ei_ged125_OperationalStatus_conditions_prevent_call = EI_INIT; static expert_field ei_ged125_OperationalStatus_invalid_message = EI_INIT; static expert_field ei_ged125_length_bad = EI_INIT; static expert_field ei_ged125_sendseqno_and_dialogueid = EI_INIT; static expert_field ei_ged125_service_control_value_unknown = EI_INIT; static expert_field ei_ged125_trunk_group_id = EI_INIT; static expert_field ei_ged125_TrunkCount_invalid = EI_INIT; static dissector_handle_t ged125_handle; /* Preferences */ static gboolean ged125_desegment_body = TRUE; #define GED125_FAILURE_CONF_VALUE 1 #define GED125_FAILURE_EVENT_VALUE 2 #define GED125_OPEN_REQ_VALUE 3 #define GED125_OPEN_CONF_VALUE 4 #define GED125_HEARTBEAT_REQ_VALUE 5 #define GED125_HEARTBEAT_CONF_VALUE 6 #define GED125_CLOSE_REQ_VALUE 7 #define GED125_CLOSE_CONF_VALUE 8 #define GED125_INIT_DATA_REQ_VALUE 9 #define GED125_INIT_DATA_CONF_VALUE 10 #define GED125_INIT_TRKGRP_DATA_EVENT_VALUE 11 #define GED125_INIT_SERVICE_DATA_EVENT_VALUE 12 #define GED125_INIT_VRU_DATA_EVENT_VALUE 13 #define GED125_INIT_DATA_END_EVENT_VALUE 14 #define GED125_DELIVERED_EVENT_VALUE 15 #define GED125_ORIGINATED_EVENT_VALUE 16 #define GED125_CALL_CLEARED_EVENT_VALUE 17 #define GED125_CONFERENCED_EVENT_VALUE 18 #define GED125_DIVERTED_EVENT_VALUE 19 #define GED125_NEW_TRANSACTION_EVENT_VALUE 20 #define GED125_SET_CALL_VARIABLES_EVENT_VALUE 21 #define GED125_VRU_STATUS_EVENT_VALUE 22 #define GED125_TRKGRP_STATUS_EVENT_VALUE 23 #define GED125_SERVICE_STATUS_EVENT_VALUE 24 #define GED125_ROUTE_REQUEST_EVENT_VALUE 41 #define GED125_ROUTE_SELECT_VALUE 42 #define GED125_ROUTE_END_EVENT_VALUE 43 #define GED125_ROUTE_END_VALUE 44 #define GED125_TIME_SYNCH_REQ_VALUE 45 #define GED125_TIME_SYNCH_CONF_VALUE 46 #define GED125_SERVICE_CONTROL_VALUE 47 #define GED125_SIMULATOR_RESET_EVENT_VALUE 48 #define GED125_REGISTER_VARIABLES_VALUE 49 #define GED125_INIT_SERVICE_CTRL_REQ_VALUE 1 #define GED125_INIT_SERVICE_CTRL_CONF_VALUE 2 #define GED125_INIT_SERVICE_CTRL_DATA_VALUE 3 #define GED125_INIT_SERVICE_CTRL_END_VALUE 4 #define GED125_NEW_CALL_VALUE 5 #define GED125_REQUEST_INSTRUCTION_VALUE 6 #define GED125_RUN_SCRIPT_REQ_VALUE 7 #define GED125_RUN_SCRIPT_RESULT_VALUE 8 #define GED125_CONNECT_VALUE 9 #define GED125_EVENT_REPORT_VALUE 10 #define GED125_DIALOGUE_FAILURE_CONF_VALUE 11 #define GED125_DIALOGUE_FAILURE_EVENT_VALUE 12 #define GED125_INIT_SERVICE_CTRL_TRKGRP_VALUE 13 #define GED125_INIT_SERVICE_CTRL_SERVICE_VALUE 14 #define GED125_INIT_SERVICE_CTRL_VRU_VALUE 15 #define GED125_TRKGRP_STATUS_VALUE 16 #define GED125_SERVICE_STATUS_VALUE 17 #define GED125_VRU_STATUS_VALUE 18 #define GED125_CANCEL_VALUE 19 #define GED125_RELEASE_VALUE 20 #define GED125_NEW_DIALOGUE_VALUE 21 #define GED125_CONNECT_TO_RESOURCE_VALUE 22 #define GED125_RESOURCE_CONNECTED_VALUE 23 #define GED125_MICROAPP_CONTEXT_VALUE 24 #define GED125_MICROAPP_PLAY_VALUE 25 #define GED125_MICROAPP_PLAY_CONTINUE_VALUE 26 #define GED125_MICROAPP_COLLECT_DATA_VALUE 27 #define GED125_MICROAPP_MENU_VALUE 28 #define GED125_MICROAPP_RESULT_VALUE 29 #define GED125_TEMPORARY_CONNECT_VALUE 30 /*Message Element Names and values*/ static const value_string vals_floating_point_types[] = { { 0x0, "Invalid"}, { 0x1, "Text" }, { 0x12, "ANI: Calling-line ID of the caller" }, { 0x13, "UUI" }, { 0x14, "DNIS" }, { 0x15, "Digits Dialed" }, { 0x16, "Call Variable 1" }, { 0x17, "Call Variable 2" }, { 0x18, "Call Variable 3" }, { 0x19, "Call Variable 4" }, { 0x1A, "Call Variable 5" }, { 0x1B, "Call Variable 6" }, { 0x1C, "Call Variable 7" }, { 0x1D, "Call Variable 8" }, { 0x1E, "Call Variable 9" }, { 0x1F, "Call Variable 10" }, { 0x20, "Dialed Number" }, { 0x21, "CED" }, { 0x22, "Label" }, { 0x23, "Trunk_Group_ID" }, { 0x24, "TRUNK_NUMBER" }, { 0x25, "Called_Number" }, { 0x26, "Script_ID" }, { 0x27, "Script Configuration" }, { 0x28, "Correlation_ID" }, { 0x29, "Cause_Code" }, { 0x2a, "Exp Call Var Name" }, { 0x2b, "Exp Call Var Value" }, { 0x2c, "EXP CALL VAR ARRAY" }, { 0x2d, "New Transaction Tag" }, { 0x2e, "Transfer Hint Tag" }, { 0x2f, "Media_Specifier" }, { 0x30, "Initial Prompt-(MEDIA_SPECIFIER)" }, { 0x31, "Invalid Entry Prompt-(MEDIA_SPECIFIER)" }, { 0x32, "Timeout_Prompt-(MEDIA_SPECIFIER)" }, { 0x33, "Customer ID" }, { 0x34, "Application_Media_Library" }, { 0x35, "System Media Library" }, { 0x36, "Locale" }, { 0x37, "Media-Server_Set" }, { 0x38, "Microapp-Error Text" }, { 0x39, "ASR Grammar" }, { 0x3a, "Currency" }, { 0, NULL} }; /*RELEASE Message type*/ static const value_string Cause_just_for_release_message_vals[] = { {0, "Normal-Call Clearing" }, {1, "No Route to Destination" }, {0, NULL} }; /*Base Message for the ged125*/ static const value_string base_message_values[] = { { GED125_FAILURE_CONF_VALUE, "FAILURE_CONF" }, { GED125_FAILURE_EVENT_VALUE, "FAILURE_EVENT" }, { GED125_OPEN_REQ_VALUE, "OPEN_REQ" }, { GED125_OPEN_CONF_VALUE, "OPEN_CONF" }, { GED125_HEARTBEAT_REQ_VALUE, "HEARTBEAT_REQ" }, { GED125_HEARTBEAT_CONF_VALUE, "HEARTBEAT_CONF" }, { GED125_CLOSE_REQ_VALUE, "CLOSE_REQ" }, { GED125_CLOSE_CONF_VALUE, "CLOSE_CONF" }, { GED125_INIT_DATA_REQ_VALUE, "INIT_DATA_REQ" }, { GED125_INIT_DATA_CONF_VALUE, "INIT_DATA_CONF" }, { GED125_INIT_TRKGRP_DATA_EVENT_VALUE, "INIT_TRKGRP_DATA_EVENT" }, { GED125_INIT_SERVICE_DATA_EVENT_VALUE, "INIT_SERVICE_DATA_EVENT" }, { GED125_INIT_VRU_DATA_EVENT_VALUE, "INIT_VRU_DATA_EVENT" }, { GED125_INIT_DATA_END_EVENT_VALUE, "INIT_DATA_END_EVENT" }, { GED125_DELIVERED_EVENT_VALUE, "DELIVERED_EVENT" }, { GED125_ORIGINATED_EVENT_VALUE, "ORIGINATED_EVENT" }, { GED125_CALL_CLEARED_EVENT_VALUE, "CALL_CLEARED_EVENT" }, { GED125_CONFERENCED_EVENT_VALUE, "CONFERENCED_EVENT" }, { GED125_DIVERTED_EVENT_VALUE, "DIVERTED_EVENT" }, { GED125_NEW_TRANSACTION_EVENT_VALUE, "NEW_TRANSACTION_EVENT" }, { GED125_SET_CALL_VARIABLES_EVENT_VALUE, "SET_CALL_VARIABLES_EVENT" }, { GED125_VRU_STATUS_EVENT_VALUE, "VRU_STATUS_EVENT" }, { GED125_TRKGRP_STATUS_EVENT_VALUE, "TRKGRP_STATUS_EVENT" }, { GED125_SERVICE_STATUS_EVENT_VALUE, "SERVICE_STATUS_EVENT" }, { GED125_ROUTE_REQUEST_EVENT_VALUE, "ROUTE_REQUEST_EVENT" }, { GED125_ROUTE_SELECT_VALUE, "ROUTE_SELECT" }, { GED125_ROUTE_END_EVENT_VALUE, "ROUTE_END_EVENT" }, { GED125_ROUTE_END_VALUE, "ROUTE_END" }, { GED125_TIME_SYNCH_REQ_VALUE, "TIME_SYNCH_REQ" }, { GED125_TIME_SYNCH_CONF_VALUE, "TIME_SYNCH_CONF" }, { GED125_SERVICE_CONTROL_VALUE, "SERVICE_CONTROL" }, { GED125_SIMULATOR_RESET_EVENT_VALUE, "SIMULATOR_RESET_EVENT" }, { GED125_REGISTER_VARIABLES_VALUE, "REGISTER_VARIABLES" }, { 0, NULL} }; /*status codes that may be included in the FAILURE_CONF, FAILURE_EVENT, DIALOGUE_FAILURE_CONF, DIALOGUE_FAILURE_EVENT, ROUTE_END_EVENT, and ROUTE_END messages.*/ static const value_string error_codes[] = { { 0x0, "E_NO_ERROR"}, { 0x1, "E_INVALID_VERSION" }, { 0x2, "E_SESSION_ALREADY_ACTIVE" }, { 0x3, "E_VRU_OFFLINE" }, { 0x4, "E_SESSION_NOT_ACTIVE" }, { 0x5, "E_INVALID_DIALED_NUMBER"}, { 0x6, "E_EVENTS_NOT_SUPPORTED"}, { 0x7, "E_EVENTS_NOT_SUPPORTED"}, { 0x8, "E_ROUTING_NOT_SUPPORTED"}, { 0x9, "E_TIME_SYNCH_NOT_SUPPORTED"}, { 0xA, "E_TIMEOUT"}, { 0xB, "E_PG_OFFLINE"}, { 0xC, "E_REQUEST_REFUSED"}, { 0xD, "E_ROUTING_NOT_AVAILABLE"}, { 0xE, "E_ROUTE_NOT_ACCEPTED"}, { 0xF, "E_UNSPECIFIED_FAILURE"}, { 0x10, "E_INVALID_INVOKEID"}, { 0x11, "E_SERVICE_CTRL_NOT_SUPPORTED"}, { 0x12, "E_NO_SCRIPT"}, { 0x13, "E_CALL_VARIABLE1"}, { 0x14, "E_CALL_VARIABLE2"}, { 0x15, "E_CALL_VARIABLE3"}, { 0x16, "E_CALL_VARIABLE4"}, { 0x17, "E_CALL_VARIABLE5"}, { 0x18, "E_CALL_VARIABLE6"}, { 0x19, "E_CALL_VARIABLE7"}, { 0x1A, "E_CALL_VARIABLE8"}, { 0x1B, "E_CALL_VARIABLE9"}, { 0x1C, "E_CALL_VARIABLE10"}, { 0x1E, "E_INVALID_SCRIPT"}, { 0x1F, "E_INVALID_CALLID"}, { 0x20, "E_DUPLICATE_DIALOGUEID"}, { 0x21, "E_INVALID_MESSAGE"}, { 0x22, "E_INVALID_DIALOGUEID"}, { 0x23, "E_OPERATION_CANCELLED"}, { 0x24, "E_OPERATION_NOT_CANCELLED"}, { 0x25, "E_SIMULATOR_RESET"}, { 0x26, "E_SIMULATOR_REINIT"}, { 0, NULL} }; /*Call Cleared Causes*/ static const value_string vals_status_code_call_cleared[] = { { 0x1, "DBCD_DROP_HANDLED_PRIMARY_ROUTE-(Normal Completion)"}, { 0x2, "DBCD_ABAND_AGENT_TERMINAL-(Call Abandoned)"}, { 0x3, "DBCD_BLIND_TRANSFER-(Call Transferred)"}, { 0x4, "DBCD_DROP_HANDLED_PRIMARY_ROUTE-(Normal Completion)"}, { 0x5, "DBCD_DROP_BUSY-(Busy)"}, { 0x6, "DBCD_DROP_NO_ANSWER-(No Answer)"}, { 0x7, "DBCD_TIME_OUT-(Maintenance)"}, { 0x8, "DBCD_FORCED_BUSY-(Net Congestion)"}, { 0x9, "DBCD_INTERCEPT_REORDER-(Net Not Obtainable)"}, { 0xA, "DBCD_DROP_REORDER-(Reorder Tone)"}, { 0xB, "DBCD_INTERCEPT_DENIAL-(Resources Not Available)"}, { 0xC, "DBCD_FORCED_BUSY-(Net Congestion)"}, { 0xD, "DBCD_CALLED_PARTY_DISCONNECTED-(Called Party Disconnected)"}, { 0, NULL} }; /*Trunk Status Definitions*/ static const value_string status_code_trunk_status[] = { { 1, "TRUNK_OUT_OF_SERVICE"}, { 2, "TRUNK_IN_USE_INBOUND"}, { 3, "TRUNK_IN_USE_OUTBOUND"}, { 4, "TRUNK_IDLE"}, { 0, NULL} }; #if 0 /*Label values*/ static const value_string vals_status_code_label_values[] = { { 0x1, "NORMAL"}, { 0x2, "BUSY"}, { 0x3, "RING"}, { 0x5, "DEFAULT"}, { 0, NULL} }; #endif /*Service Control Message Sub-values*/ static const value_string vals_service_control_message_subvalues[] = { { GED125_INIT_SERVICE_CTRL_REQ_VALUE, "INIT_SERVICE_CTRL_REQ"}, { GED125_INIT_SERVICE_CTRL_CONF_VALUE, "INIT_SERVICE_CTRL_CONF"}, { GED125_INIT_SERVICE_CTRL_DATA_VALUE, "INIT_SERVICE_CTRL_DATA"}, { GED125_INIT_SERVICE_CTRL_END_VALUE, "INIT_SERVICE_CTRL_END"}, { GED125_NEW_CALL_VALUE, "NEW_CALL"}, { GED125_REQUEST_INSTRUCTION_VALUE, "REQUEST_INSTRUCTION"}, { GED125_RUN_SCRIPT_REQ_VALUE, "RUN_SCRIPT_REQ"}, { GED125_RUN_SCRIPT_RESULT_VALUE, "RUN_SCRIPT_RESULT"}, { GED125_CONNECT_VALUE, "CONNECT"}, { GED125_EVENT_REPORT_VALUE, "EVENT_REPORT"}, { GED125_DIALOGUE_FAILURE_CONF_VALUE, "DIALOGUE_FAILURE_CONF"}, { GED125_DIALOGUE_FAILURE_EVENT_VALUE, "DIALOGUE_FAILURE_EVENT"}, { GED125_INIT_SERVICE_CTRL_TRKGRP_VALUE, "INIT_SERVICE_CTRL_TRKGRP"}, { GED125_INIT_SERVICE_CTRL_SERVICE_VALUE, "INIT_SERVICE_CTRL_SERVICE"}, { GED125_INIT_SERVICE_CTRL_VRU_VALUE, "INIT_SERVICE_CTRL_VRU"}, { GED125_TRKGRP_STATUS_VALUE, "TRKGRP_STATUS"}, { GED125_SERVICE_STATUS_VALUE, "SERVICE_STATUS"}, { GED125_VRU_STATUS_VALUE, "VRU_STATUS"}, { GED125_CANCEL_VALUE, "CANCEL"}, { GED125_RELEASE_VALUE, "RELEASE"}, { GED125_NEW_DIALOGUE_VALUE, "NEW_DIALOGUE"}, { GED125_CONNECT_TO_RESOURCE_VALUE, "CONNECT_TO_RESOURCE"}, { GED125_RESOURCE_CONNECTED_VALUE, "RESOURCE_CONNECTED"}, { GED125_MICROAPP_CONTEXT_VALUE, "MICROAPP_CONTEXT"}, { GED125_MICROAPP_PLAY_VALUE, "MICROAPP_PLAY"}, { GED125_MICROAPP_PLAY_CONTINUE_VALUE, "MICROAPP_PLAY_CONTINUE"}, { GED125_MICROAPP_COLLECT_DATA_VALUE, "MICROAPP_COLLECT_DATA"}, { GED125_MICROAPP_MENU_VALUE, "MICROAPP_MENU"}, { GED125_MICROAPP_RESULT_VALUE, "MICROAPP_RESULT"}, { GED125_TEMPORARY_CONNECT_VALUE, "TEMPORARY_CONNECT"}, { 0, NULL} }; /*Microapp Error Codes*/ static const value_string status_code_microcapp_error_codes[] = { { 0, "MICROAPP_E_OK" }, { 1, "MICROAPP_E_ERROR" }, { 2, "MICROAPP_E_VRU_TIMED_OUT" }, { 3, "MICROAPP_E_ABORTED" }, { 4, "MICROAPP_E_DIALOG_FAILED" }, { 5, "MICROAPP_E_VRU_SCRIPT_NOT_FOUND"}, { 1001, "MICROAPP_E_INTERNAL" }, { 1002, "MICROAPP_E_MAX_INVALID" }, { 1003, "MICROAPP_E_MAX_NO_ENTRY" }, { 1004, "MICROAPP_E_MEDIA_PROTOCOL" }, { 1005, "MICROAPP_E_MEDIA_VALUE" }, { 1006, "MICROAPP_E_NETWORK" }, { 1007, "MICROAPP_E_NO_MEDIA" }, { 1008, "MICROAPP_E_NUMBER_FORMAT" }, { 1009, "MICROAPP_E_PARAMETER" }, { 1010, "MICROAPP_E_SYSTEM" }, { 1011, "MICROAPP_E_UNSUPPORTED" }, { 1012, "MICROAPP_E_DATA_RANGE" }, { 1013, "MICROAPP_E_INTERNAL_TIMEOUT" }, { 1014, "MICROAPP_E_RECOGNITION" }, { 1999, "MICROAPP_E_OTHER" }, { 0, NULL} }; /*Label values*/ static const value_string status_code_Label_values[] = { { 1, "NORMAL" }, { 2, "BUSY" }, { 3, "RING" }, { 4, "Not Supported" }, { 5, "DEFAULT" }, { 0, NULL} }; /*Event Report Codes*/ static const value_string status_code_event_reportcodes[] = { { 1, "CONNECT_FAILURE" }, { 2, "BUSY" }, { 3, "NO_ANSWER" }, { 4, "ANSWER" }, { 5, "ABANDON" }, { 6, "DISCONNECT" }, { 7, "CONNECT_INVALID" }, { 0, NULL} }; /*values for the media specifier fields*/ static const value_string Data_Playback_Type[] = { { 1, "PLAYBACK_TYPE_NUMBER" }, { 2, "PLAYBACK_TYPE_CHAR" }, { 3, "PLAYBACK_TYPE_ETIME" }, { 4, "PLAYBACK_TYPE_TOD" }, { 5, "PLAYBACK_TYPE_24TOD" }, { 6, "PLAYBACK_TYPE_DOW" }, { 7, "PLAYBACK_TYPE_DATE" }, { 8, "PLAYBACK_TYPE_CURRENCY" }, { 9, "PLAYBACK_TYPE_TEXT" }, { 0, NULL} }; /*values for the media specifier fields*/ static const value_string Data_Playback_Formats[] = { { 1, "PLAYBACK_FORMAT_HHMM" }, { 2, "PLAYBACK_FORMAT_HHMMSS" }, { 3, "PLAYBACK_FORMAT_HHMMAP" }, { 4, "PLAYBACK_FORMAT_OTHER" }, { 0, NULL} }; static const value_string floating_media_protocol_vals[] = { { 'H', "(HTTP)" }, { 'S', "(Streaming)" }, { 'O', "(Other)" }, { 'F', "(File)" }, { 'T', "(Text)" }, { 'D', "(DATA)" }, { 0, NULL} }; static const value_string floating_media_library_designator_vals[] = { { 'A', "(Application)" }, { 'S', "(System)" }, { 0, NULL} }; static void OperationalStatus_funk(tvbuff_t* tvb, packet_info *pinfo, proto_tree* tree, gint* offset) { guint32 value; proto_item* ti; value = tvb_get_ntohl(tvb, *offset); ti = proto_tree_add_item(tree, hf_ged125_OperationalStatus, tvb, *offset, 4, ENC_BIG_ENDIAN); if (value == 0) expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_normal); else if (value <= 31 && value >0) expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_loss_redundant_component); else if (value <= 63 && value >= 32 ) /*32-63*/ expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_degraded_call_processing); else if (value <= 127 && value >= 64 ) /*64-127*/ expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_conditions_prevent_call); else if (value > 127) /*error*/ expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_invalid_message); *offset += 4; } static void StatusVariable_funk(tvbuff_t* tvb, proto_tree* tree, gint* offset, const gint size) { while(*offset+4 <= size) { proto_tree_add_item(tree, hf_ged125_StatusVariable, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; } } static void trunk_funk_without_status(tvbuff_t* tvb, proto_tree* z_tree, gint* offset, const gint size) { gint count = 0; while(*offset+2 <= size && count < 1024) { proto_tree_add_item(z_tree, hf_ged125_TrunkNumber, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; count++; } } static void trunk_funk(tvbuff_t* tvb, proto_tree* tree, gint* offset, const gint size) { guint16 count = 0; /* 1023 max trunks, the trunk loop(counting from 0 from 1023 is 1024)*/ while(*offset+4 <= size && count < 1024) { proto_tree_add_item(tree, hf_ged125_TrunkNumber, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; proto_tree_add_item(tree, hf_ged125_TrunkStatus, tvb, *offset, 2, ENC_BIG_ENDIAN); *offset += 2; count++; } } static void Media_Specifier_dissect(tvbuff_t* tvb, proto_tree* tree, gint* offset, guint32 length) { guint8 media_protocol; media_protocol = tvb_get_guint8(tvb, *offset); proto_tree_add_item(tree, hf_ged125_floating_media_protocol, tvb, *offset, 1, ENC_NA|ENC_ASCII); *offset += 1; switch (media_protocol) { case 'H': case 'S': case 'O': case 'F': proto_tree_add_item(tree, hf_ged125_floating_library_designator, tvb, *offset, 1, ENC_NA|ENC_ASCII); *offset += 1; proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 2, ENC_NA|ENC_ASCII); break; case 'T': proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 1, ENC_NA|ENC_ASCII); break; case 'D': proto_tree_add_item(tree, hf_ged125_Data_Playback_Type, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_ged125_Data_Playback_Formats, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 9, ENC_NA|ENC_ASCII); break; } *offset += length; } static void floating_fields(tvbuff_t* tvb, packet_info *pinfo, proto_tree* tree, gint offset, const gint size) { gint32 length = 4; guint32 floating_type; proto_tree *ged125_tree, *float_tree; proto_item *ti; if (size - offset > 0) length = size - offset; ged125_tree = proto_tree_add_subtree(tree, tvb, offset, length, ett_ged125_floating, NULL, "Float Message"); /*The Universal Floating-Fields Loop of Fun*/ while (offset < size-2) { floating_type = tvb_get_guint8(tvb, offset); ti = proto_tree_add_uint_format(ged125_tree, hf_ged125_floating, tvb, offset, 1, floating_type, "%s", val_to_str(floating_type, vals_floating_point_types, "Unknown %d")); float_tree = proto_item_add_subtree(ti, ett_ged125_float_field); offset += 1; length = tvb_get_guint8(tvb, offset); proto_tree_add_uint(float_tree, hf_ged125_length, tvb, offset, 1, length); offset += 1; if ((offset + length > size) && (length > 0)) { expert_add_info(pinfo, ti, &ei_ged125_length_bad); break; } switch (floating_type) { case 42: case 43: proto_tree_add_item(float_tree, hf_ged125_floating_payload_ECC_tag, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; if (length-4 > 0) { proto_tree_add_item(float_tree, hf_ged125_floating_payload_strg, tvb, offset, length-4, ENC_NA|ENC_ASCII); offset += (length-4); } break; case 44: /*ECC_VAR_ARRAY*/ proto_tree_add_item(float_tree, hf_ged125_floating_payload_ECC_tag, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(float_tree, hf_ged125_floating_uchar_array_index, tvb, offset, 1, ENC_BIG_ENDIAN); offset += 1; if (length-5 > 0) { proto_tree_add_item(float_tree, hf_ged125_floating_payload_strg, tvb, offset, length-4, ENC_NA|ENC_ASCII); offset += (length-5); } break; case 47: case 48: case 49: case 50: /*MEDIA_SPECIFIER*/ Media_Specifier_dissect(tvb, float_tree, &offset, length); break; case 19: /* unspec var type(UUI) */ proto_tree_add_item(float_tree, hf_ged125_floating_payload_unspec, tvb, offset, length, ENC_NA); offset += length; break; case 1: case 18: case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31: case 32: case 33: case 34: case 37: case 38: case 39: case 40: case 51: case 52: case 53: case 54: case 55: case 56: case 57: case 58: proto_tree_add_item(float_tree, hf_ged125_floating_payload_strg, tvb, offset, length, ENC_NA|ENC_ASCII); offset += length; break; case 35: case 36: proto_tree_add_item(float_tree, hf_ged125_floating_payload_uint, tvb, offset, 4, ENC_BIG_ENDIAN); offset += length; break; case 41: proto_tree_add_item(float_tree, hf_ged125_floating_cause_code, tvb, offset, 4, ENC_BIG_ENDIAN); offset += length; break; case 45: case 46: proto_tree_add_item(float_tree, hf_ged125_floating_payload_bool, tvb, offset, 4, ENC_BIG_ENDIAN); offset += length; break; } } } static void service_control_dissect(tvbuff_t* tvb,proto_tree* msg_tree, proto_tree* ged125_tree, packet_info* pinfo, gint* offset, const gint size) { proto_item *ti; proto_tree *service_tree, *data_tree; guint32 mess_type, DialogueID, SendSeqNo; service_tree = proto_tree_add_subtree(msg_tree, tvb, *offset, 12, ett_ged125_service_control_header, NULL, "Service-Control Header"); /* get message sub type, don't want to output that just yet */ mess_type = tvb_get_ntohl(tvb, *offset); *offset += 4; DialogueID = tvb_get_ntohl(tvb, *offset); proto_tree_add_item(service_tree, hf_ged125_DialogueID_num, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; col_add_fstr(pinfo->cinfo, COL_INFO, "Service_Control->%s DIALOGUE_ID=%u LEN=%u", val_to_str(mess_type, vals_service_control_message_subvalues, "Unknown %d"), DialogueID, size); SendSeqNo = tvb_get_ntohl(tvb, *offset); ti = proto_tree_add_item(service_tree, hf_ged125_SendSeqNo_num, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; if ((DialogueID != SendSeqNo) && ((DialogueID == 0xFFFFFFFF) || (SendSeqNo == 0xFFFFFFFF))) expert_add_info(pinfo, ti, &ei_ged125_sendseqno_and_dialogueid); ti = proto_tree_add_uint(service_tree, hf_ged125_service_control_value, tvb, *offset-12, 4, mess_type); data_tree = proto_item_add_subtree(ti, ett_ged125_service_control_data); switch (mess_type) { case GED125_INIT_SERVICE_CTRL_REQ_VALUE: case GED125_INIT_SERVICE_CTRL_CONF_VALUE: case GED125_INIT_SERVICE_CTRL_END_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_INIT_SERVICE_CTRL_DATA_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ServiceFeatures, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_NEW_CALL_VALUE: case GED125_REQUEST_INSTRUCTION_VALUE: proto_tree_add_item(data_tree, hf_ged125_TrunkGroupID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_TrunkNumber, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_RUN_SCRIPT_REQ_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_RUN_SCRIPT_RESULT_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ResultCode, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_CONNECT_VALUE: proto_tree_add_item(data_tree, hf_ged125_LabelType, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_EVENT_REPORT_VALUE: proto_tree_add_item(data_tree, hf_ged125_EventID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_DIALOGUE_FAILURE_CONF_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ErrorCode, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_DIALOGUE_FAILURE_EVENT_VALUE: proto_tree_add_item(data_tree, hf_ged125_ErrorCode, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_INIT_SERVICE_CTRL_TRKGRP_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_TrunkGroupID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_TrunkCount, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; trunk_funk(tvb, data_tree, offset, size); break; case GED125_INIT_SERVICE_CTRL_SERVICE_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_AvailableNow, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_CallsInNow, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_CallsOutNow, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_INIT_SERVICE_CTRL_VRU_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_CurrentTime_num, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_TimeZoneDelta, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; OperationalStatus_funk(tvb, pinfo, data_tree, offset); StatusVariable_funk(tvb, data_tree, offset, size); break; case GED125_TRKGRP_STATUS_VALUE: proto_tree_add_item(data_tree, hf_ged125_TrunkGroupID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_TrunkCount, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; trunk_funk(tvb, data_tree, offset, size); break; case GED125_SERVICE_STATUS_VALUE: proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ServiceAvailable, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_VRU_STATUS_VALUE: proto_tree_add_item(data_tree, hf_ged125_CurrentTime_num, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_TimeZoneDelta, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; OperationalStatus_funk(tvb, pinfo, data_tree, offset); StatusVariable_funk(tvb, data_tree, offset, size); break; case GED125_CANCEL_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_RequestID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_RELEASE_VALUE: proto_tree_add_item(data_tree, hf_ged125_Cause_just_for_release_message, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; break; case GED125_NEW_DIALOGUE_VALUE: proto_tree_add_item(data_tree, hf_ged125_CallID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_CONNECT_TO_RESOURCE_VALUE: case GED125_MICROAPP_CONTEXT_VALUE: case GED125_TEMPORARY_CONNECT_VALUE: floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_RESOURCE_CONNECTED_VALUE: /*nothing goes here*/ break; case GED125_MICROAPP_PLAY_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ToBeContinued, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Barge_In_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_MICROAPP_PLAY_CONTINUE_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ToBeContinued, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_MICROAPP_COLLECT_DATA_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_DTMF_Termination_Key, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_No_Entry_Timeout, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Interdigit_Timeout, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Number_of_No_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Number_of_Invalid_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Min_Length, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Max_Length, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Barge_In_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ASR_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_MICROAPP_MENU_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_No_Entry_Timeout, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Number_of_No_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Number_of_Invalid_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_DTMF_Menu_Keys, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Barge_In_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_ASR_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; case GED125_MICROAPP_RESULT_VALUE: proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; proto_tree_add_item(data_tree, hf_ged125_Microapp_Error_Code, tvb, *offset, 4, ENC_BIG_ENDIAN); *offset += 4; floating_fields(tvb, pinfo, ged125_tree, *offset, size); break; default: expert_add_info(pinfo, ti, &ei_ged125_service_control_value_unknown); } } static guint get_ged125_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset _U_, void *data _U_) { /* XXX: why does this not use the offset to get the value? */ return tvb_get_ntohl(tvb, 0) + 8; } static int dissect_ged125_base_messages(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_) { gint size = tvb_reported_length(tvb); proto_item *ti, *message_item; proto_tree *ged125_tree, *ged125_header_tree, *ged125_message_tree; gint offset = 8; /*get to the fixed message, just outside of header*/ guint32 value, message_type = tvb_get_ntohl(tvb, 4); col_set_str(pinfo->cinfo, COL_PROTOCOL, "GED125"); col_add_fstr(pinfo->cinfo, COL_INFO, "%s %u bytes", val_to_str(message_type, base_message_values, "Unknown %d"), size); ti = proto_tree_add_item(tree, proto_ged125, tvb, 0, -1, ENC_NA); ged125_tree = proto_item_add_subtree( ti, ett_ged125); /* Message header */ ged125_header_tree = proto_tree_add_subtree(ged125_tree, tvb, 0, 8, ett_ged125_header, NULL, "GED125 Header"); proto_tree_add_item(ged125_header_tree, hf_ged125_length, tvb, 0, 4, ENC_BIG_ENDIAN); proto_tree_add_item(ged125_header_tree, hf_ged125_value, tvb, 4, 4, ENC_BIG_ENDIAN); ged125_message_tree = proto_tree_add_subtree(ged125_tree, tvb, offset, -1, ett_ged125_message, &message_item, "GED125 Message"); switch (message_type) { case GED125_FAILURE_CONF_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_FAILURE_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_OPEN_REQ_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_VersionNumber, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_IdleTimeout, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_OPEN_CONF_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_UseEventFeed, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_UsePolledFeed, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_UseCallRouting, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_UseTimeSynch, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_UseServiceControl, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_HEARTBEAT_REQ_VALUE: case GED125_HEARTBEAT_CONF_VALUE: case GED125_CLOSE_CONF_VALUE: case GED125_INIT_DATA_REQ_VALUE: case GED125_INIT_DATA_CONF_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_CLOSE_REQ_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; floating_fields(tvb, pinfo, ged125_tree, offset, size); break; case GED125_INIT_TRKGRP_DATA_EVENT_VALUE: value = tvb_get_ntohl(tvb, offset); ti = proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; if (value > 65535) expert_add_info(pinfo, ti, &ei_ged125_trunk_group_id); value = tvb_get_ntohl(tvb, offset); ti = proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkCount, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; if (value > 1023) expert_add_info(pinfo, ti, &ei_ged125_TrunkCount_invalid); proto_tree_add_item(ged125_message_tree, hf_ged125_CallsInToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallsOutToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_InServiceTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_InUseInboundTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_InUseOutboundTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_AllTrunksInUseTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; trunk_funk(tvb, ged125_message_tree, &offset, size); break; case GED125_INIT_SERVICE_DATA_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_AvailableNow, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallsInNow, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallsOutNow, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallsInToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallsOutToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallsHandledToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_HandleTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_DivertedInToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_DivertedOutToday, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_INIT_VRU_DATA_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_TimeZoneDelta, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; OperationalStatus_funk(tvb, pinfo, ged125_message_tree, &offset); StatusVariable_funk(tvb, ged125_message_tree, &offset, size); break; case GED125_INIT_DATA_END_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_InitDataTime, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_StartOfDay, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_DELIVERED_EVENT_VALUE: case GED125_ORIGINATED_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkGroupID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkNumber, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; floating_fields(tvb, pinfo, ged125_tree, offset, size); break; case GED125_CALL_CLEARED_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_floating_CauseCode, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; floating_fields(tvb, pinfo, ged125_tree, offset, size); break; case GED125_CONFERENCED_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_ConferenceCallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_PrimaryCallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_SecondaryCallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_DIVERTED_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_NewServiceID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_NEW_TRANSACTION_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_NewCallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_SET_CALL_VARIABLES_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; floating_fields(tvb, pinfo, ged125_tree, offset, size); break; case GED125_VRU_STATUS_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CurrentTime_num, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_TimeZoneDelta, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; OperationalStatus_funk(tvb, pinfo, ged125_message_tree, &offset); StatusVariable_funk(tvb, ged125_message_tree, &offset, size); break; case GED125_TRKGRP_STATUS_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkGroupID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; value = tvb_get_ntohl(tvb, offset); ti = proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkCount, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; if (value > 1023) expert_add_info(pinfo, ti, &ei_ged125_TrunkCount_invalid); proto_tree_add_item(ged125_message_tree, hf_ged125_InService, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; trunk_funk_without_status(tvb, ged125_message_tree, &offset, size); break; case GED125_SERVICE_STATUS_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceAvailable, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_ROUTE_REQUEST_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CrossRefID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; floating_fields(tvb, pinfo, ged125_tree, offset, size); return tvb_captured_length(tvb); case GED125_ROUTE_SELECT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CrossRefID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_LabelType, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; floating_fields(tvb, pinfo, ged125_tree, offset, size); break; case GED125_ROUTE_END_EVENT_VALUE: case GED125_ROUTE_END_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CrossRefID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_TIME_SYNCH_REQ_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; proto_tree_add_item(ged125_message_tree, hf_ged125_VRUTimeLag, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_TIME_SYNCH_CONF_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN); offset += 4; break; case GED125_SERVICE_CONTROL_VALUE: service_control_dissect(tvb, ged125_message_tree, ged125_tree, pinfo, &offset, size); break; case GED125_SIMULATOR_RESET_EVENT_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_simulator_reset_event, tvb, offset, 4, ENC_BIG_ENDIAN); break; case GED125_REGISTER_VARIABLES_VALUE: proto_tree_add_item(ged125_message_tree, hf_ged125_CallVarsMask, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; floating_fields(tvb, pinfo, ged125_tree, offset, size); break; } proto_item_set_len(message_item, offset-8); return tvb_captured_length(tvb); } static int dissect_ged125(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) { gint size; guint32 message_type; size = tvb_captured_length(tvb); if (size < 12) return 0; message_type = tvb_get_ntohl(tvb, 4); /*checks to make sure it's of a ged125 base message type*/ if (try_val_to_str(message_type, base_message_values) == NULL) return 0; /* not a known command */ tcp_dissect_pdus(tvb, pinfo, tree, ged125_desegment_body, 4, get_ged125_pdu_len, dissect_ged125_base_messages, data); return size; } void proto_register_ged125 (void) { module_t* ged125_module; static hf_register_info hf[] = { { &hf_ged125_length, { "Package Length", "ged125.len", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_value, { "Message value", "ged125.value", FT_UINT32, BASE_DEC, VALS(base_message_values), 0x0, NULL, HFILL }}, { &hf_ged125_service_control_value, { "Sub-Service Control Message value", "ged125.service_control", FT_UINT32, BASE_DEC, VALS(vals_service_control_message_subvalues), 0x0, NULL, HFILL }}, { &hf_ged125_DialogueID_num, { "Dialogue Id", "ged125.dialogue_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_SendSeqNo_num, { "SendSeqNo", "ged125.send_seq_no", FT_UINT32, BASE_DEC, NULL, 0x0, "Send sequence for the sent message", HFILL }}, { &hf_ged125_CurrentTime_num, { "Current Time", "ged125.current_time", FT_UINT32, BASE_DEC, NULL, 0x0, "The current UTC time (VRU clock)", HFILL }}, { &hf_ged125_TimeZoneDelta, { "Time Zone Delta", "ged125.time_zone_delta", FT_INT32, BASE_DEC,NULL, 0x0, "The current local time zone delta, expressed in seconds." "This value is added to a UTC time to form a time in the local time zone", HFILL }}, { &hf_ged125_OperationalStatus, { "Operational Status", "ged125.operational_status", FT_UINT32, BASE_DEC, NULL, 0x0, "Operational Status of the VRU", HFILL }}, { &hf_ged125_StatusVariable, { "Status Variable", "ged125.status_variable", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_InvokeID, { "Invoke ID", "ged125.invoke_id", FT_UINT32, BASE_DEC, NULL, 0x0, "Same as the corresponding req. mess", HFILL }}, { &hf_ged125_Status, { "Status", "ged125.status", FT_UINT32, BASE_DEC, VALS(error_codes), 0x0, "Status: Indicates cause of failure", HFILL }}, { &hf_ged125_VersionNumber, { "Version Number", "ged125.version_number", FT_UINT32, BASE_DEC, NULL, 0x0, "Interface number requested by the Peripheral Gateway," "defines the version of all messages in the message set", HFILL }}, { &hf_ged125_IdleTimeout, { "Idle Timeout (ms)", "ged125.idle_timeout", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_floating_CauseCode, { "Cause code", "ged125.cause_code", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_UseEventFeed, { "Use Event Feed", "ged125.use_event_feed", FT_BOOLEAN, 32, NULL, 0x01, "Indicates if the VRU supports the Event Data Feed", HFILL }}, /* only valid for ICM version 4 or lower*/ { &hf_ged125_UsePolledFeed, { "Use Polled Feed", "ged125.use_polled_feed", FT_BOOLEAN, 32, NULL, 0x01, "Indicates if the VRU supports the Polled Data Feed.", HFILL }}, { &hf_ged125_UseCallRouting, { "Use Call Routing", "ged125.use_call_routing", FT_BOOLEAN, 32, NULL, 0x01, "Indicates if the VRU supports the Call Routing Interface", HFILL }}, { &hf_ged125_UseTimeSynch, { "Use Time Synch", "ged125.use_time_synch", FT_BOOLEAN, 32, NULL, 0x01, "Indicates if the VRU supports the Time Synchronization Interface", HFILL }}, /*Requires Protocol Version 2 or later*/ { &hf_ged125_UseServiceControl, { "Use Service Control", "ged125.use_service_control", FT_BOOLEAN, 32, NULL, 0x01, "Indicates if the VRU supports the Service Control Interface", HFILL }}, { &hf_ged125_TrunkGroupID, { "Trunk Group ID", "ged125.trunk_group_id", FT_UINT32, BASE_DEC, NULL, 0x0, "An ID assigned by the VRU to this trunk group, in the range 0 to 65535", HFILL }}, { &hf_ged125_TrunkCount, { "Trunk Count", "ged125.trunk_count", FT_UINT32, BASE_DEC, NULL, 0x0, "The number of trunks configured in this message. TrunkCount may not exceed 1024", HFILL }}, { &hf_ged125_CallsInToday, { "Calls In Today", "ged125.calls_in_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative number of inbound calls that have arrived on the trunk group this day", HFILL }}, { &hf_ged125_CallsOutToday, { "Calls Out Today", "ged125.call_out_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative number of outbound calls that have been placed on the trunk group this day", HFILL }}, { &hf_ged125_InServiceTimeToday, { "In Service Time Today", "ged125.in_service_time_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative amount of time (sec) that trunks in the trunk group " "have been in service this day", HFILL }}, { &hf_ged125_InUseInboundTimeToday, { "In Use Inbound Time Today", "ged125.in_use_inbound_time_today", FT_UINT32, BASE_DEC,NULL, 0x0, "The cumulative amount of time (sec) that trunks in the trunk group " "have been in use on incoming calls this day", HFILL }}, { &hf_ged125_InUseOutboundTimeToday, { "In Use Outbound Time Today", "ged125.in_use_outbound_time_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative amount of time (sec) that trunks in the trunk group " "have been in use on outgoing calls this day", HFILL }}, { &hf_ged125_AllTrunksInUseTimeToday, { "All Trunks In Use Time Today", "ged125.all_trunks_in_use_time_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative amount of time (sec) that all trunks in the trunk group " "were simultaneously busy this day", HFILL }}, { &hf_ged125_TrunkNumber, { "Trunk Number", "ged125.trunk_number", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_TrunkStatus, { "Trunk Status", "ged125.trunk_status", FT_UINT16, BASE_DEC, VALS(status_code_trunk_status), 0x0, NULL, HFILL }}, { &hf_ged125_ServiceID, { "Service ID", "ged125.service_id", FT_UINT32, BASE_DEC, NULL, 0x0, "An ID assigned by the VRU to this service", HFILL }}, { &hf_ged125_AvailableNow, { "Available Now", "ged125.available_now", FT_BOOLEAN, 32, NULL, 0x01, "Current availability of the service", HFILL }}, { &hf_ged125_CallsInNow, { "Call In Now", "ged125.call_in_now", FT_UINT32, BASE_DEC, NULL, 0x0, "The number of inbound calls currently in progress on the service.", HFILL }}, { &hf_ged125_CallsOutNow, { "Call Out Now", "ged125.call_out_now", FT_UINT32, BASE_DEC, NULL, 0x0, "The number of outbound calls currently in progress on the service", HFILL }}, { &hf_ged125_CallsHandledToday, { "Calls Handled Today", "ged125.call_handled_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative number of calls handled on the service this day", HFILL }}, { &hf_ged125_HandleTimeToday, { "Handle Time Today", "ged125.handle_time_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative amount of time (secs) spent handling calls on the service this day", HFILL }}, { &hf_ged125_DivertedInToday, { "Diverted In Today", "ged125.diverted_in_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative number of calls diverted from another service to this service this day", HFILL }}, { &hf_ged125_DivertedOutToday, { "Diverted Out Today", "ged125.diverted_out_today", FT_UINT32, BASE_DEC, NULL, 0x0, "The cumulative number of calls diverted from this service to another service this day", HFILL }}, { &hf_ged125_InitDataTime, { "Init Data Time", "ged125.init_data_time", FT_UINT32, BASE_DEC, NULL, 0x0, "The UTC time at which the initial snapshot was taken", HFILL }}, { &hf_ged125_StartOfDay, { "Start Of Day", "ged125.start_of_day", FT_UINT32, BASE_DEC, NULL, 0x0, "Corresponds to midnight local time at the VRU (UTC). However, this may refer " "to a different time if the VRU has restarted", HFILL }}, { &hf_ged125_CallID, { "Call ID", "ged125.call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "An ID assigned to the call by the VRU", HFILL }}, { &hf_ged125_floating, { "Field", "ged125.floating_field", FT_UINT32, BASE_DEC, VALS(vals_floating_point_types), 0x0, "Shows the type of floating field", HFILL }}, { &hf_ged125_ServiceFeatures, { "Service Features", "ged125.service_features", FT_UINT32, BASE_HEX, NULL, 0x0, "A bit mask that is a logical OR of the Service Control features supported by the VRU", HFILL }}, { &hf_ged125_floating_payload_strg, { "Floating Payload", "ged125.floating_payload.strg", FT_STRING, FT_NONE, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_floating_payload_uint, { "Floating Payload", "ged125.floating_payload.uint", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_floating_payload_bool, { "Floating Payload", "ged125.floating_payload.bool", FT_BOOLEAN, 32, NULL, 0x01, NULL, HFILL }}, { &hf_ged125_floating_payload_ECC_tag, { "ECC VAR Tag", "ged125.ecc_var_tag", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_ResultCode, { "Errors running script", "ged125.result_code", FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x01, NULL, HFILL }}, { &hf_ged125_LabelType, { "Label Type", "ged125.label_type", FT_UINT32, BASE_DEC, VALS(status_code_Label_values),0x0, "The type of the label returned in the following field", HFILL }}, { &hf_ged125_EventID, { "Event ID", "ged125.event_id", FT_UINT32, BASE_DEC, VALS(status_code_event_reportcodes), 0x0, "A code that identifies the event detected by the VRU", HFILL }}, { &hf_ged125_ErrorCode, { "Error Code", "ged125.error_code", FT_UINT32, BASE_DEC, VALS(error_codes), 0x0, "A status code indicating the cause of the failure", HFILL }}, { &hf_ged125_Cause_just_for_release_message, { "Cause of Release", "ged125.call_release", FT_UINT32, BASE_DEC, VALS(Cause_just_for_release_message_vals), 0x0, "The reason the call was released", HFILL }}, { &hf_ged125_InService, { "In Service", "ged125.in_service", FT_BOOLEAN, 32, NULL, 0x01, "A flag indicating that the affected trunks have been placed into " "service (True) or removed from service (False)", HFILL }}, { &hf_ged125_ServiceAvailable, { "Service Available", "ged125.service_available", FT_BOOLEAN, 32, NULL, 0x01, NULL, HFILL }}, { &hf_ged125_RequestID, { "Request ID", "ged125.request_id", FT_UINT32, BASE_DEC, NULL, 0x0, "The InvokeID of the previously issued request to be cancelled", HFILL }}, { &hf_ged125_ToBeContinued, { "To Be Continued", "ged125.to_be_continued", FT_BOOLEAN, 32, NULL, 0x01, "A flag which indicates whether additional MICROAPP_PLAY_CONTINUE messages will follow", HFILL }}, { &hf_ged125_Barge_In_Allowed, { "Barge In Allowed", "ged125.barge_in_allowed", FT_BOOLEAN, 32, NULL, 0x01, "Indicates whether caller is allowed to interrupt playing", HFILL }}, { &hf_ged125_floating_cause_code,/* table 34*/ { "Call Cleared Code", "ged125.call_cleared_code", FT_UINT32, BASE_DEC,VALS(vals_status_code_call_cleared), 0x0, "Termination Call Details", HFILL }}, { &hf_ged125_DTMF_Termination_Key, { "DTMF Termination Key", "ged125.dtmf_termination_key", FT_UINT32,BASE_DEC, NULL,0x0, "Terminates a variable length string of DTMF digits " "(typically # key). The value is a bit map", HFILL }}, { &hf_ged125_No_Entry_Timeout, { "No Entry Timeout", "ged125.no_entry_timeout", FT_UINT32, BASE_DEC, NULL, 0x0, "Determines how many seconds a caller is allowed to start entering data", HFILL }}, { &hf_ged125_Interdigit_Timeout, { "Interdigit Timeout", "ged125.interdigit_timeout", FT_UINT32, BASE_DEC, NULL, 0x0, "Determines how many seconds the caller is allowed between digits, " "before the system assumes the caller is finished", HFILL }}, { &hf_ged125_Number_of_No_Entry_Tries, { "Number of No Entry Tries", "ged125.number_of_no_entry_tries", FT_UINT32, BASE_DEC, NULL, 0x0, "Number of times VRU should repeat the 'Get data' cycle when the caller " "doesn't enter any data", HFILL }}, { &hf_ged125_Number_of_Invalid_Entry_Tries, { "Number of Invalid Entry Tries", "ged125.number_of_invalid_entry_tries", FT_UINT32, BASE_DEC, NULL, 0x0, "Number of times VRU should repeat the 'Get data' cycle when the " "caller enters invalid data", HFILL }}, { &hf_ged125_Min_Length, { "Min Length of Digits", "ged125.min_length", FT_UINT32, BASE_DEC, NULL, 0x0, "Minimum number of digits expected from the caller", HFILL }}, { &hf_ged125_Max_Length, { "Max Length of Digits", "ged125.max_length", FT_UINT32, BASE_DEC, NULL, 0x0, "Maximum number of digits expected from the caller", HFILL }}, { &hf_ged125_ASR_Allowed, { "ASR Allowed", "ged125.asr_allowed", FT_BOOLEAN, 32, NULL, 0x01, "Indicates whether Automatic Speech Recognition should be enabled for this request", HFILL }}, { &hf_ged125_DTMF_Menu_Keys, { "DTMF Menu Keys", "ged125.dtmf_menu_keys", FT_UINT32, BASE_DEC, NULL, 0x0, "Indicates which keypad keys represent valid menu choices", HFILL }}, { &hf_ged125_Microapp_Error_Code, { "Microapp Error Code", "ged125.microapp_error_code", FT_UINT32, BASE_DEC, VALS(status_code_microcapp_error_codes), 0x0, NULL, HFILL }}, { &hf_ged125_ConferenceCallID, { "Conference Call ID", "ged125.conference_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "An ID assigned to the resultant conference call by the VRU", HFILL }}, { &hf_ged125_PrimaryCallID, { "Primary Call ID", "ged125.primary_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "The ID of the primary (inbound) call being conferenced", HFILL }}, { &hf_ged125_SecondaryCallID, { "Secondary Call ID", "ged125.secondary_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "The ID of the secondary (outbound) call being conferenced", HFILL }}, { &hf_ged125_NewServiceID, { "New Service ID", "ged125.new_service_id", FT_UINT32, BASE_DEC, NULL, 0x0, "The ID of the new service to which the call was diverted", HFILL }}, { &hf_ged125_NewCallID, { "New Call ID", "ged125.new_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_simulator_reset_event, { "Simulator Reset Event", "ged125.simulator_reset_event", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }}, { &hf_ged125_CrossRefID, { "Cross Reference ID", "ged125.cross_ref_id", FT_UINT32, BASE_DEC, NULL, 0x0, "A cross-reference identifier assigned by the VRU to this call routing dialogue", HFILL }}, { &hf_ged125_VRUTimeLag, { "VRU Time Lag", "ged125.vru_time_lag", FT_INT32, BASE_DEC, NULL, 0x0, "Number of seconds that the VRU clock lags the ICM clock", HFILL }}, { &hf_ged125_CallVarsMask, { "Call Vars Mask", "ged125.call_vars_mask", FT_UINT32, BASE_HEX, NULL, 0x0, "A bit map, with the least significant bit referring to Call Variable1", HFILL }}, { &hf_ged125_floating_payload_unspec, { "Unspec floating data-type", "ged125.floating_unspec", FT_BYTES, BASE_NONE, NULL, 0x0, "Unknown data type", HFILL }}, { &hf_ged125_floating_media_protocol, { "Media Protocol", "ged125.media_protocol", FT_CHAR, BASE_HEX, VALS(floating_media_protocol_vals), 0x0, "Type of media", HFILL }}, { &hf_ged125_floating_library_designator, { "Library Designator", "ged125.library_designator", FT_CHAR, BASE_HEX, VALS(floating_media_library_designator_vals), 0x0, "System or Application", HFILL }}, { &hf_ged125_Data_Playback_Type, { "Data Playback Type", "ged125.data_playback_type", FT_UINT32, BASE_DEC, VALS(Data_Playback_Type), 0x0, NULL, HFILL }}, { &hf_ged125_Data_Playback_Formats, { "Data Playback Format", "ged125.data_playback_format", FT_UINT32, BASE_DEC, VALS(Data_Playback_Formats),0x0, "Only relevant if Data Playback Type is one of the time formats. " "It should contain PLAYBACK_FORMAT_OTHER in all other cases", HFILL }}, { &hf_ged125_floating_uchar_array_index, { "Uchar-Array Index", "ged125.uchar_array_index", FT_UINT32, BASE_DEC, NULL, 0x0, "Array index of an ECC field", HFILL }} }; static gint *ett[] = { &ett_ged125, &ett_ged125_header, &ett_ged125_message, &ett_ged125_floating, &ett_ged125_float_field, &ett_ged125_service_control_header, &ett_ged125_service_control_data }; static ei_register_info ei[] = { { &ei_ged125_OperationalStatus_normal, { "ged125.operational_status.normal", PI_PROTOCOL, PI_NOTE, "Normal Operation", EXPFILL }}, { &ei_ged125_OperationalStatus_loss_redundant_component, { "ged125.operational_status.loss_redundant_component", PI_PROTOCOL, PI_NOTE, "Loss of redundant component or other transparent failure; still fully functional for call processing", EXPFILL }}, { &ei_ged125_OperationalStatus_degraded_call_processing, { "ged125.operational_status.degraded_call_processing", PI_PROTOCOL, PI_NOTE, "Degraded call processing", EXPFILL }}, { &ei_ged125_OperationalStatus_conditions_prevent_call, { "ged125.operational_status.conditions_prevent_call", PI_PROTOCOL, PI_NOTE, "Conditions prevent call processing", EXPFILL }}, { &ei_ged125_OperationalStatus_invalid_message, { "ged125.operational_status.invalid_message", PI_PROTOCOL, PI_WARN, "Error: Invalid message", EXPFILL }}, { &ei_ged125_length_bad, { "ged125.length.bad", PI_MALFORMED, PI_ERROR, "Incorrect size given in the packet (corrupted)", EXPFILL }}, { &ei_ged125_sendseqno_and_dialogueid, { "ged125.sendseqno_and_dialogueid", PI_PROTOCOL, PI_WARN, "Both SendSeqNo & DialogueID must be NULL because at least one is NULL", EXPFILL }}, { &ei_ged125_service_control_value_unknown, { "ged125.service_control_value.unknown", PI_PROTOCOL, PI_WARN, "Unknown Service-Control Message Sub-type, aborting dissection", EXPFILL }}, { &ei_ged125_trunk_group_id, { "ged125.trunk_group_id.bad_range", PI_PROTOCOL, PI_WARN, "TrunkGroupID must be between 0-65535", EXPFILL }}, { &ei_ged125_TrunkCount_invalid, { "ged125.trunk_count.invalid", PI_PROTOCOL, PI_WARN, "Invalid number of trunks (max is 1023)", EXPFILL }}, }; expert_module_t* expert_ged125; proto_ged125 = proto_register_protocol ("Cisco GED-125 Protocol", "GED125", "ged125"); proto_register_field_array (proto_ged125, hf, array_length (hf)); proto_register_subtree_array (ett, array_length (ett)); expert_ged125 = expert_register_protocol(proto_ged125); expert_register_field_array(expert_ged125, ei, array_length(ei)); ged125_handle = register_dissector("ged125", dissect_ged125, proto_ged125); ged125_module = prefs_register_protocol(proto_ged125, NULL); prefs_register_bool_preference(ged125_module, "desegment_body", "Reassemble GED125 bodies spanning multiple TCP segments", "Whether the GED125 dissector should desegment all messages spanning multiple TCP segments", &ged125_desegment_body); } void proto_reg_handoff_ged125(void) { /* Register TCP port for dissection */ dissector_add_for_decode_as_with_preference("tcp.port", ged125_handle); } /* * Editor modelines - https://www.wireshark.org/tools/modelines.html * * Local variables: * c-basic-offset: 8 * tab-width: 8 * indent-tabs-mode: t * End: * * vi: set shiftwidth=8 tabstop=8 noexpandtab: * :indentSize=8:tabSize=8:noTabs=false: */