?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MSWSP: add ids for another unknown Property Set
[wireshark-wip.git] / epan / dissectors / packet-ged125.c
blob27e5794a9f345eb635a399d0291d206ad26ccaf6
1 /* packet-ged125.c
2 * Routines for ged125 dissection
3 * Copyright June/July 2008, Martin Corraine <mcorrain@cisco.com, mac1190@rit.edu>
4 * Assistance was provided by the following:
5 * Paul Antinori <pantinor[AT]cisco.com>
6 *
7 * $Id$
8 *
9 * Wireshark - Network traffic analyzer
10 * By Gerald Combs <gerald@wireshark.org>
11 * Copyright 1998 Gerald Combs
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version 2
16 * of the License, or (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 *
27 * GED125
28 * This is Cisco's protocol that runs atop TCP (ged125 is in the payload of TCP).
29 * The protocol serves as a way for the ICM and the VRU to communicate to each
30 * other in Cisco's CVP. The spec sheet that was used to write this dissector was
31 * Revision 3.1a of November 26, 2007.
32 *
33 * Protocol Structure
34 *
35 * All messages have an eight byte header. The first 4 bytes represent the package
36 * length. This length doesn't include the length of the base header. Next, is the
37 * message base type which is also 4 bytes. All ged125 messages have this format
38 * unless a message spans across several packets. The most common message is the
39 * service control type. This message type will have its own header and with in
40 * that header have a few other things. One of these things is a sub-message type.
41 */
42
43 #include "config.h"
44
45 #include <glib.h>
46
47 #include <epan/packet.h>
48 #include <epan/expert.h>
49 #include <epan/prefs.h>
50 #include "packet-tcp.h"
51
52 static int proto_ged125 = -1;
53
54 static gint hf_ged125_length = -1;
55 static gint hf_ged125_value = -1;
56 static gint hf_ged125_service_control_value = -1;
57 static gint hf_ged125_DialogueID_num = -1;
58 static gint hf_ged125_SendSeqNo_num = -1;
59 static gint hf_ged125_CurrentTime_num = -1;
60 static gint hf_ged125_TimeZoneDelta = -1;
61 static gint hf_ged125_OperationalStatus = -1;
62 static gint hf_ged125_StatusVariable = -1;
63 static gint hf_ged125_InvokeID = -1;
64 static gint hf_ged125_Status = -1;
65 static gint hf_ged125_VersionNumber = -1;
66 static gint hf_ged125_IdleTimeout = -1;
67 static gint hf_ged125_UseEventFeed = -1;
68 static gint hf_ged125_UsePolledFeed = -1;
69 static gint hf_ged125_UseCallRouting = -1;
70 static gint hf_ged125_UseTimeSynch = -1;
71 static gint hf_ged125_UseServiceControl = -1;
72 static gint hf_ged125_TrunkGroupID = -1;
73 static gint hf_ged125_TrunkCount = -1;
74 static gint hf_ged125_CallsInToday = -1;
75 static gint hf_ged125_CallsOutToday = -1;
76 static gint hf_ged125_InServiceTimeToday = -1;
77 static gint hf_ged125_InUseInboundTimeToday = -1;
78 static gint hf_ged125_InUseOutboundTimeToday = -1;
79 static gint hf_ged125_AllTrunksInUseTimeToday = -1;
80 static gint hf_ged125_TrunkNumber = -1;
81 static gint hf_ged125_TrunkStatus = -1;
82 static gint hf_ged125_ServiceID = -1;
83 static gint hf_ged125_AvailableNow = -1;
84 static gint hf_ged125_CallsInNow = -1;
85 static gint hf_ged125_CallsOutNow = -1;
86 static gint hf_ged125_CallsHandledToday = -1;
87 static gint hf_ged125_HandleTimeToday = -1;
88 static gint hf_ged125_DivertedInToday = -1;
89 static gint hf_ged125_DivertedOutToday = -1;
90 static gint hf_ged125_StartOfDay = -1;
91 static gint hf_ged125_InitDataTime = -1;
92 static gint hf_ged125_CallID = -1;
93 static gint hf_ged125_floating = -1;
94 static gint hf_ged125_floating_CauseCode = -1;
95 static gint hf_ged125_ServiceFeatures = -1;
96 static gint hf_ged125_floating_payload_strg = -1;
97 static gint hf_ged125_floating_payload_uint = -1;
98 static gint hf_ged125_floating_payload_bool = -1;
99 static gint hf_ged125_floating_payload_ECC_tag = -1;
100 static gint hf_ged125_ResultCode = -1;
101 static gint hf_ged125_LabelType = -1;
102 static gint hf_ged125_Cause_just_for_release_message = -1;
103 static gint hf_ged125_EventID = -1;
104 static gint hf_ged125_ErrorCode = -1;
105 static gint hf_ged125_InService = -1;
106 static gint hf_ged125_ServiceAvailable = -1;
107 static gint hf_ged125_RequestID = -1;
108 static gint hf_ged125_ToBeContinued = -1;
109 static gint hf_ged125_Barge_In_Allowed = -1;
110 static gint hf_ged125_floating_cause_code = -1;
111 static gint hf_ged125_DTMF_Termination_Key = -1;
112 static gint hf_ged125_No_Entry_Timeout = -1;
113 static gint hf_ged125_Interdigit_Timeout = -1;
114 static gint hf_ged125_Number_of_No_Entry_Tries = -1;
115 static gint hf_ged125_Number_of_Invalid_Entry_Tries = -1;
116 static gint hf_ged125_Min_Length = -1;
117 static gint hf_ged125_Max_Length = -1;
118 static gint hf_ged125_ASR_Allowed = -1;
119 static gint hf_ged125_DTMF_Menu_Keys = -1;
120 static gint hf_ged125_Microapp_Error_Code = -1;
121 static gint hf_ged125_ConferenceCallID = -1;
122 static gint hf_ged125_PrimaryCallID = -1;
123 static gint hf_ged125_SecondaryCallID = -1;
124 static gint hf_ged125_NewServiceID = -1;
125 static gint hf_ged125_NewCallID = -1;
126 static gint hf_ged125_simulator_reset_event = -1;
127 static gint hf_ged125_CrossRefID = -1;
128 static gint hf_ged125_VRUTimeLag = -1;
129 static gint hf_ged125_CallVarsMask = -1;
130 static gint hf_ged125_floating_payload_unspec = -1;
131 static gint hf_ged125_floating_uchar_array_index = -1;
132 static gint hf_ged125_floating_media_protocol = -1;
133 static gint hf_ged125_floating_library_designator = -1;
134 static gint hf_ged125_Data_Playback_Type = -1;
135 static gint hf_ged125_Data_Playback_Formats = -1;
136
137 static gint ett_ged125 = -1;
138 static gint ett_ged125_header = -1;
139 static gint ett_ged125_message = -1;
140 static gint ett_ged125_floating = -1;
141 static gint ett_ged125_float_field = -1;
142 static gint ett_ged125_service_control_header = -1;
143 static gint ett_ged125_service_control_data = -1;
144
145 static expert_field ei_ged125_OperationalStatus_normal = EI_INIT;
146 static expert_field ei_ged125_OperationalStatus_loss_redundant_component = EI_INIT;
147 static expert_field ei_ged125_OperationalStatus_degraded_call_processing = EI_INIT;
148 static expert_field ei_ged125_OperationalStatus_conditions_prevent_call = EI_INIT;
149 static expert_field ei_ged125_OperationalStatus_invalid_message = EI_INIT;
150 static expert_field ei_ged125_length_bad = EI_INIT;
151 static expert_field ei_ged125_sendseqno_and_dialogueid = EI_INIT;
152 static expert_field ei_ged125_service_control_value_unknown = EI_INIT;
153 static expert_field ei_ged125_trunk_group_id = EI_INIT;
154 static expert_field ei_ged125_TrunkCount_invalid = EI_INIT;
155
156 static dissector_handle_t ged125_handle;
157
158 /* Preferences */
159 static guint global_tcp_port_ged125 = 0;
160 static gboolean ged125_desegment_body = TRUE;
161
162 #define GED125_FAILURE_CONF_VALUE 1
163 #define GED125_FAILURE_EVENT_VALUE 2
164 #define GED125_OPEN_REQ_VALUE 3
165 #define GED125_OPEN_CONF_VALUE 4
166 #define GED125_HEARTBEAT_REQ_VALUE 5
167 #define GED125_HEARTBEAT_CONF_VALUE 6
168 #define GED125_CLOSE_REQ_VALUE 7
169 #define GED125_CLOSE_CONF_VALUE 8
170 #define GED125_INIT_DATA_REQ_VALUE 9
171 #define GED125_INIT_DATA_CONF_VALUE 10
172 #define GED125_INIT_TRKGRP_DATA_EVENT_VALUE 11
173 #define GED125_INIT_SERVICE_DATA_EVENT_VALUE 12
174 #define GED125_INIT_VRU_DATA_EVENT_VALUE 13
175 #define GED125_INIT_DATA_END_EVENT_VALUE 14
176 #define GED125_DELIVERED_EVENT_VALUE 15
177 #define GED125_ORIGINATED_EVENT_VALUE 16
178 #define GED125_CALL_CLEARED_EVENT_VALUE 17
179 #define GED125_CONFERENCED_EVENT_VALUE 18
180 #define GED125_DIVERTED_EVENT_VALUE 19
181 #define GED125_NEW_TRANSACTION_EVENT_VALUE 20
182 #define GED125_SET_CALL_VARIABLES_EVENT_VALUE 21
183 #define GED125_VRU_STATUS_EVENT_VALUE 22
184 #define GED125_TRKGRP_STATUS_EVENT_VALUE 23
185 #define GED125_SERVICE_STATUS_EVENT_VALUE 24
186 #define GED125_ROUTE_REQUEST_EVENT_VALUE 41
187 #define GED125_ROUTE_SELECT_VALUE 42
188 #define GED125_ROUTE_END_EVENT_VALUE 43
189 #define GED125_ROUTE_END_VALUE 44
190 #define GED125_TIME_SYNCH_REQ_VALUE 45
191 #define GED125_TIME_SYNCH_CONF_VALUE 46
192 #define GED125_SERVICE_CONTROL_VALUE 47
193 #define GED125_SIMULATOR_RESET_EVENT_VALUE 48
194 #define GED125_REGISTER_VARIABLES_VALUE 49
195
196 #define GED125_INIT_SERVICE_CTRL_REQ_VALUE 1
197 #define GED125_INIT_SERVICE_CTRL_CONF_VALUE 2
198 #define GED125_INIT_SERVICE_CTRL_DATA_VALUE 3
199 #define GED125_INIT_SERVICE_CTRL_END_VALUE 4
200 #define GED125_NEW_CALL_VALUE 5
201 #define GED125_REQUEST_INSTRUCTION_VALUE 6
202 #define GED125_RUN_SCRIPT_REQ_VALUE 7
203 #define GED125_RUN_SCRIPT_RESULT_VALUE 8
204 #define GED125_CONNECT_VALUE 9
205 #define GED125_EVENT_REPORT_VALUE 10
206 #define GED125_DIALOGUE_FAILURE_CONF_VALUE 11
207 #define GED125_DIALOGUE_FAILURE_EVENT_VALUE 12
208 #define GED125_INIT_SERVICE_CTRL_TRKGRP_VALUE 13
209 #define GED125_INIT_SERVICE_CTRL_SERVICE_VALUE 14
210 #define GED125_INIT_SERVICE_CTRL_VRU_VALUE 15
211 #define GED125_TRKGRP_STATUS_VALUE 16
212 #define GED125_SERVICE_STATUS_VALUE 17
213 #define GED125_VRU_STATUS_VALUE 18
214 #define GED125_CANCEL_VALUE 19
215 #define GED125_RELEASE_VALUE 20
216 #define GED125_NEW_DIALOGUE_VALUE 21
217 #define GED125_CONNECT_TO_RESOURCE_VALUE 22
218 #define GED125_RESOURCE_CONNECTED_VALUE 23
219 #define GED125_MICROAPP_CONTEXT_VALUE 24
220 #define GED125_MICROAPP_PLAY_VALUE 25
221 #define GED125_MICROAPP_PLAY_CONTINUE_VALUE 26
222 #define GED125_MICROAPP_COLLECT_DATA_VALUE 27
223 #define GED125_MICROAPP_MENU_VALUE 28
224 #define GED125_MICROAPP_RESULT_VALUE 29
225 #define GED125_TEMPORARY_CONNECT_VALUE 30
226
227 /*Message Element Names and values*/
228 static const value_string vals_floating_point_types[] = {
229 { 0x0, "Invalid"},
230 { 0x1, "Text" },
231 { 0x12, "ANI: Calling-line ID of the caller" },
232 { 0x13, "UUI" },
233 { 0x14, "DNIS" },
234 { 0x15, "Digits Dialed" },
235 { 0x16, "Call Variable 1" },
236 { 0x17, "Call Variable 2" },
237 { 0x18, "Call Variable 3" },
238 { 0x19, "Call Variable 4" },
239 { 0x1A, "Call Variable 5" },
240 { 0x1B, "Call Variable 6" },
241 { 0x1C, "Call Variable 7" },
242 { 0x1D, "Call Variable 8" },
243 { 0x1E, "Call Variable 9" },
244 { 0x1F, "Call Variable 10" },
245 { 0x20, "Dialed Number" },
246 { 0x21, "CED" },
247 { 0x22, "Label" },
248 { 0x23, "Trunk_Group_ID" },
249 { 0x24, "TRUNK_NUMBER" },
250 { 0x25, "Called_Number" },
251 { 0x26, "Script_ID" },
252 { 0x27, "Script Configuration" },
253 { 0x28, "Correlation_ID" },
254 { 0x29, "Cause_Code" },
255 { 0x2a, "Exp Call Var Name" },
256 { 0x2b, "Exp Call Var Value" },
257 { 0x2c, "EXP CALL VAR ARRAY" },
258 { 0x2d, "New Transaction Tag" },
259 { 0x2e, "Transfer Hint Tag" },
260 { 0x2f, "Media_Specifier" },
261 { 0x30, "Initial Prompt-(MEDIA_SPECIFIER)" },
262 { 0x31, "Invalid Entry Prompt-(MEDIA_SPECIFIER)" },
263 { 0x32, "Timeout_Prompt-(MEDIA_SPECIFIER)" },
264 { 0x33, "Customer ID" },
265 { 0x34, "Application_Media_Library" },
266 { 0x35, "System Media Library" },
267 { 0x36, "Locale" },
268 { 0x37, "Media-Server_Set" },
269 { 0x38, "Microapp-Error Text" },
270 { 0x39, "ASR Grammar" },
271 { 0x3a, "Currency" },
272 { 0, NULL}
273 };
274
275 /*RELEASE Message type*/
276 static const value_string Cause_just_for_release_message_vals[] = {
277 {0, "Normal-Call Clearing" },
278 {1, "No Route to Destination" },
279 {0, NULL}
280 };
281
282 /*Base Message for the ged125*/
283 static const value_string base_message_values[] = {
284 { GED125_FAILURE_CONF_VALUE, "FAILURE_CONF" },
285 { GED125_FAILURE_EVENT_VALUE, "FAILURE_EVENT" },
286 { GED125_OPEN_REQ_VALUE, "OPEN_REQ" },
287 { GED125_OPEN_CONF_VALUE, "OPEN_CONF" },
288 { GED125_HEARTBEAT_REQ_VALUE, "HEARTBEAT_REQ" },
289 { GED125_HEARTBEAT_CONF_VALUE, "HEARTBEAT_CONF" },
290 { GED125_CLOSE_REQ_VALUE, "CLOSE_REQ" },
291 { GED125_CLOSE_CONF_VALUE, "CLOSE_CONF" },
292 { GED125_INIT_DATA_REQ_VALUE, "INIT_DATA_REQ" },
293 { GED125_INIT_DATA_CONF_VALUE, "INIT_DATA_CONF" },
294 { GED125_INIT_TRKGRP_DATA_EVENT_VALUE, "INIT_TRKGRP_DATA_EVENT" },
295 { GED125_INIT_SERVICE_DATA_EVENT_VALUE, "INIT_SERVICE_DATA_EVENT" },
296 { GED125_INIT_VRU_DATA_EVENT_VALUE, "INIT_VRU_DATA_EVENT" },
297 { GED125_INIT_DATA_END_EVENT_VALUE, "INIT_DATA_END_EVENT" },
298 { GED125_DELIVERED_EVENT_VALUE, "DELIVERED_EVENT" },
299 { GED125_ORIGINATED_EVENT_VALUE, "ORIGINATED_EVENT" },
300 { GED125_CALL_CLEARED_EVENT_VALUE, "CALL_CLEARED_EVENT" },
301 { GED125_CONFERENCED_EVENT_VALUE, "CONFERENCED_EVENT" },
302 { GED125_DIVERTED_EVENT_VALUE, "DIVERTED_EVENT" },
303 { GED125_NEW_TRANSACTION_EVENT_VALUE, "NEW_TRANSACTION_EVENT" },
304 { GED125_SET_CALL_VARIABLES_EVENT_VALUE, "SET_CALL_VARIABLES_EVENT" },
305 { GED125_VRU_STATUS_EVENT_VALUE, "VRU_STATUS_EVENT" },
306 { GED125_TRKGRP_STATUS_EVENT_VALUE, "TRKGRP_STATUS_EVENT" },
307 { GED125_SERVICE_STATUS_EVENT_VALUE, "SERVICE_STATUS_EVENT" },
308 { GED125_ROUTE_REQUEST_EVENT_VALUE, "ROUTE_REQUEST_EVENT" },
309 { GED125_ROUTE_SELECT_VALUE, "ROUTE_SELECT" },
310 { GED125_ROUTE_END_EVENT_VALUE, "ROUTE_END_EVENT" },
311 { GED125_ROUTE_END_VALUE, "ROUTE_END" },
312 { GED125_TIME_SYNCH_REQ_VALUE, "TIME_SYNCH_REQ" },
313 { GED125_TIME_SYNCH_CONF_VALUE, "TIME_SYNCH_CONF" },
314 { GED125_SERVICE_CONTROL_VALUE, "SERVICE_CONTROL" },
315 { GED125_SIMULATOR_RESET_EVENT_VALUE, "SIMULATOR_RESET_EVENT" },
316 { GED125_REGISTER_VARIABLES_VALUE, "REGISTER_VARIABLES" },
317 { 0, NULL}
318 };
319
320 /*status codes that may be included in the FAILURE_CONF, FAILURE_EVENT,
321 DIALOGUE_FAILURE_CONF, DIALOGUE_FAILURE_EVENT, ROUTE_END_EVENT, and
322 ROUTE_END messages.*/
323 static const value_string error_codes[] = {
324 { 0x0, "E_NO_ERROR"},
325 { 0x1, "E_INVALID_VERSION" },
326 { 0x2, "E_SESSION_ALREADY_ACTIVE" },
327 { 0x3, "E_VRU_OFFLINE" },
328 { 0x4, "E_SESSION_NOT_ACTIVE" },
329 { 0x5, "E_INVALID_DIALED_NUMBER"},
330 { 0x6, "E_EVENTS_NOT_SUPPORTED"},
331 { 0x7, "E_EVENTS_NOT_SUPPORTED"},
332 { 0x8, "E_ROUTING_NOT_SUPPORTED"},
333 { 0x9, "E_TIME_SYNCH_NOT_SUPPORTED"},
334 { 0xA, "E_TIMEOUT"},
335 { 0xB, "E_PG_OFFLINE"},
336 { 0xC, "E_REQUEST_REFUSED"},
337 { 0xD, "E_ROUTING_NOT_AVAILABLE"},
338 { 0xE, "E_ROUTE_NOT_ACCEPTED"},
339 { 0xF, "E_UNSPECIFIED_FAILURE"},
340 { 0x10, "E_INVALID_INVOKEID"},
341 { 0x11, "E_SERVICE_CTRL_NOT_SUPPORTED"},
342 { 0x12, "E_NO_SCRIPT"},
343 { 0x13, "E_CALL_VARIABLE1"},
344 { 0x14, "E_CALL_VARIABLE2"},
345 { 0x15, "E_CALL_VARIABLE3"},
346 { 0x16, "E_CALL_VARIABLE4"},
347 { 0x17, "E_CALL_VARIABLE5"},
348 { 0x18, "E_CALL_VARIABLE6"},
349 { 0x19, "E_CALL_VARIABLE7"},
350 { 0x1A, "E_CALL_VARIABLE8"},
351 { 0x1B, "E_CALL_VARIABLE9"},
352 { 0x1C, "E_CALL_VARIABLE10"},
353 { 0x1E, "E_INVALID_SCRIPT"},
354 { 0x1F, "E_INVALID_CALLID"},
355 { 0x20, "E_DUPLICATE_DIALOGUEID"},
356 { 0x21, "E_INVALID_MESSAGE"},
357 { 0x22, "E_INVALID_DIALOGUEID"},
358 { 0x23, "E_OPERATION_CANCELLED"},
359 { 0x24, "E_OPERATION_NOT_CANCELLED"},
360 { 0x25, "E_SIMULATOR_RESET"},
361 { 0x26, "E_SIMULATOR_REINIT"},
362 { 0, NULL}
363 };
364
365 /*Call Cleared Causes*/
366 static const value_string vals_status_code_call_cleared[] = {
367 { 0x1, "DBCD_DROP_HANDLED_PRIMARY_ROUTE-(Normal Completion)"},
368 { 0x2, "DBCD_ABAND_AGENT_TERMINAL-(Call Abandoned)"},
369 { 0x3, "DBCD_BLIND_TRANSFER-(Call Transferred)"},
370 { 0x4, "DBCD_DROP_HANDLED_PRIMARY_ROUTE-(Normal Completion)"},
371 { 0x5, "DBCD_DROP_BUSY-(Busy)"},
372 { 0x6, "DBCD_DROP_NO_ANSWER-(No Answer)"},
373 { 0x7, "DBCD_TIME_OUT-(Maintenance)"},
374 { 0x8, "DBCD_FORCED_BUSY-(Net Congestion)"},
375 { 0x9, "DBCD_INTERCEPT_REORDER-(Net Not Obtainable)"},
376 { 0xA, "DBCD_DROP_REORDER-(Reorder Tone)"},
377 { 0xB, "DBCD_INTERCEPT_DENIAL-(Resources Not Available)"},
378 { 0xC, "DBCD_FORCED_BUSY-(Net Congestion)"},
379 { 0xD, "DBCD_CALLED_PARTY_DISCONNECTED-(Called Party Disconnected)"},
380 { 0, NULL}
381 };
382
383 /*Trunk Status Definitions*/
384 static const value_string status_code_trunk_status[] = {
385 { 1, "TRUNK_OUT_OF_SERVICE"},
386 { 2, "TRUNK_IN_USE_INBOUND"},
387 { 3, "TRUNK_IN_USE_OUTBOUND"},
388 { 4, "TRUNK_IDLE"},
389 { 0, NULL}
390 };
391
392 #if 0
393 /*Label values*/
394 static const value_string vals_status_code_label_values[] = {
395 { 0x1, "NORMAL"},
396 { 0x2, "BUSY"},
397 { 0x3, "RING"},
398 { 0x5, "DEFAULT"},
399 { 0, NULL}
400 };
401 #endif
402
403 /*Service Control Message Sub-values*/
404 static const value_string vals_service_control_message_subvalues[] = {
405 { GED125_INIT_SERVICE_CTRL_REQ_VALUE, "INIT_SERVICE_CTRL_REQ"},
406 { GED125_INIT_SERVICE_CTRL_CONF_VALUE, "INIT_SERVICE_CTRL_CONF"},
407 { GED125_INIT_SERVICE_CTRL_DATA_VALUE, "INIT_SERVICE_CTRL_DATA"},
408 { GED125_INIT_SERVICE_CTRL_END_VALUE, "INIT_SERVICE_CTRL_END"},
409 { GED125_NEW_CALL_VALUE, "NEW_CALL"},
410 { GED125_REQUEST_INSTRUCTION_VALUE, "REQUEST_INSTRUCTION"},
411 { GED125_RUN_SCRIPT_REQ_VALUE, "RUN_SCRIPT_REQ"},
412 { GED125_RUN_SCRIPT_RESULT_VALUE, "RUN_SCRIPT_RESULT"},
413 { GED125_CONNECT_VALUE, "CONNECT"},
414 { GED125_EVENT_REPORT_VALUE, "EVENT_REPORT"},
415 { GED125_DIALOGUE_FAILURE_CONF_VALUE, "DIALOGUE_FAILURE_CONF"},
416 { GED125_DIALOGUE_FAILURE_EVENT_VALUE, "DIALOGUE_FAILURE_EVENT"},
417 { GED125_INIT_SERVICE_CTRL_TRKGRP_VALUE, "INIT_SERVICE_CTRL_TRKGRP"},
418 { GED125_INIT_SERVICE_CTRL_SERVICE_VALUE, "INIT_SERVICE_CTRL_SERVICE"},
419 { GED125_INIT_SERVICE_CTRL_VRU_VALUE, "INIT_SERVICE_CTRL_VRU"},
420 { GED125_TRKGRP_STATUS_VALUE, "TRKGRP_STATUS"},
421 { GED125_SERVICE_STATUS_VALUE, "SERVICE_STATUS"},
422 { GED125_VRU_STATUS_VALUE, "VRU_STATUS"},
423 { GED125_CANCEL_VALUE, "CANCEL"},
424 { GED125_RELEASE_VALUE, "RELEASE"},
425 { GED125_NEW_DIALOGUE_VALUE, "NEW_DIALOGUE"},
426 { GED125_CONNECT_TO_RESOURCE_VALUE, "CONNECT_TO_RESOURCE"},
427 { GED125_RESOURCE_CONNECTED_VALUE, "RESOURCE_CONNECTED"},
428 { GED125_MICROAPP_CONTEXT_VALUE, "MICROAPP_CONTEXT"},
429 { GED125_MICROAPP_PLAY_VALUE, "MICROAPP_PLAY"},
430 { GED125_MICROAPP_PLAY_CONTINUE_VALUE, "MICROAPP_PLAY_CONTINUE"},
431 { GED125_MICROAPP_COLLECT_DATA_VALUE, "MICROAPP_COLLECT_DATA"},
432 { GED125_MICROAPP_MENU_VALUE, "MICROAPP_MENU"},
433 { GED125_MICROAPP_RESULT_VALUE, "MICROAPP_RESULT"},
434 { GED125_TEMPORARY_CONNECT_VALUE, "TEMPORARY_CONNECT"},
435 { 0, NULL}
436 };
437
438 /*Microapp Error Codes*/
439 static const value_string status_code_microcapp_error_codes[] = {
440 { 0, "MICROAPP_E_OK" },
441 { 1, "MICROAPP_E_ERROR" },
442 { 2, "MICROAPP_E_VRU_TIMED_OUT" },
443 { 3, "MICROAPP_E_ABORTED" },
444 { 4, "MICROAPP_E_DIALOG_FAILED" },
445 { 5, "MICROAPP_E_VRU_SCRIPT_NOT_FOUND"},
446 { 1001, "MICROAPP_E_INTERNAL" },
447 { 1002, "MICROAPP_E_MAX_INVALID" },
448 { 1003, "MICROAPP_E_MAX_NO_ENTRY" },
449 { 1004, "MICROAPP_E_MEDIA_PROTOCOL" },
450 { 1005, "MICROAPP_E_MEDIA_VALUE" },
451 { 1006, "MICROAPP_E_NETWORK" },
452 { 1007, "MICROAPP_E_NO_MEDIA" },
453 { 1008, "MICROAPP_E_NUMBER_FORMAT" },
454 { 1009, "MICROAPP_E_PARAMETER" },
455 { 1010, "MICROAPP_E_SYSTEM" },
456 { 1011, "MICROAPP_E_UNSUPPORTED" },
457 { 1012, "MICROAPP_E_DATA_RANGE" },
458 { 1013, "MICROAPP_E_INTERNAL_TIMEOUT" },
459 { 1014, "MICROAPP_E_RECOGNITION" },
460 { 1999, "MICROAPP_E_OTHER" },
461 { 0, NULL}
462 };
463
464 /*Label values*/
465 static const value_string status_code_Label_values[] = {
466 { 1, "NORMAL" },
467 { 2, "BUSY" },
468 { 3, "RING" },
469 { 4, "Not Supported" },
470 { 5, "DEFAULT" },
471 { 0, NULL}
472 };
473
474 /*Event Report Codes*/
475 static const value_string status_code_event_reportcodes[] = {
476 { 1, "CONNECT_FAILURE" },
477 { 2, "BUSY" },
478 { 3, "NO_ANSWER" },
479 { 4, "ANSWER" },
480 { 5, "ABANDON" },
481 { 6, "DISCONNECT" },
482 { 7, "CONNECT_INVALID" },
483 { 0, NULL}
484 };
485
486 /*values for the media specifier fields*/
487 static const value_string Data_Playback_Type[] = {
488 { 1, "PLAYBACK_TYPE_NUMBER" },
489 { 2, "PLAYBACK_TYPE_CHAR" },
490 { 3, "PLAYBACK_TYPE_ETIME" },
491 { 4, "PLAYBACK_TYPE_TOD" },
492 { 5, "PLAYBACK_TYPE_24TOD" },
493 { 6, "PLAYBACK_TYPE_DOW" },
494 { 7, "PLAYBACK_TYPE_DATE" },
495 { 8, "PLAYBACK_TYPE_CURRENCY" },
496 { 9, "PLAYBACK_TYPE_TEXT" },
497 { 0, NULL}
498 };
499
500 /*values for the media specifier fields*/
501 static const value_string Data_Playback_Formats[] = {
502 { 1, "PLAYBACK_FORMAT_HHMM" },
503 { 2, "PLAYBACK_FORMAT_HHMMSS" },
504 { 3, "PLAYBACK_FORMAT_HHMMAP" },
505 { 4, "PLAYBACK_FORMAT_OTHER" },
506 { 0, NULL}
507 };
508
509 static const value_string floating_media_protocol_vals[] = {
510 { 'H', "(HTTP)" },
511 { 'S', "(Streaming)" },
512 { 'O', "(Other)" },
513 { 'F', "(File)" },
514 { 'T', "(Text)" },
515 { 'D', "(DATA)" },
516 { 0, NULL}
517 };
518
519 static const value_string floating_media_library_designator_vals[] = {
520 { 'A', "(Application)" },
521 { 'S', "(System)" },
522 { 0, NULL}
523 };
524
525 static void
526 OperationalStatus_funk(tvbuff_t* tvb, packet_info *pinfo, proto_tree* tree, gint* offset)
527 {
528 guint32 value;
529 proto_item* ti;
530
531 value = tvb_get_ntohl(tvb, *offset);
532 ti = proto_tree_add_item(tree, hf_ged125_OperationalStatus, tvb, *offset, 4, ENC_BIG_ENDIAN);
533
534 if (value == 0)
535 expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_normal);
536 else if (value <= 31 && value >0)
537 expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_loss_redundant_component);
538 else if (value <= 63 && value >= 32 ) /*32-63*/
539 expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_degraded_call_processing);
540 else if (value <= 127 && value >= 64 ) /*64-127*/
541 expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_conditions_prevent_call);
542 else if (value > 127) /*error*/
543 expert_add_info(pinfo, ti, &ei_ged125_OperationalStatus_invalid_message);
544
545 *offset += 4;
546 }
547
548
549 static void
550 StatusVariable_funk(tvbuff_t* tvb, proto_tree* tree, gint* offset, const gint size)
551 {
552 while(*offset+4 <= size)
553 {
554 proto_tree_add_item(tree, hf_ged125_StatusVariable, tvb, *offset, 4, ENC_BIG_ENDIAN);
555 *offset += 4;
556 }
557 }
558
559 static void
560 trunk_funk_without_status(tvbuff_t* tvb, proto_tree* z_tree, gint* offset, const gint size)
561 {
562 gint count = 0;
563
564 while(*offset+2 <= size && count < 1024)
565 {
566 proto_tree_add_item(z_tree, hf_ged125_TrunkNumber, tvb, *offset, 2, ENC_BIG_ENDIAN);
567 *offset += 2;
568 count++;
569 }
570 }
571
572 static void
573 trunk_funk(tvbuff_t* tvb, proto_tree* tree, gint* offset, const gint size)
574 {
575 guint16 count = 0;
576
577 /* 1023 max trunks, the trunk loop(counting from 0 from 1023 is 1024)*/
578 while(*offset+4 <= size && count < 1024) {
579 proto_tree_add_item(tree, hf_ged125_TrunkNumber, tvb, *offset, 2, ENC_BIG_ENDIAN);
580 *offset += 2;
581 proto_tree_add_item(tree, hf_ged125_TrunkStatus, tvb, *offset, 2, ENC_BIG_ENDIAN);
582 *offset += 2;
583
584 count++;
585 }
586 }
587
588 static void
589 Media_Specifier_dissect(tvbuff_t* tvb, proto_tree* tree, gint* offset, guint32 length)
590 {
591 guint8 media_protocol;
592
593 media_protocol = tvb_get_guint8(tvb, *offset);
594 proto_tree_add_item(tree, hf_ged125_floating_media_protocol, tvb, *offset, 1, ENC_BIG_ENDIAN);
595 *offset += 1;
596
597 switch (media_protocol)
598 {
599 case 'H':
600 case 'S':
601 case 'O':
602 case 'F':
603 proto_tree_add_item(tree, hf_ged125_floating_library_designator, tvb, *offset, 1, ENC_BIG_ENDIAN);
604 *offset += 1;
605 proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 2, ENC_NA|ENC_ASCII);
606 break;
607
608 case 'T':
609 proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 1, ENC_NA|ENC_ASCII);
610 break;
611
612 case 'D':
613 proto_tree_add_item(tree, hf_ged125_Data_Playback_Type, tvb, *offset, 4, ENC_BIG_ENDIAN);
614 *offset += 4;
615 proto_tree_add_item(tree, hf_ged125_Data_Playback_Formats, tvb, *offset, 4, ENC_BIG_ENDIAN);
616 *offset += 4;
617 proto_tree_add_item(tree, hf_ged125_floating_payload_strg, tvb, *offset, length - 9, ENC_NA|ENC_ASCII);
618 break;
619 }
620
621 *offset += length;
622 }
623
624 static void
625 floating_fields(tvbuff_t* tvb, packet_info *pinfo, proto_tree* tree, gint offset, const gint size)
626 {
627 gint32 length = 4;
628 guint32 floating_type;
629 proto_tree *ged125_tree, *float_tree;
630 proto_item *ti;
631
632 if (size - offset > 0)
633 length = size - offset;
634
635 ti = proto_tree_add_text(tree, tvb, offset, length, "Float Message");
636 ged125_tree = proto_item_add_subtree(ti, ett_ged125_floating);
637
638 /*The Universal Floating-Fields Loop of Fun*/
639 while (offset < size-2)
640 {
641 floating_type = tvb_get_guint8(tvb, offset);
642 ti = proto_tree_add_uint_format(ged125_tree, hf_ged125_floating, tvb, offset, 1,
643 floating_type, "%s", val_to_str(floating_type,
644 vals_floating_point_types, "Unknown %d"));
645 float_tree = proto_item_add_subtree(ti, ett_ged125_float_field);
646 offset += 1;
647
648 length = tvb_get_guint8(tvb, offset);
649 proto_tree_add_uint(float_tree, hf_ged125_length, tvb, offset, 1, length);
650 offset += 1;
651
652 if ((offset + length > size) && (length > 0))
653 {
654 expert_add_info(pinfo, ti, &ei_ged125_length_bad);
655 break;
656 }
657
658 switch (floating_type)
659 {
660 case 42:
661 case 43:
662 proto_tree_add_item(float_tree, hf_ged125_floating_payload_ECC_tag, tvb, offset, 4, ENC_BIG_ENDIAN);
663 offset += 4;
664 if (length-4 > 0)
665 {
666 proto_tree_add_item(float_tree, hf_ged125_floating_payload_strg, tvb, offset, length-4, ENC_NA|ENC_ASCII);
667 offset += (length-4);
668 }
669 break;
670
671 case 44: /*ECC_VAR_ARRAY*/
672 proto_tree_add_item(float_tree, hf_ged125_floating_payload_ECC_tag, tvb, offset, 4, ENC_BIG_ENDIAN);
673 offset += 4;
674 proto_tree_add_item(float_tree, hf_ged125_floating_uchar_array_index, tvb, offset, 1, ENC_BIG_ENDIAN);
675 offset += 1;
676 if (length-5 > 0)
677 {
678 proto_tree_add_item(float_tree, hf_ged125_floating_payload_strg, tvb, offset, length-4, ENC_NA|ENC_ASCII);
679 offset += (length-5);
680 }
681 break;
682
683 case 47:
684 case 48:
685 case 49:
686 case 50: /*MEDIA_SPECIFIER*/
687 Media_Specifier_dissect(tvb, float_tree, &offset, length);
688 break;
689
690 case 19: /* unspec var type(UUI) */
691 proto_tree_add_item(float_tree, hf_ged125_floating_payload_unspec, tvb, offset, length, ENC_NA);
692 offset += length;
693 break;
694
695 case 1:
696 case 18:
697 case 20: case 21: case 22: case 23: case 24: case 25: case 26: case 27:
698 case 28: case 29: case 30: case 31: case 32: case 33: case 34:
699 case 37: case 38: case 39: case 40:
700 case 51: case 52: case 53: case 54: case 55: case 56: case 57: case 58:
701 proto_tree_add_item(float_tree, hf_ged125_floating_payload_strg, tvb, offset, length, ENC_NA|ENC_ASCII);
702 offset += length;
703 break;
704
705 case 35:
706 case 36:
707 proto_tree_add_item(float_tree, hf_ged125_floating_payload_uint, tvb, offset, 4, ENC_BIG_ENDIAN);
708 offset += length;
709 break;
710 case 41:
711 proto_tree_add_item(float_tree, hf_ged125_floating_cause_code, tvb, offset, 4, ENC_BIG_ENDIAN);
712 offset += length;
713 break;
714
715 case 45:
716 case 46:
717 proto_tree_add_item(float_tree, hf_ged125_floating_payload_bool, tvb, offset, 4, ENC_BIG_ENDIAN);
718 offset += length;
719 break;
720 }
721 }
722 }
723
724 static void
725 service_control_dissect(tvbuff_t* tvb,proto_tree* msg_tree, proto_tree* ged125_tree, packet_info* pinfo,
726 gint* offset, const gint size)
727 {
728 proto_item *ti;
729 proto_tree *service_tree, *data_tree;
730 guint32 mess_type, DialogueID, SendSeqNo;
731
732 ti = proto_tree_add_text(msg_tree, tvb, *offset, 12, "Service-Control Header");
733 service_tree = proto_item_add_subtree(ti, ett_ged125_service_control_header);
734
735 /* get message sub type, don't want to output that just yet */
736 mess_type = tvb_get_ntohl(tvb, *offset);
737 *offset += 4;
738
739 DialogueID = tvb_get_ntohl(tvb, *offset);
740 proto_tree_add_item(service_tree, hf_ged125_DialogueID_num, tvb, *offset, 4, ENC_BIG_ENDIAN);
741 *offset += 4;
742
743 col_add_fstr(pinfo->cinfo, COL_INFO, "Service_Control->%s DIALOGUE_ID=%u LEN=%u",
744 val_to_str(mess_type, vals_service_control_message_subvalues, "Unknown %d"), DialogueID, size);
745
746 SendSeqNo = tvb_get_ntohl(tvb, *offset);
747 ti = proto_tree_add_item(service_tree, hf_ged125_SendSeqNo_num, tvb, *offset, 4, ENC_BIG_ENDIAN);
748 *offset += 4;
749
750 if ((DialogueID != SendSeqNo) &&
751 ((DialogueID == 0xFFFFFFFF) || (SendSeqNo == 0xFFFFFFFF)))
752 expert_add_info(pinfo, ti, &ei_ged125_sendseqno_and_dialogueid);
753
754 ti = proto_tree_add_uint(service_tree, hf_ged125_service_control_value,
755 tvb, *offset-12, 4, mess_type);
756 data_tree = proto_item_add_subtree(ti, ett_ged125_service_control_data);
757
758 switch (mess_type)
759 {
760 case GED125_INIT_SERVICE_CTRL_REQ_VALUE:
761 case GED125_INIT_SERVICE_CTRL_CONF_VALUE:
762 case GED125_INIT_SERVICE_CTRL_END_VALUE:
763 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
764 *offset += 4;
765 break;
766
767 case GED125_INIT_SERVICE_CTRL_DATA_VALUE:
768 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
769 *offset += 4;
770 proto_tree_add_item(data_tree, hf_ged125_ServiceFeatures, tvb, *offset, 4, ENC_BIG_ENDIAN);
771 *offset += 4;
772 break;
773
774 case GED125_NEW_CALL_VALUE:
775 case GED125_REQUEST_INSTRUCTION_VALUE:
776 proto_tree_add_item(data_tree, hf_ged125_TrunkGroupID, tvb, *offset, 4, ENC_BIG_ENDIAN);
777 *offset += 4;
778 proto_tree_add_item(data_tree, hf_ged125_TrunkNumber, tvb, *offset, 4, ENC_BIG_ENDIAN);
779 *offset += 4;
780 proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN);
781 *offset += 4;
782 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
783 break;
784
785 case GED125_RUN_SCRIPT_REQ_VALUE:
786 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
787 *offset += 4;
788 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
789 break;
790
791 case GED125_RUN_SCRIPT_RESULT_VALUE:
792 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
793 *offset += 4;
794 proto_tree_add_item(data_tree, hf_ged125_ResultCode, tvb, *offset, 4, ENC_BIG_ENDIAN);
795 *offset += 4;
796 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
797 break;
798
799 case GED125_CONNECT_VALUE:
800 proto_tree_add_item(data_tree, hf_ged125_LabelType, tvb, *offset, 4, ENC_BIG_ENDIAN);
801 *offset += 4;
802 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
803 break;
804
805 case GED125_EVENT_REPORT_VALUE:
806 proto_tree_add_item(data_tree, hf_ged125_EventID, tvb, *offset, 4, ENC_BIG_ENDIAN);
807 *offset += 4;
808 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
809 break;
810
811 case GED125_DIALOGUE_FAILURE_CONF_VALUE:
812 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
813 *offset += 4;
814 proto_tree_add_item(data_tree, hf_ged125_ErrorCode, tvb, *offset, 4, ENC_BIG_ENDIAN);
815 *offset += 4;
816 break;
817
818 case GED125_DIALOGUE_FAILURE_EVENT_VALUE:
819 proto_tree_add_item(data_tree, hf_ged125_ErrorCode, tvb, *offset, 4, ENC_BIG_ENDIAN);
820 *offset += 4;
821 break;
822
823 case GED125_INIT_SERVICE_CTRL_TRKGRP_VALUE:
824 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
825 *offset += 4;
826 proto_tree_add_item(data_tree, hf_ged125_TrunkGroupID, tvb, *offset, 4, ENC_BIG_ENDIAN);
827 *offset += 4;
828 proto_tree_add_item(data_tree, hf_ged125_TrunkCount, tvb, *offset, 4, ENC_BIG_ENDIAN);
829 *offset += 4;
830 trunk_funk(tvb, data_tree, offset, size);
831 break;
832
833 case GED125_INIT_SERVICE_CTRL_SERVICE_VALUE:
834 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
835 *offset += 4;
836 proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN);
837 *offset += 4;
838 proto_tree_add_item(data_tree, hf_ged125_AvailableNow, tvb, *offset, 4, ENC_BIG_ENDIAN);
839 *offset += 4;
840 proto_tree_add_item(data_tree, hf_ged125_CallsInNow, tvb, *offset, 4, ENC_BIG_ENDIAN);
841 *offset += 4;
842 proto_tree_add_item(data_tree, hf_ged125_CallsOutNow, tvb, *offset, 4, ENC_BIG_ENDIAN);
843 *offset += 4;
844 break;
845
846 case GED125_INIT_SERVICE_CTRL_VRU_VALUE:
847 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
848 *offset += 4;
849 proto_tree_add_item(data_tree, hf_ged125_CurrentTime_num, tvb, *offset, 4, ENC_BIG_ENDIAN);
850 *offset += 4;
851 proto_tree_add_item(data_tree, hf_ged125_TimeZoneDelta, tvb, *offset, 4, ENC_BIG_ENDIAN);
852 *offset += 4;
853 OperationalStatus_funk(tvb, pinfo, data_tree, offset);
854 StatusVariable_funk(tvb, data_tree, offset, size);
855 break;
856
857 case GED125_TRKGRP_STATUS_VALUE:
858 proto_tree_add_item(data_tree, hf_ged125_TrunkGroupID, tvb, *offset, 4, ENC_BIG_ENDIAN);
859 *offset += 4;
860 proto_tree_add_item(data_tree, hf_ged125_TrunkCount, tvb, *offset, 4, ENC_BIG_ENDIAN);
861 *offset += 4;
862 trunk_funk(tvb, data_tree, offset, size);
863 break;
864
865 case GED125_SERVICE_STATUS_VALUE:
866 proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN);
867 *offset += 4;
868 proto_tree_add_item(data_tree, hf_ged125_ServiceAvailable, tvb, *offset, 4, ENC_BIG_ENDIAN);
869 *offset += 4;
870 break;
871
872 case GED125_VRU_STATUS_VALUE:
873 proto_tree_add_item(data_tree, hf_ged125_CurrentTime_num, tvb, *offset, 4, ENC_BIG_ENDIAN);
874 *offset += 4;
875 proto_tree_add_item(data_tree, hf_ged125_TimeZoneDelta, tvb, *offset, 4, ENC_BIG_ENDIAN);
876 *offset += 4;
877 OperationalStatus_funk(tvb, pinfo, data_tree, offset);
878 StatusVariable_funk(tvb, data_tree, offset, size);
879 break;
880
881 case GED125_CANCEL_VALUE:
882 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
883 *offset += 4;
884 proto_tree_add_item(data_tree, hf_ged125_RequestID, tvb, *offset, 4, ENC_BIG_ENDIAN);
885 *offset += 4;
886 break;
887
888 case GED125_RELEASE_VALUE:
889 proto_tree_add_item(data_tree, hf_ged125_Cause_just_for_release_message, tvb, *offset, 4, ENC_BIG_ENDIAN);
890 *offset += 4;
891 break;
892
893 case GED125_NEW_DIALOGUE_VALUE:
894 proto_tree_add_item(data_tree, hf_ged125_CallID, tvb, *offset, 4, ENC_BIG_ENDIAN);
895 *offset += 4;
896 proto_tree_add_item(data_tree, hf_ged125_ServiceID, tvb, *offset, 4, ENC_BIG_ENDIAN);
897 *offset += 4;
898 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
899 break;
900
901 case GED125_CONNECT_TO_RESOURCE_VALUE:
902 case GED125_MICROAPP_CONTEXT_VALUE:
903 case GED125_TEMPORARY_CONNECT_VALUE:
904 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
905 break;
906
907 case GED125_RESOURCE_CONNECTED_VALUE:
908 /*nothing goes here*/
909 break;
910
911 case GED125_MICROAPP_PLAY_VALUE:
912 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
913 *offset += 4;
914 proto_tree_add_item(data_tree, hf_ged125_ToBeContinued, tvb, *offset, 4, ENC_BIG_ENDIAN);
915 *offset += 4;
916 proto_tree_add_item(data_tree, hf_ged125_Barge_In_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN);
917 *offset += 4;
918 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
919 break;
920
921 case GED125_MICROAPP_PLAY_CONTINUE_VALUE:
922 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
923 *offset += 4;
924 proto_tree_add_item(data_tree, hf_ged125_ToBeContinued, tvb, *offset, 4, ENC_BIG_ENDIAN);
925 *offset += 4;
926 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
927 break;
928
929 case GED125_MICROAPP_COLLECT_DATA_VALUE:
930 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
931 *offset += 4;
932 proto_tree_add_item(data_tree, hf_ged125_DTMF_Termination_Key, tvb, *offset, 4, ENC_BIG_ENDIAN);
933 *offset += 4;
934 proto_tree_add_item(data_tree, hf_ged125_No_Entry_Timeout, tvb, *offset, 4, ENC_BIG_ENDIAN);
935 *offset += 4;
936 proto_tree_add_item(data_tree, hf_ged125_Interdigit_Timeout, tvb, *offset, 4, ENC_BIG_ENDIAN);
937 *offset += 4;
938 proto_tree_add_item(data_tree, hf_ged125_Number_of_No_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN);
939 *offset += 4;
940 proto_tree_add_item(data_tree, hf_ged125_Number_of_Invalid_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN);
941 *offset += 4;
942 proto_tree_add_item(data_tree, hf_ged125_Min_Length, tvb, *offset, 4, ENC_BIG_ENDIAN);
943 *offset += 4;
944 proto_tree_add_item(data_tree, hf_ged125_Max_Length, tvb, *offset, 4, ENC_BIG_ENDIAN);
945 *offset += 4;
946 proto_tree_add_item(data_tree, hf_ged125_Barge_In_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN);
947 *offset += 4;
948 proto_tree_add_item(data_tree, hf_ged125_ASR_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN);
949 *offset += 4;
950 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
951 break;
952
953 case GED125_MICROAPP_MENU_VALUE:
954 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
955 *offset += 4;
956 proto_tree_add_item(data_tree, hf_ged125_No_Entry_Timeout, tvb, *offset, 4, ENC_BIG_ENDIAN);
957 *offset += 4;
958 proto_tree_add_item(data_tree, hf_ged125_Number_of_No_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN);
959 *offset += 4;
960 proto_tree_add_item(data_tree, hf_ged125_Number_of_Invalid_Entry_Tries, tvb, *offset, 4, ENC_BIG_ENDIAN);
961 *offset += 4;
962 proto_tree_add_item(data_tree, hf_ged125_DTMF_Menu_Keys, tvb, *offset, 4, ENC_BIG_ENDIAN);
963 *offset += 4;
964 proto_tree_add_item(data_tree, hf_ged125_Barge_In_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN);
965 *offset += 4;
966 proto_tree_add_item(data_tree, hf_ged125_ASR_Allowed, tvb, *offset, 4, ENC_BIG_ENDIAN);
967 *offset += 4;
968 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
969 break;
970
971 case GED125_MICROAPP_RESULT_VALUE:
972 proto_tree_add_item(data_tree, hf_ged125_InvokeID, tvb, *offset, 4, ENC_BIG_ENDIAN);
973 *offset += 4;
974 proto_tree_add_item(data_tree, hf_ged125_Microapp_Error_Code, tvb, *offset, 4, ENC_BIG_ENDIAN);
975 *offset += 4;
976 floating_fields(tvb, pinfo, ged125_tree, *offset, size);
977 break;
978
979 default:
980 expert_add_info(pinfo, ti, &ei_ged125_service_control_value_unknown);
981 }
982 }
983
984 static guint
985 get_ged125_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, gint offset _U_)
986 {
987 return tvb_get_ntohl(tvb, 0) + 8;
988 }
989
990 static int
991 dissect_ged125_base_messages(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, void* data _U_)
992 {
993 gint size = tvb_reported_length(tvb);
994 proto_item *ti, *message_item;
995 proto_tree *ged125_tree, *ged125_header_tree, *ged125_message_tree;
996 gint offset = 8; /*get to the fixed message, just outside of header*/
997 guint32 value,
998 message_type = tvb_get_ntohl(tvb, 4);
999
1000 col_set_str(pinfo->cinfo, COL_PROTOCOL, "GED125");
1001 col_add_fstr(pinfo->cinfo, COL_INFO, "%s %u bytes",
1002 val_to_str(message_type, base_message_values, "Unknown %d"), size);
1003
1004 ti = proto_tree_add_item(tree, proto_ged125, tvb, 0, -1, ENC_NA);
1005 ged125_tree = proto_item_add_subtree( ti, ett_ged125);
1006
1007 /* Message header */
1008 ti = proto_tree_add_text(ged125_tree, tvb, 0, 8, "GED125 Header");
1009 ged125_header_tree = proto_item_add_subtree(ti, ett_ged125_header);
1010
1011 proto_tree_add_item(ged125_header_tree, hf_ged125_length, tvb, 0, 4, ENC_BIG_ENDIAN);
1012 proto_tree_add_item(ged125_header_tree, hf_ged125_value, tvb, 4, 4, ENC_BIG_ENDIAN);
1013
1014 message_item = proto_tree_add_text(ged125_tree, tvb, offset, -1, "GED125 Message");
1015 ged125_message_tree = proto_item_add_subtree(message_item, ett_ged125_message);
1016
1017 switch (message_type)
1018 {
1019 case GED125_FAILURE_CONF_VALUE:
1020 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1021 offset += 4;
1022 proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN);
1023 offset += 4;
1024 break;
1025
1026 case GED125_FAILURE_EVENT_VALUE:
1027 proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN);
1028 offset += 4;
1029 break;
1030
1031 case GED125_OPEN_REQ_VALUE:
1032 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1033 offset += 4;
1034 proto_tree_add_item(ged125_message_tree, hf_ged125_VersionNumber, tvb, offset, 4, ENC_BIG_ENDIAN);
1035 offset += 4;
1036 proto_tree_add_item(ged125_message_tree, hf_ged125_IdleTimeout, tvb, offset, 4, ENC_BIG_ENDIAN);
1037 offset += 4;
1038 break;
1039
1040 case GED125_OPEN_CONF_VALUE:
1041 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1042 offset += 4;
1043 proto_tree_add_item(ged125_message_tree, hf_ged125_UseEventFeed, tvb, offset, 4, ENC_BIG_ENDIAN);
1044 offset += 4;
1045 proto_tree_add_item(ged125_message_tree, hf_ged125_UsePolledFeed, tvb, offset, 4, ENC_BIG_ENDIAN);
1046 offset += 4;
1047 proto_tree_add_item(ged125_message_tree, hf_ged125_UseCallRouting, tvb, offset, 4, ENC_BIG_ENDIAN);
1048 offset += 4;
1049 proto_tree_add_item(ged125_message_tree, hf_ged125_UseTimeSynch, tvb, offset, 4, ENC_BIG_ENDIAN);
1050 offset += 4;
1051 proto_tree_add_item(ged125_message_tree, hf_ged125_UseServiceControl, tvb, offset, 4, ENC_BIG_ENDIAN);
1052 offset += 4;
1053 break;
1054
1055 case GED125_HEARTBEAT_REQ_VALUE:
1056 case GED125_HEARTBEAT_CONF_VALUE:
1057 case GED125_CLOSE_CONF_VALUE:
1058 case GED125_INIT_DATA_REQ_VALUE:
1059 case GED125_INIT_DATA_CONF_VALUE:
1060 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1061 offset += 4;
1062 break;
1063
1064 case GED125_CLOSE_REQ_VALUE:
1065 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1066 offset += 4;
1067 proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN);
1068 offset += 4;
1069 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1070 break;
1071
1072 case GED125_INIT_TRKGRP_DATA_EVENT_VALUE:
1073 value = tvb_get_ntohl(tvb, offset);
1074 ti = proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1075 offset += 4;
1076 if (value > 65535)
1077 expert_add_info(pinfo, ti, &ei_ged125_trunk_group_id);
1078
1079 value = tvb_get_ntohl(tvb, offset);
1080 ti = proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkCount, tvb, offset, 4, ENC_BIG_ENDIAN);
1081 offset += 4;
1082 if (value > 1023)
1083 expert_add_info(pinfo, ti, &ei_ged125_TrunkCount_invalid);
1084
1085 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsInToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1086 offset += 4;
1087 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsOutToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1088 offset += 4;
1089 proto_tree_add_item(ged125_message_tree, hf_ged125_InServiceTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1090 offset += 4;
1091 proto_tree_add_item(ged125_message_tree, hf_ged125_InUseInboundTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1092 offset += 4;
1093 proto_tree_add_item(ged125_message_tree, hf_ged125_InUseOutboundTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1094 offset += 4;
1095 proto_tree_add_item(ged125_message_tree, hf_ged125_AllTrunksInUseTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1096 offset += 4;
1097
1098 trunk_funk(tvb, ged125_message_tree, &offset, size);
1099 break;
1100
1101 case GED125_INIT_SERVICE_DATA_EVENT_VALUE:
1102 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1103 offset += 4;
1104 proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN);
1105 offset += 4;
1106 proto_tree_add_item(ged125_message_tree, hf_ged125_AvailableNow, tvb, offset, 4, ENC_BIG_ENDIAN);
1107 offset += 4;
1108 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsInNow, tvb, offset, 4, ENC_BIG_ENDIAN);
1109 offset += 4;
1110 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsOutNow, tvb, offset, 4, ENC_BIG_ENDIAN);
1111 offset += 4;
1112 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsInToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1113 offset += 4;
1114 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsOutToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1115 offset += 4;
1116 proto_tree_add_item(ged125_message_tree, hf_ged125_CallsHandledToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1117 offset += 4;
1118 proto_tree_add_item(ged125_message_tree, hf_ged125_HandleTimeToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1119 offset += 4;
1120 proto_tree_add_item(ged125_message_tree, hf_ged125_DivertedInToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1121 offset += 4;
1122 proto_tree_add_item(ged125_message_tree, hf_ged125_DivertedOutToday, tvb, offset, 4, ENC_BIG_ENDIAN);
1123 offset += 4;
1124 break;
1125
1126 case GED125_INIT_VRU_DATA_EVENT_VALUE:
1127 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1128 offset += 4;
1129 proto_tree_add_item(ged125_message_tree, hf_ged125_TimeZoneDelta, tvb, offset, 4, ENC_BIG_ENDIAN);
1130 offset += 4;
1131
1132 OperationalStatus_funk(tvb, pinfo, ged125_message_tree, &offset);
1133 StatusVariable_funk(tvb, ged125_message_tree, &offset, size);
1134 break;
1135
1136 case GED125_INIT_DATA_END_EVENT_VALUE:
1137 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1138 offset += 4;
1139 proto_tree_add_item(ged125_message_tree, hf_ged125_InitDataTime, tvb, offset, 4, ENC_BIG_ENDIAN);
1140 offset += 4;
1141 proto_tree_add_item(ged125_message_tree, hf_ged125_StartOfDay, tvb, offset, 4, ENC_BIG_ENDIAN);
1142 offset += 4;
1143 break;
1144
1145 case GED125_DELIVERED_EVENT_VALUE:
1146 case GED125_ORIGINATED_EVENT_VALUE:
1147 proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1148 offset += 4;
1149 proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkGroupID, tvb, offset, 4, ENC_BIG_ENDIAN);
1150 offset += 4;
1151 proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkNumber, tvb, offset, 4, ENC_BIG_ENDIAN);
1152 offset += 4;
1153 proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN);
1154 offset += 4;
1155 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1156 break;
1157
1158 case GED125_CALL_CLEARED_EVENT_VALUE:
1159 proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1160 offset += 4;
1161 proto_tree_add_item(ged125_message_tree, hf_ged125_floating_CauseCode, tvb, offset, 4, ENC_BIG_ENDIAN);
1162 offset += 4;
1163 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1164 break;
1165
1166 case GED125_CONFERENCED_EVENT_VALUE:
1167 proto_tree_add_item(ged125_message_tree, hf_ged125_ConferenceCallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1168 offset += 4;
1169 proto_tree_add_item(ged125_message_tree, hf_ged125_PrimaryCallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1170 offset += 4;
1171 proto_tree_add_item(ged125_message_tree, hf_ged125_SecondaryCallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1172 offset += 4;
1173 proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN);
1174 offset += 4;
1175 break;
1176
1177 case GED125_DIVERTED_EVENT_VALUE:
1178 proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1179 offset += 4;
1180 proto_tree_add_item(ged125_message_tree, hf_ged125_NewServiceID, tvb, offset, 4, ENC_BIG_ENDIAN);
1181 offset += 4;
1182 break;
1183
1184 case GED125_NEW_TRANSACTION_EVENT_VALUE:
1185 proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1186 offset += 4;
1187 proto_tree_add_item(ged125_message_tree, hf_ged125_NewCallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1188 offset += 4;
1189 proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN);
1190 offset += 4;
1191 break;
1192
1193 case GED125_SET_CALL_VARIABLES_EVENT_VALUE:
1194 proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1195 offset += 4;
1196 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1197 break;
1198
1199 case GED125_VRU_STATUS_EVENT_VALUE:
1200 proto_tree_add_item(ged125_message_tree, hf_ged125_CurrentTime_num, tvb, offset, 4, ENC_BIG_ENDIAN);
1201 offset += 4;
1202 proto_tree_add_item(ged125_message_tree, hf_ged125_TimeZoneDelta, tvb, offset, 4, ENC_BIG_ENDIAN);
1203 offset += 4;
1204 OperationalStatus_funk(tvb, pinfo, ged125_message_tree, &offset);
1205 StatusVariable_funk(tvb, ged125_message_tree, &offset, size);
1206 break;
1207
1208 case GED125_TRKGRP_STATUS_EVENT_VALUE:
1209 proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkGroupID, tvb, offset, 4, ENC_BIG_ENDIAN);
1210 offset += 4;
1211
1212 value = tvb_get_ntohl(tvb, offset);
1213 ti = proto_tree_add_item(ged125_message_tree, hf_ged125_TrunkCount, tvb, offset, 4, ENC_BIG_ENDIAN);
1214 offset += 4;
1215 if (value > 1023)
1216 expert_add_info(pinfo, ti, &ei_ged125_TrunkCount_invalid);
1217
1218 proto_tree_add_item(ged125_message_tree, hf_ged125_InService, tvb, offset, 4, ENC_BIG_ENDIAN);
1219 offset += 4;
1220 trunk_funk_without_status(tvb, ged125_message_tree, &offset, size);
1221 break;
1222
1223 case GED125_SERVICE_STATUS_EVENT_VALUE:
1224 proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceID, tvb, offset, 4, ENC_BIG_ENDIAN);
1225 offset += 4;
1226 proto_tree_add_item(ged125_message_tree, hf_ged125_ServiceAvailable, tvb, offset, 4, ENC_BIG_ENDIAN);
1227 offset += 4;
1228 break;
1229
1230 case GED125_ROUTE_REQUEST_EVENT_VALUE:
1231 proto_tree_add_item(ged125_message_tree, hf_ged125_CrossRefID, tvb, offset, 4, ENC_BIG_ENDIAN);
1232 offset += 4;
1233 proto_tree_add_item(ged125_message_tree, hf_ged125_CallID, tvb, offset, 4, ENC_BIG_ENDIAN);
1234 offset += 4;
1235 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1236 return tvb_length(tvb);
1237
1238 case GED125_ROUTE_SELECT_VALUE:
1239 proto_tree_add_item(ged125_message_tree, hf_ged125_CrossRefID, tvb, offset, 4, ENC_BIG_ENDIAN);
1240 offset += 4;
1241 proto_tree_add_item(ged125_message_tree, hf_ged125_LabelType, tvb, offset, 4, ENC_BIG_ENDIAN);
1242 offset += 4;
1243 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1244 break;
1245
1246 case GED125_ROUTE_END_EVENT_VALUE:
1247 case GED125_ROUTE_END_VALUE:
1248 proto_tree_add_item(ged125_message_tree, hf_ged125_CrossRefID, tvb, offset, 4, ENC_BIG_ENDIAN);
1249 offset += 4;
1250 proto_tree_add_item(ged125_message_tree, hf_ged125_Status, tvb, offset, 4, ENC_BIG_ENDIAN);
1251 offset += 4;
1252 break;
1253
1254 case GED125_TIME_SYNCH_REQ_VALUE:
1255 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1256 offset += 4;
1257 proto_tree_add_item(ged125_message_tree, hf_ged125_VRUTimeLag, tvb, offset, 4, ENC_BIG_ENDIAN);
1258 offset += 4;
1259 break;
1260
1261 case GED125_TIME_SYNCH_CONF_VALUE:
1262 proto_tree_add_item(ged125_message_tree, hf_ged125_InvokeID, tvb, offset, 4, ENC_BIG_ENDIAN);
1263 offset += 4;
1264 break;
1265
1266 case GED125_SERVICE_CONTROL_VALUE:
1267 service_control_dissect(tvb, ged125_message_tree, ged125_tree, pinfo, &offset, size);
1268 break;
1269
1270 case GED125_SIMULATOR_RESET_EVENT_VALUE:
1271 proto_tree_add_item(ged125_message_tree, hf_ged125_simulator_reset_event, tvb, offset, 4, ENC_BIG_ENDIAN);
1272 break;
1273
1274 case GED125_REGISTER_VARIABLES_VALUE:
1275 proto_tree_add_item(ged125_message_tree, hf_ged125_CallVarsMask, tvb, offset, 2, ENC_BIG_ENDIAN);
1276 offset += 2;
1277 floating_fields(tvb, pinfo, ged125_tree, offset, size);
1278 break;
1279 }
1280
1281 proto_item_set_len(message_item, offset-8);
1282 return tvb_length(tvb);
1283 }
1284
1285 static int
1286 dissect_ged125(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
1287 {
1288 gint size;
1289 guint32 message_type;
1290
1291 size = tvb_length(tvb);
1292
1293 if (size < 12)
1294 return 0;
1295
1296 message_type = tvb_get_ntohl(tvb, 4);
1297
1298 /*checks to make sure it's of a ged125 base message type*/
1299 if (try_val_to_str(message_type, base_message_values) == NULL)
1300 return 0; /* not a known command */
1301
1302 tcp_dissect_pdus(tvb, pinfo, tree, ged125_desegment_body, 4,
1303 get_ged125_pdu_len, dissect_ged125_base_messages, data);
1304
1305 return size;
1306 }
1307
1308 void
1309 proto_register_ged125 (void)
1310 {
1311 module_t* ged125_module;
1312
1313 static hf_register_info hf[] = {
1314 { &hf_ged125_length,
1315 { "Package Length", "ged125.len",
1316 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1317
1318 { &hf_ged125_value,
1319 { "Message value", "ged125.value",
1320 FT_UINT32, BASE_DEC, VALS(base_message_values), 0x0, NULL, HFILL }},
1321
1322 { &hf_ged125_service_control_value,
1323 { "Sub-Service Control Message value", "ged125.service_control",
1324 FT_UINT32, BASE_DEC, VALS(vals_service_control_message_subvalues),
1325 0x0, NULL, HFILL }},
1326
1327 { &hf_ged125_DialogueID_num,
1328 { "Dialogue Id", "ged125.dialogue_id",
1329 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1330
1331 { &hf_ged125_SendSeqNo_num,
1332 { "SendSeqNo", "ged125.send_seq_no",
1333 FT_UINT32, BASE_DEC, NULL, 0x0,
1334 "Send sequence for the sent message", HFILL }},
1335
1336 { &hf_ged125_CurrentTime_num,
1337 { "Current Time", "ged125.current_time",
1338 FT_UINT32, BASE_DEC, NULL, 0x0,
1339 "The current UTC time (VRU clock)", HFILL }},
1340
1341 { &hf_ged125_TimeZoneDelta,
1342 { "Time Zone Delta", "ged125.time_zone_delta",
1343 FT_INT32, BASE_DEC,NULL, 0x0,
1344 "The current local time zone delta, expressed in seconds."
1345 "This value is added to a UTC time to form a time in the local time zone",
1346 HFILL }},
1347
1348 { &hf_ged125_OperationalStatus,
1349 { "Operational Status", "ged125.operational_status",
1350 FT_UINT32, BASE_DEC, NULL, 0x0,
1351 "Operational Status of the VRU", HFILL }},
1352
1353 { &hf_ged125_StatusVariable,
1354 { "Status Variable", "ged125.status_variable",
1355 FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1356
1357 { &hf_ged125_InvokeID,
1358 { "Invoke ID", "ged125.invoke_id",
1359 FT_UINT32, BASE_DEC, NULL, 0x0,
1360 "Same as the corresponding req. mess", HFILL }},
1361
1362 { &hf_ged125_Status,
1363 { "Status", "ged125.status",
1364 FT_UINT32, BASE_DEC, VALS(error_codes), 0x0,
1365 "Status: Indicates cause of failure", HFILL }},
1366
1367 { &hf_ged125_VersionNumber,
1368 { "Version Number", "ged125.version_number",
1369 FT_UINT32, BASE_DEC, NULL, 0x0,
1370 "Interface number requested by the Peripheral Gateway,"
1371 "defines the version of all messages in the message set", HFILL }},
1372
1373 { &hf_ged125_IdleTimeout,
1374 { "Idle Timeout (ms)", "ged125.idle_timeout",
1375 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1376
1377 { &hf_ged125_floating_CauseCode,
1378 { "Cause code", "ged125.cause_code",
1379 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1380
1381 { &hf_ged125_UseEventFeed,
1382 { "Use Event Feed", "ged125.use_event_feed",
1383 FT_BOOLEAN, 32, NULL, 0x01,
1384 "Indicates if the VRU supports the Event Data Feed", HFILL }},
1385
1386 /* only valid for ICM version 4 or lower*/
1387 { &hf_ged125_UsePolledFeed,
1388 { "Use Polled Feed", "ged125.use_polled_feed",
1389 FT_BOOLEAN, 32, NULL, 0x01,
1390 "Indicates if the VRU supports the Polled Data Feed.", HFILL }},
1391
1392 { &hf_ged125_UseCallRouting,
1393 { "Use Call Routing", "ged125.use_call_routing",
1394 FT_BOOLEAN, 32, NULL, 0x01,
1395 "Indicates if the VRU supports the Call Routing Interface", HFILL }},
1396
1397 { &hf_ged125_UseTimeSynch,
1398 { "Use Time Synch", "ged125.use_time_synch",
1399 FT_BOOLEAN, 32, NULL, 0x01,
1400 "Indicates if the VRU supports the Time Synchronization Interface", HFILL }},
1401
1402 /*Requires Protocol Version 2 or later*/
1403 { &hf_ged125_UseServiceControl,
1404 { "Use Service Control", "ged125.use_service_control",
1405 FT_BOOLEAN, 32, NULL, 0x01,
1406 "Indicates if the VRU supports the Service Control Interface", HFILL }},
1407
1408 { &hf_ged125_TrunkGroupID,
1409 { "Trunk Group ID", "ged125.trunk_group_id",
1410 FT_UINT32, BASE_DEC, NULL, 0x0,
1411 "An ID assigned by the VRU to this trunk group, in the range 0 to 65535", HFILL }},
1412
1413 { &hf_ged125_TrunkCount,
1414 { "Trunk Count", "ged125.trunk_count",
1415 FT_UINT32, BASE_DEC, NULL, 0x0,
1416 "The number of trunks configured in this message. TrunkCount may not exceed 1024", HFILL }},
1417
1418 { &hf_ged125_CallsInToday,
1419 { "Calls In Today", "ged125.calls_in_today",
1420 FT_UINT32, BASE_DEC, NULL, 0x0,
1421 "The cumulative number of inbound calls that have arrived on the trunk group this day", HFILL }},
1422
1423 { &hf_ged125_CallsOutToday,
1424 { "Calls Out Today", "ged125.call_out_today",
1425 FT_UINT32, BASE_DEC, NULL, 0x0,
1426 "The cumulative number of outbound calls that have been placed on the trunk group this day", HFILL }},
1427
1428 { &hf_ged125_InServiceTimeToday,
1429 { "In Service Time Today", "ged125.in_service_time_today",
1430 FT_UINT32, BASE_DEC, NULL, 0x0,
1431 "The cumulative amount of time (sec) that trunks in the trunk group "
1432 "have been in service this day", HFILL }},
1433
1434 { &hf_ged125_InUseInboundTimeToday,
1435 { "In Use Inbound Time Today", "ged125.in_use_inbound_time_today",
1436 FT_UINT32, BASE_DEC,NULL, 0x0,
1437 "The cumulative amount of time (sec) that trunks in the trunk group "
1438 "have been in use on incoming calls this day", HFILL }},
1439
1440 { &hf_ged125_InUseOutboundTimeToday,
1441 { "In Use Outbound Time Today", "ged125.in_use_outbound_time_today",
1442 FT_UINT32, BASE_DEC, NULL, 0x0,
1443 "The cumulative amount of time (sec) that trunks in the trunk group "
1444 "have been in use on outgoing calls this day", HFILL }},
1445
1446 { &hf_ged125_AllTrunksInUseTimeToday,
1447 { "All Trunks In Use Time Today", "ged125.all_trunks_in_use_time_today",
1448 FT_UINT32, BASE_DEC, NULL, 0x0,
1449 "The cumulative amount of time (sec) that all trunks in the trunk group "
1450 "were simultaneously busy this day", HFILL }},
1451
1452 { &hf_ged125_TrunkNumber,
1453 { "Trunk Number", "ged125.trunk_number",
1454 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1455
1456 { &hf_ged125_TrunkStatus,
1457 { "Trunk Status", "ged125.trunk_status",
1458 FT_UINT16, BASE_DEC, VALS(status_code_trunk_status), 0x0, NULL, HFILL }},
1459
1460 { &hf_ged125_ServiceID,
1461 { "Service ID", "ged125.service_id",
1462 FT_UINT32, BASE_DEC, NULL, 0x0,
1463 "An ID assigned by the VRU to this service", HFILL }},
1464
1465 { &hf_ged125_AvailableNow,
1466 { "Available Now", "ged125.available_now",
1467 FT_BOOLEAN, 32, NULL, 0x01,
1468 "Current availability of the service", HFILL }},
1469
1470 { &hf_ged125_CallsInNow,
1471 { "Call In Now", "ged125.call_in_now",
1472 FT_UINT32, BASE_DEC, NULL, 0x0,
1473 "The number of inbound calls currently in progress on the service.", HFILL }},
1474
1475 { &hf_ged125_CallsOutNow,
1476 { "Call Out Now", "ged125.call_out_now",
1477 FT_UINT32, BASE_DEC, NULL, 0x0,
1478 "The number of outbound calls currently in progress on the service", HFILL }},
1479
1480 { &hf_ged125_CallsHandledToday,
1481 { "Calls Handled Today", "ged125.call_handled_today",
1482 FT_UINT32, BASE_DEC, NULL, 0x0,
1483 "The cumulative number of calls handled on the service this day", HFILL }},
1484
1485 { &hf_ged125_HandleTimeToday,
1486 { "Handle Time Today", "ged125.handle_time_today",
1487 FT_UINT32, BASE_DEC, NULL, 0x0,
1488 "The cumulative amount of time (secs) spent handling calls on the service this day", HFILL }},
1489
1490 { &hf_ged125_DivertedInToday,
1491 { "Diverted In Today", "ged125.diverted_in_today",
1492 FT_UINT32, BASE_DEC, NULL, 0x0,
1493 "The cumulative number of calls diverted from another service to this service this day", HFILL }},
1494
1495 { &hf_ged125_DivertedOutToday,
1496 { "Diverted Out Today", "ged125.diverted_out_today",
1497 FT_UINT32, BASE_DEC, NULL, 0x0,
1498 "The cumulative number of calls diverted from this service to another service this day", HFILL }},
1499
1500 { &hf_ged125_InitDataTime,
1501 { "Init Data Time", "ged125.init_data_time",
1502 FT_UINT32, BASE_DEC, NULL, 0x0,
1503 "The UTC time at which the initial snapshot was taken", HFILL }},
1504
1505 { &hf_ged125_StartOfDay,
1506 { "Start Of Day", "ged125.start_of_day",
1507 FT_UINT32, BASE_DEC, NULL, 0x0,
1508 "Corresponds to midnight local time at the VRU (UTC). However, this may refer "
1509 "to a different time if the VRU has restarted", HFILL }},
1510
1511 { &hf_ged125_CallID,
1512 { "Call ID", "ged125.call_id",
1513 FT_UINT32, BASE_DEC, NULL, 0x0,
1514 "An ID assigned to the call by the VRU", HFILL }},
1515
1516 { &hf_ged125_floating,
1517 { "Field", "ged125.floating_field",
1518 FT_UINT32, BASE_DEC, VALS(vals_floating_point_types), 0x0,
1519 "Shows the type of floating field", HFILL }},
1520
1521 { &hf_ged125_ServiceFeatures,
1522 { "Service Features", "ged125.service_features",
1523 FT_UINT32, BASE_HEX, NULL, 0x0,
1524 "A bit mask that is a logical OR of the Service Control features supported by the VRU", HFILL }},
1525
1526 { &hf_ged125_floating_payload_strg,
1527 { "Floating Payload", "ged125.floating_payload",
1528 FT_STRING, FT_NONE, NULL, 0x0, NULL, HFILL }},
1529
1530 { &hf_ged125_floating_payload_uint,
1531 { "Floating Payload", "ged125.floating_payload",
1532 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1533
1534 { &hf_ged125_floating_payload_bool,
1535 { "Floating Payload", "ged125.floating_payload",
1536 FT_BOOLEAN, 32, NULL, 0x01, NULL, HFILL }},
1537
1538 { &hf_ged125_floating_payload_ECC_tag,
1539 { "ECC VAR Tag", "ged125.ecc_var_tag",
1540 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1541
1542 { &hf_ged125_ResultCode,
1543 { "Errors running script", "ged125.result_code",
1544 FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x01, NULL, HFILL }},
1545
1546 { &hf_ged125_LabelType,
1547 { "Label Type", "ged125.label_type",
1548 FT_UINT32, BASE_DEC, VALS(status_code_Label_values),0x0,
1549 "The type of the label returned in the following field", HFILL }},
1550
1551 { &hf_ged125_EventID,
1552 { "Event ID", "ged125.event_id",
1553 FT_UINT32, BASE_DEC, VALS(status_code_event_reportcodes), 0x0,
1554 "A code that identifies the event detected by the VRU", HFILL }},
1555
1556 { &hf_ged125_ErrorCode,
1557 { "Error Code", "ged125.error_code",
1558 FT_UINT32, BASE_DEC, VALS(error_codes), 0x0,
1559 "A status code indicating the cause of the failure", HFILL }},
1560
1561 { &hf_ged125_Cause_just_for_release_message,
1562 { "Cause of Release", "ged125.call_release",
1563 FT_UINT32, BASE_DEC, VALS(Cause_just_for_release_message_vals), 0x0,
1564 "The reason the call was released", HFILL }},
1565
1566 { &hf_ged125_InService,
1567 { "In Service", "ged125.in_service",
1568 FT_BOOLEAN, 32, NULL, 0x01,
1569 "A flag indicating that the affected trunks have been placed into "
1570 "service (True) or removed from service (False)", HFILL }},
1571
1572 { &hf_ged125_ServiceAvailable,
1573 { "Service Available", "ged125.service_available",
1574 FT_BOOLEAN, 32, NULL, 0x01,
1575 NULL, HFILL }},
1576
1577 { &hf_ged125_RequestID,
1578 { "Request ID", "ged125.request_id",
1579 FT_UINT32, BASE_DEC, NULL, 0x0,
1580 "The InvokeID of the previously issued request to be cancelled", HFILL }},
1581
1582 { &hf_ged125_ToBeContinued,
1583 { "To Be Continued", "ged125.to_be_continued",
1584 FT_BOOLEAN, 32, NULL, 0x01,
1585 "A flag which indicates whether additional MICROAPP_PLAY_CONTINUE messages will follow", HFILL }},
1586
1587 { &hf_ged125_Barge_In_Allowed,
1588 { "Barge In Allowed", "ged125.barge_in_allowed",
1589 FT_BOOLEAN, 32, NULL, 0x01,
1590 "Indicates whether caller is allowed to interrupt playing", HFILL }},
1591
1592 { &hf_ged125_floating_cause_code,/* table 34*/
1593 { "Call Cleared Code", "ged125.call_cleared_code",
1594 FT_UINT32, BASE_DEC,VALS(vals_status_code_call_cleared), 0x0,
1595 "Termination Call Details", HFILL }},
1596
1597 { &hf_ged125_DTMF_Termination_Key,
1598 { "DTMF Termination Key", "ged125.dtmf_termination_key",
1599 FT_UINT32,BASE_DEC, NULL,0x0,
1600 "Terminates a variable length string of DTMF digits "
1601 "(typically # key). The value is a bit map", HFILL }},
1602
1603 { &hf_ged125_No_Entry_Timeout,
1604 { "No Entry Timeout", "ged125.no_entry_timeout",
1605 FT_UINT32, BASE_DEC, NULL, 0x0,
1606 "Determines how many seconds a caller is allowed to start entering data", HFILL }},
1607
1608 { &hf_ged125_Interdigit_Timeout,
1609 { "Interdigit Timeout", "ged125.interdigit_timeout",
1610 FT_UINT32, BASE_DEC, NULL, 0x0,
1611 "Determines how many seconds the caller is allowed between digits, "
1612 "before the system assumes the caller is finished", HFILL }},
1613
1614 { &hf_ged125_Number_of_No_Entry_Tries,
1615 { "Number of No Entry Tries", "ged125.number_of_no_entry_tries",
1616 FT_UINT32, BASE_DEC, NULL, 0x0,
1617 "Number of times VRU should repeat the 'Get data' cycle when the caller "
1618 "doesn't enter any data", HFILL }},
1619
1620 { &hf_ged125_Number_of_Invalid_Entry_Tries,
1621 { "Number of Invalid Entry Tries", "ged125.number_of_invalid_entry_tries",
1622 FT_UINT32, BASE_DEC, NULL, 0x0,
1623 "Number of times VRU should repeat the 'Get data' cycle when the "
1624 "caller enters invalid data", HFILL }},
1625
1626 { &hf_ged125_Min_Length,
1627 { "Min Length of Digits", "ged125.min_length",
1628 FT_UINT32, BASE_DEC, NULL, 0x0,
1629 "Minimum number of digits expected from the caller", HFILL }},
1630
1631 { &hf_ged125_Max_Length,
1632 { "Max Length of Digits", "ged125.max_length",
1633 FT_UINT32, BASE_DEC, NULL, 0x0,
1634 "Maximum number of digits expected from the caller", HFILL }},
1635
1636 { &hf_ged125_ASR_Allowed,
1637 { "ASR Allowed", "ged125.asr_allowed",
1638 FT_BOOLEAN, 32, NULL, 0x01,
1639 "Indicates whether Automatic Speech Recognition should be enabled for this request", HFILL }},
1640
1641 { &hf_ged125_DTMF_Menu_Keys,
1642 { "DTMF Menu Keys", "ged125.dtmf_menu_keys",
1643 FT_UINT32, BASE_DEC, NULL, 0x0,
1644 "Indicates which keypad keys represent valid menu choices", HFILL }},
1645
1646 { &hf_ged125_Microapp_Error_Code,
1647 { "Microapp Error Code", "ged125.microapp_error_code",
1648 FT_UINT32, BASE_DEC,
1649 VALS(status_code_microcapp_error_codes), 0x0, NULL, HFILL }},
1650
1651 { &hf_ged125_ConferenceCallID,
1652 { "Conference Call ID", "ged125.conference_call_id",
1653 FT_UINT32, BASE_DEC, NULL, 0x0,
1654 "An ID assigned to the resultant conference call by the VRU", HFILL }},
1655
1656 { &hf_ged125_PrimaryCallID,
1657 { "Primary Call ID", "ged125.primary_call_id",
1658 FT_UINT32, BASE_DEC, NULL, 0x0,
1659 "The ID of the primary (inbound) call being conferenced", HFILL }},
1660
1661 { &hf_ged125_SecondaryCallID,
1662 { "Secondary Call ID", "ged125.secondary_call_id",
1663 FT_UINT32, BASE_DEC, NULL, 0x0,
1664 "The ID of the secondary (outbound) call being conferenced", HFILL }},
1665
1666 { &hf_ged125_NewServiceID,
1667 { "New Service ID", "ged125.new_service_id",
1668 FT_UINT32, BASE_DEC, NULL, 0x0,
1669 "The ID of the new service to which the call was diverted", HFILL }},
1670
1671 { &hf_ged125_NewCallID,
1672 { "New Call ID", "ged125.new_call_id",
1673 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1674
1675 { &hf_ged125_simulator_reset_event,
1676 { "Simulator Reset Event", "ged125.simulator_reset_event",
1677 FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL }},
1678
1679 { &hf_ged125_CrossRefID,
1680 { "Cross Reference ID", "ged125.cross_ref_id",
1681 FT_UINT32, BASE_DEC, NULL, 0x0,
1682 "A cross-reference identifier assigned by the VRU to this call routing dialogue", HFILL }},
1683
1684 { &hf_ged125_VRUTimeLag,
1685 { "VRU Time Lag", "ged125.vru_time_lag",
1686 FT_INT32, BASE_DEC, NULL, 0x0,
1687 "Number of seconds that the VRU clock lags the ICM clock", HFILL }},
1688
1689 { &hf_ged125_CallVarsMask,
1690 { "Call Vars Mask", "ged125.call_vars_mask",
1691 FT_UINT32, BASE_HEX, NULL, 0x0,
1692 "A bit map, with the least significant bit referring to Call Variable1", HFILL }},
1693
1694 { &hf_ged125_floating_payload_unspec,
1695 { "Unspec floating data-type", "ged125.floating_unspec",
1696 FT_BYTES, BASE_NONE, NULL, 0x0,
1697 "Unknown data type", HFILL }},
1698
1699 { &hf_ged125_floating_media_protocol,
1700 { "Media Protocol", "ged125.media_protocol",
1701 FT_UINT8, BASE_DEC, VALS(floating_media_protocol_vals), 0x0,
1702 "Type of media", HFILL }},
1703
1704 { &hf_ged125_floating_library_designator,
1705 { "Library Designator", "ged125.library_designator",
1706 FT_UINT8, BASE_DEC, VALS(floating_media_library_designator_vals), 0x0,
1707 "System or Application", HFILL }},
1708
1709 { &hf_ged125_Data_Playback_Type,
1710 { "Data Playback Type", "ged125.data_playback_type",
1711 FT_UINT32, BASE_DEC, VALS(Data_Playback_Type), 0x0, NULL, HFILL }},
1712
1713 { &hf_ged125_Data_Playback_Formats,
1714 { "Data Playback Format", "ged125.data_playback_format",
1715 FT_UINT32, BASE_DEC, VALS(Data_Playback_Formats),0x0,
1716 "Only relevant if Data Playback Type is one of the time formats. "
1717 "It should contain PLAYBACK_FORMAT_OTHER in all other cases", HFILL }},
1718
1719 { &hf_ged125_floating_uchar_array_index,
1720 { "Uchar-Array Index", "ged125.uchar_array_index",
1721 FT_UINT32, BASE_DEC, NULL, 0x0,
1722 "Array index of an ECC field", HFILL }}
1723 };
1724
1725 static gint *ett[] = {
1726 &ett_ged125,
1727 &ett_ged125_header,
1728 &ett_ged125_message,
1729 &ett_ged125_floating,
1730 &ett_ged125_float_field,
1731 &ett_ged125_service_control_header,
1732 &ett_ged125_service_control_data
1733 };
1734
1735 static ei_register_info ei[] = {
1736 { &ei_ged125_OperationalStatus_normal, { "ged125.operational_status.normal", PI_PROTOCOL, PI_NOTE, "Normal Operation", EXPFILL }},
1737 { &ei_ged125_OperationalStatus_loss_redundant_component, { "ged125.operational_status.loss_redundant_component", PI_PROTOCOL, PI_NOTE,
1738 "Loss of redundant component or other transparent failure; still fully functional for call processing", EXPFILL }},
1739 { &ei_ged125_OperationalStatus_degraded_call_processing, { "ged125.operational_status.degraded_call_processing", PI_PROTOCOL, PI_NOTE, "Degraded call processing", EXPFILL }},
1740 { &ei_ged125_OperationalStatus_conditions_prevent_call, { "ged125.operational_status.conditions_prevent_call", PI_PROTOCOL, PI_NOTE, "Conditions prevent call processing", EXPFILL }},
1741 { &ei_ged125_OperationalStatus_invalid_message, { "ged125.operational_status.invalid_message", PI_PROTOCOL, PI_WARN, "Error: Invalid message", EXPFILL }},
1742 { &ei_ged125_length_bad, { "ged125.length.bad", PI_MALFORMED, PI_ERROR, "Incorrect size given in the packet (corrupted)", EXPFILL }},
1743 { &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 }},
1744 { &ei_ged125_service_control_value_unknown, { "ged125.service_control_value.unknown", PI_PROTOCOL, PI_WARN, "Unknown Service-Control Message Sub-type, aborting dissection", EXPFILL }},
1745 { &ei_ged125_trunk_group_id, { "ged125.trunk_group_id.bad_range", PI_PROTOCOL, PI_WARN, "TrunkGroupID must be between 0-65535", EXPFILL }},
1746 { &ei_ged125_TrunkCount_invalid, { "ged125.trunk_count.invalid", PI_PROTOCOL, PI_WARN, "Invalid number of trunks (max is 1023)", EXPFILL }},
1747 };
1748
1749 expert_module_t* expert_ged125;
1750
1751 proto_ged125 = proto_register_protocol ("Cisco GED-125 Protocol", "GED125", "ged125");
1752 proto_register_field_array (proto_ged125, hf, array_length (hf));
1753 proto_register_subtree_array (ett, array_length (ett));
1754 expert_ged125 = expert_register_protocol(proto_ged125);
1755 expert_register_field_array(expert_ged125, ei, array_length(ei));
1756
1757 ged125_handle = new_register_dissector("ged125", dissect_ged125, proto_ged125);
1758
1759 ged125_module = prefs_register_protocol(proto_ged125, NULL);
1760
1761 prefs_register_uint_preference(ged125_module, "tcp_port","GED125 TCP Port",
1762 "Set up the TCP port for GED125 (default is 5000)",
1763 10, &global_tcp_port_ged125);
1764
1765 prefs_register_bool_preference(ged125_module, "desegment_body",
1766 "Reassemble GED125 bodies spanning multiple TCP segments",
1767 "Whether the GED125 dissector should desegment all messages spanning multiple TCP segments",
1768 &ged125_desegment_body);
1769 }
1770
1771 void
1772 proto_reg_handoff_ged125(void)
1773 {
1774 static guint old_ged125_tcp_port = 0;
1775
1776 /* Register TCP port for dissection */
1777 if (old_ged125_tcp_port != 0 && old_ged125_tcp_port != global_tcp_port_ged125)
1778 dissector_delete_uint("tcp.port", old_ged125_tcp_port, ged125_handle);
1779
1780
1781 if (global_tcp_port_ged125 != 0 && old_ged125_tcp_port != global_tcp_port_ged125)
1782 dissector_add_uint("tcp.port", global_tcp_port_ged125, ged125_handle);
1783
1784 old_ged125_tcp_port = global_tcp_port_ged125;
1785 }