/* packet-ged125.c

 * Routines for ged125 dissection

 * Copyright June/July 2008, Martin Corraine <mcorrain@cisco.com, mac1190@rit.edu>

 * Assistance was provided by the following:

 * Paul Antinori    <pantinor[AT]cisco.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * 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 <epan/packet.h>

#include <epan/expert.h>

#include <epan/prefs.h>

#include "packet-tcp.h"

void proto_register_ged125(void);

void proto_reg_handoff_ged125(void);

static int proto_ged125;

static int hf_ged125_length;

static int hf_ged125_value;

static int hf_ged125_service_control_value;

static int hf_ged125_DialogueID_num;

static int hf_ged125_SendSeqNo_num;

static int hf_ged125_CurrentTime_num;

static int hf_ged125_TimeZoneDelta;

static int hf_ged125_OperationalStatus;

static int hf_ged125_StatusVariable;

static int hf_ged125_InvokeID;

static int hf_ged125_Status;

static int hf_ged125_VersionNumber;

static int hf_ged125_IdleTimeout;

static int hf_ged125_UseEventFeed;

static int hf_ged125_UsePolledFeed;

static int hf_ged125_UseCallRouting;

static int hf_ged125_UseTimeSynch;

static int hf_ged125_UseServiceControl;

static int hf_ged125_TrunkGroupID;

static int hf_ged125_TrunkCount;

static int hf_ged125_CallsInToday;

static int hf_ged125_CallsOutToday;

static int hf_ged125_InServiceTimeToday;

static int hf_ged125_InUseInboundTimeToday;

static int hf_ged125_InUseOutboundTimeToday;

static int hf_ged125_AllTrunksInUseTimeToday;

static int hf_ged125_TrunkNumber;

static int hf_ged125_TrunkStatus;

static int hf_ged125_ServiceID;

static int hf_ged125_AvailableNow;

static int hf_ged125_CallsInNow;

static int hf_ged125_CallsOutNow;

static int hf_ged125_CallsHandledToday;

static int hf_ged125_HandleTimeToday;

static int hf_ged125_DivertedInToday;

static int hf_ged125_DivertedOutToday;

static int hf_ged125_StartOfDay;

static int hf_ged125_InitDataTime;

static int hf_ged125_CallID;

static int hf_ged125_floating;

static int hf_ged125_floating_CauseCode;

static int hf_ged125_ServiceFeatures;

static int hf_ged125_floating_payload_strg;

static int hf_ged125_floating_payload_uint;

static int hf_ged125_floating_payload_bool;

static int hf_ged125_floating_payload_ECC_tag;

static int hf_ged125_ResultCode;

static int hf_ged125_LabelType;

static int hf_ged125_Cause_just_for_release_message;

static int hf_ged125_EventID;

static int hf_ged125_ErrorCode;

static int hf_ged125_InService;

static int hf_ged125_ServiceAvailable;

static int hf_ged125_RequestID;

static int hf_ged125_ToBeContinued;

static int hf_ged125_Barge_In_Allowed;

static int hf_ged125_floating_cause_code;

static int hf_ged125_DTMF_Termination_Key;

static int hf_ged125_No_Entry_Timeout;

static int hf_ged125_Interdigit_Timeout;

static int hf_ged125_Number_of_No_Entry_Tries;

static int hf_ged125_Number_of_Invalid_Entry_Tries;

static int hf_ged125_Min_Length;

static int hf_ged125_Max_Length;

static int hf_ged125_ASR_Allowed;

static int hf_ged125_DTMF_Menu_Keys;

static int hf_ged125_Microapp_Error_Code;

static int hf_ged125_ConferenceCallID;

static int hf_ged125_PrimaryCallID;

static int hf_ged125_SecondaryCallID;

static int hf_ged125_NewServiceID;

static int hf_ged125_NewCallID;

static int hf_ged125_simulator_reset_event;

static int hf_ged125_CrossRefID;

static int hf_ged125_VRUTimeLag;

static int hf_ged125_CallVarsMask;

static int hf_ged125_floating_payload_unspec;

static int hf_ged125_floating_uchar_array_index;

static int hf_ged125_floating_media_protocol;

static int hf_ged125_floating_library_designator;

static int hf_ged125_Data_Playback_Type;

static int hf_ged125_Data_Playback_Formats;

static int ett_ged125;

static int ett_ged125_header;

static int ett_ged125_message;

static int ett_ged125_floating;

static int ett_ged125_float_field;

static int ett_ged125_service_control_header;

static int ett_ged125_service_control_data;

static expert_field ei_ged125_OperationalStatus_normal;

static expert_field ei_ged125_OperationalStatus_loss_redundant_component;

static expert_field ei_ged125_OperationalStatus_degraded_call_processing;

static expert_field ei_ged125_OperationalStatus_conditions_prevent_call;

static expert_field ei_ged125_OperationalStatus_invalid_message;

static expert_field ei_ged125_length_bad;

static expert_field ei_ged125_sendseqno_and_dialogueid;

static expert_field ei_ged125_service_control_value_unknown;

static expert_field ei_ged125_trunk_group_id;

static expert_field ei_ged125_TrunkCount_invalid;

static dissector_handle_t ged125_handle;

/* Preferences */

