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