static bool 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, int* offset)

{

  uint32_t 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, int* offset, const int 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, int* offset, const int size)

{

  int 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, int* offset, const int size)

{

  uint16_t 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, int* offset, uint32_t length)

{

  uint8_t media_protocol;

  const int start = *offset;

  if (length == 0)

    return;

  media_protocol = tvb_get_uint8(tvb, *offset);

  proto_tree_add_item(tree, hf_ged125_floating_media_protocol, tvb, *offset, 1, ENC_ASCII);

  *offset += 1;

  switch (media_protocol)

  {

  case 'H':

  case 'S':

  case 'O':

  case 'F':

    if (length < 2)

      break;

    proto_tree_add_item(tree, hf_ged125_floating_library_designator, tvb, *offset, 1, ENC_ASCII);

    *offset += 1;

    proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 2, ENC_ASCII);

    break;

  case 'T':

    proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 1, ENC_ASCII);

    break;

  case 'D':

    if (length < 9)

      break;

    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_ASCII);

    break;

  }

  /* The length covers the whole value, including the fields above */

  *offset = start + (int)length;

}

static void

floating_fields(tvbuff_t* tvb, packet_info *pinfo, proto_tree* tree, int offset, const int size)

{

  int32_t length;

  uint32_t floating_type;

  proto_tree *ged125_tree, *float_tree;

  proto_item *ti;

  /* No floating fields in this message */

  if (size - offset <= 0)

    return;

  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_uint8(tvb, offset);

    ti = proto_tree_add_uint_format(ged125_tree, hf_ged125_floating, tvb, offset, 1,

                      floating_type, "%s", val_to_str(pinfo->pool, floating_type,

                      vals_floating_point_types, "Unknown %d"));

    float_tree = proto_item_add_subtree(ti, ett_ged125_float_field);

    offset += 1;

    length = tvb_get_uint8(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_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-5, 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_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;

    default:

      /* Unknown floating field type: skip its value */

      offset += length;

      break;

    }

  }

}

static void

service_control_dissect(tvbuff_t* tvb,proto_tree* msg_tree, proto_tree* ged125_tree, packet_info* pinfo,

  int* offset, const int size)

{

  proto_item *ti;

  proto_tree *service_tree, *data_tree;

  uint32_t 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;

  proto_tree_add_item_ret_uint(service_tree, hf_ged125_DialogueID_num, tvb, *offset, 4, ENC_BIG_ENDIAN, &DialogueID);

  *offset += 4;

  col_add_fstr(pinfo->cinfo, COL_INFO, "Service_Control->%s DIALOGUE_ID=%u LEN=%u",

      val_to_str(pinfo->pool, mess_type, vals_service_control_message_subvalues, "Unknown %d"), DialogueID, size);

  ti = proto_tree_add_item_ret_uint(service_tree, hf_ged125_SendSeqNo_num, tvb, *offset, 4, ENC_BIG_ENDIAN, &SendSeqNo);

  *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);