?  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-isup.c
blob306f8e4c3707e219962d9228d8d82e5d6d68ca95
1 /* packet-isup.c
2 * Routines for ISUP dissection
3 * Copyright 2001, Martina Obermeier <martina.obermeier@icn.siemens.de>
4 *
5 * Modified 2003-09-10 by Anders Broman
6 * <anders.broman@ericsson.com>
7 * Inserted routines for BICC dissection according to Q.765.5 Q.1902 Q.1970 Q.1990,
8 * calling SDP dissector for RFC2327 decoding.
9 * Modified 2004-01-10 by Anders Broman to add ability to dissect
10 * Content type application/ISUP RFC 3204 used in SIP-T
11 *
12 * Copyright 2004-2005, Anders Broman <anders.broman@ericsson.com>
13 *
14 * Wireshark - Network traffic analyzer
15 * By Gerald Combs <gerald@wireshark.org>
16 * Copyright 1998 Gerald Combs
17 *
18 * Copied from README.developer
19 *
20 * SPDX-License-Identifier: GPL-2.0-or-later
21 * References:
22 * ISUP:
23 * http://www.itu.int/rec/recommendation.asp?type=products&lang=e&parent=T-REC-Q
24 * Q.763-199912, Q.763-200212Amd2
25 * ITU-T Q.763/Amd.1 (03/2001)
26 *
27 * National variants
28 * French ISUP Specification: SPIROU 1998 - 002-005 edition 1 ( Info found here http://www.icg-corp.com/docs/ISUP.pdf ).
29 * See also http://www.fftelecoms.org/sites/default/files/contenus_lies/fft_interco_ip_-_sip-i_interface_specification_v1_0.pdf
30 * Israeli ISUP Specification: excertp (for BCM message) found in https://gitlab.com/wireshark/wireshark/-/issues/4231 .
31 * Russian national ISUP-R 2000: RD 45.217-2001 book 4
32 * Japan ISUP http://www.ttc.or.jp/jp/document_list/sum/sum_JT-Q763v21.1.pdf
33 */
34
35 #include "config.h"
36
37 #include <epan/packet.h>
38 #include <epan/expert.h>
39 #include <epan/exceptions.h>
40 #include <epan/conversation.h>
41 #include <epan/stats_tree.h>
42 #include <epan/asn1.h>
43 #include <epan/prefs.h>
44 #include <epan/sctpppids.h>
45 #include <epan/osi-utils.h>
46 #include <epan/reassemble.h>
47 #include <epan/to_str.h>
48 #include <epan/media_params.h>
49 #include <epan/tfs.h>
50 #include <epan/unit_strings.h>
51
52 #include <wsutil/array.h>
53 #include "packet-q931.h"
54 #include "packet-isup.h"
55 #include "packet-e164.h"
56 #include "packet-charging_ase.h"
57 #include "packet-mtp3.h"
58 #include "packet-media-type.h"
59
60 void proto_register_isup(void);
61 void proto_reg_handoff_isup(void);
62 void proto_register_bicc(void);
63 void proto_reg_handoff_bicc(void);
64
65 static dissector_handle_t isup_handle;
66
67 #define ISUP_ITU_STANDARD_VARIANT 0
68 #define ISUP_FRENCH_VARIANT 1
69 #define ISUP_ISRAELI_VARIANT 2
70 #define ISUP_RUSSIAN_VARIANT 3
71 #define ISUP_JAPAN_VARIANT 4
72 #define ISUP_JAPAN_TTC_VARIANT 5
73
74 static int isup_standard = ITU_STANDARD;
75 /* Preference standard or national ISUP variants */
76 static int g_isup_variant = ISUP_ITU_STANDARD_VARIANT;
77
78 #define ASCII_NUMBER_DELTA 0x30
79 #define ASCII_LETTER_DELTA 0x37
80
81 /* Definition of protocol field values und lengths */
82
83 /* Definition of Message Types */
84 #define MESSAGE_TYPE_INITIAL_ADDR 1
85 #define MESSAGE_TYPE_SUBSEQ_ADDR 2
86 #define MESSAGE_TYPE_INFO_REQ 3
87 #define MESSAGE_TYPE_INFO 4
88 #define MESSAGE_TYPE_CONTINUITY 5
89 #define MESSAGE_TYPE_ADDR_CMPL 6
90 #define MESSAGE_TYPE_CONNECT 7
91 #define MESSAGE_TYPE_FORW_TRANS 8
92 #define MESSAGE_TYPE_ANSWER 9
93 #define MESSAGE_TYPE_RELEASE 12
94 #define MESSAGE_TYPE_SUSPEND 13
95 #define MESSAGE_TYPE_RESUME 14
96 #define MESSAGE_TYPE_REL_CMPL 16
97 #define MESSAGE_TYPE_CONT_CHECK_REQ 17
98 #define MESSAGE_TYPE_RESET_CIRCUIT 18
99 #define MESSAGE_TYPE_BLOCKING 19
100 #define MESSAGE_TYPE_UNBLOCKING 20
101 #define MESSAGE_TYPE_BLOCK_ACK 21
102 #define MESSAGE_TYPE_UNBLOCK_ACK 22
103 #define MESSAGE_TYPE_CIRC_GRP_RST 23
104 #define MESSAGE_TYPE_CIRC_GRP_BLCK 24
105 #define MESSAGE_TYPE_CIRC_GRP_UNBL 25
106 #define MESSAGE_TYPE_CIRC_GRP_BL_ACK 26
107 #define MESSAGE_TYPE_CIRC_GRP_UNBL_ACK 27
108 #define MESSAGE_TYPE_FACILITY_REQ 31
109 #define MESSAGE_TYPE_FACILITY_ACC 32
110 #define MESSAGE_TYPE_FACILITY_REJ 33
111 #define MESSAGE_TYPE_LOOP_BACK_ACK 36
112 #define MESSAGE_TYPE_PASS_ALONG 40
113 #define MESSAGE_TYPE_CIRC_GRP_RST_ACK 41
114 #define MESSAGE_TYPE_CIRC_GRP_QRY 42
115 #define MESSAGE_TYPE_CIRC_GRP_QRY_RSP 43
116 #define MESSAGE_TYPE_CALL_PROGRSS 44
117 #define MESSAGE_TYPE_USER2USER_INFO 45
118 #define MESSAGE_TYPE_UNEQUIPPED_CIC 46
119 #define MESSAGE_TYPE_CONFUSION 47
120 #define MESSAGE_TYPE_OVERLOAD 48
121 #define MESSAGE_TYPE_CHARGE_INFO 49
122 #define MESSAGE_TYPE_NETW_RESRC_MGMT 50
123 #define MESSAGE_TYPE_FACILITY 51
124 #define MESSAGE_TYPE_USER_PART_TEST 52
125 #define MESSAGE_TYPE_USER_PART_AVAIL 53
126 #define MESSAGE_TYPE_IDENT_REQ 54
127 #define MESSAGE_TYPE_IDENT_RSP 55
128 #define MESSAGE_TYPE_SEGMENTATION 56
129 #define MESSAGE_TYPE_LOOP_PREVENTION 64
130 #define MESSAGE_TYPE_APPLICATION_TRANS 65
131 #define MESSAGE_TYPE_PRE_RELEASE_INFO 66
132 #define MESSAGE_TYPE_SUBSEQUENT_DIR_NUM 67
133
134 #define ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK 0xE9
135 #define ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES 0xEA
136 #define ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP 0xEB
137 #define ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST 0xEC
138 #define ANSI_ISUP_MESSAGE_TYPE_EXIT 0xED
139
140 static const value_string isup_message_type_value[] = {
141 { MESSAGE_TYPE_INITIAL_ADDR, "Initial address"},
142 { MESSAGE_TYPE_SUBSEQ_ADDR, "Subsequent address"},
143 { MESSAGE_TYPE_INFO_REQ, "Information request (national use)"},
144 { MESSAGE_TYPE_INFO, "Information (national use)"},
145 { MESSAGE_TYPE_CONTINUITY, "Continuity"},
146 { MESSAGE_TYPE_ADDR_CMPL, "Address complete"},
147 { MESSAGE_TYPE_CONNECT, "Connect"},
148 { MESSAGE_TYPE_FORW_TRANS, "Forward transfer"},
149 { MESSAGE_TYPE_ANSWER, "Answer"},
150
151 { 10, "Reserved (used in 1984 version)"},
152 { 11, "Reserved (used in 1984 version)"},
153
154 { MESSAGE_TYPE_RELEASE, "Release"},
155 { MESSAGE_TYPE_SUSPEND, "Suspend"},
156 { MESSAGE_TYPE_RESUME, "Resume"},
157
158 { 15, "Reserved"},
159
160 { MESSAGE_TYPE_REL_CMPL, "Release complete"},
161 { MESSAGE_TYPE_CONT_CHECK_REQ, "Continuity check request"},
162 { MESSAGE_TYPE_RESET_CIRCUIT, "Reset Circuit"},
163 { MESSAGE_TYPE_BLOCKING, "Blocking"},
164 { MESSAGE_TYPE_UNBLOCKING, "Unblocking"},
165 { MESSAGE_TYPE_BLOCK_ACK, "Blocking acknowledgement"},
166 { MESSAGE_TYPE_UNBLOCK_ACK, "Unblocking acknowledgment"},
167 { MESSAGE_TYPE_CIRC_GRP_RST, "Circuit group reset"},
168 { MESSAGE_TYPE_CIRC_GRP_BLCK, "Circuit group blocking"},
169 { MESSAGE_TYPE_CIRC_GRP_UNBL, "Circuit group unblocking"},
170 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "Circuit group blocking acknowledgement"},
171 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "Circuit group unblocking acknowledgement"},
172
173 { 28, "Reserved (used in 1988 version)"},
174 { 29, "Reserved (used in 1988 version)"},
175 { 30, "Reserved (used in 1988 version)"},
176
177 { MESSAGE_TYPE_FACILITY_REQ, "Facility request"},
178 { MESSAGE_TYPE_FACILITY_ACC, "Facility accepted"},
179 { MESSAGE_TYPE_FACILITY_REJ, "Facility reject"},
180
181 { 34, "Reserved (used in 1984 version)"},
182 { 35, "Reserved (used in 1984 version)"},
183
184 { MESSAGE_TYPE_LOOP_BACK_ACK, "Loop back acknowledgement (national use)"},
185
186 { 37, "Reserved (used in 1984 version)"},
187 { 38, "Reserved (used in 1984 version)"},
188 { 39, "Reserved (used in 1984 version)"},
189
190 { MESSAGE_TYPE_PASS_ALONG, "Pass-along (national use)"},
191 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "Circuit group reset acknowledgement"},
192 { MESSAGE_TYPE_CIRC_GRP_QRY, "Circuit group query (national use)"},
193 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "Circuit group query response (national use)"},
194 { MESSAGE_TYPE_CALL_PROGRSS, "Call progress"},
195 { MESSAGE_TYPE_USER2USER_INFO, "User-to-user information"},
196 { MESSAGE_TYPE_UNEQUIPPED_CIC, "Unequipped CIC (national use)"},
197 { MESSAGE_TYPE_CONFUSION, "Confusion"},
198 { MESSAGE_TYPE_OVERLOAD, "Overload (national use)"},
199 { MESSAGE_TYPE_CHARGE_INFO, "Charge information (national use)"},
200 { MESSAGE_TYPE_NETW_RESRC_MGMT, "Network resource management"},
201 { MESSAGE_TYPE_FACILITY, "Facility"},
202 { MESSAGE_TYPE_USER_PART_TEST, "User part test"},
203 { MESSAGE_TYPE_USER_PART_AVAIL, "User part available"},
204 { MESSAGE_TYPE_IDENT_REQ, "Identification request"},
205 { MESSAGE_TYPE_IDENT_RSP, "Identification response"},
206 { MESSAGE_TYPE_SEGMENTATION, "Segmentation"},
207
208 { 57, "Reserved (used in B-ISUP)"},
209 { 58, "Reserved (used in B-ISUP)"},
210 { 59, "Reserved (used in B-ISUP)"},
211 { 60, "Reserved (used in B-ISUP)"},
212 { 61, "Reserved (used in B-ISUP)"},
213
214 { 62, "Unknown"},
215 { 63, "Unknown"},
216
217 { MESSAGE_TYPE_LOOP_PREVENTION, "Loop prevention"},
218 { MESSAGE_TYPE_APPLICATION_TRANS, "Application transport"},
219 { MESSAGE_TYPE_PRE_RELEASE_INFO, "Pre-release information"},
220 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "Subsequent Directory Number (national use)"},
221 { 0, NULL}};
222 static value_string_ext isup_message_type_value_ext = VALUE_STRING_EXT_INIT(isup_message_type_value);
223
224 #define FRENCH_CHARGING_PULSE 0xe1
225 #define FRENCH_CHARGING_ACK 0xe2
226 static const value_string french_isup_message_type_value[] = {
227 { MESSAGE_TYPE_INITIAL_ADDR, "Initial address"},
228 { MESSAGE_TYPE_SUBSEQ_ADDR, "Subsequent address"},
229 { MESSAGE_TYPE_INFO_REQ, "Information request (national use)"},
230 { MESSAGE_TYPE_INFO, "Information (national use)"},
231 { MESSAGE_TYPE_CONTINUITY, "Continuity"},
232 { MESSAGE_TYPE_ADDR_CMPL, "Address complete"},
233 { MESSAGE_TYPE_CONNECT, "Connect"},
234 { MESSAGE_TYPE_FORW_TRANS, "Forward transfer"},
235 { MESSAGE_TYPE_ANSWER, "Answer"},
236
237 { 10, "Reserved (used in 1984 version)"},
238 { 11, "Reserved (used in 1984 version)"},
239
240 { MESSAGE_TYPE_RELEASE, "Release"},
241 { MESSAGE_TYPE_SUSPEND, "Suspend"},
242 { MESSAGE_TYPE_RESUME, "Resume"},
243
244 { 15, "Reserved"},
245
246 { MESSAGE_TYPE_REL_CMPL, "Release complete"},
247 { MESSAGE_TYPE_CONT_CHECK_REQ, "Continuity check request"},
248 { MESSAGE_TYPE_RESET_CIRCUIT, "Reset Circuit"},
249 { MESSAGE_TYPE_BLOCKING, "Blocking"},
250 { MESSAGE_TYPE_UNBLOCKING, "Unblocking"},
251 { MESSAGE_TYPE_BLOCK_ACK, "Blocking acknowledgement"},
252 { MESSAGE_TYPE_UNBLOCK_ACK, "Unblocking acknowledgment"},
253 { MESSAGE_TYPE_CIRC_GRP_RST, "Circuit group reset"},
254 { MESSAGE_TYPE_CIRC_GRP_BLCK, "Circuit group blocking"},
255 { MESSAGE_TYPE_CIRC_GRP_UNBL, "Circuit group unblocking"},
256 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "Circuit group blocking acknowledgement"},
257 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "Circuit group unblocking acknowledgement"},
258
259 { 28, "Reserved (used in 1988 version)"},
260 { 29, "Reserved (used in 1988 version)"},
261 { 30, "Reserved (used in 1988 version)"},
262
263 { MESSAGE_TYPE_FACILITY_REQ, "Facility request"},
264 { MESSAGE_TYPE_FACILITY_ACC, "Facility accepted"},
265 { MESSAGE_TYPE_FACILITY_REJ, "Facility reject"},
266
267 { 34, "Reserved (used in 1984 version)"},
268 { 35, "Reserved (used in 1984 version)"},
269
270 { MESSAGE_TYPE_LOOP_BACK_ACK, "Loop back acknowledgement (national use)"},
271
272 { 37, "Reserved (used in 1984 version)"},
273 { 38, "Reserved (used in 1984 version)"},
274 { 39, "Reserved (used in 1984 version)"},
275
276 { MESSAGE_TYPE_PASS_ALONG, "Pass-along (national use)"},
277 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "Circuit group reset acknowledgement"},
278 { MESSAGE_TYPE_CIRC_GRP_QRY, "Circuit group query (national use)"},
279 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "Circuit group query response (national use)"},
280 { MESSAGE_TYPE_CALL_PROGRSS, "Call progress"},
281 { MESSAGE_TYPE_USER2USER_INFO, "User-to-user information"},
282 { MESSAGE_TYPE_UNEQUIPPED_CIC, "Unequipped CIC (national use)"},
283 { MESSAGE_TYPE_CONFUSION, "Confusion"},
284 { MESSAGE_TYPE_OVERLOAD, "Overload (national use)"},
285 { MESSAGE_TYPE_CHARGE_INFO, "Charge information (national use)"},
286 { MESSAGE_TYPE_NETW_RESRC_MGMT, "Network resource management"},
287 { MESSAGE_TYPE_FACILITY, "Facility"},
288 { MESSAGE_TYPE_USER_PART_TEST, "User part test"},
289 { MESSAGE_TYPE_USER_PART_AVAIL, "User part available"},
290 { MESSAGE_TYPE_IDENT_REQ, "Identification request"},
291 { MESSAGE_TYPE_IDENT_RSP, "Identification response"},
292 { MESSAGE_TYPE_SEGMENTATION, "Segmentation"},
293
294 { 57, "Reserved (used in B-ISUP)"},
295 { 58, "Reserved (used in B-ISUP)"},
296 { 59, "Reserved (used in B-ISUP)"},
297 { 60, "Reserved (used in B-ISUP)"},
298 { 61, "Reserved (used in B-ISUP)"},
299
300 { 62, "Unknown"},
301 { 63, "Unknown"},
302
303 { MESSAGE_TYPE_LOOP_PREVENTION, "Loop prevention"},
304 { MESSAGE_TYPE_APPLICATION_TRANS, "Application transport"},
305 { MESSAGE_TYPE_PRE_RELEASE_INFO, "Pre-release information"},
306 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "Subsequent Directory Number (national use)"},
307 { FRENCH_CHARGING_PULSE, "Charging Pulse"},
308 { FRENCH_CHARGING_ACK, "Charging Acknowledge"},
309 { 0, NULL}};
310 static value_string_ext french_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(french_isup_message_type_value);
311
312 #define ISRAELI_BACKWARD_CHARGING 232
313 #define ISRAELI_TRAFFIC_CHANGE 233
314 #define ISRAELI_CHARGE_ACK 234
315 static const value_string israeli_isup_message_type_value[] = {
316 { MESSAGE_TYPE_INITIAL_ADDR, "Initial address"},
317 { MESSAGE_TYPE_SUBSEQ_ADDR, "Subsequent address"},
318 { MESSAGE_TYPE_INFO_REQ, "Information request (national use)"},
319 { MESSAGE_TYPE_INFO, "Information (national use)"},
320 { MESSAGE_TYPE_CONTINUITY, "Continuity"},
321 { MESSAGE_TYPE_ADDR_CMPL, "Address complete"},
322 { MESSAGE_TYPE_CONNECT, "Connect"},
323 { MESSAGE_TYPE_FORW_TRANS, "Forward transfer"},
324 { MESSAGE_TYPE_ANSWER, "Answer"},
325
326 { 10, "Reserved (used in 1984 version)"},
327 { 11, "Reserved (used in 1984 version)"},
328
329 { MESSAGE_TYPE_RELEASE, "Release"},
330 { MESSAGE_TYPE_SUSPEND, "Suspend"},
331 { MESSAGE_TYPE_RESUME, "Resume"},
332
333 { 15, "Reserved"},
334
335 { MESSAGE_TYPE_REL_CMPL, "Release complete"},
336 { MESSAGE_TYPE_CONT_CHECK_REQ, "Continuity check request"},
337 { MESSAGE_TYPE_RESET_CIRCUIT, "Reset Circuit"},
338 { MESSAGE_TYPE_BLOCKING, "Blocking"},
339 { MESSAGE_TYPE_UNBLOCKING, "Unblocking"},
340 { MESSAGE_TYPE_BLOCK_ACK, "Blocking acknowledgement"},
341 { MESSAGE_TYPE_UNBLOCK_ACK, "Unblocking acknowledgment"},
342 { MESSAGE_TYPE_CIRC_GRP_RST, "Circuit group reset"},
343 { MESSAGE_TYPE_CIRC_GRP_BLCK, "Circuit group blocking"},
344 { MESSAGE_TYPE_CIRC_GRP_UNBL, "Circuit group unblocking"},
345 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "Circuit group blocking acknowledgement"},
346 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "Circuit group unblocking acknowledgement"},
347
348 { 28, "Reserved (used in 1988 version)"},
349 { 29, "Reserved (used in 1988 version)"},
350 { 30, "Reserved (used in 1988 version)"},
351
352 { MESSAGE_TYPE_FACILITY_REQ, "Facility request"},
353 { MESSAGE_TYPE_FACILITY_ACC, "Facility accepted"},
354 { MESSAGE_TYPE_FACILITY_REJ, "Facility reject"},
355
356 { 34, "Reserved (used in 1984 version)"},
357 { 35, "Reserved (used in 1984 version)"},
358
359 { MESSAGE_TYPE_LOOP_BACK_ACK, "Loop back acknowledgement (national use)"},
360
361 { 37, "Reserved (used in 1984 version)"},
362 { 38, "Reserved (used in 1984 version)"},
363 { 39, "Reserved (used in 1984 version)"},
364
365 { MESSAGE_TYPE_PASS_ALONG, "Pass-along (national use)"},
366 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "Circuit group reset acknowledgement"},
367 { MESSAGE_TYPE_CIRC_GRP_QRY, "Circuit group query (national use)"},
368 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "Circuit group query response (national use)"},
369 { MESSAGE_TYPE_CALL_PROGRSS, "Call progress"},
370 { MESSAGE_TYPE_USER2USER_INFO, "User-to-user information"},
371 { MESSAGE_TYPE_UNEQUIPPED_CIC, "Unequipped CIC (national use)"},
372 { MESSAGE_TYPE_CONFUSION, "Confusion"},
373 { MESSAGE_TYPE_OVERLOAD, "Overload (national use)"},
374 { MESSAGE_TYPE_CHARGE_INFO, "Charge information (national use)"},
375 { MESSAGE_TYPE_NETW_RESRC_MGMT, "Network resource management"},
376 { MESSAGE_TYPE_FACILITY, "Facility"},
377 { MESSAGE_TYPE_USER_PART_TEST, "User part test"},
378 { MESSAGE_TYPE_USER_PART_AVAIL, "User part available"},
379 { MESSAGE_TYPE_IDENT_REQ, "Identification request"},
380 { MESSAGE_TYPE_IDENT_RSP, "Identification response"},
381 { MESSAGE_TYPE_SEGMENTATION, "Segmentation"},
382
383 { 57, "Reserved (used in B-ISUP)"},
384 { 58, "Reserved (used in B-ISUP)"},
385 { 59, "Reserved (used in B-ISUP)"},
386 { 60, "Reserved (used in B-ISUP)"},
387 { 61, "Reserved (used in B-ISUP)"},
388
389 { 62, "Unknown"},
390 { 63, "Unknown"},
391
392 { MESSAGE_TYPE_LOOP_PREVENTION, "Loop prevention"},
393 { MESSAGE_TYPE_APPLICATION_TRANS, "Application transport"},
394 { MESSAGE_TYPE_PRE_RELEASE_INFO, "Pre-release information"},
395 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "Subsequent Directory Number (national use)"},
396 { ISRAELI_BACKWARD_CHARGING, "Backward Charging"},
397 { ISRAELI_TRAFFIC_CHANGE, "Traffic Change"},
398 { ISRAELI_CHARGE_ACK, "Charge Ack"},
399 { 0, NULL}};
400 static value_string_ext israeli_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(israeli_isup_message_type_value);
401
402 #define RUSSIAN_CLEAR_CALLING_LINE 252
403 #define RUSSIAN_RINGING 255
404
405 static const value_string russian_isup_message_type_value[] = {
406 { MESSAGE_TYPE_INITIAL_ADDR, "Initial address"},
407 { MESSAGE_TYPE_SUBSEQ_ADDR, "Subsequent address"},
408 { MESSAGE_TYPE_INFO_REQ, "Information request (national use)"},
409 { MESSAGE_TYPE_INFO, "Information (national use)"},
410 { MESSAGE_TYPE_CONTINUITY, "Continuity"},
411 { MESSAGE_TYPE_ADDR_CMPL, "Address complete"},
412 { MESSAGE_TYPE_CONNECT, "Connect"},
413 { MESSAGE_TYPE_FORW_TRANS, "Forward transfer"},
414 { MESSAGE_TYPE_ANSWER, "Answer"},
415
416 { 10, "Reserved (used in 1984 version)"},
417 { 11, "Reserved (used in 1984 version)"},
418
419 { MESSAGE_TYPE_RELEASE, "Release"},
420 { MESSAGE_TYPE_SUSPEND, "Suspend"},
421 { MESSAGE_TYPE_RESUME, "Resume"},
422
423 { 15, "Reserved"},
424
425 { MESSAGE_TYPE_REL_CMPL, "Release complete"},
426 { MESSAGE_TYPE_CONT_CHECK_REQ, "Continuity check request"},
427 { MESSAGE_TYPE_RESET_CIRCUIT, "Reset Circuit"},
428 { MESSAGE_TYPE_BLOCKING, "Blocking"},
429 { MESSAGE_TYPE_UNBLOCKING, "Unblocking"},
430 { MESSAGE_TYPE_BLOCK_ACK, "Blocking acknowledgement"},
431 { MESSAGE_TYPE_UNBLOCK_ACK, "Unblocking acknowledgment"},
432 { MESSAGE_TYPE_CIRC_GRP_RST, "Circuit group reset"},
433 { MESSAGE_TYPE_CIRC_GRP_BLCK, "Circuit group blocking"},
434 { MESSAGE_TYPE_CIRC_GRP_UNBL, "Circuit group unblocking"},
435 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "Circuit group blocking acknowledgement"},
436 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "Circuit group unblocking acknowledgement"},
437
438 { 28, "Reserved (used in 1988 version)"},
439 { 29, "Reserved (used in 1988 version)"},
440 { 30, "Reserved (used in 1988 version)"},
441
442 { MESSAGE_TYPE_FACILITY_REQ, "Facility request"},
443 { MESSAGE_TYPE_FACILITY_ACC, "Facility accepted"},
444 { MESSAGE_TYPE_FACILITY_REJ, "Facility reject"},
445
446 { 34, "Reserved (used in 1984 version)"},
447 { 35, "Reserved (used in 1984 version)"},
448
449 { MESSAGE_TYPE_LOOP_BACK_ACK, "Loop back acknowledgement (national use)"},
450
451 { 37, "Reserved (used in 1984 version)"},
452 { 38, "Reserved (used in 1984 version)"},
453 { 39, "Reserved (used in 1984 version)"},
454
455 { MESSAGE_TYPE_PASS_ALONG, "Pass-along (national use)"},
456 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "Circuit group reset acknowledgement"},
457 { MESSAGE_TYPE_CIRC_GRP_QRY, "Circuit group query (national use)"},
458 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "Circuit group query response (national use)"},
459 { MESSAGE_TYPE_CALL_PROGRSS, "Call progress"},
460 { MESSAGE_TYPE_USER2USER_INFO, "User-to-user information"},
461 { MESSAGE_TYPE_UNEQUIPPED_CIC, "Unequipped CIC (national use)"},
462 { MESSAGE_TYPE_CONFUSION, "Confusion"},
463 { MESSAGE_TYPE_OVERLOAD, "Overload (national use)"},
464 { MESSAGE_TYPE_CHARGE_INFO, "Charge information (national use)"},
465 { MESSAGE_TYPE_NETW_RESRC_MGMT, "Network resource management"},
466 { MESSAGE_TYPE_FACILITY, "Facility"},
467 { MESSAGE_TYPE_USER_PART_TEST, "User part test"},
468 { MESSAGE_TYPE_USER_PART_AVAIL, "User part available"},
469 { MESSAGE_TYPE_IDENT_REQ, "Identification request"},
470 { MESSAGE_TYPE_IDENT_RSP, "Identification response"},
471 { MESSAGE_TYPE_SEGMENTATION, "Segmentation"},
472
473 { 57, "Reserved (used in B-ISUP)"},
474 { 58, "Reserved (used in B-ISUP)"},
475 { 59, "Reserved (used in B-ISUP)"},
476 { 60, "Reserved (used in B-ISUP)"},
477 { 61, "Reserved (used in B-ISUP)"},
478
479 { 62, "Unknown"},
480 { 63, "Unknown"},
481
482 { MESSAGE_TYPE_LOOP_PREVENTION, "Loop prevention"},
483 { MESSAGE_TYPE_APPLICATION_TRANS, "Application transport"},
484 { MESSAGE_TYPE_PRE_RELEASE_INFO, "Pre-release information"},
485 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "Subsequent Directory Number (national use)"},
486 { RUSSIAN_CLEAR_CALLING_LINE, "Clear Calling Line"}, /* 252 */
487 { RUSSIAN_RINGING, "Ringing"}, /* 255 */
488
489 { 0, NULL}};
490 static value_string_ext russian_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(russian_isup_message_type_value);
491
492 /* http://www.ttc.or.jp/jp/document_list/sum/sum_JT-Q763v21.1.pdf */
493 #define MESSAGE_TYPE_JAPAN_CHARG_INF 254
494 static const value_string japan_isup_message_type_value[] = {
495 { MESSAGE_TYPE_INITIAL_ADDR, "Initial address"},
496 { MESSAGE_TYPE_SUBSEQ_ADDR, "Subsequent address"},
497 { MESSAGE_TYPE_INFO_REQ, "Information request (national use)"},
498 { MESSAGE_TYPE_INFO, "Information (national use)"},
499 { MESSAGE_TYPE_CONTINUITY, "Continuity"},
500 { MESSAGE_TYPE_ADDR_CMPL, "Address complete"},
501 { MESSAGE_TYPE_CONNECT, "Connect"},
502 { MESSAGE_TYPE_FORW_TRANS, "Forward transfer"},
503 { MESSAGE_TYPE_ANSWER, "Answer"},
504
505 { 0x0a, "Reserved (used in 1984 version)"},
506 { 0x0b, "Reserved (used in 1984 version)"},
507
508 { MESSAGE_TYPE_RELEASE, "Release"},
509 { MESSAGE_TYPE_SUSPEND, "Suspend"},
510 { MESSAGE_TYPE_RESUME, "Resume"},
511
512 { 15, "Reserved"},
513
514 { MESSAGE_TYPE_REL_CMPL, "Release complete"},
515 { MESSAGE_TYPE_CONT_CHECK_REQ, "Continuity check request"},
516 { MESSAGE_TYPE_RESET_CIRCUIT, "Reset Circuit"},
517 { MESSAGE_TYPE_BLOCKING, "Blocking"},
518 { MESSAGE_TYPE_UNBLOCKING, "Unblocking"},
519 { MESSAGE_TYPE_BLOCK_ACK, "Blocking acknowledgement"},
520 { MESSAGE_TYPE_UNBLOCK_ACK, "Unblocking acknowledgment"},
521 { MESSAGE_TYPE_CIRC_GRP_RST, "Circuit group reset"},
522 { MESSAGE_TYPE_CIRC_GRP_BLCK, "Circuit group blocking"},
523 { MESSAGE_TYPE_CIRC_GRP_UNBL, "Circuit group unblocking"},
524 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "Circuit group blocking acknowledgement"},
525 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "Circuit group unblocking acknowledgement"},
526
527 { 28, "Reserved (used in 1988 version)"},
528 { 29, "Reserved (used in 1988 version)"},
529 { 30, "Reserved (used in 1988 version)"},
530
531 { MESSAGE_TYPE_FACILITY_REQ, "Facility request"},
532 { MESSAGE_TYPE_FACILITY_ACC, "Facility accepted"},
533 { MESSAGE_TYPE_FACILITY_REJ, "Facility reject"},
534
535 { 34, "Reserved (used in 1984 version)"},
536 { 35, "Reserved (used in 1984 version)"},
537
538 { MESSAGE_TYPE_LOOP_BACK_ACK, "Loop back acknowledgement (national use)"},
539
540 { 37, "Reserved (used in 1984 version)"},
541 { 38, "Reserved (used in 1984 version)"},
542 { 39, "Reserved (used in 1984 version)"},
543
544 { MESSAGE_TYPE_PASS_ALONG, "Pass-along (national use)"},
545 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "Circuit group reset acknowledgement"},
546 { MESSAGE_TYPE_CIRC_GRP_QRY, "Circuit group query (national use)"},
547 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "Circuit group query response (national use)"},
548 { MESSAGE_TYPE_CALL_PROGRSS, "Call progress"},
549 { MESSAGE_TYPE_USER2USER_INFO, "User-to-user information"},
550 { MESSAGE_TYPE_UNEQUIPPED_CIC, "Unequipped CIC (national use)"},
551 { MESSAGE_TYPE_CONFUSION, "Confusion"},
552 { MESSAGE_TYPE_OVERLOAD, "Overload (national use)"},
553 { MESSAGE_TYPE_CHARGE_INFO, "Charge information (national use)"},
554 { MESSAGE_TYPE_NETW_RESRC_MGMT, "Network resource management"},
555 { MESSAGE_TYPE_FACILITY, "Facility"},
556 { MESSAGE_TYPE_USER_PART_TEST, "User part test"},
557 { MESSAGE_TYPE_USER_PART_AVAIL, "User part available"},
558 { MESSAGE_TYPE_IDENT_REQ, "Identification request"},
559 { MESSAGE_TYPE_IDENT_RSP, "Identification response"},
560 { MESSAGE_TYPE_SEGMENTATION, "Segmentation"},
561
562 { 57, "Reserved (used in B-ISUP)"},
563 { 58, "Reserved (used in B-ISUP)"},
564 { 59, "Reserved (used in B-ISUP)"},
565 { 60, "Reserved (used in B-ISUP)"},
566 { 61, "Reserved (used in B-ISUP)"},
567
568 { 62, "Unknown"},
569 { 63, "Unknown"},
570
571 { MESSAGE_TYPE_LOOP_PREVENTION, "Loop prevention"},
572 { MESSAGE_TYPE_APPLICATION_TRANS, "Application transport"},
573 { MESSAGE_TYPE_PRE_RELEASE_INFO, "Pre-release information"},
574 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "Subsequent Directory Number (national use)"},
575 { MESSAGE_TYPE_JAPAN_CHARG_INF, "Charge information"},
576 { 0, NULL}};
577 static value_string_ext japan_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(japan_isup_message_type_value);
578
579 static const value_string ansi_isup_message_type_value[] = {
580 { MESSAGE_TYPE_INITIAL_ADDR, "Initial address"},
581 { MESSAGE_TYPE_SUBSEQ_ADDR, "Subsequent address"},
582 { MESSAGE_TYPE_INFO_REQ, "Information request (national use)"},
583 { MESSAGE_TYPE_INFO, "Information (national use)"},
584 { MESSAGE_TYPE_CONTINUITY, "Continuity"},
585 { MESSAGE_TYPE_ADDR_CMPL, "Address complete"},
586 { MESSAGE_TYPE_CONNECT, "Connect"},
587 { MESSAGE_TYPE_FORW_TRANS, "Forward transfer"},
588 { MESSAGE_TYPE_ANSWER, "Answer"},
589 { MESSAGE_TYPE_RELEASE, "Release"},
590 { MESSAGE_TYPE_SUSPEND, "Suspend"},
591 { MESSAGE_TYPE_RESUME, "Resume"},
592 { MESSAGE_TYPE_REL_CMPL, "Release complete"},
593 { MESSAGE_TYPE_CONT_CHECK_REQ, "Continuity check request"},
594 { MESSAGE_TYPE_RESET_CIRCUIT, "Reset Circuit"},
595 { MESSAGE_TYPE_BLOCKING, "Blocking"},
596 { MESSAGE_TYPE_UNBLOCKING, "Unblocking"},
597 { MESSAGE_TYPE_BLOCK_ACK, "Blocking acknowledgement"},
598 { MESSAGE_TYPE_UNBLOCK_ACK, "Unblocking acknowledgment"},
599 { MESSAGE_TYPE_CIRC_GRP_RST, "Circuit group reset"},
600 { MESSAGE_TYPE_CIRC_GRP_BLCK, "Circuit group blocking"},
601 { MESSAGE_TYPE_CIRC_GRP_UNBL, "Circuit group unblocking"},
602 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "Circuit group blocking acknowledgement"},
603 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "Circuit group unblocking acknowledgement"},
604 { MESSAGE_TYPE_FACILITY_REQ, "Facility request"},
605 { MESSAGE_TYPE_FACILITY_ACC, "Facility accepted"},
606 { MESSAGE_TYPE_FACILITY_REJ, "Facility reject"},
607 { MESSAGE_TYPE_LOOP_BACK_ACK, "Loop back acknowledgement (national use)"},
608 { MESSAGE_TYPE_PASS_ALONG, "Pass-along (national use)"},
609 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "Circuit group reset acknowledgement"},
610 { MESSAGE_TYPE_CIRC_GRP_QRY, "Circuit group query (national use)"},
611 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "Circuit group query response (national use)"},
612 { MESSAGE_TYPE_CALL_PROGRSS, "Call progress"},
613 { MESSAGE_TYPE_USER2USER_INFO, "User-to-user information"},
614 { MESSAGE_TYPE_UNEQUIPPED_CIC, "Unequipped CIC (national use)"},
615 { MESSAGE_TYPE_CONFUSION, "Confusion"},
616 { MESSAGE_TYPE_OVERLOAD, "Overload (national use)"},
617 { MESSAGE_TYPE_CHARGE_INFO, "Charge information (national use)"},
618 { MESSAGE_TYPE_NETW_RESRC_MGMT, "Network resource management"},
619 { MESSAGE_TYPE_FACILITY, "Facility"},
620 { MESSAGE_TYPE_USER_PART_TEST, "User part test"},
621 { MESSAGE_TYPE_USER_PART_AVAIL, "User part available"},
622 { MESSAGE_TYPE_IDENT_REQ, "Identification request"},
623 { MESSAGE_TYPE_IDENT_RSP, "Identification response"},
624 { MESSAGE_TYPE_SEGMENTATION, "Segmentation"},
625 { MESSAGE_TYPE_LOOP_PREVENTION, "Loop prevention"},
626 { MESSAGE_TYPE_APPLICATION_TRANS, "Application transport"},
627 { MESSAGE_TYPE_PRE_RELEASE_INFO, "Pre-release information"},
628 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "Subsequent Directory Number (national use)"},
629 { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK, "Circuit Reservation Acknowledge"},
630 { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES, "Circuit Reservation"},
631 { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP, "Circuit Validation Test Response"},
632 { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST, "Circuit Validation Test"},
633 { ANSI_ISUP_MESSAGE_TYPE_EXIT, "Exit"},
634 { 0, NULL}};
635 static value_string_ext ansi_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(ansi_isup_message_type_value);
636
637 /* Same as above but in acronym form (for the Info column) */
638 static const value_string isup_message_type_value_acro[] = {
639 { MESSAGE_TYPE_INITIAL_ADDR, "IAM"},
640 { MESSAGE_TYPE_SUBSEQ_ADDR, "SAM"},
641 { MESSAGE_TYPE_INFO_REQ, "INR"},
642 { MESSAGE_TYPE_INFO, "INF"},
643 { MESSAGE_TYPE_CONTINUITY, "COT"},
644 { MESSAGE_TYPE_ADDR_CMPL, "ACM"},
645 { MESSAGE_TYPE_CONNECT, "CON"},
646 { MESSAGE_TYPE_FORW_TRANS, "FOT"},
647 { MESSAGE_TYPE_ANSWER, "ANM"},
648
649 { 10, "Reserved"},
650 { 11, "Reserved"},
651
652 { MESSAGE_TYPE_RELEASE, "REL"},
653 { MESSAGE_TYPE_SUSPEND, "SUS"},
654 { MESSAGE_TYPE_RESUME, "RES"},
655
656 { 15, "Reserved"},
657
658 { MESSAGE_TYPE_REL_CMPL, "RLC"},
659 { MESSAGE_TYPE_CONT_CHECK_REQ, "CCR"},
660 { MESSAGE_TYPE_RESET_CIRCUIT, "RSC"},
661 { MESSAGE_TYPE_BLOCKING, "BLO"},
662 { MESSAGE_TYPE_UNBLOCKING, "UBL"},
663 { MESSAGE_TYPE_BLOCK_ACK, "BLA"},
664 { MESSAGE_TYPE_UNBLOCK_ACK, "UBLA"},
665 { MESSAGE_TYPE_CIRC_GRP_RST, "GRS"},
666 { MESSAGE_TYPE_CIRC_GRP_BLCK, "CGB"},
667 { MESSAGE_TYPE_CIRC_GRP_UNBL, "CGU"},
668 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "CGBA"},
669 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "CGUA"},
670
671 { 28, "Reserved"},
672 { 29, "Reserved"},
673 { 30, "Reserved"},
674
675 { MESSAGE_TYPE_FACILITY_REQ, "FAR"},
676 { MESSAGE_TYPE_FACILITY_ACC, "FAA"},
677 { MESSAGE_TYPE_FACILITY_REJ, "FRJ"},
678
679 { 34, "Reserved"},
680 { 35, "Reserved"},
681
682 { MESSAGE_TYPE_LOOP_BACK_ACK, "LPA"},
683
684 { 37, "Reserved"},
685 { 38, "Reserved"},
686 { 39, "Reserved"},
687
688 { MESSAGE_TYPE_PASS_ALONG, "PAM"},
689 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "GRA"},
690 { MESSAGE_TYPE_CIRC_GRP_QRY, "CQM"},
691 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "CQR"},
692 { MESSAGE_TYPE_CALL_PROGRSS, "CPG"},
693 { MESSAGE_TYPE_USER2USER_INFO, "UUI"},
694 { MESSAGE_TYPE_UNEQUIPPED_CIC, "UCIC"},
695 { MESSAGE_TYPE_CONFUSION, "CFN"},
696 { MESSAGE_TYPE_OVERLOAD, "OLM"},
697 { MESSAGE_TYPE_CHARGE_INFO, "CRG"},
698 { MESSAGE_TYPE_NETW_RESRC_MGMT, "NRM"},
699 { MESSAGE_TYPE_FACILITY, "FAC"},
700 { MESSAGE_TYPE_USER_PART_TEST, "UPT"},
701 { MESSAGE_TYPE_USER_PART_AVAIL, "UPA"},
702 { MESSAGE_TYPE_IDENT_REQ, "IDR"},
703 { MESSAGE_TYPE_IDENT_RSP, "IDS"},
704 { MESSAGE_TYPE_SEGMENTATION, "SGM"},
705
706 { 57, "Reserved"},
707 { 58, "Reserved"},
708 { 59, "Reserved"},
709 { 60, "Reserved"},
710 { 61, "Reserved"},
711
712 { 62, "Unknown"},
713 { 63, "Unknown"},
714
715 { MESSAGE_TYPE_LOOP_PREVENTION, "LOP"},
716 { MESSAGE_TYPE_APPLICATION_TRANS, "APM"},
717 { MESSAGE_TYPE_PRE_RELEASE_INFO, "PRI"},
718 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "SDN"},
719 { 0, NULL}};
720 value_string_ext isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(isup_message_type_value_acro);
721
722 static const value_string french_isup_message_type_value_acro[] = {
723 { MESSAGE_TYPE_INITIAL_ADDR, "IAM"},
724 { MESSAGE_TYPE_SUBSEQ_ADDR, "SAM"},
725 { MESSAGE_TYPE_INFO_REQ, "INR"},
726 { MESSAGE_TYPE_INFO, "INF"},
727 { MESSAGE_TYPE_CONTINUITY, "COT"},
728 { MESSAGE_TYPE_ADDR_CMPL, "ACM"},
729 { MESSAGE_TYPE_CONNECT, "CON"},
730 { MESSAGE_TYPE_FORW_TRANS, "FOT"},
731 { MESSAGE_TYPE_ANSWER, "ANM"},
732
733 { 10, "Reserved"},
734 { 11, "Reserved"},
735
736 { MESSAGE_TYPE_RELEASE, "REL"},
737 { MESSAGE_TYPE_SUSPEND, "SUS"},
738 { MESSAGE_TYPE_RESUME, "RES"},
739
740 { 15, "Reserved"},
741
742 { MESSAGE_TYPE_REL_CMPL, "RLC"},
743 { MESSAGE_TYPE_CONT_CHECK_REQ, "CCR"},
744 { MESSAGE_TYPE_RESET_CIRCUIT, "RSC"},
745 { MESSAGE_TYPE_BLOCKING, "BLO"},
746 { MESSAGE_TYPE_UNBLOCKING, "UBL"},
747 { MESSAGE_TYPE_BLOCK_ACK, "BLA"},
748 { MESSAGE_TYPE_UNBLOCK_ACK, "UBLA"},
749 { MESSAGE_TYPE_CIRC_GRP_RST, "GRS"},
750 { MESSAGE_TYPE_CIRC_GRP_BLCK, "CGB"},
751 { MESSAGE_TYPE_CIRC_GRP_UNBL, "CGU"},
752 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "CGBA"},
753 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "CGUA"},
754
755 { 28, "Reserved"},
756 { 29, "Reserved"},
757 { 30, "Reserved"},
758
759 { MESSAGE_TYPE_FACILITY_REQ, "FAR"},
760 { MESSAGE_TYPE_FACILITY_ACC, "FAA"},
761 { MESSAGE_TYPE_FACILITY_REJ, "FRJ"},
762
763 { 34, "Reserved"},
764 { 35, "Reserved"},
765
766 { MESSAGE_TYPE_LOOP_BACK_ACK, "LPA"},
767
768 { 37, "Reserved"},
769 { 38, "Reserved"},
770 { 39, "Reserved"},
771
772 { MESSAGE_TYPE_PASS_ALONG, "PAM"},
773 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "GRA"},
774 { MESSAGE_TYPE_CIRC_GRP_QRY, "CQM"},
775 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "CQR"},
776 { MESSAGE_TYPE_CALL_PROGRSS, "CPG"},
777 { MESSAGE_TYPE_USER2USER_INFO, "UUI"},
778 { MESSAGE_TYPE_UNEQUIPPED_CIC, "UCIC"},
779 { MESSAGE_TYPE_CONFUSION, "CFN"},
780 { MESSAGE_TYPE_OVERLOAD, "OLM"},
781 { MESSAGE_TYPE_CHARGE_INFO, "CRG"},
782 { MESSAGE_TYPE_NETW_RESRC_MGMT, "NRM"},
783 { MESSAGE_TYPE_FACILITY, "FAC"},
784 { MESSAGE_TYPE_USER_PART_TEST, "UPT"},
785 { MESSAGE_TYPE_USER_PART_AVAIL, "UPA"},
786 { MESSAGE_TYPE_IDENT_REQ, "IDR"},
787 { MESSAGE_TYPE_IDENT_RSP, "IDS"},
788 { MESSAGE_TYPE_SEGMENTATION, "SGM"},
789
790 { 57, "Reserved"},
791 { 58, "Reserved"},
792 { 59, "Reserved"},
793 { 60, "Reserved"},
794 { 61, "Reserved"},
795
796 { 62, "Unknown"},
797 { 63, "Unknown"},
798
799 { MESSAGE_TYPE_LOOP_PREVENTION, "LOP"},
800 { MESSAGE_TYPE_APPLICATION_TRANS, "APM"},
801 { MESSAGE_TYPE_PRE_RELEASE_INFO, "PRI"},
802 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "SDN"},
803 { FRENCH_CHARGING_PULSE, "CHP"},
804 { FRENCH_CHARGING_ACK, "CHA"},
805 { 0, NULL}};
806 static value_string_ext french_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(french_isup_message_type_value_acro);
807
808 static const value_string israeli_isup_message_type_value_acro[] = {
809 { MESSAGE_TYPE_INITIAL_ADDR, "IAM"},
810 { MESSAGE_TYPE_SUBSEQ_ADDR, "SAM"},
811 { MESSAGE_TYPE_INFO_REQ, "INR"},
812 { MESSAGE_TYPE_INFO, "INF"},
813 { MESSAGE_TYPE_CONTINUITY, "COT"},
814 { MESSAGE_TYPE_ADDR_CMPL, "ACM"},
815 { MESSAGE_TYPE_CONNECT, "CON"},
816 { MESSAGE_TYPE_FORW_TRANS, "FOT"},
817 { MESSAGE_TYPE_ANSWER, "ANM"},
818
819 { 10, "Reserved"},
820 { 11, "Reserved"},
821
822 { MESSAGE_TYPE_RELEASE, "REL"},
823 { MESSAGE_TYPE_SUSPEND, "SUS"},
824 { MESSAGE_TYPE_RESUME, "RES"},
825
826 { 15, "Reserved"},
827
828 { MESSAGE_TYPE_REL_CMPL, "RLC"},
829 { MESSAGE_TYPE_CONT_CHECK_REQ, "CCR"},
830 { MESSAGE_TYPE_RESET_CIRCUIT, "RSC"},
831 { MESSAGE_TYPE_BLOCKING, "BLO"},
832 { MESSAGE_TYPE_UNBLOCKING, "UBL"},
833 { MESSAGE_TYPE_BLOCK_ACK, "BLA"},
834 { MESSAGE_TYPE_UNBLOCK_ACK, "UBLA"},
835 { MESSAGE_TYPE_CIRC_GRP_RST, "GRS"},
836 { MESSAGE_TYPE_CIRC_GRP_BLCK, "CGB"},
837 { MESSAGE_TYPE_CIRC_GRP_UNBL, "CGU"},
838 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "CGBA"},
839 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "CGUA"},
840
841 { 28, "Reserved"},
842 { 29, "Reserved"},
843 { 30, "Reserved"},
844
845 { MESSAGE_TYPE_FACILITY_REQ, "FAR"},
846 { MESSAGE_TYPE_FACILITY_ACC, "FAA"},
847 { MESSAGE_TYPE_FACILITY_REJ, "FRJ"},
848
849 { 34, "Reserved"},
850 { 35, "Reserved"},
851
852 { MESSAGE_TYPE_LOOP_BACK_ACK, "LPA"},
853
854 { 37, "Reserved"},
855 { 38, "Reserved"},
856 { 39, "Reserved"},
857
858 { MESSAGE_TYPE_PASS_ALONG, "PAM"},
859 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "GRA"},
860 { MESSAGE_TYPE_CIRC_GRP_QRY, "CQM"},
861 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "CQR"},
862 { MESSAGE_TYPE_CALL_PROGRSS, "CPG"},
863 { MESSAGE_TYPE_USER2USER_INFO, "UUI"},
864 { MESSAGE_TYPE_UNEQUIPPED_CIC, "UCIC"},
865 { MESSAGE_TYPE_CONFUSION, "CFN"},
866 { MESSAGE_TYPE_OVERLOAD, "OLM"},
867 { MESSAGE_TYPE_CHARGE_INFO, "CRG"},
868 { MESSAGE_TYPE_NETW_RESRC_MGMT, "NRM"},
869 { MESSAGE_TYPE_FACILITY, "FAC"},
870 { MESSAGE_TYPE_USER_PART_TEST, "UPT"},
871 { MESSAGE_TYPE_USER_PART_AVAIL, "UPA"},
872 { MESSAGE_TYPE_IDENT_REQ, "IDR"},
873 { MESSAGE_TYPE_IDENT_RSP, "IDS"},
874 { MESSAGE_TYPE_SEGMENTATION, "SGM"},
875
876 { 57, "Reserved"},
877 { 58, "Reserved"},
878 { 59, "Reserved"},
879 { 60, "Reserved"},
880 { 61, "Reserved"},
881
882 { 62, "Unknown"},
883 { 63, "Unknown"},
884
885 { MESSAGE_TYPE_LOOP_PREVENTION, "LOP"},
886 { MESSAGE_TYPE_APPLICATION_TRANS, "APM"},
887 { MESSAGE_TYPE_PRE_RELEASE_INFO, "PRI"},
888 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "SDN"},
889 { ISRAELI_BACKWARD_CHARGING, "BCM"},
890 { ISRAELI_TRAFFIC_CHANGE, "TCM"},
891 { ISRAELI_CHARGE_ACK, "CAM"},
892 { 0, NULL}};
893 static value_string_ext israeli_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(israeli_isup_message_type_value_acro);
894
895 /* Same as above but in acronym form (for the Info column) */
896 static const value_string russian_isup_message_type_value_acro[] = {
897 { MESSAGE_TYPE_INITIAL_ADDR, "IAM"},
898 { MESSAGE_TYPE_SUBSEQ_ADDR, "SAM"},
899 { MESSAGE_TYPE_INFO_REQ, "INR"},
900 { MESSAGE_TYPE_INFO, "INF"},
901 { MESSAGE_TYPE_CONTINUITY, "COT"},
902 { MESSAGE_TYPE_ADDR_CMPL, "ACM"},
903 { MESSAGE_TYPE_CONNECT, "CON"},
904 { MESSAGE_TYPE_FORW_TRANS, "FOT"},
905 { MESSAGE_TYPE_ANSWER, "ANM"},
906
907 { 10, "Reserved"},
908 { 11, "Reserved"},
909
910 { MESSAGE_TYPE_RELEASE, "REL"},
911 { MESSAGE_TYPE_SUSPEND, "SUS"},
912 { MESSAGE_TYPE_RESUME, "RES"},
913
914 { 15, "Reserved"},
915
916 { MESSAGE_TYPE_REL_CMPL, "RLC"},
917 { MESSAGE_TYPE_CONT_CHECK_REQ, "CCR"},
918 { MESSAGE_TYPE_RESET_CIRCUIT, "RSC"},
919 { MESSAGE_TYPE_BLOCKING, "BLO"},
920 { MESSAGE_TYPE_UNBLOCKING, "UBL"},
921 { MESSAGE_TYPE_BLOCK_ACK, "BLA"},
922 { MESSAGE_TYPE_UNBLOCK_ACK, "UBLA"},
923 { MESSAGE_TYPE_CIRC_GRP_RST, "GRS"},
924 { MESSAGE_TYPE_CIRC_GRP_BLCK, "CGB"},
925 { MESSAGE_TYPE_CIRC_GRP_UNBL, "CGU"},
926 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "CGBA"},
927 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "CGUA"},
928
929 { 28, "Reserved"},
930 { 29, "Reserved"},
931 { 30, "Reserved"},
932
933 { MESSAGE_TYPE_FACILITY_REQ, "FAR"},
934 { MESSAGE_TYPE_FACILITY_ACC, "FAA"},
935 { MESSAGE_TYPE_FACILITY_REJ, "FRJ"},
936
937 { 34, "Reserved"},
938 { 35, "Reserved"},
939
940 { MESSAGE_TYPE_LOOP_BACK_ACK, "LPA"},
941
942 { 37, "Reserved"},
943 { 38, "Reserved"},
944 { 39, "Reserved"},
945
946 { MESSAGE_TYPE_PASS_ALONG, "PAM"},
947 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "GRA"},
948 { MESSAGE_TYPE_CIRC_GRP_QRY, "CQM"},
949 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "CQR"},
950 { MESSAGE_TYPE_CALL_PROGRSS, "CPG"},
951 { MESSAGE_TYPE_USER2USER_INFO, "UUI"},
952 { MESSAGE_TYPE_UNEQUIPPED_CIC, "UCIC"},
953 { MESSAGE_TYPE_CONFUSION, "CFN"},
954 { MESSAGE_TYPE_OVERLOAD, "OLM"},
955 { MESSAGE_TYPE_CHARGE_INFO, "CRG"},
956 { MESSAGE_TYPE_NETW_RESRC_MGMT, "NRM"},
957 { MESSAGE_TYPE_FACILITY, "FAC"},
958 { MESSAGE_TYPE_USER_PART_TEST, "UPT"},
959 { MESSAGE_TYPE_USER_PART_AVAIL, "UPA"},
960 { MESSAGE_TYPE_IDENT_REQ, "IDR"},
961 { MESSAGE_TYPE_IDENT_RSP, "IDS"},
962 { MESSAGE_TYPE_SEGMENTATION, "SGM"},
963
964 { 57, "Reserved"},
965 { 58, "Reserved"},
966 { 59, "Reserved"},
967 { 60, "Reserved"},
968 { 61, "Reserved"},
969
970 { 62, "Unknown"},
971 { 63, "Unknown"},
972
973 { MESSAGE_TYPE_LOOP_PREVENTION, "LOP"},
974 { MESSAGE_TYPE_APPLICATION_TRANS, "APM"},
975 { MESSAGE_TYPE_PRE_RELEASE_INFO, "PRI"},
976 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "SDN"},
977 { RUSSIAN_CLEAR_CALLING_LINE, "CCL"}, /* 252 */
978 { RUSSIAN_RINGING, "RNG"}, /* 255 */
979 { 0, NULL}};
980 static value_string_ext russian_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(russian_isup_message_type_value_acro);
981
982 static const value_string japan_isup_message_type_value_acro[] = {
983 { MESSAGE_TYPE_INITIAL_ADDR, "IAM"},
984 { MESSAGE_TYPE_SUBSEQ_ADDR, "SAM"},
985 { MESSAGE_TYPE_INFO_REQ, "INR"},
986 { MESSAGE_TYPE_INFO, "INF"},
987 { MESSAGE_TYPE_CONTINUITY, "COT"},
988 { MESSAGE_TYPE_ADDR_CMPL, "ACM"},
989 { MESSAGE_TYPE_CONNECT, "CON"},
990 { MESSAGE_TYPE_FORW_TRANS, "FOT"},
991 { MESSAGE_TYPE_ANSWER, "ANM"},
992
993 { 10, "Reserved"},
994 { 11, "Reserved"},
995
996 { MESSAGE_TYPE_RELEASE, "REL"},
997 { MESSAGE_TYPE_SUSPEND, "SUS"},
998 { MESSAGE_TYPE_RESUME, "RES"},
999
1000 { 15, "Reserved"},
1001
1002 { MESSAGE_TYPE_REL_CMPL, "RLC"},
1003 { MESSAGE_TYPE_CONT_CHECK_REQ, "CCR"},
1004 { MESSAGE_TYPE_RESET_CIRCUIT, "RSC"},
1005 { MESSAGE_TYPE_BLOCKING, "BLO"},
1006 { MESSAGE_TYPE_UNBLOCKING, "UBL"},
1007 { MESSAGE_TYPE_BLOCK_ACK, "BLA"},
1008 { MESSAGE_TYPE_UNBLOCK_ACK, "UBLA"},
1009 { MESSAGE_TYPE_CIRC_GRP_RST, "GRS"},
1010 { MESSAGE_TYPE_CIRC_GRP_BLCK, "CGB"},
1011 { MESSAGE_TYPE_CIRC_GRP_UNBL, "CGU"},
1012 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "CGBA"},
1013 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "CGUA"},
1014
1015 { 28, "Reserved"},
1016 { 29, "Reserved"},
1017 { 30, "Reserved"},
1018
1019 { MESSAGE_TYPE_FACILITY_REQ, "FAR"},
1020 { MESSAGE_TYPE_FACILITY_ACC, "FAA"},
1021 { MESSAGE_TYPE_FACILITY_REJ, "FRJ"},
1022
1023 { 34, "Reserved"},
1024 { 35, "Reserved"},
1025
1026 { MESSAGE_TYPE_LOOP_BACK_ACK, "LPA"},
1027
1028 { 37, "Reserved"},
1029 { 38, "Reserved"},
1030 { 39, "Reserved"},
1031
1032 { MESSAGE_TYPE_PASS_ALONG, "PAM"},
1033 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "GRA"},
1034 { MESSAGE_TYPE_CIRC_GRP_QRY, "CQM"},
1035 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "CQR"},
1036 { MESSAGE_TYPE_CALL_PROGRSS, "CPG"},
1037 { MESSAGE_TYPE_USER2USER_INFO, "UUI"},
1038 { MESSAGE_TYPE_UNEQUIPPED_CIC, "UCIC"},
1039 { MESSAGE_TYPE_CONFUSION, "CFN"},
1040 { MESSAGE_TYPE_OVERLOAD, "OLM"},
1041 { MESSAGE_TYPE_CHARGE_INFO, "CRG"},
1042 { MESSAGE_TYPE_NETW_RESRC_MGMT, "NRM"},
1043 { MESSAGE_TYPE_FACILITY, "FAC"},
1044 { MESSAGE_TYPE_USER_PART_TEST, "UPT"},
1045 { MESSAGE_TYPE_USER_PART_AVAIL, "UPA"},
1046 { MESSAGE_TYPE_IDENT_REQ, "IDR"},
1047 { MESSAGE_TYPE_IDENT_RSP, "IDS"},
1048 { MESSAGE_TYPE_SEGMENTATION, "SGM"},
1049
1050 { 57, "Reserved"},
1051 { 58, "Reserved"},
1052 { 59, "Reserved"},
1053 { 60, "Reserved"},
1054 { 61, "Reserved"},
1055
1056 { 62, "Unknown"},
1057 { 63, "Unknown"},
1058
1059 { MESSAGE_TYPE_LOOP_PREVENTION, "LOP"},
1060 { MESSAGE_TYPE_APPLICATION_TRANS, "APM"},
1061 { MESSAGE_TYPE_PRE_RELEASE_INFO, "PRI"},
1062 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "SDN"},
1063 { MESSAGE_TYPE_JAPAN_CHARG_INF, "CHG"}, /* 254 */
1064 { 0, NULL}};
1065 static value_string_ext japan_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(japan_isup_message_type_value_acro);
1066
1067 /* Same as above but in acronym form (for the Info column) */
1068 static const value_string ansi_isup_message_type_value_acro[] = {
1069 { MESSAGE_TYPE_INITIAL_ADDR, "IAM"},
1070 { MESSAGE_TYPE_SUBSEQ_ADDR, "SAM"},
1071 { MESSAGE_TYPE_INFO_REQ, "INR"},
1072 { MESSAGE_TYPE_INFO, "INF"},
1073 { MESSAGE_TYPE_CONTINUITY, "COT"},
1074 { MESSAGE_TYPE_ADDR_CMPL, "ACM"},
1075 { MESSAGE_TYPE_CONNECT, "CON"},
1076 { MESSAGE_TYPE_FORW_TRANS, "FOT"},
1077 { MESSAGE_TYPE_ANSWER, "ANM"},
1078 { MESSAGE_TYPE_RELEASE, "REL"},
1079 { MESSAGE_TYPE_SUSPEND, "SUS"},
1080 { MESSAGE_TYPE_RESUME, "RES"},
1081 { MESSAGE_TYPE_REL_CMPL, "RLC"},
1082 { MESSAGE_TYPE_CONT_CHECK_REQ, "CCR"},
1083 { MESSAGE_TYPE_RESET_CIRCUIT, "RSC"},
1084 { MESSAGE_TYPE_BLOCKING, "BLO"},
1085 { MESSAGE_TYPE_UNBLOCKING, "UBL"},
1086 { MESSAGE_TYPE_BLOCK_ACK, "BLA"},
1087 { MESSAGE_TYPE_UNBLOCK_ACK, "UBLA"},
1088 { MESSAGE_TYPE_CIRC_GRP_RST, "GRS"},
1089 { MESSAGE_TYPE_CIRC_GRP_BLCK, "CGB"},
1090 { MESSAGE_TYPE_CIRC_GRP_UNBL, "CGU"},
1091 { MESSAGE_TYPE_CIRC_GRP_BL_ACK, "CGBA"},
1092 { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK, "CGUA"},
1093 { MESSAGE_TYPE_FACILITY_REQ, "FAR"},
1094 { MESSAGE_TYPE_FACILITY_ACC, "FAA"},
1095 { MESSAGE_TYPE_FACILITY_REJ, "FRJ"},
1096 { MESSAGE_TYPE_LOOP_BACK_ACK, "LPA"},
1097 { MESSAGE_TYPE_PASS_ALONG, "PAM"},
1098 { MESSAGE_TYPE_CIRC_GRP_RST_ACK, "GRA"},
1099 { MESSAGE_TYPE_CIRC_GRP_QRY, "CQM"},
1100 { MESSAGE_TYPE_CIRC_GRP_QRY_RSP, "CQR"},
1101 { MESSAGE_TYPE_CALL_PROGRSS, "CPG"},
1102 { MESSAGE_TYPE_USER2USER_INFO, "UUI"},
1103 { MESSAGE_TYPE_UNEQUIPPED_CIC, "UCIC"},
1104 { MESSAGE_TYPE_CONFUSION, "CFN"},
1105 { MESSAGE_TYPE_OVERLOAD, "OLM"},
1106 { MESSAGE_TYPE_CHARGE_INFO, "CRG"},
1107 { MESSAGE_TYPE_NETW_RESRC_MGMT, "NRM"},
1108 { MESSAGE_TYPE_FACILITY, "FAC"},
1109 { MESSAGE_TYPE_USER_PART_TEST, "UPT"},
1110 { MESSAGE_TYPE_USER_PART_AVAIL, "UPA"},
1111 { MESSAGE_TYPE_IDENT_REQ, "IDR"},
1112 { MESSAGE_TYPE_IDENT_RSP, "IDS"},
1113 { MESSAGE_TYPE_SEGMENTATION, "SGM"},
1114 { MESSAGE_TYPE_LOOP_PREVENTION, "LOP"},
1115 { MESSAGE_TYPE_APPLICATION_TRANS, "APM"},
1116 { MESSAGE_TYPE_PRE_RELEASE_INFO, "PRI"},
1117 { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM, "SDN"},
1118 { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK, "CRA"},
1119 { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES, "CRM"},
1120 { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP, "CVR"},
1121 { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST, "CVT"},
1122 { ANSI_ISUP_MESSAGE_TYPE_EXIT, "EXIT"},
1123 { 0, NULL}};
1124 static value_string_ext ansi_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(ansi_isup_message_type_value_acro);
1125
1126 /* Table 5/Q.763 */
1127 const value_string isup_parameter_type_value[] = {
1128 /* 0 */ { PARAM_TYPE_END_OF_OPT_PARAMS, "End of optional parameters"},
1129 /* 1 */ { PARAM_TYPE_CALL_REF, "Call Reference (national use)"},
1130 /* 2 */ { PARAM_TYPE_TRANSM_MEDIUM_REQU, "Transmission medium requirement"},
1131 /* 3 */ { PARAM_TYPE_ACC_TRANSP, "Access transport"},
1132 /* 4 */ { PARAM_TYPE_CALLED_PARTY_NR, "Called party number"},
1133 /* 5 */ { PARAM_TYPE_SUBSQT_NR, "Subsequent number"},
1134 /* 6 */ { PARAM_TYPE_NATURE_OF_CONN_IND, "Nature of connection indicators"},
1135 /* 7 */ { PARAM_TYPE_FORW_CALL_IND, "Forward call indicators"},
1136 /* 8 */ { PARAM_TYPE_OPT_FORW_CALL_IND, "Optional forward call indicators"},
1137 /* 9 */ { PARAM_TYPE_CALLING_PRTY_CATEG, "Calling party's category"},
1138 /* 10 */ { PARAM_TYPE_CALLING_PARTY_NR, "Calling party number"},
1139 /* 11 */ { PARAM_TYPE_REDIRECTING_NR, "Redirecting number"},
1140 /* 12 */ { PARAM_TYPE_REDIRECTION_NR, "Redirection number"},
1141 /* 13 */ { PARAM_TYPE_CONNECTION_REQ, "Connection request"},
1142 /* 14 */ { PARAM_TYPE_INFO_REQ_IND, "Information request indicators (national use)"},
1143 /* 15 */ { PARAM_TYPE_INFO_IND, "Information indicators (national use)"},
1144 /* 16 */ { PARAM_TYPE_CONTINUITY_IND, "Continuity request"},
1145 /* 17 */ { PARAM_TYPE_BACKW_CALL_IND, "Backward call indicators"},
1146 /* 18 */ { PARAM_TYPE_CAUSE_INDICATORS, "Cause indicators"},
1147 /* 19 */ { PARAM_TYPE_REDIRECTION_INFO, "Redirection information"},
1148 /* 20 */ { 20, "Not used"},
1149 /* 21 */ { PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE, "Circuit group supervision message type"},
1150 /* 22 */ { PARAM_TYPE_RANGE_AND_STATUS, "Range and Status"},
1151 /* 23 */ { 23, "Not used"},
1152 /* 24 */ { PARAM_TYPE_FACILITY_IND, "Facility indicator"},
1153 /* 25 */ { 25, "Not used"},
1154 /* 26 */ { PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD, "Closed user group interlock code"},
1155 /* 27 */ { 27, "Not used"},
1156 /* 28 */ { 28, "Not used"},
1157 /* 29 */ { PARAM_TYPE_USER_SERVICE_INFO, "User service information"},
1158 /* 30 */ { PARAM_TYPE_SIGNALLING_POINT_CODE, "Signalling point code (national use)"},
1159 /* 31 */ { 31, "Not used"},
1160 /* 32 */ { PARAM_TYPE_USER_TO_USER_INFO, "User-to-user information"},
1161 /* 33 */ { PARAM_TYPE_CONNECTED_NR, "Connected number"},
1162 /* 34 */ { PARAM_TYPE_SUSP_RESUME_IND, "Suspend/Resume indicators"},
1163 /* 35 */ { PARAM_TYPE_TRANSIT_NETW_SELECT, "Transit network selection (national use)"},
1164 /* 36 */ { PARAM_TYPE_EVENT_INFO, "Event information"},
1165 /* 37 */ { PARAM_TYPE_CIRC_ASSIGN_MAP, "Circuit assignment map"},
1166 /* 38 */ { PARAM_TYPE_CIRC_STATE_IND, "Circuit state indicator (national use)"},
1167 /* 39 */ { PARAM_TYPE_AUTO_CONG_LEVEL, "Automatic congestion level"},
1168 /* 40 */ { PARAM_TYPE_ORIG_CALLED_NR, "Original called number"},
1169 /* 41 */ { PARAM_TYPE_OPT_BACKW_CALL_IND, "Backward call indicators"},
1170 /* 42 */ { PARAM_TYPE_USER_TO_USER_IND, "User-to-user indicators"},
1171 /* 43 */ { PARAM_TYPE_ORIG_ISC_POINT_CODE, "Origination ISC point code"},
1172 /* 44 */ { PARAM_TYPE_GENERIC_NOTIF_IND, "Generic notification indicator"},
1173 /* 45 */ { PARAM_TYPE_CALL_HIST_INFO, "Call history information"},
1174 /* 46 */ { PARAM_TYPE_ACC_DELIV_INFO, "Access delivery information"},
1175 /* 47 */ { PARAM_TYPE_NETW_SPECIFIC_FACLTY, "Network specific facility (national use)"},
1176 /* 48 */ { PARAM_TYPE_USER_SERVICE_INFO_PR, "User service information prime"},
1177 /* 49 */ { PARAM_TYPE_PROPAG_DELAY_COUNTER, "Propagation delay counter"},
1178 /* 50 */ { PARAM_TYPE_REMOTE_OPERATIONS, "Remote operations (national use)"},
1179 /* 51 */ { PARAM_TYPE_SERVICE_ACTIVATION, "Service activation"},
1180 /* 52 */ { PARAM_TYPE_USER_TELESERV_INFO, "User teleservice information"},
1181 /* 53 */ { PARAM_TYPE_TRANSM_MEDIUM_USED, "Transmission medium used"},
1182 /* 54 */ { PARAM_TYPE_CALL_DIV_INFO, "Call diversion information"},
1183 /* 55 */ { PARAM_TYPE_ECHO_CTRL_INFO, "Echo control information"},
1184 /* 56 */ { PARAM_TYPE_MSG_COMPAT_INFO, "Message compatibility information"},
1185 /* 57 */ { PARAM_TYPE_PARAM_COMPAT_INFO, "Parameter compatibility information"},
1186 /* 58 */ { PARAM_TYPE_MLPP_PRECEDENCE, "MLPP precedence"},
1187 /* 59 */ { PARAM_TYPE_MCID_REQ_IND, "MCID request indicators"},
1188 /* 60 */ { PARAM_TYPE_MCID_RSP_IND, "MCID response indicators"},
1189 /* 61 */ { PARAM_TYPE_HOP_COUNTER, "Hop counter"},
1190 /* 62 */ { PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR, "Transmission medium requirement prime"},
1191 /* 63 */ { PARAM_TYPE_LOCATION_NR, "Location number"},
1192 /* 64 */ { PARAM_TYPE_REDIR_NR_RSTRCT, "Redirection number restriction"},
1193 /* 65 */ { 65, "Not used"},
1194 /* 66 */ { 66, "Not used"},
1195 /* 67 */ { PARAM_TYPE_CALL_TRANS_REF, "Call transfer reference"},
1196 /* 68 */ { PARAM_TYPE_LOOP_PREV_IND, "Loop prevention indicators"},
1197 /* 69 */ { PARAM_TYPE_CALL_TRANS_NR, "Call transfer number"},
1198 /* 70 */ { 70, "Not used"},
1199 /* 71 */ { 71, "Not used"},
1200 /* 72 */ { 72, "Not used"},
1201 /* 73 */ { 73, "Not used"},
1202 /* 74 */ { 74, "Not used"},
1203 /* 75 */ { PARAM_TYPE_CCSS, "CCSS"},
1204 /* 76 */ { PARAM_TYPE_FORW_GVNS, "Forward GVNS"},
1205 /* 77 */ { PARAM_TYPE_BACKW_GVNS, "Backward GVNS"},
1206 /* 78 */ { PARAM_TYPE_REDIRECT_CAPAB, "Redirect capability (reserved for national use)"},
1207 /* 79 */ { 79, "Not used"},
1208 /* 80 */ { 80, "Not used"},
1209 /* 81 */ { 81, "Not used"},
1210 /* 82 */ { 82, "Not used"},
1211 /* 83 */ { 83, "Not used"},
1212 /* 84 */ { 84, "Not used"},
1213 /* 85 */ { 85, "Not used"},
1214 /* 86 */ { 86, "Not used"},
1215 /* 87 */ { 87, "Not used"},
1216 /* 88 */ { 88, "Not used"},
1217 /* 89 */ { 89, "Not used"},
1218 /* 90 */ { 90, "Not used"},
1219 /* 91 */ { PARAM_TYPE_NETW_MGMT_CTRL, "Network management controls"},
1220 /* 92 */ { 92, "Not used"},
1221 /* 93 */ { 93, "Not used"},
1222 /* 94 */ { 94, "Not used"},
1223 /* 95 */ { 95, "Not used"},
1224 /* 96 */ { 96, "Not used"},
1225 /* 97 */ { 97, "Not used"},
1226 /* 98 */ { 98, "Not used"},
1227 /* 99 */ { 99, "Not used"},
1228 /* 100 */ { 100, "Not used"},
1229 /* 101 */ { PARAM_TYPE_CORRELATION_ID, "Correlation id"},
1230 /* 102 */ { PARAM_TYPE_SCF_ID, "SCF id"},
1231 /* 103 */ { 103, "Not used"},
1232 /* 104 */ { 104, "Not used"},
1233 /* 105 */ { 105, "Not used"},
1234 /* 106 */ { 106, "Not used"},
1235 /* 107 */ { 107, "Not used"},
1236 /* 108 */ { 108, "Not used"},
1237 /* 109 */ { 109, "Not used"},
1238 /* 110 */ { PARAM_TYPE_CALL_DIV_TREAT_IND, "Call diversion treatment indicators"},
1239 /* 111 */ { PARAM_TYPE_CALLED_IN_NR, "Called IN number"},
1240 /* 112 */ { PARAM_TYPE_CALL_OFF_TREAT_IND, "Call offering treatment indicators"},
1241 /* 113 */ { PARAM_TYPE_CHARGED_PARTY_IDENT, "Charged party identification (national use)"},
1242 /* 114 */ { PARAM_TYPE_CONF_TREAT_IND, "Conference treatment indicators"},
1243 /* 115 */ { PARAM_TYPE_DISPLAY_INFO, "Display information"},
1244 /* 116 */ { PARAM_TYPE_UID_ACTION_IND, "UID action indicators"},
1245 /* 117 */ { PARAM_TYPE_UID_CAPAB_IND, "UID capability indicators"},
1246 /* 119 */ { PARAM_TYPE_REDIRECT_COUNTER, "Redirect counter (reserved for national use)"},
1247 /* 120 */ { PARAM_TYPE_APPLICATON_TRANS, "Application transport"},
1248 /* 121 */ { PARAM_TYPE_COLLECT_CALL_REQ, "Collect call request"},
1249 /* 122 */ { 122, "Not used"},
1250 /* 123 */ { 123, "Not used"},
1251 /* 124 */ { 124, "Not used"},
1252 /* 125 */ { 125, "Not used"},
1253 /* 126 */ { 126, "Not used"},
1254 /* 127 */ { 127, "Not used"},
1255 /* 128 */ { 128, "Not used"},
1256 /* 129 */ { 129, "Not used"},
1257 /* 130 */ { 130, "Not used"},
1258 /* 142 */ { 142, "Forward CAT indicators"}, /* Q.763 Amendment 6(10/2009) */
1259 /* 143 */ { 143, "Backward CAT indicators"}, /* Q.763 Amendment 6(10/2009) */
1260 /* 150 */ { 150, "Automatic re-routing" }, /* Q.763 Amendment 3(04/2004) */
1261 /* 166 */ { 166, "IEPS call information" }, /* Q.763 Amendment 4(01/2006) */
1262 /* 168 */ { 168, "VED information" }, /* Q.763 Amendment 5(09/2006) */
1263 /* 192 */ { PARAM_TYPE_GENERIC_NR, "Generic number"},
1264 /* 193 */ { PARAM_TYPE_GENERIC_DIGITS, "Generic digits (national use)"},
1265 { 0, NULL}};
1266 static value_string_ext isup_parameter_type_value_ext = VALUE_STRING_EXT_INIT(isup_parameter_type_value);
1267
1268 #define JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER 125 /* 7D */
1269 #define JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF 139 /* 8B */
1270 #define JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF 140 /* 8C */
1271 #define JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND 215 /* D7 */
1272 #define JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND 236 /* EC */
1273 #define JAPAN_ISUP_PARAM_NETWORK_POI_CA 238 /* EE */
1274 #define JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO 241 /* F1 */
1275 #define JAPAN_ISUP_PARAM_CHARGE_INF_DELAY 242 /* F2 */
1276
1277 #define JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT 243 /* F3 */
1278 #define JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL 245 /* F5 */
1279 #define JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER 249 /* F9 */
1280 #define JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE 250 /* FA */
1281 #define JAPAN_ISUP_PARAM_TYPE_CHARGE_INF 251 /* FB */
1282 #define JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO 253 /* FD */
1283
1284 static const value_string japan_isup_parameter_type_value[] = {
1285 /* 0 */ { PARAM_TYPE_END_OF_OPT_PARAMS, "End of optional parameters"},
1286 /* 1 */ { PARAM_TYPE_CALL_REF, "Call Reference (national use)"},
1287 /* 2 */ { PARAM_TYPE_TRANSM_MEDIUM_REQU, "Transmission medium requirement"},
1288 /* 3 */ { PARAM_TYPE_ACC_TRANSP, "Access transport"},
1289 /* 4 */ { PARAM_TYPE_CALLED_PARTY_NR, "Called party number"},
1290 /* 5 */ { PARAM_TYPE_SUBSQT_NR, "Subsequent number"},
1291 /* 6 */ { PARAM_TYPE_NATURE_OF_CONN_IND, "Nature of connection indicators"},
1292 /* 7 */ { PARAM_TYPE_FORW_CALL_IND, "Forward call indicators"},
1293 /* 8 */ { PARAM_TYPE_OPT_FORW_CALL_IND, "Optional forward call indicators"},
1294 /* 9 */ { PARAM_TYPE_CALLING_PRTY_CATEG, "Calling party's category"},
1295 /* 10 */ { PARAM_TYPE_CALLING_PARTY_NR, "Calling party number"},
1296 /* 11 */ { PARAM_TYPE_REDIRECTING_NR, "Redirecting number"},
1297 /* 12 */ { PARAM_TYPE_REDIRECTION_NR, "Redirection number"},
1298 /* 13 */ { PARAM_TYPE_CONNECTION_REQ, "Connection request"},
1299 /* 14 */ { PARAM_TYPE_INFO_REQ_IND, "Information request indicators (national use)"},
1300 /* 15 */ { PARAM_TYPE_INFO_IND, "Information indicators (national use)"},
1301 /* 16 */ { PARAM_TYPE_CONTINUITY_IND, "Continuity request"},
1302 /* 17 */ { PARAM_TYPE_BACKW_CALL_IND, "Backward call indicators"},
1303 /* 18 */ { PARAM_TYPE_CAUSE_INDICATORS, "Cause indicators"},
1304 /* 19 */ { PARAM_TYPE_REDIRECTION_INFO, "Redirection information"},
1305 /* 20 */ { 20, "Not used"},
1306 /* 21 */ { PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE, "Circuit group supervision message type"},
1307 /* 22 */ { PARAM_TYPE_RANGE_AND_STATUS, "Range and Status"},
1308 /* 23 */ { 23, "Not used"},
1309 /* 24 */ { PARAM_TYPE_FACILITY_IND, "Facility indicator"},
1310 /* 25 */ { 25, "Not used"},
1311 /* 26 */ { PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD, "Closed user group interlock code"},
1312 /* 27 */ { 27, "Not used"},
1313 /* 28 */ { 28, "Not used"},
1314 /* 29 */ { PARAM_TYPE_USER_SERVICE_INFO, "User service information"},
1315 /* 30 */ { PARAM_TYPE_SIGNALLING_POINT_CODE, "Signalling point code (national use)"},
1316 /* 31 */ { 31, "Not used"},
1317 /* 32 */ { PARAM_TYPE_USER_TO_USER_INFO, "User-to-user information"},
1318 /* 33 */ { PARAM_TYPE_CONNECTED_NR, "Connected number"},
1319 /* 34 */ { PARAM_TYPE_SUSP_RESUME_IND, "Suspend/Resume indicators"},
1320 /* 35 */ { PARAM_TYPE_TRANSIT_NETW_SELECT, "Transit network selection (national use)"},
1321 /* 36 */ { PARAM_TYPE_EVENT_INFO, "Event information"},
1322 /* 37 */ { PARAM_TYPE_CIRC_ASSIGN_MAP, "Circuit assignment map"},
1323 /* 38 */ { PARAM_TYPE_CIRC_STATE_IND, "Circuit state indicator (national use)"},
1324 /* 39 */ { PARAM_TYPE_AUTO_CONG_LEVEL, "Automatic congestion level"},
1325 /* 40 */ { PARAM_TYPE_ORIG_CALLED_NR, "Original called number"},
1326 /* 41 */ { PARAM_TYPE_OPT_BACKW_CALL_IND, "Backward call indicators"},
1327 /* 42 */ { PARAM_TYPE_USER_TO_USER_IND, "User-to-user indicators"},
1328 /* 43 */ { PARAM_TYPE_ORIG_ISC_POINT_CODE, "Origination ISC point code"},
1329 /* 44 */ { PARAM_TYPE_GENERIC_NOTIF_IND, "Generic notification indicator"},
1330 /* 45 */ { PARAM_TYPE_CALL_HIST_INFO, "Call history information"},
1331 /* 46 */ { PARAM_TYPE_ACC_DELIV_INFO, "Access delivery information"},
1332 /* 47 */ { PARAM_TYPE_NETW_SPECIFIC_FACLTY, "Network specific facility (national use)"},
1333 /* 48 */ { PARAM_TYPE_USER_SERVICE_INFO_PR, "User service information prime"},
1334 /* 49 */ { PARAM_TYPE_PROPAG_DELAY_COUNTER, "Propagation delay counter"},
1335 /* 50 */ { PARAM_TYPE_REMOTE_OPERATIONS, "Remote operations (national use)"},
1336 /* 51 */ { PARAM_TYPE_SERVICE_ACTIVATION, "Service activation"},
1337 /* 52 */ { PARAM_TYPE_USER_TELESERV_INFO, "User teleservice information"},
1338 /* 53 */ { PARAM_TYPE_TRANSM_MEDIUM_USED, "Transmission medium used"},
1339 /* 54 */ { PARAM_TYPE_CALL_DIV_INFO, "Call diversion information"},
1340 /* 55 */ { PARAM_TYPE_ECHO_CTRL_INFO, "Echo control information"},
1341 /* 56 */ { PARAM_TYPE_MSG_COMPAT_INFO, "Message compatibility information"},
1342 /* 57 */ { PARAM_TYPE_PARAM_COMPAT_INFO, "Parameter compatibility information"},
1343 /* 58 */ { PARAM_TYPE_MLPP_PRECEDENCE, "MLPP precedence"},
1344 /* 59 */ { PARAM_TYPE_MCID_REQ_IND, "MCID request indicators"},
1345 /* 60 */ { PARAM_TYPE_MCID_RSP_IND, "MCID response indicators"},
1346 /* 61 */ { PARAM_TYPE_HOP_COUNTER, "Hop counter"},
1347 /* 62 */ { PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR, "Transmission medium requirement prime"},
1348 /* 63 */ { PARAM_TYPE_LOCATION_NR, "Location number"},
1349 /* 64 */ { PARAM_TYPE_REDIR_NR_RSTRCT, "Redirection number restriction"},
1350 /* 65 */ { 65, "Not used"},
1351 /* 66 */ { 66, "Not used"},
1352 /* 67 */ { PARAM_TYPE_CALL_TRANS_REF, "Call transfer reference"},
1353 /* 68 */ { PARAM_TYPE_LOOP_PREV_IND, "Loop prevention indicators"},
1354 /* 69 */ { PARAM_TYPE_CALL_TRANS_NR, "Call transfer number"},
1355 /* 70 */ { 70, "Not used"},
1356 /* 71 */ { 71, "Not used"},
1357 /* 72 */ { 72, "Not used"},
1358 /* 73 */ { 73, "Not used"},
1359 /* 74 */ { 74, "Not used"},
1360 /* 75 */ { PARAM_TYPE_CCSS, "CCSS"},
1361 /* 76 */ { PARAM_TYPE_FORW_GVNS, "Forward GVNS"},
1362 /* 77 */ { PARAM_TYPE_BACKW_GVNS, "Backward GVNS"},
1363 /* 78 */ { PARAM_TYPE_REDIRECT_CAPAB, "Redirect capability (reserved for national use)"},
1364 /* 79 */ { 79, "Not used"},
1365 /* 80 */ { 80, "Not used"},
1366 /* 81 */ { 81, "Not used"},
1367 /* 82 */ { 82, "Not used"},
1368 /* 83 */ { 83, "Not used"},
1369 /* 84 */ { 84, "Not used"},
1370 /* 85 */ { 85, "Not used"},
1371 /* 86 */ { 86, "Not used"},
1372 /* 87 */ { 87, "Not used"},
1373 /* 88 */ { 88, "Not used"},
1374 /* 89 */ { 89, "Not used"},
1375 /* 90 */ { 90, "Not used"},
1376 /* 101 */ { PARAM_TYPE_CORRELATION_ID, "Correlation id"},
1377 /* 102 */ { PARAM_TYPE_SCF_ID, "SCF id"},
1378 /* 103 */ { 103, "Not used"},
1379 /* 104 */ { 104, "Not used"},
1380 /* 105 */ { 105, "Not used"},
1381 /* 106 */ { 106, "Not used"},
1382 /* 107 */ { 107, "Not used"},
1383 /* 108 */ { 108, "Not used"},
1384 /* 109 */ { 109, "Not used"},
1385 /* 110 */ { PARAM_TYPE_CALL_DIV_TREAT_IND, "Call diversion treatment indicators"},
1386 /* 111 */ { PARAM_TYPE_CALLED_IN_NR, "Called IN number"},
1387 /* 112 */ { PARAM_TYPE_CALL_OFF_TREAT_IND, "Call offering treatment indicators"},
1388 /* 113 */ { PARAM_TYPE_CHARGED_PARTY_IDENT, "Charged party identification (national use)"},
1389 /* 114 */ { PARAM_TYPE_CONF_TREAT_IND, "Conference treatment indicators"},
1390 /* 115 */ { PARAM_TYPE_DISPLAY_INFO, "Display information"},
1391 /* 116 */ { PARAM_TYPE_UID_ACTION_IND, "UID action indicators"},
1392 /* 117 */ { PARAM_TYPE_UID_CAPAB_IND, "UID capability indicators"},
1393 /* 119 */ { PARAM_TYPE_REDIRECT_COUNTER, "Redirect counter (reserved for national use)"},
1394 /* 120 */ { PARAM_TYPE_APPLICATON_TRANS, "Application transport"},
1395 /* 121 */ { PARAM_TYPE_COLLECT_CALL_REQ, "Collect call request"},
1396 /* 122 */ { 122, "Not used"},
1397 /* 123 */ { 123, "Not used"},
1398 /* 124 */ { 124, "Not used"},
1399 /* 125 */ { JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER, "Called Directory Number"}, /* 125 7D */
1400 /* 126 */ { 126, "Not used"},
1401 /* 127 */ { 127, "Not used"},
1402 /* 128 */ { 128, "Not used"},
1403 /* 129 */ { 129, "Not used"},
1404 /* 130 */ { 130, "Not used"},
1405 /* 131 */ { 131, "Not used"},
1406 /* 132 */ { 132, "Not used"},
1407 /* 133 */ { 133, "Not used"},
1408 /* 134 */ { 134, "Not used"},
1409 /* 135 */ { 135, "Not used"},
1410 /* 136 */ { 136, "Not used"},
1411 /* 137 */ { 137, "Not used"},
1412 /* 138 */ { 138, "Not used"},
1413 /* 139 */ { JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF, "Redirect forward information"}, /* 8B */
1414 /* 140 */ { JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF, "Redirect Backward information"}, /* 8C */
1415
1416 /* 192 */ { PARAM_TYPE_GENERIC_NR, "Generic number"},
1417 /* 193 */ { PARAM_TYPE_GENERIC_DIGITS, "Generic digits (national use)"},
1418 { JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND, "Emergency Call indicator"}, /* 215 EC */
1419 { JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND, "Emergency Call Information indicator"}, /* 236 EC */
1420 { JAPAN_ISUP_PARAM_NETWORK_POI_CA, "Network POI-CA"}, /* 238 EE */
1421 { JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO, "Carrier Information transfer"}, /* 241 F1 */
1422 { JAPAN_ISUP_PARAM_CHARGE_INF_DELAY, "Charge Information Delay"}, /* 242 F2 */
1423 { JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT, "Additional party's category"}, /* 243 F3 */
1424 { JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL, "Reason For CLIP Failure"}, /* 245 F5 */
1425 { JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER, "Contractor Number"}, /* 249 F9 */
1426 { JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE, "Charge information type"}, /* 250 FA */
1427 { JAPAN_ISUP_PARAM_TYPE_CHARGE_INF, "Charge information"}, /* 250 FA */
1428 { JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO, "Charge area information"}, /* 253 FD */
1429
1430 { 0, NULL}};
1431 static value_string_ext japan_isup_parameter_type_value_ext = VALUE_STRING_EXT_INIT(japan_isup_parameter_type_value);
1432
1433 static const value_string ansi_isup_parameter_type_value[] = {
1434 /* 0 */ { PARAM_TYPE_END_OF_OPT_PARAMS, "End of optional parameters"},
1435 /* 1 */ { PARAM_TYPE_CALL_REF, "Call Reference (national use)"},
1436 /* 2 */ { PARAM_TYPE_TRANSM_MEDIUM_REQU, "Transmission medium requirement"},
1437 /* 3 */ { PARAM_TYPE_ACC_TRANSP, "Access transport"},
1438 /* 4 */ { PARAM_TYPE_CALLED_PARTY_NR, "Called party number"},
1439 /* 5 */ { PARAM_TYPE_SUBSQT_NR, "Subsequent number"},
1440 /* 6 */ { PARAM_TYPE_NATURE_OF_CONN_IND, "Nature of connection indicators"},
1441 /* 7 */ { PARAM_TYPE_FORW_CALL_IND, "Forward call indicators"},
1442 /* 8 */ { PARAM_TYPE_OPT_FORW_CALL_IND, "Optional forward call indicators"},
1443 /* 9 */ { PARAM_TYPE_CALLING_PRTY_CATEG, "Calling party's category"},
1444 /* 10 */ { PARAM_TYPE_CALLING_PARTY_NR, "Calling party number"},
1445 /* 11 */ { PARAM_TYPE_REDIRECTING_NR, "Redirecting number"},
1446 /* 12 */ { PARAM_TYPE_REDIRECTION_NR, "Redirection number"},
1447 /* 13 */ { PARAM_TYPE_CONNECTION_REQ, "Connection request"},
1448 /* 14 */ { PARAM_TYPE_INFO_REQ_IND, "Information request indicators (national use)"},
1449 /* 15 */ { PARAM_TYPE_INFO_IND, "Information indicators (national use)"},
1450 /* 16 */ { PARAM_TYPE_CONTINUITY_IND, "Continuity request"},
1451 /* 17 */ { PARAM_TYPE_BACKW_CALL_IND, "Backward call indicators"},
1452 /* 18 */ { PARAM_TYPE_CAUSE_INDICATORS, "Cause indicators"},
1453 /* 19 */ { PARAM_TYPE_REDIRECTION_INFO, "Redirection information"},
1454 /* 20 */ { 20, "Not used"},
1455 /* 21 */ { PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE, "Circuit group supervision message type"},
1456 /* 22 */ { PARAM_TYPE_RANGE_AND_STATUS, "Range and Status"},
1457 /* 23 */ { 23, "Not used"},
1458 /* 24 */ { PARAM_TYPE_FACILITY_IND, "Facility indicator"},
1459 /* 25 */ { 25, "Not used"},
1460 /* 26 */ { PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD, "Closed user group interlock code"},
1461 /* 27 */ { 27, "Not used"},
1462 /* 28 */ { 28, "Not used"},
1463 /* 29 */ { PARAM_TYPE_USER_SERVICE_INFO, "User service information"},
1464 /* 30 */ { PARAM_TYPE_SIGNALLING_POINT_CODE, "Signalling point code (national use)"},
1465 /* 31 */ { 31, "Not used"},
1466 /* 32 */ { PARAM_TYPE_USER_TO_USER_INFO, "User-to-user information"},
1467 /* 33 */ { PARAM_TYPE_CONNECTED_NR, "Connected number"},
1468 /* 34 */ { PARAM_TYPE_SUSP_RESUME_IND, "Suspend/Resume indicators"},
1469 /* 35 */ { PARAM_TYPE_TRANSIT_NETW_SELECT, "Transit network selection (national use)"},
1470 /* 36 */ { PARAM_TYPE_EVENT_INFO, "Event information"},
1471 /* 37 */ { PARAM_TYPE_CIRC_ASSIGN_MAP, "Circuit assignment map"},
1472 /* 38 */ { PARAM_TYPE_CIRC_STATE_IND, "Circuit state indicator (national use)"},
1473 /* 39 */ { PARAM_TYPE_AUTO_CONG_LEVEL, "Automatic congestion level"},
1474 /* 40 */ { PARAM_TYPE_ORIG_CALLED_NR, "Original called number"},
1475 /* 41 */ { PARAM_TYPE_OPT_BACKW_CALL_IND, "Backward call indicators"},
1476 /* 42 */ { PARAM_TYPE_USER_TO_USER_IND, "User-to-user indicators"},
1477 /* 43 */ { PARAM_TYPE_ORIG_ISC_POINT_CODE, "Origination ISC point code"},
1478 /* 44 */ { PARAM_TYPE_GENERIC_NOTIF_IND, "Generic notification indicator"},
1479 /* 45 */ { PARAM_TYPE_CALL_HIST_INFO, "Call history information"},
1480 /* 46 */ { PARAM_TYPE_ACC_DELIV_INFO, "Access delivery information"},
1481 /* 47 */ { PARAM_TYPE_NETW_SPECIFIC_FACLTY, "Network specific facility (national use)"},
1482 /* 48 */ { PARAM_TYPE_USER_SERVICE_INFO_PR, "User service information prime"},
1483 /* 49 */ { PARAM_TYPE_PROPAG_DELAY_COUNTER, "Propagation delay counter"},
1484 /* 50 */ { PARAM_TYPE_REMOTE_OPERATIONS, "Remote operations (national use)"},
1485 /* 51 */ { PARAM_TYPE_SERVICE_ACTIVATION, "Service activation"},
1486 /* 52 */ { PARAM_TYPE_USER_TELESERV_INFO, "User teleservice information"},
1487 /* 53 */ { PARAM_TYPE_TRANSM_MEDIUM_USED, "Transmission medium used"},
1488 /* 54 */ { PARAM_TYPE_CALL_DIV_INFO, "Call diversion information"},
1489 /* 55 */ { PARAM_TYPE_ECHO_CTRL_INFO, "Echo control information"},
1490 /* 56 */ { PARAM_TYPE_MSG_COMPAT_INFO, "Message compatibility information"},
1491 /* 57 */ { PARAM_TYPE_PARAM_COMPAT_INFO, "Parameter compatibility information"},
1492 /* 58 */ { PARAM_TYPE_MLPP_PRECEDENCE, "MLPP precedence"},
1493 /* 59 */ { PARAM_TYPE_MCID_REQ_IND, "MCID request indicators"},
1494 /* 60 */ { PARAM_TYPE_MCID_RSP_IND, "MCID response indicators"},
1495 /* 61 */ { PARAM_TYPE_HOP_COUNTER, "Hop counter"},
1496 /* 62 */ { PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR, "Transmission medium requirement prime"},
1497 /* 63 */ { PARAM_TYPE_LOCATION_NR, "Location number"},
1498 /* 64 */ { PARAM_TYPE_REDIR_NR_RSTRCT, "Redirection number restriction"},
1499 /* 65 */ { 65, "Not used"},
1500 /* 66 */ { 66, "Not used"},
1501 /* 67 */ { PARAM_TYPE_CALL_TRANS_REF, "Call transfer reference"},
1502 /* 68 */ { PARAM_TYPE_LOOP_PREV_IND, "Loop prevention indicators"},
1503 /* 69 */ { PARAM_TYPE_CALL_TRANS_NR, "Call transfer number"},
1504 /* 70 */ { 70, "Not used"},
1505 /* 71 */ { 71, "Not used"},
1506 /* 72 */ { 72, "Not used"},
1507 /* 73 */ { 73, "Not used"},
1508 /* 74 */ { 74, "Not used"},
1509 /* 75 */ { PARAM_TYPE_CCSS, "CCSS"},
1510 /* 76 */ { PARAM_TYPE_FORW_GVNS, "Forward GVNS"},
1511 /* 77 */ { PARAM_TYPE_BACKW_GVNS, "Backward GVNS"},
1512 /* 78 */ { PARAM_TYPE_REDIRECT_CAPAB, "Redirect capability (reserved for national use)"},
1513 /* 79 */ { 79, "Not used"},
1514 /* 80 */ { 80, "Not used"},
1515 /* 81 */ { 81, "Not used"},
1516 /* 82 */ { 82, "Not used"},
1517 /* 83 */ { 83, "Not used"},
1518 /* 84 */ { 84, "Not used"},
1519 /* 85 */ { 85, "Not used"},
1520 /* 86 */ { 86, "Not used"},
1521 /* 87 */ { 87, "Not used"},
1522 /* 88 */ { 88, "Not used"},
1523 /* 89 */ { 89, "Not used"},
1524 /* 90 */ { 90, "Not used"},
1525 /* 101 */ { PARAM_TYPE_CORRELATION_ID, "Correlation id"},
1526 /* 102 */ { PARAM_TYPE_SCF_ID, "SCF id"},
1527 /* 103 */ { 103, "Not used"},
1528 /* 104 */ { 104, "Not used"},
1529 /* 105 */ { 105, "Not used"},
1530 /* 106 */ { 106, "Not used"},
1531 /* 107 */ { 107, "Not used"},
1532 /* 108 */ { 108, "Not used"},
1533 /* 109 */ { 109, "Not used"},
1534 /* 110 */ { PARAM_TYPE_CALL_DIV_TREAT_IND, "Call diversion treatment indicators"},
1535 /* 111 */ { PARAM_TYPE_CALLED_IN_NR, "Called IN number"},
1536 /* 112 */ { PARAM_TYPE_CALL_OFF_TREAT_IND, "Call offering treatment indicators"},
1537 /* 113 */ { PARAM_TYPE_CHARGED_PARTY_IDENT, "Charged party identification (national use)"},
1538 /* 114 */ { PARAM_TYPE_CONF_TREAT_IND, "Conference treatment indicators"},
1539 /* 115 */ { PARAM_TYPE_DISPLAY_INFO, "Display information"},
1540 /* 116 */ { PARAM_TYPE_UID_ACTION_IND, "UID action indicators"},
1541 /* 117 */ { PARAM_TYPE_UID_CAPAB_IND, "UID capability indicators"},
1542 /* 119 */ { PARAM_TYPE_REDIRECT_COUNTER, "Redirect counter (reserved for national use)"},
1543 /* 120 */ { PARAM_TYPE_APPLICATON_TRANS, "Application transport"},
1544 /* 121 */ { PARAM_TYPE_COLLECT_CALL_REQ, "Collect call request"},
1545 /* 122 */ { 122, "Not used"},
1546 /* 123 */ { 123, "Not used"},
1547 /* 124 */ { 124, "Not used"},
1548 /* 125 */ { 125, "Not used"},
1549 /* 126 */ { 126, "Not used"},
1550 /* 127 */ { 127, "Not used"},
1551 /* 128 */ { 128, "Not used"},
1552 /* 129 */ { PARAM_TYPE_CALLING_GEODETIC_LOCATION, "Calling geodetic location"},
1553 /* 130 */ { 130, "Not used"},
1554
1555 /* 192 */ { PARAM_TYPE_GENERIC_NR, "Generic number"},
1556 /* 193 */ { PARAM_TYPE_GENERIC_DIGITS, "Generic digits (national use)"},
1557 #if 0 /* XXX: Dups of below */
1558 { PARAM_TYPE_JURISDICTION, "Jurisdiction"},
1559 { PARAM_TYPE_GENERIC_NAME, "Generic name"},
1560 { PARAM_TYPE_ORIG_LINE_INFO, "Originating line info"},
1561 #endif
1562 /* 194 */ { ANSI_ISUP_PARAM_TYPE_OPER_SERV_INF, "Operator Services information"},
1563 /* 195 */ { ANSI_ISUP_PARAM_TYPE_EGRESS, "Egress"},
1564 /* 196 */ { ANSI_ISUP_PARAM_TYPE_JURISDICTION, "Jurisdiction"},
1565 /* 197 */ { ANSI_ISUP_PARAM_TYPE_CARRIER_ID, "Carrier identification"},
1566 /* 198 */ { ANSI_ISUP_PARAM_TYPE_BUSINESS_GRP, "Business group"},
1567 /* 199 */ { ANSI_ISUP_PARAM_TYPE_GENERIC_NAME, "Generic name"},
1568 /* 225 */ { ANSI_ISUP_PARAM_TYPE_NOTIF_IND, "Notification indicator"},
1569 { ANSI_ISUP_PARAM_TYPE_CG_CHAR_IND, "Circuit group characteristic indicator"},
1570 { ANSI_ISUP_PARAM_TYPE_CVR_RESP_IND, "Circuit validation response indicator"},
1571 { ANSI_ISUP_PARAM_TYPE_OUT_TRK_GRP_NM, "Outgoing trunk group number"},
1572 { ANSI_ISUP_PARAM_TYPE_CI_NAME_IND, "Circuit identification name"},
1573 { ANSI_ISUP_PARAM_CLLI_CODE, "COMMON LANGUAGE location identification (CLLI) code"},
1574 { ANSI_ISUP_PARAM_ORIG_LINE_INF, "Originating line information"},
1575 { ANSI_ISUP_PARAM_CHRG_NO, "Charge number"},
1576 { ANSI_ISUP_PARAM_SERV_CODE_IND, "Service code indicator"},
1577 { ANSI_ISUP_PARAM_SPEC_PROC_REQ, "Special processing request"},
1578 { ANSI_ISUP_PARAM_CARRIER_SEL_INF, "Carrier selection information"},
1579 { ANSI_ISUP_PARAM_NET_TRANS, "Network transport"},
1580 { 0, NULL}};
1581 static value_string_ext ansi_isup_parameter_type_value_ext = VALUE_STRING_EXT_INIT(ansi_isup_parameter_type_value);
1582
1583 #define CIC_LENGTH 2
1584 #define BICC_CIC_LENGTH 4
1585 #define MESSAGE_TYPE_LENGTH 1
1586 #define COMMON_HEADER_LENGTH (CIC_LENGTH + MESSAGE_TYPE_LENGTH)
1587 #define BICC_COMMON_HEADER_LENGTH (BICC_CIC_LENGTH + MESSAGE_TYPE_LENGTH)
1588
1589 #define MAXDIGITS 32 /* Max number of address digits */
1590 #define MAXGNAME 15 /* Max number of characters in generic name */
1591
1592 #define PARAMETER_TYPE_LENGTH 1
1593 #define PARAMETER_POINTER_LENGTH 1
1594 #define PARAMETER_LENGTH_IND_LENGTH 1
1595
1596 /* All following parameter length definitions are WITHOUT the parameter type byte and length indicator for optional parameters*/
1597 #define PARAMETER_NAME_LENGTH 1
1598 #define PARAMETER_LENGTH_IND_LENGTH 1
1599 #define ACCESS_DELIVERY_INFO_LENGTH 1
1600 #define AUTO_CONGEST_LEVEL_LENGTH 1
1601 #define BACKWARD_CALL_IND_LENGTH 2
1602 #define BACKWARD_GVNS_LENGTH 1
1603 #define CALL_DIV_INFO_LENGTH 1
1604 #define CALL_DIV_TREATMENT_IND_LENGTH 1
1605 #define CALL_HISTORY_INFO_LENGTH 2
1606 #define CALL_OFFERING_TREATMENT_IND_LENGTH 1
1607 #define CALL_REFERENCE_LENGTH 5
1608 #define CALL_TRANSFER_REF_LENGTH 1
1609 #define CALLING_PRTYS_CATEGORY_LENGTH 1
1610 #define CCSS_LENGTH 1
1611 #define CIRCUIT_ASSIGNMENT_MAP_LENGTH 5
1612 #define CIRC_GRP_SV_MSG_TYPE_LENGTH 1
1613 #define CLOSED_USR_GRP_INTERLOCK_CODE_LENGTH 4
1614 #define COLLECT_CALL_REQUEST_LENGTH 1
1615 #define CONFERENCE_TREATMENT_IND_LENGTH 1
1616 #define CONNECTION_REQUEST_LENGTH 7
1617 #define CONTINUITY_IND_LENGTH 1
1618 #define ECHO_CONTROL_INFO_LENGTH 1
1619 #define END_OF_OPT_PART_LENGTH 1
1620 #define EVENT_INFO_LENGTH 1
1621 #define FACILITY_IND_LENGTH 1
1622 #define FORWARD_CALL_IND_LENGTH 2
1623 #define GENERIC_NOTIFICATION_IND_LENGTH 1
1624 #define HOP_COUNTER_LENGTH 1
1625 #define ORIG_LINE_INFO_LENGTH 1
1626 #define INFO_IND_LENGTH 2
1627 #define INFO_REQUEST_IND_LENGTH 2
1628 #define LOOP_PREVENTION_IND_LENGTH 1
1629 #define MCID_REQUEST_IND_LENGTH 1
1630 #define MCID_RESPONSE_IND_LENGTH 1
1631 #define MLPP_PRECEDENCE_LENGTH 1
1632 #define NATURE_OF_CONNECTION_IND_LENGTH 1
1633 #define NETWORK_MANAGEMENT_CONTROLS_LENGTH 1
1634 #define OPTIONAL_BACKWARD_CALL_IND_LENGTH 1
1635 #define OPTIONAL_FORWARD_CALL_IND_LENGTH 1
1636 #define ORIGINAL_ISC_POINT_CODE_LENGTH 2
1637 #define PROPAGATION_DELAY_COUNT_LENGTH 2
1638 #define REDIRECTION_NUMBER_LENGTH 2
1639 #define REDIRECTION_INFO_LENGTH 2
1640 #define REDIRECTION_NUMBER_RESTRICTION_LENGTH 1
1641 #define SIGNALLING_POINT_CODE_LENGTH 2
1642 #define SUSPEND_RESUME_IND_LENGTH 1
1643 #define TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH 1
1644 #define TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH 1
1645 #define TRANSMISSION_MEDIUM_USED_LENGTH 1
1646 #define UID_ACTION_IND_LENGTH 1
1647 #define UID_CAPABILITY_IND_LENGTH 1
1648 #define USER_TELESERVICE_INFO_LENGTH 2
1649 #define USER_TO_USER_IND_LENGTH 1
1650 #define RANGE_LENGTH 1
1651
1652 #define CVR_RESP_IND_LENGTH 1
1653 #define CG_CHAR_IND_LENGTH 1
1654 #define CI_NAME_IND 28
1655 #define CLLI_CODE_LENGTH 13
1656
1657 #define CALL_ID_LENGTH 3 /* for parameter Call Reference */
1658 #define SPC_LENGTH 2 /* for parameter Call Reference, Connection request */
1659 #define LOCAL_REF_LENGTH 3 /* for parameter Connection request */
1660 #define PROTOCOL_CLASS_LENGTH 1 /* for parameter Connection request */
1661 #define CREDIT_LENGTH 1 /* for parameter Connection request */
1662
1663 #define CIC_OFFSET 0
1664 #define BICC_CIC_OFFSET 0
1665
1666 #define NO_SATELLITE_CIRCUIT_IN_CONNECTION 0
1667 #define ONE_SATELLITE_CIRCUIT_IN_CONNECTION 1
1668 #define TWO_SATELLITE_CIRCUIT_IN_CONNECTION 2
1669 static const value_string isup_satellite_ind_value[] = {
1670 { NO_SATELLITE_CIRCUIT_IN_CONNECTION, "No Satellite circuit in connection"},
1671 { ONE_SATELLITE_CIRCUIT_IN_CONNECTION, "One Satellite circuit in connection"},
1672 { TWO_SATELLITE_CIRCUIT_IN_CONNECTION, "Two Satellite circuits in connection"},
1673 { 0, NULL}};
1674
1675 #define CONTINUITY_CHECK_NOT_REQUIRED 0
1676 #define CONTINUITY_CHECK_REQUIRED 1
1677 #define CONTINUITY_CHECK_ON_A_PREVIOUS_CIRCUIT 2
1678 #define CONTINUITY_CHECK_SPARE 3
1679 static const value_string isup_continuity_check_ind_value[] = {
1680 { CONTINUITY_CHECK_NOT_REQUIRED, "Continuity check not required"},
1681 { CONTINUITY_CHECK_REQUIRED, "Continuity check required on this circuit"},
1682 { CONTINUITY_CHECK_ON_A_PREVIOUS_CIRCUIT , "Continuity check performed on a previous circuit"},
1683 { CONTINUITY_CHECK_SPARE , "spare"},
1684 { 0, NULL}};
1685
1686 static const value_string bicc_continuity_check_ind_value[] = {
1687 { CONTINUITY_CHECK_NOT_REQUIRED, "no COT to be expected"},
1688 { CONTINUITY_CHECK_REQUIRED, "reserved"},
1689 { CONTINUITY_CHECK_ON_A_PREVIOUS_CIRCUIT , "COT to be expected"},
1690 { CONTINUITY_CHECK_SPARE , "spare"},
1691 { 0, NULL}};
1692
1693 static const true_false_string isup_echo_control_device_ind_value = {
1694 "Echo control device included",
1695 "Echo control device not included"
1696 };
1697
1698 static const true_false_string isup_natnl_inatnl_call_ind_value = {
1699 "Call to be treated as international call",
1700 "Call to be treated as national call"
1701 };
1702
1703 #define NO_END_TO_END_METHOD_AVAILABLE 0
1704 #define PASS_ALONG_METHOD_AVAILABLE 1
1705 #define SCCP_METHOD_AVAILABLE 2
1706 #define PASS_ALONG_AND_SCCP_METHOD_AVAILABLE 3
1707 static const value_string isup_end_to_end_method_ind_value[] = {
1708 { NO_END_TO_END_METHOD_AVAILABLE, "No End-to-end method available (only link-by-link method available)"},
1709 { PASS_ALONG_METHOD_AVAILABLE, "Pass-along method available (national use)"},
1710 { SCCP_METHOD_AVAILABLE, "SCCP method available"},
1711 { PASS_ALONG_AND_SCCP_METHOD_AVAILABLE, "pass-along and SCCP method available (national use)"},
1712 { 0, NULL}};
1713
1714 static const value_string bicc_end_to_end_method_ind_value[] = {
1715 { NO_END_TO_END_METHOD_AVAILABLE, "No End-to-end method available (only link-by-link method available)"},
1716 { PASS_ALONG_METHOD_AVAILABLE, "reserved"},
1717 { SCCP_METHOD_AVAILABLE, "reserved"},
1718 { PASS_ALONG_AND_SCCP_METHOD_AVAILABLE, "reserved"},
1719 { 0, NULL}};
1720
1721 static const true_false_string isup_interworking_ind_value = {
1722 "interworking encountered",
1723 "no interworking encountered (No.7 signalling all the way)"
1724 };
1725
1726 static const true_false_string isup_end_to_end_info_ind_value = {
1727 "end-to-end information available",
1728 "no end-to-end information available"
1729 };
1730
1731 static const true_false_string bicc_end_to_end_info_ind_value = {
1732 "reserved",
1733 "no end-to-end information available"
1734 };
1735
1736 static const true_false_string ansi_isup_iam_seg_ind_value = {
1737 "Additional information has been received and incorporated into call set-up",
1738 "No Indication"
1739 };
1740
1741 static const true_false_string isup_ISDN_user_part_ind_value = {
1742 "ISDN user part used all the way",
1743 "ISDN user part not used all the way"
1744 };
1745
1746 static const true_false_string bicc_ISDN_user_part_ind_value = {
1747 "BICC used all the way",
1748 "BICC not used all the way"
1749 };
1750
1751 #define ISUP_PREFERRED_ALL_THE_WAY 0
1752 #define ISUP_NOT_REQUIRED_ALL_THE_WAY 1
1753 #define ISUP_REQUIRED_ALL_WAY 2
1754 #define ISUP_ISDN_USER_PART_IND_SPARE 3
1755 static const value_string isup_preferences_ind_value[] = {
1756 { ISUP_PREFERRED_ALL_THE_WAY, "ISDN user part preferred all the way"},
1757 { ISUP_NOT_REQUIRED_ALL_THE_WAY, "ISDN user part not required all the way"},
1758 { ISUP_REQUIRED_ALL_WAY, "ISDN user part required all the way"},
1759 { ISUP_ISDN_USER_PART_IND_SPARE, "spare"},
1760 { 0, NULL}};
1761
1762 static const value_string bicc_preferences_ind_value[] = {
1763 { ISUP_PREFERRED_ALL_THE_WAY, "BICC preferred all the way"},
1764 { ISUP_NOT_REQUIRED_ALL_THE_WAY, "BICC not required all the way"},
1765 { ISUP_REQUIRED_ALL_WAY, "BICC required all the way"},
1766 { ISUP_ISDN_USER_PART_IND_SPARE, "spare"},
1767 { 0, NULL}};
1768
1769 static const true_false_string isup_ISDN_originating_access_ind_value = {
1770 "originating access ISDN",
1771 "originating access non-ISDN"
1772 };
1773
1774 static const true_false_string isup_ISDN_ported_num_trans_ind_value = {
1775 "number translated",
1776 "number not translated"
1777 };
1778
1779 static const true_false_string isup_ISDN_qor_attempt_ind_value = {
1780 "QoR routing attempt in progress",
1781 "no QoR routing attempt in progress"
1782 };
1783
1784 #define NO_INDICATION 0
1785 #define CONNECTIONLESS_METHOD_AVAILABLE 1
1786 #define CONNECTION_ORIENTED_METHOD_AVAILABLE 2
1787 #define CONNECTIONLESS_AND_ORIENTED_METHOD_AVAILABLE 3
1788 static const value_string isup_SCCP_method_ind_value[] = {
1789 { NO_INDICATION, "No indication"},
1790 { CONNECTIONLESS_METHOD_AVAILABLE, "Connectionless method available (national use)"},
1791 { CONNECTION_ORIENTED_METHOD_AVAILABLE, "Connection oriented method available"},
1792 { CONNECTIONLESS_AND_ORIENTED_METHOD_AVAILABLE, "Connectionless and -oriented method available (national use)"},
1793 { 0, NULL}};
1794
1795 static const value_string bicc_SCCP_method_ind_value[] = {
1796 { NO_INDICATION, "No indication"},
1797 { CONNECTIONLESS_METHOD_AVAILABLE, "reserved"},
1798 { CONNECTION_ORIENTED_METHOD_AVAILABLE, "reserved"},
1799 { CONNECTIONLESS_AND_ORIENTED_METHOD_AVAILABLE, "reserved"},
1800 { 0, NULL}};
1801
1802 #define UNKNOWN_AT_THIS_TIME 0
1803 #define OPERATOR_FRENCH 1
1804 #define OPERATOR_ENGLISH 2
1805 #define OPERATOR_GERMAN 3
1806 #define OPERATOR_RUSSIAN 4
1807 #define OPERATOR_SPANISH 5
1808 #define ORDINARY_CALLING_SUBSCRIBER 10
1809 #define CALLING_SUBSCRIBER_WITH_PRIORITY 11
1810 #define DATA_CALL 12
1811 #define TEST_CALL 13
1812 #define PAYPHONE 15
1813 static const value_string isup_calling_partys_category_value[] = {
1814 { UNKNOWN_AT_THIS_TIME, "Category unknown at this time (national use)"},
1815 { OPERATOR_FRENCH, "operator, language French"},
1816 { OPERATOR_ENGLISH, "operator, language English"},
1817 { OPERATOR_GERMAN, "operator, language German"},
1818 { OPERATOR_RUSSIAN, "operator, language Russian"},
1819 { OPERATOR_SPANISH, "operator, language Spanish"},
1820
1821 { 6, "available to Administrations"},
1822 { 7, "available to Administrations"},
1823 { 8, "available to Administrations"},
1824 { 9, "reserved (national use)"},
1825
1826 { ORDINARY_CALLING_SUBSCRIBER, "ordinary calling subscriber"},
1827 { CALLING_SUBSCRIBER_WITH_PRIORITY, "calling subscriber with priority"},
1828 { DATA_CALL, "data call (voice band data)"},
1829 { TEST_CALL, "test call"},
1830 /* q.763-200212Amd2 */
1831 { 14, "IEPS call marking for preferential call set up"},
1832 { PAYPHONE, "payphone"},
1833 /* q.763-200212Amd3 */
1834 { 16, "Mobile terminal located in the home PLMN"},
1835 { 17, "Mobile terminal located in a visited PLMN"},
1836 { 0, NULL}};
1837 value_string_ext isup_calling_partys_category_value_ext = VALUE_STRING_EXT_INIT(isup_calling_partys_category_value);
1838
1839 static const value_string russian_isup_calling_partys_category_value[] = {
1840 { UNKNOWN_AT_THIS_TIME, "Category unknown at this time (national use)"},
1841 { OPERATOR_FRENCH, "operator, language French"},
1842 { OPERATOR_ENGLISH, "operator, language English"},
1843 { OPERATOR_GERMAN, "operator, language German"},
1844 { OPERATOR_RUSSIAN, "operator, language Russian"},
1845 { OPERATOR_SPANISH, "operator, language Spanish"},
1846
1847 { 6, "Operator, language by mutual agreement by Administration"},
1848 { 7, "Operator, language by mutual agreement by Administration"},
1849 { 8, "Operator, language by mutual agreement by Administration"},
1850 { 9, "National Operator"},
1851
1852 { ORDINARY_CALLING_SUBSCRIBER, "ordinary calling subscriber"},
1853 { CALLING_SUBSCRIBER_WITH_PRIORITY, "calling subscriber with priority"},
1854 { DATA_CALL, "data call (voice band data)"},
1855 { TEST_CALL, "test call"},
1856 /* q.763-200212Amd2 */
1857 { 14, "IEPS call marking for preferential call set up"},
1858 { PAYPHONE, "payphone"},
1859 /* q.763-200212Amd3 */
1860 { 16, "Mobile terminal located in the home PLMN"},
1861 { 17, "Mobile terminal located in a visited PLMN"},
1862
1863 { 0xe0, "Reserved (Sub.Category 0)"},
1864 { 0xe1, "Hotel subscriber"},
1865 { 0xe2, "Charge free subscriber"},
1866 { 0xe3, "Subscriber with special service access"},
1867 { 0xe4, "Local subscriber"},
1868 { 0xe5, "Local coinbox"},
1869 { 0xf0, "Automatic call of category I"},
1870 { 0xf1, "Semiautomatic call of category I"},
1871 { 0xf2, "Automatic call of category II"},
1872 { 0xf3, "Semiautomatic call of category II"},
1873 { 0xf4, "Automatic call of category III"},
1874 { 0xf5, "Semiautomatic call of category III"},
1875 { 0xf6, "Automatic call of category IV"},
1876 { 0xf7, "Semiautomatic call of category IV"},
1877
1878 { 0, NULL}};
1879 static value_string_ext russian_isup_calling_partys_category_value_ext = VALUE_STRING_EXT_INIT(russian_isup_calling_partys_category_value);
1880
1881 #define CVR_RSP_IND_FAILURE 0
1882 #define CVR_RSP_IND_SUCCESS 1
1883
1884 static const value_string isup_cvr_rsp_ind_value[ ] = {
1885 { CVR_RSP_IND_FAILURE, "CVR Response Fail" },
1886 { CVR_RSP_IND_SUCCESS, "CVR Response Success" },
1887 { 0, NULL }
1888 };
1889
1890 #define CVR_CG_IND_DOUBLE_SEIZE_NONE 0
1891 #define CVR_CG_IND_DOUBLE_SEIZE_ODD 1
1892 #define CVR_CG_IND_DOUBLE_SEIZE_EVEN 2
1893 #define CVR_CG_IND_DOUBLE_SEIZE_ALL 3
1894
1895 static const value_string isup_cvr_cg_double_seize_value[ ] = {
1896 { CVR_CG_IND_DOUBLE_SEIZE_NONE, "Double Seize control NONE" },
1897 { CVR_CG_IND_DOUBLE_SEIZE_ODD, "Double Seize control odd circuits"},
1898 { CVR_CG_IND_DOUBLE_SEIZE_EVEN, "Double Seize control even circuits"},
1899 { CVR_CG_IND_DOUBLE_SEIZE_ALL, "Double Seize control all circuits"},
1900 {0, NULL }
1901 };
1902
1903 #define CVR_CG_IND_CAR_IND_UNKNOWN 0
1904 #define CVR_CG_IND_CAR_IND_ANALOG 1
1905 #define CVR_CG_IND_CAR_IND_DIGITAL 2
1906 #define CVR_CG_IND_CAR_IND_ANALOG_DIG 3
1907
1908 static const value_string isup_cvr_cg_car_ind_value[ ] = {
1909 { CVR_CG_IND_CAR_IND_UNKNOWN , "Carrier Type Unknown" },
1910 { CVR_CG_IND_CAR_IND_ANALOG , "Carrier Type Analog" },
1911 { CVR_CG_IND_CAR_IND_DIGITAL , "Carrier Type Digital"},
1912 { CVR_CG_IND_CAR_IND_ANALOG_DIG, "Carrier Type Digital And Analog"},
1913 { 0, NULL }
1914 };
1915
1916 #define CVR_CG_IND_ALARM_CAR_IND_UNKNOWN 0
1917 #define CVR_CG_IND_ALARM_CAR_IND_SOFTWARE 1
1918 #define CVR_CG_IND_ALARM_CAR_IND_HARDWARE 2
1919 #define CVR_CG_IND_ALARM_CAR_IND_SPARE 3
1920
1921 static const value_string isup_cvr_alarm_car_ind_value[ ] = {
1922 { CVR_CG_IND_ALARM_CAR_IND_UNKNOWN , "Alarm Carrier Ind Default"},
1923 { CVR_CG_IND_ALARM_CAR_IND_SOFTWARE , "Alarm Carrier Ind Software"},
1924 { CVR_CG_IND_ALARM_CAR_IND_HARDWARE , "Alarm Carrier Ind Hardware"},
1925 { CVR_CG_IND_ALARM_CAR_IND_SPARE , "Alarm Carrier Ind Spare"},
1926 { 0, NULL }
1927 };
1928
1929 #define CVR_CG_IND_CONT_CHK_UNKNOWN 0
1930 #define CVR_CG_IND_CONT_CHK_NONE 1
1931 #define CVR_CG_IND_CONT_CHK_STAT 2
1932 #define CVR_CG_IND_CONT_CHK_PER_CALL 3
1933
1934 static const value_string isup_cvr_cont_chk_ind_value[ ] = {
1935
1936 { CVR_CG_IND_CONT_CHK_UNKNOWN , "Continuity Check Unknown"},
1937 { CVR_CG_IND_CONT_CHK_NONE , "Continuity Check NONE"},
1938 { CVR_CG_IND_CONT_CHK_STAT , "Continuity Check Statistical"},
1939 { CVR_CG_IND_CONT_CHK_PER_CALL , "Continuity Check Per Call"},
1940 { 0, NULL }
1941 };
1942
1943 #define MEDIUM_SPEECH 0
1944 #define MEDIUM_64KBS 2
1945 #define MEDIUM_3_1_KHZ_AUDIO 3
1946 #define MEDIUM_RESERVED_SERVICE2_1 4
1947 #define MEDIUM_RESERVED_SERVICE1_2 5
1948 #define MEDIUM_64KBS_PREFERRED 6
1949 #define MEDIUM_2_64KBS 7
1950 #define MEDIUM_384KBS 8
1951 #define MEDIUM_1536KBS 9
1952 #define MEDIUM_1920KBS 10
1953
1954 #define MEDIUM_3_64KBS 16
1955 #define MEDIUM_4_64KBS 17
1956 #define MEDIUM_5_64KBS 18
1957
1958 #define MEDIUM_7_64KBS 20
1959 #define MEDIUM_8_64KBS 21
1960 #define MEDIUM_9_64KBS 22
1961 #define MEDIUM_10_64KBS 23
1962 #define MEDIUM_11_64KBS 24
1963 #define MEDIUM_12_64KBS 25
1964 #define MEDIUM_13_64KBS 26
1965 #define MEDIUM_14_64KBS 27
1966 #define MEDIUM_15_64KBS 28
1967 #define MEDIUM_16_64KBS 29
1968 #define MEDIUM_17_64KBS 30
1969 #define MEDIUM_18_64KBS 31
1970 #define MEDIUM_19_64KBS 32
1971 #define MEDIUM_20_64KBS 33
1972 #define MEDIUM_21_64KBS 34
1973 #define MEDIUM_22_64KBS 35
1974 #define MEDIUM_23_64KBS 36
1975
1976 #define MEDIUM_25_64KBS 38
1977 #define MEDIUM_26_64KBS 39
1978 #define MEDIUM_27_64KBS 40
1979 #define MEDIUM_28_64KBS 41
1980 #define MEDIUM_29_64KBS 42
1981
1982 static const value_string isup_transmission_medium_requirement_value[] = {
1983 { MEDIUM_SPEECH, "speech"},
1984 { 1, "spare"},
1985 { MEDIUM_64KBS, "64 kbit/s unrestricted"},
1986 { MEDIUM_3_1_KHZ_AUDIO, "3.1 kHz audio"},
1987 { MEDIUM_RESERVED_SERVICE2_1, "reserved for alternate speech (service 2)/64 kbit/s unrestricted (service 1)"},
1988 { MEDIUM_RESERVED_SERVICE1_2, "reserved for alternate 64 kbit/s unrestricted (service 1)/speech (service 2)"},
1989 { MEDIUM_64KBS_PREFERRED, "64 kbit/s preferred"},
1990 { MEDIUM_2_64KBS, "2x64 kbit/s unrestricted"},
1991 { MEDIUM_384KBS, "384 kbit/s unrestricted"},
1992 { MEDIUM_1536KBS, "1536 kbit/s unrestricted"},
1993 { MEDIUM_1920KBS, "1920 kbit/s unrestricted"},
1994
1995 { 11, "spare"},
1996 { 12, "spare"},
1997 { 13, "spare"},
1998 { 14, "spare"},
1999 { 15, "spare"},
2000
2001 { MEDIUM_3_64KBS, "3x64 kbit/s unrestricted"},
2002 { MEDIUM_4_64KBS, "4x64 kbit/s unrestricted"},
2003 { MEDIUM_5_64KBS, "5x64 kbit/s unrestricted"},
2004
2005 { 19, "spare"},
2006
2007 { MEDIUM_7_64KBS, "7x64 kbit/s unrestricted"},
2008 { MEDIUM_8_64KBS, "8x64 kbit/s unrestricted"},
2009 { MEDIUM_9_64KBS, "9x64 kbit/s unrestricted"},
2010 { MEDIUM_10_64KBS, "10x64 kbit/s unrestricted"},
2011 { MEDIUM_11_64KBS, "11x64 kbit/s unrestricted"},
2012 { MEDIUM_12_64KBS, "12x64 kbit/s unrestricted"},
2013 { MEDIUM_13_64KBS, "13x64 kbit/s unrestricted"},
2014 { MEDIUM_14_64KBS, "14x64 kbit/s unrestricted"},
2015 { MEDIUM_15_64KBS, "15x64 kbit/s unrestricted"},
2016 { MEDIUM_16_64KBS, "16x64 kbit/s unrestricted"},
2017 { MEDIUM_17_64KBS, "17x64 kbit/s unrestricted"},
2018 { MEDIUM_18_64KBS, "18x64 kbit/s unrestricted"},
2019 { MEDIUM_19_64KBS, "19x64 kbit/s unrestricted"},
2020 { MEDIUM_20_64KBS, "20x64 kbit/s unrestricted"},
2021 { MEDIUM_21_64KBS, "21x64 kbit/s unrestricted"},
2022 { MEDIUM_22_64KBS, "22x64 kbit/s unrestricted"},
2023 { MEDIUM_23_64KBS, "23x64 kbit/s unrestricted"},
2024
2025 { 37, "spare"},
2026
2027 { MEDIUM_25_64KBS, "25x64 kbit/s unrestricted"},
2028 { MEDIUM_26_64KBS, "26x64 kbit/s unrestricted"},
2029 { MEDIUM_27_64KBS, "27x64 kbit/s unrestricted"},
2030 { MEDIUM_28_64KBS, "28x64 kbit/s unrestricted"},
2031 { MEDIUM_29_64KBS, "29x64 kbit/s unrestricted"},
2032 { 0, NULL}};
2033 value_string_ext isup_transmission_medium_requirement_value_ext = VALUE_STRING_EXT_INIT(isup_transmission_medium_requirement_value);
2034
2035 static const value_string isup_transmission_medium_requirement_prime_value[] = {
2036 { MEDIUM_SPEECH, "speech"},
2037 { 1, "spare"},
2038 { MEDIUM_64KBS, "reserved for 64 kbit/s unrestricted"},
2039 { MEDIUM_3_1_KHZ_AUDIO, "3.1 kHz audio"},
2040 { MEDIUM_RESERVED_SERVICE2_1, "reserved for alternate speech (service 2)/64 kbit/s unrestricted (service 1)"},
2041 { MEDIUM_RESERVED_SERVICE1_2, "reserved for alternate 64 kbit/s unrestricted (service 1)/speech (service 2)"},
2042 { MEDIUM_64KBS_PREFERRED, "reserved for 64 kbit/s preferred"},
2043 { MEDIUM_2_64KBS, "reserved for 2x64 kbit/s unrestricted"},
2044 { MEDIUM_384KBS, "reserved for 384 kbit/s unrestricted"},
2045 { MEDIUM_1536KBS, "reserved for 1536 kbit/s unrestricted"},
2046 { MEDIUM_1920KBS, "reserved for 1920 kbit/s unrestricted"},
2047 { 0, NULL}};
2048 static value_string_ext isup_transmission_medium_requirement_prime_value_ext = VALUE_STRING_EXT_INIT(isup_transmission_medium_requirement_prime_value);
2049
2050
2051 /* Definitions for Called and Calling Party number */
2052 #define ISUP_ODD_EVEN_MASK 0x80
2053 #define ISUP_NATURE_OF_ADDRESS_IND_MASK 0x7F
2054 #define ISUP_INN_MASK 0x80
2055 #define ISUP_NI_MASK 0x80
2056 #define ISUP_NUMBERING_PLAN_IND_MASK 0x70
2057 #define ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK 0x0C
2058 #define ISUP_SCREENING_IND_MASK 0x03
2059 #define ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK 0x0F
2060 #define ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK 0xF0
2061
2062 static const true_false_string isup_odd_even_ind_value = {
2063 "odd number of address signals",
2064 "even number of address signals"
2065 };
2066
2067 #define ISUP_CALLED_PARTY_NATURE_SUBSCRIBER_NR 1
2068 #define ISUP_CALLED_PARTY_NATURE_UNKNOWN 2
2069 #define ISUP_CALLED_PARTY_NATURE_NATIONAL_NR 3
2070 #define ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR 4
2071 #define ISUP_CALLED_PARTY_NATURE_NETW_SPEC_NR 5
2072
2073 #define ISUP_CHARGE_NATURE_ANI_CGPA_SUB_NR 1
2074 #define ISUP_CHARGE_NATURE_ANI_NA 2
2075 #define ISUP_CHARGE_NATURE_ANI_CGPA_NAT_NR 3
2076 #define ISUP_CHARGE_NATURE_ANI_CDPA_SUB_NR 5
2077 #define ISUP_CHARGE_NATURE_ANI_CDPA_NO_NR 6
2078 #define ISUP_CHARGE_NATURE_ANI_CDPA_NAT_NR 7
2079
2080 static const value_string isup_called_party_nature_of_address_ind_value[] = {
2081 { ISUP_CALLED_PARTY_NATURE_SUBSCRIBER_NR, "subscriber number (national use)"},
2082 { ISUP_CALLED_PARTY_NATURE_UNKNOWN, "unknown (national use)"},
2083 { ISUP_CALLED_PARTY_NATURE_NATIONAL_NR, "national (significant) number"},
2084 { ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR, "international number"},
2085 { ISUP_CALLED_PARTY_NATURE_NETW_SPEC_NR, "network-specific number (national use)"},
2086 { 0, NULL}};
2087
2088 static const value_string isup_calling_party_nature_of_address_ind_value[] = {
2089 { ISUP_CALLED_PARTY_NATURE_SUBSCRIBER_NR, "subscriber number (national use)"},
2090 { ISUP_CALLED_PARTY_NATURE_UNKNOWN, "unknown (national use)"},
2091 { ISUP_CALLED_PARTY_NATURE_NATIONAL_NR, "national (significant) number"},
2092 { ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR, "international number"},
2093 { 5, "PISN specific number"},
2094 { 0, NULL}};
2095
2096 static const value_string isup_charge_number_nature_of_address_ind_value[] = {
2097 { ISUP_CHARGE_NATURE_ANI_CGPA_SUB_NR, "ANI of the calling party; subscriber number"},
2098 { ISUP_CHARGE_NATURE_ANI_NA, "ANI not available or not provided"},
2099 { ISUP_CHARGE_NATURE_ANI_CGPA_NAT_NR, "ANI of the calling party; national number"},
2100 { ISUP_CHARGE_NATURE_ANI_CDPA_SUB_NR, "ANI of the called party; subscriber number"},
2101 { ISUP_CHARGE_NATURE_ANI_CDPA_NO_NR, "ANI of the called party; no number present"},
2102 { ISUP_CHARGE_NATURE_ANI_CDPA_NAT_NR, "ANI of the called party; national number"},
2103 { 0, NULL}};
2104
2105 #define ISUP_GENERIC_NAME_PRESENTATION_ALLOWED 0
2106 #define ISUP_GENERIC_NAME_PRESENTATION_RESTRICT 1
2107 #define ISUP_GENERIC_NAME_PRESENTATION_BLOCK_TOGGLE 2
2108 #define ISUP_GENERIC_NAME_PRESENTATION_NO_INDIC 3
2109 #define ISUP_GENERIC_NAME_TYPE_SPARE 0
2110 #define ISUP_GENERIC_NAME_TYPE_CALLING 1
2111 #define ISUP_GENERIC_NAME_TYPE_ORIG_CALLED 2
2112 #define ISUP_GENERIC_NAME_TYPE_REDIRECTING 3
2113 #define ISUP_GENERIC_NAME_TYPE_CONNECTED 4
2114
2115 static const value_string isup_generic_name_presentation_value[] = {
2116 { ISUP_GENERIC_NAME_PRESENTATION_ALLOWED, "presentation allowed"},
2117 { ISUP_GENERIC_NAME_PRESENTATION_RESTRICT, "presentation restricted"},
2118 { ISUP_GENERIC_NAME_PRESENTATION_BLOCK_TOGGLE, "blocking toggle"},
2119 { ISUP_GENERIC_NAME_PRESENTATION_NO_INDIC, "no indication"},
2120 { 0, NULL}};
2121
2122 static const true_false_string isup_generic_name_availability_value = {
2123 "name not available",
2124 "name available/unknown"
2125 };
2126
2127 static const value_string isup_generic_name_type_value[] = {
2128 { ISUP_GENERIC_NAME_TYPE_SPARE, "spare"},
2129 { ISUP_GENERIC_NAME_TYPE_CALLING, "calling name"},
2130 { ISUP_GENERIC_NAME_TYPE_ORIG_CALLED, "original called name"},
2131 { ISUP_GENERIC_NAME_TYPE_REDIRECTING, "redirecting name"},
2132 { ISUP_GENERIC_NAME_TYPE_CONNECTED, "connected name"},
2133 { 5, "spare"},
2134 { 6, "spare"},
2135 { 7, "spare"},
2136 { 0, NULL}};
2137
2138 static const true_false_string isup_INN_ind_value = {
2139 "routing to internal network number not allowed",
2140 "routing to internal network number allowed"
2141 };
2142 static const true_false_string isup_NI_ind_value = {
2143 "incomplete",
2144 "complete"
2145 };
2146
2147 static const value_string isup_location_presentation_restricted_ind_value[] = {
2148 { 0, "presentation allowed"},
2149 { 1, "presentation restricted"},
2150 { 2, "location not available"},
2151 { 3, "spare"},
2152 { 0, NULL}};
2153
2154 static const value_string isup_location_type_of_shape_value[] = {
2155 { 0, "ellipsoid point"},
2156 { 1, "ellipsoid point with uncertainty"},
2157 { 2, "point with altitude and uncertainty"},
2158 { 3, "ellipse on the ellipsoid"},
2159 { 4, "ellipsoid circle sector"},
2160 { 5, "polygon"},
2161 { 0, NULL}};
2162
2163 #define ISDN_NUMBERING_PLAN 1
2164 #define DATA_NUMBERING_PLAN 3
2165 #define TELEX_NUMBERING_PLAN 4
2166 static const value_string isup_numbering_plan_ind_value[] = {
2167 { 0, "Unknown (national use)"},
2168 { ISDN_NUMBERING_PLAN, "ISDN (Telephony) numbering plan ITU-T E.164"},
2169 { DATA_NUMBERING_PLAN, "Data numbering plan ITU-T X.121(national use)"},
2170 { TELEX_NUMBERING_PLAN, "Telex numbering plan ITU-T F.69(national use)"},
2171 { 5, "Private numbering plan (national use)"},
2172 { 6, "Reserved for national use"},
2173 { 0, NULL}};
2174
2175 #define ADDRESS_PRESETATION_ALLOWED 0
2176 #define ADDRESS_PRESETATION_RESTRICTED 1
2177 #define ADDRESS_NOT_AVAILABLE 2
2178 static const value_string isup_address_presentation_restricted_ind_value[] = {
2179 { ADDRESS_PRESETATION_ALLOWED, "presentation allowed"},
2180 { ADDRESS_PRESETATION_RESTRICTED, "presentation restricted"},
2181 { ADDRESS_NOT_AVAILABLE, "address not available (national use)"},
2182 { 3, "spare"},
2183 { 0, NULL}};
2184
2185 static const value_string isup_screening_ind_value[] = {
2186 { 0, "reserved"},
2187 { 1, "user provided, verified and passed"},
2188 { 2, "reserved"},
2189 { 3, "network provided"},
2190 { 0, NULL}};
2191
2192 static const value_string isup_screening_ind_enhanced_value[] = {
2193 { 0, "user provided, not verified"},
2194 { 1, "user provided, verified and passed"},
2195 { 2, "user provided, verified and failed"},
2196 { 3, "network provided"},
2197 { 0, NULL}};
2198
2199 static const value_string isup_called_party_address_digit_value[] = {
2200 { 0, "0"},
2201 { 1, "1"},
2202 { 2, "2"},
2203 { 3, "3"},
2204 { 4, "4"},
2205 { 5, "5"},
2206 { 6, "6"},
2207 { 7, "7"},
2208 { 8, "8"},
2209 { 9, "9"},
2210 { 10, "spare"},
2211 { 11, "code 11 "},
2212 { 12, "code 12"},
2213 { 15, "Stop sending"},
2214 { 0, NULL}};
2215 static value_string_ext isup_called_party_address_digit_value_ext = VALUE_STRING_EXT_INIT(isup_called_party_address_digit_value);
2216
2217 static const value_string isup_calling_party_address_digit_value[] = {
2218 { 0, "0"},
2219 { 1, "1"},
2220 { 2, "2"},
2221 { 3, "3"},
2222 { 4, "4"},
2223 { 5, "5"},
2224 { 6, "6"},
2225 { 7, "7"},
2226 { 8, "8"},
2227 { 9, "9"},
2228 { 10, "spare"},
2229 { 11, "code 11 "},
2230 { 12, "code 12"},
2231 { 15, "spare"},
2232 { 0, NULL}};
2233 static value_string_ext isup_calling_party_address_digit_value_ext = VALUE_STRING_EXT_INIT(isup_calling_party_address_digit_value);
2234
2235 /*End of Called/Calling party address definitions */
2236
2237 /* Japan ISUP*/
2238 /*******************************/
2239 /* CARRIER INFORMATION */
2240 /*******************************/
2241
2242 /* IEC INDICATOR */
2243 #define CARRIER_INFO_IEC_NO_TRANSFER 0
2244 #define CARRIER_INFO_IEC_TRANSFER_FORW 1
2245 #define CARRIER_INFO_IEC_TRANSFER_BACK 2
2246 #define CARRIER_INFO_IEC_TRANSFER_BOTH_DIR 3
2247 static const value_string isup_carrier_info_iec_indic_value[] = {
2248 { CARRIER_INFO_IEC_NO_TRANSFER, "No transfer"},
2249 { CARRIER_INFO_IEC_TRANSFER_FORW, "Transfer in forward direction"},
2250 { CARRIER_INFO_IEC_TRANSFER_BACK, "Transfer in backward direction"},
2251 { CARRIER_INFO_IEC_TRANSFER_BOTH_DIR, "Transfer in both directions"},
2252 { 0, NULL}};
2253
2254
2255 /* CATEGORY OF CARRIER */
2256 #define CARRIER_INFO_CATEGORY_SCPC 0xFA
2257 #define CARRIER_INFO_CATEGORY_OLEC 0xFB
2258 #define CARRIER_INFO_CATEGORY_TLEC 0xFC
2259 #define CARRIER_INFO_CATEGORY_CIEC 0xFD
2260 #define CARRIER_INFO_CATEGORY_IEC 0xFE
2261 #define CARRIER_INFO_CATEGORY_SPARE 0xFF
2262 static const value_string isup_carrier_info_category_value[] = {
2263 { CARRIER_INFO_CATEGORY_SCPC, "(Service Control Point Carrier)"},
2264 { CARRIER_INFO_CATEGORY_OLEC, "(Originating Local Exchange Carrier)"},
2265 { CARRIER_INFO_CATEGORY_TLEC, "(Terminating Local Exchange Carrier)"},
2266 { CARRIER_INFO_CATEGORY_CIEC, "(Chosen Inter|Exchange Carrier)"},
2267 { CARRIER_INFO_CATEGORY_IEC, "(Inter|Exchange Carrier)"},
2268 { CARRIER_INFO_CATEGORY_SPARE, "Spare"},
2269 { 0, NULL}};
2270 static value_string_ext isup_carrier_info_category_vals_ext = VALUE_STRING_EXT_INIT(isup_carrier_info_category_value);
2271
2272 /* TYPE OF CARRIER INFORMATION */
2273 #define CARRIER_INFO_TYPE_OF_CARRIER_POIHIE 0xFC
2274 #define CARRIER_INFO_TYPE_OF_CARRIER_POICA 0xFD
2275 #define CARRIER_INFO_TYPE_OF_CARRIER_CARID 0xFE
2276 #define CARRIER_INFO_TYPE_OF_CARRIER_SPARE 0xFF
2277 static const value_string isup_carrier_info_type_of_carrier_value[] = {
2278 { CARRIER_INFO_TYPE_OF_CARRIER_POIHIE, "POI Hierarchy information"},
2279 { CARRIER_INFO_TYPE_OF_CARRIER_POICA, "POI|CA information (Charge Area)"},
2280 { CARRIER_INFO_TYPE_OF_CARRIER_CARID, "Carrier identification (ID) code"},
2281 { CARRIER_INFO_TYPE_OF_CARRIER_SPARE, "Spare"},
2282 { 0, NULL}};
2283 static value_string_ext isup_carrier_info_type_of_carrier_vals_ext = VALUE_STRING_EXT_INIT(isup_carrier_info_type_of_carrier_value);
2284
2285 /* POI/HIE */
2286 #define CARRIER_INFO_POIHIE_NOINDIC 0
2287 #define CARRIER_INFO_POIHIE_HIE1 1
2288 #define CARRIER_INFO_POIHIE_HIE2 2
2289 static const value_string isup_carrier_info_poihie_value[] = {
2290 { CARRIER_INFO_POIHIE_NOINDIC, "No indication"},
2291 { CARRIER_INFO_POIHIE_HIE1, "Hierarchy level 1"},
2292 { CARRIER_INFO_POIHIE_HIE2, "Hierarchy level 2"},
2293 { 0, NULL}};
2294
2295 #if 0
2296 /* POICA */
2297 /* ODD/EVEN */
2298 #define CARRIER_INFO_CA_OE_0 0
2299 #define CARRIER_INFO_CA_OE_1 1
2300 static const value_string isup_carrier_info_poica_oe_value[] = {
2301 { CARRIER_INFO_CA_OE_0, "Reserved"},
2302 { CARRIER_INFO_CA_OE_1, "Odd number of charge area digits"},
2303 { 0, NULL}};
2304 #endif
2305
2306 #if 0
2307 /* CARID */
2308 /* ODD/EVEN */
2309 #define CARRIER_INFO_CARID_OE_0 0
2310 #define CARRIER_INFO_CARID_OE_1 1
2311 static const value_string isup_carrier_info_carid_oe_value[] = {
2312 { CARRIER_INFO_CARID_OE_0, "Even number of ID code digits"},
2313 { CARRIER_INFO_CARID_OE_1, "Odd number of ID code digits"},
2314 { 0, NULL}};
2315 #endif
2316
2317 /* CARRIER INFORMATION DIGITS */
2318 #define CARRIER_INFO_DIGIT_0 0
2319 #define CARRIER_INFO_DIGIT_1 1
2320 #define CARRIER_INFO_DIGIT_2 2
2321 #define CARRIER_INFO_DIGIT_3 3
2322 #define CARRIER_INFO_DIGIT_4 4
2323 #define CARRIER_INFO_DIGIT_5 5
2324 #define CARRIER_INFO_DIGIT_6 6
2325 #define CARRIER_INFO_DIGIT_7 7
2326 #define CARRIER_INFO_DIGIT_8 8
2327 #define CARRIER_INFO_DIGIT_9 9
2328 static const value_string isup_carrier_info_digits_value[] = {
2329 { CARRIER_INFO_DIGIT_0, "Digit 0"},
2330 { CARRIER_INFO_DIGIT_1, "Digit 1"},
2331 { CARRIER_INFO_DIGIT_2, "Digit 2"},
2332 { CARRIER_INFO_DIGIT_3, "Digit 3"},
2333 { CARRIER_INFO_DIGIT_4, "Digit 4"},
2334 { CARRIER_INFO_DIGIT_5, "Digit 5"},
2335 { CARRIER_INFO_DIGIT_6, "Digit 6"},
2336 { CARRIER_INFO_DIGIT_7, "Digit 7"},
2337 { CARRIER_INFO_DIGIT_8, "Digit 8"},
2338 { CARRIER_INFO_DIGIT_9, "Digit 9"},
2339 { 0, NULL}};
2340
2341 /*******************************/
2342 /* CHARGE AREA INFORMATION */
2343 /*******************************/
2344 #if 0
2345 /* ODD/EVEN */
2346 #define CHARGE_AREA_INFO_OE_0 0
2347 #define CHARGE_AREA_INFO_OE_1 1
2348 static const value_string isup_charge_area_info_oe_value[] = {
2349 { CHARGE_AREA_INFO_OE_0, "Even number of Charge Area digits"},
2350 { CHARGE_AREA_INFO_OE_1, "Odd number of Charge Area code digits"},
2351 { 0, NULL}};
2352 #endif
2353
2354 #define CHARGE_AREA_NAT_INFO_MA 0
2355 #define CHARGE_AREA_NAT_INFO_CA 1
2356 static const value_string isup_charge_area_info_nat_of_info_value[] = {
2357 { CHARGE_AREA_NAT_INFO_MA, "MA code (and optionally NC)"},
2358 { CHARGE_AREA_NAT_INFO_CA, "CA code"},
2359 { 0, NULL}};
2360
2361 static const true_false_string isup_calling_party_address_request_ind_value = {
2362 "calling party address requested",
2363 "calling party address not requested"
2364 };
2365 static const true_false_string isup_holding_ind_value = {
2366 "holding requested/(ANSI)holding required (No procedure specified for U.S. networks)",
2367 "holding not requested/(ANSI)holding not required"
2368 };
2369 static const true_false_string isup_calling_partys_category_request_ind_value = {
2370 "Calling Party's category requested",
2371 "Calling Party's category not requested",
2372 };
2373 static const true_false_string isup_charge_information_request_ind_value = {
2374 "Charge Information requested",
2375 "Charge Information not requested"
2376 };
2377 static const true_false_string isup_malicious_call_identification_request_ind_value = {
2378 "Malicious call identification requested",
2379 "Malicious call identification not requested"
2380 };
2381
2382 #define CALLING_PARTY_ADDRESS_NOT_INCLUDED 0
2383 #define CALLING_PARTY_ADDRESS_NOT_AVAILABLE 1
2384 #define CALLING_PARTY_ADDRESS_INCLUDED 3
2385 static const value_string isup_calling_party_address_response_ind_value[] = {
2386 { CALLING_PARTY_ADDRESS_NOT_INCLUDED, "Calling party address not included"},
2387 { CALLING_PARTY_ADDRESS_NOT_AVAILABLE, "Calling party address not available"},
2388 { 4, "spare"},
2389 { CALLING_PARTY_ADDRESS_INCLUDED, "Calling party address included"},
2390 { 0, NULL}};
2391
2392 static const true_false_string isup_hold_provided_ind_value = {
2393 "hold provided",
2394 "hold not provided"
2395 };
2396 static const true_false_string isup_calling_partys_category_response_ind_value = {
2397 "Calling Party's category included",
2398 "Calling Party's category not included",
2399 };
2400 static const true_false_string isup_charge_information_response_ind_value = {
2401 "Charge Information included",
2402 "Charge Information not included"
2403 };
2404 static const true_false_string isup_solicited_information_ind_value = {
2405 "unsolicited",
2406 "solicited"
2407 };
2408
2409 static const true_false_string isup_continuity_ind_value = {
2410 "Continuity check successful",
2411 "Continuity check failed"
2412 };
2413
2414 #define CHARGE_NO_IND 0
2415 #define CHARGE_NO_CHARGE 1
2416 #define CHARGE_CHARGE 2
2417 static const value_string isup_charge_ind_value[] = {
2418 { CHARGE_NO_IND, "No indication"},
2419 { CHARGE_NO_CHARGE, "No charge"},
2420 { CHARGE_CHARGE, "Charge"},
2421 { 3, "spare"},
2422 { 0, NULL}};
2423
2424 #define CALLED_PARTYS_STATUS_NO_IND 0
2425 #define CALLED_PARTYS_STATUS_SUBSCR_FREE 1
2426 #define CALLED_PARTYS_STATUS_CONNECT_WHEN_FREE 2
2427 static const value_string isup_called_partys_status_ind_value[] = {
2428 { CALLED_PARTYS_STATUS_NO_IND, "No indication"},
2429 { CALLED_PARTYS_STATUS_SUBSCR_FREE, "Subscriber free"},
2430 { CALLED_PARTYS_STATUS_CONNECT_WHEN_FREE, "Connect when free (national use)"},
2431 { 3, "spare"},
2432 { 0, NULL}};
2433
2434 #define CALLED_PARTYS_CATEGORY_NO_IND 0
2435 #define CALLED_PARTYS_CATEGORY_ORDINARY_SUBSCR 1
2436 #define CALLED_PARTYS_CATEGORY_PAYPHONE 2
2437 static const value_string isup_called_partys_category_ind_value[] = {
2438 { CALLED_PARTYS_CATEGORY_NO_IND, "No indication"},
2439 { CALLED_PARTYS_CATEGORY_ORDINARY_SUBSCR, "Ordinary subscriber"},
2440 { CALLED_PARTYS_CATEGORY_PAYPHONE, "Payphone"},
2441 { 3, "spare"},
2442 { 0, NULL}};
2443
2444 static const true_false_string isup_ISDN_terminating_access_ind_value = {
2445 "terminating access ISDN",
2446 "terminating access non-ISDN"
2447 };
2448
2449 static const true_false_string isup_suspend_resume_ind_value = {
2450 "network initiated",
2451 "ISDN subscriber initiated"
2452 };
2453 #define MAINTENANCE 0
2454 #define HARDWARE_FAILURE 1
2455 #define RES_FOR_NATNL_USE 2
2456 static const value_string isup_cgs_message_type_value[] = {
2457 { MAINTENANCE, "maintenance oriented"},
2458 { HARDWARE_FAILURE, "hardware failure oriented"},
2459 { RES_FOR_NATNL_USE, "reserved for national use (ISUP'84)"},
2460 { 3, "spare"},
2461 { 0, NULL}};
2462
2463 #define USER_TO_USER_SERVICE 2
2464 static const value_string isup_facility_ind_value[] = {
2465 { USER_TO_USER_SERVICE, "user-to-user service"},
2466 { 0, NULL}};
2467
2468 #define MTC_BLCK_STATE_TRANSIENT 0
2469 #define MTC_BLCK_STATE_UNEQUIPPED 3
2470 static const value_string isup_mtc_blocking_state_DC00_value[] = {
2471 { MTC_BLCK_STATE_TRANSIENT, "transient"},
2472 { 1, "spare"},
2473 { 2, "spare"},
2474 { MTC_BLCK_STATE_UNEQUIPPED, "unequipped"},
2475 { 0, NULL}};
2476
2477 #define MTC_BLCK_NO_BLOCKING 0
2478 #define MTC_LOCALLY_BLOCKED 1
2479 #define MTC_REMOTELY_BLOCKED 2
2480 #define MTC_LOCAL_REMOTE_BLOCKED 3
2481 static const value_string isup_mtc_blocking_state_DCnot00_value[] = {
2482 { MTC_BLCK_NO_BLOCKING, "no blocking (active)"},
2483 { MTC_LOCALLY_BLOCKED, "locally blocked"},
2484 { MTC_REMOTELY_BLOCKED, "remotely blocked"},
2485 { MTC_LOCAL_REMOTE_BLOCKED, "locally and remotely blocked"},
2486 { 0, NULL}};
2487
2488 #define CALL_PROC_INCOMING_BUSY 1
2489 #define CALL_PROC_OUTGOING_BUSY 2
2490 #define CALL_PROC_IDLE 3
2491 static const value_string isup_call_processing_state_value[] = {
2492 { CALL_PROC_INCOMING_BUSY, "circuit incoming busy"},
2493 { CALL_PROC_OUTGOING_BUSY, "circuit outgoing busy"},
2494 { CALL_PROC_IDLE, "idle"},
2495 { 0, NULL}};
2496
2497 #define HW_BLCK_NO_BLOCKING 0
2498 #define HW_LOCALLY_BLOCKED 1
2499 #define HW_REMOTELY_BLOCKED 2
2500 #define HW_LOCAL_REMOTE_BLOCKED 3
2501 static const value_string isup_HW_blocking_state_value[] = {
2502 { HW_BLCK_NO_BLOCKING, "no blocking (active)"},
2503 { HW_LOCALLY_BLOCKED, "locally blocked"},
2504 { HW_REMOTELY_BLOCKED, "remotely blocked"},
2505 { HW_LOCAL_REMOTE_BLOCKED, "locally and remotely blocked"},
2506 { 0, NULL}};
2507
2508 #define EVENT_ALERTING 1
2509 #define EVENT_PROGRESS 2
2510 #define EVENT_INBAND_INFO 3
2511 #define EVENT_ON_BUSY 4
2512 #define EVENT_ON_NO_REPLY 5
2513 #define EVENT_UNCONDITIONAL 6
2514 static const value_string isup_event_ind_value[] = {
2515 /* according 3.21/Q.763 */
2516 { EVENT_ALERTING, "ALERTING"},
2517 { EVENT_PROGRESS, "PROGRESS"},
2518 { EVENT_INBAND_INFO, "in-band information or an appropriate pattern is now available"},
2519 { EVENT_ON_BUSY, "call forwarded on busy (national use)"},
2520 { EVENT_ON_NO_REPLY, "call forwarded on no reply (national use)"},
2521 { EVENT_UNCONDITIONAL, "call forwarded unconditional (national use)"},
2522 { 0, NULL}};
2523
2524 static const true_false_string isup_event_presentation_restricted_ind_value = {
2525 /* according 3.21/Q.763 */
2526 "presentation restricted",
2527 "no indication"
2528 };
2529 #define CUG_NON_CUG_CALL 0
2530 #define CUG_CALL_OUTGOING_ACCESS_ALLOWED 2
2531 #define CUG_CALL_OUTGOING_ACCESS_NOT_ALLOWED 3
2532 static const value_string isup_CUG_call_ind_value[] = {
2533 /* according 3.38/Q.763 */
2534 { CUG_NON_CUG_CALL, "non-CUG call"},
2535 { 1, "spare"},
2536 { CUG_CALL_OUTGOING_ACCESS_ALLOWED, "closed user group call, outgoing access allowed"},
2537 { CUG_CALL_OUTGOING_ACCESS_NOT_ALLOWED, "closed user group call, outgoing access not allowed"},
2538 { 0, NULL}};
2539
2540
2541 static const true_false_string isup_simple_segmentation_ind_value = {
2542 /* according 3.38/Q.763 */
2543 "additional information will be sent in a segmentation message",
2544 "no additional information will be sent"
2545 };
2546
2547 static const value_string isup_redirecting_ind_value[] = {
2548 /* according 3.45/Q.763 */
2549 { 0, "no redirection (national use)"},
2550 { 1, "call rerouted (national use)"},
2551 { 2, "call rerouted, all redirection information presentation restricted (national use)"},
2552 { 3, "call diverted"},
2553 { 4, "call diverted, all redirection information presentation restricted"},
2554 { 5, "call rerouted, redirection number presentation restricted (national use)"},
2555 { 6, "call diversion, redirection number presentation restricted (national use)"},
2556 { 7, "spare"},
2557 { 0, NULL}};
2558
2559 static const value_string isup_original_redirection_reason_value[] = {
2560 /* according 3.45/Q.763 */
2561 { 0, "unknown/not available"},
2562 { 1, "user busy (national use)"},
2563 { 2, "no reply (national use)"},
2564 { 3, "unconditional (national use)"},
2565 { 0, NULL}};
2566
2567 static const value_string isup_redirection_reason_value[] = {
2568 /* according 3.45/Q.763 */
2569 { 0, "unknown/not available"},
2570 { 1, "user busy (national use)"},
2571 { 2, "no reply (national use)"},
2572 { 3, "unconditional (national use)"},
2573 { 4, "deflection during alerting"},
2574 { 5, "deflection immediate response"},
2575 { 6, "mobile subscriber not reachable"},
2576 { 0, NULL}};
2577
2578 static const value_string isup_type_of_network_identification_value[] = {
2579 /* according 3.53/Q.763 */
2580 { 0, "CCITT/ITU-T-standardized identification"},
2581 { 2, "national network identification"},
2582 { 0, NULL}};
2583
2584 static const value_string isup_network_identification_plan_value[] = {
2585 /* according 3.53/Q.763 */
2586 { 0, "if CCITT/ITU-T id - unknown"},
2587 { 3, "if CCITT/ITU-T id - public data network id code (X.121)"},
2588 { 6, "if CCITT/ITU-T id - public land Mobile Network id code (E.211)"},
2589 { 0, NULL}};
2590
2591 static const value_string isup_map_type_value[] = {
2592 /* according 3.69/Q.763 */
2593 { 1, "1544 kbit/s digital path map format (64 kbit/s base rate"},
2594 { 2, "2048 kbit/s digital path map format (64 kbit/s base rate"},
2595 { 0, NULL}};
2596
2597 static const value_string isup_auto_congestion_level_value[] = {
2598 /* according 3.4/Q.763 */
2599 { 1, "Congestion level 1 exceeded"},
2600 { 2, "Congestion level 2 exceeded"},
2601 { 0, NULL}};
2602
2603 static const true_false_string isup_inband_information_ind_value = {
2604 /* according 3.37/Q.763 */
2605 "in-band information or an appropriate pattern is now available",
2606 "no indication"
2607 };
2608 static const true_false_string isup_call_diversion_may_occur_ind_value = {
2609 /* according 3.37/Q.763 */
2610 "call diversion may occur",
2611 "no indication"
2612 };
2613 static const true_false_string isup_MLPP_user_ind_value = {
2614 /* according 3.37/Q.763 */
2615 "MLPP user",
2616 "no indication"
2617 };
2618
2619 static const true_false_string isup_access_delivery_ind_value = {
2620 /* according 3.2/Q.763 */
2621 "No set-up message generated",
2622 "Set-up message generated"
2623 };
2624
2625 static const value_string isup_loop_prevention_response_ind_value[] = {
2626 /* according 3.67/Q.763 */
2627 { 0, "insufficient information"},
2628 { 1, "no loop exists"},
2629 { 2, "simultaneous transfer"},
2630 { 0, NULL}};
2631
2632 static const true_false_string isup_temporary_alternative_routing_ind_value = {
2633 /* according 3.68/Q.763 */
2634 "TAR controlled call",
2635 "no indication"
2636 };
2637 static const true_false_string isup_extension_ind_value = {
2638 /* according 3.68/Q.763 */
2639 "last octet",
2640 "information continues through the next octet"
2641 };
2642
2643
2644
2645 static const value_string isup_call_to_be_diverted_ind_value[] = {
2646 /* according 3.72/Q.763 */
2647 { 0, "no indication"},
2648 { 1, "call diversion allowed"},
2649 { 2, "call diversion not allowed"},
2650 { 3, "spare"},
2651 { 0, NULL}};
2652
2653 static const value_string isup_call_to_be_offered_ind_value[] = {
2654 /* according 3.72/Q.763 */
2655 { 0, "no indication"},
2656 { 1, "call offering not allowed"},
2657 { 2, "call offering allowed"},
2658 { 3, "spare"},
2659 { 0, NULL}};
2660
2661 static const value_string isup_conference_acceptance_ind_value[] = {
2662 /* according 3.76/Q.763 */
2663 { 0, "no indication"},
2664 { 1, "accept conference request"},
2665 { 2, "reject conference request"},
2666 { 3, "spare"},
2667 { 0, NULL}};
2668
2669 static const value_string isup_application_transport_parameter_value[] = {
2670 /* according 3.82/Q.763 */
2671 { 0, "Unidentified Context and Error Handling (UCEH) ASE"},
2672 { 1, "PSS1 ASE (VPN)"},
2673 { 2, "spare"},
2674 { 3, "Charging ASE"},
2675 { 4, "GAT"},
2676 { 5, "BAT ASE"},
2677 { 6, "Enhanced Unidentified Context and Error Handling ASE (EUCEH ASE)"},
2678 { 0, NULL}};
2679
2680 static const true_false_string isup_Release_call_indicator_value = {
2681 "release call",
2682 "do not release call"
2683 };
2684
2685 static const true_false_string isup_Send_notification_ind_value = {
2686 "send notification",
2687 "do not send notification"
2688 };
2689 static const value_string isup_APM_segmentation_ind_value[] = {
2690
2691 { 0x00, "final segment"},
2692 { 0x01, "number of following segments"},
2693 { 0x02, "number of following segments"},
2694 { 0x03, "number of following segments"},
2695 { 0x04, "number of following segments"},
2696 { 0x05, "number of following segments"},
2697 { 0x06, "number of following segments"},
2698 { 0x07, "number of following segments"},
2699 { 0x08, "number of following segments"},
2700 { 0x09, "number of following segments"},
2701 { 0, NULL}};
2702
2703 static const true_false_string isup_Sequence_ind_value = {
2704 "new sequence",
2705 "subsequent segment to first segment"
2706 };
2707
2708
2709 /* Generalized bit masks for 8 and 16 bits fields */
2710 #define A_8BIT_MASK 0x01
2711 #define B_8BIT_MASK 0x02
2712 #define C_8BIT_MASK 0x04
2713 #define D_8BIT_MASK 0x08
2714 #define E_8BIT_MASK 0x10
2715 #define F_8BIT_MASK 0x20
2716 #define G_8BIT_MASK 0x40
2717 #define H_8BIT_MASK 0x80
2718
2719 #define BA_8BIT_MASK 0x03
2720 #define CB_8BIT_MASK 0x06
2721 #define DC_8BIT_MASK 0x0C
2722 #define ED_8BIT_MASK 0x18
2723 #define FE_8BIT_MASK 0x30
2724 #define GF_8BIT_MASK 0x60
2725 #define HG_8BIT_MASK 0xC0
2726 #define GFE_8BIT_MASK 0x70
2727 #define HGF_8BIT_MASK 0xE0
2728 #define DCBA_8BIT_MASK 0x0F
2729 #define EDCBA_8BIT_MASK 0x1F
2730 #define HGFE_8BIT_MASK 0xF0
2731 #define GFEDCBA_8BIT_MASK 0x7F
2732 #define FEDCBA_8BIT_MASK 0x3F
2733
2734 #define A_16BIT_MASK 0x0100
2735 #define B_16BIT_MASK 0x0200
2736 #define C_16BIT_MASK 0x0400
2737 #define D_16BIT_MASK 0x0800
2738 #define E_16BIT_MASK 0x1000
2739 #define F_16BIT_MASK 0x2000
2740 #define G_16BIT_MASK 0x4000
2741 #define H_16BIT_MASK 0x8000
2742 #define I_16BIT_MASK 0x0001
2743 #define J_16BIT_MASK 0x0002
2744 #define K_16BIT_MASK 0x0004
2745 #define L_16BIT_MASK 0x0008
2746 #define M_16BIT_MASK 0x0010
2747 #define N_16BIT_MASK 0x0020
2748 #define O_16BIT_MASK 0x0040
2749 #define P_16BIT_MASK 0x0080
2750
2751 #define BA_16BIT_MASK 0x0300
2752 #define CB_16BIT_MASK 0x0600
2753 #define DC_16BIT_MASK 0x0C00
2754 #define FE_16BIT_MASK 0x3000
2755 #define HG_16BIT_MASK 0xC000
2756 #define KJ_16BIT_MASK 0x0006
2757 #define PO_16BIT_MASK 0x00C0
2758
2759 #define CBA_16BIT_MASK 0x0700
2760 #define KJI_16BIT_MASK 0x0007
2761 #define HGFE_16BIT_MASK 0xF000
2762 #define PONM_16BIT_MASK 0x00F0
2763
2764 /* Initialize the protocol and registered fields */
2765 static int proto_isup;
2766 static int proto_bicc;
2767
2768 static bool isup_show_cic_in_info = true;
2769
2770 static int hf_isup_called;
2771 static int hf_isup_calling;
2772 static int hf_isup_redirecting;
2773 static int hf_isup_redirection_number;
2774 static int hf_isup_subsequent_number;
2775 static int hf_isup_connected_number;
2776 static int hf_isup_transit_network_selection;
2777 static int hf_isup_original_called_number;
2778 static int hf_isup_location_number;
2779 static int hf_isup_call_transfer_number;
2780 static int hf_isup_called_in_number;
2781 static int hf_isup_generic_number;
2782 static int hf_isup_jurisdiction;
2783 static int hf_isup_charge_number;
2784
2785 static int hf_isup_cic;
2786 static int hf_bicc_cic;
2787
2788 static int isup_tap;
2789
2790 static int hf_isup_message_type;
2791 static int hf_isup_parameter_type;
2792 static int hf_isup_parameter_value;
2793 static int hf_isup_mand_parameter_type;
2794 static int hf_isup_opt_parameter_type;
2795 static int hf_isup_parameter_length;
2796 static int hf_isup_mandatory_variable_parameter_pointer;
2797 static int hf_isup_pointer_to_start_of_optional_part;
2798
2799 static int hf_isup_cvr_rsp_ind;
2800 static int hf_isup_cvr_cg_car_ind;
2801 static int hf_isup_cvr_cg_double_seize;
2802 static int hf_isup_cvr_cg_alarm_car_ind;
2803 static int hf_isup_cvr_cont_chk_ind;
2804
2805 static int hf_isup_satellite_indicator;
2806 static int hf_isup_continuity_check_indicator;
2807 static int hf_bicc_continuity_check_indicator;
2808 static int hf_isup_echo_control_device_indicator;
2809
2810 static int hf_isup_forw_call_natnl_inatnl_call_indicator;
2811 static int hf_isup_forw_call_end_to_end_method_indicator;
2812 static int hf_bicc_forw_call_end_to_end_method_indicator;
2813 static int hf_isup_forw_call_interworking_indicator;
2814 static int hf_isup_forw_call_end_to_end_info_indicator;
2815 static int hf_bicc_forw_call_end_to_end_info_indicator;
2816 static int hf_isup_forw_call_isdn_user_part_indicator;
2817 static int hf_bicc_forw_call_isdn_user_part_indicator;
2818 static int hf_isup_forw_call_preferences_indicator;
2819 static int hf_bicc_forw_call_preferences_indicator;
2820 static int hf_isup_forw_call_isdn_access_indicator;
2821 static int hf_isup_forw_call_ported_num_trans_indicator;
2822 static int hf_isup_forw_call_qor_attempt_indicator;
2823 static int hf_isup_forw_call_sccp_method_indicator;
2824 static int hf_bicc_forw_call_sccp_method_indicator;
2825
2826 static int hf_isup_calling_partys_category;
2827 static int hf_russian_isup_calling_partys_category;
2828
2829 static int hf_isup_transmission_medium_requirement;
2830
2831 static int hf_isup_odd_even_indicator;
2832 static int hf_isup_called_party_nature_of_address_indicator;
2833 static int hf_isup_calling_party_nature_of_address_indicator;
2834 static int hf_isup_inn_indicator;
2835 static int hf_isup_ni_indicator;
2836 static int hf_isup_numbering_plan_indicator;
2837 static int hf_isup_address_presentation_restricted_indicator;
2838 static int hf_isup_screening_indicator;
2839 static int hf_isup_screening_indicator_enhanced;
2840 static int hf_isup_called_party_odd_address_signal_digit;
2841 static int hf_isup_calling_party_odd_address_signal_digit;
2842 static int hf_isup_called_party_even_address_signal_digit;
2843 static int hf_isup_calling_party_even_address_signal_digit;
2844
2845 static int hf_isup_generic_name_presentation;
2846 static int hf_isup_generic_name_availability;
2847 static int hf_isup_generic_name_type;
2848 static int hf_isup_generic_name_ia5;
2849
2850 static int hf_isup_OECD_inf_ind;
2851 static int hf_isup_IECD_inf_ind;
2852 static int hf_isup_OECD_req_ind;
2853 static int hf_isup_IECD_req_ind;
2854
2855 static int hf_isup_calling_party_address_request_indicator;
2856 static int hf_isup_info_req_holding_indicator;
2857 static int hf_isup_calling_partys_category_request_indicator;
2858 static int hf_isup_charge_information_request_indicator;
2859 static int hf_isup_charge_number_nature_of_address_indicator;
2860 static int hf_isup_malicious_call_identification_request_indicator;
2861
2862 static int hf_isup_calling_party_address_response_indicator;
2863 static int hf_isup_hold_provided_indicator;
2864 static int hf_isup_calling_partys_category_response_indicator;
2865 static int hf_isup_charge_information_response_indicator;
2866 static int hf_isup_solicited_indicator;
2867
2868 static int hf_isup_continuity_indicator;
2869
2870 static int hf_isup_backw_call_charge_ind;
2871 static int hf_isup_backw_call_called_partys_status_ind;
2872 static int hf_isup_backw_call_called_partys_category_ind;
2873 static int hf_isup_backw_call_end_to_end_method_ind;
2874 static int hf_bicc_backw_call_end_to_end_method_ind;
2875 static int hf_isup_backw_call_interworking_ind;
2876 static int hf_isup_backw_call_end_to_end_info_ind;
2877 static int hf_bicc_backw_call_end_to_end_info_ind;
2878 static int hf_isup_backw_call_iam_seg_ind;
2879 static int hf_isup_backw_call_isdn_user_part_ind;
2880 static int hf_bicc_backw_call_isdn_user_part_ind;
2881 static int hf_isup_backw_call_holding_ind;
2882 static int hf_isup_backw_call_isdn_access_ind;
2883 static int hf_isup_backw_call_echo_control_device_ind;
2884 static int hf_isup_backw_call_sccp_method_ind;
2885 static int hf_bicc_backw_call_sccp_method_ind;
2886
2887 static int hf_isup_cause_indicator;
2888 static int hf_ansi_isup_cause_indicator;
2889
2890 static int hf_isup_suspend_resume_indicator;
2891
2892 static int hf_isup_range_indicator;
2893 static int hf_isup_bitbucket;
2894 static int hf_isup_cgs_message_type;
2895
2896 static int hf_isup_mtc_blocking_state1;
2897 static int hf_isup_mtc_blocking_state2;
2898 static int hf_isup_call_proc_state;
2899 static int hf_isup_hw_blocking_state;
2900
2901 static int hf_isup_event_ind;
2902 static int hf_isup_event_presentation_restricted_ind;
2903
2904 static int hf_isup_cug_call_ind;
2905 static int hf_isup_simple_segmentation_ind;
2906 static int hf_isup_connected_line_identity_request_ind;
2907
2908 static int hf_isup_redirecting_ind;
2909 static int hf_isup_original_redirection_reason;
2910 static int hf_isup_redirection_counter;
2911 static int hf_isup_redirection_reason;
2912
2913 static int hf_isup_type_of_network_identification;
2914 static int hf_isup_network_identification_plan;
2915
2916 static int hf_isup_map_type;
2917
2918 static int hf_isup_automatic_congestion_level;
2919
2920 static int hf_isup_inband_information_ind;
2921 static int hf_isup_call_diversion_may_occur_ind;
2922 static int hf_isup_mlpp_user_ind;
2923
2924 static int hf_isup_UUI_type;
2925 static int hf_isup_UUI_req_service1;
2926 static int hf_isup_UUI_req_service2;
2927 static int hf_isup_UUI_req_service3;
2928 static int hf_isup_UUI_res_service1;
2929 static int hf_isup_UUI_res_service2;
2930 static int hf_isup_UUI_res_service3;
2931 static int hf_isup_notification_indicator;
2932 static int hf_isup_UUI_network_discard_ind;
2933 static int hf_isup_access_delivery_ind;
2934
2935 static int hf_isup_transmission_medium_requirement_prime;
2936
2937 static int hf_isup_loop_prevention_response_ind;
2938
2939 static int hf_isup_temporary_alternative_routing_ind;
2940 static int hf_isup_extension_ind;
2941
2942 static int hf_isup_call_to_be_diverted_ind;
2943
2944 static int hf_isup_call_to_be_offered_ind;
2945
2946 static int hf_isup_conference_acceptance_ind;
2947
2948 static int hf_isup_transit_at_intermediate_exchange_ind;
2949 static int hf_isup_Release_call_ind;
2950 static int hf_isup_Send_notification_ind;
2951 static int hf_isup_Discard_message_ind_value;
2952 static int hf_isup_Discard_parameter_ind;
2953 static int hf_isup_Pass_on_not_possible_indicator;
2954 static int hf_isup_pass_on_not_possible_indicator2;
2955 static int hf_isup_Broadband_narrowband_interworking_ind;
2956 static int hf_isup_Broadband_narrowband_interworking_ind2;
2957
2958 static int hf_isup_app_cont_ident;
2959 static int hf_isup_app_Send_notification_ind;
2960 static int hf_isup_apm_segmentation_ind;
2961 static int hf_isup_apm_si_ind;
2962 static int hf_isup_apm_slr;
2963 static int hf_isup_orig_addr_len;
2964 static int hf_isup_dest_addr_len;
2965 static int hf_isup_app_Release_call_ind;
2966 static int hf_isup_cause_location;
2967
2968 static int hf_ansi_isup_coding_standard;
2969 static int hf_ansi_isup_spare_b7;
2970 static int hf_ansi_isup_type_of_nw_id;
2971 static int hf_ansi_isup_nw_id_plan;
2972 static int hf_ansi_isup_tns_nw_id_plan;
2973 static int hf_ansi_isup_nw_id;
2974 static int hf_ansi_isup_circuit_code;
2975
2976 static int hf_length_indicator;
2977 static int hf_afi;
2978 static int hf_bicc_nsap_dsp;
2979 static int hf_bicc_nsap_dsp_length;
2980 static int hf_bat_ase_identifier;
2981
2982 static int hf_Action_Indicator;
2983
2984 static int hf_Instruction_ind_for_general_action;
2985
2986 static int hf_Send_notification_ind_for_general_action;
2987
2988 static int hf_Instruction_ind_for_pass_on_not_possible;
2989
2990 static int hf_Send_notification_ind_for_pass_on_not_possible;
2991 static int hf_BCTP_Version_Indicator;
2992 static int hf_Tunnelled_Protocol_Indicator;
2993 static int hf_TPEI;
2994 static int hf_BVEI;
2995 static int hf_bncid;
2996 static int hf_bat_ase_biwfa;
2997 static int hf_characteristics;
2998
2999 static int hf_Organization_Identifier;
3000 static int hf_codec_type;
3001 static int hf_etsi_codec_type;
3002 static int hf_active_code_set;
3003 static int hf_active_code_set_12_2;
3004 static int hf_active_code_set_10_2;
3005 static int hf_active_code_set_7_95;
3006 static int hf_active_code_set_7_40;
3007 static int hf_active_code_set_6_70;
3008 static int hf_active_code_set_5_90;
3009 static int hf_active_code_set_5_15;
3010 static int hf_active_code_set_4_75;
3011 static int hf_supported_code_set;
3012 static int hf_supported_code_set_12_2;
3013 static int hf_supported_code_set_10_2;
3014 static int hf_supported_code_set_7_95;
3015 static int hf_supported_code_set_7_40;
3016 static int hf_supported_code_set_6_70;
3017 static int hf_supported_code_set_5_90;
3018 static int hf_supported_code_set_5_15;
3019 static int hf_supported_code_set_4_75;
3020 static int hf_optimisation_mode;
3021 static int hf_max_codec_modes;
3022 static int hf_bearer_control_tunneling;
3023 static int hf_Local_BCU_ID;
3024 static int hf_late_cut_through_cap_ind;
3025 static int hf_bat_ase_signal;
3026 static int hf_bat_ase_duration;
3027 static int hf_bat_ase_bearer_redir_ind;
3028 static int hf_bat_ase_default;
3029 static int hf_BAT_ASE_Comp_Report_Reason;
3030 static int hf_BAT_ASE_Comp_Report_ident;
3031 static int hf_BAT_ASE_Comp_Report_diagnostic;
3032 static int hf_nsap_ipv4_addr;
3033 static int hf_nsap_ipv6_addr;
3034 static int hf_iana_icp;
3035
3036 static int hf_isup_geo_loc_presentation_restricted_ind;
3037 static int hf_isup_geo_loc_screening_ind;
3038
3039 static int hf_isup_apm_msg_fragments;
3040 static int hf_isup_apm_msg_fragment;
3041 static int hf_isup_apm_msg_fragment_overlap;
3042 static int hf_isup_apm_msg_fragment_overlap_conflicts;
3043 static int hf_isup_apm_msg_fragment_multiple_tails;
3044 static int hf_isup_apm_msg_fragment_too_long_fragment;
3045 static int hf_isup_apm_msg_fragment_error;
3046 static int hf_isup_apm_msg_fragment_count;
3047 static int hf_isup_apm_msg_reassembled_in;
3048 static int hf_isup_apm_msg_reassembled_length;
3049
3050 /* national parameters */
3051 static int hf_isup_french_coll_field;
3052 static int hf_isup_french_msg_num;
3053
3054 static int hf_isup_israeli_charging_message_indicators_current;
3055 static int hf_isup_israeli_charging_message_indicators_next;
3056 static int hf_isup_israeli_current_rate;
3057 static int hf_isup_israeli_time_indicator;
3058 static int hf_isup_israeli_next_rate;
3059
3060 static int hf_japan_isup_redirect_capability;
3061 static int hf_japan_isup_redirect_counter;
3062 static int hf_japan_isup_rfi_info_type;
3063 static int hf_japan_isup_rfi_info_len;
3064 static int hf_japan_isup_perf_redir_reason;
3065 static int hf_japan_isup_redir_pos_ind;
3066 static int hf_japan_isup_inv_redir_reason;
3067 static int hf_japan_isup_bwd_info_type;
3068 static int hf_japan_isup_tag_len;
3069 static int hf_japan_isup_hold_at_emerg_call_disc_ind;
3070 static int hf_japan_isup_emerg_call_type;
3071 static int hf_japan_isup_add_user_cat_type;
3072 static int hf_japan_isup_type_1_add_fixed_serv_inf;
3073 static int hf_japan_isup_type_1_add_mobile_serv_inf;
3074 static int hf_japan_isup_type_2_add_mobile_serv_inf;
3075 static int hf_japan_isup_type_3_add_mobile_serv_inf;
3076 static int hf_japan_isup_reason_for_clip_fail;
3077 static int hf_japan_isup_contractor_number;
3078
3079 static int hf_isup_carrier_info_iec;
3080 /*static int hf_isup_carrier_info_cat_of_carrier;*/
3081 /*static int hf_isup_carrier_info_type_of_carrier_info;*/
3082 static int hf_japan_isup_carrier_info_length;
3083 static int hf_isup_carrier_info_odd_no_digits;
3084 static int hf_isup_carrier_info_even_no_digits;
3085 static int hf_isup_carrier_info_ca_odd_no_digits;
3086 static int hf_isup_carrier_info_ca_even_no_digits;
3087 static int hf_isup_carrier_info_poi_entry_HEI;
3088 static int hf_isup_carrier_info_poi_exit_HEI;
3089
3090 static int hf_japan_isup_charge_delay_type;
3091 static int hf_japan_isup_charge_info_type;
3092 static int hf_japan_isup_sig_elem_type;
3093 static int hf_japan_isup_activation_id;
3094 static int hf_japan_isup_op_cls;
3095 static int hf_japan_isup_op_type;
3096 static int hf_japan_isup_charging_party_type;
3097 static int hf_japan_isup_utp;
3098 static int hf_japan_isup_crci1;
3099 static int hf_japan_isup_crci2;
3100 static int hf_japan_isup_crci1_len;
3101 static int hf_japan_isup_iu;
3102 static int hf_japan_isup_dcr;
3103 static int hf_japan_isup_ecr;
3104 static int hf_japan_isup_ncr;
3105 static int hf_japan_isup_scr;
3106 static int hf_japan_isup_collecting_method;
3107 static int hf_japan_isup_tariff_rate_pres;
3108
3109 static int hf_japan_isup_charge_area_nat_of_info_value;
3110 static int hf_japan_isup_charging_info_nc_odd_digits;
3111 static int hf_japan_isup_charging_info_nc_even_digits;
3112 static int hf_isup_charging_info_maca_odd_digits;
3113 static int hf_isup_charging_info_maca_even_digits;
3114
3115 /* Generated from convert_proto_tree_add_text.pl */
3116 static int hf_isup_protocol_class;
3117 static int hf_isup_geo_loc_shape_description;
3118 static int hf_isup_geo_loc_shape;
3119 static int hf_isup_ccss_call_indicator;
3120 static int hf_isup_charged_party_identification;
3121 static int hf_isup_forward_gvns;
3122 static int hf_isup_idi;
3123 static int hf_isup_precedence_level;
3124 static int hf_isup_configuration_data;
3125 static int hf_isup_redirect_capability;
3126 static int hf_isup_credit;
3127 static int hf_isup_idp;
3128 static int hf_isup_apm_seg_indicator;
3129 static int hf_isup_user_service_information;
3130 static int hf_isup_tunnelled_protocol_data;
3131 static int hf_isup_mlpp_service_domain;
3132 static int hf_isup_uid_capability_indicators;
3133 static int hf_isup_call_identity;
3134 static int hf_isup_scf_id;
3135 static int hf_isup_call_diversion_information;
3136 static int hf_isup_display_information;
3137 static int hf_isup_call_history_info;
3138 static int hf_isup_remote_operations;
3139 static int hf_isup_user_to_user_info;
3140 static int hf_isup_address_digits;
3141 static int hf_isup_network_id;
3142 static int hf_isup_uid_action_indicators;
3143 static int hf_isup_dsp;
3144 static int hf_isup_instruction_indicators;
3145 static int hf_isup_circuit_assignment_map;
3146 static int hf_isup_collect_call_request_indicator;
3147 static int hf_isup_hop_counter;
3148 static int hf_isup_user_service_information_prime;
3149 static int hf_isup_message_compatibility_information;
3150 static int hf_isup_app_transport_param_field8;
3151 static int hf_isup_app_transport_param_field16;
3152 static int hf_isup_binary_code;
3153 static int hf_isup_local_reference;
3154 static int hf_isup_cause_indicators;
3155 static int hf_isup_backward_gvns;
3156 static int hf_isup_presentation_indicator;
3157 static int hf_isup_mcid_request_indicators;
3158 static int hf_isup_origination_isc_point_code;
3159 static int hf_isup_upgraded_parameter;
3160 static int hf_isup_generic_digits;
3161 static int hf_isup_diagnostic;
3162 static int hf_isup_network_specific_facility;
3163 static int hf_isup_app_transport_instruction_indicator;
3164 static int hf_isup_look_forward_busy;
3165 static int hf_isup_redirect_counter;
3166 static int hf_isup_correlation_id;
3167 static int hf_isup_network_identity;
3168 static int hf_isup_user_teleservice_information;
3169 static int hf_isup_mcid_response_indicators;
3170 static int hf_isup_apm_user_info_field;
3171 static int hf_isup_feature_code;
3172 static int hf_isup_number_qualifier_indicator;
3173 static int hf_isup_echo_control_information;
3174 static int hf_isup_network_id_length_indicator;
3175 static int hf_isup_unknown_organisation_identifier;
3176 static int hf_isup_originating_line_info;
3177 static int hf_isup_loop_prevention_indicator_type;
3178 static int hf_isup_signalling_point_code;
3179 static int hf_isup_call_transfer_identity;
3180 static int hf_isup_access_transport_parameter_field;
3181 static int hf_isup_propagation_delay_counter;
3182 static int hf_isup_number_different_meaning;
3183
3184 /* Initialize the subtree pointers */
3185 static int ett_isup;
3186 static int ett_isup_parameter;
3187 static int ett_isup_address_digits;
3188 static int ett_isup_carrier_info;
3189 static int ett_isup_pass_along_message;
3190 static int ett_isup_circuit_state_ind;
3191 static int ett_bat_ase;
3192 static int ett_bicc;
3193 static int ett_bat_ase_element;
3194 static int ett_bat_ase_iwfa;
3195 static int ett_acs;
3196 static int ett_scs;
3197
3198 static int ett_isup_apm_msg_fragment;
3199 static int ett_isup_apm_msg_fragments;
3200 static int ett_isup_range;
3201 static int ett_app_transport_fields;
3202 static int ett_app_transport;
3203 static int ett_apm_seg_indicator;
3204 static int ett_echo_control_information;
3205 static int ett_instruction_indicators;
3206 static int ett_message_compatibility_information;
3207
3208 static expert_field ei_isup_format_national_matter;
3209 static expert_field ei_isup_message_type_unknown;
3210 static expert_field ei_isup_not_dissected_yet;
3211 static expert_field ei_isup_message_type_no_optional_parameters;
3212 static expert_field ei_isup_status_subfield_not_present;
3213 static expert_field ei_isup_empty_number;
3214 static expert_field ei_isup_too_many_digits;
3215 static expert_field ei_isup_opt_par_length_err;
3216
3217 static dissector_handle_t bicc_handle;
3218
3219 static dissector_handle_t sdp_handle;
3220 static dissector_handle_t q931_ie_handle;
3221
3222 /* Declarations to desegment APM Messages */
3223 static bool isup_apm_desegment = true;
3224
3225 static const fragment_items isup_apm_msg_frag_items = {
3226 /* Fragment subtrees */
3227 &ett_isup_apm_msg_fragment,
3228 &ett_isup_apm_msg_fragments,
3229 /* Fragment fields */
3230 &hf_isup_apm_msg_fragments,
3231 &hf_isup_apm_msg_fragment,
3232 &hf_isup_apm_msg_fragment_overlap,
3233 &hf_isup_apm_msg_fragment_overlap_conflicts,
3234 &hf_isup_apm_msg_fragment_multiple_tails,
3235 &hf_isup_apm_msg_fragment_too_long_fragment,
3236 &hf_isup_apm_msg_fragment_error,
3237 &hf_isup_apm_msg_fragment_count,
3238 /* Reassembled in field */
3239 &hf_isup_apm_msg_reassembled_in,
3240 /* Reassembled length field */
3241 &hf_isup_apm_msg_reassembled_length,
3242 /* Reassembled data field */
3243 NULL,
3244 /* Tag */
3245 "ISUP APM Message fragments"
3246 };
3247
3248 static reassembly_table isup_apm_msg_reassembly_table;
3249
3250 /* Info for the tap that must be passed between procedures */
3251 static char *tap_called_number;
3252 static char *tap_calling_number;
3253 static uint8_t tap_cause_value;
3254
3255 /* ------------------------------------------------------------------
3256 Mapping number to ASCII-character
3257 ------------------------------------------------------------------ */
3258 static char number_to_char(int number)
3259 {
3260 if (number < 10)
3261 return ((char) number + ASCII_NUMBER_DELTA);
3262 else
3263 return ((char) number + ASCII_LETTER_DELTA);
3264 }
3265
3266 /* ------------------------------------------------------------------ */
3267 /* Dissectors for all used parameter types */
3268 /* ------------------------------------------------------------------ */
3269 /* argument tvbuff_t contains only parameter-specific length */
3270 /* length indicator is already dissected in dissect_isup_message() or */
3271 /* dissect_isup_optional_parameter() */
3272 /* ------------------------------------------------------------------ */
3273 /* ------------------------------------------------------------------
3274 Dissector Parameter circuit validation response indicator
3275 */
3276
3277 static void
3278 dissect_isup_cvr_response_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3279 {
3280 uint8_t cvr_response_ind;
3281
3282 cvr_response_ind = tvb_get_uint8(parameter_tvb, 0);
3283 proto_tree_add_uint(parameter_tree, hf_isup_cvr_rsp_ind, parameter_tvb, 0, CVR_RESP_IND_LENGTH, cvr_response_ind);
3284 proto_item_append_text(parameter_item, " : 0x%x", cvr_response_ind);
3285
3286 }
3287
3288 /* ------------------------------------------------------------------
3289 Dissector Parameter circuit validation response - circuit group
3290 characters
3291 */
3292 static void
3293 dissect_isup_circuit_group_char_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3294 {
3295 uint8_t cvr_cg_char_ind;
3296
3297 cvr_cg_char_ind = tvb_get_uint8(parameter_tvb, 0);
3298 proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_car_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3299 proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_double_seize, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3300 proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_alarm_car_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3301 proto_tree_add_uint(parameter_tree, hf_isup_cvr_cont_chk_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3302
3303 proto_item_append_text(parameter_item, " : 0x%x", cvr_cg_char_ind);
3304 }
3305
3306 /* ------------------------------------------------------------------
3307 Dissector Parameter nature of connection flags
3308 */
3309 static void
3310 dissect_isup_nature_of_connection_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3311 {
3312 uint8_t nature_of_connection_ind;
3313 static int * const isup_indicators[] = {
3314 &hf_isup_satellite_indicator,
3315 &hf_isup_continuity_check_indicator,
3316 &hf_isup_echo_control_device_indicator,
3317 NULL
3318 };
3319
3320 static int * const bicc_indicators[] = {
3321 &hf_isup_satellite_indicator,
3322 &hf_bicc_continuity_check_indicator,
3323 &hf_isup_echo_control_device_indicator,
3324 NULL
3325 };
3326
3327 nature_of_connection_ind = tvb_get_uint8(parameter_tvb, 0);
3328 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, NATURE_OF_CONNECTION_IND_LENGTH,
3329 g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
3330
3331 proto_item_append_text(parameter_item, " : 0x%x", nature_of_connection_ind);
3332 }
3333
3334 /* ------------------------------------------------------------------
3335 Dissector Parameter Forward Call Indicators
3336 */
3337 static void
3338 dissect_isup_forward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_item *parameter_item, proto_tree *parameter_tree)
3339 {
3340 uint16_t forward_call_ind = tvb_get_ntohs(parameter_tvb, 0);
3341 static int * const isup_indicators[] = {
3342 &hf_isup_forw_call_natnl_inatnl_call_indicator,
3343 &hf_isup_forw_call_end_to_end_method_indicator,
3344 &hf_isup_forw_call_interworking_indicator,
3345 &hf_isup_forw_call_end_to_end_info_indicator,
3346 &hf_isup_forw_call_isdn_user_part_indicator,
3347 &hf_isup_forw_call_preferences_indicator,
3348 &hf_isup_forw_call_isdn_access_indicator,
3349 &hf_isup_forw_call_sccp_method_indicator,
3350 &hf_isup_forw_call_ported_num_trans_indicator,
3351 &hf_isup_forw_call_qor_attempt_indicator,
3352 NULL
3353 };
3354
3355 static int * const bicc_indicators[] = {
3356 &hf_isup_forw_call_natnl_inatnl_call_indicator,
3357 &hf_bicc_forw_call_end_to_end_method_indicator,
3358 &hf_isup_forw_call_interworking_indicator,
3359 &hf_bicc_forw_call_end_to_end_info_indicator,
3360 &hf_bicc_forw_call_isdn_user_part_indicator,
3361 &hf_bicc_forw_call_preferences_indicator,
3362 &hf_isup_forw_call_isdn_access_indicator,
3363 &hf_bicc_forw_call_sccp_method_indicator,
3364 &hf_isup_forw_call_ported_num_trans_indicator,
3365 &hf_isup_forw_call_qor_attempt_indicator,
3366 NULL
3367 };
3368
3369 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, FORWARD_CALL_IND_LENGTH,
3370 g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
3371
3372 proto_item_append_text(parameter_item, " : 0x%x", forward_call_ind);
3373 }
3374
3375 /* ------------------------------------------------------------------
3376 Dissector Parameter Calling Party's Category
3377 */
3378 static void
3379 dissect_isup_calling_partys_category_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, uint8_t itu_isup_variant)
3380 {
3381 uint8_t calling_partys_category;
3382
3383 calling_partys_category = tvb_get_uint8(parameter_tvb, 0);
3384
3385 if (itu_isup_variant == ISUP_RUSSIAN_VARIANT) {
3386 proto_tree_add_uint(parameter_tree, hf_russian_isup_calling_partys_category,
3387 parameter_tvb, 0, CALLING_PRTYS_CATEGORY_LENGTH, calling_partys_category);
3388
3389 proto_item_append_text(parameter_item, " : 0x%x (%s)",
3390 calling_partys_category,
3391 val_to_str_ext_const(calling_partys_category,
3392 &russian_isup_calling_partys_category_value_ext,
3393 "reserved/spare"));
3394
3395 } else {
3396 proto_tree_add_uint(parameter_tree, hf_isup_calling_partys_category,
3397 parameter_tvb, 0, CALLING_PRTYS_CATEGORY_LENGTH, calling_partys_category);
3398
3399 proto_item_append_text(parameter_item, " : 0x%x (%s)",
3400 calling_partys_category,
3401 val_to_str_ext_const(calling_partys_category,
3402 &isup_calling_partys_category_value_ext,
3403 "reserved/spare"));
3404 }
3405 }
3406
3407
3408 /* ------------------------------------------------------------------
3409 Dissector Parameter Transmission medium requirement
3410 */
3411 static void
3412 dissect_isup_transmission_medium_requirement_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3413 {
3414 uint8_t transmission_medium_requirement;
3415
3416 transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
3417 proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement,
3418 parameter_tvb, 0, TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH, transmission_medium_requirement);
3419
3420 proto_item_append_text(parameter_item, " : %u (%s)", transmission_medium_requirement,
3421 val_to_str_ext_const(transmission_medium_requirement, &isup_transmission_medium_requirement_value_ext, "spare"));
3422 }
3423
3424 static char *
3425 dissect_isup_digits_common(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, proto_item *item,
3426 int hf_number, int hf_odd_digit, int hf_even_digit,
3427 bool even_indicator, e164_number_type_t number_type, unsigned nature_of_address)
3428 {
3429 int i = 0;
3430 int reported_length, captured_length;
3431 proto_item *digits_item;
3432 proto_tree *digits_tree;
3433 uint8_t digit_pair = 0;
3434 wmem_strbuf_t *strbuf_number;
3435 char *number;
3436 e164_info_t e164_info;
3437 int start_offset = offset;
3438
3439 reported_length = tvb_reported_length_remaining(tvb, offset);
3440 if (reported_length == 0) {
3441 expert_add_info(pinfo, item, &ei_isup_empty_number);
3442 proto_item_append_text(item, ": (empty)");
3443 return NULL;
3444 }
3445
3446 strbuf_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
3447
3448 /* Make the digit string, looping on captured length (in case a snaplen was set) */
3449 captured_length = tvb_captured_length_remaining(tvb, offset);
3450 while (captured_length > 0) {
3451 if (++i > MAXDIGITS) {
3452 break;
3453 }
3454 digit_pair = tvb_get_uint8(tvb, offset);
3455 wmem_strbuf_append_c(strbuf_number, number_to_char(digit_pair & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
3456
3457 if ((captured_length - 1) > 0) {
3458 if (++i > MAXDIGITS) {
3459 break;
3460 }
3461 wmem_strbuf_append_c(strbuf_number, number_to_char((digit_pair & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
3462 }
3463
3464 offset += 1;
3465 captured_length -= 1;
3466 }
3467
3468 if (even_indicator && (tvb_captured_length(tvb) > 0) && (++i < MAXDIGITS)) {
3469 /* Even Indicator set -> last (even) digit is valid and has be displayed */
3470 wmem_strbuf_append_c(strbuf_number, number_to_char((digit_pair & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
3471 }
3472
3473 number = wmem_strbuf_finalize(strbuf_number);
3474
3475 /* Now make the tree */
3476 offset = start_offset;
3477 i = 0;
3478 digits_item = proto_tree_add_string(tree, hf_number, tvb, offset, -1, number);
3479 digits_tree = proto_item_add_subtree(digits_item, ett_isup_address_digits);
3480
3481 while (reported_length > 0) {
3482 if (++i > MAXDIGITS) {
3483 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
3484 break;
3485 }
3486 proto_tree_add_item(digits_tree, hf_odd_digit, tvb, offset, 1, ENC_NA);
3487
3488 if ((reported_length - 1) > 0) {
3489 if (++i > MAXDIGITS) {
3490 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
3491 break;
3492 }
3493 proto_tree_add_item(digits_tree, hf_even_digit, tvb, offset, 1, ENC_NA);
3494 }
3495
3496 offset += 1;
3497 reported_length -= 1;
3498 }
3499
3500 if (even_indicator && (tvb_reported_length(tvb) > 0)) {
3501 if (++i < MAXDIGITS) {
3502 /* Even Indicator set -> last (even) digit is valid and has be displayed */
3503 proto_tree_add_item(digits_tree, hf_even_digit, tvb, offset - 1, 1, ENC_NA);
3504 } else {
3505 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
3506 }
3507 }
3508
3509 if (number_type != NONE) {
3510 e164_info.e164_number_type = number_type;
3511 e164_info.nature_of_address = nature_of_address;
3512 e164_info.E164_number_str = number;
3513 e164_info.E164_number_length = i - 1;
3514 dissect_e164_number(tvb, digits_tree, 2, (offset - 2), e164_info);
3515 }
3516
3517 proto_item_append_text(item, ": %s", number);
3518
3519 return number;
3520 }
3521
3522 /* ------------------------------------------------------------------
3523 Dissector Parameter Called party number
3524 */
3525 void
3526 dissect_isup_called_party_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3527 {
3528 uint8_t indicators1, indicators2;
3529 int offset = 0;
3530 int number_plan;
3531 static int * const indicators1_flags[] = {
3532 &hf_isup_odd_even_indicator,
3533 &hf_isup_called_party_nature_of_address_indicator,
3534 NULL
3535 };
3536
3537 static int * const indicators2_flags[] = {
3538 &hf_isup_inn_indicator,
3539 &hf_isup_numbering_plan_indicator,
3540 NULL
3541 };
3542
3543 indicators1 = tvb_get_uint8(parameter_tvb, 0);
3544 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_flags, ENC_NA);
3545 indicators2 = tvb_get_uint8(parameter_tvb, 1);
3546 number_plan = (indicators2 & 0x70)>> 4;
3547 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_flags, ENC_NA);
3548 offset = 2;
3549
3550 tap_called_number = dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
3551 hf_isup_called, hf_isup_called_party_odd_address_signal_digit,
3552 hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
3553 number_plan == 1 ? CALLED_PARTY_NUMBER : NONE,
3554 (indicators1 & 0x7f));
3555 }
3556
3557 /* ------------------------------------------------------------------
3558 Dissector Parameter Subsequent number
3559 */
3560 static void
3561 dissect_isup_subsequent_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3562 {
3563 uint8_t indicators1;
3564 int offset = 0;
3565
3566 indicators1 = tvb_get_uint8(parameter_tvb, 0);
3567 proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, indicators1);
3568 offset = 1;
3569
3570 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
3571 hf_isup_subsequent_number, hf_isup_called_party_odd_address_signal_digit,
3572 hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
3573 NONE, 0);
3574 }
3575 /* ------------------------------------------------------------------
3576 Dissector Parameter Information Request Indicators
3577 */
3578 static void
3579 dissect_isup_information_request_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3580 {
3581 static int * const indicators[] = {
3582 &hf_isup_calling_party_address_request_indicator,
3583 &hf_isup_info_req_holding_indicator,
3584 &hf_isup_calling_partys_category_request_indicator,
3585 &hf_isup_charge_information_request_indicator,
3586 &hf_isup_malicious_call_identification_request_indicator,
3587 NULL
3588 };
3589
3590 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, INFO_REQUEST_IND_LENGTH, indicators, ENC_BIG_ENDIAN);
3591
3592 proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3593 }
3594 /* ------------------------------------------------------------------
3595 Dissector Parameter Information Indicators
3596 */
3597 static void
3598 dissect_isup_information_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3599 {
3600 static int * const indicators[] = {
3601 &hf_isup_calling_party_address_response_indicator,
3602 &hf_isup_hold_provided_indicator,
3603 &hf_isup_calling_partys_category_response_indicator,
3604 &hf_isup_charge_information_response_indicator,
3605 &hf_isup_solicited_indicator,
3606 NULL
3607 };
3608
3609 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, INFO_IND_LENGTH, indicators, ENC_BIG_ENDIAN);
3610
3611 proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3612 }
3613 /* ------------------------------------------------------------------
3614 Dissector Parameter Continuity Indicators
3615 */
3616 static void
3617 dissect_isup_continuity_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3618 {
3619 uint8_t continuity_indicators;
3620
3621 continuity_indicators = tvb_get_uint8(parameter_tvb, 0);
3622 proto_tree_add_boolean(parameter_tree, hf_isup_continuity_indicator, parameter_tvb, 0, CONTINUITY_IND_LENGTH, continuity_indicators);
3623
3624 proto_item_append_text(parameter_item, " : 0x%x", continuity_indicators);
3625 }
3626 /* ------------------------------------------------------------------
3627 Dissector Parameter Backward Call Indicators
3628 */
3629 static void
3630 dissect_isup_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3631 {
3632 static int * const isup_indicators[] = {
3633 &hf_isup_backw_call_charge_ind,
3634 &hf_isup_backw_call_called_partys_status_ind,
3635 &hf_isup_backw_call_called_partys_category_ind,
3636 &hf_isup_backw_call_end_to_end_method_ind,
3637 &hf_isup_backw_call_interworking_ind,
3638 &hf_isup_backw_call_end_to_end_info_ind,
3639 &hf_isup_backw_call_isdn_user_part_ind,
3640 &hf_isup_backw_call_holding_ind,
3641 &hf_isup_backw_call_isdn_access_ind,
3642 &hf_isup_backw_call_echo_control_device_ind,
3643 &hf_isup_backw_call_sccp_method_ind,
3644 NULL
3645 };
3646
3647 static int * const bicc_indicators[] = {
3648 &hf_isup_backw_call_charge_ind,
3649 &hf_isup_backw_call_called_partys_status_ind,
3650 &hf_isup_backw_call_called_partys_category_ind,
3651 &hf_bicc_backw_call_end_to_end_method_ind,
3652 &hf_isup_backw_call_interworking_ind,
3653 &hf_bicc_backw_call_end_to_end_info_ind,
3654 &hf_bicc_backw_call_isdn_user_part_ind,
3655 &hf_isup_backw_call_holding_ind,
3656 &hf_isup_backw_call_isdn_access_ind,
3657 &hf_isup_backw_call_echo_control_device_ind,
3658 &hf_bicc_backw_call_sccp_method_ind,
3659 NULL
3660 };
3661
3662 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, BACKWARD_CALL_IND_LENGTH,
3663 g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators,
3664 ENC_BIG_ENDIAN);
3665 proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3666 }
3667
3668 static void
3669 dissect_ansi_isup_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3670 {
3671 static int * const isup_indicators[] = {
3672 &hf_isup_backw_call_charge_ind,
3673 &hf_isup_backw_call_called_partys_status_ind,
3674 &hf_isup_backw_call_called_partys_category_ind,
3675 &hf_isup_backw_call_end_to_end_method_ind,
3676 &hf_isup_backw_call_interworking_ind,
3677 &hf_isup_backw_call_iam_seg_ind,
3678 &hf_isup_backw_call_isdn_user_part_ind,
3679 &hf_isup_backw_call_holding_ind,
3680 &hf_isup_backw_call_isdn_access_ind,
3681 &hf_isup_backw_call_echo_control_device_ind,
3682 &hf_isup_backw_call_sccp_method_ind,
3683 NULL
3684 };
3685
3686 static int * const bicc_indicators[] = {
3687 &hf_isup_backw_call_charge_ind,
3688 &hf_isup_backw_call_called_partys_status_ind,
3689 &hf_isup_backw_call_called_partys_category_ind,
3690 &hf_bicc_backw_call_end_to_end_method_ind,
3691 &hf_isup_backw_call_interworking_ind,
3692 &hf_isup_backw_call_iam_seg_ind,
3693 &hf_bicc_backw_call_isdn_user_part_ind,
3694 &hf_isup_backw_call_holding_ind,
3695 &hf_isup_backw_call_isdn_access_ind,
3696 &hf_isup_backw_call_echo_control_device_ind,
3697 &hf_bicc_backw_call_sccp_method_ind,
3698 NULL
3699 };
3700
3701 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, BACKWARD_CALL_IND_LENGTH,
3702 g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
3703 proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3704 }
3705 /* ------------------------------------------------------------------
3706 Dissector Parameter Cause Indicators - no detailed dissection since defined in Rec. Q.850
3707 */
3708
3709 /*
3710 * Cause codes for Cause.
3711 * The decoding of cause indicators parameter field are defined in ITU-T
3712 * Recommendation Q.850; those are different from the ones in the Q.931
3713 * dissector, as that has some values not specified by the standard but
3714 * that appear to be used for purposes other than the ones in Q.850.
3715 */
3716 /* The table is "filled" with "unassigned" to make full use of value_string_ext */
3717 static const value_string q850_cause_code_vals[] = {
3718 { 0x00, "Valid cause code not yet received" },
3719 { 0x01, "Unallocated (unassigned) number" },
3720 { 0x02, "No route to specified transit network" },
3721 { 0x03, "No route to destination" },
3722 { 0x04, "Send special information tone" },
3723 { 0x05, "Misdialled trunk prefix" },
3724 { 0x06, "Channel unacceptable" },
3725 { 0x07, "Call awarded and being delivered in an established channel" },
3726 { 0x08, "Preemption" },
3727 { 0x09, "Preemption - circuit reserved for reuse" },
3728 { 0x0A, "Unassigned" },
3729 { 0x0B, "Unassigned" },
3730 { 0x0C, "Unassigned" },
3731 { 0x0D, "Unassigned" },
3732 { 0x0E, "QoR: ported number" },
3733 { 0x0F, "Unassigned" },
3734 { 0x10, "Normal call clearing" },
3735 { 0x11, "User busy" },
3736 { 0x12, "No user responding" },
3737 { 0x13, "No answer from user (user alerted)" },
3738 { 0x14, "Subscriber absent" },
3739 { 0x15, "Call rejected" },
3740 { 0x16, "Number changed" },
3741 { 0x17, "Redirection to new destination" },
3742 { 0x18, "Call rejected due to feature at the destination" },
3743 { 0x19, "Exchange routing error" },
3744 { 0x1A, "Non-selected user clearing" },
3745 { 0x1B, "Destination out of order" },
3746 { 0x1C, "Invalid number format (address incomplete)" },
3747 { 0x1D, "Facility rejected" },
3748 { 0x1E, "Response to STATUS ENQUIRY" },
3749 { 0x1F, "Normal unspecified" },
3750 { 0x20, "Unassigned" },
3751 { 0x21, "Circuit out of order" },
3752 { 0x22, "No circuit/channel available" },
3753 { 0x23, "Unassigned" },
3754 { 0x24, "Unassigned" },
3755 { 0x25, "Unassigned" },
3756 { 0x26, "Network out of order" },
3757 { 0x27, "Permanent frame mode connection out of service" },
3758 { 0x28, "Permanent frame mode connection operational" },
3759 { 0x29, "Temporary failure" },
3760 { 0x2A, "Switching equipment congestion" },
3761 { 0x2B, "Access information discarded" },
3762 { 0x2C, "Requested circuit/channel not available" },
3763 { 0x2D, "Unassigned" },
3764 { 0x2E, "Precedence call blocked" },
3765 { 0x2F, "Resources unavailable, unspecified" },
3766 { 0x30, "Unassigned" },
3767 { 0x31, "Quality of service unavailable" },
3768 { 0x32, "Requested facility not subscribed" },
3769 { 0x33, "Unassigned" },
3770 { 0x34, "Unassigned" },
3771 { 0x35, "Outgoing calls barred within CUG" },
3772 { 0x36, "Unassigned" },
3773 { 0x37, "Incoming calls barred within CUG" },
3774 { 0x38, "Call waiting not subscribed" },
3775 { 0x39, "Bearer capability not authorized" },
3776 { 0x3A, "Bearer capability not presently available" },
3777 { 0x3B, "Unassigned" },
3778 { 0x3C, "Unassigned" },
3779 { 0x3D, "Unassigned" },
3780 { 0x3E, "Inconsistency in designated outgoing access information and subscriber class" },
3781 { 0x3F, "Service or option not available, unspecified" },
3782 { 0x40, "Unassigned" },
3783 { 0x41, "Bearer capability not implemented" },
3784 { 0x42, "Channel type not implemented" },
3785 { 0x43, "Unassigned" },
3786 { 0x44, "Unassigned" },
3787 { 0x45, "Requested facility not implemented" },
3788 { 0x46, "Only restricted digital information bearer capability is available" },
3789 { 0x47, "Unassigned" },
3790 { 0x48, "Unassigned" },
3791 { 0x49, "Unassigned" },
3792 { 0x4A, "Unassigned" },
3793 { 0x4B, "Unassigned" },
3794 { 0x4C, "Unassigned" },
3795 { 0x4D, "Unassigned" },
3796 { 0x4E, "Unassigned" },
3797 { 0x4F, "Service or option not implemented, unspecified" },
3798 { 0x50, "Unassigned" },
3799 { 0x51, "Invalid call reference value" },
3800 { 0x52, "Identified channel does not exist" },
3801 { 0x53, "Call identity does not exist for suspended call" },
3802 { 0x54, "Call identity in use" },
3803 { 0x55, "No call suspended" },
3804 { 0x56, "Call having the requested call identity has been cleared" },
3805 { 0x57, "Called user not member of CUG" },
3806 { 0x58, "Incompatible destination" },
3807 { 0x59, "Unassigned" },
3808 { 0x5A, "Non-existing CUG" },
3809 { 0x5B, "Invalid transit network selection (national use)" },
3810 { 0x5C, "Unassigned" },
3811 { 0x5D, "Unassigned" },
3812 { 0x5E, "Unassigned" },
3813 { 0x5F, "Invalid message, unspecified" },
3814 { 0x60, "Mandatory information element is missing" },
3815 { 0x61, "Message type non-existent or not implemented" },
3816 { 0x62, "Message not compatible with call state or message type non-existent or not implemented" },
3817 { 0x63, "Information element nonexistent or not implemented" },
3818 { 0x64, "Invalid information element contents" },
3819 { 0x65, "Message not compatible with call state" },
3820 { 0x66, "Recovery on timer expiry" },
3821 { 0x67, "Parameter non-existent or not implemented - passed on" },
3822 { 0x68, "Unassigned" },
3823 { 0x69, "Unassigned" },
3824 { 0x6A, "Unassigned" },
3825 { 0x6B, "Unassigned" },
3826 { 0x6C, "Unassigned" },
3827 { 0x6D, "Unassigned" },
3828 { 0x6E, "Message with unrecognized parameter discarded" },
3829 { 0x6F, "Protocol error, unspecified" },
3830 { 0x70, "Unassigned" },
3831 { 0x71, "Unassigned" },
3832 { 0x72, "Unassigned" },
3833 { 0x73, "Unassigned" },
3834 { 0x74, "Unassigned" },
3835 { 0x75, "Unassigned" },
3836 { 0x76, "Unassigned" },
3837 { 0x77, "Unassigned" },
3838 { 0x78, "Unassigned" },
3839 { 0x79, "Unassigned" },
3840 { 0x7A, "Unassigned" },
3841 { 0x7B, "Unassigned" },
3842 { 0x7C, "Unassigned" },
3843 { 0x7D, "Unassigned" },
3844 { 0x7E, "Unassigned" },
3845 { 0x7F, "Interworking, unspecified" },
3846 { 0, NULL }
3847 };
3848 value_string_ext q850_cause_code_vals_ext = VALUE_STRING_EXT_INIT(q850_cause_code_vals);
3849
3850 static const value_string ansi_isup_cause_code_vals[] = {
3851 { 0x00, "Valid cause code not yet received" },
3852 { 0x01, "Unallocated (unassigned) number" },
3853 { 0x02, "No route to specified transit network" },
3854 { 0x03, "No route to destination" },
3855 { 0x04, "Send special information tone" },
3856 { 0x05, "Misdialled trunk prefix" },
3857 { 0x06, "Channel unacceptable" },
3858 { 0x07, "Call awarded and being delivered in an established channel" },
3859 { 0x08, "Preemption" },
3860 { 0x09, "Preemption - circuit reserved for reuse" },
3861 { 0x0A, "Unassigned" },
3862 { 0x0B, "Unassigned" },
3863 { 0x0C, "Unassigned" },
3864 { 0x0D, "Unassigned" },
3865 { 0x0E, "QoR: ported number" },
3866 { 0x0F, "Unassigned" },
3867 { 0x10, "Normal call clearing" },
3868 { 0x11, "User busy" },
3869 { 0x12, "No user responding" },
3870 { 0x13, "No answer from user (user alerted)" },
3871 { 0x14, "Subscriber absent" },
3872 { 0x15, "Call rejected" },
3873 { 0x16, "Number changed" },
3874 { 0x17, "Unallocated destination number" },
3875 { 0X18, "Undefined business group" },
3876 { 0x19, "Exchange routing error" },
3877 { 0x1A, "Non-selected user clearing" },
3878 { 0x1B, "Destination out of order" },
3879 { 0x1C, "Invalid number format (address incomplete)" },
3880 { 0x1D, "Facility rejected" },
3881 { 0x1E, "Response to STATUS ENQUIRY" },
3882 { 0x1F, "Normal unspecified" },
3883 { 0x20, "Unassigned" },
3884 { 0x21, "Circuit out of order" },
3885 { 0x22, "No circuit/channel available" },
3886 { 0x23, "Unassigned" },
3887 { 0x24, "Unassigned" },
3888 { 0x25, "Unassigned" },
3889 { 0x26, "Network out of order" },
3890 { 0x27, "Permanent frame mode connection out of service" },
3891 { 0x28, "Permanent frame mode connection operational" },
3892 { 0x29, "Temporary failure" },
3893 { 0x2A, "Switching equipment congestion" },
3894 { 0x2B, "Access information discarded" },
3895 { 0x2C, "Requested circuit/channel not available" },
3896 { 0x2D, "Preemption" },
3897 { 0x2E, "Precedence call blocked" },
3898 { 0x2F, "Resources unavailable, unspecified" },
3899 { 0x30, "Unassigned" },
3900 { 0x31, "Quality of service unavailable" },
3901 { 0x32, "Requested facility not subscribed" },
3902 { 0x33, "Call type incompatible with service request" },
3903 { 0x34, "Unassigned" },
3904 { 0x35, "Outgoing calls barred within CUG" },
3905 { 0x36, "Call blocked due to group restriction" },
3906 { 0x37, "Incoming calls barred within CUG" },
3907 { 0x38, "Call waiting not subscribed" },
3908 { 0x39, "Bearer capability not authorized" },
3909 { 0x3A, "Bearer capability not presently available" },
3910 { 0x3B, "Unassigned" },
3911 { 0x3C, "Unassigned" },
3912 { 0x3D, "Unassigned" },
3913 { 0x3E, "Inconsistency in designated outgoing access information and subscriber class" },
3914 { 0x3F, "Service or option not available, unspecified" },
3915 { 0x40, "Unassigned" },
3916 { 0x41, "Bearer capability not implemented" },
3917 { 0x42, "Channel type not implemented" },
3918 { 0x43, "Unassigned" },
3919 { 0x44, "Unassigned" },
3920 { 0x45, "Requested facility not implemented" },
3921 { 0x46, "Only restricted digital information bearer capability is available" },
3922 { 0x47, "Unassigned" },
3923 { 0x48, "Unassigned" },
3924 { 0x49, "Unassigned" },
3925 { 0x4A, "Unassigned" },
3926 { 0x4B, "Unassigned" },
3927 { 0x4C, "Unassigned" },
3928 { 0x4D, "Unassigned" },
3929 { 0x4E, "Unassigned" },
3930 { 0x4F, "Service or option not implemented, unspecified" },
3931 { 0x50, "Unassigned" },
3932 { 0x51, "Invalid call reference value" },
3933 { 0x52, "Identified channel does not exist" },
3934 { 0x53, "Call identity does not exist for suspended call" },
3935 { 0x54, "Call identity in use" },
3936 { 0x55, "No call suspended" },
3937 { 0x56, "Call having the requested call identity has been cleared" },
3938 { 0x57, "Called user not member of CUG" },
3939 { 0x58, "Incompatible destination" },
3940 { 0x59, "Unassigned" },
3941 { 0x5A, "Non-existing CUG" },
3942 { 0x5B, "Invalid transit network selection (national use)" },
3943 { 0x5C, "Unassigned" },
3944 { 0x5D, "Unassigned" },
3945 { 0x5E, "Unassigned" },
3946 { 0x5F, "Invalid message, unspecified" },
3947 { 0x60, "Mandatory information element is missing" },
3948 { 0x61, "Message type non-existent or not implemented" },
3949 { 0x62, "Message not compatible with call state or message type non-existent or not implemented" },
3950 { 0x63, "Information element nonexistent or not implemented" },
3951 { 0x64, "Invalid information element contents" },
3952 { 0x65, "Message not compatible with call state" },
3953 { 0x66, "Recovery on timer expiry" },
3954 { 0x67, "Parameter non-existent or not implemented - passed on" },
3955 { 0x68, "Unassigned" },
3956 { 0x69, "Unassigned" },
3957 { 0x6A, "Unassigned" },
3958 { 0x6B, "Unassigned" },
3959 { 0x6C, "Unassigned" },
3960 { 0x6D, "Unassigned" },
3961 { 0x6E, "Message with unrecognized parameter discarded" },
3962 { 0x6F, "Protocol error, unspecified" },
3963 { 0x70, "Unassigned" },
3964 { 0x71, "Unassigned" },
3965 { 0x72, "Unassigned" },
3966 { 0x73, "Unassigned" },
3967 { 0x74, "Unassigned" },
3968 { 0x75, "Unassigned" },
3969 { 0x76, "Unassigned" },
3970 { 0x77, "Unassigned" },
3971 { 0x78, "Unassigned" },
3972 { 0x79, "Unassigned" },
3973 { 0x7A, "Unassigned" },
3974 { 0x7B, "Unassigned" },
3975 { 0x7C, "Unassigned" },
3976 { 0x7D, "Unassigned" },
3977 { 0x7E, "Unassigned" },
3978 { 0x7F, "Internetworking, unspecified" },
3979 { 0, NULL }
3980 };
3981 static value_string_ext ansi_isup_cause_code_vals_ext = VALUE_STRING_EXT_INIT(ansi_isup_cause_code_vals);
3982
3983 static const value_string ansi_isup_coding_standard_vals[] = {
3984 { 0, "CCITT Standard" },
3985 { 1, "Reserved for other international standards" },
3986 { 2, "ANSI Standard" },
3987 { 3, "Reserved" },
3988 { 0, NULL }
3989 };
3990 void
3991 dissect_isup_cause_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
3992 { unsigned length = tvb_reported_length(parameter_tvb);
3993 proto_tree_add_item(parameter_tree, hf_isup_cause_indicators, parameter_tvb, 0, -1, ENC_NA);
3994 dissect_q931_cause_ie(parameter_tvb, 0, length,
3995 parameter_tree,
3996 hf_isup_cause_indicator, &tap_cause_value, isup_parameter_type_value);
3997 }
3998
3999 static void
4000 dissect_ansi_isup_cause_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4001 {
4002 uint8_t coding_standard;
4003 uint8_t cause_value;
4004 int offset = 0;
4005 unsigned length = tvb_reported_length(parameter_tvb);
4006
4007 coding_standard = (tvb_get_uint8(parameter_tvb, offset)&0x60)>>5;
4008
4009 switch (coding_standard) {
4010 case 0:
4011 /*CCITT*/
4012 proto_tree_add_item(parameter_tree, hf_isup_cause_location, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4013 proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4014 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4015 offset += 1;
4016 length -= 1;
4017 if (length == 0)
4018 return;
4019 proto_tree_add_item(parameter_tree, hf_isup_cause_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4020 cause_value = tvb_get_uint8(parameter_tvb, offset)&0x7f;
4021 offset += 1;
4022 length -= 1;
4023 proto_item_append_text(parameter_item, " : %s (%u)",
4024 val_to_str_ext_const(cause_value, &q850_cause_code_vals_ext, "spare"), cause_value);
4025 if (length == 0) {
4026 return;
4027 }
4028 proto_tree_add_item(parameter_tree, hf_isup_diagnostic, parameter_tvb, offset, length, ENC_NA);
4029 return;
4030 case 2:
4031 /*ANSI*/
4032 proto_tree_add_item(parameter_tree, hf_isup_cause_location, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4033 proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4034 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4035 offset += 1;
4036 length -= 1;
4037 if (length == 0)
4038 return;
4039 proto_tree_add_item(parameter_tree, hf_ansi_isup_cause_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4040 cause_value = tvb_get_uint8(parameter_tvb, offset)&0x7f;
4041 proto_item_append_text(parameter_item, " : %s (%u)",
4042 val_to_str_ext_const(cause_value, &ansi_isup_cause_code_vals_ext, "spare"),
4043 cause_value);
4044 offset += 1;
4045 length -= 1;
4046 if (length == 0) {
4047 return;
4048 }
4049 proto_tree_add_item(parameter_tree, hf_isup_diagnostic, parameter_tvb, offset, length, ENC_NA);
4050 return;
4051 default:
4052 proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4053 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4054 break;
4055 }
4056 }
4057
4058 /* ------------------------------------------------------------------
4059 Dissector ANSI Transit network selection
4060 */
4061
4062 static const value_string ansi_isup_tns_nw_id_plan_vals[] = {
4063 { 0x00, "Unknown" },
4064 { 0x01, "3-digit carrier id with circuit code" },
4065 { 0x02, "4-digit carrier id with circuit code" },
4066 { 0, NULL } };
4067
4068 static void
4069 dissect_ansi_isup_transit_network_selection_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo _U_, proto_tree *parameter_tree, proto_item *parameter_item _U_)
4070 {
4071 int offset = 0;
4072
4073 static int * const indicators_fields[] = {
4074 &hf_ansi_isup_spare_b7,
4075 &hf_isup_type_of_network_identification,
4076 &hf_ansi_isup_tns_nw_id_plan,
4077 NULL
4078 };
4079
4080 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators_fields, ENC_NA);
4081 offset = 1;
4082
4083 proto_tree_add_item(parameter_tree, hf_ansi_isup_nw_id, parameter_tvb, offset, 2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN);
4084 offset += 2;
4085 proto_tree_add_item(parameter_tree, hf_ansi_isup_circuit_code, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4086
4087 }
4088
4089 static const value_string ansi_isup_type_of_nw_id_vals[] = {
4090 { 0x00, "Spare" },
4091 { 0x01, "Spare" },
4092 { 0x02, "National network identification" },
4093 { 0x03, "Spare" },
4094 { 0x04, "Spare" },
4095 { 0x05, "Spare" },
4096 { 0x06, "Spare" },
4097 { 0x07, "Spare" },
4098 { 0, NULL } };
4099
4100 static const value_string ansi_isup_nw_id_plan_vals[] = {
4101 { 0x00, "Unknown" },
4102 { 0x01, "3-digit carrier id" },
4103 { 0x02, "4-digit carrier id" },
4104 { 0, NULL } };
4105
4106 static void
4107 dissect_ansi_isup_param_carrier_id(tvbuff_t *parameter_tvb, packet_info *pinfo _U_, proto_tree *parameter_tree, proto_item *parameter_item _U_)
4108 {
4109 int offset = 0;
4110
4111 static int * const flags[] = {
4112 &hf_ansi_isup_spare_b7,
4113 &hf_ansi_isup_type_of_nw_id,
4114 &hf_ansi_isup_nw_id_plan,
4115 NULL
4116 };
4117
4118 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, offset, 1, flags, ENC_BIG_ENDIAN);
4119 offset++;
4120
4121 proto_tree_add_item(parameter_tree, hf_ansi_isup_nw_id, parameter_tvb, offset, 2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN);
4122
4123 }
4124
4125 /* ------------------------------------------------------------------
4126 Dissector Parameter Suspend/Resume Indicators
4127 */
4128 static void
4129 dissect_isup_suspend_resume_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4130 {
4131 uint8_t indicators;
4132
4133 indicators = tvb_get_uint8(parameter_tvb, 0);
4134 proto_tree_add_boolean(parameter_tree, hf_isup_suspend_resume_indicator, parameter_tvb, 0, SUSPEND_RESUME_IND_LENGTH, indicators);
4135
4136 proto_item_append_text(parameter_item, " : 0x%x", indicators);
4137 }
4138 /* ------------------------------------------------------------------
4139 Dissector Parameter Range and Status Indicators
4140 */
4141 static void
4142 dissect_isup_range_and_status_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
4143 {
4144 proto_tree *range_tree;
4145 int offset = 0;
4146 uint8_t range, actual_status_length;
4147
4148 range = tvb_get_uint8(parameter_tvb, 0) + 1;
4149 proto_tree_add_uint_format(parameter_tree, hf_isup_range_indicator, parameter_tvb, offset, RANGE_LENGTH, range, "Range: %u", range);
4150 offset = offset + RANGE_LENGTH;
4151
4152 actual_status_length = tvb_reported_length_remaining(parameter_tvb, offset);
4153 if (actual_status_length > 0) {
4154 range_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1, ett_isup_range, NULL, "Status subfield");
4155 if (range<9) {
4156 proto_tree_add_uint_bits_format_value(range_tree, hf_isup_bitbucket, parameter_tvb, (offset*8)+(8-range), range,
4157 tvb_get_uint8(parameter_tvb, offset), ENC_BIG_ENDIAN, "%u bit 1", range);
4158 }
4159 } else {
4160 expert_add_info(pinfo, parameter_item, &ei_isup_status_subfield_not_present);
4161 }
4162
4163 proto_item_append_text(parameter_item, ": Range (%u) and status", range);
4164 }
4165 /* ------------------------------------------------------------------
4166 Dissector Parameter Circuit group supervision message type
4167 */
4168 static void
4169 dissect_isup_circuit_group_supervision_message_type_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4170 {
4171 uint8_t cgs_message_type;
4172
4173 cgs_message_type = tvb_get_uint8(parameter_tvb, 0);
4174 proto_tree_add_uint(parameter_tree, hf_isup_cgs_message_type, parameter_tvb, 0, CIRC_GRP_SV_MSG_TYPE_LENGTH, cgs_message_type);
4175
4176 proto_item_append_text(parameter_item, " : %s (%u)",
4177 val_to_str_const(cgs_message_type, isup_cgs_message_type_value, "unknown"), cgs_message_type);
4178 }
4179 /* ------------------------------------------------------------------
4180 Dissector Parameter Facility indicator parameter
4181 */
4182 static void
4183 dissect_isup_facility_ind_parameter(tvbuff_t *parameter_tvb, proto_item *parameter_item)
4184 {
4185 uint8_t indicator;
4186
4187 indicator = tvb_get_uint8(parameter_tvb, 0);
4188
4189 proto_item_append_text(parameter_item, " : %s (%u)" , val_to_str_const(indicator, isup_facility_ind_value, "spare"), indicator);
4190 }
4191 /* ------------------------------------------------------------------
4192 Dissector Parameter Circuit state indicator
4193 */
4194 static void
4195 dissect_isup_circuit_state_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4196 {
4197 proto_item *circuit_state_item;
4198 proto_tree *circuit_state_tree;
4199 uint8_t circuit_state;
4200 int offset = 0;
4201 int i = 0;
4202
4203 while (tvb_reported_length_remaining(parameter_tvb, offset) > 0) {
4204 circuit_state_tree = proto_tree_add_subtree_format(parameter_tree, parameter_tvb, offset, -1,
4205 ett_isup_circuit_state_ind, &circuit_state_item,
4206 "Circuit# CIC+%u state", i);
4207 circuit_state = tvb_get_uint8(parameter_tvb, offset);
4208 if ((circuit_state & DC_8BIT_MASK) == 0) {
4209 proto_tree_add_uint(circuit_state_tree, hf_isup_mtc_blocking_state1, parameter_tvb, offset, 1, circuit_state);
4210 proto_item_append_text(circuit_state_item, ": %s",
4211 val_to_str_const(circuit_state&BA_8BIT_MASK, isup_mtc_blocking_state_DC00_value, "unknown"));
4212 }
4213 else {
4214 proto_tree_add_uint(circuit_state_tree, hf_isup_mtc_blocking_state2, parameter_tvb, offset, 1, circuit_state);
4215 proto_tree_add_uint(circuit_state_tree, hf_isup_call_proc_state, parameter_tvb, offset, 1, circuit_state);
4216 proto_tree_add_uint(circuit_state_tree, hf_isup_hw_blocking_state, parameter_tvb, offset, 1, circuit_state);
4217 proto_item_append_text(circuit_state_item, ": %s", val_to_str_const(circuit_state&BA_8BIT_MASK, isup_mtc_blocking_state_DCnot00_value, "unknown"));
4218 }
4219 i++;
4220 offset += 1;
4221 }
4222 proto_item_append_text(parameter_item, " (national use)");
4223 }
4224 /* ------------------------------------------------------------------
4225 Dissector Parameter Event information
4226 */
4227 static void
4228 dissect_isup_event_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4229 {
4230 uint8_t indicators;
4231
4232 indicators = tvb_get_uint8(parameter_tvb, 0);
4233 proto_tree_add_uint_format_value(parameter_tree, hf_isup_event_ind, parameter_tvb, 0, EVENT_INFO_LENGTH, indicators,
4234 "%s (%u)",
4235 val_to_str_const(indicators & GFEDCBA_8BIT_MASK, isup_event_ind_value, "spare"),
4236 indicators & GFEDCBA_8BIT_MASK);
4237 proto_tree_add_boolean(parameter_tree, hf_isup_event_presentation_restricted_ind, parameter_tvb, 0, EVENT_INFO_LENGTH, indicators);
4238
4239 proto_item_append_text(parameter_item, " : %s (%u)", val_to_str_const(indicators & GFEDCBA_8BIT_MASK, isup_event_ind_value, "spare"), indicators);
4240 }
4241 /* ------------------------------------------------------------------
4242 Dissector Parameter User-to-user information- no detailed dissection since defined in Rec. Q.931
4243 */
4244 static void
4245 dissect_isup_user_to_user_information_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
4246 { unsigned length = tvb_reported_length(parameter_tvb);
4247 proto_tree_add_item(parameter_tree, hf_isup_user_to_user_info, parameter_tvb, 0, -1, ENC_NA);
4248 dissect_q931_user_user_ie(parameter_tvb, pinfo, 0, length,
4249 parameter_tree);
4250 }
4251 /* ------------------------------------------------------------------
4252 Dissector Parameter Call Reference
4253 */
4254 static void
4255 dissect_isup_call_reference_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4256 {
4257 uint32_t call_id;
4258 uint16_t spc;
4259
4260 call_id = tvb_get_ntoh24(parameter_tvb, 0);
4261 spc = tvb_get_letohs(parameter_tvb, CALL_ID_LENGTH) & 0x3FFF; /*since 1st 2 bits spare */
4262 proto_tree_add_item(parameter_tree, hf_isup_call_identity, parameter_tvb, 0, CALL_ID_LENGTH, ENC_BIG_ENDIAN);
4263 proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, CALL_ID_LENGTH, SPC_LENGTH, ENC_BIG_ENDIAN);
4264
4265 proto_item_append_text(parameter_item, " : Call ID = %u, SPC = %u", call_id, spc);
4266 }
4267 /* ------------------------------------------------------------------
4268 Dissector Parameter Access Transport - no detailed dissection since defined in Rec. Q.931
4269 */
4270 static void
4271 dissect_isup_access_transport_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree,
4272 proto_item *parameter_item _U_, packet_info *pinfo)
4273 {
4274
4275 proto_tree_add_item(parameter_tree, hf_isup_access_transport_parameter_field, parameter_tvb, 0, -1, ENC_NA);
4276
4277 if (q931_ie_handle)
4278 call_dissector(q931_ie_handle, parameter_tvb, pinfo, parameter_tree);
4279 }
4280
4281 /* dissect x.213 NSAP coded Address */
4282
4283 static const value_string x213_afi_value[] = {
4284 { NSAP_IDI_IANA_ICP_DEC, "IANA ICP, decimal"},
4285 { NSAP_IDI_IANA_ICP_BIN, "IANA ICP, binary"},
4286 { NSAP_IDI_X_121_DEC_FSD_NZ, "X.121, decimal, first significant digit non-zero"},
4287 { NSAP_IDI_X_121_BIN_FSD_NZ, "X.121, binary, first significant digit non-zero"},
4288 { NSAP_IDI_ISO_DCC_DEC, "ISO DCC, decimal"},
4289 { NSAP_IDI_ISO_DCC_BIN, "ISO DCC, binary"},
4290 { NSAP_IDI_F_69_DEC_FSD_NZ, "F.69, decimal, first significant digit non-zero"},
4291 { NSAP_IDI_F_69_BIN_FSD_NZ, "F.69, binary, first significant digit non-zero"},
4292 { NSAP_IDI_E_163_DEC_FSD_NZ, "E.163, decimal, first significant digit non-zero"},
4293 { NSAP_IDI_E_163_BIN_FSD_NZ, "E.163, binary, first significant digit non-zero"},
4294 { NSAP_IDI_E_164_DEC_FSD_NZ, "E.164, decimal, first significant digit non-zero"},
4295 { NSAP_IDI_E_164_BIN_FSD_NZ, "E.164, binary, first significant digit non-zero"},
4296 { NSAP_IDI_ISO_6523_ICD_DEC, "ISO 6523-ICD, decimal"},
4297 { NSAP_IDI_ISO_6523_ICD_BIN, "ISO 6523-ICD, binary"},
4298 { NSAP_IDI_LOCAL_DEC, "Local, decimal"},
4299 { NSAP_IDI_LOCAL_BIN, "Local, binary"},
4300 { NSAP_IDI_LOCAL_ISO_646_CHAR, "Local, ISO/IEC 646 character"},
4301 { NSAP_IDI_LOCAL_NATIONAL_CHAR, "Local, National character"},
4302 { NSAP_IDI_X_121_DEC_FSD_Z, "X.121, decimal, first significant digit zero"},
4303 { NSAP_IDI_X_121_BIN_FSD_Z, "X.121, binary, first significant digit zero"},
4304 { NSAP_IDI_F_69_DEC_FSD_Z, "F.69, decimal, first significant digit zero"},
4305 { NSAP_IDI_F_69_BIN_FSD_Z, "F.69, binary, first significant digit zero"},
4306 { NSAP_IDI_E_163_DEC_FSD_Z, "E.163, decimal, first significant digit zero"},
4307 { NSAP_IDI_E_163_BIN_FSD_Z, "E.163, binary, first significant digit zero"},
4308 { NSAP_IDI_E_164_DEC_FSD_Z, "E.164, decimal, first significant digit zero"},
4309 { NSAP_IDI_E_164_BIN_FSD_Z, "E.164, binary, first significant digit zero"},
4310
4311 { NSAP_IDI_ITU_T_IND_DEC, "ITU-T IND, decimal"},
4312 { NSAP_IDI_ITU_T_IND_BIN, "ITU-T IND, binary"},
4313
4314 { NSAP_IDI_IANA_ICP_DEC_GROUP, "IANA ICP Group no, decimal"},
4315 { NSAP_IDI_IANA_ICP_BIN_GROUP, "IANA ICP Group no, binary"},
4316 { NSAP_IDI_X_121_DEC_FSD_NZ_GROUP, "X.121 Group no, decimal, first significant digit non-zero"},
4317 { NSAP_IDI_X_121_BIN_FSD_NZ_GROUP, "X.121 Group no, binary, first significant digit non-zero"},
4318 { NSAP_IDI_ISO_DCC_DEC_GROUP, "ISO DCC Group no, decimal"},
4319 { NSAP_IDI_ISO_DCC_BIN_GROUP, "ISO DCC Group no, binary"},
4320 { NSAP_IDI_F_69_DEC_FSD_NZ_GROUP, "F.69 Group no, decimal, first significant digit non-zero"},
4321 { NSAP_IDI_F_69_BIN_FSD_NZ_GROUP, "F.69 Group no, binary, first significant digit non-zero"},
4322 { NSAP_IDI_E_163_DEC_FSD_NZ_GROUP, "E.163 Group no, decimal, first significant digit non-zero"},
4323 { NSAP_IDI_E_163_BIN_FSD_NZ_GROUP, "E.163 Group no, binary, first significant digit non-zero"},
4324 { NSAP_IDI_E_164_DEC_FSD_NZ_GROUP, "E.164 Group no, decimal, first significant digit non-zero"},
4325 { NSAP_IDI_E_164_BIN_FSD_NZ_GROUP, "E.164 Group no, binary, first significant digit non-zero"},
4326 { NSAP_IDI_ISO_6523_ICD_DEC_GROUP, "ISO 6523-ICD Group no, decimal"},
4327 { NSAP_IDI_ISO_6523_ICD_BIN_GROUP, "ISO 6523-ICD Group no, binary"},
4328 { NSAP_IDI_LOCAL_DEC_GROUP, "Local Group no, decimal"},
4329 { NSAP_IDI_LOCAL_BIN_GROUP, "Local Group no, binary"},
4330 { NSAP_IDI_LOCAL_ISO_646_CHAR_GROUP, "Local Group no, ISO/IEC 646 character"},
4331 { NSAP_IDI_LOCAL_NATIONAL_CHAR_GROUP, "Local Group no, national character"},
4332 { NSAP_IDI_X_121_DEC_FSD_Z_GROUP, "X.121 Group no, decimal, first significant digit zero"},
4333 { NSAP_IDI_X_121_BIN_FSD_Z_GROUP, "X.121 Group no, binary, first significant digit zero"},
4334 { NSAP_IDI_F_69_DEC_FSD_Z_GROUP, "F.69 Group no, decimal, first significant digit zero"},
4335 { NSAP_IDI_F_69_BIN_FSD_Z_GROUP, "F.69 Group no, binary, first significant digit zero"},
4336 { NSAP_IDI_E_163_DEC_FSD_Z_GROUP, "E.163 Group no, decimal, first significant digit zero"},
4337 { NSAP_IDI_E_163_BIN_FSD_Z_GROUP, "E.163 Group no, binary, first significant digit zero"},
4338 { NSAP_IDI_E_164_DEC_FSD_Z_GROUP, "E.164 Group no, decimal, first significant digit zero"},
4339 { NSAP_IDI_E_164_BIN_FSD_Z_GROUP, "E.163 Group no, binary, first significant digit zero"},
4340
4341 { NSAP_IDI_ITU_T_IND_DEC_GROUP, "ITU-T IND Group no, decimal"},
4342 { NSAP_IDI_ITU_T_IND_BIN_GROUP, "ITU-T IND Group no, binary"},
4343 { 0, NULL }
4344 };
4345 value_string_ext x213_afi_value_ext = VALUE_STRING_EXT_INIT(x213_afi_value);
4346
4347
4348 /* Up-to-date information on the allocated ICP values can be found in */
4349 /* RFC 4548 at */
4350 /* https://tools.ietf.org/html/rfc4548 */
4351 static const value_string iana_icp_values[] = {
4352 { 0x0, "IP Version 6 Address"},
4353 { 0x1, "IP Version 4 Address"},
4354 { 0, NULL }
4355 };
4356
4357 /*
4358 * XXX - shouldn't there be a centralized routine for dissecting NSAPs?
4359 * See also "dissect_atm_nsap()" in epan/dissectors/packet-arp.c and
4360 * "print_nsap_net()" in epan/osi_utils.c.
4361 */
4362 void
4363 dissect_nsap(tvbuff_t *parameter_tvb, int offset, int len, proto_tree *parameter_tree)
4364 {
4365 uint8_t afi;
4366 unsigned icp;
4367
4368 afi = tvb_get_uint8(parameter_tvb, offset);
4369
4370 switch (afi) {
4371 case NSAP_IDI_IANA_ICP_BIN: /* IANA ICP Binary format*/
4372 proto_tree_add_item(parameter_tree, hf_isup_idp, parameter_tvb, offset, 3, ENC_NA);
4373
4374 proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
4375 offset = offset + 1;
4376 icp = tvb_get_ntohs(parameter_tvb, offset);
4377 proto_tree_add_uint(parameter_tree, hf_iana_icp, parameter_tvb, offset, 1, icp);
4378 if (icp == 0) { /* IPv6 addr */
4379 proto_tree_add_item(parameter_tree, hf_isup_dsp, parameter_tvb, offset + 2, 17, ENC_NA);
4380 proto_tree_add_item(parameter_tree, hf_nsap_ipv6_addr, parameter_tvb, offset + 2,
4381 16, ENC_NA);
4382
4383 }
4384 else { /* IPv4 addr */
4385 /* XXX - this is really only for ICP 1 */
4386 proto_tree_add_item(parameter_tree, hf_isup_dsp, parameter_tvb, offset + 2, 17, ENC_NA);
4387 proto_tree_add_item(parameter_tree, hf_nsap_ipv4_addr, parameter_tvb, offset + 2, 4, ENC_BIG_ENDIAN);
4388 }
4389
4390 break;
4391 case NSAP_IDI_E_164_BIN_FSD_NZ: /* E.164 ATM format */
4392 case NSAP_IDI_E_164_BIN_FSD_NZ_GROUP: /* E.164 ATM group format */
4393 proto_tree_add_item(parameter_tree, hf_isup_idp, parameter_tvb, offset, 9, ENC_NA);
4394
4395 proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
4396
4397 proto_tree_add_item(parameter_tree, hf_isup_idi, parameter_tvb, offset + 1, 8, ENC_NA);
4398 offset = offset +1;
4399 /* Dissect country code */
4400 dissect_e164_cc(parameter_tvb, parameter_tree, offset, E164_ENC_BCD);
4401
4402 proto_tree_add_uint_format_value(parameter_tree, hf_bicc_nsap_dsp_length, parameter_tvb, offset, 0,
4403 (len-9), "%u (len %u -9)", (len-9), len);
4404
4405 proto_tree_add_item(parameter_tree, hf_bicc_nsap_dsp, parameter_tvb, offset + 8, (len - 9), ENC_NA);
4406
4407 break;
4408 default:
4409 proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, len, afi);
4410 }/* end switch afi */
4411
4412 }
4413
4414
4415 #define ACTION_INDICATOR 0x01
4416 #define BACKBONE_NETWORK_CONNECTION_IDENTIFIER 0x02
4417 #define INTERWORKING_FUNCTION_ADDRESS 0x03
4418 #define CODEC_LIST 0x04
4419 #define CODEC 0x05
4420 #define BAT_COMPATIBILITY_REPORT 0x06
4421 #define BEARER_NETWORK_CONNECTION_CHARACTERISTICS 0x07
4422 #define BEARER_CONTROL_INFORMATION 0x08
4423 #define BEARER_CONTROL_TUNNELLING 0x09
4424 #define BEARER_CONTROL_UNIT_IDENTIFIER 0x0A
4425 #define SIGNAL 0x0B
4426 #define BEARER_REDIRECTION_CAPABILITY 0x0C
4427 #define BEARER_REDIRECTION_INDICATORS 0x0D
4428 #define SIGNAL_TYPE 0x0E
4429 #define DURATION 0x0F
4430
4431
4432 static const value_string bat_ase_list_of_Identifiers_vals[] = {
4433
4434 { 0x00 , "spare" },
4435 { ACTION_INDICATOR , "Action Indicator" },
4436 { BACKBONE_NETWORK_CONNECTION_IDENTIFIER , "Backbone Network Connection Identifier" },
4437 { INTERWORKING_FUNCTION_ADDRESS , "Interworking Function Address" },
4438 { CODEC_LIST , "Codec List" },
4439 { CODEC , "Codec" },
4440 { BAT_COMPATIBILITY_REPORT , "BAT Compatibility Report" },
4441 { BEARER_NETWORK_CONNECTION_CHARACTERISTICS , "Bearer Network Connection Characteristics" },
4442 { BEARER_CONTROL_INFORMATION , "Bearer Control Information"},
4443 { BEARER_CONTROL_TUNNELLING , "Bearer Control Tunnelling"},
4444 { BEARER_CONTROL_UNIT_IDENTIFIER , "Bearer Control Unit Identifier" },
4445 { SIGNAL , "Signal"},
4446 { BEARER_REDIRECTION_CAPABILITY , "Bearer Redirection Capability"},
4447 { BEARER_REDIRECTION_INDICATORS , "Bearer Redirection Indicators"},
4448 { SIGNAL_TYPE , "Signal Type"},
4449 { DURATION , "Duration" },
4450 { 0, NULL }
4451 };
4452 static value_string_ext bat_ase_list_of_Identifiers_vals_ext = VALUE_STRING_EXT_INIT(bat_ase_list_of_Identifiers_vals);
4453
4454 /*ITU-T Q.765.5 (06/2000) 13*/
4455 static const value_string Instruction_indicator_for_general_action_vals[] =
4456 {
4457 { 0, "Pass on information element"},
4458 { 1, "Discard information element"},
4459 { 2, "Discard BICC data"},
4460 { 3, "Release call"},
4461 { 0, NULL}};
4462
4463 static const value_string Instruction_indicator_for_pass_on_not_possible_vals[] = {
4464 { 0, "Release call"},
4465 { 1, "Discard information element"},
4466 { 2, "Discard BICC data"},
4467 { 3, "reserved (interpreted as 00)"},
4468 { 0, NULL}};
4469
4470 static const value_string bat_ase_action_indicator_field_vals[] = {
4471
4472 { 0x00, "no indication"},
4473 { 0x01, "connect backward"},
4474 { 0x02, "connect forward"},
4475 { 0x03, "connect forward, no notification"},
4476 { 0x04, "connect forward, plus notification"},
4477 { 0x05, "connect forward, no notification + selected codec"},
4478 { 0x06, "connect forward, plus notification + selected codec"},
4479 { 0x07, "use idle"},
4480 { 0x08, "connected"},
4481 { 0x09, "switched"},
4482 { 0x0a, "selected codec"},
4483 { 0x0b, "modify codec"},
4484 { 0x0c, "successful codec modification"},
4485 { 0x0d, "codec modification failure"},
4486 { 0x0e, "mid-call codec negotiation"},
4487 { 0x0f, "modify to selected codec information"},
4488 { 0x10, "mid-call codec negotiation failure"},
4489 { 0x11, "start signal, notify"},
4490 { 0x12, "start signal, no notify"},
4491 { 0x13, "stop signal, notify"},
4492 { 0x14, "stop signal, no notify"},
4493 { 0x15, "start signal acknowledge"},
4494 { 0x16, "start signal reject"},
4495 { 0x17, "stop signal acknowledge"},
4496 { 0x18, "bearer redirect"},
4497 { 0, NULL }
4498 };
4499 static value_string_ext bat_ase_action_indicator_field_vals_ext = VALUE_STRING_EXT_INIT(bat_ase_action_indicator_field_vals);
4500
4501 static const true_false_string BCTP_BVEI_value = {
4502 "Version Error Indication, BCTP version not supported",
4503 "No indication"
4504 };
4505
4506 static const value_string BCTP_Tunnelled_Protocol_Indicator_vals[] = {
4507
4508 { 0x20, "IPBCP (text encoded)"},
4509 { 0x21, "spare (text encoded protocol)"},
4510 { 0x22, "not used"},
4511 { 0, NULL }
4512 };
4513
4514 static const true_false_string BCTP_TPEI_value = {
4515 "Protocol Error Indication, Bearer Control Protocol not supported",
4516 "No indication"
4517 };
4518
4519
4520 #define ITU_T 0x01
4521 #define ETSI 0x02
4522
4523 static const value_string bat_ase_organization_identifier_subfield_vals[] = {
4524
4525 { 0x00, "no indication"},
4526 { 0x01, "ITU-T"},
4527 { 0x02, "ETSI (refer to TS 26.103)"},
4528 { 0, NULL }
4529 };
4530
4531 #define G_711_64_A 0x01
4532 #define G_711_64_U 0x02
4533 #define G_711_56_A 0x03
4534 #define G_711_56_U 0x04
4535 #define G_722_SB_ADPCM 0x05
4536 #define G_723_1 0x06
4537 #define G_723_1_Annex_A 0x07
4538 #define G_726_ADPCM 0x08
4539 #define G_727_Embedded_ADPCM 0x09
4540 #define G_728 0x0a
4541 #define G_729_CS_ACELP 0x0b
4542 #define G_729_Annex_B 0x0c
4543
4544 static const value_string ITU_T_codec_type_subfield_vals[] = {
4545
4546 { 0x00, "no indication"},
4547 { G_711_64_A, "G.711 64 kbit/s A-law"},
4548 { G_711_64_U, "G.711 64 kbit/s -law"},
4549 { G_711_56_A, "G.711 56 kbit/s A-law"},
4550 { G_711_56_U, "G.711 56 kbit/s -law"},
4551 { G_722_SB_ADPCM, "G.722 (SB-ADPCM)"},
4552 { G_723_1, "G.723.1"},
4553 { G_723_1_Annex_A, "G.723.1 Annex A (silence suppression)"},
4554 { G_726_ADPCM, "G.726 (ADPCM)"},
4555 { G_727_Embedded_ADPCM, "G.727 (Embedded ADPCM)"},
4556 { G_728, "G.728"},
4557 { G_729_CS_ACELP, "G.729 (CS-ACELP)"},
4558 { G_729_Annex_B, "G.729 Annex B (silence suppression)"},
4559 { 0, NULL }
4560 };
4561 static value_string_ext ITU_T_codec_type_subfield_vals_ext = VALUE_STRING_EXT_INIT(ITU_T_codec_type_subfield_vals);
4562
4563 static const value_string ETSI_codec_type_subfield_vals[] = {
4564
4565 { 0x00, "GSM Full Rate (13.0 kBit/s)(GSM FR)"},
4566 { 0x01, "GSM Half Rate (5.6 kBit/s) (GSM HR)"},
4567 { 0x02, "GSM Enhanced Full Rate (12.2 kBit/s)(GSM EFR)"},
4568 { 0x03, "Full Rate Adaptive Multi-Rate (FR AMR)"},
4569 { 0x04, "Half Rate Adaptive Multi-Rate (HR AMR)"},
4570 { 0x05, "UMTS Adaptive Multi-Rate (UMTS AMR)"},
4571 { 0x06, "UMTS Adaptive Multi-Rate 2 (UMTS AMR 2)"},
4572 { 0x07, "TDMA Enhanced Full Rate (7.4 kBit/s) (TDMA EFR)"},
4573 { 0x08, "PDC Enhanced Full Rate (6.7 kBit/s) (PDC EFR)"},
4574 { 0x09, "Full Rate Adaptive Multi-Rate WideBand (FR AMR-WB)"},
4575 { 0x0a, "UMTS Adaptive Multi-Rate WideBand (UMTS AMR-WB)"},
4576 { 0x0b, "8PSK Half Rate Adaptive Multi-Rate (OHR AMR)"},
4577 { 0x0c, "8PSK Full Rate Adaptive Multi-Rate WideBand (OFR AMR-WB)"},
4578 { 0x0d, "8PSK Half Rate Adaptive Multi-Rate WideBand (OHR AMR-WB)"},
4579 { 0xfe, "Reserved for future use."},
4580 { 0xff, "Reserved for MuMe dummy Codec Type (MuMe)"},
4581 { 0, NULL }
4582 };
4583 static value_string_ext ETSI_codec_type_subfield_vals_ext = VALUE_STRING_EXT_INIT(ETSI_codec_type_subfield_vals);
4584
4585 #if 0
4586 static const value_string bat_initial_codec_mode_vals[] = {
4587 {0x7, "12.2 kbps"},
4588 {0x6, "10.2 kbps"},
4589 {0x5, "7.95 kbps"},
4590 {0x4, "7.40 kbps"},
4591 {0x3, "6.70 kbps"},
4592 {0x2, "5.90 kbps"},
4593 {0x1, "5.15 kbps"},
4594 {0x0, "4.75 kbps"},
4595 {0, NULL}
4596 };
4597 #endif
4598
4599 static const value_string optimisation_mode_vals[] = {
4600 { 0, "Optimisation of the ACS not supported,"},
4601 { 1, "Optimisation of the ACS supported,"},
4602 { 0, NULL }
4603 };
4604
4605 static const value_string bearer_network_connection_characteristics_vals[] = {
4606
4607 { 0x00, "no indication"},
4608 { 0x01, "AAL type 1"},
4609 { 0x02, "AAL type 2"},
4610 { 0x03, "Structured AAL type 1"},
4611 { 0x04, "IP/RTP"},
4612 { 0x05, "TDM (reserved for use by ITU-T Rec. Q.1950)"},
4613 { 0, NULL }
4614 };
4615 value_string_ext bearer_network_connection_characteristics_vals_ext = VALUE_STRING_EXT_INIT(bearer_network_connection_characteristics_vals);
4616
4617 static const true_false_string Bearer_Control_Tunnelling_ind_value = {
4618 "Tunnelling to be used",
4619 "No indication"
4620 };
4621
4622 static const true_false_string late_cut_through_cap_ind_value = {
4623 "Late Cut-through supported",
4624 "Late Cut-through not supported"
4625 };
4626 /* ITU-T Rec. Q.765.5/Amd.1 (07/2001) */
4627 static const value_string Bearer_Redirection_Indicator_vals[] = {
4628 { 0x00, " no indication"},
4629 { 0x01, "late cut-through request"},
4630 { 0x02, "redirect temporary reject"},
4631 { 0x03, "redirect backwards request"},
4632 { 0x04, "redirect forwards request"},
4633 { 0x05, "redirect bearer release request"},
4634 { 0x06, "redirect bearer release proceed"},
4635 { 0x07, "redirect bearer release complete"},
4636 { 0x08, "redirect cut-through request"},
4637 { 0x09, "redirect bearer connected indication"},
4638 { 0x0a, "redirect failure"},
4639 { 0x0b, "new connection identifier"},
4640 { 0, NULL }
4641 };
4642 static value_string_ext Bearer_Redirection_Indicator_vals_ext = VALUE_STRING_EXT_INIT(Bearer_Redirection_Indicator_vals);
4643
4644 /*26/Q.765.5 - Signal Type */
4645 static const value_string BAT_ASE_Signal_Type_vals[] = {
4646 { 0x00, "DTMF 0"},
4647 { 0x01, "DTMF 1"},
4648 { 0x02, "DTMF 2"},
4649 { 0x03, "DTMF 3"},
4650 { 0x04, "DTMF 4"},
4651 { 0x05, "DTMF 5"},
4652 { 0x06, "DTMF 6"},
4653 { 0x07, "DTMF 7"},
4654 { 0x08, "DTMF 8"},
4655 { 0x09, "DTMF 9"},
4656 { 0x0a, "DTMF *"},
4657 { 0x0b, "DTMF #"},
4658 { 0x0c, "DTMF A"},
4659 { 0x0d, "DTMF B"},
4660 { 0x0e, "DTMF C"},
4661 { 0x0f, "DTMF D"},
4662 /* 0001 0000
4663 * to
4664 * 0011 1111
4665 * Spare
4666 */
4667 { 0x10, "Spare"},
4668 { 0x11, "Spare"},
4669 { 0x12, "Spare"},
4670 { 0x13, "Spare"},
4671 { 0x14, "Spare"},
4672 { 0x15, "Spare"},
4673 { 0x16, "Spare"},
4674 { 0x17, "Spare"},
4675 { 0x18, "Spare"},
4676 { 0x19, "Spare"},
4677 { 0x1a, "Spare"},
4678 { 0x1b, "Spare"},
4679 { 0x1c, "Spare"},
4680 { 0x1d, "Spare"},
4681 { 0x1e, "Spare"},
4682 { 0x1f, "Spare"},
4683 { 0x20, "Spare"},
4684 { 0x21, "Spare"},
4685 { 0x22, "Spare"},
4686 { 0x23, "Spare"},
4687 { 0x24, "Spare"},
4688 { 0x25, "Spare"},
4689 { 0x26, "Spare"},
4690 { 0x27, "Spare"},
4691 { 0x28, "Spare"},
4692 { 0x29, "Spare"},
4693 { 0x2a, "Spare"},
4694 { 0x2b, "Spare"},
4695 { 0x2c, "Spare"},
4696 { 0x2d, "Spare"},
4697 { 0x2e, "Spare"},
4698 { 0x2f, "Spare"},
4699 { 0x30, "Spare"},
4700 { 0x31, "Spare"},
4701 { 0x32, "Spare"},
4702 { 0x33, "Spare"},
4703 { 0x34, "Spare"},
4704 { 0x35, "Spare"},
4705 { 0x36, "Spare"},
4706 { 0x37, "Spare"},
4707 { 0x38, "Spare"},
4708 { 0x39, "Spare"},
4709 { 0x3a, "Spare"},
4710 { 0x3b, "Spare"},
4711 { 0x3c, "Spare"},
4712 { 0x3d, "Spare"},
4713 { 0x3e, "Spare"},
4714 { 0x3f, "Spare"},
4715
4716 { 0x40, "dial tone"},
4717 { 0x41, "PABX internal dial tone"},
4718 { 0x42, "special dial tone"},
4719 { 0x43, "second dial tone"},
4720 { 0x44, "ringing tone"},
4721 { 0x45, "special ringing tone"},
4722 { 0x46, "busy tone"},
4723 { 0x47, "congestion tone"},
4724 { 0x48, "special information tone"},
4725 { 0x49, "warning tone"},
4726 { 0x4a, "intrusion tone"},
4727 { 0x4b, "call waiting tone"},
4728 { 0x4c, "pay tone"},
4729 { 0x4d, "payphone recognition tone"},
4730 { 0x4e, "comfort tone"},
4731 { 0x4f, "tone on hold"},
4732 { 0x50, "record tone"},
4733 { 0x51, "Caller waiting tone"},
4734 { 0x52, "positive indication tone"},
4735 { 0x53, "negative indication tone"},
4736 { 0, NULL }
4737 };
4738 static value_string_ext BAT_ASE_Signal_Type_vals_ext = VALUE_STRING_EXT_INIT(BAT_ASE_Signal_Type_vals);
4739
4740 static const value_string BAT_ASE_Report_Reason_vals[] = {
4741
4742 { 0x00, "no indication"},
4743 { 0x01, "information element non-existent or not implemented"},
4744 { 0x02, "BICC data with unrecognized information element, discarded"},
4745 { 0, NULL }
4746 };
4747 /* This routine should be called with offset at Organization_Identifier not the lengh indicator
4748 * because of use from other disectors.
4749 */
4750 extern int dissect_codec_mode(proto_tree *tree, tvbuff_t *tvb, int offset, int len) {
4751 uint8_t tempdata;
4752 static int * const active_code_sets[] = {
4753 &hf_active_code_set_12_2,
4754 &hf_active_code_set_10_2,
4755 &hf_active_code_set_7_95,
4756 &hf_active_code_set_7_40,
4757 &hf_active_code_set_6_70,
4758 &hf_active_code_set_5_90,
4759 &hf_active_code_set_5_15,
4760 &hf_active_code_set_4_75,
4761 NULL
4762 };
4763
4764 static int * const supported_code_sets[] = {
4765 &hf_supported_code_set_12_2,
4766 &hf_supported_code_set_10_2,
4767 &hf_supported_code_set_7_95,
4768 &hf_supported_code_set_7_40,
4769 &hf_supported_code_set_6_70,
4770 &hf_supported_code_set_5_90,
4771 &hf_supported_code_set_5_15,
4772 &hf_supported_code_set_4_75,
4773 NULL
4774 };
4775
4776 tempdata = tvb_get_uint8(tvb, offset);
4777 proto_tree_add_uint(tree, hf_Organization_Identifier , tvb, offset, 1, tempdata);
4778 switch (tempdata) {
4779 case ITU_T :
4780 offset = offset + 1;
4781 tempdata = tvb_get_uint8(tvb, offset);
4782 proto_tree_add_uint(tree, hf_codec_type , tvb, offset, 1, tempdata);
4783 offset = offset + 1;
4784 switch (tempdata) {
4785 case G_711_64_A :
4786 case G_711_64_U :
4787 case G_711_56_A :
4788 case G_711_56_U :
4789 case G_722_SB_ADPCM :
4790 case G_723_1 :
4791 case G_723_1_Annex_A :
4792 /* These codecs have no configuration data */
4793 break;
4794 case G_726_ADPCM :
4795 case G_727_Embedded_ADPCM :
4796 /* four bit config data, TODO decode config */
4797 if (len > 2) {
4798 proto_tree_add_item(tree, hf_isup_configuration_data, tvb, offset, 1, ENC_NA);
4799 offset = offset + 1;
4800 }
4801 break;
4802 case G_728 :
4803 case G_729_CS_ACELP :
4804 case G_729_Annex_B :
4805 /* three bit config data, TODO decode config */
4806 if (len > 2) {
4807 proto_tree_add_item(tree, hf_isup_configuration_data, tvb, offset, 1, ENC_NA);
4808 offset = offset + 1;
4809 }
4810 break;
4811 default:
4812 break;
4813
4814 }
4815 break;
4816 case ETSI:
4817 offset = offset + 1;
4818 tempdata = tvb_get_uint8(tvb, offset);
4819 proto_tree_add_uint(tree, hf_etsi_codec_type , tvb, offset, 1, tempdata);
4820 if (len > 2) {
4821 offset = offset + 1;
4822
4823 proto_tree_add_bitmask_with_flags(tree, tvb, offset, hf_active_code_set,
4824 ett_acs, active_code_sets, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);
4825 }
4826 if (len > 3) {
4827 offset = offset + 1;
4828
4829 proto_tree_add_bitmask_with_flags(tree, tvb, offset, hf_supported_code_set,
4830 ett_acs, supported_code_sets, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);
4831 }
4832 if (len > 4) {
4833 offset = offset + 1;
4834 proto_tree_add_item(tree, hf_optimisation_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
4835 proto_tree_add_item(tree, hf_max_codec_modes, tvb, offset, 1, ENC_LITTLE_ENDIAN);
4836 }
4837 offset = offset + 1;
4838 break;
4839 default:
4840 offset = offset + 1;
4841 proto_tree_add_item(tree, hf_isup_unknown_organisation_identifier, tvb, offset, len, ENC_NA);
4842 offset = offset + len - 1;
4843 break;
4844 }
4845 /* switch OID */
4846
4847 return offset;
4848 }
4849
4850 static int
4851 dissect_codec(tvbuff_t *parameter_tvb, proto_tree *bat_ase_element_tree, int length_indicator, int offset, int identifier)
4852 {
4853 /* offset is at length indicator e.g 1 step past identifier */
4854 static int * const compatibility_info[] = {
4855 &hf_Instruction_ind_for_general_action,
4856 &hf_Send_notification_ind_for_general_action,
4857 &hf_Instruction_ind_for_pass_on_not_possible,
4858 &hf_Send_notification_ind_for_pass_on_not_possible,
4859 &hf_isup_extension_ind,
4860 NULL
4861 };
4862
4863 proto_tree_add_uint(bat_ase_element_tree , hf_bat_ase_identifier , parameter_tvb, offset - 1, 1, identifier);
4864 proto_tree_add_uint(bat_ase_element_tree , hf_length_indicator , parameter_tvb, offset, 1, length_indicator);
4865 offset = offset + 1;
4866
4867 proto_tree_add_bitmask_list(bat_ase_element_tree, parameter_tvb, offset, 1, compatibility_info, ENC_NA);
4868
4869 offset = dissect_codec_mode(bat_ase_element_tree, parameter_tvb, offset+1, length_indicator-1);
4870 return offset;
4871 }
4872
4873 /* Dissect BAT ASE message according to Q.765.5 200006 and Amendment 1 200107
4874 * Layout of message Length Octet
4875 * Element name
4876 * Identifier 1 1
4877 * Length indicator 1 2
4878 * Compatibility information 1 3
4879 * Contents 1 4
4880 * Identifier n m
4881 * Length indicator n
4882 * Compatibility information n
4883 * Contents n p
4884 */
4885
4886 static void
4887 dissect_bat_ase_Encapsulated_Application_Information(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, int offset)
4888 {
4889 int list_end;
4890 tvbuff_t *next_tvb;
4891 proto_tree *bat_ase_tree, *bat_ase_element_tree, *bat_ase_iwfa_tree;
4892 proto_item *bat_ase_element_item, *bat_ase_iwfa_item;
4893 uint8_t identifier, content, BCTP_Indicator_field_1, BCTP_Indicator_field_2;
4894 uint8_t tempdata, element_no, number_of_indicators;
4895 uint16_t sdp_length;
4896 uint8_t diagnostic_len;
4897 uint8_t length_ind_len;
4898 unsigned tempdata16;
4899 unsigned content_len, length_indicator;
4900 unsigned duration;
4901 unsigned diagnostic;
4902 uint32_t bncid;
4903
4904 element_no = 0;
4905
4906 bat_ase_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1, ett_bat_ase, NULL,
4907 "Bearer Association Transport (BAT) Application Service Element (ASE) Encapsulated Application Information:");
4908
4909 while (tvb_reported_length_remaining(parameter_tvb, offset) > 0) {
4910 element_no = element_no + 1;
4911 identifier = tvb_get_uint8(parameter_tvb, offset);
4912
4913 /* length indicator may be 11 bits long */
4914 offset = offset + 1;
4915 proto_tree_add_item(bat_ase_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4916 tempdata = tvb_get_uint8(parameter_tvb, offset);
4917 if (tempdata & 0x80) {
4918 length_indicator = tempdata & 0x7f;
4919 length_ind_len = 1;
4920 }
4921 else {
4922 offset = offset + 1;
4923 tempdata16 = (tempdata & 0x7f);
4924 length_indicator = tvb_get_uint8(parameter_tvb, offset)& 0x0f;
4925 length_indicator = length_indicator << 7;
4926 length_indicator = length_indicator + tempdata16;
4927 length_ind_len = 2;
4928 }
4929
4930 bat_ase_element_tree = proto_tree_add_subtree_format(bat_ase_tree, parameter_tvb,
4931 (offset - length_ind_len), (length_indicator + 2),
4932 ett_bat_ase_element, &bat_ase_element_item,
4933 "BAT ASE Element %u, Identifier: %s", element_no,
4934 val_to_str_ext(identifier, &bat_ase_list_of_Identifiers_vals_ext, "unknown (%u)"));
4935
4936 if (identifier != CODEC) {
4937 /* identifier, length indicator and compatibility info must be printed inside CODEC */
4938 /* dissection in order to use dissect_codec routine for codec list */
4939 proto_tree_add_uint(bat_ase_element_tree , hf_bat_ase_identifier , parameter_tvb,
4940 offset - length_ind_len, 1, identifier);
4941 proto_tree_add_uint(bat_ase_element_tree , hf_length_indicator , parameter_tvb,
4942 offset - length_ind_len + 1, length_ind_len, length_indicator);
4943
4944 offset = offset + 1;
4945 proto_tree_add_item(bat_ase_element_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4946 proto_tree_add_item(bat_ase_element_tree, hf_Send_notification_ind_for_pass_on_not_possible, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4947 proto_tree_add_item(bat_ase_element_tree, hf_Instruction_ind_for_pass_on_not_possible, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4948 proto_tree_add_item(bat_ase_element_tree, hf_Send_notification_ind_for_general_action, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4949 proto_tree_add_item(bat_ase_element_tree, hf_Instruction_ind_for_general_action, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4950 offset = offset + 1;
4951 }
4952 content_len = length_indicator - 1 ; /* exclude the treated Compatibility information */
4953
4954 /* content will be different depending on identifier */
4955 switch (identifier) {
4956
4957 case ACTION_INDICATOR :
4958
4959 content = tvb_get_uint8(parameter_tvb, offset);
4960 proto_tree_add_uint(bat_ase_element_tree, hf_Action_Indicator , parameter_tvb, offset, 1, content);
4961 proto_item_append_text(bat_ase_element_item, " - %s",
4962 val_to_str_ext(content, &bat_ase_action_indicator_field_vals_ext, "unknown (%u)"));
4963 offset = offset + 1;
4964 break;
4965 case BACKBONE_NETWORK_CONNECTION_IDENTIFIER :
4966
4967 bncid = tvb_get_ntohl(parameter_tvb, offset);
4968 switch (content_len) {
4969 case 1:
4970 bncid = bncid & 0x000000ff;
4971 break;
4972 case 2:
4973 bncid = bncid & 0x0000ffff;
4974 break;
4975 case 3:
4976 bncid = bncid & 0x00ffffff;
4977 break;
4978 case 4:;
4979 default:;
4980 }
4981 proto_tree_add_uint_format(bat_ase_element_tree, hf_bncid, parameter_tvb, offset, content_len, bncid, "BNCId: 0x%08x", bncid);
4982 proto_item_append_text(bat_ase_element_item, " - 0x%08x", bncid);
4983 offset = offset + content_len;
4984
4985 break;
4986 case INTERWORKING_FUNCTION_ADDRESS :
4987 bat_ase_iwfa_item = proto_tree_add_item(bat_ase_element_tree, hf_bat_ase_biwfa, parameter_tvb, offset, content_len,
4988 ENC_NA);
4989 bat_ase_iwfa_tree = proto_item_add_subtree(bat_ase_iwfa_item , ett_bat_ase_iwfa);
4990 dissect_nsap(parameter_tvb, offset, content_len, bat_ase_iwfa_tree);
4991
4992 offset = offset + content_len;
4993 break;
4994 case CODEC_LIST :
4995 list_end = offset + content_len;
4996 while (offset < (list_end - 1)) {
4997 identifier = tvb_get_uint8(parameter_tvb, offset);
4998 offset = offset + 1;
4999 tempdata = tvb_get_uint8(parameter_tvb, offset);
5000 if (tempdata & 0x80) {
5001 length_indicator = tempdata & 0x7f;
5002 }
5003 else {
5004 offset = offset +1;
5005 length_indicator = tvb_get_uint8(parameter_tvb, offset);
5006 length_indicator = length_indicator << 7;
5007 length_indicator = length_indicator & (tempdata & 0x7f);
5008 }
5009 offset = dissect_codec(parameter_tvb, bat_ase_element_tree, length_indicator , offset, identifier);
5010 }
5011 break;
5012 case CODEC :
5013 /* offset is at length indicator in this case */
5014 offset = dissect_codec(parameter_tvb, bat_ase_element_tree, length_indicator , offset, identifier);
5015 break;/* case codec */
5016 case BAT_COMPATIBILITY_REPORT :
5017 tempdata = tvb_get_uint8(parameter_tvb, offset);
5018 proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_Reason, parameter_tvb, offset, 1, tempdata);
5019 offset = offset + 1;
5020
5021 diagnostic_len = content_len - 1;
5022 while (diagnostic_len > 0) {
5023 tempdata = tvb_get_uint8(parameter_tvb, offset);
5024 proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_ident, parameter_tvb, offset, 1, tempdata);
5025 offset = offset + 1;
5026 diagnostic = tvb_get_letohs(parameter_tvb, offset);
5027 proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_diagnostic, parameter_tvb, offset, 2, diagnostic);
5028 offset = offset + 2;
5029 diagnostic_len = diagnostic_len - 3;
5030 }
5031 break;
5032 case BEARER_NETWORK_CONNECTION_CHARACTERISTICS :
5033 tempdata = tvb_get_uint8(parameter_tvb, offset);
5034 proto_tree_add_uint(bat_ase_element_tree, hf_characteristics , parameter_tvb,
5035 offset, 1, tempdata);
5036 proto_item_append_text(bat_ase_element_item, " - %s",
5037 val_to_str_ext(tempdata, &bearer_network_connection_characteristics_vals_ext, "unknown (%u)"));
5038
5039 offset = offset + content_len;
5040 break;
5041 /* The Bearer Control Information information element contains the bearer control tunnelling protocol */
5042 /* ITU-T Q.1990 (2001), BICC bearer control tunnelling protocol. */
5043
5044 case BEARER_CONTROL_INFORMATION :
5045 BCTP_Indicator_field_1 = tvb_get_uint8(parameter_tvb, offset);
5046 proto_tree_add_uint(bat_ase_element_tree, hf_BCTP_Version_Indicator,
5047 parameter_tvb, offset, 1, BCTP_Indicator_field_1);
5048
5049 proto_tree_add_boolean(bat_ase_element_tree, hf_BVEI,
5050 parameter_tvb, offset, 1, BCTP_Indicator_field_1);
5051 offset = offset + 1;
5052
5053 BCTP_Indicator_field_2 = tvb_get_uint8(parameter_tvb, offset);
5054
5055 proto_tree_add_uint(bat_ase_element_tree, hf_Tunnelled_Protocol_Indicator ,
5056 parameter_tvb, offset, 1, BCTP_Indicator_field_2);
5057
5058 proto_tree_add_boolean(bat_ase_element_tree, hf_TPEI,
5059 parameter_tvb, offset, 1, BCTP_Indicator_field_2);
5060 offset = offset + 1;
5061
5062 sdp_length = (length_indicator) - 3;
5063
5064 if (sdp_length > tvb_reported_length_remaining(parameter_tvb, offset)) {
5065 /* If this is a segmented message we may not have all the data */
5066 next_tvb = tvb_new_subset_remaining(parameter_tvb, offset);
5067 } else {
5068 next_tvb = tvb_new_subset_length(parameter_tvb, offset, sdp_length);
5069 }
5070 if (BCTP_Indicator_field_2==0x20) {
5071 /* IPBCP (text encoded) */
5072 call_dissector(sdp_handle, next_tvb, pinfo, bat_ase_element_tree);
5073 } else {
5074 proto_tree_add_item(bat_ase_element_tree, hf_isup_tunnelled_protocol_data, next_tvb, 0, -1, ENC_NA);
5075 }
5076 offset = offset + sdp_length;
5077 break;
5078 case BEARER_CONTROL_TUNNELLING :
5079
5080 tempdata = tvb_get_uint8(parameter_tvb, offset);
5081 proto_tree_add_boolean(bat_ase_element_tree, hf_bearer_control_tunneling , parameter_tvb, offset, 1, (tempdata & 0x01));
5082 if (tempdata & 0x01)
5083 proto_item_append_text(bat_ase_element_item, " - Tunnelling to be used ");
5084
5085 offset = offset + content_len;
5086 break;
5087 case BEARER_CONTROL_UNIT_IDENTIFIER :
5088 tempdata = tvb_get_uint8(parameter_tvb, offset);
5089 proto_tree_add_item(bat_ase_element_tree, hf_isup_network_id_length_indicator, parameter_tvb, offset, 1, ENC_NA);
5090 offset = offset + 1;
5091 if (tempdata > 0) {
5092
5093 /* Q.765.5 amd 1
5094 Network ID
5095 The coding of the Network ID field is identical to the coding of the Network ID field in the
5096 Global Call Reference parameter as specified in clause 6/Q.1902.3 (see [3]).
5097 NOTE .When used inside a network domain, the Network ID may be omitted by setting the
5098 Network ID Length indicator to the value "0".
5099 Q.1902.3
5100 The following codes are used in the subfields of the global call reference parameter field:
5101 a) Network ID
5102 The Network ID contains the value field (coded according to ASN.1 BER) of an object
5103 identifier identifying the network. This means that the tag and length fields are omitted.
5104 An example of such an object identifier can be the following:
5105 .{itu-t (0) administration (2) national regulatory authority (x) network (y)}
5106 The value for x is the value of the national regulatory authority (one of the Data Country
5107 Codes associated to the country as specified in ITU-T X.121 shall be used for "national
5108 regulatory authority"), the value for y is under the control of the national regulatory
5109 authority concerned.
5110 b) Node ID
5111 A binary number that uniquely identifies within the network the node which generates the
5112 call reference.
5113 c) Call Reference ID
5114 A binary number used for the call reference of the call. This is generated by the node for
5115 each call.
5116
5117 */
5118 proto_tree_add_item(bat_ase_element_tree, hf_isup_network_id, parameter_tvb, offset, tempdata, ENC_NA);
5119 offset += tempdata;
5120 } /* end if */
5121
5122 proto_tree_add_item(bat_ase_element_tree, hf_Local_BCU_ID, parameter_tvb, offset, 4, ENC_LITTLE_ENDIAN);
5123 offset += 4;
5124 break;
5125 case SIGNAL :
5126 /* As type is Constructor new elements follow, return to main loop */
5127 break;
5128 case BEARER_REDIRECTION_CAPABILITY :
5129 tempdata = tvb_get_uint8(parameter_tvb, offset);
5130 proto_tree_add_boolean(bat_ase_element_tree, hf_late_cut_through_cap_ind , parameter_tvb, offset, 1, tempdata);
5131 offset = offset + content_len;
5132 break;
5133 case BEARER_REDIRECTION_INDICATORS :
5134 number_of_indicators = 0;
5135 while (number_of_indicators < content_len) {
5136 tempdata = tvb_get_uint8(parameter_tvb, offset);
5137 proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_bearer_redir_ind , parameter_tvb, offset, 1, tempdata);
5138 offset = offset + 1;
5139 number_of_indicators = number_of_indicators + 1;
5140 }
5141 break;
5142 case SIGNAL_TYPE :
5143 tempdata = tvb_get_uint8(parameter_tvb, offset);
5144 proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_signal , parameter_tvb, offset, 1, tempdata);
5145 offset = offset + content_len;
5146 break;
5147 case DURATION :
5148 duration = tvb_get_letohs(parameter_tvb, offset);
5149 proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_duration , parameter_tvb, offset, 2, duration);
5150 offset = offset + content_len;
5151 break;
5152 default :
5153 proto_tree_add_item(bat_ase_element_tree, hf_bat_ase_default, parameter_tvb, offset, content_len, ENC_NA);
5154 offset = offset + content_len;
5155 }
5156 }
5157
5158 }
5159
5160
5161
5162 /*
5163 Octet
5164 -------------------------------------------
5165 1 | ext. Application context identifier lsb
5166 -------------------------------------------
5167 1a | ext. msb
5168 -------------------------------------------
5169 2 | ext. spare SNI RCI
5170 -------------------------------------------
5171 3 | ext. SI APM segmentation indicator
5172 -------------------------------------------
5173 3a | ext. Segmentation local reference
5174 -------------------------------------------
5175 4a |
5176 : | APM-user information
5177 4n |
5178 +-------------------------------------------
5179
5180 Figure 77/Q.763 . Application transport parameter field
5181 */
5182 static void
5183 dissect_isup_application_transport_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5184 {
5185
5186 uint8_t si_and_apm_seg_ind;
5187 uint8_t apm_Segmentation_local_ref = 0;
5188 uint16_t aci16;
5189 int offset = 0;
5190 uint8_t octet;
5191 unsigned length = tvb_reported_length(parameter_tvb);
5192 bool more_frag;
5193 bool save_fragmented;
5194
5195 tvbuff_t *new_tvb = NULL;
5196 tvbuff_t *next_tvb = NULL;
5197 fragment_head *frag_msg = NULL;
5198
5199 static int * const apm_flags[] = {
5200 &hf_isup_extension_ind,
5201 &hf_isup_apm_si_ind,
5202 &hf_isup_apm_segmentation_ind,
5203 NULL
5204 };
5205
5206 static int * const app_trans_flags[] = {
5207 &hf_isup_extension_ind,
5208 &hf_isup_app_Send_notification_ind,
5209 &hf_isup_app_Release_call_ind,
5210 NULL
5211 };
5212
5213 static int * const app_field_flags[] = {
5214 &hf_isup_extension_ind,
5215 &hf_isup_app_cont_ident,
5216 NULL
5217 };
5218
5219 aci16 = tvb_get_uint8(parameter_tvb, offset);
5220
5221 if ((aci16 & H_8BIT_MASK) == 0x80) {
5222 /* Octet 1 */
5223 aci16 = aci16 & 0x7f;
5224 proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_app_transport_param_field8, ett_app_transport_fields, app_field_flags, ENC_NA);
5225 offset = offset + 1;
5226 }
5227 /* Octet 1a */
5228 else {
5229 proto_tree_add_item(parameter_tree, hf_isup_app_transport_param_field16, parameter_tvb, offset, 2, ENC_BIG_ENDIAN);
5230 aci16 = (aci16<<8) | (tvb_get_uint8(parameter_tvb, offset) & 0x7f);
5231 proto_tree_add_uint(parameter_tree, hf_isup_app_cont_ident , parameter_tvb, offset, 2, aci16);
5232 offset = offset + 2;
5233 }
5234
5235 /* Octet 2 */
5236 proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_app_transport_instruction_indicator, ett_app_transport, app_trans_flags, ENC_NA);
5237 offset = offset + 1;
5238
5239 /* Octet 3*/
5240 si_and_apm_seg_ind = tvb_get_uint8(parameter_tvb, offset);
5241 proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_apm_seg_indicator, ett_apm_seg_indicator, apm_flags, ENC_NA);
5242 offset = offset + 1;
5243
5244 /* Octet 3a */
5245 if ((si_and_apm_seg_ind & H_8BIT_MASK) == 0x00) {
5246 apm_Segmentation_local_ref = tvb_get_uint8(parameter_tvb, offset);
5247 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5248 proto_tree_add_item(parameter_tree, hf_isup_apm_slr, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5249 offset = offset + 1;
5250 }
5251 /* For APM'98'-user applications. (aci 0 - 3), APM-user information field starts at octet 4 */
5252 if (aci16 > 3) {
5253 /* Octet 4 Originating Address length */
5254 octet = tvb_get_uint8(parameter_tvb, offset);
5255 proto_tree_add_item(parameter_tree, hf_isup_orig_addr_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5256 offset += 1;
5257 if (octet != 0) {
5258 /* 4b */
5259 proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5260 /* nature of address indicator */
5261 offset += 1;
5262 proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5263 proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5264 offset += 1;
5265 /* Address digits */
5266 proto_tree_add_item(parameter_tree, hf_isup_address_digits, parameter_tvb, offset, octet - 2, ENC_NA);
5267 offset = offset + octet - 2;
5268 }
5269 /* Octet 5 Destination Address length */
5270 octet = tvb_get_uint8(parameter_tvb, offset);
5271 proto_tree_add_item(parameter_tree, hf_isup_dest_addr_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5272 offset += 1;
5273 if (octet != 0) {
5274 /* 4b */
5275 proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5276 /* nature of address indicator */
5277 offset += 1;
5278 proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5279 proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5280 offset += 1;
5281 /* Address digits */
5282 proto_tree_add_item(parameter_tree, hf_isup_address_digits, parameter_tvb, offset, octet - 2, ENC_NA);
5283 offset = offset + octet - 2;
5284 }
5285 }
5286 /*
5287 * Defragment ?
5288 *
5289 */
5290 if (isup_apm_desegment) {
5291 if ((si_and_apm_seg_ind != 0xc0) && ((si_and_apm_seg_ind & H_8BIT_MASK)!=0x80)) {
5292 /* debug ws_warning("got here Frame %u", pinfo->num); */
5293 /* Segmented message */
5294 save_fragmented = pinfo->fragmented;
5295 pinfo->fragmented = true;
5296 more_frag = true;
5297 if (si_and_apm_seg_ind == 0)
5298 more_frag = false;
5299
5300 frag_msg = fragment_add_seq_next(&isup_apm_msg_reassembly_table,
5301 parameter_tvb, offset,
5302 pinfo,
5303 (apm_Segmentation_local_ref & 0x7f), /* ID for fragments belonging together */
5304 NULL,
5305 tvb_reported_length_remaining(parameter_tvb, offset), /* fragment length - to the end */
5306 more_frag); /* More fragments? */
5307
5308 if ((si_and_apm_seg_ind & 0x3f) !=0 && (si_and_apm_seg_ind &0x40) !=0) {
5309 /* First fragment set number of fragments */
5310 fragment_set_tot_len(&isup_apm_msg_reassembly_table,
5311 pinfo,
5312 apm_Segmentation_local_ref & 0x7f,
5313 NULL,
5314 (si_and_apm_seg_ind & 0x3f));
5315 }
5316
5317 new_tvb = process_reassembled_data(parameter_tvb, offset, pinfo,
5318 "Reassembled ISUP", frag_msg, &isup_apm_msg_frag_items,
5319 NULL, parameter_tree);
5320
5321 if (frag_msg) { /* Reassembled */
5322 col_append_str(pinfo->cinfo, COL_INFO,
5323 " (Message Reassembled)");
5324 } else { /* Not last packet of reassembled Short Message */
5325 col_append_str(pinfo->cinfo, COL_INFO,
5326 " (Message fragment)");
5327 }
5328
5329 pinfo->fragmented = save_fragmented;
5330 }
5331 }/*isup_apm_desegment*/
5332
5333 if (offset == (int)length) {
5334 /* No data */
5335 proto_tree_add_item(parameter_tree, hf_isup_apm_user_info_field, parameter_tvb, offset, 0, ENC_NA);
5336 return;
5337 }
5338 if (new_tvb) { /* take it all */
5339 next_tvb = new_tvb;
5340 } else { /* make a new subset */
5341 next_tvb = tvb_new_subset_remaining(parameter_tvb, offset);
5342 }
5343
5344 proto_tree_add_item(parameter_tree, hf_isup_apm_user_info_field, parameter_tvb, offset, -1, ENC_NA);
5345
5346 switch (aci16 & 0x7fff) {
5347 case 3:
5348 /* Charging ASE */
5349 dissect_charging_ase_ChargingMessageType_PDU(next_tvb, pinfo, parameter_tree, NULL);
5350 break;
5351 case 5:
5352 /* dissect BAT ASE element, without transparent data (Q.765.5-200006) */
5353 dissect_bat_ase_Encapsulated_Application_Information(next_tvb, pinfo, parameter_tree, 0);
5354 break;
5355 default:
5356 expert_add_info_format(pinfo, parameter_tree, &ei_isup_not_dissected_yet, "No further dissection of APM-user information field");
5357 break;
5358 }
5359 }
5360
5361
5362
5363 /* ------------------------------------------------------------------
5364 Dissector Parameter Optional Forward Call indicators
5365 */
5366 static void
5367 dissect_isup_optional_forward_call_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5368 {
5369 uint8_t ind;
5370 static int * const indicators[] = {
5371 &hf_isup_cug_call_ind,
5372 &hf_isup_simple_segmentation_ind,
5373 &hf_isup_connected_line_identity_request_ind,
5374 NULL
5375 };
5376
5377 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, OPTIONAL_FORWARD_CALL_IND_LENGTH, indicators, ENC_NA);
5378
5379 ind = tvb_get_uint8(parameter_tvb, 0);
5380 proto_item_append_text(parameter_item, " : %s (%u)",
5381 val_to_str_const(ind & BA_8BIT_MASK, isup_CUG_call_ind_value, "spare"),
5382 ind);
5383 }
5384 /* ------------------------------------------------------------------
5385 Dissector Parameter calling party number
5386 */
5387 void
5388 dissect_isup_calling_party_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5389 {
5390 uint8_t indicators1, indicators2;
5391 int offset = 0;
5392 int number_plan;
5393 static int * const indicators1_fields[] = {
5394 &hf_isup_odd_even_indicator,
5395 &hf_isup_calling_party_nature_of_address_indicator,
5396 NULL
5397 };
5398 static int * const indicators2_fields[] = {
5399 &hf_isup_ni_indicator,
5400 &hf_isup_numbering_plan_indicator,
5401 &hf_isup_address_presentation_restricted_indicator,
5402 &hf_isup_screening_indicator,
5403 NULL
5404 };
5405
5406 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5407 indicators1 = tvb_get_uint8(parameter_tvb, 0);
5408 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5409 indicators2 = tvb_get_uint8(parameter_tvb, 1);
5410 number_plan = (indicators2 & 0x70)>> 4;
5411 offset = 2;
5412
5413 tap_calling_number = dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5414 hf_isup_calling, hf_isup_calling_party_odd_address_signal_digit,
5415 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5416 number_plan == 1 ? CALLING_PARTY_NUMBER : NONE,
5417 (indicators1 & 0x7f));
5418 }
5419 /* ------------------------------------------------------------------
5420 Dissector Parameter Original called number
5421 */
5422 void
5423 dissect_isup_original_called_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5424 {
5425 uint8_t indicators1;
5426 int offset = 0;
5427 static int * const indicators1_fields[] = {
5428 &hf_isup_odd_even_indicator,
5429 &hf_isup_calling_party_nature_of_address_indicator,
5430 NULL
5431 };
5432 static int * const indicators2_fields[] = {
5433 &hf_isup_numbering_plan_indicator,
5434 &hf_isup_address_presentation_restricted_indicator,
5435 NULL
5436 };
5437
5438
5439 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5440 indicators1 = tvb_get_uint8(parameter_tvb, 0);
5441 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5442 offset = 2;
5443
5444 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5445 hf_isup_original_called_number,
5446 hf_isup_calling_party_odd_address_signal_digit,
5447 hf_isup_calling_party_even_address_signal_digit,
5448 ((indicators1 & 0x80) == 0), NONE, 0);
5449 }
5450 /* ------------------------------------------------------------------
5451 Dissector Parameter Redirecting number
5452 */
5453 void
5454 dissect_isup_redirecting_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5455 {
5456 uint8_t indicators1;
5457 int offset = 0;
5458 static int * const indicators1_fields[] = {
5459 &hf_isup_odd_even_indicator,
5460 &hf_isup_calling_party_nature_of_address_indicator,
5461 NULL
5462 };
5463 static int * const indicators2_fields[] = {
5464 &hf_isup_numbering_plan_indicator,
5465 &hf_isup_address_presentation_restricted_indicator,
5466 NULL
5467 };
5468
5469 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5470 indicators1 = tvb_get_uint8(parameter_tvb, 0);
5471 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5472 offset = 2;
5473
5474 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5475 hf_isup_redirecting, hf_isup_calling_party_odd_address_signal_digit,
5476 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5477 NONE, 0);
5478 }
5479
5480 /* ------------------------------------------------------------------
5481 Dissector Parameter Redirection number
5482 */
5483 static void
5484 dissect_isup_redirection_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5485 {
5486 uint8_t indicators1;
5487 int offset = 0;
5488 static int * const indicators1_fields[] = {
5489 &hf_isup_odd_even_indicator,
5490 &hf_isup_called_party_nature_of_address_indicator,
5491 NULL
5492 };
5493 static int * const indicators2_fields[] = {
5494 &hf_isup_inn_indicator,
5495 &hf_isup_numbering_plan_indicator,
5496 NULL
5497 };
5498
5499 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5500 indicators1 = tvb_get_uint8(parameter_tvb, 0);
5501 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5502 offset = 2;
5503
5504 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5505 hf_isup_redirection_number, hf_isup_called_party_odd_address_signal_digit,
5506 hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5507 NONE, 0);
5508 }
5509
5510 /* ------------------------------------------------------------------
5511 Dissector Parameter Connection request
5512 */
5513 static void
5514 dissect_isup_connection_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5515 {
5516 uint32_t local_ref;
5517 uint16_t spc;
5518 uint8_t protocol_class, credit, offset = 0;
5519
5520 local_ref = tvb_get_ntoh24(parameter_tvb, 0);
5521 proto_tree_add_item(parameter_tree, hf_isup_local_reference, parameter_tvb, offset, LOCAL_REF_LENGTH, ENC_BIG_ENDIAN);
5522 offset = LOCAL_REF_LENGTH;
5523 spc = tvb_get_letohs(parameter_tvb, offset) & 0x3FFF; /*since 1st 2 bits spare */
5524 proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, offset, SPC_LENGTH, ENC_BIG_ENDIAN);
5525 offset += SPC_LENGTH;
5526 protocol_class = tvb_get_uint8(parameter_tvb, offset);
5527 proto_tree_add_item(parameter_tree, hf_isup_protocol_class, parameter_tvb, offset, PROTOCOL_CLASS_LENGTH, ENC_BIG_ENDIAN);
5528 offset += PROTOCOL_CLASS_LENGTH;
5529 credit = tvb_get_uint8(parameter_tvb, offset);
5530 proto_tree_add_item(parameter_tree, hf_isup_credit, parameter_tvb, offset, CREDIT_LENGTH, ENC_BIG_ENDIAN);
5531
5532 proto_item_append_text(parameter_item,
5533 " : Local Reference = %u, SPC = %u, Protocol Class = %u, Credit = %u",
5534 local_ref, spc, protocol_class, credit);
5535 }
5536 /* ------------------------------------------------------------------
5537 Dissector Parameter Redirection information
5538 */
5539 void
5540 dissect_isup_redirection_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5541 {
5542 if (tvb_reported_length(parameter_tvb) == 2) {
5543 uint16_t indicators;
5544 indicators = tvb_get_ntohs(parameter_tvb, 0);
5545 proto_tree_add_uint(parameter_tree, hf_isup_redirecting_ind, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5546 proto_tree_add_uint(parameter_tree, hf_isup_original_redirection_reason, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5547 proto_tree_add_uint(parameter_tree, hf_isup_redirection_counter, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5548 proto_tree_add_uint(parameter_tree, hf_isup_redirection_reason, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5549 }
5550 else { /* ISUP'88 (blue book) */
5551 uint16_t indicators;
5552 indicators = tvb_get_uint8(parameter_tvb, 0) * 0x100; /*since 2nd octet isn't present*/
5553 proto_tree_add_uint(parameter_tree, hf_isup_redirecting_ind, parameter_tvb, 0, 1, indicators);
5554 proto_tree_add_uint(parameter_tree, hf_isup_original_redirection_reason, parameter_tvb, 0, 1, indicators);
5555 proto_item_append_text(parameter_item, " (2nd octet not present since ISUP '88)");
5556 }
5557 }
5558 /* ------------------------------------------------------------------
5559 Dissector Parameter Closed user group interlock code
5560 */
5561 static void
5562 dissect_isup_closed_user_group_interlock_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5563 {
5564 char NI_digits[5] = "";
5565 uint8_t digit_pair;
5566 uint16_t bin_code;
5567
5568 digit_pair = tvb_get_uint8(parameter_tvb, 0);
5569 NI_digits[0] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
5570 NI_digits[1] = number_to_char(digit_pair & DCBA_8BIT_MASK);
5571 digit_pair = tvb_get_uint8(parameter_tvb, 1);
5572 NI_digits[2] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
5573 NI_digits[3] = number_to_char(digit_pair & DCBA_8BIT_MASK);
5574 NI_digits[4] = '\0';
5575 proto_tree_add_string(parameter_tree, hf_isup_network_identity, parameter_tvb, 0, 2, NI_digits);
5576 bin_code = tvb_get_ntohs(parameter_tvb, 2);
5577 proto_tree_add_item(parameter_tree, hf_isup_binary_code, parameter_tvb, 2, 2, ENC_BIG_ENDIAN);
5578 proto_item_append_text(parameter_item, " : NI = %s, Binary code = 0x%x", NI_digits, bin_code);
5579 }
5580 /* ------------------------------------------------------------------
5581 Dissector Parameter User service information- no detailed dissection since defined in Rec. Q.931
5582 */
5583 static void
5584 dissect_isup_user_service_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5585 { unsigned length = tvb_reported_length(parameter_tvb);
5586 proto_tree_add_item(parameter_tree, hf_isup_user_service_information, parameter_tvb, 0, length, ENC_NA);
5587 dissect_q931_bearer_capability_ie(parameter_tvb,
5588 0, length,
5589 parameter_tree);
5590 }
5591 /* ------------------------------------------------------------------
5592 Dissector Parameter Signalling point code
5593 */
5594 static void
5595 dissect_isup_signalling_point_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5596 {
5597 uint16_t spc;
5598
5599 spc = tvb_get_letohs(parameter_tvb, 0) & 0x3FFF; /*since 1st 2 bits spare */
5600 proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, 0, SIGNALLING_POINT_CODE_LENGTH, ENC_BIG_ENDIAN);
5601
5602 proto_item_append_text(parameter_item, " : %u", spc);
5603 }
5604 /* ------------------------------------------------------------------
5605 Dissector Parameter Connected number
5606 */
5607 static void
5608 dissect_isup_connected_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5609 {
5610 uint8_t indicators1;
5611 int offset = 0;
5612 static int * const indicators1_fields[] = {
5613 &hf_isup_odd_even_indicator,
5614 &hf_isup_calling_party_nature_of_address_indicator,
5615 NULL
5616 };
5617 static int * const indicators2_fields[] = {
5618 &hf_isup_numbering_plan_indicator,
5619 &hf_isup_address_presentation_restricted_indicator,
5620 &hf_isup_screening_indicator,
5621 NULL
5622 };
5623
5624 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5625 indicators1 = tvb_get_uint8(parameter_tvb, 0);
5626 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5627 offset = 2;
5628
5629 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5630 hf_isup_connected_number, hf_isup_calling_party_odd_address_signal_digit,
5631 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5632 NONE, 0);
5633 }
5634
5635 /* ------------------------------------------------------------------
5636 Dissector Transit network selection
5637 */
5638 static void
5639 dissect_isup_transit_network_selection_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5640 {
5641 uint8_t indicators1;
5642 int offset = 0;
5643 static int * const indicators_fields[] = {
5644 &hf_isup_odd_even_indicator,
5645 &hf_isup_type_of_network_identification,
5646 &hf_isup_network_identification_plan,
5647 NULL
5648 };
5649
5650 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators_fields, ENC_NA);
5651 indicators1 = tvb_get_uint8(parameter_tvb, 0);
5652 offset = 1;
5653
5654 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5655 hf_isup_transit_network_selection, hf_isup_calling_party_odd_address_signal_digit,
5656 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5657 NONE, 0);
5658 }
5659
5660 /* ------------------------------------------------------------------
5661 Dissector Parameter Circuit assignment map
5662 */
5663 static void
5664 dissect_isup_circuit_assignment_map_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5665 { uint8_t map_type;
5666
5667 map_type = tvb_get_uint8(parameter_tvb, 0);
5668 proto_tree_add_uint(parameter_tree, hf_isup_map_type, parameter_tvb, 0, 1, map_type);
5669 proto_tree_add_item(parameter_tree, hf_isup_circuit_assignment_map, parameter_tvb, 1, 5, ENC_NA);
5670 }
5671 /* ------------------------------------------------------------------
5672 Dissector Parameter Automatic congestion level
5673 */
5674 static void
5675 dissect_isup_automatic_congestion_level_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5676 { uint8_t congestion_level;
5677
5678 congestion_level = tvb_get_uint8(parameter_tvb, 0);
5679 proto_tree_add_uint(parameter_tree, hf_isup_automatic_congestion_level, parameter_tvb, 0, AUTO_CONGEST_LEVEL_LENGTH, congestion_level);
5680 proto_item_append_text(parameter_item, " : %s (%u)",
5681 val_to_str_const(congestion_level, isup_auto_congestion_level_value, "spare"), congestion_level);
5682 }
5683 /* ------------------------------------------------------------------
5684 Dissector Parameter Optional backward Call indicators
5685 */
5686 static void
5687 dissect_isup_optional_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5688 {
5689 static int * const indicators[] = {
5690 &hf_isup_inband_information_ind,
5691 &hf_isup_call_diversion_may_occur_ind,
5692 &hf_isup_simple_segmentation_ind,
5693 &hf_isup_mlpp_user_ind,
5694 NULL
5695 };
5696
5697 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, OPTIONAL_BACKWARD_CALL_IND_LENGTH, indicators, ENC_NA);
5698
5699 proto_item_append_text(parameter_item, " : 0x%x", tvb_get_uint8(parameter_tvb, 0));
5700 }
5701 /* ------------------------------------------------------------------
5702 Dissector Parameter User-to-user indicators
5703 */
5704 static const value_string isup_UUI_request_service_values[] = {
5705 { 0, "No information"},
5706 { 1, "Spare"},
5707 { 2, "Request, not essential"},
5708 { 3, "Request,essential"},
5709 { 0, NULL}
5710 };
5711
5712 static const value_string isup_UUI_response_service_values[] = {
5713 { 0, "No information"},
5714 { 1, "Not provided"},
5715 { 2, "Provided"},
5716 { 3, "Spare"},
5717 { 0, NULL}
5718 };
5719 static const true_false_string isup_UUI_network_discard_ind_value = {
5720 "User-to-user information discarded by the network",
5721 "No information"
5722 };
5723
5724 static void
5725 dissect_isup_user_to_user_indicators_parameter(tvbuff_t *parameter_tvb,
5726 proto_tree *parameter_tree,
5727 proto_item *parameter_item)
5728 {
5729 uint8_t indicators;
5730 static int * const req_fields[] = {
5731 &hf_isup_UUI_type,
5732 &hf_isup_UUI_req_service1,
5733 &hf_isup_UUI_req_service2,
5734 &hf_isup_UUI_req_service3,
5735 NULL
5736 };
5737 static int * const res_fields[] = {
5738 &hf_isup_UUI_type,
5739 &hf_isup_UUI_res_service1,
5740 &hf_isup_UUI_res_service2,
5741 &hf_isup_UUI_res_service3,
5742 &hf_isup_UUI_network_discard_ind,
5743 NULL
5744 };
5745
5746 indicators = tvb_get_uint8(parameter_tvb, 0);
5747 proto_tree_add_boolean(parameter_tree, hf_isup_UUI_type, parameter_tvb, 0, 1, indicators);
5748 if ((indicators & 0x01) == 0) {
5749 /* Request */
5750 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, req_fields, ENC_NA);
5751 }
5752 else {
5753 /* Response */
5754 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, res_fields, ENC_NA);
5755 }
5756 proto_item_append_text(parameter_item, " : 0x%x", indicators);
5757 }
5758 /* ------------------------------------------------------------------
5759 Dissector Parameter Original ISC point code
5760 */
5761 static void
5762 dissect_isup_original_isc_point_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5763 {
5764 uint16_t spc;
5765
5766 spc = tvb_get_letohs(parameter_tvb, 0) & 0x3FFF; /*since 1st 2 bits spare */
5767 proto_tree_add_item(parameter_tree, hf_isup_origination_isc_point_code, parameter_tvb, 0, ORIGINAL_ISC_POINT_CODE_LENGTH, ENC_BIG_ENDIAN);
5768
5769 proto_item_append_text(parameter_item, " : %u", spc);
5770 }
5771 /* ------------------------------------------------------------------
5772 Dissector Parameter Generic notification indicator
5773
5774 3.25 Generic notification indicator
5775
5776 a) Extension indicator (ext.)
5777 0 information continues in the next octet
5778 1 last octet
5779
5780 b) Notification indicator
5781 0 0 0 0 0 0 0 user suspended
5782 0 0 0 0 0 0 1 user resumed
5783 0 0 0 0 0 1 0 bearer service change
5784 0 0 0 0 0 1 1 encoded component discriminator for extension to ASN.1 (used in DSS1)
5785 0 0 0 0 1 0 0 call completion delay
5786 \x01\x02\x04
5787 1 0 0 0 0 0 1
5788 to
5789 0 0 0 0 1 0 1 reserved
5790
5791 1 0 0 0 0 1 0 conference established
5792 1 0 0 0 0 1 1 conference disconnected
5793 1 0 0 0 1 0 0 other party added
5794 1 0 0 0 1 0 1 isolated
5795 1 0 0 0 1 1 0 reattached
5796 1 0 0 0 1 1 1 other party isolated
5797 1 0 0 1 0 0 0 other party reattached
5798 1 0 0 1 0 0 1 other party split
5799 1 0 0 1 0 1 0 other party disconnected
5800 1 0 0 1 0 1 1 conference floating
5801 \x01\x04
5802 1 0 1 1 1 1 1
5803 to
5804 1 0 0 1 1 0 0 reserved
5805
5806 1 1 0 0 0 0 0 call is a waiting call
5807 \x01\x02\x04
5808 1 1 0 0 1 1 1
5809 to
5810 1 1 0 0 0 0 1 reserved
5811
5812 1 1 0 1 0 0 0 diversion activated (used in DSS1)
5813 1 1 0 1 0 0 1 call transfer, alerting
5814 1 1 0 1 0 1 0 call transfer, active
5815 \x01\x02
5816 \x01\x03
5817 \x04
5818 1 1 1 1 0 0 0
5819 to
5820 1 1 0 1 0 1 1
5821 reserved
5822 1 1 1 1 0 0 1 remote hold
5823 1 1 1 1 0 1 0 remote retrieval
5824 1 1 1 1 0 1 1 call is diverting
5825 \x01\x02
5826 \x01\x03
5827 \x04
5828 1 1 1 1 1 1 1
5829 to
5830 1 1 1 1 1 0 0
5831 reserved
5832 */
5833 static const value_string q763_generic_notification_indicator_vals[] = {
5834 { 0x00 , "User Suspended" },
5835 { 0x01 , "User Resumed" },
5836 { 0x02 , "Bearer service change" },
5837 { 0x03 , "Discriminator for extension to ASN.1 encoded component (used in DSS1)" },
5838 { 0x04 , "Call completion delay" },
5839 { 0x42 , "Conference established" },
5840 { 0x43 , "Conference disconnected" },
5841 { 0x44 , "Other party added" },
5842 { 0x45 , "Isolated" },
5843 { 0x46 , "Reattached" },
5844 { 0x47 , "Other party isolated" },
5845 { 0x48 , "Other party reattached" },
5846 { 0x49 , "Other party split" },
5847 { 0x4A , "Other party disconnected" },
5848 { 0x4B , "Conference floating" },
5849 { 0x60 , "Call is a waiting call" },
5850 { 0x68 , "Diversion activated (used in DSS1)" },
5851 { 0x69 , "Call transfer, alerting" },
5852 { 0x6A , "Call transfer, active" },
5853 { 0x79 , "Remote hold" },
5854 { 0x7A , "Remote retrieval" },
5855 { 0x7B , "Call is diverting" },
5856 { 0 , NULL },
5857 };
5858 static value_string_ext q763_generic_notification_indicator_vals_ext = VALUE_STRING_EXT_INIT(q763_generic_notification_indicator_vals);
5859
5860 static void
5861 dissect_isup_generic_notification_indicator_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5862 {
5863 uint8_t indicators;
5864
5865 indicators = tvb_get_uint8(parameter_tvb, 0);
5866 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
5867 proto_tree_add_item(parameter_tree, hf_isup_notification_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
5868 proto_item_append_text(parameter_item, " : %s",
5869 val_to_str_ext((indicators&0x7f), &q763_generic_notification_indicator_vals_ext, "Reserved (0x%X)"));
5870 }
5871 /* ------------------------------------------------------------------
5872 Dissector Parameter Call history information
5873 */
5874 static void
5875 dissect_isup_call_history_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5876 {
5877 uint16_t info;
5878
5879 info = tvb_get_ntohs(parameter_tvb, 0);
5880 proto_tree_add_uint_format_value(parameter_tree, hf_isup_call_history_info, parameter_tvb, 0, CALL_HISTORY_INFO_LENGTH, info, "propagation delay = %u ms", info);
5881 proto_item_append_text(parameter_item, " : propagation delay = %u ms", info);
5882 }
5883 /* ------------------------------------------------------------------
5884 Dissector Parameter Access delivery information
5885 */
5886 static void
5887 dissect_isup_access_delivery_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5888 {
5889 uint8_t indicator;
5890
5891 indicator = tvb_get_uint8(parameter_tvb, 0);
5892 proto_tree_add_boolean(parameter_tree, hf_isup_access_delivery_ind, parameter_tvb, 0, ACCESS_DELIVERY_INFO_LENGTH, indicator);
5893 proto_item_append_text(parameter_item, " : 0x%x", indicator);
5894 }
5895 /* ------------------------------------------------------------------
5896 Dissector Parameter Network specific facility
5897 */
5898 static void
5899 dissect_isup_network_specific_facility_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5900 { unsigned length = tvb_reported_length(parameter_tvb);
5901 proto_tree_add_item(parameter_tree, hf_isup_network_specific_facility, parameter_tvb, 0, length, ENC_NA);
5902 }
5903 /* ------------------------------------------------------------------
5904 Dissector Parameter User service information prime
5905 */
5906 static void
5907 dissect_isup_user_service_information_prime_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5908 { unsigned length = tvb_reported_length(parameter_tvb);
5909 proto_tree_add_item(parameter_tree, hf_isup_user_service_information_prime, parameter_tvb, 0, length, ENC_NA);
5910 dissect_q931_bearer_capability_ie(parameter_tvb,
5911 0, length,
5912 parameter_tree);
5913 }
5914 /* ------------------------------------------------------------------
5915 Dissector Parameter Propagation delay counter
5916 */
5917 static void
5918 dissect_isup_propagation_delay_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5919 {
5920 uint32_t info;
5921
5922 proto_tree_add_item_ret_uint(parameter_tree, hf_isup_propagation_delay_counter, parameter_tvb, 0, PROPAGATION_DELAY_COUNT_LENGTH, ENC_BIG_ENDIAN, &info);
5923 proto_item_append_text(parameter_item, ": counter = %u ms", info);
5924 }
5925 /* ------------------------------------------------------------------
5926 Dissector Parameter Remote operations
5927 */
5928 static void
5929 dissect_isup_remote_operations_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5930 { unsigned length = tvb_reported_length(parameter_tvb);
5931 proto_tree_add_item(parameter_tree, hf_isup_remote_operations, parameter_tvb, 0, length, ENC_NA);
5932 }
5933 /* ------------------------------------------------------------------
5934 Dissector Parameter Service activation
5935 */
5936 static void
5937 dissect_isup_service_activation_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5938 {
5939 unsigned i;
5940 uint8_t feature_code;
5941 unsigned length = tvb_reported_length(parameter_tvb);
5942
5943 for (i=0; i<length; i++) {
5944 feature_code = tvb_get_uint8(parameter_tvb, i);
5945 proto_tree_add_uint_format(parameter_tree, hf_isup_feature_code, parameter_tvb, i, 1, feature_code, "Feature Code %u: %u", i+1, feature_code);
5946 }
5947 }
5948 /* ------------------------------------------------------------------
5949 Dissector Parameter User service information prime - no detailed dissection since defined in Rec. Q.931
5950 */
5951 static void
5952 dissect_isup_user_teleservice_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5953 {
5954 unsigned length = tvb_reported_length(parameter_tvb);
5955 proto_tree_add_item(parameter_tree, hf_isup_user_teleservice_information, parameter_tvb, 0, length, ENC_NA);
5956
5957 dissect_q931_high_layer_compat_ie(parameter_tvb, 0, length, parameter_tree);
5958 }
5959 /* ------------------------------------------------------------------
5960 Dissector Parameter Transmission medium requirement used
5961 */
5962 static void
5963 dissect_isup_transmission_medium_used_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5964 {
5965 uint8_t transmission_medium_requirement;
5966
5967 transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
5968 proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement_prime,
5969 parameter_tvb, 0, TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH, transmission_medium_requirement);
5970
5971 proto_item_append_text(parameter_item,
5972 " : %u (%s)",
5973 transmission_medium_requirement,
5974 val_to_str_ext_const(transmission_medium_requirement,
5975 &isup_transmission_medium_requirement_prime_value_ext,
5976 "spare/reserved"));
5977 }
5978 /* ------------------------------------------------------------------
5979 Dissector Parameter Call diversion information
5980 */
5981 static void
5982 dissect_isup_call_diversion_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5983 { uint8_t indicator;
5984
5985 indicator = tvb_get_uint8(parameter_tvb, 0);
5986 proto_tree_add_uint_format_value(parameter_tree, hf_isup_call_diversion_information, parameter_tvb, 0, CALL_DIV_INFO_LENGTH, indicator,
5987 "0x%x (refer to 3.6/Q.763 for detailed decoding)", indicator);
5988 proto_item_append_text(parameter_item, " : 0x%x", indicator);
5989 }
5990 /* ------------------------------------------------------------------
5991 Dissector Parameter Echo control information
5992 */
5993 static const value_string OECD_inf_ind_vals[] = {
5994 {0x00, "no information"},
5995 {0x01, "outgoing echo control device not included and not available"},
5996 {0x02, "outgoing echo control device included"},
5997 {0x03, "outgoing echo control device not included but available"},
5998 { 0, NULL }
5999 };
6000 static const value_string IECD_inf_ind_vals[] = {
6001 {0x00, "no information"},
6002 {0x01, "incoming echo control device not included and not available"},
6003 {0x02, "incoming echo control device included"},
6004 {0x03, "incoming echo control device not included but available"},
6005 { 0, NULL }
6006 };
6007
6008 static const value_string OECD_req_ind_vals[] = {
6009 {0x00, "no information"},
6010 {0x01, "outgoing echo control device activation request"},
6011 {0x02, "outgoing echo control device deactivation request"},
6012 {0x03, "spare"},
6013 { 0, NULL }
6014 };
6015
6016 static const value_string IECD_req_ind_vals[] = {
6017 {0x00, "no information"},
6018 {0x01, "incoming echo control device activation request"},
6019 {0x02, "incoming echo control device deactivation request"},
6020 {0x03, "spare"},
6021 { 0, NULL }
6022 };
6023
6024 static void
6025 dissect_isup_echo_control_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6026 { uint8_t indicator;
6027 static int * const info[] = {
6028 &hf_isup_OECD_inf_ind,
6029 &hf_isup_IECD_inf_ind,
6030 &hf_isup_OECD_req_ind,
6031 &hf_isup_IECD_req_ind,
6032 NULL
6033 };
6034
6035 indicator = tvb_get_uint8(parameter_tvb, 0);
6036 proto_tree_add_bitmask(parameter_tree, parameter_tvb, 0, hf_isup_echo_control_information, ett_echo_control_information, info, ENC_NA);
6037
6038 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6039 }
6040 /* ------------------------------------------------------------------
6041 Dissector Parameter Message compatibility information
6042 */
6043
6044 static const true_false_string isup_pass_on_not_possible_indicator_value = {
6045 "discard information",
6046 "release call",
6047 };
6048
6049 static void
6050 dissect_isup_message_compatibility_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6051 {
6052 int offset = 0;
6053
6054 static int * const params[] = {
6055 &hf_isup_transit_at_intermediate_exchange_ind,
6056 &hf_isup_Release_call_ind,
6057 &hf_isup_Send_notification_ind,
6058 &hf_isup_Discard_message_ind_value,
6059 &hf_isup_pass_on_not_possible_indicator2,
6060 &hf_isup_Broadband_narrowband_interworking_ind2,
6061 &hf_isup_extension_ind,
6062 NULL
6063 };
6064
6065 proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_message_compatibility_information, ett_message_compatibility_information, params, ENC_NA);
6066 }
6067 /* ------------------------------------------------------------------
6068 Dissector Parameter compatibility information
6069 */
6070 static const true_false_string isup_transit_at_intermediate_exchange_ind_value = {
6071 "End node interpretation",
6072 "Transit interpretation"
6073 };
6074
6075
6076 static const true_false_string isup_Discard_message_ind_value = {
6077 "Discard message",
6078 "Do not discard message (pass on)",
6079 };
6080
6081 static const true_false_string isup_Discard_parameter_ind_value = {
6082 "Discard parameter",
6083 "Do not discard parameter (pass on)",
6084 };
6085
6086 static const value_string isup_Pass_on_not_possible_indicator_vals[] = {
6087 { 0x00, "Release call" },
6088 { 0x01, "Discard message" },
6089 { 0x02, "Discard parameter" },
6090 { 0x03, "Reserved (interpreted as 00)" },
6091 { 0, NULL },
6092 };
6093 static const value_string ISUP_Broadband_narrowband_interworking_indicator_vals[] = {
6094 { 0x00, "Pass on" },
6095 { 0x01, "Discard message" },
6096 { 0x02, "Release call" },
6097 { 0x03, "Discard parameter" },
6098 { 0, NULL },
6099 };
6100
6101 static void
6102 dissect_isup_parameter_compatibility_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6103 {
6104 unsigned length = tvb_reported_length(parameter_tvb);
6105 unsigned len = length;
6106 uint8_t upgraded_parameter, upgraded_parameter_no;
6107 int offset;
6108 uint8_t instruction_indicators;
6109
6110 static int * const indicator_flags[] = {
6111 &hf_isup_transit_at_intermediate_exchange_ind,
6112 &hf_isup_Release_call_ind,
6113 &hf_isup_Send_notification_ind,
6114 &hf_isup_Discard_message_ind_value,
6115 &hf_isup_Discard_parameter_ind,
6116 &hf_isup_Pass_on_not_possible_indicator,
6117 &hf_isup_extension_ind,
6118 NULL
6119 };
6120
6121 offset = 0;
6122 upgraded_parameter_no = 0;
6123
6124 /* etxrab Decoded as per Q.763 section 3.41 */
6125
6126 while (len > 0) {
6127 upgraded_parameter_no = upgraded_parameter_no + 1;
6128 upgraded_parameter = tvb_get_uint8(parameter_tvb, offset);
6129
6130 proto_tree_add_uint_format(parameter_tree, hf_isup_upgraded_parameter, parameter_tvb, offset, 1, upgraded_parameter,
6131 "Upgraded parameter no: %u = %s", upgraded_parameter_no,
6132 val_to_str_ext(upgraded_parameter, &isup_parameter_type_value_ext, "unknown (%u)"));
6133 offset += 1;
6134 len -= 1;
6135 instruction_indicators = tvb_get_uint8(parameter_tvb, offset);
6136 proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_instruction_indicators, ett_instruction_indicators, indicator_flags, ENC_NA);
6137
6138 offset += 1;
6139 len -= 1;
6140 if (!(instruction_indicators & H_8BIT_MASK)) {
6141 if (len == 0)
6142 return;
6143 instruction_indicators = tvb_get_uint8(parameter_tvb, offset);
6144 proto_tree_add_uint(parameter_tree, hf_isup_Broadband_narrowband_interworking_ind,
6145 parameter_tvb, offset, 1, instruction_indicators);
6146 offset += 1;
6147 len -= 1;
6148 }
6149
6150 if (len == 0)
6151 return;
6152 }
6153 }
6154 /* ------------------------------------------------------------------
6155 Dissector Parameter MLPP precedence
6156 */
6157 static const value_string isup_mlpp_precedence_look_forward_busy_vals[] = {
6158 { 0x00 , "Allowed" },
6159 { 0x01 , "Not Allowed" },
6160 { 0x02 , "Path reserved" },
6161 { 0x03 , "Spare" },
6162 { 0 , NULL },
6163 };
6164
6165 static const value_string isup_mlpp_precedence_level_vals[] = {
6166 { 0x00 , "Flash Override" },
6167 { 0x01 , "Flash" },
6168 { 0x02 , "Immediate" },
6169 { 0x03 , "Priority" },
6170 { 0x04 , "Routine" },
6171 { 0x05 , "Spare" },
6172 { 0x06 , "Spare" },
6173 { 0x07 , "Spare" },
6174 { 0x08 , "Spare" },
6175 { 0x09 , "Spare" },
6176 { 0x0A , "Spare" },
6177 { 0x0B , "Spare" },
6178 { 0x0C , "Spare" },
6179 { 0x0D , "Spare" },
6180 { 0x0E , "Spare" },
6181 { 0x0F , "Spare" },
6182 { 0 , NULL },
6183 };
6184
6185 static void
6186 dissect_isup_mlpp_precedence_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6187 {
6188 char NI_digits[5] = "";
6189 const char *temp_text = "";
6190 uint8_t digit_pair;
6191 uint32_t bin_code;
6192
6193 proto_tree_add_item(parameter_tree, hf_isup_look_forward_busy, parameter_tvb, 0, 1, ENC_NA);
6194
6195 proto_tree_add_item(parameter_tree, hf_isup_precedence_level, parameter_tvb, 0, 1, ENC_NA);
6196
6197 digit_pair = tvb_get_uint8(parameter_tvb, 1);
6198 NI_digits[0] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
6199 NI_digits[1] = number_to_char(digit_pair & DCBA_8BIT_MASK);
6200 digit_pair = tvb_get_uint8(parameter_tvb, 2);
6201 NI_digits[2] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
6202 NI_digits[3] = number_to_char(digit_pair & DCBA_8BIT_MASK);
6203 NI_digits[4] = '\0';
6204 proto_tree_add_string(parameter_tree, hf_isup_network_identity, parameter_tvb, 1, 2, NI_digits);
6205 bin_code = tvb_get_ntoh24(parameter_tvb, 3);
6206 proto_tree_add_item(parameter_tree, hf_isup_mlpp_service_domain, parameter_tvb, 3, 3, ENC_BIG_ENDIAN);
6207 proto_item_append_text(parameter_item,
6208 " : Prec = %s, NI = %s, MLPP service domain = 0x%x", temp_text, NI_digits, bin_code);
6209 }
6210 /* ------------------------------------------------------------------
6211 Dissector Parameter MCID request indicators
6212 */
6213 static void
6214 dissect_isup_mcid_request_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6215 { uint8_t indicator;
6216
6217 indicator = tvb_get_uint8(parameter_tvb, 0);
6218 proto_tree_add_uint_format_value(parameter_tree, hf_isup_mcid_request_indicators, parameter_tvb, 0, MCID_REQUEST_IND_LENGTH, indicator, "0x%x (MCID requested by Bit1=1, Holding requested by Bit2=1 see 3.31/Q.763)", indicator);
6219 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6220 }
6221 /* ------------------------------------------------------------------
6222 Dissector Parameter MCID response indicators
6223 */
6224 static void
6225 dissect_isup_mcid_response_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6226 { uint8_t indicator;
6227
6228 indicator = tvb_get_uint8(parameter_tvb, 0);
6229 proto_tree_add_uint_format_value(parameter_tree, hf_isup_mcid_response_indicators, parameter_tvb, 0, MCID_RESPONSE_IND_LENGTH, indicator, "0x%x (MCID included if Bit1=1, Holding provided if Bit2=1 see 3.32/Q.763)", indicator);
6230 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6231 }
6232 /* ------------------------------------------------------------------
6233 Dissector Parameter Hop counter
6234 */
6235 static void
6236 dissect_isup_hop_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6237 { uint8_t counter;
6238
6239 counter = tvb_get_uint8(parameter_tvb, 0) & EDCBA_8BIT_MASK; /* since bits H,G and F are spare */
6240 proto_tree_add_item(parameter_tree, hf_isup_hop_counter, parameter_tvb, 0, HOP_COUNTER_LENGTH, ENC_NA);
6241 proto_item_append_text(parameter_item, " : %u", counter);
6242 }
6243 /* ------------------------------------------------------------------
6244 Dissector Parameter Originating line information
6245 */
6246 static void
6247 dissect_isup_orig_line_info_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6248 { uint8_t info;
6249
6250 info = tvb_get_uint8(parameter_tvb, 0);
6251 proto_tree_add_item(parameter_tree, hf_isup_originating_line_info, parameter_tvb, 0, ORIG_LINE_INFO_LENGTH, ENC_NA);
6252 proto_item_append_text(parameter_item, " : %u (ANI II if < 51, reserved otherwise)", info);
6253 }
6254 /* ------------------------------------------------------------------
6255 Dissector Parameter Transmission medium requirement prime
6256 */
6257 static void
6258 dissect_isup_transmission_medium_requirement_prime_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6259 {
6260 uint8_t transmission_medium_requirement;
6261
6262 transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
6263 proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement_prime,
6264 parameter_tvb, 0, TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH, transmission_medium_requirement);
6265
6266 proto_item_append_text(parameter_item,
6267 " : %u (%s)",
6268 transmission_medium_requirement,
6269 val_to_str_ext_const(transmission_medium_requirement,
6270 &isup_transmission_medium_requirement_prime_value_ext,
6271 "spare/reserved"));
6272 }
6273
6274 /* ------------------------------------------------------------------
6275 Dissector Parameter location number
6276 */
6277 void
6278 dissect_isup_location_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6279 {
6280 uint8_t indicators1, indicators2;
6281 int offset = 0;
6282 static int * const indicators1_fields[] = {
6283 &hf_isup_odd_even_indicator,
6284 &hf_isup_calling_party_nature_of_address_indicator,
6285 NULL
6286 };
6287
6288 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
6289 indicators1 = tvb_get_uint8(parameter_tvb, 0);
6290 indicators2 = tvb_get_uint8(parameter_tvb, 1);
6291 proto_tree_add_boolean(parameter_tree, hf_isup_inn_indicator, parameter_tvb, 1, 1, indicators2);
6292 proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, indicators2);
6293 if ((indicators2 & GFE_8BIT_MASK) == 0x50) {
6294 proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 1, 1, indicators2 & GFE_8BIT_MASK,
6295 "Numbering plan indicator = private numbering plan");
6296 }
6297 proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 1, 1, indicators2);
6298 proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator, parameter_tvb, 1, 1, indicators2);
6299
6300 /* NOTE When the address presentation restricted indicator indicates address not available, the
6301 * subfields in items a), b), c) and d) are coded with 0's, and the screening indicator is set to 11
6302 * (network provided).
6303 * BUG 938 - Just check if there is someting more to dissect.
6304 */
6305 if (tvb_reported_length_remaining(parameter_tvb, offset) < 3) {
6306 proto_item_append_text(parameter_item, " : address not available");
6307 return;
6308 }
6309
6310 offset = 2;
6311
6312 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6313 hf_isup_location_number, hf_isup_calling_party_odd_address_signal_digit,
6314 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6315 NONE, 0);
6316 }
6317
6318 /* ------------------------------------------------------------------
6319 Dissector Parameter Redirection number restriction
6320 */
6321 static const value_string isup_redirection_presentation_indicator_vals[] = {
6322 { 0x00 , "Presentation allowed" },
6323 { 0x01 , "Presentation restricted" },
6324 { 0x02 , "Spare" },
6325 { 0x03 , "Spare" },
6326 { 0 , NULL },
6327 };
6328
6329 static void
6330 dissect_isup_redirection_number_restriction_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6331 {
6332 uint8_t indicator;
6333
6334 indicator = tvb_get_uint8(parameter_tvb, 0);
6335 proto_tree_add_item(parameter_tree, hf_isup_presentation_indicator, parameter_tvb, 0, REDIRECTION_NUMBER_RESTRICTION_LENGTH, ENC_NA);
6336 proto_item_append_text(parameter_item, " : 0x%x ", indicator);
6337 }
6338 /* ------------------------------------------------------------------
6339 Dissector Parameter Call transfer identity
6340 */
6341 static void
6342 dissect_isup_call_transfer_reference_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6343 { uint8_t id;
6344
6345 id = tvb_get_uint8(parameter_tvb, 0);
6346 proto_tree_add_item(parameter_tree, hf_isup_call_transfer_identity, parameter_tvb, 0, CALL_TRANSFER_REF_LENGTH, ENC_NA);
6347 proto_item_append_text(parameter_item, " : %u", id);
6348 }
6349 /* ------------------------------------------------------------------
6350 Dissector Parameter Loop prevention
6351 */
6352
6353 static void
6354 dissect_isup_loop_prevention_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6355 {
6356 uint8_t indicator;
6357
6358 indicator = tvb_get_uint8(parameter_tvb, 0);
6359 proto_tree_add_item(parameter_tree, hf_isup_loop_prevention_indicator_type, parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, ENC_NA);
6360 if ((indicator & A_8BIT_MASK) == 0) {
6361 proto_item_append_text(parameter_item, " : Request (%u)", indicator);
6362 }
6363 else {
6364 proto_tree_add_uint(parameter_tree, hf_isup_loop_prevention_response_ind,
6365 parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, indicator);
6366 proto_item_append_text(parameter_item, " : Response (%u)", indicator);
6367 }
6368 }
6369
6370 /* ------------------------------------------------------------------
6371 Dissector Parameter Call transfer number
6372 */
6373 static void
6374 dissect_isup_call_transfer_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6375 {
6376 uint8_t indicators1, indicators2;
6377 int offset = 0;
6378
6379 indicators1 = tvb_get_uint8(parameter_tvb, 0);
6380 proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, indicators1);
6381 proto_tree_add_uint(parameter_tree, hf_isup_calling_party_nature_of_address_indicator, parameter_tvb, 0, 1, indicators1);
6382 indicators2 = tvb_get_uint8(parameter_tvb, 1);
6383 proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, indicators2);
6384 if ((indicators2 & GFE_8BIT_MASK) == 0x50)
6385 proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 1, 1, indicators2 & GFE_8BIT_MASK,
6386 "Numbering plan indicator = private numbering plan");
6387 proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 1, 1, indicators2);
6388 proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator_enhanced, parameter_tvb, 1, 1, indicators2);
6389 offset = 2;
6390
6391 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6392 hf_isup_call_transfer_number, hf_isup_calling_party_odd_address_signal_digit,
6393 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6394 NONE, 0);
6395 }
6396
6397 /* ------------------------------------------------------------------
6398 Dissector Parameter CCSS
6399 */
6400 static const true_false_string tfs_ccss_call_no_indication = { "CCSS call", "no indication"};
6401
6402 static void
6403 dissect_isup_ccss_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6404 {
6405 uint8_t indicator;
6406
6407 indicator = tvb_get_uint8(parameter_tvb, 0);
6408 proto_tree_add_item(parameter_tree, hf_isup_ccss_call_indicator, parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, ENC_NA);
6409 if ((indicator & A_8BIT_MASK) == 0) {
6410 proto_item_append_text(parameter_item, " : no indication (%u)", indicator);
6411 }
6412 else {
6413 proto_item_append_text(parameter_item, " : CCSS call (%u)", indicator);
6414 }
6415 }
6416 /* ------------------------------------------------------------------
6417 Parameter Forward GVNS
6418 */
6419 static void
6420 dissect_isup_forward_gvns_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6421 { unsigned length = tvb_reported_length(parameter_tvb);
6422 proto_tree_add_item(parameter_tree, hf_isup_forward_gvns, parameter_tvb, 0, length, ENC_NA);
6423 }
6424 /* ------------------------------------------------------------------
6425 Parameter Redirect capability
6426 */
6427
6428 static const value_string isup_jpn_redirect_capabilit_vals[] = {
6429 { 0, "Reserved" },
6430 { 1, "Redirect possible before ACM" },
6431 { 2, "Reserved" },
6432 { 3, "Reserved" },
6433 { 4, "Spare" },
6434 { 5, "Spare" },
6435 { 6, "Spare" },
6436 { 7, "Spare" },
6437 { 0, NULL}
6438 };
6439
6440 static void
6441 dissect_isup_redirect_capability_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_, uint8_t itu_isup_variant)
6442 {
6443 unsigned length = tvb_reported_length(parameter_tvb);
6444
6445 switch (itu_isup_variant) {
6446 case ISUP_JAPAN_VARIANT:
6447 /* Fall through */
6448 case ISUP_JAPAN_TTC_VARIANT:
6449 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6450 proto_tree_add_item(parameter_tree, hf_japan_isup_redirect_capability, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6451 break;
6452 default:
6453 proto_tree_add_uint_format_value(parameter_tree, hf_isup_redirect_capability, parameter_tvb, 0, length, itu_isup_variant, "(format is a national matter)");
6454 break;
6455 }
6456 }
6457 /* ------------------------------------------------------------------
6458 Dissector Parameter Backward GVNS
6459 */
6460 static void
6461 dissect_isup_backward_gvns_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6462 { uint8_t indicator;
6463
6464 indicator = tvb_get_uint8(parameter_tvb, 0);
6465 proto_tree_add_uint_format_value(parameter_tree, hf_isup_backward_gvns, parameter_tvb, 0, BACKWARD_GVNS_LENGTH, indicator,
6466 "0x%x (refer to 3.62/Q.763 for detailed decoding)", indicator);
6467 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6468 }
6469 /* ------------------------------------------------------------------
6470 Dissector Parameter Network management controls
6471 */
6472 static void
6473 dissect_isup_network_management_controls_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6474 { uint8_t indicator;
6475
6476 indicator = tvb_get_uint8(parameter_tvb, 0);
6477 proto_tree_add_boolean(parameter_tree, hf_isup_temporary_alternative_routing_ind,
6478 parameter_tvb, 0, NETWORK_MANAGEMENT_CONTROLS_LENGTH, indicator);
6479 proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, NETWORK_MANAGEMENT_CONTROLS_LENGTH, indicator);
6480 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6481 }
6482 /* ------------------------------------------------------------------
6483 Dissector Parameter Correlation id - no detailed dissection since defined in Rec. Q.1281
6484 */
6485 static void
6486 dissect_isup_correlation_id_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6487 { unsigned length = tvb_reported_length(parameter_tvb);
6488 proto_tree_add_item(parameter_tree, hf_isup_correlation_id, parameter_tvb, 0, length, ENC_NA);
6489 }
6490 /* ------------------------------------------------------------------
6491 Dissector Parameter SCF id - no detailed dissection since defined in Rec. Q.1281
6492 */
6493 static void
6494 dissect_isup_scf_id_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6495 { unsigned length = tvb_reported_length(parameter_tvb);
6496 proto_tree_add_item(parameter_tree, hf_isup_scf_id, parameter_tvb, 0, length, ENC_NA);
6497 }
6498 /* ------------------------------------------------------------------
6499 Dissector Parameter Call diversion treatment indicators
6500 */
6501 static void
6502 dissect_isup_call_diversion_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6503 { uint8_t indicator;
6504
6505 indicator = tvb_get_uint8(parameter_tvb, 0);
6506 proto_tree_add_uint(parameter_tree, hf_isup_call_to_be_diverted_ind, parameter_tvb, 0, CALL_DIV_TREATMENT_IND_LENGTH, indicator);
6507 proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CALL_DIV_TREATMENT_IND_LENGTH, indicator);
6508 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6509 }
6510
6511 /* ------------------------------------------------------------------
6512 Dissector Parameter called IN number
6513 */
6514 static void
6515 dissect_isup_called_in_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6516 {
6517 uint8_t indicators1;
6518 int offset = 0;
6519 static int * const indicators1_fields[] = {
6520 &hf_isup_odd_even_indicator,
6521 &hf_isup_calling_party_nature_of_address_indicator,
6522 NULL
6523 };
6524 static int * const indicators2_fields[] = {
6525 &hf_isup_numbering_plan_indicator,
6526 &hf_isup_address_presentation_restricted_indicator,
6527 NULL
6528 };
6529
6530 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
6531 indicators1 = tvb_get_uint8(parameter_tvb, 0);
6532 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
6533 offset = 2;
6534
6535 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6536 hf_isup_called_in_number, hf_isup_calling_party_odd_address_signal_digit,
6537 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6538 NONE, 0);
6539 }
6540
6541 /* ------------------------------------------------------------------
6542 Dissector Parameter Call offering treatment indicators
6543 */
6544 static void
6545 dissect_isup_call_offering_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6546 { uint8_t indicator;
6547
6548 indicator = tvb_get_uint8(parameter_tvb, 0);
6549 proto_tree_add_uint(parameter_tree, hf_isup_call_to_be_offered_ind, parameter_tvb, 0, CALL_OFFERING_TREATMENT_IND_LENGTH, indicator);
6550 proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CALL_OFFERING_TREATMENT_IND_LENGTH, indicator);
6551 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6552 }
6553 /* ------------------------------------------------------------------
6554 Parameter Charged party identification
6555 */
6556 static void
6557 dissect_isup_charged_party_identification_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6558 { unsigned length = tvb_reported_length(parameter_tvb);
6559 proto_tree_add_item(parameter_tree, hf_isup_charged_party_identification, parameter_tvb, 0, length, ENC_NA);
6560 }
6561 /* ------------------------------------------------------------------
6562 Dissector Parameter Conference treatment indicators
6563 */
6564 static void
6565 dissect_isup_conference_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6566 { uint8_t indicator;
6567
6568 indicator = tvb_get_uint8(parameter_tvb, 0);
6569 proto_tree_add_uint(parameter_tree, hf_isup_conference_acceptance_ind, parameter_tvb, 0, CONFERENCE_TREATMENT_IND_LENGTH, indicator);
6570 proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CONFERENCE_TREATMENT_IND_LENGTH, indicator);
6571 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6572 }
6573 /* ------------------------------------------------------------------
6574 Dissector Parameter Display information
6575 * TODO Output Display info :
6576 * Quote from Q.931:
6577 * 4.5.16 Display
6578 * The purpose of the Display information element is to supply display information
6579 * that may be displayed by the user. The information contained in this element is coded
6580 * in IA5 characters.
6581 * 8 7 6 5 4 3 2 1 Octet
6582 * 0 0 1 0 1 0 0 0 1 Display information element identifier
6583 * 2 Length of display contents
6584 * 0 3 Display information (IA5 characters)
6585 * etc.
6586 * - end - quote -
6587 * Assuming octet 2 and onwards is passed here - just output text ?
6588 */
6589 static void
6590 dissect_isup_display_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6591 { unsigned length = tvb_reported_length(parameter_tvb);
6592 proto_tree_add_item(parameter_tree, hf_isup_display_information, parameter_tvb, 0, length, ENC_NA);
6593 }
6594 /* ------------------------------------------------------------------
6595 Parameter UID action indicators
6596 */
6597 static void
6598 dissect_isup_uid_action_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6599 { uint8_t indicator;
6600
6601 indicator = tvb_get_uint8(parameter_tvb, 0);
6602 proto_tree_add_uint_format_value(parameter_tree, hf_isup_uid_action_indicators, parameter_tvb, 0, UID_ACTION_IND_LENGTH, indicator,
6603 "0x%x (refer to 3.78/Q.763 for detailed decoding)", indicator);
6604 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6605 }
6606 /* ------------------------------------------------------------------
6607 Parameter UID capability indicators
6608 */
6609 static void
6610 dissect_isup_uid_capability_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6611 { uint8_t indicator;
6612
6613 indicator = tvb_get_uint8(parameter_tvb, 0);
6614 proto_tree_add_uint_format_value(parameter_tree, hf_isup_uid_capability_indicators, parameter_tvb, 0, UID_CAPABILITY_IND_LENGTH,
6615 indicator, "0x%x (refer to 3.79/Q.763 for detailed decoding)", indicator);
6616 proto_item_append_text(parameter_item, " : 0x%x", indicator);
6617 }
6618 /* ------------------------------------------------------------------
6619 Parameter Redirect counter
6620 */
6621 static void
6622 dissect_isup_redirect_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_, uint8_t itu_isup_variant)
6623 {
6624 unsigned length = tvb_reported_length(parameter_tvb);
6625
6626 switch (itu_isup_variant) {
6627 case ISUP_JAPAN_VARIANT:
6628 /* Fall through */
6629 case ISUP_JAPAN_TTC_VARIANT:
6630 proto_tree_add_item(parameter_tree, hf_japan_isup_redirect_counter, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6631 break;
6632 default:
6633 proto_tree_add_uint_format_value(parameter_tree, hf_isup_redirect_counter, parameter_tvb, 0, length, itu_isup_variant, "(format is a national matter)");
6634 break;
6635 }
6636 }
6637 /* ------------------------------------------------------------------
6638 Dissector Parameter Collect call request
6639 */
6640 static const true_false_string tfs_collect_call_req_no_indication = { "collect call requested", "no indication"};
6641
6642 static void
6643 dissect_isup_collect_call_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6644 { uint8_t indicator;
6645
6646 indicator = tvb_get_uint8(parameter_tvb, 0);
6647 proto_tree_add_item(parameter_tree, hf_isup_collect_call_request_indicator, parameter_tvb, 0, COLLECT_CALL_REQUEST_LENGTH, ENC_NA);
6648 if ((indicator & A_8BIT_MASK) == 0) {
6649 proto_item_append_text(parameter_item, " : no indication (0x%x)", indicator);
6650 }
6651 else {
6652 proto_item_append_text(parameter_item, " : collect call requested (0x%x)", indicator);
6653 }
6654 }
6655 /* ------------------------------------------------------------------
6656 Dissector Parameter Calling geodetic location
6657 */
6658 void
6659 dissect_isup_calling_geodetic_location_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6660 {
6661 unsigned length = tvb_reported_length(parameter_tvb);
6662 uint8_t oct, lpri;
6663
6664 oct = tvb_get_uint8(parameter_tvb, 0);
6665 lpri = (oct & 0xc0) >> 2;
6666
6667 proto_tree_add_uint(parameter_tree, hf_isup_geo_loc_presentation_restricted_ind, parameter_tvb, 0, 1, oct);
6668 proto_tree_add_uint(parameter_tree, hf_isup_geo_loc_screening_ind, parameter_tvb, 0, 1, oct);
6669
6670 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 1, 1, ENC_NA);
6671 proto_tree_add_item(parameter_tree, hf_isup_geo_loc_shape, parameter_tvb, 1, 1, ENC_NA);
6672
6673 if (length > 2)
6674 {
6675 if (lpri < 0x2)
6676 {
6677 proto_tree_add_item(parameter_tree, hf_isup_geo_loc_shape_description, parameter_tvb, 2, length - 2, ENC_NA);
6678 }
6679 else
6680 {
6681 /* not supposed to have any data if 'lpri' was 'location not available' */
6682
6683 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 2, length - 2,
6684 "Unknown (?), should not have data if LPRI is 'location not available'");
6685 }
6686 }
6687 }
6688
6689 /* ------------------------------------------------------------------
6690 Dissector Parameter Generic number
6691 */
6692 static const range_string number_qualifier_indicator_vals[] = {
6693 { 0x00, 0x00, "reserved (dialled digits) (national use)"},
6694 { 0x01, 0x01, "additional called number (national use)"},
6695 { 0x02, 0x02, "reserved (supplemental user provided calling number - failed network screening) (national use)"},
6696 { 0x03, 0x03, "reserved (supplemental user provided calling number - not screened) (national use)"},
6697 { 0x04, 0x04, "reserved (redirecting terminating number) (national use)"},
6698 { 0x05, 0x05, "additional connected number"},
6699 { 0x06, 0x06, "additional calling party number"},
6700 { 0x07, 0x07, "reserved for additional original called number"},
6701 { 0x08, 0x08, "reserved for additional redirecting number"},
6702 { 0x09, 0x09, "reserved for additional redirection number"},
6703 { 0x0a, 0x0a, "reserved (used in 1992 version)"},
6704 { 0x0b, 0x7f, "spare"},
6705 { 0x80, 0xfe, "reserved for national use"},
6706 { 0xff, 0xff, "reserved for expansion"},
6707 { 0, 0, NULL}
6708 };
6709 void
6710 dissect_isup_generic_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6711 {
6712 uint8_t indicators1, indicators2;
6713 int offset = 0;
6714 static int * const indicators1_fields[] = {
6715 &hf_isup_odd_even_indicator,
6716 &hf_isup_calling_party_nature_of_address_indicator,
6717 NULL
6718 };
6719
6720 proto_tree_add_item(parameter_tree, hf_isup_number_qualifier_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6721 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb,1 , 1, indicators1_fields, ENC_NA);
6722 indicators1 = tvb_get_uint8(parameter_tvb, 1);
6723 indicators2 = tvb_get_uint8(parameter_tvb, 2);
6724 proto_tree_add_boolean(parameter_tree, hf_isup_ni_indicator, parameter_tvb, 2, 1, indicators2);
6725 proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 2, 1, indicators2);
6726 if ((indicators2 & GFE_8BIT_MASK) == 0x50) {
6727 proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 2, 1, indicators2 & GFE_8BIT_MASK,
6728 "Numbering plan indicator = private numbering plan");
6729 }
6730 proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 2, 1, indicators2);
6731 proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator_enhanced, parameter_tvb, 2, 1, indicators2);
6732 offset = 3;
6733
6734 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6735 hf_isup_generic_number, hf_isup_calling_party_odd_address_signal_digit,
6736 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6737 NONE, 0);
6738
6739 /*
6740 * Indicators1 = Nature of address
6741 * Indicators2 = Number plan indicator
6742 */
6743 indicators1 = indicators1 & 0x7f;
6744 indicators2 = (indicators2 & 0x70)>>4;
6745 if ((indicators1 == ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR) && (indicators2 == ISDN_NUMBERING_PLAN))
6746 dissect_e164_cc(parameter_tvb, parameter_tree, 3, E164_ENC_BCD);
6747 }
6748
6749 /* ------------------------------------------------------------------
6750 Dissector Parameter Jurisdiction parameter
6751 */
6752 static void
6753 dissect_isup_jurisdiction_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6754 {
6755 int offset = 0;
6756
6757 offset = 0;
6758
6759 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6760 hf_isup_jurisdiction, hf_isup_called_party_odd_address_signal_digit,
6761 hf_isup_called_party_even_address_signal_digit, (tvb_reported_length(parameter_tvb) > 0),
6762 NONE, 0);
6763 }
6764
6765 /* ------------------------------------------------------------------
6766 Dissector Parameter Generic name
6767 */
6768 static void
6769 dissect_isup_generic_name_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6770 {
6771 int gen_name_length;
6772 char *gen_name = NULL;
6773 static int * const indicators[] = {
6774 &hf_isup_generic_name_presentation,
6775 &hf_isup_generic_name_availability,
6776 &hf_isup_generic_name_type,
6777 NULL
6778 };
6779
6780 gen_name = (char *)wmem_alloc(pinfo->pool, MAXGNAME + 1);
6781 gen_name[0] = '\0';
6782 gen_name_length = tvb_reported_length(parameter_tvb) - 1;
6783
6784 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators, ENC_NA);
6785
6786 gen_name = tvb_get_string_enc(pinfo->pool, parameter_tvb, 1, gen_name_length, ENC_ASCII);
6787 gen_name[gen_name_length] = '\0';
6788 proto_tree_add_string(parameter_tree, hf_isup_generic_name_ia5, parameter_tvb, 1, gen_name_length, gen_name);
6789 proto_item_append_text(parameter_item, " : %s", gen_name);
6790
6791 }
6792
6793 /* ------------------------------------------------------------------
6794 Dissector Parameter Generic digits
6795 */
6796 void
6797 dissect_isup_generic_digits_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6798 { unsigned length = tvb_reported_length(parameter_tvb);
6799 proto_tree_add_item(parameter_tree, hf_isup_generic_digits, parameter_tvb, 0, length, ENC_NA);
6800 }
6801
6802 /* ------------------------------------------------------------------
6803 Dissector Parameter Charge number
6804 */
6805 static void
6806 dissect_isup_charge_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6807 {
6808 uint8_t indicators1;
6809 int offset = 0;
6810 static int * const indicators1_fields[] = {
6811 &hf_isup_odd_even_indicator,
6812 &hf_isup_charge_number_nature_of_address_indicator,
6813 NULL
6814 };
6815
6816 proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
6817 indicators1 = tvb_get_uint8(parameter_tvb, 0);
6818 proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, ENC_NA);
6819 offset = 2;
6820
6821 dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6822 hf_isup_charge_number, hf_isup_calling_party_odd_address_signal_digit,
6823 hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6824 NONE, 0);
6825 }
6826
6827 /* ------------------------------------------------------------------ */
6828 static void
6829 dissect_isup_unknown_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6830 {
6831 unsigned length = tvb_reported_length(parameter_tvb);
6832 proto_tree_add_item(parameter_tree, hf_isup_parameter_value, parameter_tvb, 0, length, ENC_NA);
6833 }
6834 /* ------------------------------------------------------------------ */
6835
6836 /* Japan ISUP */
6837
6838 /*
6839 8 7 6 5 4 3 2 1
6840 O/E Nature of address indicator 1
6841 INN NAPI Spare 2
6842 2nd address signal 1st address signal 3
6843 ... ... :
6844 Filler (if necessary) nth address signal 15
6845 */
6846 static void
6847 dissect_japan_isup_called_dir_num(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6848 {
6849 int offset = 0;
6850 int parameter_length;
6851
6852 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
6853
6854 proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6855 proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6856 offset += 1;
6857
6858 proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6859 proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6860 offset += 1;
6861
6862 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, parameter_length-offset, "Number not dissected yet");
6863 }
6864
6865
6866 /*
6867 8 7 6 5 4 3 2 1
6868 +-----+-----+-----+-----+-----+-----+-----+-----+
6869 - Information Type Tag - 1
6870 +-----------------------------------------------+
6871 - Information Type Length - 2
6872 +-----------------------------------------------+
6873 - Information Type Value - 3
6874 +-----------------------------------------------+
6875 . .
6876 . .
6877 . .
6878 +-----------------------------------------------+
6879 - Information Type Tag - n+1
6880 +-----------------------------------------------+
6881 - Information Type Length - n+2
6882 +-----------------------------------------------+
6883 - Information Type Value - n+3
6884 |-----------------------------------------------/
6885
6886 Information Type Tag
6887
6888 00000000 Reserved (Note)
6889 00000001 Reserved
6890 00000010 Reserved
6891 00000011 Performing redirect indicator
6892 00000100 Invoking redirect reason
6893 00000101
6894 to Spare
6895 11111111
6896
6897 Note: In standard this value is marked as -Not used-,
6898 here is treated as reserved.
6899
6900 Performing redirect indicator
6901
6902 8 7 6 5 4 3 2 1
6903 +-----+-----+-----+-----+-----+-----+-----+-----+
6904 - ext - Performing redirect reason - 1
6905 +-----+-----------------------------------------+
6906 - -Redirect possible-
6907 - Spare - indicator at - 2
6908 - - performing -
6909 - - exchange -
6910 +-----------------------------+-----------------+
6911 : : : :
6912 : : :
6913 +-----------------------------------------------+
6914 - ext - Performing redirect reason - 2n|1
6915 +-----+-----------------------|-----------------+ Reason n
6916 - -Redirect possible-
6917 - Spare - indicator at - 2n
6918 - - performing -
6919 - - exchange -
6920 |-----------------------------+-----------------/
6921
6922
6923 Redirect possible indicator at performing exchange
6924 000 No indication
6925 001 Redirect possible before ACM
6926 010 Reserved
6927 011 Reserved
6928 100
6929 to Spare
6930 111
6931
6932 Invoking redirect reason
6933
6934 8 7 6 5 4 3 2 1
6935 +-----+-----+-----+-----+-----+-----+-----+-----+
6936 - ext - Invoking redirect reason - 1
6937 +-----+-----------------------------------------+
6938 : : :
6939 : : :
6940 +-----------------------------------------------+
6941 - ext - Invoking redirect reason - n
6942 |-----+-----------------------------------------/
6943
6944 Extension indicator (ext)
6945
6946 0 Information continues in next octet
6947 1 Last octet
6948
6949 Invoking redirect reason
6950
6951 0000000 Unknown / not available
6952 0000001 Service provider portability (national use)
6953 0000010 Reserved for location portability
6954 0000011 Reserved for service portability
6955 0000100
6956 to Spare
6957 0111111
6958 1000000
6959 to Reserved for national use
6960 1111101
6961 1111110 Local number portability / Mobile number
6962 portability
6963 1111111 Reserved for national use
6964
6965 */
6966
6967 static const value_string isup_rfi_info_type_values[] = {
6968 { 0, "Reserved" },
6969 { 1, "Reserved" },
6970 { 2, "Reserved" },
6971 { 3, "Performing redirect indicator" },
6972 { 4, "Invoking redirect reason" },
6973 { 0, NULL}
6974 };
6975
6976 /* Performing redirect reason */
6977 static const value_string perf_redir_reason_vals[] = {
6978 { 0, "Unknown/not available" },
6979 { 1, "Service provider portability (national use)" },
6980 { 2, "Reserved for location portability" },
6981 { 3, "Reserved for service portability" },
6982 /*
6983 0000100
6984 to Spare
6985 0111111
6986 1000000
6987 to Reserved for national use
6988 1111101
6989 */
6990 { 0x7e, "Local number portability / Mobile number portability" },
6991 { 0x7f, "Reserved for national use" },
6992 { 0, NULL}
6993 };
6994
6995
6996 static const value_string redir_pos_ind_vals[] = {
6997 { 0, "No indication" },
6998 { 1, "Redirect possible before ACM" },
6999 { 2, "Reserved" },
7000 { 3, "Reserved" },
7001 { 4, "Reserved" },
7002 { 5, "Reserved" },
7003 { 6, "Reserved" },
7004 { 7, "Reserved" },
7005 { 0, NULL}
7006 };
7007
7008
7009 static void
7010 dissect_japan_isup_redirect_fwd_inf(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7011 {
7012 int offset = 0;
7013 uint8_t tag, tag_len, ext_ind;
7014 int parameter_length;
7015
7016 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7017
7018 while (offset < parameter_length) {
7019 /* Information Type Tag */
7020 tag = tvb_get_uint8(parameter_tvb, offset);
7021 proto_tree_add_item(parameter_tree, hf_japan_isup_rfi_info_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7022 offset += 1;
7023 /* Information Type Length */
7024 tag_len = tvb_get_uint8(parameter_tvb, offset);
7025 proto_tree_add_item(parameter_tree, hf_japan_isup_rfi_info_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7026 offset += 1;
7027 switch (tag) {
7028 case 3: /* Performing redirect indicator */
7029 /* Performing redirect reason oct 1 */
7030 ext_ind = 0;
7031 while (ext_ind == 0) {
7032 ext_ind = tvb_get_uint8(parameter_tvb, offset) >> 7;
7033 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7034 proto_tree_add_item(parameter_tree, hf_japan_isup_perf_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7035 offset += 1;
7036 /* Redirect possible indicator at performing exchange */
7037 proto_tree_add_item(parameter_tree, hf_japan_isup_redir_pos_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7038 offset += 1;
7039 }
7040 break;
7041 case 4:
7042 /* Invoking redirect reason */
7043 ext_ind = 0;
7044 while (ext_ind == 0) {
7045 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7046 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7047 proto_tree_add_item(parameter_tree, hf_japan_isup_inv_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7048 offset += 1;
7049 }
7050 break;
7051 default:
7052 /* Information Type Value */
7053 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, tag_len, "Unknown(not dissected) tag");
7054 offset = offset + tag_len;
7055 break;
7056 }
7057 }
7058 }
7059
7060
7061 static const value_string japan_isup_bwd_info_type_vals[] = {
7062 { 0, "Reserved" },
7063 { 1, "Reserved" },
7064 { 2, "Reserved" },
7065 { 3, "invoking redirect reason" },
7066 { 0, NULL}
7067 };
7068
7069 static void
7070 dissect_japan_isup_redirect_backw_inf(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7071 {
7072 int offset = 0;
7073 uint8_t tag, tag_len, ext_ind;
7074 int parameter_length;
7075
7076 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7077
7078 while (offset < parameter_length) {
7079 /* Information Type Tag */
7080 tag = tvb_get_uint8(parameter_tvb, offset);
7081 proto_tree_add_item(parameter_tree, hf_japan_isup_bwd_info_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7082 offset += 1;
7083 /* Information Type Length */
7084 tag_len = tvb_get_uint8(parameter_tvb, offset);
7085 proto_tree_add_item(parameter_tree, hf_japan_isup_tag_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7086 offset += 1;
7087 switch (tag) {
7088 case 3: /* invoking redirect reason */
7089 /* invoking redirect reason oct 1 */
7090 ext_ind = 0;
7091 while (ext_ind == 0) {
7092 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7093 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7094 proto_tree_add_item(parameter_tree, hf_japan_isup_inv_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7095 offset += 1;
7096 }
7097 break;
7098 default:
7099 /* Information Type Value */
7100 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, tag_len, "Unknown(not dissected) tag");
7101 offset = offset + tag_len;
7102 break;
7103 }
7104 }
7105 }
7106
7107
7108 static const value_string japan_isup_emerg_call_type_vals[] = {
7109 { 0, "No specific category" },
7110 { 1, "Spare" },
7111 { 2, "Spare" },
7112 { 3, "Spare" },
7113 { 0, NULL}
7114 };
7115 static void
7116 dissect_japan_isup_emergency_call_ind(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7117 {
7118 int offset = 0;
7119
7120 proto_tree_add_item(parameter_tree, hf_japan_isup_emerg_call_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7121 }
7122
7123 static const value_string hold_at_emerg_call_disc_ind_vals[] = {
7124 { 0, "No indication" },
7125 { 1, "Emergency Call is holding" },
7126 { 2, "Call Back from the Emergency Center" },
7127 { 3, "Re-answer to an Emergency call" },
7128 { 0, NULL}
7129 };
7130
7131 static void
7132 dissect_japan_isup_emergency_call_inf_ind(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7133 {
7134 int offset = 0;
7135
7136
7137 proto_tree_add_item(parameter_tree, hf_japan_isup_hold_at_emerg_call_disc_ind, parameter_tvb, offset, 2, ENC_BIG_ENDIAN);
7138 }
7139
7140 static void
7141 dissect_japan_isup_network_poi_cad(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7142 {
7143 proto_item *digits_item;
7144 proto_tree *digits_tree;
7145 int offset = 0;
7146 uint8_t octet;
7147 uint8_t odd_even;
7148 uint8_t carrier_info_length;
7149 int num_octets_with_digits = 0;
7150 int digit_index = 0;
7151 wmem_strbuf_t *ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7152
7153 /* POI Hierarchy information
7154
7155 8 7 6 5 4 3 2 1
7156 +-----------------------|-----------------------+
7157 | Entry POI Hierarchy | Exit POI Hierarchy | 1
7158 | | |
7159 \-----------------------------------------------|
7160
7161 */
7162
7163 /* POI Hierarchy information */
7164 proto_tree_add_item(parameter_tree, hf_isup_carrier_info_poi_entry_HEI, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7165 proto_tree_add_item(parameter_tree, hf_isup_carrier_info_poi_exit_HEI, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7166 offset += 1;
7167
7168 /* length of CA information (in octets) */
7169 carrier_info_length = tvb_get_uint8(parameter_tvb, offset);
7170 proto_tree_add_item(parameter_tree, hf_japan_isup_carrier_info_length, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7171 offset += 1;
7172
7173 /* POI|CA information (Charge Area)
7174
7175 8 7 6 5 4 3 2 1
7176 +-----|-----------------------------------------+
7177 |Odd/ | Spare | 1
7178 |even | |
7179 +-----------------------------------------------+
7180 | 2nd CA code digit | 1st CA code digit | 2
7181 | | |
7182 +-----------------------+-----------------------+
7183 . . .
7184 . . .
7185 . . .
7186 +-----------------------+-----------------------+
7187 | Filler | 5|th CA code digit | m
7188 | | |
7189 \-----------------------------------------------|
7190 */
7191
7192 digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7193 ett_isup_address_digits, &digits_item, "Charge Area Number");
7194
7195 /* Odd.Even Indicator*/
7196 odd_even = tvb_get_uint8(parameter_tvb, offset);
7197 proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);
7198
7199 /* Number of Octets containing digits*/
7200 num_octets_with_digits = carrier_info_length - 1;
7201
7202 /* Lets now load up the digits.*/
7203 /* If the odd indicator is set... drop the Filler from the last octet.*/
7204 /* This loop also loads up ca_number with the digits for display*/
7205 digit_index = 0;
7206 while (num_octets_with_digits > 0) {
7207 offset += 1;
7208 octet = tvb_get_uint8(parameter_tvb, offset);
7209 if (++digit_index > MAXDIGITS) {
7210 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7211 break;
7212 }
7213 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
7214 wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7215 if (num_octets_with_digits == 1) {
7216 if (odd_even == 0) {
7217 if (++digit_index > MAXDIGITS) {
7218 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7219 break;
7220 }
7221 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7222 wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7223 }
7224 }
7225 else {
7226 if (++digit_index > MAXDIGITS) {
7227 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7228 break;
7229 }
7230 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7231 wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7232 }
7233
7234 num_octets_with_digits--;
7235 }
7236 proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
7237 }
7238
7239 static const range_string jpn_isup_add_user_cat_type_vals[] = {
7240 { 0, 0, "Spare" },
7241 { 1, 0x80, "Reserved for network specific use" },
7242 { 0x81, 0xfa, "Spare" },
7243 { 0xfb, 0xfb, "Type 3 of additional mobile service information" },
7244 { 0xfc, 0xfc, "Type 2 of additional mobile service information" },
7245 { 0xfd, 0xfd, "Type 1 of additional mobile service information" },
7246 { 0xfe, 0xfe, "Type 1 of additional fixed service information" },
7247 { 0xff, 0xff, "Spare" },
7248 { 0, 0, NULL } };
7249
7250 static const value_string jpn_isup_type_1_add_fixed_serv_inf_vals[] = {
7251 { 0, "Spare" },
7252 { 1, "Train payphone" },
7253 { 2, "Pink (non-NTT payphone)" },
7254 { 0, NULL}
7255 };
7256
7257 static const value_string jpn_isup_type_1_add_mobile_serv_inf_vals[] = {
7258 { 0, "Spare" },
7259 { 1, "Cellular telephone service" },
7260 { 2, "Maritime telephone service" },
7261 { 3, "Airplane telephone service" },
7262 { 4, "Paging service" },
7263 { 5, "PHS service" },
7264 { 6, "Spare" },
7265 { 0, NULL}
7266 };
7267 static const value_string jpn_isup_type_2_add_mobile_serv_inf_vals[] = {
7268 { 0, "Spare" },
7269 { 1, "HiCap method (analog)" },
7270 { 2, "N/J-TACS" },
7271 { 3, "PDC 800 MHz" },
7272 { 4, "PDC 1500 MHz" },
7273 { 5, "N-STAR satellite" },
7274 { 6, "cdmaOne 800 MHz" },
7275 { 7, "Iridium satellite" },
7276 { 8, "IMT-2000" },
7277 { 9, "PHS (fixed network dependent)" },
7278 { 10, "Spare" },
7279 { 0, NULL}
7280 };
7281 static value_string_ext jpn_isup_type_2_add_mobile_serv_inf_vals_ext = VALUE_STRING_EXT_INIT(jpn_isup_type_2_add_mobile_serv_inf_vals);
7282
7283
7284 void
7285 dissect_japan_isup_additonal_user_cat(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7286 {
7287 int offset = 0;
7288 uint8_t type;
7289 int parameter_length;
7290
7291 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7292
7293 while (offset < parameter_length) {
7294 /* Type of Additional User/Service Information */
7295 type = tvb_get_uint8(parameter_tvb, offset);
7296 proto_tree_add_item(parameter_tree, hf_japan_isup_add_user_cat_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7297 offset += 1;
7298 /* Additional User/Service Information */
7299 switch (type) {
7300 case 0xfe:
7301 /* Type 1 of additional fixed service information */
7302 proto_tree_add_item(parameter_tree, hf_japan_isup_type_1_add_fixed_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7303 break;
7304 case 0xfd:
7305 /* Type 1 of additional mobile service information */
7306 proto_tree_add_item(parameter_tree, hf_japan_isup_type_1_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7307 break;
7308 case 0xfc:
7309 /* Type 2 of additional mobile service information */
7310 proto_tree_add_item(parameter_tree, hf_japan_isup_type_2_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7311 break;
7312 case 0xfb:
7313 /* Type 3 of additional mobile service information */
7314 proto_tree_add_item(parameter_tree, hf_japan_isup_type_3_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7315 break;
7316 default:
7317 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, 1,
7318 "Unknown(not dissected) Additional User/Service Information");
7319 break;
7320 }
7321 offset += 1;
7322 }
7323 }
7324
7325
7326 static const value_string jpn_isup_reason_for_clip_fail_vals[] = {
7327 { 0, "Spare" },
7328 { 1, "User's request" },
7329 { 2, "Interaction with other service" },
7330 { 3, "Public telephone origination" },
7331 { 4, "Spare" },
7332 { 0, NULL}
7333 };
7334 static void
7335 dissect_japan_isup_reason_for_clip_fail(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7336 {
7337 int offset = 0;
7338
7339
7340 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7341 proto_tree_add_item(parameter_tree, hf_japan_isup_reason_for_clip_fail, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7342 }
7343
7344 static void
7345 dissect_japan_isup_contractor_number(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
7346 {
7347 int offset = 0;
7348 int parameter_length;
7349 char *digit_str;
7350
7351 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7352
7353 proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7354 proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7355 offset += 1;
7356
7357 proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7358 offset += 1;
7359
7360 proto_tree_add_item_ret_display_string(parameter_tree, hf_japan_isup_contractor_number, parameter_tvb, offset, parameter_length-2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN, pinfo->pool, &digit_str);
7361
7362 proto_item_append_text(parameter_item, " %s", digit_str);
7363
7364 }
7365 /* ------------------------------------------------------------------
7366 Dissector Parameter Optional .Carrier Information
7367
7368
7369 8 7 6 5 4 3 2 1
7370 +-----------------------------------------------+
7371 | spare | IEC | 1
7372 | | indicator |
7373 +-----------------------------------------------+
7374 | Category of carrier 1 | 2
7375 | |
7376 +-----------------------------------------------+
7377 | Length of carrier 1 information | 3
7378 | |
7379 +-----------------------------------------------+
7380 | Carrier 1 information / octet 1 | 4
7381 | |
7382 +-----------------------------------------------+
7383 . . .
7384 . . .
7385 . . .
7386 +-----------------------------------------------+
7387 | Carrier 1 information / octet n | 3+n
7388 | |
7389 +-----------------------------------------------+
7390 . .
7391 */
7392 static void
7393 dissect_japan_isup_carrier_information(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
7394 {
7395 proto_item *catagory_of_carrier;
7396 proto_tree *carrier_info_tree;
7397
7398 proto_item *digits_item;
7399 proto_tree *digits_tree;
7400
7401 proto_item *type_of_carrier;
7402 proto_tree *type_of_carrier_tree;
7403
7404 uint8_t octet;
7405 uint8_t odd_even;
7406 uint8_t type_of_carrier_info;
7407 uint8_t carrier_info_length;
7408 uint8_t carrierX_end_index;
7409
7410 int offset = 0;
7411 int length = 0;
7412
7413 int num_octets_with_digits = 0;
7414
7415 int digit_index;
7416 wmem_strbuf_t *cid_number;
7417 wmem_strbuf_t *ca_number;
7418
7419 /*Octet 1 : IEC Indicator*/
7420 octet = tvb_get_uint8(parameter_tvb, 0);
7421 proto_tree_add_uint(parameter_tree, hf_isup_carrier_info_iec, parameter_tvb, 0, 1, octet);
7422
7423
7424 length = tvb_reported_length_remaining(parameter_tvb, 2);
7425 if (length == 0) {
7426 expert_add_info(pinfo, parameter_item, &ei_isup_empty_number);
7427 proto_item_append_text(parameter_item, ": (empty)");
7428 return;
7429 }
7430
7431 offset = 1;
7432
7433 /* Lets loop through the Carrier Information*/
7434
7435 while (length > 0) {
7436
7437 carrier_info_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7438 ett_isup_carrier_info, &catagory_of_carrier, "Category of Carrier:");
7439
7440 /*Octet 2 : Category of Carrier*/
7441 octet = tvb_get_uint8(parameter_tvb, offset);
7442 /*proto_tree_add_uint(carrier_info_tree, hf_isup_carrier_info_cat_of_carrier, parameter_tvb, 0, 1, octet);*/
7443 proto_item_append_text(catagory_of_carrier, ": %s (%u)", val_to_str_ext_const(octet, &isup_carrier_info_category_vals_ext, "spare"), octet );
7444
7445
7446 /*Octet 3 : Length of Category Information No.x*/
7447 offset += 1;
7448 carrierX_end_index = tvb_get_uint8(parameter_tvb, offset)+offset;
7449
7450 while (offset < carrierX_end_index) {
7451
7452 type_of_carrier_tree = proto_tree_add_subtree(carrier_info_tree, parameter_tvb, offset, -1,
7453 ett_isup_carrier_info, &type_of_carrier, "Type of Carrier:");
7454
7455 /* Type of Carrier Information*/
7456 offset += 1;
7457 type_of_carrier_info = tvb_get_uint8(parameter_tvb, offset);
7458 /*proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_type_of_carrier_info, parameter_tvb, 0, 1, type_of_carrier_info);*/
7459 proto_item_append_text(type_of_carrier, ": %s (%u)", val_to_str_ext_const(type_of_carrier_info, &isup_carrier_info_type_of_carrier_vals_ext, "spare"), type_of_carrier_info );
7460
7461
7462 /* Carrier Information Length */
7463 offset += 1;
7464 carrier_info_length = tvb_get_uint8(parameter_tvb, offset);
7465
7466 /* POI Hierarchy information
7467
7468 8 7 6 5 4 3 2 1
7469 +-----------------------|-----------------------+
7470 | Entry POI Hierarchy | Exit POI Hierarchy | 1
7471 | | |
7472 \-----------------------------------------------|
7473
7474 */
7475
7476 if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_POIHIE) {
7477 /* POI Hierarchy information */
7478 offset += 1;
7479 octet = tvb_get_uint8(parameter_tvb, offset);
7480 proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_poi_entry_HEI, parameter_tvb, 0, 1, octet);
7481 proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_poi_exit_HEI, parameter_tvb, 0, 1, octet);
7482 }
7483
7484 /* POI|CA information (Charge Area)
7485
7486 8 7 6 5 4 3 2 1
7487 +-----|-----------------------------------------+
7488 |Odd/ | Spare | 1
7489 |even | |
7490 +-----------------------------------------------+
7491 | 2nd CA code digit | 1st CA code digit | 2
7492 | | |
7493 +-----------------------+-----------------------+
7494 . . .
7495 . . .
7496 . . .
7497 +-----------------------+-----------------------+
7498 | Filler | 5|th CA code digit | m
7499 | | |
7500 \-----------------------------------------------|
7501 */
7502 if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_POICA) {
7503
7504 digits_tree = proto_tree_add_subtree(type_of_carrier_tree, parameter_tvb, offset, -1,
7505 ett_isup_address_digits, &digits_item, "Charge Area");
7506
7507 /* Odd.Even Indicator*/
7508 offset += 1;
7509 odd_even = tvb_get_uint8(parameter_tvb, offset);
7510 proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);
7511
7512 /* Number of Octets containing digits*/
7513 num_octets_with_digits = carrier_info_length - 1;
7514
7515 /* Lets now load up the digits.*/
7516 /* If the odd indicator is set... drop the Filler from the last octet.*/
7517 /* This loop also loads up ca_number with the digits for display*/
7518 ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7519 digit_index = 0;
7520 while (num_octets_with_digits > 0) {
7521 offset += 1;
7522 if (++digit_index > MAXDIGITS) {
7523 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7524 break;
7525 }
7526 octet = tvb_get_uint8(parameter_tvb, offset);
7527 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
7528 wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7529 if (num_octets_with_digits == 1) {
7530 if (odd_even == 0) {
7531 if (++digit_index > MAXDIGITS) {
7532 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7533 break;
7534 }
7535 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7536 wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7537 }
7538 }
7539 else {
7540 if (++digit_index > MAXDIGITS) {
7541 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7542 break;
7543 }
7544 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7545 wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7546 }
7547
7548 num_octets_with_digits--;
7549 }
7550
7551 proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
7552
7553 }
7554
7555 /* Carrier Identification Code
7556 8 7 6 5 4 3 2 1
7557 +-----|-----------------------------------------+
7558 |Odd/ | Spare | 1
7559 |even | |
7560 +-----------------------------------------------+
7561 | 2nd ID code digit | 1st ID code digit | 2
7562 | | |
7563 +-----------------------+-----------------------+
7564 . . .
7565 . . .
7566 . . .
7567 +-----------------------+-----------------------+
7568 | Filler (if necessary) | n|th ID code digit | m
7569 | | |
7570 \-----------------------------------------------|
7571 */
7572
7573 if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_CARID) {
7574 digits_tree = proto_tree_add_subtree(type_of_carrier_tree, parameter_tvb, offset, -1,
7575 ett_isup_address_digits, &digits_item, "Carrier ID Code");
7576
7577 offset += 1;
7578 /* Odd.Even Indicator*/
7579 odd_even = tvb_get_uint8(parameter_tvb, offset);
7580 proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);
7581
7582 /* Number of Octets containing digits*/
7583 num_octets_with_digits = carrier_info_length - 1;
7584
7585 /* Lets now load up the digits.*/
7586 /* If the odd indicator is set... drop the Filler from the last octet.*/
7587 /* This loop also loads up cid_number with the digits for display*/
7588 cid_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7589 digit_index = 0;
7590 while (num_octets_with_digits > 0) {
7591 offset += 1;
7592 if (++digit_index > MAXDIGITS) {
7593 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7594 break;
7595 }
7596 octet = tvb_get_uint8(parameter_tvb, offset);
7597 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_odd_no_digits, parameter_tvb, 0, 1, octet);
7598 wmem_strbuf_append_c(cid_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7599 if (num_octets_with_digits == 1) {
7600 if (odd_even == 0) {
7601 if (++digit_index > MAXDIGITS) {
7602 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7603 break;
7604 }
7605 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_even_no_digits, parameter_tvb, 0, 1, octet);
7606 wmem_strbuf_append_c(cid_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7607 }
7608 }
7609 else {
7610 if (++digit_index > MAXDIGITS) {
7611 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7612 break;
7613 }
7614 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_even_no_digits, parameter_tvb, 0, 1, octet);
7615 wmem_strbuf_append_c(cid_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7616 }
7617 num_octets_with_digits--;
7618 }
7619 proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(cid_number));
7620 }
7621 }
7622
7623 offset += 1;
7624 length = tvb_reported_length_remaining(parameter_tvb, offset);
7625 }
7626 }
7627
7628
7629 static const range_string japan_isup_charge_delay_type_value[] = {
7630 { 0, 0, "Spare" },
7631 { 1, 0x80, "Reserved for network specific use" },
7632 { 0x81, 0xfa, "Spare" },
7633 { 0xfb, 0xfc, "Reserved" },
7634 { 0xfd, 0xfd, "Charge rate transfer" },
7635 { 0xfe, 0xfe, "Terminating charge area information" },
7636 { 0xff, 0xff, "Spare" },
7637 { 0, 0, NULL } };
7638
7639 static void
7640 dissect_japan_isup_charge_inf_delay(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7641 {
7642
7643 int offset = 0;
7644 int parameter_length;
7645
7646 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7647
7648 while (offset < parameter_length) {
7649 proto_tree_add_item(parameter_tree, hf_japan_isup_charge_delay_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7650 offset += 1;
7651 }
7652 }
7653
7654 /* ----------------------------------------------------
7655 Dissector Parameter Optional .Additional User Information
7656
7657 8 7 6 5 4 3 2 1
7658 +-----------------------------------------------+
7659 | Type of additional user/service | 1
7660 | information (1) |
7661 +-----------------------------------------------+
7662 | Additional user/service information (1) | 2
7663 | |
7664 +-----------------------------------------------+
7665 . .
7666 . .
7667 . .
7668 +-----------------------------------------------+
7669 | Type of additional user/service | 2n|1
7670 | information (n) |
7671 +-----------------------------------------------+
7672 | Additional user/service information (n) | 2n
7673 | |
7674 \------------------------------------------------
7675 */
7676
7677
7678
7679 /* ----------------------------------------------------
7680 Dissector Parameter Optional .Charge Area Information
7681
7682 8 7 6 5 4 3 2 1
7683 +-----+-----------------------------------------+
7684 |Odd/ | Nature of information indicator | 1
7685 |even | |
7686 +-----------------------------------------------+
7687 | 2nd NC digit | 1st NC digit | 2 ||
7688 | | | | see
7689 +-----------------------+-----------------------+ | Note
7690 | 4th NC digit | 3rd NC digit | 3 ||
7691 | | |
7692 +-----------------------+-----------------------+
7693 | 2nd MA/CA code digit | 1st MA/CA code digit | 4
7694 | | |
7695 +-----------------------+-----------------------+
7696 . . .
7697 . . .
7698 . . .
7699 +-----------------------+-----------------------+
7700 | Filler (if necessary) | nth MA/CA code digit | m
7701 | | |
7702 \-----------------------------------------------|
7703 */
7704 static void
7705 dissect_japan_isup_charge_area_info(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7706 {
7707 proto_item *digits_item;
7708 proto_tree *digits_tree;
7709
7710 uint8_t octet;
7711
7712 int nat_of_info_indic;
7713 int length;
7714 int offset;
7715 int odd_even;
7716 int digit_index = 0;
7717
7718 wmem_strbuf_t *ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7719
7720 /*Octet 1 : Indicator*/
7721 octet = tvb_get_uint8(parameter_tvb, 0);
7722 nat_of_info_indic = octet & 0x7F;
7723 odd_even = octet & 0x80;
7724 proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, octet);
7725 proto_tree_add_uint(parameter_tree, hf_japan_isup_charge_area_nat_of_info_value, parameter_tvb, 0, 1, octet);
7726
7727 offset = 1;
7728 length = tvb_reported_length_remaining(parameter_tvb, offset);
7729
7730 /*Only CA code digits.*/
7731 if (nat_of_info_indic == CHARGE_AREA_NAT_INFO_CA) {
7732 digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7733 ett_isup_address_digits, &digits_item, "Charge Area");
7734
7735 while (length > 0) {
7736 if (++digit_index > MAXDIGITS) {
7737 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7738 break;
7739 }
7740 octet = tvb_get_uint8(parameter_tvb, offset);
7741 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
7742 wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7743 if (length == 1) {
7744 if (odd_even == 0) {
7745 if (++digit_index > MAXDIGITS) {
7746 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7747 break;
7748 }
7749 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7750 wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7751 }
7752 }
7753 else {
7754 if (++digit_index > MAXDIGITS) {
7755 expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7756 break;
7757 }
7758 proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7759 wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7760 }
7761 offset += 1;
7762 length -= 1;
7763 }
7764 proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
7765 }
7766 /*Only MA code digits.*/
7767 if (nat_of_info_indic == CHARGE_AREA_NAT_INFO_MA) {
7768 digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7769 ett_isup_address_digits, &digits_item, "Message Area:");
7770
7771 /* First two octets contains*/
7772 /* four NC digits*/
7773 octet = tvb_get_uint8(parameter_tvb, offset);
7774 proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_odd_digits, parameter_tvb, 0, 1, octet);
7775 proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_even_digits, parameter_tvb, 0, 1, octet);
7776 offset++;
7777 octet = tvb_get_uint8(parameter_tvb, offset);
7778 proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_odd_digits, parameter_tvb, 0, 1, octet);
7779 proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_even_digits, parameter_tvb, 0, 1, octet);
7780 offset++;
7781
7782 /* Now loop through MA/CA digits.*/
7783 length = tvb_reported_length_remaining(parameter_tvb, offset);
7784
7785 while (length > 0) {
7786 octet = tvb_get_uint8(parameter_tvb, offset);
7787 proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_odd_digits, parameter_tvb, 0, 1, octet);
7788 if (length == 1) {
7789 if (odd_even == 0) {
7790 proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_even_digits, parameter_tvb, 0, 1, octet);
7791 }
7792 }
7793 else {
7794 proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_even_digits, parameter_tvb, 0, 1, octet);
7795 }
7796 offset += 1;
7797 length -= 1;
7798 }
7799
7800 }
7801 }
7802
7803 static const value_string japan_isup_chg_info_type_value[] = {
7804 { 0, "Spare" },
7805 { 1, "Reserved" },
7806 { 2, "Reserved" },
7807 { 3, "Advanced Charge Rate Transfer(TDS Service)" },
7808 { 0xfe, "Charge rate transfer (flexible charging)" },
7809 { 0xff, "Spare" },
7810 { 0, NULL}
7811 };
7812
7813 static uint16_t
7814 dissect_japan_chg_inf_type(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7815 {
7816 uint16_t chg_inf_type;
7817
7818 chg_inf_type = tvb_get_uint8(parameter_tvb, 0);
7819 proto_tree_add_item(parameter_tree, hf_japan_isup_charge_info_type, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
7820
7821 return chg_inf_type;
7822 }
7823
7824 static const value_string japan_isup_sig_elem_type_values[] = {
7825 { 2, "Activate" },
7826 { 0, NULL}
7827 };
7828
7829 static const value_string japan_isup_op_cls_values[] = {
7830 { 0, "Class 1" },
7831 { 1, "Class 2" },
7832 { 2, "Class 3" },
7833 { 3, "Class 4" },
7834 { 0, NULL}
7835 };
7836
7837 static const value_string japan_isup_op_type_values[] = {
7838 { 6, "Immediate charging" },
7839 { 0, NULL}
7840 };
7841
7842 static const value_string japan_isup_charging_party_type_values[] = {
7843 { 0, "Originator charge" },
7844 { 0, NULL}
7845 };
7846
7847 static const value_string japan_isup_collecting_method_values[] = {
7848 { 0, "Subscriber will be claimed" },
7849 { 0, NULL}
7850 };
7851
7852 static const value_string japan_isup_tariff_rate_pres_values[] = {
7853 { 2, "No charge rate information" },
7854 { 0, NULL}
7855 };
7856
7857 static void
7858 dissect_japan_chg_inf_type_acr(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7859 {
7860 int offset = 0;
7861 uint8_t ext_ind;
7862
7863 /* length : 2-5 octets */
7864 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7865 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7866 proto_tree_add_item(parameter_tree, hf_japan_isup_sig_elem_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7867 offset += 1;
7868 if (!ext_ind) {
7869 /* Activation ID */
7870 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7871 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7872 proto_tree_add_item(parameter_tree, hf_japan_isup_activation_id, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7873 offset += 1;
7874 if (!ext_ind) {
7875 /* Operation type and class */
7876 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7877 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7878 proto_tree_add_item(parameter_tree, hf_japan_isup_op_cls, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7879 proto_tree_add_item(parameter_tree, hf_japan_isup_op_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7880 offset += 1;
7881 if (!ext_ind) {
7882 /* Tariff collecting method and charging party type */
7883 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7884 proto_tree_add_item(parameter_tree, hf_japan_isup_charging_party_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7885 proto_tree_add_item(parameter_tree, hf_japan_isup_collecting_method, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7886 offset += 1;
7887 }
7888 }
7889 }
7890 /* Tariff rate presentation */
7891 proto_tree_add_item(parameter_tree, hf_japan_isup_tariff_rate_pres, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7892
7893 }
7894
7895
7896 static const value_string japan_isup_utp_values[] = {
7897 { 0, "Spare" },
7898 { 0xfc, "100 yen" },
7899 { 0xfd, "10 yen" },
7900 { 0xfe, "No indication" },
7901 { 0xff, "Spare" },
7902 { 0, NULL}
7903 };
7904
7905 static const value_string japan_isup_crci1_values[] = {
7906 { 0, "Spare" },
7907 { 0x7c, "Public (Payphone)" },
7908 { 0x7d, "Ordinary" },
7909 { 0x7e, "No flexible charge rate information" },
7910 { 0x7f, "Spare" },
7911 { 0, NULL}
7912 };
7913
7914 static void
7915 dissect_japan_chg_inf_type_crt(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7916 {
7917 int offset = 0;
7918 uint8_t ext_ind;
7919 uint8_t len;
7920 int parameter_length;
7921
7922 parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7923
7924
7925 /* Unit per Time Period (UTP) */
7926 proto_tree_add_item(parameter_tree, hf_japan_isup_utp, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7927 offset += 1;
7928
7929 /* Charge rate information category 1 (CRIC 1) */
7930 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7931 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7932 proto_tree_add_item(parameter_tree, hf_japan_isup_crci1, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7933 offset += 1;
7934 if (!ext_ind) {
7935 len = tvb_get_uint8(parameter_tvb, offset);
7936 proto_tree_add_item(parameter_tree, hf_japan_isup_crci1_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7937 offset += 1;
7938 /* Initial units (IU) IA5 coded in two octets */
7939 proto_tree_add_item(parameter_tree, hf_japan_isup_iu, parameter_tvb, offset, 2, ENC_NA|ENC_ASCII);
7940 offset += 2;
7941 /* Daytime Charge rate (DCR) (Octets A, B, C) IA5 coded in three octets */
7942 proto_tree_add_item(parameter_tree, hf_japan_isup_dcr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7943 offset+=3;
7944 if (len > 5) {
7945 /* Evening Charge rate (ECR) (Octets B, E, F) IA5 coded in three octets */
7946 proto_tree_add_item(parameter_tree, hf_japan_isup_ecr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7947 offset += 3;
7948 }
7949 if (len > 8) {
7950 /* Nighttime Charge rate (NCR) (Octet G,H,I) IA5 coded in three octets */
7951 proto_tree_add_item(parameter_tree, hf_japan_isup_ncr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7952 offset += 3;
7953 }
7954 if (len > 11) {
7955 /* Spare charge rate (SCR) (Octets J,K,L) IA5 coded in three octets */
7956 proto_tree_add_item(parameter_tree, hf_japan_isup_scr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7957 offset += 3;
7958 }
7959 }
7960 if (parameter_length > offset) {
7961 /* Charge rate information category 2 (CRIC 2) */
7962 ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7963 proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7964 proto_tree_add_item(parameter_tree, hf_japan_isup_crci2, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7965 offset += 1;
7966 if (!ext_ind) {
7967 len = tvb_get_uint8(parameter_tvb, offset);
7968 proto_tree_add_item(parameter_tree, hf_japan_isup_crci1_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7969 offset += 1;
7970 /* Initial units (IU) IA5 coded in two octets */
7971 proto_tree_add_item(parameter_tree, hf_japan_isup_iu, parameter_tvb, offset, 2, ENC_NA|ENC_ASCII);
7972 offset += 2;
7973 /* Daytime Charge rate (DCR) (Octets A, B, C) IA5 coded in three octets */
7974 proto_tree_add_item(parameter_tree, hf_japan_isup_dcr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7975 offset += 3;
7976 if (len > 5) {
7977 /* Evening Charge rate (ECR) (Octets B, E, F) IA5 coded in three octets */
7978 proto_tree_add_item(parameter_tree, hf_japan_isup_ecr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7979 offset += 3;
7980 }
7981 if (len > 8) {
7982 /* Nighttime Charge rate (NCR) (Octet G,H,I) IA5 coded in three octets */
7983 proto_tree_add_item(parameter_tree, hf_japan_isup_ncr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7984 offset += 3;
7985 }
7986 if (len > 11) {
7987 /* Spare charge rate (SCR) (Octets J,K,L) IA5 coded in three octets */
7988 proto_tree_add_item(parameter_tree, hf_japan_isup_scr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
7989 /*offset += 3;*/
7990 }
7991 }
7992 }
7993 }
7994
7995
7996 static void
7997 dissect_japan_chg_inf_param(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item, uint16_t chg_inf_type)
7998 {
7999
8000 switch (chg_inf_type) {
8001 case 3:
8002 /* Advanced Charge Rate Transfer (TDS service) */
8003 dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
8004 break;
8005 case 254:
8006 /* Charge rate transfer (flexible charging) */
8007 dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
8008 break;
8009 default:
8010 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 0, -1, "Charge information data, not dissected yet");
8011 break;
8012 }
8013 }
8014
8015 /* END Japan ISUP */
8016
8017 /* ------------------------------------------------------------------
8018 Dissector all optional parameters
8019 */
8020 static void
8021 dissect_isup_optional_parameter(tvbuff_t *optional_parameters_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
8022 {
8023 proto_item *parameter_item;
8024 proto_tree *parameter_tree;
8025 int offset = 0;
8026 unsigned parameter_type, parameter_length, actual_length;
8027 tvbuff_t *parameter_tvb;
8028 uint8_t octet;
8029 uint16_t chg_inf_type = 0xffff;
8030
8031 /* Dissect all optional parameters while end of message isn't reached */
8032 parameter_type = 0xFF; /* Start-initialization since parameter_type is used for while-condition */
8033
8034 while ((tvb_reported_length_remaining(optional_parameters_tvb, offset) >= 1) && (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS)) {
8035 parameter_type = tvb_get_uint8(optional_parameters_tvb, offset);
8036
8037 if (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS) {
8038 parameter_length = tvb_get_uint8(optional_parameters_tvb, offset + PARAMETER_TYPE_LENGTH);
8039 if (parameter_length + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH > (unsigned)(tvb_reported_length_remaining(optional_parameters_tvb, offset))) {
8040 proto_tree_add_expert_format(isup_tree, pinfo, &ei_isup_opt_par_length_err, optional_parameters_tvb, offset, -1,
8041 "Wrong parameter length %u, should be %u",
8042 parameter_length,
8043 tvb_reported_length_remaining(optional_parameters_tvb, offset)- (PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH));
8044 return;
8045 }
8046
8047 parameter_tree = proto_tree_add_subtree_format(isup_tree, optional_parameters_tvb,
8048 offset,
8049 parameter_length + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH,
8050 ett_isup_parameter, &parameter_item,
8051 "Parameter: (t=%u, l=%u)",
8052 parameter_type, parameter_length);
8053 /* Handle national extensions here */
8054 switch (itu_isup_variant) {
8055 case ISUP_JAPAN_VARIANT:
8056 /* Fall through */
8057 case ISUP_JAPAN_TTC_VARIANT:
8058 proto_tree_add_uint_format_value(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset, PARAMETER_TYPE_LENGTH,
8059 parameter_type,
8060 "%u (%s)",
8061 parameter_type,
8062 val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
8063 proto_item_append_text(parameter_tree, ": %s", val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "Unknown"));
8064 break;
8065 default:
8066 proto_tree_add_uint(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset, PARAMETER_TYPE_LENGTH, parameter_type);
8067 proto_item_append_text(parameter_tree, ": %s", val_to_str_ext_const(parameter_type, &ansi_isup_parameter_type_value_ext, "Unknown"));
8068 break;
8069
8070 }
8071 offset += PARAMETER_TYPE_LENGTH;
8072
8073 octet = tvb_get_uint8(optional_parameters_tvb, offset);
8074
8075 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, optional_parameters_tvb, offset,
8076 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8077 offset += PARAMETER_LENGTH_IND_LENGTH;
8078 if (octet == 0)
8079 continue;
8080
8081 actual_length = tvb_reported_length_remaining(optional_parameters_tvb, offset);
8082 if (actual_length > 0) {
8083 parameter_tvb = tvb_new_subset_length_caplen(optional_parameters_tvb, offset, MIN(parameter_length, actual_length), parameter_length);
8084 switch (parameter_type) {
8085 case PARAM_TYPE_CALL_REF:
8086 dissect_isup_call_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8087 break;
8088 case PARAM_TYPE_TRANSM_MEDIUM_REQU:
8089 dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
8090 break;
8091 case PARAM_TYPE_ACC_TRANSP:
8092 dissect_isup_access_transport_parameter(parameter_tvb, parameter_tree, parameter_item, pinfo);
8093 break;
8094 case PARAM_TYPE_CALLED_PARTY_NR:
8095 dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8096 break;
8097 case PARAM_TYPE_SUBSQT_NR:
8098 dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8099 break;
8100 case PARAM_TYPE_NATURE_OF_CONN_IND:
8101 dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8102 break;
8103 case PARAM_TYPE_FORW_CALL_IND:
8104 dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
8105 break;
8106 case PARAM_TYPE_OPT_FORW_CALL_IND:
8107 dissect_isup_optional_forward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8108 break;
8109 case PARAM_TYPE_CALLING_PRTY_CATEG:
8110 dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8111 break;
8112 case PARAM_TYPE_CALLING_PARTY_NR:
8113 dissect_isup_calling_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8114 break;
8115 case PARAM_TYPE_REDIRECTING_NR:
8116 dissect_isup_redirecting_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8117 break;
8118 case PARAM_TYPE_REDIRECTION_NR:
8119 dissect_isup_redirection_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8120 break;
8121 case PARAM_TYPE_CONNECTION_REQ:
8122 dissect_isup_connection_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8123 break;
8124 case PARAM_TYPE_INFO_REQ_IND:
8125 dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8126 break;
8127 case PARAM_TYPE_INFO_IND:
8128 dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8129 break;
8130 case PARAM_TYPE_CONTINUITY_IND:
8131 dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8132 break;
8133 case PARAM_TYPE_BACKW_CALL_IND:
8134 dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8135 break;
8136 case PARAM_TYPE_CAUSE_INDICATORS:
8137 dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8138 break;
8139 case PARAM_TYPE_REDIRECTION_INFO:
8140 dissect_isup_redirection_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8141 break;
8142 case PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE:
8143 dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
8144 break;
8145 case PARAM_TYPE_RANGE_AND_STATUS:
8146 dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8147 break;
8148 case PARAM_TYPE_FACILITY_IND:
8149 dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
8150 break;
8151 case PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD:
8152 dissect_isup_closed_user_group_interlock_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8153 break;
8154 case PARAM_TYPE_USER_SERVICE_INFO:
8155 dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8156 break;
8157 case PARAM_TYPE_SIGNALLING_POINT_CODE:
8158 dissect_isup_signalling_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8159 break;
8160 case PARAM_TYPE_USER_TO_USER_INFO:
8161 dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8162 break;
8163 case PARAM_TYPE_CONNECTED_NR:
8164 dissect_isup_connected_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8165 break;
8166 case PARAM_TYPE_SUSP_RESUME_IND:
8167 dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8168 break;
8169 case PARAM_TYPE_TRANSIT_NETW_SELECT:
8170 dissect_isup_transit_network_selection_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8171 break;
8172 case PARAM_TYPE_EVENT_INFO:
8173 dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8174 break;
8175 case PARAM_TYPE_CIRC_ASSIGN_MAP:
8176 dissect_isup_circuit_assignment_map_parameter(parameter_tvb, parameter_tree, parameter_item);
8177 break;
8178 case PARAM_TYPE_CIRC_STATE_IND:
8179 dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8180 break;
8181 case PARAM_TYPE_AUTO_CONG_LEVEL:
8182 dissect_isup_automatic_congestion_level_parameter(parameter_tvb, parameter_tree, parameter_item);
8183 break;
8184 case PARAM_TYPE_ORIG_CALLED_NR:
8185 dissect_isup_original_called_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8186 break;
8187 case PARAM_TYPE_OPT_BACKW_CALL_IND:
8188 dissect_isup_optional_backward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8189 break;
8190 case PARAM_TYPE_USER_TO_USER_IND:
8191 dissect_isup_user_to_user_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8192 break;
8193 case PARAM_TYPE_ORIG_ISC_POINT_CODE:
8194 dissect_isup_original_isc_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8195 break;
8196 case PARAM_TYPE_GENERIC_NOTIF_IND:
8197 dissect_isup_generic_notification_indicator_parameter(parameter_tvb, parameter_tree, parameter_item);
8198 break;
8199 case PARAM_TYPE_CALL_HIST_INFO :
8200 dissect_isup_call_history_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8201 break;
8202 case PARAM_TYPE_ACC_DELIV_INFO:
8203 dissect_isup_access_delivery_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8204 break;
8205 case PARAM_TYPE_NETW_SPECIFIC_FACLTY:
8206 dissect_isup_network_specific_facility_parameter(parameter_tvb, parameter_tree, parameter_item);
8207 break;
8208 case PARAM_TYPE_USER_SERVICE_INFO_PR:
8209 dissect_isup_user_service_information_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8210 break;
8211 case PARAM_TYPE_PROPAG_DELAY_COUNTER:
8212 dissect_isup_propagation_delay_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8213 break;
8214 case PARAM_TYPE_REMOTE_OPERATIONS:
8215 dissect_isup_remote_operations_parameter(parameter_tvb, parameter_tree, parameter_item);
8216 break;
8217 case PARAM_TYPE_SERVICE_ACTIVATION:
8218 dissect_isup_service_activation_parameter(parameter_tvb, parameter_tree, parameter_item);
8219 break;
8220 case PARAM_TYPE_USER_TELESERV_INFO:
8221 dissect_isup_user_teleservice_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8222 break;
8223 case PARAM_TYPE_TRANSM_MEDIUM_USED:
8224 dissect_isup_transmission_medium_used_parameter(parameter_tvb, parameter_tree, parameter_item);
8225 break;
8226 case PARAM_TYPE_CALL_DIV_INFO:
8227 dissect_isup_call_diversion_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8228 break;
8229 case PARAM_TYPE_ECHO_CTRL_INFO:
8230 dissect_isup_echo_control_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8231 break;
8232 case PARAM_TYPE_MSG_COMPAT_INFO:
8233 dissect_isup_message_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8234 break;
8235 case PARAM_TYPE_PARAM_COMPAT_INFO:
8236 dissect_isup_parameter_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8237 break;
8238 case PARAM_TYPE_MLPP_PRECEDENCE:
8239 dissect_isup_mlpp_precedence_parameter(parameter_tvb, parameter_tree, parameter_item);
8240 break;
8241 case PARAM_TYPE_MCID_REQ_IND:
8242 dissect_isup_mcid_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8243 break;
8244 case PARAM_TYPE_MCID_RSP_IND:
8245 dissect_isup_mcid_response_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8246 break;
8247 case PARAM_TYPE_HOP_COUNTER:
8248 dissect_isup_hop_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8249 break;
8250 case PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR:
8251 dissect_isup_transmission_medium_requirement_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8252 break;
8253 case PARAM_TYPE_LOCATION_NR:
8254 dissect_isup_location_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8255 break;
8256 case PARAM_TYPE_REDIR_NR_RSTRCT:
8257 dissect_isup_redirection_number_restriction_parameter(parameter_tvb, parameter_tree, parameter_item);
8258 break;
8259 case PARAM_TYPE_CALL_TRANS_REF:
8260 dissect_isup_call_transfer_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8261 break;
8262 case PARAM_TYPE_LOOP_PREV_IND:
8263 dissect_isup_loop_prevention_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8264 break;
8265 case PARAM_TYPE_CALL_TRANS_NR:
8266 dissect_isup_call_transfer_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8267 break;
8268 case PARAM_TYPE_CCSS:
8269 dissect_isup_ccss_parameter(parameter_tvb, parameter_tree, parameter_item);
8270 break;
8271 case PARAM_TYPE_FORW_GVNS:
8272 dissect_isup_forward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8273 break;
8274 case PARAM_TYPE_BACKW_GVNS:
8275 dissect_isup_backward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8276 break;
8277 case PARAM_TYPE_REDIRECT_CAPAB:
8278 dissect_isup_redirect_capability_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8279 break;
8280 case PARAM_TYPE_NETW_MGMT_CTRL:
8281 dissect_isup_network_management_controls_parameter(parameter_tvb, parameter_tree, parameter_item);
8282 break;
8283 case PARAM_TYPE_CORRELATION_ID:
8284 dissect_isup_correlation_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8285 break;
8286 case PARAM_TYPE_SCF_ID:
8287 dissect_isup_scf_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8288 break;
8289 case PARAM_TYPE_CALL_DIV_TREAT_IND:
8290 dissect_isup_call_diversion_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8291 break;
8292 case PARAM_TYPE_CALLED_IN_NR:
8293 dissect_isup_called_in_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8294 break;
8295 case PARAM_TYPE_CALL_OFF_TREAT_IND:
8296 dissect_isup_call_offering_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8297 break;
8298 case PARAM_TYPE_CHARGED_PARTY_IDENT:
8299 dissect_isup_charged_party_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
8300 break;
8301 case PARAM_TYPE_CONF_TREAT_IND:
8302 dissect_isup_conference_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8303 break;
8304 case PARAM_TYPE_DISPLAY_INFO:
8305 dissect_isup_display_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8306 break;
8307 case PARAM_TYPE_UID_ACTION_IND:
8308 dissect_isup_uid_action_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8309 break;
8310 case PARAM_TYPE_UID_CAPAB_IND:
8311 dissect_isup_uid_capability_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8312 break;
8313 case PARAM_TYPE_REDIRECT_COUNTER:
8314 dissect_isup_redirect_counter_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8315 break;
8316 case PARAM_TYPE_COLLECT_CALL_REQ:
8317 dissect_isup_collect_call_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8318 break;
8319 case PARAM_TYPE_GENERIC_NR:
8320 dissect_isup_generic_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8321 break;
8322 case PARAM_TYPE_GENERIC_DIGITS:
8323 dissect_isup_generic_digits_parameter(parameter_tvb, parameter_tree, parameter_item);
8324 break;
8325 case PARAM_TYPE_APPLICATON_TRANS:
8326 dissect_isup_application_transport_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8327 break;
8328
8329 default:
8330 switch (itu_isup_variant) {
8331 case ISUP_JAPAN_VARIANT:
8332 /* Fall through */
8333 case ISUP_JAPAN_TTC_VARIANT:
8334 switch (parameter_type) {
8335 case JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER:
8336 dissect_japan_isup_called_dir_num(parameter_tvb, pinfo, parameter_tree, parameter_item);
8337 break;
8338 case JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF: /* 0x8B */
8339 dissect_japan_isup_redirect_fwd_inf(parameter_tvb, pinfo, parameter_tree, parameter_item);
8340 break;
8341 case JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF: /* 0x8C */
8342 dissect_japan_isup_redirect_backw_inf(parameter_tvb, pinfo, parameter_tree, parameter_item);
8343 break;
8344 case JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND: /* D7 */
8345 dissect_japan_isup_emergency_call_ind(parameter_tvb, parameter_tree, parameter_item);
8346 break;
8347 case JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND: /* EC */
8348 dissect_japan_isup_emergency_call_inf_ind(parameter_tvb, parameter_tree, parameter_item);
8349 break;
8350 case JAPAN_ISUP_PARAM_NETWORK_POI_CA: /* EE */
8351 dissect_japan_isup_network_poi_cad(parameter_tvb, pinfo, parameter_tree, parameter_item);
8352 break;
8353 case JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO: /* 241 F1 */
8354 dissect_japan_isup_carrier_information(parameter_tvb, pinfo, parameter_tree, parameter_item);
8355 break;
8356 case JAPAN_ISUP_PARAM_CHARGE_INF_DELAY: /* 242 F2 */
8357 dissect_japan_isup_charge_inf_delay(parameter_tvb, parameter_tree, parameter_item);
8358 break;
8359 case JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT: /* F3 */
8360 dissect_japan_isup_additonal_user_cat(parameter_tvb, pinfo, parameter_tree, parameter_item);
8361 break;
8362 case JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL: /* F5 */
8363 dissect_japan_isup_reason_for_clip_fail(parameter_tvb, parameter_tree, parameter_item);
8364 break;
8365 case JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER: /* F9 */
8366 dissect_japan_isup_contractor_number(parameter_tvb, pinfo, parameter_tree, parameter_item);
8367 break;
8368 case JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE: /* FA */
8369 chg_inf_type = dissect_japan_chg_inf_type(parameter_tvb, parameter_tree, parameter_item);
8370 break;
8371 case JAPAN_ISUP_PARAM_TYPE_CHARGE_INF:
8372 dissect_japan_chg_inf_param(parameter_tvb, pinfo, parameter_tree, parameter_item, chg_inf_type);
8373 break;
8374 case JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO:
8375 dissect_japan_isup_charge_area_info(parameter_tvb, pinfo, parameter_tree, parameter_item);
8376 break;
8377 default:
8378 dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
8379 break;
8380 }
8381 break;
8382 default:
8383 dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
8384 break;
8385 }
8386 break;
8387 }
8388
8389 offset += MIN(parameter_length, actual_length);
8390 }
8391
8392 }
8393 else {
8394 /* End of optional parameters is reached */
8395 proto_tree_add_uint_format(isup_tree, hf_isup_parameter_type, optional_parameters_tvb , offset, PARAMETER_TYPE_LENGTH,
8396 parameter_type, "End of optional parameters (%u)", parameter_type);
8397 }
8398 }
8399 }
8400
8401 /* ------------------------------------------------------------------
8402 Dissector all ANSI optional parameters
8403 TODO: Actually make this dissect ANSI :) - It's still plain old ITU for now
8404 */
8405 static void
8406 dissect_ansi_isup_optional_parameter(tvbuff_t *optional_parameters_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
8407 { proto_item *parameter_item;
8408 proto_tree *parameter_tree;
8409 int offset = 0;
8410 unsigned parameter_type, parameter_length, actual_length;
8411 tvbuff_t *parameter_tvb;
8412 uint8_t octet;
8413
8414 /* Dissect all optional parameters while end of message isn't reached */
8415 parameter_type = 0xFF; /* Start-initialization since parameter_type is used for while-condition */
8416
8417 while ((tvb_reported_length_remaining(optional_parameters_tvb, offset) >= 1) && (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS)) {
8418 parameter_type = tvb_get_uint8(optional_parameters_tvb, offset);
8419
8420 if (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS) {
8421 parameter_length = tvb_get_uint8(optional_parameters_tvb, offset + PARAMETER_TYPE_LENGTH);
8422
8423 parameter_tree = proto_tree_add_subtree_format(isup_tree, optional_parameters_tvb,
8424 offset, parameter_length + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH,
8425 ett_isup_parameter, &parameter_item, "Parameter: (t=%u, l=%u): %s",
8426 parameter_type, parameter_length, val_to_str_ext_const(parameter_type, &ansi_isup_parameter_type_value_ext, "Unknown"));
8427 proto_tree_add_uint(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset,
8428 PARAMETER_TYPE_LENGTH, parameter_type);
8429 offset += PARAMETER_TYPE_LENGTH;
8430
8431 octet = tvb_get_uint8(optional_parameters_tvb, offset);
8432
8433 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, optional_parameters_tvb, offset,
8434 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8435 offset += PARAMETER_LENGTH_IND_LENGTH;
8436 if (octet == 0)
8437 continue;
8438
8439 actual_length = tvb_reported_length_remaining(optional_parameters_tvb, offset);
8440 if (actual_length > 0) {
8441 parameter_tvb = tvb_new_subset_length_caplen(optional_parameters_tvb, offset, MIN(parameter_length, actual_length), parameter_length);
8442 switch (parameter_type) {
8443 case PARAM_TYPE_CALL_REF:
8444 dissect_isup_call_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8445 break;
8446 case PARAM_TYPE_TRANSM_MEDIUM_REQU:
8447 dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
8448 break;
8449 case PARAM_TYPE_ACC_TRANSP:
8450 dissect_isup_access_transport_parameter(parameter_tvb, parameter_tree, parameter_item, pinfo);
8451 break;
8452 case PARAM_TYPE_CALLED_PARTY_NR:
8453 dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8454 break;
8455 case PARAM_TYPE_SUBSQT_NR:
8456 dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8457 break;
8458 case PARAM_TYPE_NATURE_OF_CONN_IND:
8459 dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8460 break;
8461 case PARAM_TYPE_FORW_CALL_IND:
8462 dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
8463 break;
8464 case PARAM_TYPE_OPT_FORW_CALL_IND:
8465 dissect_isup_optional_forward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8466 break;
8467 case PARAM_TYPE_CALLING_PRTY_CATEG:
8468 dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8469 break;
8470 case PARAM_TYPE_CALLING_PARTY_NR:
8471 dissect_isup_calling_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8472 break;
8473 case PARAM_TYPE_REDIRECTING_NR:
8474 dissect_isup_redirecting_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8475 break;
8476 case PARAM_TYPE_REDIRECTION_NR:
8477 dissect_isup_redirection_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8478 break;
8479 case PARAM_TYPE_CONNECTION_REQ:
8480 dissect_isup_connection_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8481 break;
8482 case PARAM_TYPE_INFO_REQ_IND:
8483 dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8484 break;
8485 case PARAM_TYPE_INFO_IND:
8486 dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8487 break;
8488 case PARAM_TYPE_CONTINUITY_IND:
8489 dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8490 break;
8491 case PARAM_TYPE_BACKW_CALL_IND:
8492 dissect_ansi_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8493 break;
8494 case PARAM_TYPE_CAUSE_INDICATORS:
8495 dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8496 break;
8497 case PARAM_TYPE_REDIRECTION_INFO:
8498 dissect_isup_redirection_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8499 break;
8500 case PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE:
8501 dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
8502 break;
8503 case PARAM_TYPE_RANGE_AND_STATUS:
8504 dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8505 break;
8506 case PARAM_TYPE_FACILITY_IND:
8507 dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
8508 break;
8509 case PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD:
8510 dissect_isup_closed_user_group_interlock_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8511 break;
8512 case PARAM_TYPE_USER_SERVICE_INFO:
8513 dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8514 break;
8515 case PARAM_TYPE_SIGNALLING_POINT_CODE:
8516 dissect_isup_signalling_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8517 break;
8518 case PARAM_TYPE_USER_TO_USER_INFO:
8519 dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8520 break;
8521 case PARAM_TYPE_CONNECTED_NR:
8522 dissect_isup_connected_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8523 break;
8524 case PARAM_TYPE_SUSP_RESUME_IND:
8525 dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8526 break;
8527 case PARAM_TYPE_TRANSIT_NETW_SELECT:
8528 dissect_ansi_isup_transit_network_selection_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8529 break;
8530 case PARAM_TYPE_EVENT_INFO:
8531 dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8532 break;
8533 case PARAM_TYPE_CIRC_ASSIGN_MAP:
8534 dissect_isup_circuit_assignment_map_parameter(parameter_tvb, parameter_tree, parameter_item);
8535 break;
8536 case PARAM_TYPE_CIRC_STATE_IND:
8537 dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8538 break;
8539 case PARAM_TYPE_AUTO_CONG_LEVEL:
8540 dissect_isup_automatic_congestion_level_parameter(parameter_tvb, parameter_tree, parameter_item);
8541 break;
8542 case PARAM_TYPE_ORIG_CALLED_NR:
8543 dissect_isup_original_called_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8544 break;
8545 case PARAM_TYPE_OPT_BACKW_CALL_IND:
8546 dissect_isup_optional_backward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8547 break;
8548 case PARAM_TYPE_USER_TO_USER_IND:
8549 dissect_isup_user_to_user_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8550 break;
8551 case PARAM_TYPE_ORIG_ISC_POINT_CODE:
8552 dissect_isup_original_isc_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8553 break;
8554 case PARAM_TYPE_GENERIC_NOTIF_IND:
8555 dissect_isup_generic_notification_indicator_parameter(parameter_tvb, parameter_tree, parameter_item);
8556 break;
8557 case PARAM_TYPE_CALL_HIST_INFO :
8558 dissect_isup_call_history_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8559 break;
8560 case PARAM_TYPE_ACC_DELIV_INFO:
8561 dissect_isup_access_delivery_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8562 break;
8563 case PARAM_TYPE_NETW_SPECIFIC_FACLTY:
8564 dissect_isup_network_specific_facility_parameter(parameter_tvb, parameter_tree, parameter_item);
8565 break;
8566 case PARAM_TYPE_USER_SERVICE_INFO_PR:
8567 dissect_isup_user_service_information_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8568 break;
8569 case PARAM_TYPE_PROPAG_DELAY_COUNTER:
8570 dissect_isup_propagation_delay_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8571 break;
8572 case PARAM_TYPE_REMOTE_OPERATIONS:
8573 dissect_isup_remote_operations_parameter(parameter_tvb, parameter_tree, parameter_item);
8574 break;
8575 case PARAM_TYPE_SERVICE_ACTIVATION:
8576 dissect_isup_service_activation_parameter(parameter_tvb, parameter_tree, parameter_item);
8577 break;
8578 case PARAM_TYPE_USER_TELESERV_INFO:
8579 dissect_isup_user_teleservice_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8580 break;
8581 case PARAM_TYPE_TRANSM_MEDIUM_USED:
8582 dissect_isup_transmission_medium_used_parameter(parameter_tvb, parameter_tree, parameter_item);
8583 break;
8584 case PARAM_TYPE_CALL_DIV_INFO:
8585 dissect_isup_call_diversion_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8586 break;
8587 case PARAM_TYPE_ECHO_CTRL_INFO:
8588 dissect_isup_echo_control_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8589 break;
8590 case PARAM_TYPE_MSG_COMPAT_INFO:
8591 dissect_isup_message_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8592 break;
8593 case PARAM_TYPE_PARAM_COMPAT_INFO:
8594 dissect_isup_parameter_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8595 break;
8596 case PARAM_TYPE_MLPP_PRECEDENCE:
8597 dissect_isup_mlpp_precedence_parameter(parameter_tvb, parameter_tree, parameter_item);
8598 break;
8599 case PARAM_TYPE_MCID_REQ_IND:
8600 dissect_isup_mcid_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8601 break;
8602 case PARAM_TYPE_MCID_RSP_IND:
8603 dissect_isup_mcid_response_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8604 break;
8605 case PARAM_TYPE_HOP_COUNTER:
8606 dissect_isup_hop_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8607 break;
8608 case PARAM_TYPE_ORIG_LINE_INFO:
8609 dissect_isup_orig_line_info_parameter(parameter_tvb, parameter_tree, parameter_item);
8610 break;
8611 case PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR:
8612 dissect_isup_transmission_medium_requirement_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8613 break;
8614 case PARAM_TYPE_LOCATION_NR:
8615 dissect_isup_location_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8616 break;
8617 case PARAM_TYPE_REDIR_NR_RSTRCT:
8618 dissect_isup_redirection_number_restriction_parameter(parameter_tvb, parameter_tree, parameter_item);
8619 break;
8620 case PARAM_TYPE_CALL_TRANS_REF:
8621 dissect_isup_call_transfer_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8622 break;
8623 case PARAM_TYPE_LOOP_PREV_IND:
8624 dissect_isup_loop_prevention_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8625 break;
8626 case PARAM_TYPE_CALL_TRANS_NR:
8627 dissect_isup_call_transfer_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8628 break;
8629 case PARAM_TYPE_CCSS:
8630 dissect_isup_ccss_parameter(parameter_tvb, parameter_tree, parameter_item);
8631 break;
8632 case PARAM_TYPE_FORW_GVNS:
8633 dissect_isup_forward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8634 break;
8635 case PARAM_TYPE_BACKW_GVNS:
8636 dissect_isup_backward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8637 break;
8638 case PARAM_TYPE_REDIRECT_CAPAB:
8639 dissect_isup_redirect_capability_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8640 break;
8641 case PARAM_TYPE_NETW_MGMT_CTRL:
8642 dissect_isup_network_management_controls_parameter(parameter_tvb, parameter_tree, parameter_item);
8643 break;
8644 case PARAM_TYPE_CORRELATION_ID:
8645 dissect_isup_correlation_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8646 break;
8647 case PARAM_TYPE_SCF_ID:
8648 dissect_isup_scf_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8649 break;
8650 case PARAM_TYPE_CALL_DIV_TREAT_IND:
8651 dissect_isup_call_diversion_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8652 break;
8653 case PARAM_TYPE_CALLED_IN_NR:
8654 dissect_isup_called_in_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8655 break;
8656 case PARAM_TYPE_CALL_OFF_TREAT_IND:
8657 dissect_isup_call_offering_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8658 break;
8659 case PARAM_TYPE_CHARGED_PARTY_IDENT:
8660 dissect_isup_charged_party_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
8661 break;
8662 case PARAM_TYPE_CONF_TREAT_IND:
8663 dissect_isup_conference_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8664 break;
8665 case PARAM_TYPE_DISPLAY_INFO:
8666 dissect_isup_display_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8667 break;
8668 case PARAM_TYPE_UID_ACTION_IND:
8669 dissect_isup_uid_action_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8670 break;
8671 case PARAM_TYPE_UID_CAPAB_IND:
8672 dissect_isup_uid_capability_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8673 break;
8674 case PARAM_TYPE_REDIRECT_COUNTER:
8675 dissect_isup_redirect_counter_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8676 break;
8677 case PARAM_TYPE_COLLECT_CALL_REQ:
8678 dissect_isup_collect_call_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8679 break;
8680 case PARAM_TYPE_CALLING_GEODETIC_LOCATION:
8681 dissect_isup_calling_geodetic_location_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8682 break;
8683 case PARAM_TYPE_GENERIC_NR:
8684 dissect_isup_generic_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8685 break;
8686 case PARAM_TYPE_JURISDICTION:
8687 dissect_isup_jurisdiction_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8688 break;
8689 case PARAM_TYPE_GENERIC_NAME:
8690 dissect_isup_generic_name_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8691 break;
8692 case PARAM_TYPE_GENERIC_DIGITS:
8693 dissect_isup_generic_digits_parameter(parameter_tvb, parameter_tree, parameter_item);
8694 break;
8695 case PARAM_TYPE_CHARGE_NR:
8696 dissect_isup_charge_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8697 break;
8698 case PARAM_TYPE_APPLICATON_TRANS:
8699 dissect_isup_application_transport_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8700 break;
8701 case ANSI_ISUP_PARAM_TYPE_CARRIER_ID:
8702 dissect_ansi_isup_param_carrier_id(parameter_tvb, pinfo, parameter_tree, parameter_item);
8703 break;
8704 default:
8705 dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
8706 break;
8707 }
8708
8709 offset += MIN(parameter_length, actual_length);
8710 }
8711
8712 }
8713 else {
8714 /* End of optional parameters is reached */
8715 proto_tree_add_uint_format(isup_tree, hf_isup_parameter_type, optional_parameters_tvb , offset,
8716 PARAMETER_TYPE_LENGTH, parameter_type, "End of optional parameters (%u)", parameter_type);
8717 }
8718 }
8719 }
8720
8721 /* ------------------------------------------------------------------ */
8722 /* Dissectors for all used message types */
8723 /* Called by dissect_isup_message(), */
8724 /* call parameter dissectors in order of mandatory parameters */
8725 /* (since not labeled) */
8726 /* ------------------------------------------------------------------
8727 Dissector Message Type Circuit Validation Test Response
8728 */
8729 static int
8730 dissect_ansi_isup_circuit_validation_test_resp_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8731 {
8732 proto_item *parameter_item;
8733 proto_tree *parameter_tree;
8734 tvbuff_t *parameter_tvb;
8735 int offset = 0;
8736 int parameter_type, actual_length;
8737
8738 /* Do stuff for first mandatory fixed parameter: CVR Response Indicator */
8739 parameter_type = ANSI_ISUP_PARAM_TYPE_CVR_RESP_IND;
8740 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset, CVR_RESP_IND_LENGTH,
8741 ett_isup_parameter, &parameter_item, "CVR Response Indicator");
8742
8743 proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
8744 "%u (%s)",
8745 parameter_type,
8746 val_to_str_ext_const(parameter_type, &isup_parameter_type_value_ext, "CVR Response Indicator"));
8747
8748 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8749
8750 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CVR_RESP_IND_LENGTH, actual_length), CVR_RESP_IND_LENGTH);
8751 dissect_isup_cvr_response_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8752 offset += CVR_RESP_IND_LENGTH;
8753
8754 /* Do stuff for second mandatory fixed parameter: CG Characteristics Indicator */
8755 parameter_type = ANSI_ISUP_PARAM_TYPE_CG_CHAR_IND;
8756 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8757 CG_CHAR_IND_LENGTH, ett_isup_parameter, &parameter_item,
8758 "Circuit Group Characteristics Indicators");
8759 proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
8760 "%u (%s)",
8761 parameter_type,
8762 val_to_str_ext_const(parameter_type, &isup_parameter_type_value_ext, "Circuit Group Characters"));
8763 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8764 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CG_CHAR_IND_LENGTH, actual_length), CG_CHAR_IND_LENGTH);
8765 dissect_isup_circuit_group_char_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8766 offset += CG_CHAR_IND_LENGTH;
8767
8768 return offset;
8769 }
8770
8771 /* ------------------------------------------------------------------
8772 Dissector Message Type Circuit Reservation
8773 */
8774 static int
8775 dissect_ansi_isup_circuit_reservation_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
8776 { proto_item *parameter_item;
8777 proto_tree *parameter_tree;
8778 tvbuff_t *parameter_tvb;
8779 int offset = 0;
8780 int parameter_type, actual_length;
8781
8782 /* Do stuff for mandatory fixed parameter: Nature of Connection Indicators */
8783 parameter_type = PARAM_TYPE_NATURE_OF_CONN_IND;
8784 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8785 NATURE_OF_CONNECTION_IND_LENGTH, ett_isup_parameter, &parameter_item,
8786 "Nature of Connection Indicators");
8787 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8788 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8789 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(NATURE_OF_CONNECTION_IND_LENGTH, actual_length), NATURE_OF_CONNECTION_IND_LENGTH);
8790 dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8791 offset += NATURE_OF_CONNECTION_IND_LENGTH;
8792
8793 return offset;
8794 }
8795
8796 /* ------------------------------------------------------------------
8797 Dissector Message Type Initial address message
8798 */
8799 static int
8800 dissect_isup_initial_address_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
8801 { proto_item *parameter_item;
8802 proto_tree *parameter_tree;
8803 tvbuff_t *parameter_tvb;
8804 int offset = 0;
8805 int parameter_type, parameter_pointer, parameter_length, actual_length;
8806
8807 /* Do stuff for first mandatory fixed parameter: Nature of Connection Indicators */
8808 parameter_type = PARAM_TYPE_NATURE_OF_CONN_IND;
8809 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8810 NATURE_OF_CONNECTION_IND_LENGTH, ett_isup_parameter, &parameter_item,
8811 "Nature of Connection Indicators");
8812 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8813 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8814 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(NATURE_OF_CONNECTION_IND_LENGTH, actual_length), NATURE_OF_CONNECTION_IND_LENGTH);
8815 dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8816 offset += NATURE_OF_CONNECTION_IND_LENGTH;
8817
8818 /* Do stuff for 2nd mandatory fixed parameter: Forward Call Indicators */
8819 parameter_type = PARAM_TYPE_FORW_CALL_IND;
8820 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8821 FORWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
8822 "Forward Call Indicators");
8823 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8824 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8825 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(FORWARD_CALL_IND_LENGTH, actual_length), FORWARD_CALL_IND_LENGTH);
8826 dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
8827 offset += FORWARD_CALL_IND_LENGTH;
8828
8829 /* Do stuff for 3nd mandatory fixed parameter: Calling party's category */
8830 parameter_type = PARAM_TYPE_CALLING_PRTY_CATEG;
8831 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8832 CALLING_PRTYS_CATEGORY_LENGTH,
8833 ett_isup_parameter, &parameter_item,
8834 "Calling Party's category");
8835 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8836 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8837 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CALLING_PRTYS_CATEGORY_LENGTH, actual_length), CALLING_PRTYS_CATEGORY_LENGTH);
8838 dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8839 offset += CALLING_PRTYS_CATEGORY_LENGTH;
8840
8841 switch (isup_standard) {
8842 case ITU_STANDARD:
8843 /* If ITU, do stuff for 4th mandatory fixed parameter: Transmission medium requirement */
8844 parameter_type = PARAM_TYPE_TRANSM_MEDIUM_REQU;
8845 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8846 TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH,
8847 ett_isup_parameter, &parameter_item,
8848 "Transmission medium requirement");
8849 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8850 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8851 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
8852 offset,
8853 MIN(TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH, actual_length),
8854 TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH);
8855 dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
8856 offset += TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH;
8857 break;
8858 case ANSI_STANDARD:
8859 /* If ANSI, do stuff for the first mandatory variable parameter, USER_SERVICE_INFORMATION */
8860 parameter_type = PARAM_TYPE_USER_SERVICE_INFO;
8861 parameter_pointer = tvb_get_uint8(message_tvb, offset);
8862 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
8863 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
8864 offset + parameter_pointer,
8865 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
8866 ett_isup_parameter, &parameter_item,
8867 "User Service Information");
8868 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8869 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
8870 PARAMETER_POINTER_LENGTH, parameter_pointer);
8871 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
8872 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8873 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8874 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
8875 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
8876 MIN(parameter_length, actual_length),
8877 parameter_length);
8878 dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8879 offset += PARAMETER_POINTER_LENGTH;
8880 break;
8881 }
8882
8883 /* Do stuff for mandatory variable parameter Called party number */
8884 parameter_type = PARAM_TYPE_CALLED_PARTY_NR;
8885 parameter_pointer = tvb_get_uint8(message_tvb, offset);
8886 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
8887
8888 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
8889 offset + parameter_pointer,
8890 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
8891 ett_isup_parameter, &parameter_item,
8892 "Called Party Number");
8893 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8894 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
8895 PARAMETER_POINTER_LENGTH, parameter_pointer);
8896 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
8897 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8898 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8899 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
8900 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
8901 MIN(parameter_length, actual_length),
8902 parameter_length);
8903 dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8904 offset += PARAMETER_POINTER_LENGTH;
8905
8906 return offset;
8907 }
8908
8909 /* ------------------------------------------------------------------
8910 Dissector Message Type subsequent address message
8911 */
8912 static int dissect_isup_subsequent_address_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
8913 { proto_item *parameter_item;
8914 proto_tree *parameter_tree;
8915 tvbuff_t *parameter_tvb;
8916 int offset = 0;
8917 int parameter_type, parameter_pointer, parameter_length, actual_length;
8918
8919 /* Do stuff for mandatory variable parameter Subsequent number */
8920 parameter_type = PARAM_TYPE_SUBSQT_NR;
8921
8922 parameter_pointer = tvb_get_uint8(message_tvb, offset);
8923 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
8924
8925 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
8926 offset + parameter_pointer,
8927 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
8928 ett_isup_parameter, &parameter_item,
8929 "Subsequent Number");
8930 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8931 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
8932 PARAMETER_POINTER_LENGTH, parameter_pointer);
8933 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
8934 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8935 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8936 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
8937 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
8938 MIN(parameter_length, actual_length),
8939 parameter_length);
8940 dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8941 offset += PARAMETER_POINTER_LENGTH;
8942
8943 return offset;
8944 }
8945
8946 /* ------------------------------------------------------------------
8947 Dissector Message Type Information request message
8948 */
8949 static int
8950 dissect_isup_information_request_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8951 { proto_item *parameter_item;
8952 proto_tree *parameter_tree;
8953 tvbuff_t *parameter_tvb;
8954 int offset = 0;
8955 int parameter_type, actual_length;
8956
8957 /* Do stuff for first mandatory fixed parameter: Information request indicators*/
8958 parameter_type = PARAM_TYPE_INFO_REQ_IND;
8959 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8960 INFO_REQUEST_IND_LENGTH,
8961 ett_isup_parameter, &parameter_item,
8962 "Information request indicators");
8963 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8964 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8965 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(INFO_REQUEST_IND_LENGTH, actual_length), INFO_REQUEST_IND_LENGTH);
8966 dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8967 offset += INFO_REQUEST_IND_LENGTH;
8968 return offset;
8969 }
8970
8971 /* ------------------------------------------------------------------
8972 Dissector Message Type Information
8973 */
8974 static int
8975 dissect_isup_information_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8976 {
8977 proto_item *parameter_item;
8978 proto_tree *parameter_tree;
8979 tvbuff_t *parameter_tvb;
8980 int offset = 0;
8981 int parameter_type, actual_length;
8982
8983 /* Do stuff for first mandatory fixed parameter: Information indicators*/
8984 parameter_type = PARAM_TYPE_INFO_IND;
8985 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8986 INFO_IND_LENGTH, ett_isup_parameter, &parameter_item,
8987 "Information indicators");
8988 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8989 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
8990 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(INFO_IND_LENGTH, actual_length), INFO_IND_LENGTH);
8991 dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8992 offset += INFO_IND_LENGTH;
8993 return offset;
8994 }
8995
8996 /* ------------------------------------------------------------------
8997 Dissector Message Type Continuity
8998 */
8999 static int
9000 dissect_isup_continuity_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9001 { proto_item *parameter_item;
9002 proto_tree *parameter_tree;
9003 tvbuff_t *parameter_tvb;
9004 int offset = 0;
9005 int parameter_type, actual_length;
9006
9007 /* Do stuff for first mandatory fixed parameter: Continuity indicators*/
9008 parameter_type = PARAM_TYPE_CONTINUITY_IND;
9009 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9010 CONTINUITY_IND_LENGTH, ett_isup_parameter, &parameter_item,
9011 "Continuity indicators");
9012 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9013 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9014 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CONTINUITY_IND_LENGTH, actual_length), CONTINUITY_IND_LENGTH);
9015 dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9016 offset += CONTINUITY_IND_LENGTH;
9017 return offset;
9018 }
9019
9020 /* ------------------------------------------------------------------
9021 Dissector Message Type Address complete
9022 */
9023 static int
9024 dissect_isup_address_complete_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9025 {
9026 proto_item *parameter_item;
9027 proto_tree *parameter_tree;
9028 tvbuff_t *parameter_tvb;
9029 int offset = 0;
9030 int parameter_type, actual_length;
9031
9032 /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9033 parameter_type = PARAM_TYPE_BACKW_CALL_IND;
9034 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9035 BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
9036 "Backward Call Indicators");
9037 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9038 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9039 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(BACKWARD_CALL_IND_LENGTH, actual_length), BACKWARD_CALL_IND_LENGTH);
9040 dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9041 offset += BACKWARD_CALL_IND_LENGTH;
9042 return offset;
9043 }
9044
9045 static int
9046 dissect_ansi_isup_address_complete_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9047 {
9048 proto_item *parameter_item;
9049 proto_tree *parameter_tree;
9050 tvbuff_t *parameter_tvb;
9051 int offset = 0;
9052 int parameter_type, actual_length;
9053
9054 /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9055 parameter_type = PARAM_TYPE_BACKW_CALL_IND;
9056 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9057 BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
9058 "Backward Call Indicators");
9059 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9060 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9061 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(BACKWARD_CALL_IND_LENGTH, actual_length), BACKWARD_CALL_IND_LENGTH);
9062 dissect_ansi_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9063 offset += BACKWARD_CALL_IND_LENGTH;
9064 return offset;
9065 }
9066
9067 /* ------------------------------------------------------------------
9068 Dissector Message Type Connect
9069 */
9070 static int
9071 dissect_isup_connect_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9072 { proto_item *parameter_item;
9073 proto_tree *parameter_tree;
9074 tvbuff_t *parameter_tvb;
9075 int offset = 0;
9076 int parameter_type, actual_length;
9077
9078 /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9079 parameter_type = PARAM_TYPE_BACKW_CALL_IND;
9080 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9081 BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
9082 "Backward Call Indicators");
9083 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9084 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9085 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(BACKWARD_CALL_IND_LENGTH, actual_length), BACKWARD_CALL_IND_LENGTH);
9086 dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9087 offset += BACKWARD_CALL_IND_LENGTH;
9088 return offset;
9089 }
9090
9091 /* ------------------------------------------------------------------
9092 Dissector Message Type release message
9093 */
9094 static int
9095 dissect_isup_release_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9096 { proto_item *parameter_item;
9097 proto_tree *parameter_tree;
9098 tvbuff_t *parameter_tvb;
9099 int offset = 0;
9100 int parameter_type, parameter_pointer, parameter_length, actual_length;
9101
9102 /* Do stuff for mandatory variable parameter Cause indicators */
9103 parameter_type = PARAM_TYPE_CAUSE_INDICATORS;
9104
9105 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9106 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9107
9108 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9109 offset + parameter_pointer,
9110 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9111 ett_isup_parameter, &parameter_item,
9112 "Cause indicators");
9113 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9114 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9115 PARAMETER_POINTER_LENGTH, parameter_pointer);
9116 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9117 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9118 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9119 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9120 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9121 MIN(parameter_length, actual_length),
9122 parameter_length);
9123 switch (isup_standard) {
9124 case ITU_STANDARD:
9125 dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9126 break;
9127 case ANSI_STANDARD:
9128 dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9129 break;
9130 }
9131 offset += PARAMETER_POINTER_LENGTH;
9132
9133 return offset;
9134 }
9135
9136 /* ------------------------------------------------------------------
9137 Dissector Message Type Resume/Suspend
9138 */
9139 static int
9140 dissect_isup_suspend_resume_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9141 { proto_item *parameter_item;
9142 proto_tree *parameter_tree;
9143 tvbuff_t *parameter_tvb;
9144 int offset = 0;
9145 int parameter_type, actual_length;
9146
9147 /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9148 parameter_type = PARAM_TYPE_SUSP_RESUME_IND;
9149 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9150 SUSPEND_RESUME_IND_LENGTH,
9151 ett_isup_parameter, &parameter_item,
9152 "Suspend/Resume indicator");
9153 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9154 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9155 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(SUSPEND_RESUME_IND_LENGTH, actual_length), SUSPEND_RESUME_IND_LENGTH);
9156 dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9157 offset += SUSPEND_RESUME_IND_LENGTH;
9158 return offset;
9159 }
9160
9161 /* ------------------------------------------------------------------
9162 Dissector Message Type Circuit group reset/query message
9163 */
9164 static int
9165 dissect_isup_circuit_group_reset_query_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9166 { proto_item *parameter_item;
9167 proto_tree *parameter_tree;
9168 tvbuff_t *parameter_tvb;
9169 int offset = 0;
9170 int parameter_type, parameter_pointer, parameter_length, actual_length;
9171
9172 /* Do stuff for mandatory variable parameter range and status*/
9173 parameter_type = PARAM_TYPE_RANGE_AND_STATUS;
9174
9175 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9176 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9177
9178 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9179 offset + parameter_pointer,
9180 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9181 ett_isup_parameter, &parameter_item,
9182 "Range and status");
9183 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9184 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9185 PARAMETER_POINTER_LENGTH, parameter_pointer);
9186 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9187 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9188 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9189 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9190 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9191 MIN(parameter_length, actual_length),
9192 parameter_length);
9193 dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9194 offset += PARAMETER_POINTER_LENGTH;
9195
9196 return offset;
9197 }
9198
9199 /* ------------------------------------------------------------------
9200 Dissector Message Type Circuit group blocking/blocking ack/unblocking/unblocking ack messages
9201 */
9202 static int
9203 dissect_isup_circuit_group_blocking_messages(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9204 { proto_item *parameter_item;
9205 proto_tree *parameter_tree;
9206 tvbuff_t *parameter_tvb;
9207 int offset = 0;
9208 int parameter_type, parameter_pointer, parameter_length, actual_length;
9209
9210 /* Do stuff for first mandatory fixed parameter: circuit group supervision message type*/
9211 parameter_type = PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE;
9212 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9213 CIRC_GRP_SV_MSG_TYPE_LENGTH,
9214 ett_isup_parameter, &parameter_item,
9215 "Circuit group supervision message type");
9216 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9217 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9218 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CIRC_GRP_SV_MSG_TYPE_LENGTH, actual_length), CIRC_GRP_SV_MSG_TYPE_LENGTH);
9219 dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
9220 offset += CIRC_GRP_SV_MSG_TYPE_LENGTH;
9221
9222 /* Do stuff for mandatory variable parameter range and status*/
9223 parameter_type = PARAM_TYPE_RANGE_AND_STATUS;
9224
9225 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9226 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9227
9228 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9229 offset + parameter_pointer,
9230 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9231 ett_isup_parameter, &parameter_item,
9232 "Range and status");
9233 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9234 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9235 PARAMETER_POINTER_LENGTH, parameter_pointer);
9236 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9237 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9238 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9239 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9240 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9241 MIN(parameter_length, actual_length),
9242 parameter_length);
9243 dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9244 offset += PARAMETER_POINTER_LENGTH;
9245
9246 return offset;
9247 }
9248
9249 /* ------------------------------------------------------------------
9250 Dissector Message Type Facility request/accepted
9251 */
9252 static int
9253 dissect_isup_facility_request_accepted_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9254 { proto_item *parameter_item;
9255 proto_tree *parameter_tree;
9256 tvbuff_t *parameter_tvb;
9257 int offset = 0;
9258 int parameter_type, actual_length;
9259
9260 /* Do stuff for first mandatory fixed parameter: facility indicators*/
9261 parameter_type = PARAM_TYPE_FACILITY_IND;
9262 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9263 FACILITY_IND_LENGTH,
9264 ett_isup_parameter, &parameter_item,
9265 "Facility indicator");
9266 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9267 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9268 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(FACILITY_IND_LENGTH, actual_length), FACILITY_IND_LENGTH);
9269 dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
9270 offset += FACILITY_IND_LENGTH;
9271 return offset;
9272 }
9273
9274 /* ------------------------------------------------------------------
9275 Dissector Message Type Facility reject
9276 */
9277 static int
9278 dissect_isup_facility_reject_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9279 { proto_item *parameter_item;
9280 proto_tree *parameter_tree;
9281 tvbuff_t *parameter_tvb;
9282 int offset = 0;
9283 int parameter_type, parameter_pointer, parameter_length, actual_length;
9284
9285 /* Do stuff for first mandatory fixed parameter: facility indicators*/
9286 parameter_type = PARAM_TYPE_FACILITY_IND;
9287 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9288 FACILITY_IND_LENGTH,
9289 ett_isup_parameter, &parameter_item,
9290 "Facility indicator");
9291 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9292 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9293 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(FACILITY_IND_LENGTH, actual_length), FACILITY_IND_LENGTH);
9294 dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
9295 offset += FACILITY_IND_LENGTH;
9296
9297 /* Do stuff for mandatory variable parameter Cause indicators */
9298 parameter_type = PARAM_TYPE_CAUSE_INDICATORS;
9299
9300 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9301 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9302
9303 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9304 offset + parameter_pointer,
9305 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9306 ett_isup_parameter, &parameter_item,
9307 "Cause indicators, see Q.850");
9308 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9309 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb,
9310 offset, PARAMETER_POINTER_LENGTH, parameter_pointer);
9311 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9312 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9313 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9314 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9315 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9316 MIN(parameter_length, actual_length),
9317 parameter_length);
9318 switch (isup_standard) {
9319 case ITU_STANDARD:
9320 dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9321 break;
9322 case ANSI_STANDARD:
9323 dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9324 break;
9325 }
9326 offset += PARAMETER_POINTER_LENGTH;
9327
9328 return offset;
9329 }
9330
9331 /* ------------------------------------------------------------------
9332 Dissector Message Type Circuit group reset acknowledgement message
9333 */
9334 static int
9335 dissect_isup_circuit_group_reset_acknowledgement_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9336 { proto_item *parameter_item;
9337 proto_tree *parameter_tree;
9338 tvbuff_t *parameter_tvb;
9339 int offset = 0;
9340 int parameter_type, parameter_pointer, parameter_length, actual_length;
9341
9342 /* Do stuff for mandatory variable parameter range and status*/
9343 parameter_type = PARAM_TYPE_RANGE_AND_STATUS;
9344
9345 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9346 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9347
9348 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9349 offset + parameter_pointer,
9350 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9351 ett_isup_parameter, &parameter_item,
9352 "Range and status");
9353 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9354 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9355 PARAMETER_POINTER_LENGTH, parameter_pointer);
9356 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9357 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9358 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9359 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9360 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9361 MIN(parameter_length, actual_length),
9362 parameter_length);
9363 dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9364 offset += PARAMETER_POINTER_LENGTH;
9365
9366 return offset;
9367 }
9368
9369 /* ------------------------------------------------------------------
9370 Dissector Message Type Circuit group query response message
9371 */
9372 static int
9373 dissect_isup_circuit_group_query_response_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9374 { proto_item *parameter_item;
9375 proto_tree *parameter_tree;
9376 tvbuff_t *parameter_tvb;
9377 int offset = 0;
9378 int parameter_type, parameter_pointer, parameter_length, actual_length;
9379
9380 /* Do stuff for 1. mandatory variable parameter range and status*/
9381 parameter_type = PARAM_TYPE_RANGE_AND_STATUS;
9382
9383 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9384 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9385
9386 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9387 offset + parameter_pointer,
9388 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9389 ett_isup_parameter, &parameter_item,
9390 "Range and status");
9391 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9392 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9393 PARAMETER_POINTER_LENGTH, parameter_pointer);
9394 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9395 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9396 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9397 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9398 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9399 MIN(parameter_length, actual_length),
9400 parameter_length);
9401 dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9402 offset += PARAMETER_POINTER_LENGTH;
9403
9404 /* Do stuff for 2. mandatory variable parameter Circuit state indicator*/
9405 parameter_type = PARAM_TYPE_CIRC_STATE_IND;
9406
9407 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9408 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9409
9410 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9411 offset + parameter_pointer,
9412 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9413 ett_isup_parameter, &parameter_item,
9414 "Circuit state indicator (national use)");
9415 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9416 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9417 PARAMETER_POINTER_LENGTH, parameter_pointer);
9418 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9419 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9420 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9421 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9422 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9423 MIN(parameter_length, actual_length),
9424 parameter_length);
9425 dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
9426 offset += PARAMETER_POINTER_LENGTH;
9427
9428 return offset;
9429 }
9430
9431 /* ------------------------------------------------------------------
9432 Dissector Message Type Call Progress
9433 */
9434 static int
9435 dissect_isup_call_progress_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9436 { proto_item *parameter_item;
9437 proto_tree *parameter_tree;
9438 tvbuff_t *parameter_tvb;
9439 int offset = 0;
9440 int parameter_type, actual_length;
9441
9442 /* Do stuff for first mandatory fixed parameter: Event information*/
9443 parameter_type = PARAM_TYPE_EVENT_INFO;
9444 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9445 EVENT_INFO_LENGTH, ett_isup_parameter, &parameter_item,
9446 "Event information");
9447 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9448 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9449 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(EVENT_INFO_LENGTH, actual_length), EVENT_INFO_LENGTH);
9450 dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
9451 offset += EVENT_INFO_LENGTH;
9452 return offset;
9453 }
9454
9455 /* ------------------------------------------------------------------
9456 Dissector Message Type User-to-User information
9457 */
9458 static int
9459 dissect_isup_user_to_user_information_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9460 { proto_item *parameter_item;
9461 proto_tree *parameter_tree;
9462 tvbuff_t *parameter_tvb;
9463 int offset = 0;
9464 int parameter_type, parameter_pointer, parameter_length, actual_length;
9465
9466 /* Do stuff for mandatory variable parameter User-to-user information*/
9467 parameter_type = PARAM_TYPE_USER_TO_USER_INFO;
9468
9469 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9470 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9471
9472 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9473 offset + parameter_pointer,
9474 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9475 ett_isup_parameter, &parameter_item,
9476 "User-to-user information, see Q.931");
9477 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9478 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9479 PARAMETER_POINTER_LENGTH, parameter_pointer);
9480 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9481 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9482 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9483 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9484 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9485 MIN(parameter_length, actual_length),
9486 parameter_length);
9487 dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9488 offset += PARAMETER_POINTER_LENGTH;
9489
9490 return offset;
9491 }
9492
9493 /* ------------------------------------------------------------------
9494 Dissector Message Type Confusion
9495 */
9496 static int
9497 dissect_isup_confusion_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9498 { proto_item *parameter_item;
9499 proto_tree *parameter_tree;
9500 tvbuff_t *parameter_tvb;
9501 int offset = 0;
9502 int parameter_type, parameter_pointer, parameter_length, actual_length;
9503
9504 /* Do stuff for mandatory variable parameter Cause indicators */
9505 parameter_type = PARAM_TYPE_CAUSE_INDICATORS;
9506
9507 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9508 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9509
9510 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9511 offset + parameter_pointer,
9512 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9513 ett_isup_parameter, &parameter_item,
9514 "Cause indicators, see Q.850");
9515 proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9516 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9517 PARAMETER_POINTER_LENGTH, parameter_pointer);
9518 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length,
9519 message_tvb, offset + parameter_pointer, PARAMETER_LENGTH_IND_LENGTH,
9520 parameter_length);
9521 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9522 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9523 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9524 MIN(parameter_length, actual_length),
9525 parameter_length);
9526
9527 switch (isup_standard) {
9528 case ITU_STANDARD:
9529 dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9530 break;
9531 case ANSI_STANDARD:
9532 dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9533 break;
9534 }
9535 offset += PARAMETER_POINTER_LENGTH;
9536
9537 return offset;
9538 }
9539
9540 /* Dissect national messages */
9541 static int
9542 dissect_french_isup_charging_pulse_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9543 {
9544 int offset = 0;
9545
9546 proto_tree_add_item(isup_tree, hf_isup_french_coll_field, message_tvb, offset, 1, ENC_BIG_ENDIAN);
9547 offset += 1;
9548 proto_tree_add_item(isup_tree, hf_isup_french_msg_num, message_tvb, offset, 1, ENC_BIG_ENDIAN);
9549 offset += 1;
9550
9551 return offset;
9552 }
9553
9554 static const value_string israeli_cmi_current_rate[] = {
9555 { 0, "Current rate not present" },
9556 { 1, "Rate expressed in deciseconds" },
9557 { 2, "Rate expressed in centiseconds" },
9558 { 3, "Rate expressed in milliseconds" },
9559 { 0, NULL}
9560 };
9561 static const value_string israeli_cmi_next_rate[] = {
9562 { 0, "Time indicator and next rate not present" },
9563 { 1, "Rate expressed in deciseconds" },
9564 { 2, "Rate expressed in centiseconds" },
9565 { 3, "Rate expressed in milliseconds" },
9566 { 0, NULL}
9567 };
9568 static const value_string israeli_time_indicators[] = {
9569 { 0, "spare" },
9570 { 1, "00.30 H" },
9571 { 2, "01.00 H" },
9572 { 3, "01.30 H" },
9573 { 4, "02.00 H" },
9574 { 5, "02.30 H" },
9575 { 6, "03.00 H" },
9576 { 7, "03.30 H" },
9577 { 8, "04.00 H" },
9578 { 9, "04.30 H" },
9579 { 10, "05.00 H" },
9580 { 11, "05.30 H" },
9581 { 12, "06.00 H" },
9582 { 13, "06.30 H" },
9583 { 14, "07.00 H" },
9584 { 15, "07.30 H" },
9585 { 16, "08.00 H" },
9586 { 17, "08.30 H" },
9587 { 18, "09.00 H" },
9588 { 19, "09.30 H" },
9589 { 20, "10.00 H" },
9590 { 21, "10.30 H" },
9591 { 22, "11.00 H" },
9592 { 23, "11.30 H" },
9593 { 24, "12.00 H" },
9594 { 25, "12.30 H" },
9595 { 26, "13.00 H" },
9596 { 27, "13.30 H" },
9597 { 28, "14.00 H" },
9598 { 29, "14.30 H" },
9599 { 30, "15.00 H" },
9600 { 31, "15.30 H" },
9601 { 32, "16.00 H" },
9602 { 33, "16.30 H" },
9603 { 34, "17.00 H" },
9604 { 35, "17.30 H" },
9605 { 36, "18.00 H" },
9606 { 37, "18.30 H" },
9607 { 38, "19.00 H" },
9608 { 39, "19.30 H" },
9609 { 40, "20.00 H" },
9610 { 41, "20.30 H" },
9611 { 42, "21.00 H" },
9612 { 43, "21.30 H" },
9613 { 44, "22.00 H" },
9614 { 45, "22.30 H" },
9615 { 46, "23.00 H" },
9616 { 47, "23.30 H" },
9617 { 48, "24.00 H" },
9618 { 0, NULL}
9619 };
9620 static value_string_ext israeli_time_indicators_ext = VALUE_STRING_EXT_INIT(israeli_time_indicators);
9621
9622 static int
9623 dissect_israeli_backward_charging_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9624 {
9625 int offset = 0;
9626
9627 proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_current, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9628 proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_next, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9629 offset += 1;
9630 proto_tree_add_item(isup_tree, hf_isup_israeli_current_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
9631 offset += 2;
9632 proto_tree_add_item(isup_tree, hf_isup_israeli_time_indicator, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9633 offset += 1;
9634 proto_tree_add_item(isup_tree, hf_isup_israeli_next_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
9635 offset += 2;
9636
9637 return offset;
9638 }
9639
9640 static int
9641 dissect_israeli_traffic_change_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9642 {
9643 int offset = 0;
9644
9645 proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_current, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9646 proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_next, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9647 offset += 1;
9648 proto_tree_add_item(isup_tree, hf_isup_israeli_time_indicator, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9649 offset += 1;
9650 proto_tree_add_item(isup_tree, hf_isup_israeli_next_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
9651 offset += 2;
9652
9653 return offset;
9654 }
9655
9656 static int
9657 dissect_japan_chg_inf(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9658 {
9659 proto_item *parameter_item;
9660 proto_tree *parameter_tree;
9661 tvbuff_t *parameter_tvb;
9662 int offset = 0;
9663 int parameter_type, parameter_pointer, parameter_length, actual_length;
9664 uint8_t chg_inf_type;
9665
9666 /* Do stuff for first mandatory fixed parameter: Charge information type */
9667 parameter_type = JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE;
9668 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset, 1,
9669 ett_isup_parameter, &parameter_item, "Charge information type");
9670 proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
9671 "%u (%s)",
9672 parameter_type,
9673 val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
9674 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9675 parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(1, actual_length), 1);
9676 chg_inf_type = tvb_get_uint8(parameter_tvb, 0);
9677 dissect_japan_chg_inf_type(parameter_tvb, parameter_tree, parameter_item);
9678 offset += 1;
9679
9680 /* Do stuff for mandatory variable parameter Charge information */
9681 parameter_type = JAPAN_ISUP_PARAM_TYPE_CHARGE_INF;
9682 parameter_pointer = tvb_get_uint8(message_tvb, offset);
9683 parameter_length = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9684
9685 parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9686 offset + parameter_pointer,
9687 parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9688 ett_isup_parameter, &parameter_item,
9689 "Charge information");
9690 proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
9691 "%u (%s)",
9692 parameter_type,
9693 val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
9694 proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9695 PARAMETER_POINTER_LENGTH, parameter_pointer);
9696 proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9697 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9698 actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
9699 parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
9700 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9701 MIN(parameter_length, actual_length),
9702 parameter_length);
9703
9704 /* TODO: Dissect the parameter here, switch on type */
9705 switch (chg_inf_type) {
9706 case 3:
9707 /* Advanced Charge Rate Transfer (TDS service) */
9708 dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
9709 break;
9710 case 254:
9711 /* Charge rate transfer (flexible charging) */
9712 dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
9713 break;
9714 default:
9715 proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 0, -1, "Charge information data, not dissected yet");
9716 break;
9717 }
9718
9719
9720 offset += PARAMETER_POINTER_LENGTH;
9721
9722 return offset;
9723
9724 }
9725
9726 /* ------------------------------------------------------------------ */
9727 // NOLINTBEGIN(misc-no-recursion)
9728 static void
9729 dissect_ansi_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant, uint32_t circuit_id)
9730 {
9731 isup_tap_rec_t *tap_rec;
9732
9733 tvbuff_t *parameter_tvb;
9734 tvbuff_t *optional_parameter_tvb;
9735 proto_tree *pass_along_tree;
9736 proto_item *type_item;
9737 int offset, bufferlength;
9738 uint8_t message_type, opt_parameter_pointer;
9739 bool opt_part_possible = false; /* default setting - for message types allowing optional
9740 params explicitly set to true in case statement */
9741 tap_calling_number = NULL;
9742 offset = 0;
9743
9744 // We call ourselves for MESSAGE_TYPE_PASS_ALONG.
9745 increment_dissection_depth(pinfo);
9746
9747 /* Extract message type field */
9748 message_type = tvb_get_uint8(message_tvb, 0);
9749
9750 type_item = proto_tree_add_uint_format(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type, "Message type: %s (%u)",
9751 val_to_str_ext_const(message_type, &ansi_isup_message_type_value_ext, "reserved"), message_type);
9752
9753 offset += MESSAGE_TYPE_LENGTH;
9754
9755 tap_rec = wmem_new(pinfo->pool, isup_tap_rec_t);
9756 tap_rec->message_type = message_type;
9757 tap_rec->itu_isup_variant = itu_isup_variant;
9758 tap_rec->calling_number = NULL;
9759 tap_rec->called_number = NULL;
9760 tap_rec->circuit_id = circuit_id;
9761
9762 parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
9763
9764 /* distinguish between message types:*/
9765 switch (message_type) {
9766 case MESSAGE_TYPE_INITIAL_ADDR:
9767 offset += dissect_isup_initial_address_message(parameter_tvb, pinfo, isup_tree, itu_isup_variant);
9768 opt_part_possible = true;
9769 break;
9770 case MESSAGE_TYPE_SUBSEQ_ADDR:
9771 offset += dissect_isup_subsequent_address_message(parameter_tvb, pinfo, isup_tree);
9772 opt_part_possible = true;
9773 break;
9774 case MESSAGE_TYPE_INFO_REQ:
9775 offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
9776 opt_part_possible = true;
9777 break;
9778 case MESSAGE_TYPE_INFO:
9779 offset += dissect_isup_information_message(parameter_tvb, isup_tree);
9780 opt_part_possible = true;
9781 break;
9782 case MESSAGE_TYPE_CONTINUITY:
9783 offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
9784 break;
9785 case MESSAGE_TYPE_ADDR_CMPL:
9786 offset += dissect_ansi_isup_address_complete_message(parameter_tvb, pinfo, isup_tree);
9787 opt_part_possible = true;
9788 break;
9789 case MESSAGE_TYPE_CONNECT:
9790 offset += dissect_isup_connect_message(parameter_tvb, pinfo, isup_tree);
9791 opt_part_possible = true;
9792 break;
9793 case MESSAGE_TYPE_FORW_TRANS:
9794 /* no dissector necessary since no mandatory parameters included */
9795 opt_part_possible = true;
9796 break;
9797 case MESSAGE_TYPE_ANSWER:
9798 /* no dissector necessary since no mandatory parameters included */
9799 opt_part_possible = true;
9800 break;
9801 case MESSAGE_TYPE_RELEASE:
9802 offset += dissect_isup_release_message(parameter_tvb, isup_tree);
9803 opt_part_possible = true;
9804 break;
9805 case MESSAGE_TYPE_SUSPEND:
9806 offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
9807 opt_part_possible = true;
9808 break;
9809 case MESSAGE_TYPE_RESUME:
9810 offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
9811 opt_part_possible = true;
9812 break;
9813 case MESSAGE_TYPE_REL_CMPL:
9814 /* no dissector necessary since no mandatory parameters included */
9815 break;
9816 case MESSAGE_TYPE_CONT_CHECK_REQ:
9817 /* no dissector necessary since no mandatory parameters included */
9818 break;
9819 case MESSAGE_TYPE_RESET_CIRCUIT:
9820 /* no dissector necessary since no mandatory parameters included */
9821 break;
9822 case MESSAGE_TYPE_BLOCKING:
9823 /* no dissector necessary since no mandatory parameters included */
9824 break;
9825 case MESSAGE_TYPE_UNBLOCKING:
9826 /* no dissector necessary since no mandatory parameters included */
9827 break;
9828 case MESSAGE_TYPE_BLOCK_ACK:
9829 /* no dissector necessary since no mandatory parameters included */
9830 break;
9831 case MESSAGE_TYPE_UNBLOCK_ACK:
9832 /* no dissector necessary since no mandatory parameters included */
9833 break;
9834 case MESSAGE_TYPE_CIRC_GRP_RST:
9835 offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
9836 break;
9837 case MESSAGE_TYPE_CIRC_GRP_BLCK:
9838 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9839 break;
9840 case MESSAGE_TYPE_CIRC_GRP_UNBL:
9841 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9842 break;
9843 case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
9844 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9845 break;
9846 case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
9847 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9848 break;
9849 case MESSAGE_TYPE_FACILITY_REQ:
9850 offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
9851 opt_part_possible = true;
9852 break;
9853 case MESSAGE_TYPE_FACILITY_ACC:
9854 offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
9855 opt_part_possible = true;
9856 break;
9857 case MESSAGE_TYPE_FACILITY_REJ:
9858 offset += dissect_isup_facility_reject_message(parameter_tvb, isup_tree);
9859 opt_part_possible = true;
9860 break;
9861 case MESSAGE_TYPE_LOOP_BACK_ACK:
9862 /* no dissector necessary since no mandatory parameters included */
9863 break;
9864 case MESSAGE_TYPE_PASS_ALONG:
9865 /* call dissect_isup_message recursively */
9866 {
9867 uint8_t pa_message_type;
9868 pa_message_type = tvb_get_uint8(parameter_tvb, 0);
9869 pass_along_tree = proto_tree_add_subtree_format(isup_tree, parameter_tvb, offset, -1,
9870 ett_isup_pass_along_message, NULL, "Pass-along: %s Message (%u)",
9871 val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
9872 pa_message_type);
9873 dissect_ansi_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant, circuit_id);
9874 break;
9875 }
9876 case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
9877 offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, pinfo, isup_tree);
9878 break;
9879 case MESSAGE_TYPE_CIRC_GRP_QRY:
9880 offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
9881 break;
9882 case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
9883 offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, pinfo, isup_tree);
9884 break;
9885 case MESSAGE_TYPE_CALL_PROGRSS:
9886 offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
9887 opt_part_possible = true;
9888 break;
9889 case MESSAGE_TYPE_USER2USER_INFO:
9890 offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
9891 opt_part_possible = true;
9892 break;
9893 case MESSAGE_TYPE_UNEQUIPPED_CIC:
9894 /* no dissector necessary since no mandatory parameters included */
9895 break;
9896 case MESSAGE_TYPE_CONFUSION:
9897 offset += dissect_isup_confusion_message(parameter_tvb, isup_tree);
9898 opt_part_possible = true;
9899 break;
9900 case MESSAGE_TYPE_OVERLOAD:
9901 /* no dissector necessary since no mandatory parameters included */
9902 break;
9903 case MESSAGE_TYPE_CHARGE_INFO:
9904 /* do nothing since format is a national matter */
9905 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
9906 if (bufferlength != 0)
9907 proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
9908 break;
9909 case MESSAGE_TYPE_NETW_RESRC_MGMT:
9910 /* no dissector necessary since no mandatory parameters included */
9911 opt_part_possible = true;
9912 break;
9913 case MESSAGE_TYPE_FACILITY:
9914 /* no dissector necessary since no mandatory parameters included */
9915 opt_part_possible = true;
9916 break;
9917 case MESSAGE_TYPE_USER_PART_TEST:
9918 /* no dissector necessary since no mandatory parameters included */
9919 opt_part_possible = true;
9920 break;
9921 case MESSAGE_TYPE_USER_PART_AVAIL:
9922 /* no dissector necessary since no mandatory parameters included */
9923 opt_part_possible = true;
9924 break;
9925 case MESSAGE_TYPE_IDENT_REQ:
9926 /* no dissector necessary since no mandatory parameters included */
9927 opt_part_possible = true;
9928 break;
9929 case MESSAGE_TYPE_IDENT_RSP:
9930 /* no dissector necessary since no mandatory parameters included */
9931 opt_part_possible = true;
9932 break;
9933 case MESSAGE_TYPE_SEGMENTATION:
9934 /* no dissector necessary since no mandatory parameters included */
9935 opt_part_possible = true;
9936 break;
9937 case MESSAGE_TYPE_LOOP_PREVENTION:
9938 /* no dissector necessary since no mandatory parameters included */
9939 opt_part_possible = true;
9940 break;
9941 case MESSAGE_TYPE_APPLICATION_TRANS:
9942 /* no dissector necessary since no mandatory parameters included */
9943 opt_part_possible = true;
9944 break;
9945 case MESSAGE_TYPE_PRE_RELEASE_INFO:
9946 /* no dissector necessary since no mandatory parameters included */
9947 opt_part_possible = true;
9948 break;
9949 case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
9950 /* do nothing since format is a national matter */
9951 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
9952 if (bufferlength != 0)
9953 proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
9954 break;
9955 case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK:
9956 /* no dissector necessary since no mandatory parameters included */
9957 break;
9958 case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES:
9959 offset += dissect_ansi_isup_circuit_reservation_message(parameter_tvb, pinfo, isup_tree);
9960 break;
9961 case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP:
9962 opt_part_possible = true;
9963 offset += dissect_ansi_isup_circuit_validation_test_resp_message(parameter_tvb, isup_tree);
9964 break;
9965 case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST:
9966 /* no dissector necessary since no mandatory parameters included */
9967 break;
9968 default:
9969 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
9970 if (bufferlength != 0)
9971 expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
9972 break;
9973 }
9974
9975 /* extract pointer to start of optional part (if any) */
9976 if (opt_part_possible == true) {
9977 opt_parameter_pointer = tvb_get_uint8(message_tvb, offset);
9978 if (opt_parameter_pointer > 0) {
9979 proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
9980 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
9981 "Pointer to start of optional part: %u", opt_parameter_pointer);
9982 offset += opt_parameter_pointer;
9983 optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
9984 dissect_ansi_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
9985 }
9986 else
9987 proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
9988 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
9989 "No optional parameter present (Pointer: %u)", opt_parameter_pointer);
9990 }
9991 else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
9992 expert_add_info(pinfo, type_item, &ei_isup_message_type_no_optional_parameters);
9993
9994 /* if there are calling/called number, we'll get them for the tap */
9995 tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(pinfo->pool, "");
9996 tap_rec->called_number = tap_called_number;
9997 tap_rec->cause_value = tap_cause_value;
9998 tap_queue_packet(isup_tap, pinfo, tap_rec);
9999
10000 decrement_dissection_depth(pinfo);
10001 }
10002 // NOLINTEND(misc-no-recursion)
10003
10004 // NOLINTBEGIN(misc-no-recursion)
10005 static void
10006 dissect_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant, uint32_t circuit_id)
10007 {
10008 isup_tap_rec_t *tap_rec;
10009
10010 tvbuff_t *parameter_tvb;
10011 tvbuff_t *optional_parameter_tvb;
10012 proto_tree *pass_along_tree;
10013 proto_item *type_item = NULL;
10014 int offset, bufferlength;
10015 uint8_t message_type, opt_parameter_pointer;
10016 bool opt_part_possible = false; /* default setting - for message types allowing optional
10017 params explicitly set to true in case statement */
10018 tap_calling_number = NULL;
10019 offset = 0;
10020
10021 // We call ourselves for MESSAGE_TYPE_PASS_ALONG.
10022 increment_dissection_depth(pinfo);
10023
10024 /* Extract message type field */
10025 message_type = tvb_get_uint8(message_tvb, 0);
10026
10027 switch (itu_isup_variant) {
10028 case ISUP_ITU_STANDARD_VARIANT:
10029 type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
10030 "%s (%u)",
10031 val_to_str_ext_const(message_type, &isup_message_type_value_ext, "reserved"),
10032 message_type);
10033 break;
10034 case ISUP_FRENCH_VARIANT:
10035 type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
10036 "%s (%u)",
10037 val_to_str_ext_const(message_type, &french_isup_message_type_value_ext, "reserved"),
10038 message_type);
10039 break;
10040 case ISUP_ISRAELI_VARIANT:
10041 type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
10042 "%s (%u)",
10043 val_to_str_ext_const(message_type, &israeli_isup_message_type_value_ext, "reserved"),
10044 message_type);
10045 break;
10046 case ISUP_RUSSIAN_VARIANT:
10047 type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
10048 "%s (%u)",
10049 val_to_str_ext_const(message_type, &russian_isup_message_type_value_ext, "reserved"),
10050 message_type);
10051 break;
10052 case ISUP_JAPAN_VARIANT:
10053 /* Fall through */
10054 case ISUP_JAPAN_TTC_VARIANT:
10055 type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
10056 "%s (%u)",
10057 val_to_str_ext_const(message_type, &japan_isup_message_type_value_ext, "reserved"),
10058 message_type);
10059 break;
10060 }
10061
10062 offset += MESSAGE_TYPE_LENGTH;
10063
10064 tap_rec = wmem_new(pinfo->pool, isup_tap_rec_t);
10065 tap_rec->message_type = message_type;
10066 tap_rec->itu_isup_variant = itu_isup_variant;
10067 tap_rec->calling_number = NULL;
10068 tap_rec->called_number = NULL;
10069 tap_rec->circuit_id = circuit_id;
10070
10071 parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
10072
10073 /* distinguish between message types:*/
10074 switch (message_type) {
10075 case MESSAGE_TYPE_INITIAL_ADDR:
10076 offset += dissect_isup_initial_address_message(parameter_tvb, pinfo, isup_tree, itu_isup_variant);
10077 opt_part_possible = true;
10078 break;
10079 case MESSAGE_TYPE_SUBSEQ_ADDR:
10080 offset += dissect_isup_subsequent_address_message(parameter_tvb, pinfo, isup_tree);
10081 opt_part_possible = true;
10082 break;
10083 case MESSAGE_TYPE_INFO_REQ:
10084 offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
10085 opt_part_possible = true;
10086 break;
10087 case MESSAGE_TYPE_INFO:
10088 offset += dissect_isup_information_message(parameter_tvb, isup_tree);
10089 opt_part_possible = true;
10090 break;
10091 case MESSAGE_TYPE_CONTINUITY:
10092 offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
10093 break;
10094 case MESSAGE_TYPE_ADDR_CMPL:
10095 offset += dissect_isup_address_complete_message(parameter_tvb, pinfo, isup_tree);
10096 opt_part_possible = true;
10097 break;
10098 case MESSAGE_TYPE_CONNECT:
10099 offset += dissect_isup_connect_message(parameter_tvb, pinfo, isup_tree);
10100 opt_part_possible = true;
10101 break;
10102 case MESSAGE_TYPE_FORW_TRANS:
10103 /* no dissector necessary since no mandatory parameters included */
10104 opt_part_possible = true;
10105 break;
10106 case MESSAGE_TYPE_ANSWER:
10107 /* no dissector necessary since no mandatory parameters included */
10108 opt_part_possible = true;
10109 break;
10110 case MESSAGE_TYPE_RELEASE:
10111 offset += dissect_isup_release_message(parameter_tvb, isup_tree);
10112 opt_part_possible = true;
10113 break;
10114 case MESSAGE_TYPE_SUSPEND:
10115 offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
10116 opt_part_possible = true;
10117 break;
10118 case MESSAGE_TYPE_RESUME:
10119 offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
10120 opt_part_possible = true;
10121 break;
10122 case MESSAGE_TYPE_REL_CMPL:
10123 /* no dissector necessary since no mandatory parameters included */
10124 opt_part_possible = true;
10125 break;
10126 case MESSAGE_TYPE_CONT_CHECK_REQ:
10127 /* no dissector necessary since no mandatory parameters included */
10128 break;
10129 case MESSAGE_TYPE_RESET_CIRCUIT:
10130 /* no dissector necessary since no mandatory parameters included */
10131 break;
10132 case MESSAGE_TYPE_BLOCKING:
10133 /* no dissector necessary since no mandatory parameters included */
10134 break;
10135 case MESSAGE_TYPE_UNBLOCKING:
10136 /* no dissector necessary since no mandatory parameters included */
10137 break;
10138 case MESSAGE_TYPE_BLOCK_ACK:
10139 /* no dissector necessary since no mandatory parameters included */
10140 break;
10141 case MESSAGE_TYPE_UNBLOCK_ACK:
10142 /* no dissector necessary since no mandatory parameters included */
10143 break;
10144 case MESSAGE_TYPE_CIRC_GRP_RST:
10145 offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
10146 break;
10147 case MESSAGE_TYPE_CIRC_GRP_BLCK:
10148 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10149 break;
10150 case MESSAGE_TYPE_CIRC_GRP_UNBL:
10151 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10152 break;
10153 case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
10154 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10155 break;
10156 case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
10157 offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10158 break;
10159 case MESSAGE_TYPE_FACILITY_REQ:
10160 offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
10161 opt_part_possible = true;
10162 break;
10163 case MESSAGE_TYPE_FACILITY_ACC:
10164 offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
10165 opt_part_possible = true;
10166 break;
10167 case MESSAGE_TYPE_FACILITY_REJ:
10168 offset += dissect_isup_facility_reject_message(parameter_tvb, isup_tree);
10169 opt_part_possible = true;
10170 break;
10171 case MESSAGE_TYPE_LOOP_BACK_ACK:
10172 /* no dissector necessary since no mandatory parameters included */
10173 break;
10174 case MESSAGE_TYPE_PASS_ALONG:
10175 /* call dissect_isup_message recursively */
10176 {
10177 uint8_t pa_message_type;
10178 pa_message_type = tvb_get_uint8(parameter_tvb, 0);
10179 pass_along_tree = proto_tree_add_subtree_format(isup_tree, parameter_tvb, offset, -1,
10180 ett_isup_pass_along_message, NULL,
10181 "Pass-along: %s Message (%u)",
10182 val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
10183 pa_message_type);
10184 dissect_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant, circuit_id);
10185 break;
10186 }
10187 case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
10188 offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, pinfo, isup_tree);
10189 break;
10190 case MESSAGE_TYPE_CIRC_GRP_QRY:
10191 offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
10192 break;
10193 case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
10194 offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, pinfo, isup_tree);
10195 break;
10196 case MESSAGE_TYPE_CALL_PROGRSS:
10197 offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
10198 opt_part_possible = true;
10199 break;
10200 case MESSAGE_TYPE_USER2USER_INFO:
10201 offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
10202 opt_part_possible = true;
10203 break;
10204 case MESSAGE_TYPE_UNEQUIPPED_CIC:
10205 /* no dissector necessary since no mandatory parameters included */
10206 break;
10207 case MESSAGE_TYPE_CONFUSION:
10208 offset += dissect_isup_confusion_message(parameter_tvb, isup_tree);
10209 opt_part_possible = true;
10210 break;
10211 case MESSAGE_TYPE_OVERLOAD:
10212 /* no dissector necessary since no mandatory parameters included */
10213 break;
10214 case MESSAGE_TYPE_CHARGE_INFO:
10215 /* do nothing since format is a national matter */
10216 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10217 if (bufferlength != 0) {
10218 switch (itu_isup_variant) {
10219 case ISUP_RUSSIAN_VARIANT:
10220 proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
10221 break;
10222 default:
10223 proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
10224 break;
10225 }
10226 }
10227 break;
10228 case MESSAGE_TYPE_NETW_RESRC_MGMT:
10229 /* no dissector necessary since no mandatory parameters included */
10230 opt_part_possible = true;
10231 break;
10232 case MESSAGE_TYPE_FACILITY:
10233 /* no dissector necessary since no mandatory parameters included */
10234 opt_part_possible = true;
10235 break;
10236 case MESSAGE_TYPE_USER_PART_TEST:
10237 /* no dissector necessary since no mandatory parameters included */
10238 opt_part_possible = true;
10239 break;
10240 case MESSAGE_TYPE_USER_PART_AVAIL:
10241 /* no dissector necessary since no mandatory parameters included */
10242 opt_part_possible = true;
10243 break;
10244 case MESSAGE_TYPE_IDENT_REQ:
10245 /* no dissector necessary since no mandatory parameters included */
10246 opt_part_possible = true;
10247 break;
10248 case MESSAGE_TYPE_IDENT_RSP:
10249 /* no dissector necessary since no mandatory parameters included */
10250 opt_part_possible = true;
10251 break;
10252 case MESSAGE_TYPE_SEGMENTATION:
10253 /* no dissector necessary since no mandatory parameters included */
10254 opt_part_possible = true;
10255 break;
10256 case MESSAGE_TYPE_LOOP_PREVENTION:
10257 /* no dissector necessary since no mandatory parameters included */
10258 opt_part_possible = true;
10259 break;
10260 case MESSAGE_TYPE_APPLICATION_TRANS:
10261 /* no dissector necessary since no mandatory parameters included */
10262 opt_part_possible = true;
10263 break;
10264 case MESSAGE_TYPE_PRE_RELEASE_INFO:
10265 /* no dissector necessary since no mandatory parameters included */
10266 opt_part_possible = true;
10267 break;
10268 case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
10269 /* do nothing since format is a national matter */
10270 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10271 if (bufferlength != 0)
10272 proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
10273 break;
10274 default:
10275 /* Handle national extensions here */
10276 switch (itu_isup_variant) {
10277 case ISUP_ITU_STANDARD_VARIANT:
10278 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10279 if (bufferlength != 0)
10280 expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10281 break;
10282 case ISUP_FRENCH_VARIANT:
10283 switch (message_type) {
10284 case FRENCH_CHARGING_PULSE:
10285 offset += dissect_french_isup_charging_pulse_message(parameter_tvb, isup_tree);
10286 opt_part_possible = true;
10287 break;
10288 case FRENCH_CHARGING_ACK:
10289 opt_part_possible = true;
10290 break;
10291 default:
10292 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10293 if (bufferlength != 0)
10294 expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10295 break;
10296 }
10297 break;
10298 case ISUP_ISRAELI_VARIANT:
10299 switch (message_type) {
10300 case ISRAELI_BACKWARD_CHARGING:
10301 offset += dissect_israeli_backward_charging_message(parameter_tvb, isup_tree);
10302 break;
10303 case ISRAELI_TRAFFIC_CHANGE:
10304 offset += dissect_israeli_traffic_change_message(parameter_tvb, isup_tree);
10305 break;
10306 case ISRAELI_CHARGE_ACK:
10307 /* No parameters */
10308 break;
10309 default:
10310 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10311 if (bufferlength != 0)
10312 expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10313 break;
10314 }
10315 break;
10316 case ISUP_RUSSIAN_VARIANT:
10317 switch (message_type) {
10318 case RUSSIAN_CLEAR_CALLING_LINE:
10319 /* no dissector necessary since no mandatory parameters included */
10320 break;
10321 case RUSSIAN_RINGING:
10322 /* no dissector necessary since no mandatory parameters included */
10323 opt_part_possible = true;
10324 break;
10325 default:
10326 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10327 if (bufferlength != 0)
10328 expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10329 break;
10330 }
10331 break;
10332 case ISUP_JAPAN_VARIANT:
10333 /* Fall through */
10334 case ISUP_JAPAN_TTC_VARIANT:
10335 switch (message_type) {
10336 case MESSAGE_TYPE_JAPAN_CHARG_INF:
10337 offset += dissect_japan_chg_inf(parameter_tvb, pinfo, isup_tree);
10338 opt_part_possible = true;
10339 break;
10340 default:
10341 bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10342 if (bufferlength != 0)
10343 expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10344 break;
10345 }
10346 break;
10347 } /* switch (itu_isup_variant) */
10348 break;
10349 }
10350
10351 /* extract pointer to start of optional part (if any) */
10352 if (opt_part_possible == true) {
10353 opt_parameter_pointer = tvb_get_uint8(message_tvb, offset);
10354 if (opt_parameter_pointer > 0) {
10355 proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
10356 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
10357 "Pointer to start of optional part: %u", opt_parameter_pointer);
10358 offset += opt_parameter_pointer;
10359 optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
10360 dissect_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
10361 }
10362 else
10363 proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
10364 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
10365 "No optional parameter present (Pointer: %u)", opt_parameter_pointer);
10366 }
10367 else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
10368 expert_add_info(pinfo, type_item, &ei_isup_message_type_no_optional_parameters);
10369
10370 /* if there are calling/called number, we'll get them for the tap */
10371 tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(pinfo->pool, "");
10372 tap_rec->called_number = tap_called_number;
10373 tap_rec->cause_value = tap_cause_value;
10374 tap_queue_packet(isup_tap, pinfo, tap_rec);
10375
10376 decrement_dissection_depth(pinfo);
10377 }
10378 // NOLINTEND(misc-no-recursion)
10379
10380 /* ------------------------------------------------------------------ */
10381 static int
10382 dissect_isup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
10383 {
10384
10385 /* Set up structures needed to add the protocol subtree and manage it */
10386 proto_item *ti;
10387 proto_tree *isup_tree = NULL;
10388 tvbuff_t *message_tvb;
10389 uint16_t cic;
10390 uint8_t message_type;
10391 uint8_t itu_isup_variant = g_isup_variant;
10392 value_string_ext *used_value_string_ext;
10393
10394 /* Make entries in Protocol column and Info column on summary display */
10395 /* dissect CIC in main dissector since pass-along message type carrying complete IUSP message w/o CIC needs
10396 * recursive message dissector call
10397 */
10398 /* Extract message type field */
10399 message_type = tvb_get_uint8(tvb, CIC_OFFSET + CIC_LENGTH);
10400
10401 switch (mtp3_standard) {
10402 case ANSI_STANDARD:
10403 isup_standard = ANSI_STANDARD;
10404 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(ANSI)");
10405 cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x3FFF; /*since upper 2 bits spare */
10406 if (isup_show_cic_in_info) {
10407 col_add_fstr(pinfo->cinfo, COL_INFO,
10408 "%s (CIC %u) ",
10409 val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"),
10410 cic);
10411 } else {
10412 col_add_fstr(pinfo->cinfo, COL_INFO, "%s ",
10413 val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"));
10414 }
10415 if (tree) {
10416 ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10417 isup_tree = proto_item_add_subtree(ti, ett_isup);
10418 proto_tree_add_uint(isup_tree, hf_isup_cic, tvb, CIC_OFFSET, CIC_LENGTH, cic);
10419 }
10420 conversation_set_elements_by_id(pinfo, CONVERSATION_ISUP, cic);
10421 message_tvb = tvb_new_subset_remaining(tvb, CIC_LENGTH);
10422 dissect_ansi_isup_message(message_tvb, pinfo, isup_tree, ISUP_ITU_STANDARD_VARIANT, cic);
10423 break;
10424 default:
10425 isup_standard = ITU_STANDARD;
10426 /* ITU, China, and Japan; yes, J7's CICs are a different size */
10427 cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x0FFF; /*since upper 4 bits spare */
10428 switch (itu_isup_variant) {
10429 case ISUP_FRENCH_VARIANT:
10430 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(French)");
10431 used_value_string_ext = &french_isup_message_type_value_acro_ext;
10432 break;
10433 case ISUP_ISRAELI_VARIANT:
10434 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Israeli)");
10435 used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
10436 break;
10437 case ISUP_RUSSIAN_VARIANT:
10438 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Russian)");
10439 used_value_string_ext = &russian_isup_message_type_value_acro_ext;
10440 break;
10441 case ISUP_JAPAN_VARIANT:
10442 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Japan)");
10443 used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10444 break;
10445 case ISUP_JAPAN_TTC_VARIANT:
10446 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Japan TTC)");
10447 used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10448 cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x1FFF; /*since upper 3 bits spare */
10449 break;
10450 default:
10451 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(ITU)");
10452 used_value_string_ext = &isup_message_type_value_acro_ext;
10453 break;
10454 }
10455 if (isup_show_cic_in_info) {
10456 col_add_fstr(pinfo->cinfo, COL_INFO,
10457 "%s (CIC %u) ",
10458 val_to_str_ext_const(message_type, used_value_string_ext, "reserved"),
10459 cic);
10460 } else {
10461 col_add_fstr(pinfo->cinfo, COL_INFO, "%s ",
10462 val_to_str_ext_const(message_type, used_value_string_ext, "reserved"));
10463 }
10464 if (tree) {
10465 ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10466 isup_tree = proto_item_add_subtree(ti, ett_isup);
10467 proto_tree_add_uint(isup_tree, hf_isup_cic, tvb, CIC_OFFSET, CIC_LENGTH, cic);
10468 }
10469 conversation_set_elements_by_id(pinfo, CONVERSATION_ISUP, cic);
10470 message_tvb = tvb_new_subset_remaining(tvb, CIC_LENGTH);
10471 dissect_isup_message(message_tvb, pinfo, isup_tree, itu_isup_variant, cic);
10472 }
10473 return tvb_captured_length(tvb);
10474 }
10475
10476 /* ------------------------------------------------------------------ */
10477 static int
10478 dissect_bicc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
10479 {
10480
10481 /* Set up structures needed to add the protocol subtree and manage it */
10482 proto_item *ti;
10483 proto_tree *bicc_tree = NULL;
10484 tvbuff_t *message_tvb;
10485 uint32_t bicc_cic;
10486 uint8_t message_type;
10487 uint8_t itu_isup_variant = g_isup_variant;
10488 value_string_ext *used_value_string_ext;
10489
10490 /*circuit_t *circuit;*/
10491
10492 /* Make entries in Protocol column and Info column on summary display */
10493 switch (itu_isup_variant) {
10494 case ISUP_FRENCH_VARIANT:
10495 col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(French)");
10496 used_value_string_ext = &french_isup_message_type_value_acro_ext;
10497 break;
10498 case ISUP_ISRAELI_VARIANT:
10499 col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Israeli)");
10500 used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
10501 break;
10502 case ISUP_RUSSIAN_VARIANT:
10503 col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Russian)");
10504 used_value_string_ext = &russian_isup_message_type_value_acro_ext;
10505 break;
10506 case ISUP_JAPAN_VARIANT:
10507 /* Fall through */
10508 case ISUP_JAPAN_TTC_VARIANT:
10509 col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Japan)");
10510 used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10511 break;
10512 default:
10513 col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(ITU)");
10514 used_value_string_ext = &isup_message_type_value_acro_ext;
10515 break;
10516 }
10517
10518 /* Extract message type field */
10519 message_type = tvb_get_uint8(tvb, BICC_CIC_OFFSET + BICC_CIC_LENGTH);
10520
10521 bicc_cic = tvb_get_letohl(tvb, BICC_CIC_OFFSET);
10522
10523 conversation_set_elements_by_id(pinfo, CONVERSATION_BICC, bicc_cic);
10524
10525 col_clear(pinfo->cinfo, COL_INFO);
10526 if (isup_show_cic_in_info) {
10527 col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10528 "%s (CIC %u)",
10529 val_to_str_ext_const(message_type, used_value_string_ext, "reserved"),
10530 bicc_cic);
10531 } else {
10532 col_append_sep_str(pinfo->cinfo, COL_INFO, ", ",
10533 val_to_str_ext_const(message_type, used_value_string_ext, "reserved"));
10534 }
10535 /* dissect CIC in main dissector since pass-along message type carrying complete BICC/ISUP message w/o CIC needs
10536 * recursive message dissector call
10537 */
10538 if (tree) {
10539 ti = proto_tree_add_item(tree, proto_bicc, tvb, 0, -1, ENC_NA);
10540 bicc_tree = proto_item_add_subtree(ti, ett_bicc);
10541
10542
10543 proto_tree_add_uint_format(bicc_tree, hf_bicc_cic, tvb, BICC_CIC_OFFSET, BICC_CIC_LENGTH,
10544 bicc_cic, "CIC: %u", bicc_cic);
10545 }
10546
10547 message_tvb = tvb_new_subset_remaining(tvb, BICC_CIC_LENGTH);
10548 dissect_isup_message(message_tvb, pinfo, bicc_tree, itu_isup_variant, bicc_cic);
10549 col_set_fence(pinfo->cinfo, COL_INFO);
10550 return tvb_captured_length(tvb);
10551 }
10552
10553 static int
10554 dissect_application_isup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
10555 {
10556 /* Set up structures needed to add the protocol subtree and manage it */
10557 proto_item *ti;
10558 proto_tree *isup_tree = NULL;
10559 tvbuff_t *message_tvb;
10560 uint8_t message_type;
10561 char *version, *base;
10562 uint8_t itu_isup_variant = ISUP_ITU_STANDARD_VARIANT; /* Default */
10563
10564 if (data) {
10565 media_content_info_t *content_info = (media_content_info_t *)data;
10566 if (content_info->media_str) {
10567 version = ws_find_media_type_parameter(pinfo->pool, content_info->media_str, "version");
10568 base = ws_find_media_type_parameter(pinfo->pool, content_info->media_str, "base");
10569 if ((version && g_ascii_strncasecmp(version, "ansi", 4) == 0) ||
10570 (base && g_ascii_strncasecmp(base, "ansi", 4) == 0) ||
10571 (version && g_ascii_strncasecmp(version, "gr", 2) == 0) ||
10572 (base && g_ascii_strncasecmp(base, "gr", 2) == 0)) {
10573 /*
10574 * "version" or "base" parameter begins with "ansi" or "gr", so it's
10575 * ANSI or Bellcore.
10576 */
10577 isup_standard = ANSI_STANDARD;
10578 col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(ANSI)");
10579 message_type = tvb_get_uint8(tvb, 0);
10580 /* application/ISUP has no CIC */
10581 col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10582 "ISUP:%s",
10583 val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"));
10584 if (tree) {
10585 ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10586 isup_tree = proto_item_add_subtree(ti, ett_isup);
10587 }
10588
10589 message_tvb = tvb_new_subset_remaining(tvb, 0);
10590 dissect_ansi_isup_message(message_tvb, pinfo, isup_tree, ISUP_ITU_STANDARD_VARIANT, 0);
10591 return tvb_reported_length(tvb);
10592 } else if ((version && g_ascii_strcasecmp(version, "spirou") == 0) ||
10593 (base && g_ascii_strcasecmp(base, "spirou") == 0)) {
10594 /*
10595 * "version" or "base" version is "spirou", so it's SPIROU.
10596 */
10597 isup_standard = ITU_STANDARD;
10598 itu_isup_variant = ISUP_FRENCH_VARIANT;
10599 } else {
10600 isup_standard = ITU_STANDARD;
10601 }
10602 } else {
10603 /* default to ITU */
10604 isup_standard = ITU_STANDARD;
10605 }
10606 } else {
10607 /* default to ITU */
10608 isup_standard = ITU_STANDARD;
10609 }
10610
10611
10612 /* Extract message type field */
10613 message_type = tvb_get_uint8(tvb, 0);
10614
10615 switch (itu_isup_variant) {
10616 case ISUP_ITU_STANDARD_VARIANT:
10617 /* Make entries in Protocol column and Info column on summary display */
10618 col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(ITU)");
10619
10620 /* application/ISUP has no CIC */
10621 col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10622 "ISUP:%s",
10623 val_to_str_ext_const(message_type, &isup_message_type_value_acro_ext, "reserved"));
10624 break;
10625 case ISUP_FRENCH_VARIANT:
10626 /* Make entries in Protocol column and Info column on summary display */
10627 col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(French)");
10628
10629 /* application/ISUP has no CIC */
10630 col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10631 "ISUP:%s",
10632 val_to_str_ext_const(message_type, &french_isup_message_type_value_acro_ext, "reserved"));
10633 break;
10634 #if 0
10635 /* This case can't happen unless/until we can parse the Israeli variant
10636 * out of the content type
10637 */
10638 case ISUP_ISRAELI_VARIANT:
10639 /* Make entries in Protocol column and Info column on summary display */
10640 col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(Israeli)");
10641
10642 /* application/ISUP has no CIC */
10643 col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10644 "ISUP:%s",
10645 val_to_str_ext_const(message_type, &israeli_isup_message_type_value_acro_ext, "reserved"));
10646 break;
10647 #endif
10648 default:
10649 col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10650 "ISUP: Unknown variant %d", itu_isup_variant);
10651 break;
10652 }
10653
10654 if (tree) {
10655 ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10656 isup_tree = proto_item_add_subtree(ti, ett_isup);
10657 }
10658
10659 message_tvb = tvb_new_subset_remaining(tvb, 0);
10660 dissect_isup_message(message_tvb, pinfo, isup_tree, itu_isup_variant, 0);
10661 return tvb_reported_length(tvb);
10662 }
10663 /* ---------------------------------------------------- stats tree
10664 */
10665 static int st_node_msg = -1;
10666 static int st_node_dir = -1;
10667
10668 static void
10669 msg_stats_tree_init(stats_tree *st)
10670 {
10671 st_node_msg = stats_tree_create_node(st, "Messages by Type", 0, STAT_DT_INT, true);
10672 st_node_dir = stats_tree_create_node(st, "Messages by Direction", 0, STAT_DT_INT, true);
10673 }
10674
10675 static tap_packet_status
10676 msg_stats_tree_packet(stats_tree *st, packet_info *pinfo, epan_dissect_t *edt _U_, const void *p, tap_flags_t flags _U_)
10677 {
10678 const isup_tap_rec_t *tap_rec = (const isup_tap_rec_t *)p;
10679 const char *msg;
10680 char *src, *dst, *dir;
10681 int msg_node;
10682 int dir_node;
10683 value_string_ext *used_value_string_ext;
10684
10685 switch (tap_rec->itu_isup_variant) {
10686 case ISUP_FRENCH_VARIANT:
10687 used_value_string_ext = &french_isup_message_type_value_acro_ext;
10688 break;
10689 case ISUP_ISRAELI_VARIANT:
10690 used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
10691 break;
10692 case ISUP_RUSSIAN_VARIANT:
10693 used_value_string_ext = &russian_isup_message_type_value_acro_ext;
10694 break;
10695 case ISUP_JAPAN_VARIANT:
10696 case ISUP_JAPAN_TTC_VARIANT:
10697 used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10698 break;
10699 default:
10700 used_value_string_ext = &isup_message_type_value_acro_ext;
10701 break;
10702 }
10703 msg = val_to_str_ext_const(tap_rec->message_type, used_value_string_ext, "reserved");
10704
10705 src = address_to_str(NULL, &pinfo->src);
10706 dst = address_to_str(NULL, &pinfo->dst);
10707 dir = wmem_strdup_printf(NULL, "%s->%s", src, dst);
10708 wmem_free(NULL, src);
10709 wmem_free(NULL, dst);
10710
10711 msg_node = tick_stat_node(st, msg, st_node_msg, true);
10712 tick_stat_node(st, dir, msg_node, false);
10713
10714 dir_node = tick_stat_node(st, dir, st_node_dir, true);
10715 tick_stat_node(st, msg, dir_node, false);
10716
10717 wmem_free(NULL, dir);
10718
10719 return TAP_PACKET_REDRAW;
10720 }
10721
10722 /*---------------------------------------------------------------------*/
10723 /* Register the protocol with Wireshark */
10724 void
10725 proto_register_isup(void)
10726 {
10727 /* Setup list of header fields See Section 1.6.1 for details*/
10728 static hf_register_info hf[] = {
10729 { &hf_isup_cic,
10730 { "CIC", "isup.cic",
10731 FT_UINT16, BASE_DEC, NULL, 0x0,
10732 NULL, HFILL }},
10733
10734 { &hf_isup_message_type,
10735 { "Message Type", "isup.message_type",
10736 FT_UINT8, BASE_DEC, NULL, 0x0,
10737 NULL, HFILL }},
10738
10739 { &hf_isup_parameter_type,
10740 { "Parameter Type", "isup.parameter_type",
10741 FT_UINT8, BASE_DEC, NULL, 0x0,
10742 NULL, HFILL }},
10743
10744 { &hf_isup_parameter_value,
10745 { "Parameter Value", "isup.parameter_value",
10746 FT_BYTES, BASE_NONE, NULL, 0x0,
10747 NULL, HFILL }},
10748
10749 { &hf_isup_mand_parameter_type,
10750 { "Mandatory Parameter", "isup.parameter_type",
10751 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_parameter_type_value_ext, 0x0,
10752 NULL, HFILL }},
10753
10754 { &hf_isup_opt_parameter_type,
10755 { "Optional Parameter", "isup.parameter_type",
10756 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_parameter_type_value_ext, 0x0,
10757 NULL, HFILL }},
10758
10759 { &hf_isup_parameter_length,
10760 { "Parameter Length", "isup.parameter_length",
10761 FT_UINT8, BASE_DEC, NULL, 0x0,
10762 NULL, HFILL }},
10763
10764 { &hf_isup_mandatory_variable_parameter_pointer,
10765 { "Pointer to Parameter", "isup.mandatory_variable_parameter_pointer",
10766 FT_UINT8, BASE_DEC, NULL, 0x0,
10767 NULL, HFILL }},
10768
10769 { &hf_isup_pointer_to_start_of_optional_part,
10770 { "Pointer to optional parameter part", "isup.optional_parameter_part_pointer",
10771 FT_UINT8, BASE_DEC, NULL, 0x0,
10772 NULL, HFILL }},
10773
10774 { &hf_isup_satellite_indicator,
10775 { "Satellite Indicator", "isup.satellite_indicator",
10776 FT_UINT8, BASE_HEX, VALS(isup_satellite_ind_value), BA_8BIT_MASK,
10777 NULL, HFILL }},
10778
10779 { &hf_isup_continuity_check_indicator,
10780 { "Continuity Check Indicator", "isup.continuity_check_indicator",
10781 FT_UINT8, BASE_HEX, VALS(isup_continuity_check_ind_value), DC_8BIT_MASK,
10782 NULL, HFILL }},
10783
10784 { &hf_isup_echo_control_device_indicator,
10785 { "Echo Control Device Indicator", "isup.echo_control_device_indicator",
10786 FT_BOOLEAN, 8, TFS(&isup_echo_control_device_ind_value), E_8BIT_MASK,
10787 NULL, HFILL }},
10788
10789 { &hf_isup_forw_call_natnl_inatnl_call_indicator,
10790 { "National/international call indicator", "isup.forw_call_natnl_inatnl_call_indicator",
10791 FT_BOOLEAN, 16, TFS(&isup_natnl_inatnl_call_ind_value), A_16BIT_MASK,
10792 NULL, HFILL }},
10793
10794 { &hf_isup_forw_call_end_to_end_method_indicator,
10795 { "End-to-end method indicator", "isup.forw_call_end_to_end_method_indicator",
10796 FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), CB_16BIT_MASK,
10797 NULL, HFILL }},
10798
10799 { &hf_isup_forw_call_interworking_indicator,
10800 { "Interworking indicator", "isup.forw_call_interworking_indicator",
10801 FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), D_16BIT_MASK,
10802 NULL, HFILL }},
10803
10804 { &hf_isup_forw_call_end_to_end_info_indicator,
10805 { "End-to-end information indicator", "isup.forw_call_end_to_end_information_indicator",
10806 FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), E_16BIT_MASK,
10807 NULL, HFILL }},
10808
10809 { &hf_isup_forw_call_isdn_user_part_indicator,
10810 { "ISDN user part indicator", "isup.forw_call_isdn_user_part_indicator",
10811 FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), F_16BIT_MASK,
10812 NULL, HFILL }},
10813
10814 { &hf_isup_forw_call_preferences_indicator,
10815 { "ISDN user part preference indicator", "isup.forw_call_preferences_indicator",
10816 FT_UINT16, BASE_HEX, VALS(isup_preferences_ind_value), HG_16BIT_MASK,
10817 NULL, HFILL }},
10818
10819 { &hf_isup_forw_call_isdn_access_indicator,
10820 { "ISDN access indicator", "isup.forw_call_isdn_access_indicator",
10821 FT_BOOLEAN, 16, TFS(&isup_ISDN_originating_access_ind_value), I_16BIT_MASK,
10822 NULL, HFILL }},
10823
10824 { &hf_isup_forw_call_sccp_method_indicator,
10825 { "SCCP method indicator", "isup.forw_call_sccp_method_indicator",
10826 FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), KJ_16BIT_MASK,
10827 NULL, HFILL }},
10828
10829 { &hf_isup_forw_call_ported_num_trans_indicator,
10830 { "Ported number translation indicator", "isup.forw_call_ported_num_trans_indicator",
10831 FT_BOOLEAN, 16, TFS(&isup_ISDN_ported_num_trans_ind_value), M_16BIT_MASK,
10832 NULL, HFILL }},
10833
10834 { &hf_isup_forw_call_qor_attempt_indicator,
10835 { "Query on Release attempt indicator", "isup.forw_call_qor_attempt_indicator",
10836 FT_BOOLEAN, 16, TFS(&isup_ISDN_qor_attempt_ind_value), N_16BIT_MASK,
10837 NULL, HFILL }},
10838
10839 { &hf_isup_calling_partys_category,
10840 { "Calling Party's category", "isup.calling_partys_category",
10841 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &isup_calling_partys_category_value_ext, 0x0,
10842 NULL, HFILL }},
10843
10844 { &hf_russian_isup_calling_partys_category,
10845 { "Calling Party's category", "isup.russian.calling_partys_category",
10846 FT_UINT8, BASE_HEX, VALS(isup_calling_partys_category_value), 0x0,
10847 NULL, HFILL }},
10848
10849 { &hf_isup_transmission_medium_requirement,
10850 { "Transmission medium requirement", "isup.transmission_medium_requirement",
10851 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_transmission_medium_requirement_value_ext, 0x0,
10852 NULL, HFILL }},
10853
10854 { &hf_isup_odd_even_indicator,
10855 { "Odd/even indicator", "isup.isdn_odd_even_indicator",
10856 FT_BOOLEAN, 8, TFS(&isup_odd_even_ind_value), ISUP_ODD_EVEN_MASK,
10857 NULL, HFILL }},
10858
10859 { &hf_isup_generic_name_presentation,
10860 { "Presentation indicator", "isup.isdn_generic_name_presentation",
10861 FT_UINT8, BASE_DEC, VALS(isup_generic_name_presentation_value), BA_8BIT_MASK,
10862 NULL, HFILL }},
10863
10864 { &hf_isup_generic_name_availability,
10865 { "Availability indicator", "isup.isdn_generic_name_availability",
10866 FT_BOOLEAN, 8, TFS(&isup_generic_name_availability_value), E_8BIT_MASK,
10867 NULL, HFILL }},
10868
10869 { &hf_isup_generic_name_type,
10870 { "Type indicator", "isup.isdn_generic_name_type",
10871 FT_UINT8, BASE_DEC, VALS(isup_generic_name_type_value), HGF_8BIT_MASK,
10872 NULL, HFILL }},
10873
10874 { &hf_isup_generic_name_ia5,
10875 { "Generic Name", "isup.isdn_generic_name_ia5",
10876 FT_STRING, BASE_NONE, NULL, 0x0,
10877 NULL, HFILL }},
10878
10879 { &hf_isup_called_party_nature_of_address_indicator,
10880 { "Nature of address indicator", "isup.called_party_nature_of_address_indicator",
10881 FT_UINT8, BASE_DEC, VALS(isup_called_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
10882 NULL, HFILL }},
10883
10884 { &hf_isup_calling_party_nature_of_address_indicator,
10885 { "Nature of address indicator", "isup.calling_party_nature_of_address_indicator",
10886 FT_UINT8, BASE_DEC, VALS(isup_calling_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
10887 NULL, HFILL }},
10888
10889 { &hf_isup_charge_number_nature_of_address_indicator,
10890 { "Nature of address indicator", "isup.charge_number_nature_of_address_indicator",
10891 FT_UINT8, BASE_DEC, VALS(isup_charge_number_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
10892 NULL, HFILL }},
10893
10894 { &hf_isup_inn_indicator,
10895 { "INN indicator", "isup.inn_indicator",
10896 FT_BOOLEAN, 8, TFS(&isup_INN_ind_value), ISUP_INN_MASK,
10897 NULL, HFILL }},
10898
10899 { &hf_isup_ni_indicator,
10900 { "NI indicator", "isup.ni_indicator",
10901 FT_BOOLEAN, 8, TFS(&isup_NI_ind_value), ISUP_NI_MASK,
10902 NULL, HFILL }},
10903
10904 { &hf_isup_numbering_plan_indicator,
10905 { "Numbering plan indicator", "isup.numbering_plan_indicator",
10906 FT_UINT8, BASE_DEC, VALS(isup_numbering_plan_ind_value), ISUP_NUMBERING_PLAN_IND_MASK,
10907 NULL, HFILL }},
10908
10909 { &hf_isup_address_presentation_restricted_indicator,
10910 { "Address presentation restricted indicator", "isup.address_presentation_restricted_indicator",
10911 FT_UINT8, BASE_DEC, VALS(isup_address_presentation_restricted_ind_value), ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK,
10912 NULL, HFILL }},
10913
10914 { &hf_isup_number_different_meaning,
10915 { "Different meaning for number", "isup.number_different_meaning",
10916 FT_UINT8, BASE_HEX, NULL, 0,
10917 NULL, HFILL }},
10918
10919 { &hf_isup_screening_indicator,
10920 { "Screening indicator", "isup.screening_indicator",
10921 FT_UINT8, BASE_DEC, VALS(isup_screening_ind_value), ISUP_SCREENING_IND_MASK,
10922 NULL, HFILL }},
10923
10924 { &hf_isup_screening_indicator_enhanced,
10925 { "Screening indicator", "isup.screening_indicator_enhanced",
10926 FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), ISUP_SCREENING_IND_MASK,
10927 NULL, HFILL }},
10928
10929 { &hf_isup_called_party_odd_address_signal_digit,
10930 { "Address signal digit", "isup.called_party_odd_address_signal_digit",
10931 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_called_party_address_digit_value_ext, ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
10932 NULL, HFILL }},
10933
10934 { &hf_isup_calling_party_odd_address_signal_digit,
10935 { "Address signal digit", "isup.calling_party_odd_address_signal_digit",
10936 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_calling_party_address_digit_value_ext, ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
10937 NULL, HFILL }},
10938
10939 { &hf_isup_called_party_even_address_signal_digit,
10940 { "Address signal digit", "isup.called_party_even_address_signal_digit",
10941 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_called_party_address_digit_value_ext, ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
10942 NULL, HFILL }},
10943
10944 { &hf_isup_calling_party_even_address_signal_digit,
10945 { "Address signal digit", "isup.calling_party_even_address_signal_digit",
10946 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_calling_party_address_digit_value_ext, ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
10947 NULL, HFILL }},
10948
10949 { &hf_isup_calling_party_address_request_indicator,
10950 { "Calling party address request indicator", "isup.calling_party_address_request_indicator",
10951 FT_BOOLEAN, 16, TFS(&isup_calling_party_address_request_ind_value), A_16BIT_MASK,
10952 NULL, HFILL }},
10953
10954 { &hf_isup_info_req_holding_indicator,
10955 { "Holding indicator", "isup.info_req_holding_indicator",
10956 FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), B_16BIT_MASK,
10957 NULL, HFILL }},
10958
10959 { &hf_isup_calling_partys_category_request_indicator,
10960 { "Calling party's category request indicator", "isup.calling_partys_category_request_indicator",
10961 FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_request_ind_value), D_16BIT_MASK,
10962 NULL, HFILL }},
10963
10964 { &hf_isup_charge_information_request_indicator,
10965 { "Charge information request indicator", "isup.charge_information_request_indicator",
10966 FT_BOOLEAN, 16, TFS(&isup_charge_information_request_ind_value), E_16BIT_MASK,
10967 NULL, HFILL }},
10968
10969 { &hf_isup_malicious_call_identification_request_indicator,
10970 { "Malicious call identification request indicator (ISUP'88)", "isup.malicious_call_ident_request_indicator",
10971 FT_BOOLEAN, 16, TFS(&isup_malicious_call_identification_request_ind_value), H_16BIT_MASK,
10972 NULL, HFILL }},
10973
10974 { &hf_isup_calling_party_address_response_indicator,
10975 { "Calling party address response indicator", "isup.calling_party_address_response_indicator",
10976 FT_UINT16, BASE_HEX, VALS(isup_calling_party_address_response_ind_value), BA_16BIT_MASK,
10977 NULL, HFILL }},
10978
10979 { &hf_isup_OECD_inf_ind,
10980 { "OECD information indicator", "isup.OECD_inf_ind_vals",
10981 FT_UINT8, BASE_HEX, VALS(OECD_inf_ind_vals), BA_8BIT_MASK,
10982 NULL, HFILL }},
10983
10984 { &hf_isup_IECD_inf_ind,
10985 { "IECD information indicator", "isup.IECD_inf_ind_vals",
10986 FT_UINT8, BASE_HEX, VALS(IECD_inf_ind_vals), DC_8BIT_MASK,
10987 NULL, HFILL }},
10988
10989 { &hf_isup_OECD_req_ind,
10990 { "OECD request indicator", "isup.OECD_req_ind_vals",
10991 FT_UINT8, BASE_HEX, VALS(OECD_req_ind_vals), FE_8BIT_MASK,
10992 NULL, HFILL }},
10993
10994 { &hf_isup_IECD_req_ind,
10995 { "IECD request indicator", "isup.IECD_req_ind_vals",
10996 FT_UINT8, BASE_HEX, VALS(IECD_req_ind_vals), HG_8BIT_MASK,
10997 NULL, HFILL }},
10998
10999 { &hf_isup_hold_provided_indicator,
11000 { "Hold provided indicator", "isup.hold_provided_indicator",
11001 FT_BOOLEAN, 16, TFS(&isup_hold_provided_ind_value), C_16BIT_MASK,
11002 NULL, HFILL }},
11003
11004 { &hf_isup_calling_partys_category_response_indicator,
11005 { "Calling party's category response indicator", "isup.calling_partys_category_response_indicator",
11006 FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_response_ind_value), F_16BIT_MASK,
11007 NULL, HFILL }},
11008
11009 { &hf_isup_charge_information_response_indicator,
11010 { "Charge information response indicator", "isup.charge_information_response_indicator",
11011 FT_BOOLEAN, 16, TFS(&isup_charge_information_response_ind_value), G_16BIT_MASK,
11012 NULL, HFILL }},
11013
11014 { &hf_isup_solicited_indicator,
11015 { "Solicited indicator", "isup.solicited_indicator",
11016 FT_BOOLEAN, 16, TFS(&isup_solicited_information_ind_value), H_16BIT_MASK,
11017 NULL, HFILL }},
11018
11019 { &hf_isup_continuity_indicator,
11020 { "Continuity indicator", "isup.continuity_indicator",
11021 FT_BOOLEAN, 8, TFS(&isup_continuity_ind_value), A_8BIT_MASK,
11022 NULL, HFILL }},
11023
11024 { &hf_isup_backw_call_charge_ind,
11025 { "Charge indicator", "isup.charge_indicator",
11026 FT_UINT16, BASE_HEX, VALS(isup_charge_ind_value), BA_16BIT_MASK,
11027 NULL, HFILL }},
11028
11029 { &hf_isup_backw_call_called_partys_status_ind,
11030 { "Called party's status indicator", "isup.called_partys_status_indicator",
11031 FT_UINT16, BASE_HEX, VALS(isup_called_partys_status_ind_value), DC_16BIT_MASK,
11032 NULL, HFILL }},
11033
11034 { &hf_isup_backw_call_called_partys_category_ind,
11035 { "Called party's category indicator", "isup.called_partys_category_indicator",
11036 FT_UINT16, BASE_HEX, VALS(isup_called_partys_category_ind_value), FE_16BIT_MASK,
11037 NULL, HFILL }},
11038
11039 { &hf_isup_backw_call_end_to_end_method_ind,
11040 { "End-to-end method indicator", "isup.backw_call_end_to_end_method_indicator",
11041 FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), HG_16BIT_MASK,
11042 NULL, HFILL }},
11043
11044 { &hf_isup_backw_call_interworking_ind,
11045 { "Interworking indicator", "isup.backw_call_interworking_indicator",
11046 FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), I_16BIT_MASK,
11047 NULL, HFILL }},
11048
11049 { &hf_isup_backw_call_end_to_end_info_ind,
11050 { "End-to-end information indicator", "isup.backw_call_end_to_end_information_indicator",
11051 FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), J_16BIT_MASK,
11052 NULL, HFILL }},
11053
11054 { &hf_isup_backw_call_iam_seg_ind,
11055 { "IAM segmentation indicator", "isup.backw_call_iam_seg_ind",
11056 FT_BOOLEAN, 16, TFS(&ansi_isup_iam_seg_ind_value), J_16BIT_MASK,
11057 NULL, HFILL } },
11058
11059 { &hf_isup_backw_call_isdn_user_part_ind,
11060 { "ISDN user part indicator", "isup.backw_call_isdn_user_part_indicator",
11061 FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), K_16BIT_MASK,
11062 NULL, HFILL }},
11063
11064 { &hf_isup_backw_call_holding_ind,
11065 { "Holding indicator", "isup.backw_call_holding_indicator",
11066 FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), L_16BIT_MASK,
11067 NULL, HFILL }},
11068
11069 { &hf_isup_backw_call_isdn_access_ind,
11070 { "ISDN access indicator", "isup.backw_call_isdn_access_indicator",
11071 FT_BOOLEAN, 16, TFS(&isup_ISDN_terminating_access_ind_value), M_16BIT_MASK,
11072 NULL, HFILL }},
11073
11074 { &hf_isup_backw_call_echo_control_device_ind,
11075 { "Echo Control Device Indicator", "isup.backw_call_echo_control_device_indicator",
11076 FT_BOOLEAN, 16, TFS(&isup_echo_control_device_ind_value), N_16BIT_MASK,
11077 NULL, HFILL }},
11078
11079 { &hf_isup_backw_call_sccp_method_ind,
11080 { "SCCP method indicator", "isup.backw_call_sccp_method_indicator",
11081 FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), PO_16BIT_MASK,
11082 NULL, HFILL }},
11083
11084 { &hf_isup_cause_indicator,
11085 { "Cause indicator", "isup.cause_indicator",
11086 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &q850_cause_code_vals_ext, 0x7f,
11087 NULL, HFILL }},
11088
11089 { &hf_ansi_isup_cause_indicator,
11090 { "Cause indicator", "ansi_isup.cause_indicator",
11091 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_cause_code_vals_ext, 0x7f,
11092 NULL, HFILL }},
11093
11094 { &hf_isup_suspend_resume_indicator,
11095 { "Suspend/Resume indicator", "isup.suspend_resume_indicator",
11096 FT_BOOLEAN, 8, TFS(&isup_suspend_resume_ind_value), A_8BIT_MASK,
11097 NULL, HFILL }},
11098
11099 { &hf_isup_range_indicator,
11100 { "Range indicator", "isup.range_indicator",
11101 FT_UINT8, BASE_DEC, NULL , 0x0,
11102 NULL, HFILL }},
11103
11104 { &hf_isup_bitbucket,
11105 { "Bit", "isup.bitbucket",
11106 FT_UINT8, BASE_DEC, NULL , 0x0,
11107 NULL, HFILL }},
11108
11109 { &hf_isup_cgs_message_type,
11110 { "Circuit group supervision message type", "isup.cgs_message_type",
11111 FT_UINT8, BASE_DEC, VALS(isup_cgs_message_type_value), BA_8BIT_MASK,
11112 NULL, HFILL }},
11113
11114 { &hf_isup_mtc_blocking_state1,
11115 { "Maintenance blocking state", "isup.mtc_blocking_state",
11116 FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DC00_value), BA_8BIT_MASK,
11117 NULL, HFILL }},
11118
11119 { &hf_isup_mtc_blocking_state2,
11120 { "Maintenance blocking state", "isup.mtc_blocking_state",
11121 FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DCnot00_value), BA_8BIT_MASK,
11122 NULL, HFILL }},
11123
11124 { &hf_isup_call_proc_state,
11125 { "Call processing state", "isup.call_processing_state",
11126 FT_UINT8, BASE_DEC, VALS(isup_call_processing_state_value), DC_8BIT_MASK,
11127 NULL, HFILL }},
11128
11129 { &hf_isup_hw_blocking_state,
11130 { "HW blocking state", "isup.hw_blocking_state",
11131 FT_UINT8, BASE_DEC, VALS(isup_HW_blocking_state_value), FE_8BIT_MASK,
11132 NULL, HFILL }},
11133
11134 { &hf_isup_event_ind,
11135 { "Event indicator", "isup.event_ind",
11136 FT_UINT8, BASE_DEC, VALS(isup_event_ind_value), GFEDCBA_8BIT_MASK,
11137 NULL, HFILL }},
11138
11139 { &hf_isup_event_presentation_restricted_ind,
11140 { "Event presentation restricted indicator", "isup.event_presentation_restr_ind",
11141 FT_BOOLEAN, 8, TFS(&isup_event_presentation_restricted_ind_value), H_8BIT_MASK,
11142 NULL, HFILL }},
11143
11144 { &hf_isup_cug_call_ind,
11145 { "Closed user group call indicator", "isup.clg_call_ind",
11146 FT_UINT8, BASE_DEC, VALS(isup_CUG_call_ind_value), BA_8BIT_MASK,
11147 NULL, HFILL }},
11148
11149 { &hf_isup_simple_segmentation_ind,
11150 { "Simple segmentation indicator", "isup.simple_segmentation_ind",
11151 FT_BOOLEAN, 8, TFS(&isup_simple_segmentation_ind_value), C_8BIT_MASK,
11152 NULL, HFILL }},
11153
11154 { &hf_isup_connected_line_identity_request_ind,
11155 { "Connected line identity request indicator", "isup.connected_line_identity_request_ind",
11156 FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), H_8BIT_MASK,
11157 NULL, HFILL }},
11158
11159 { &hf_isup_redirecting_ind,
11160 { "Redirection indicator", "isup.redirecting_ind",
11161 FT_UINT16, BASE_DEC, VALS(isup_redirecting_ind_value), CBA_16BIT_MASK,
11162 NULL, HFILL }},
11163
11164 { &hf_isup_original_redirection_reason,
11165 { "Original redirection reason", "isup.original_redirection_reason",
11166 FT_UINT16, BASE_DEC, VALS(isup_original_redirection_reason_value), HGFE_16BIT_MASK,
11167 NULL, HFILL }},
11168
11169 { &hf_isup_redirection_counter,
11170 { "Redirection counter", "isup.redirection_counter",
11171 FT_UINT16, BASE_DEC, NULL, KJI_16BIT_MASK,
11172 NULL, HFILL }},
11173
11174 { &hf_isup_redirection_reason,
11175 { "Redirection reason", "isup.redirection_reason",
11176 FT_UINT16, BASE_DEC, VALS(isup_redirection_reason_value), PONM_16BIT_MASK,
11177 NULL, HFILL }},
11178
11179 { &hf_isup_type_of_network_identification,
11180 { "Type of network identification", "isup.type_of_network_identification",
11181 FT_UINT8, BASE_DEC, VALS(isup_type_of_network_identification_value), GFE_8BIT_MASK,
11182 NULL, HFILL }},
11183
11184 { &hf_isup_network_identification_plan,
11185 { "Network identification plan", "isup.network_identification_plan",
11186 FT_UINT8, BASE_DEC, VALS(isup_network_identification_plan_value), DCBA_8BIT_MASK,
11187 NULL, HFILL }},
11188
11189 { &hf_isup_map_type,
11190 { "Map Type", "isup.map_type",
11191 FT_UINT8, BASE_DEC, VALS(isup_map_type_value), FEDCBA_8BIT_MASK,
11192 NULL, HFILL }},
11193
11194 { &hf_isup_automatic_congestion_level,
11195 { "Automatic congestion level", "isup.automatic_congestion_level",
11196 FT_UINT8, BASE_DEC, VALS(isup_auto_congestion_level_value), 0x0,
11197 NULL, HFILL }},
11198
11199 { &hf_isup_inband_information_ind,
11200 { "In-band information indicator", "isup.inband_information_ind",
11201 FT_BOOLEAN, 8, TFS(&isup_inband_information_ind_value), A_8BIT_MASK,
11202 NULL, HFILL }},
11203
11204 { &hf_isup_call_diversion_may_occur_ind,
11205 { "Call diversion may occur indicator", "isup.call_diversion_may_occur_ind",
11206 FT_BOOLEAN, 8, TFS(&isup_call_diversion_may_occur_ind_value), B_8BIT_MASK,
11207 NULL, HFILL }},
11208
11209 { &hf_isup_mlpp_user_ind,
11210 { "MLPP user indicator", "isup.mlpp_user",
11211 FT_BOOLEAN, 8, TFS(&isup_MLPP_user_ind_value), D_8BIT_MASK,
11212 NULL, HFILL }},
11213
11214 { &hf_isup_UUI_type,
11215 { "User-to-User indicator type", "isup.UUI_type",
11216 FT_BOOLEAN, 8, TFS(&tfs_response_request), A_8BIT_MASK,
11217 NULL, HFILL }},
11218
11219 { &hf_isup_UUI_req_service1,
11220 { "User-to-User indicator request service 1", "isup.UUI_req_service1",
11221 FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), CB_8BIT_MASK,
11222 NULL, HFILL }},
11223
11224 { &hf_isup_UUI_req_service2,
11225 { "User-to-User indicator request service 2", "isup.UUI_req_service2",
11226 FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), ED_8BIT_MASK,
11227 NULL, HFILL }},
11228
11229 { &hf_isup_UUI_req_service3,
11230 { "User-to-User indicator request service 3", "isup.UUI_req_service3",
11231 FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), GF_8BIT_MASK,
11232 NULL, HFILL }},
11233
11234 { &hf_isup_UUI_res_service1,
11235 { "User-to-User indicator response service 1", "isup.UUI_res_service1",
11236 FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), CB_8BIT_MASK,
11237 NULL, HFILL }},
11238
11239 { &hf_isup_UUI_res_service2,
11240 { "User-to-User indicator response service 2", "isup.UUI_res_service2",
11241 FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), ED_8BIT_MASK,
11242 NULL, HFILL }},
11243
11244 { &hf_isup_UUI_res_service3,
11245 { "User-to-User response service 3", "isup.UUI_res_service3",
11246 FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), GF_8BIT_MASK,
11247 NULL, HFILL }},
11248
11249 { &hf_isup_notification_indicator,
11250 { "Notification indicator", "isup.notification_indicator",
11251 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &q763_generic_notification_indicator_vals_ext, 0x7f,
11252 NULL, HFILL }},
11253
11254 { &hf_isup_UUI_network_discard_ind,
11255 { "User-to-User indicator network discard indicator", "isup.UUI_network_discard_ind",
11256 FT_BOOLEAN, 8, TFS(&isup_UUI_network_discard_ind_value), H_8BIT_MASK,
11257 NULL, HFILL }},
11258
11259 { &hf_isup_access_delivery_ind,
11260 { "Access delivery indicator", "isup.access_delivery_ind",
11261 FT_BOOLEAN, 8, TFS(&isup_access_delivery_ind_value), A_8BIT_MASK,
11262 NULL, HFILL }},
11263
11264 { &hf_isup_transmission_medium_requirement_prime,
11265 { "Transmission medium requirement prime", "isup.transmission_medium_requirement_prime",
11266 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_transmission_medium_requirement_prime_value_ext, 0x0,
11267 NULL, HFILL }},
11268
11269 { &hf_isup_loop_prevention_response_ind,
11270 { "Response indicator", "isup.loop_prevention_response_ind",
11271 FT_UINT8, BASE_DEC, VALS(isup_loop_prevention_response_ind_value), CB_8BIT_MASK,
11272 NULL, HFILL }},
11273
11274 { &hf_isup_temporary_alternative_routing_ind,
11275 { "Temporary alternative routing indicator", "isup.temporary_alternative_routing_ind",
11276 FT_BOOLEAN, 8, TFS(&isup_temporary_alternative_routing_ind_value), A_8BIT_MASK,
11277 NULL, HFILL }},
11278
11279 { &hf_isup_extension_ind,
11280 { "Extension indicator", "isup.extension_ind",
11281 FT_BOOLEAN, 8, TFS(&isup_extension_ind_value), H_8BIT_MASK,
11282 NULL, HFILL }},
11283
11284 { &hf_isup_call_to_be_diverted_ind,
11285 { "Call to be diverted indicator", "isup.call_to_be_diverted_ind",
11286 FT_UINT8, BASE_DEC, VALS(isup_call_to_be_diverted_ind_value), BA_8BIT_MASK,
11287 NULL, HFILL }},
11288
11289 { &hf_isup_call_to_be_offered_ind,
11290 { "Call to be offered indicator", "isup.call_to_be_offered_ind",
11291 FT_UINT8, BASE_DEC, VALS(isup_call_to_be_offered_ind_value), BA_8BIT_MASK,
11292 NULL, HFILL }},
11293
11294 { &hf_isup_conference_acceptance_ind,
11295 { "Conference acceptance indicator", "isup.conference_acceptance_ind",
11296 FT_UINT8, BASE_DEC, VALS(isup_conference_acceptance_ind_value), BA_8BIT_MASK,
11297 NULL, HFILL }},
11298
11299 { &hf_isup_transit_at_intermediate_exchange_ind,
11300 { "Transit at intermediate exchange indicator", "isup.transit_at_intermediate_exchange_ind",
11301 FT_BOOLEAN, 8, TFS(&isup_transit_at_intermediate_exchange_ind_value), A_8BIT_MASK,
11302 NULL, HFILL }},
11303
11304 { &hf_isup_Release_call_ind,
11305 { "Release call indicator", "isup.Release_call_ind",
11306 FT_BOOLEAN, 8, TFS(&isup_Release_call_indicator_value), B_8BIT_MASK,
11307 NULL, HFILL }},
11308
11309 { &hf_isup_Send_notification_ind,
11310 { "Send notification indicator", "isup.Send_notification_ind",
11311 FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), C_8BIT_MASK,
11312 NULL, HFILL }},
11313
11314 { &hf_isup_Discard_message_ind_value,
11315 { "Discard message indicator", "isup.Discard_message_ind_value",
11316 FT_BOOLEAN, 8, TFS(&isup_Discard_message_ind_value), D_8BIT_MASK,
11317 NULL, HFILL }},
11318
11319 { &hf_isup_Discard_parameter_ind,
11320 { "Discard parameter indicator", "isup.Discard_parameter_ind",
11321 FT_BOOLEAN, 8, TFS(&isup_Discard_parameter_ind_value), E_8BIT_MASK,
11322 NULL, HFILL }},
11323
11324 { &hf_isup_Pass_on_not_possible_indicator,
11325 { "Pass on not possible indicator", "isup.Pass_on_not_possible_ind",
11326 FT_UINT8, BASE_HEX, VALS(isup_Pass_on_not_possible_indicator_vals), GF_8BIT_MASK,
11327 NULL, HFILL }},
11328
11329 { &hf_isup_pass_on_not_possible_indicator2,
11330 { "Pass on not possible indicator", "isup.Pass_on_not_possible_val",
11331 FT_BOOLEAN, 8, TFS(&isup_pass_on_not_possible_indicator_value), E_8BIT_MASK,
11332 NULL, HFILL }},
11333
11334 { &hf_isup_Broadband_narrowband_interworking_ind,
11335 { "Broadband narrowband interworking indicator Bits JF", "isup.broadband_narrowband_interworking_ind",
11336 FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals), BA_8BIT_MASK,
11337 NULL, HFILL }},
11338
11339 { &hf_isup_Broadband_narrowband_interworking_ind2,
11340 { "Broadband narrowband interworking indicator Bits GF", "isup.broadband_narrowband_interworking_ind2",
11341 FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals), GF_8BIT_MASK,
11342 NULL, HFILL }},
11343
11344 { &hf_isup_app_cont_ident,
11345 { "Application context identifier", "isup.app_context_identifier",
11346 FT_UINT16, BASE_DEC, VALS(isup_application_transport_parameter_value), GFEDCBA_8BIT_MASK,
11347 NULL, HFILL }},
11348
11349 { &hf_isup_app_Release_call_ind,
11350 { "Release call indicator (RCI)", "isup.app_Release_call_indicator",
11351 FT_BOOLEAN, 8, TFS(&isup_Release_call_indicator_value), A_8BIT_MASK,
11352 NULL, HFILL }},
11353
11354 { &hf_isup_app_Send_notification_ind,
11355 { "Send notification indicator (SNI)", "isup.app_Send_notification_ind",
11356 FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), B_8BIT_MASK,
11357 NULL, HFILL }},
11358
11359 { &hf_isup_apm_segmentation_ind,
11360 { "APM segmentation indicator", "isup.apm_segmentation_ind",
11361 FT_UINT8, BASE_DEC, VALS(isup_APM_segmentation_ind_value), FEDCBA_8BIT_MASK,
11362 NULL, HFILL }},
11363
11364 { &hf_isup_apm_si_ind,
11365 { "Sequence indicator (SI)", "isup.APM_Sequence_ind",
11366 FT_BOOLEAN, 8, TFS(&isup_Sequence_ind_value), G_8BIT_MASK,
11367 NULL, HFILL }},
11368
11369 { &hf_isup_orig_addr_len,
11370 { "Originating Address length", "isup.orig_addr_len",
11371 FT_UINT8, BASE_DEC, NULL, 0x0,
11372 NULL, HFILL }},
11373
11374 { &hf_isup_dest_addr_len,
11375 { "Destination Address length", "isup.dest_addr_len",
11376 FT_UINT8, BASE_DEC, NULL, 0x0,
11377 NULL, HFILL }},
11378
11379 { &hf_isup_apm_slr,
11380 { "Segmentation local reference (SLR)", "isup.APM_slr",
11381 FT_UINT8, BASE_DEC, NULL, GFEDCBA_8BIT_MASK,
11382 NULL, HFILL }},
11383 { &hf_isup_cause_location,
11384 { "Cause location", "isup.cause_location",
11385 FT_UINT8, BASE_DEC|BASE_EXT_STRING, &q931_cause_location_vals_ext, 0x0f,
11386 NULL, HFILL }},
11387
11388 { &hf_ansi_isup_coding_standard,
11389 { "Coding standard", "ansi_isup.coding_standard",
11390 FT_UINT8, BASE_HEX, VALS(ansi_isup_coding_standard_vals), 0x60,
11391 NULL, HFILL }},
11392 { &hf_ansi_isup_spare_b7,
11393 { "Spare", "ansi_isup.spare.b7",
11394 FT_UINT8, BASE_DEC, NULL, 0x80,
11395 NULL, HFILL }},
11396 { &hf_ansi_isup_type_of_nw_id,
11397 { "Type of network identification", "ansi_isup.type_of_nw_id",
11398 FT_UINT8, BASE_DEC, VALS(ansi_isup_type_of_nw_id_vals), 0x70,
11399 NULL, HFILL } },
11400 { &hf_ansi_isup_nw_id_plan,
11401 { "Network identification plan", "ansi_isup.nw_id_plan",
11402 FT_UINT8, BASE_DEC, VALS(ansi_isup_nw_id_plan_vals), 0x0f,
11403 NULL, HFILL } },
11404 { &hf_ansi_isup_tns_nw_id_plan,
11405 { "Network identification plan", "ansi_isup.tns.nw_id_plan",
11406 FT_UINT8, BASE_DEC, VALS(ansi_isup_tns_nw_id_plan_vals), 0x0f,
11407 NULL, HFILL } },
11408 { &hf_ansi_isup_nw_id,
11409 { "Network id", "ansi_isup.nw_id",
11410 FT_STRING, BASE_NONE, NULL, 0x0,
11411 NULL, HFILL } },
11412 { &hf_ansi_isup_circuit_code,
11413 { "Circuit code", "ansi_isup.circuit_code",
11414 FT_UINT8, BASE_DEC, NULL, 0xf0,
11415 NULL, HFILL } },
11416
11417 { &hf_bat_ase_identifier,
11418 { "BAT ASE Identifiers", "bicc.bat_ase_identifier",
11419 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_list_of_Identifiers_vals_ext, 0x0,
11420 NULL, HFILL }},
11421
11422 { &hf_length_indicator,
11423 { "BAT ASE Element length indicator", "bicc.bat_ase_length_indicator",
11424 FT_UINT16, BASE_DEC, NULL, 0x0,
11425 NULL, HFILL }},
11426
11427 { &hf_Action_Indicator,
11428 { "BAT ASE action indicator field", "bicc.bat_ase_bat_ase_action_indicator_field",
11429 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_action_indicator_field_vals_ext, 0x00,
11430 NULL, HFILL }},
11431
11432 { &hf_Instruction_ind_for_general_action,
11433 { "BAT ASE Instruction indicator for general action", "bicc.bat_ase_Instruction_ind_for_general_action",
11434 FT_UINT8, BASE_HEX, VALS(Instruction_indicator_for_general_action_vals), 0x03,
11435 NULL, HFILL }},
11436
11437 { &hf_Send_notification_ind_for_general_action,
11438 { "Send notification indicator for general action", "bicc.bat_ase_Send_notification_ind_for_general_action",
11439 FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), 0x04,
11440 NULL, HFILL }},
11441
11442 { &hf_Instruction_ind_for_pass_on_not_possible,
11443 { "Instruction ind for pass-on not possible", "bicc.bat_ase_Instruction_ind_for_pass_on_not_possible",
11444 FT_UINT8, BASE_HEX, VALS(Instruction_indicator_for_pass_on_not_possible_vals), 0x30,
11445 NULL, HFILL }},
11446
11447 { &hf_Send_notification_ind_for_pass_on_not_possible,
11448 { "Send notification indication for pass-on not possible", "bicc.bat_ase_Send_notification_ind_for_pass_on_not_possible",
11449 FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), 0x40,
11450 NULL, HFILL }},
11451
11452 { &hf_BCTP_Version_Indicator,
11453 { "BCTP Version Indicator", "bicc.bat_ase_BCTP_Version_Indicator",
11454 FT_UINT8, BASE_DEC, NULL, 0x1f,
11455 NULL, HFILL }},
11456
11457 { &hf_BVEI,
11458 { "BVEI", "bicc.bat_ase_BCTP_BVEI",
11459 FT_BOOLEAN, 8, TFS(&BCTP_BVEI_value), 0x40,
11460 NULL, HFILL }},
11461
11462 { &hf_Tunnelled_Protocol_Indicator,
11463 { "Tunnelled Protocol Indicator", "bicc.bat_ase_BCTP_Tunnelled_Protocol_Indicator",
11464 FT_UINT8, BASE_DEC, VALS(BCTP_Tunnelled_Protocol_Indicator_vals), 0x3f,
11465 NULL, HFILL }},
11466
11467 { &hf_TPEI,
11468 { "TPEI", "bicc.bat_ase_BCTP_tpei",
11469 FT_BOOLEAN, 8, TFS(&BCTP_TPEI_value), 0x40,
11470 NULL, HFILL }},
11471
11472 { &hf_bncid,
11473 { "Backbone Network Connection Identifier (BNCId)", "bat_ase.bncid",
11474 FT_UINT32, BASE_HEX, NULL, 0x0,
11475 NULL, HFILL }},
11476
11477 { &hf_bat_ase_biwfa,
11478 { "Interworking Function Address(X.213 NSAP encoded)", "bat_ase.biwfa",
11479 FT_BYTES, BASE_NONE, NULL, 0x0,
11480 NULL, HFILL }},
11481
11482 { &hf_afi,
11483 { "X.213 Address Format Information (AFI)", "x213.afi",
11484 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &x213_afi_value_ext, 0x0,
11485 NULL, HFILL }},
11486
11487 { &hf_bicc_nsap_dsp,
11488 { "X.213 Address Format Information (DSP)", "x213.dsp",
11489 FT_BYTES, BASE_NONE, NULL, 0x0,
11490 NULL, HFILL }},
11491
11492 { &hf_bicc_nsap_dsp_length,
11493 { "DSP Length", "x213.dsp_length",
11494 FT_UINT32, BASE_DEC, NULL, 0x0,
11495 NULL, HFILL }},
11496
11497 { &hf_characteristics,
11498 { "Backbone network connection characteristics", "bat_ase.char",
11499 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bearer_network_connection_characteristics_vals_ext, 0x0,
11500 NULL, HFILL }},
11501
11502 { &hf_Organization_Identifier,
11503 { "Organization identifier subfield", "bat_ase.organization_identifier_subfield",
11504 FT_UINT8, BASE_DEC, VALS(bat_ase_organization_identifier_subfield_vals), 0x0,
11505 NULL, HFILL }},
11506
11507 { &hf_codec_type,
11508 { "ITU-T codec type subfield", "bat_ase.ITU_T_codec_type_subfield",
11509 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &ITU_T_codec_type_subfield_vals_ext, 0x0,
11510 NULL, HFILL }},
11511
11512 { &hf_etsi_codec_type,
11513 { "ETSI codec type subfield", "bat_ase.ETSI_codec_type_subfield",
11514 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &ETSI_codec_type_subfield_vals_ext, 0x0,
11515 NULL, HFILL }},
11516
11517 { &hf_active_code_set,
11518 { "Active Code Set", "bat_ase.acs",
11519 FT_UINT8, BASE_HEX, NULL, 0x0,
11520 NULL, HFILL }},
11521
11522 { &hf_active_code_set_12_2,
11523 { "12.2 kbps rate", "bat_ase.acs.12_2",
11524 FT_UINT8, BASE_HEX, NULL, 0x80,
11525 NULL, HFILL }},
11526
11527 { &hf_active_code_set_10_2,
11528 { "10.2 kbps rate", "bat_ase.acs.10_2",
11529 FT_UINT8, BASE_HEX, NULL, 0x40,
11530 NULL, HFILL }},
11531
11532 { &hf_active_code_set_7_95,
11533 { "7.95 kbps rate", "bat_ase.acs.7_95",
11534 FT_UINT8, BASE_HEX, NULL, 0x20,
11535 NULL, HFILL }},
11536
11537 { &hf_active_code_set_7_40,
11538 { "7.40 kbps rate", "bat_ase.acs.7_40",
11539 FT_UINT8, BASE_HEX, NULL, 0x10,
11540 NULL, HFILL }},
11541
11542 { &hf_active_code_set_6_70,
11543 { "6.70 kbps rate", "bat_ase.acs.6_70",
11544 FT_UINT8, BASE_HEX, NULL, 0x08,
11545 NULL, HFILL }},
11546
11547 { &hf_active_code_set_5_90,
11548 { "5.90 kbps rate", "bat_ase.acs.5_90",
11549 FT_UINT8, BASE_HEX, NULL, 0x04,
11550 NULL, HFILL }},
11551
11552 { &hf_active_code_set_5_15,
11553 { "5.15 kbps rate", "bat_ase.acs.5_15",
11554 FT_UINT8, BASE_HEX, NULL, 0x02,
11555 NULL, HFILL }},
11556
11557 { &hf_active_code_set_4_75,
11558 { "4.75 kbps rate", "bat_ase.acs.4_75",
11559 FT_UINT8, BASE_HEX, NULL, 0x01,
11560 NULL, HFILL }},
11561
11562 { &hf_supported_code_set,
11563 { "Supported Code Set", "bat_ase.scs",
11564 FT_UINT8, BASE_HEX, NULL, 0x0,
11565 NULL, HFILL }},
11566
11567 { &hf_supported_code_set_12_2,
11568 { "12.2 kbps rate", "bat_ase.scs.12_2",
11569 FT_UINT8, BASE_HEX, NULL, 0x80,
11570 NULL, HFILL }},
11571
11572 { &hf_supported_code_set_10_2,
11573 { "10.2 kbps rate", "bat_ase.scs.10_2",
11574 FT_UINT8, BASE_HEX, NULL, 0x40,
11575 NULL, HFILL }},
11576
11577 { &hf_supported_code_set_7_95,
11578 { "7.95 kbps rate", "bat_ase.scs.7_95",
11579 FT_UINT8, BASE_HEX, NULL, 0x20,
11580 NULL, HFILL }},
11581
11582 { &hf_supported_code_set_7_40,
11583 { "7.40 kbps rate", "bat_ase.scs.7_40",
11584 FT_UINT8, BASE_HEX, NULL, 0x10,
11585 NULL, HFILL }},
11586
11587 { &hf_supported_code_set_6_70,
11588 { "6.70 kbps rate", "bat_ase.scs.6_70",
11589 FT_UINT8, BASE_HEX, NULL, 0x08,
11590 NULL, HFILL }},
11591
11592 { &hf_supported_code_set_5_90,
11593 { "5.90 kbps rate", "bat_ase.scs.5_90",
11594 FT_UINT8, BASE_HEX, NULL, 0x04,
11595 NULL, HFILL }},
11596
11597 { &hf_supported_code_set_5_15,
11598 { "5.15 kbps rate", "bat_ase.scs.5_15",
11599 FT_UINT8, BASE_HEX, NULL, 0x02,
11600 NULL, HFILL }},
11601
11602 { &hf_supported_code_set_4_75,
11603 { "4.75 kbps rate", "bat_ase.scs.4_75",
11604 FT_UINT8, BASE_HEX, NULL, 0x01,
11605 NULL, HFILL }},
11606
11607 { &hf_optimisation_mode,
11608 { "Optimisation Mode for ACS , OM", "bat_ase.optimisation_mode",
11609 FT_UINT8, BASE_HEX, VALS(optimisation_mode_vals), 0x8,
11610 NULL, HFILL }},
11611
11612 { &hf_max_codec_modes,
11613 { "Maximal number of Codec Modes, MACS", "bat_ase.macs",
11614 FT_UINT8, BASE_DEC, NULL, 0x07,
11615 NULL, HFILL }},
11616
11617
11618 { &hf_bearer_control_tunneling,
11619 { "Bearer control tunneling", "bat_ase.bearer_control_tunneling",
11620 FT_BOOLEAN, 8, TFS(&Bearer_Control_Tunnelling_ind_value), 0x01,
11621 NULL, HFILL }},
11622
11623 { &hf_BAT_ASE_Comp_Report_Reason,
11624 { "Compatibility report reason", "bat_ase.Comp_Report_Reason",
11625 FT_UINT8, BASE_HEX, VALS(BAT_ASE_Report_Reason_vals), 0x0,
11626 NULL, HFILL }},
11627
11628
11629 { &hf_BAT_ASE_Comp_Report_ident,
11630 { "Compatibility report ident", "bat_ase.Comp_Report_ident",
11631 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_list_of_Identifiers_vals_ext, 0x0,
11632 NULL, HFILL }},
11633
11634 { &hf_BAT_ASE_Comp_Report_diagnostic,
11635 { "Diagnostics", "bat_ase.Comp_Report_diagnostic",
11636 FT_UINT16, BASE_HEX, NULL, 0x0,
11637 NULL, HFILL }},
11638
11639 { &hf_Local_BCU_ID,
11640 { "Local BCU ID", "bat_ase.Local_BCU_ID",
11641 FT_UINT32, BASE_HEX, NULL, 0x0,
11642 NULL, HFILL }},
11643
11644 { &hf_late_cut_through_cap_ind,
11645 { "Late Cut-through capability indicator", "bat_ase.late_cut_through_cap_ind",
11646 FT_BOOLEAN, 8, TFS(&late_cut_through_cap_ind_value), 0x01,
11647 NULL, HFILL }},
11648
11649 { &hf_bat_ase_signal,
11650 { "Q.765.5 - Signal Type", "bat_ase.signal_type",
11651 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &BAT_ASE_Signal_Type_vals_ext, 0x0,
11652 NULL, HFILL }},
11653
11654 { &hf_bat_ase_duration,
11655 { "Duration in ms", "bat_ase.duration",
11656 FT_UINT16, BASE_DEC, NULL, 0x0,
11657 NULL, HFILL }},
11658
11659 { &hf_bat_ase_default,
11660 { "Default", "bat_ase.default",
11661 FT_BYTES, BASE_NONE, NULL, 0x0,
11662 NULL, HFILL }},
11663
11664 { &hf_bat_ase_bearer_redir_ind,
11665 { "Redirection Indicator", "bat_ase.bearer_redir_ind",
11666 FT_UINT8, BASE_HEX|BASE_EXT_STRING, &Bearer_Redirection_Indicator_vals_ext, 0x0,
11667 NULL, HFILL }},
11668
11669 { &hf_nsap_ipv4_addr,
11670 { "IWFA IPv4 Address", "nsap.ipv4_addr",
11671 FT_IPv4, BASE_NONE, NULL, 0x0,
11672 NULL, HFILL }},
11673
11674 { &hf_nsap_ipv6_addr,
11675 { "IWFA IPv6 Address", "nsap.ipv6_addr",
11676 FT_IPv6, BASE_NONE, NULL, 0x0,
11677 NULL, HFILL}},
11678
11679 { &hf_iana_icp,
11680 { "IANA ICP", "nsap.iana_icp",
11681 FT_UINT16, BASE_HEX, VALS(iana_icp_values), 0x0,
11682 NULL, HFILL }},
11683
11684 { &hf_isup_called,
11685 { "Called Party Number", "isup.called",
11686 FT_STRING, BASE_NONE, NULL, 0x0,
11687 NULL, HFILL }},
11688
11689 { &hf_isup_calling,
11690 { "Calling Party Number", "isup.calling",
11691 FT_STRING, BASE_NONE, NULL, 0x0,
11692 NULL, HFILL }},
11693
11694 { &hf_isup_redirecting,
11695 { "Redirecting Number", "isup.redirecting",
11696 FT_STRING, BASE_NONE, NULL, 0x0,
11697 NULL, HFILL }},
11698
11699 { &hf_isup_redirection_number,
11700 { "Redirection Number", "isup.redirection_number",
11701 FT_STRING, BASE_NONE, NULL, 0x0,
11702 NULL, HFILL }},
11703
11704 { &hf_isup_subsequent_number,
11705 { "Subsequent Number", "isup.subsequent_number",
11706 FT_STRING, BASE_NONE, NULL, 0x0,
11707 NULL, HFILL }},
11708
11709 { &hf_isup_connected_number,
11710 { "Connected Number", "isup.connected_number",
11711 FT_STRING, BASE_NONE, NULL, 0x0,
11712 NULL, HFILL }},
11713
11714 { &hf_isup_transit_network_selection,
11715 { "Transit Network Selection", "isup.transit_network_selection",
11716 FT_STRING, BASE_NONE, NULL, 0x0,
11717 NULL, HFILL }},
11718
11719 { &hf_isup_original_called_number,
11720 { "Original Called Number", "isup.original_called_number",
11721 FT_STRING, BASE_NONE, NULL, 0x0,
11722 NULL, HFILL }},
11723
11724 { &hf_isup_location_number,
11725 { "Location Number", "isup.location_number",
11726 FT_STRING, BASE_NONE, NULL, 0x0,
11727 NULL, HFILL }},
11728
11729 { &hf_isup_call_transfer_number,
11730 { "Call Transfer Number", "isup.call_transfer_number",
11731 FT_STRING, BASE_NONE, NULL, 0x0,
11732 NULL, HFILL }},
11733
11734 { &hf_isup_called_in_number,
11735 { "Called IN Number", "isup.called_in_number",
11736 FT_STRING, BASE_NONE, NULL, 0x0,
11737 NULL, HFILL }},
11738
11739 { &hf_isup_generic_number,
11740 { "Generic Number", "isup.generic_number",
11741 FT_STRING, BASE_NONE, NULL, 0x0,
11742 NULL, HFILL }},
11743
11744 { &hf_isup_jurisdiction,
11745 { "Jurisdiction", "isup.jurisdiction",
11746 FT_STRING, BASE_NONE, NULL, 0x0,
11747 NULL, HFILL }},
11748
11749 { &hf_isup_charge_number,
11750 { "Charge Number", "isup.charge_number",
11751 FT_STRING, BASE_NONE, NULL, 0x0,
11752 NULL, HFILL }},
11753
11754 { &hf_isup_apm_msg_fragments,
11755 { "Message fragments", "isup.apm.msg.fragments",
11756 FT_NONE, BASE_NONE, NULL, 0x00,
11757 NULL, HFILL }},
11758
11759 { &hf_isup_apm_msg_fragment,
11760 { "Message fragment", "isup.apm.msg.fragment",
11761 FT_FRAMENUM, BASE_NONE, NULL, 0x00,
11762 NULL, HFILL }},
11763
11764 { &hf_isup_apm_msg_fragment_overlap,
11765 { "Message fragment overlap", "isup.apm.msg.fragment.overlap",
11766 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11767 NULL, HFILL }},
11768
11769 { &hf_isup_apm_msg_fragment_overlap_conflicts,
11770 { "Message fragment overlapping with conflicting data", "isup.apm.msg.fragment.overlap.conflicts",
11771 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11772 NULL, HFILL }},
11773
11774 { &hf_isup_apm_msg_fragment_multiple_tails,
11775 { "Message has multiple tail fragments", "isup.apm.msg.fragment.multiple_tails",
11776 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11777 NULL, HFILL }},
11778
11779 { &hf_isup_apm_msg_fragment_too_long_fragment,
11780 { "Message fragment too long", "isup.apm.msg.fragment.too_long_fragment",
11781 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11782 NULL, HFILL }},
11783
11784 { &hf_isup_apm_msg_fragment_error,
11785 { "Message defragmentation error", "isup.apm.msg.fragment.error",
11786 FT_FRAMENUM, BASE_NONE, NULL, 0x00,
11787 NULL, HFILL }},
11788
11789 { &hf_isup_apm_msg_fragment_count,
11790 { "Message fragment count", "isup.apm.msg.fragment.count",
11791 FT_UINT32, BASE_DEC, NULL, 0x00,
11792 NULL, HFILL }},
11793
11794 { &hf_isup_apm_msg_reassembled_in,
11795 { "Reassembled in", "isup.apm.msg.reassembled.in",
11796 FT_FRAMENUM, BASE_NONE, NULL, 0x00,
11797 NULL, HFILL }},
11798
11799 { &hf_isup_apm_msg_reassembled_length,
11800 { "Reassembled ISUP length", "isup.apm.msg.reassembled.length",
11801 FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL }},
11802
11803 { &hf_isup_cvr_rsp_ind,
11804 { "CVR Response Ind", "isup.conn_rsp_ind",
11805 FT_UINT8, BASE_DEC, VALS(isup_cvr_rsp_ind_value), BA_8BIT_MASK,
11806 NULL, HFILL }},
11807
11808 { &hf_isup_cvr_cg_car_ind,
11809 { "CVR Circuit Group Carrier", "isup.cg_carrier_ind",
11810 FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_car_ind_value), BA_8BIT_MASK,
11811 NULL, HFILL }},
11812
11813 { &hf_isup_cvr_cg_double_seize,
11814 { "Double Seize Control", "isup.cg_char_ind.doubleSeize",
11815 FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_double_seize_value), DC_8BIT_MASK,
11816 NULL, HFILL }},
11817
11818 { &hf_isup_cvr_cg_alarm_car_ind,
11819 { "Alarm Carrier Indicator", "isup.cg_alarm_car_ind",
11820 FT_UINT8, BASE_HEX, VALS(isup_cvr_alarm_car_ind_value), FE_8BIT_MASK,
11821 NULL, HFILL }},
11822
11823 { &hf_isup_cvr_cont_chk_ind,
11824 { "Continuity Check Indicator", "isup.cg_alarm_cnt_chk",
11825 FT_UINT8, BASE_HEX, VALS(isup_cvr_cont_chk_ind_value), HG_8BIT_MASK,
11826 NULL, HFILL }},
11827
11828 { &hf_isup_geo_loc_presentation_restricted_ind,
11829 { "Calling Geodetic Location presentation restricted indicator", "isup.location_presentation_restr_ind",
11830 FT_UINT8, BASE_DEC, VALS(isup_location_presentation_restricted_ind_value), DC_8BIT_MASK,
11831 NULL, HFILL }},
11832
11833 { &hf_isup_geo_loc_screening_ind,
11834 { "Calling Geodetic Location screening indicator", "isup.location_screening_ind",
11835 FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), BA_8BIT_MASK, /* using previously defined screening values */
11836 NULL, HFILL }},
11837
11838 /* French ISUP parameters */
11839 { &hf_isup_french_coll_field,
11840 { "Collection field", "isup.french.coll_field",
11841 FT_UINT8, BASE_DEC, NULL, 0x0,
11842 NULL, HFILL }},
11843
11844 { &hf_isup_french_msg_num,
11845 { "Message number", "isup.french.msg_num",
11846 FT_UINT8, BASE_DEC, NULL, 0x0,
11847 NULL, HFILL }},
11848
11849 /* Israeli ISUP parameters */
11850 { &hf_isup_israeli_charging_message_indicators_current,
11851 { "Current Tariff", "isup.israeli.cmi_current",
11852 FT_UINT8, BASE_DEC, VALS(israeli_cmi_current_rate), 0x03,
11853 NULL, HFILL }},
11854
11855 { &hf_isup_israeli_charging_message_indicators_next,
11856 { "Next Tariff", "isup.israeli.cmi_next",
11857 FT_UINT8, BASE_DEC, VALS(israeli_cmi_next_rate), 0x0C,
11858 NULL, HFILL }},
11859
11860 { &hf_isup_israeli_current_rate,
11861 { "Current Rate", "isup.israeli.current_rate",
11862 FT_UINT16, BASE_DEC, NULL, 0x0,
11863 NULL, HFILL }},
11864
11865 { &hf_isup_israeli_time_indicator,
11866 { "Time Indicator", "isup.israeli.time_indicator",
11867 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &israeli_time_indicators_ext, 0x0,
11868 NULL, HFILL }},
11869
11870 { &hf_isup_israeli_next_rate,
11871 { "Next Rate", "isup.israeli.next_ratej",
11872 FT_UINT16, BASE_DEC, NULL, 0x0,
11873 NULL, HFILL }},
11874
11875 /* Japan ISUP */
11876 { &hf_japan_isup_redirect_capability,
11877 { "Redirect possible indicator", "isup.jpn.redirect_capability",
11878 FT_UINT8, BASE_DEC, VALS(isup_jpn_redirect_capabilit_vals), 0x07,
11879 NULL, HFILL }},
11880
11881 { &hf_japan_isup_redirect_counter,
11882 { "Redirect counter", "isup.jpn.redirect_counter",
11883 FT_UINT8, BASE_DEC, NULL, 0x0f,
11884 NULL, HFILL }},
11885
11886 { &hf_japan_isup_rfi_info_type,
11887 { "Information Type Tag", "isup.rfi.info_type",
11888 FT_UINT8, BASE_DEC, VALS(isup_rfi_info_type_values), 0x0,
11889 NULL, HFILL }},
11890
11891 { &hf_japan_isup_rfi_info_len,
11892 { "Length", "isup.rfi.info_len",
11893 FT_UINT8, BASE_DEC, NULL, 0x0,
11894 NULL, HFILL }},
11895
11896 { &hf_japan_isup_perf_redir_reason,
11897 { "Performing redirect reason", "isup.rfi.perf_redir_reason",
11898 FT_UINT8, BASE_DEC, VALS(perf_redir_reason_vals), 0x7f,
11899 NULL, HFILL }},
11900
11901 { &hf_japan_isup_redir_pos_ind,
11902 { "Redirect possible indicator at performing exchange", "isup.rfi.redir_pos_ind",
11903 FT_UINT8, BASE_DEC, VALS(redir_pos_ind_vals), 0x07,
11904 NULL, HFILL }},
11905
11906 { &hf_japan_isup_emerg_call_type,
11907 { "Emergency Call Type", "isup.jpn.emerg_call_type",
11908 FT_UINT8, BASE_DEC, VALS(japan_isup_emerg_call_type_vals), 0x03,
11909 NULL, HFILL }},
11910
11911 { &hf_japan_isup_hold_at_emerg_call_disc_ind,
11912 { "Hold at emergency Call Disconnection Indicators", "isup.jpn.hold_at_emerg_call_disc_ind",
11913 FT_UINT16, BASE_DEC, VALS(hold_at_emerg_call_disc_ind_vals), 0x0300,
11914 NULL, HFILL }},
11915
11916 /* Value string values the same as perf_redir_reason_vals */
11917 { &hf_japan_isup_inv_redir_reason,
11918 { "Invoking redirect reason", "isup.rfi.inv_redir_reason",
11919 FT_UINT8, BASE_DEC, VALS(perf_redir_reason_vals), 0x7f,
11920 NULL, HFILL }},
11921
11922 { &hf_japan_isup_bwd_info_type,
11923 { "Information Type Tag", "isup.jpn.bwd_info_type",
11924 FT_UINT8, BASE_DEC, VALS(japan_isup_bwd_info_type_vals), 0x0,
11925 NULL, HFILL }},
11926
11927 { &hf_japan_isup_tag_len,
11928 { "Length", "isup.jpn.tag_len",
11929 FT_UINT8, BASE_DEC, NULL, 0x0,
11930 NULL, HFILL }},
11931
11932 { &hf_japan_isup_add_user_cat_type,
11933 { "Type of Additional User/Service Information", "isup.jpn.add_user_cat_type",
11934 FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(jpn_isup_add_user_cat_type_vals), 0x0,
11935 NULL, HFILL }},
11936
11937 { &hf_japan_isup_type_1_add_fixed_serv_inf,
11938 { "Type 1 of additional fixed service information", "isup.jpn.type_1_add_fixed_serv_inf",
11939 FT_UINT8, BASE_DEC, VALS(jpn_isup_type_1_add_fixed_serv_inf_vals), 0x0,
11940 NULL, HFILL }},
11941
11942 { &hf_japan_isup_type_1_add_mobile_serv_inf,
11943 { "Type 1 of additional mobile service information", "isup.jpn.type_1_add_mobile_serv_inf",
11944 FT_UINT8, BASE_DEC, VALS(jpn_isup_type_1_add_mobile_serv_inf_vals), 0x0,
11945 NULL, HFILL }},
11946
11947 { &hf_japan_isup_type_2_add_mobile_serv_inf,
11948 { "Type 2 of additional mobile service information (Communication Method)", "isup.jpn.type_2_add_mobile_serv_inf",
11949 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &jpn_isup_type_2_add_mobile_serv_inf_vals_ext, 0x0,
11950 NULL, HFILL }},
11951
11952 { &hf_japan_isup_type_3_add_mobile_serv_inf,
11953 { "Type 3 of additional mobile service information (Charging Method)", "isup.jpn.type_3_add_mobile_serv_inf",
11954 FT_UINT8, BASE_DEC, NULL, 0x0,
11955 NULL, HFILL }},
11956
11957 { &hf_japan_isup_reason_for_clip_fail,
11958 { "Reason for CLIP failure", "isup.jpn.reason_for_clip_fail",
11959 FT_UINT8, BASE_DEC, VALS(jpn_isup_reason_for_clip_fail_vals), 0x0,
11960 NULL, HFILL }},
11961
11962 { &hf_japan_isup_contractor_number,
11963 { "Contractor Number", "isup.jpn.contractor_number",
11964 FT_STRING, BASE_NONE, NULL, 0x0,
11965 NULL, HFILL }},
11966
11967 /* CHARGE AREA INFORMATION */
11968 { &hf_japan_isup_charge_area_nat_of_info_value,
11969 { "Nature of Information indicator", "isup.charg_area_info.oddeven_indic",
11970 FT_UINT8, BASE_DEC, VALS(isup_charge_area_info_nat_of_info_value), 0x7F,
11971 NULL, HFILL }},
11972
11973 { &hf_japan_isup_charging_info_nc_odd_digits,
11974 { "NC", "isup.charg_area_info.nc_odd_digit",
11975 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
11976 NULL, HFILL }},
11977
11978 { &hf_japan_isup_charging_info_nc_even_digits,
11979 { "NC", "isup.charg_area_info.nc_even_digit",
11980 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
11981 NULL, HFILL }},
11982
11983 { &hf_isup_charging_info_maca_odd_digits,
11984 { "MA/CA", "isup.charg_area_info.maca_odd_digit",
11985 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
11986 NULL, HFILL }},
11987
11988 { &hf_isup_charging_info_maca_even_digits,
11989 { "MA/CA", "isup.charg_area_info.maca_even_digit",
11990 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
11991 NULL, HFILL }},
11992
11993 /* CARRIER INFORMATION */
11994 { &hf_isup_carrier_info_iec,
11995 { "IEC Indicator", "isup.carrier_info.iec",
11996 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_iec_indic_value), 0x00,
11997 NULL, HFILL }},
11998
11999 #if 0 /* TODO: tools/checkhf.pl reported these as unused */
12000 { &hf_isup_carrier_info_cat_of_carrier,
12001 { "Category of Carrier", "isup.carrier_info.cat_of_carrier",
12002 FT_UINT8, BASE_HEX, VALS(isup_carrier_info_category_value), 0x00,
12003 NULL, HFILL }},
12004
12005 { &hf_isup_carrier_info_type_of_carrier_info,
12006 { "Type of Carrier", "isup.carrier_info.type_of_carrier",
12007 FT_UINT8, BASE_HEX, VALS(isup_carrier_info_type_of_carrier_value), 0x00,
12008 NULL, HFILL }},
12009 #endif
12010
12011 { &hf_japan_isup_carrier_info_length,
12012 { "Length of Carrier Information", "isup.jpn.carrier_info_length",
12013 FT_UINT8, BASE_DEC, NULL, 0x0,
12014 NULL, HFILL }},
12015
12016 { &hf_isup_carrier_info_odd_no_digits,
12017 { "CID", "isup.carrier_info.cid_odd_digit",
12018 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
12019 NULL, HFILL }},
12020
12021 { &hf_isup_carrier_info_even_no_digits,
12022 { "CID", "isup.carrier_info.cid_even_digit",
12023 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
12024 NULL, HFILL }},
12025
12026 { &hf_isup_carrier_info_ca_odd_no_digits,
12027 { "CA", "isup.carrier_info.ca_odd_digit",
12028 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
12029 NULL, HFILL }},
12030
12031 { &hf_isup_carrier_info_ca_even_no_digits,
12032 { "CA", "isup.carrier_info.ca_even_digit",
12033 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
12034 NULL, HFILL }},
12035
12036 { &hf_isup_carrier_info_poi_exit_HEI,
12037 { "Exit POI Hierarchy", "isup.carrier_info_exit_hierarchy",
12038 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_poihie_value), 0x0F,
12039 NULL, HFILL }},
12040
12041 { &hf_isup_carrier_info_poi_entry_HEI,
12042 { "Entry POI Hierarchy", "isup.carrier_info_entry_hierarchy",
12043 FT_UINT8, BASE_DEC, VALS(isup_carrier_info_poihie_value), 0xF0,
12044 NULL, HFILL }},
12045
12046 { &hf_japan_isup_charge_delay_type,
12047 { "Type of delayed charging information", "isup.japan.charge_delay_type",
12048 FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(japan_isup_charge_delay_type_value), 0x0,
12049 NULL, HFILL }},
12050
12051 { &hf_japan_isup_charge_info_type,
12052 { "Charge information type", "isup.japan.chg_inf_type",
12053 FT_UINT8, BASE_DEC, VALS(japan_isup_chg_info_type_value), 0x0,
12054 NULL, HFILL }},
12055
12056 { &hf_japan_isup_sig_elem_type,
12057 { "Signal element type", "isup.japan.sig_elem_type",
12058 FT_UINT8, BASE_DEC, VALS(japan_isup_sig_elem_type_values), 0x7f,
12059 NULL, HFILL }},
12060
12061 { &hf_japan_isup_activation_id,
12062 { "Activation id", "isup.japan.activation_id",
12063 FT_UINT8, BASE_DEC, NULL, 0x7F,
12064 NULL, HFILL }},
12065
12066 { &hf_japan_isup_op_cls,
12067 { "Operation class", "isup.japan.op_cls",
12068 FT_UINT8, BASE_DEC, VALS(japan_isup_op_cls_values), 0x60,
12069 NULL, HFILL }},
12070
12071 { &hf_japan_isup_op_type,
12072 { "Operation type", "isup.japan.op_type",
12073 FT_UINT8, BASE_DEC, VALS(japan_isup_op_type_values), 0x1f,
12074 NULL, HFILL }},
12075
12076 { &hf_japan_isup_charging_party_type,
12077 { "Charging party type", "isup.japan.charging_party_type",
12078 FT_UINT8, BASE_DEC, VALS(japan_isup_charging_party_type_values), 0x70,
12079 NULL, HFILL }},
12080
12081 { &hf_japan_isup_utp,
12082 { "Unit per Time Period (UTP)", "isup.japan.utp",
12083 FT_UINT8, BASE_DEC, VALS(japan_isup_utp_values), 0x0,
12084 NULL, HFILL }},
12085
12086 { &hf_japan_isup_crci1,
12087 { "Charge rate information category 1 (CRIC 1)", "isup.japan.crci1",
12088 FT_UINT8, BASE_DEC, VALS(japan_isup_crci1_values), 0x7f,
12089 NULL, HFILL }},
12090
12091 { &hf_japan_isup_crci2,
12092 { "Charge rate information category 2 (CRIC 2)", "isup.japan.crci2",
12093 FT_UINT8, BASE_DEC, VALS(japan_isup_crci1_values), 0x7f,
12094 NULL, HFILL }},
12095
12096 { &hf_japan_isup_crci1_len,
12097 { "Length", "isup.japan.crci1_len",
12098 FT_UINT8, BASE_DEC, NULL, 0x0,
12099 NULL, HFILL }},
12100
12101 { &hf_japan_isup_iu,
12102 { "Initial units (IU)", "isup.japan.iu",
12103 FT_STRING, BASE_NONE, NULL, 0x0,
12104 NULL, HFILL }},
12105
12106 { &hf_japan_isup_dcr,
12107 { "Daytime Charge rate (DCR)", "isup.japan.dcr",
12108 FT_STRING, BASE_NONE, NULL, 0x0,
12109 NULL, HFILL }},
12110
12111 { &hf_japan_isup_ecr,
12112 { "Evening Charge rate (ECR)", "isup.japan.ecr",
12113 FT_STRING, BASE_NONE, NULL, 0x0,
12114 NULL, HFILL }},
12115
12116 { &hf_japan_isup_ncr,
12117 { "Nighttime Charge rate (NCR)", "isup.japan.ncr",
12118 FT_STRING, BASE_NONE, NULL, 0x0,
12119 NULL, HFILL }},
12120
12121 { &hf_japan_isup_scr,
12122 { "Spare charge rate (SCR)", "isup.japan.scr",
12123 FT_STRING, BASE_NONE, NULL, 0x0,
12124 NULL, HFILL }},
12125
12126 { &hf_japan_isup_collecting_method,
12127 { "Charging party type", "isup.japan.collecting_method",
12128 FT_UINT8, BASE_DEC, VALS(japan_isup_collecting_method_values), 0x0f,
12129 NULL, HFILL }},
12130
12131 { &hf_japan_isup_tariff_rate_pres,
12132 { "Tariff rate presentation", "isup.japan.tariff_rate_pres",
12133 FT_UINT8, BASE_DEC, VALS(japan_isup_tariff_rate_pres_values), 0x7f,
12134 NULL, HFILL }},
12135
12136 /* Generated from convert_proto_tree_add_text.pl */
12137 { &hf_isup_cause_indicators, { "Cause indicators (-> Q.850)", "isup.cause_indicators", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12138 { &hf_isup_diagnostic, { "Diagnostic", "isup.diagnostic", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12139 { &hf_isup_user_to_user_info, { "User-to-user info (-> Q.931)", "isup.user_to_user_info", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12140 { &hf_isup_call_identity, { "Call identity", "isup.call_identity", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12141 { &hf_isup_signalling_point_code, { "Signalling Point Code", "isup.signalling_point_code", FT_UINT16, BASE_DEC, NULL, 0x3FFF, NULL, HFILL }},
12142 { &hf_isup_access_transport_parameter_field, { "Access transport parameter field (-> Q.931)", "isup.access_transport_parameter_field", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12143 { &hf_isup_idp, { "IDP", "isup.idp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12144 { &hf_isup_dsp, { "DSP", "isup.dsp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12145 { &hf_isup_idi, { "IDI", "isup.idi", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12146 { &hf_isup_configuration_data, { "Configuration data", "isup.configuration_data", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12147 { &hf_isup_unknown_organisation_identifier, { "Unknown organisation Identifier (Non ITU-T/ETSI codec)", "isup.unknown_organisation_identifier", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12148 { &hf_isup_tunnelled_protocol_data, { "Tunnelled Protocol Data", "isup.tunnelled_protocol_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12149 { &hf_isup_network_id_length_indicator, { "Network ID Length indicator", "isup.network_id_length_indicator", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12150 { &hf_isup_network_id, { "Network ID", "isup.network_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12151 { &hf_isup_app_transport_param_field8, { "Application transport parameter fields", "isup.app_transport_param_field", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12152 { &hf_isup_app_transport_param_field16, { "Application transport parameter fields", "isup.app_transport_param_field", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12153 { &hf_isup_app_transport_instruction_indicator, { "Application transport instruction indicators", "isup.app_transport_instruction_indicator", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12154 { &hf_isup_apm_seg_indicator, { "APM segmentation indicator", "isup.apm_seg_indicator", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12155 { &hf_isup_address_digits, { "Address digits", "isup.address_digits", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12156 { &hf_isup_apm_user_info_field, { "APM-user information field", "isup.apm_user_info_field", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12157 { &hf_isup_local_reference, { "Local Reference", "isup.local_reference", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12158 { &hf_isup_protocol_class, { "Protocol Class", "isup.protocol_class", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12159 { &hf_isup_credit, { "Credit", "isup.credit", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12160 { &hf_isup_network_identity, { "Network Identity", "isup.network_identity", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12161 { &hf_isup_binary_code, { "Binary Code", "isup.binary_code", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12162 { &hf_isup_user_service_information, { "User service information (-> Q.931 Bearer_capability)", "isup.user_service_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12163 { &hf_isup_circuit_assignment_map, { "Circuit assignment map (bit position indicates usage of corresponding circuit->3.69/Q.763)", "isup.circuit_assignment_map", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12164 { &hf_isup_origination_isc_point_code, { "Origination ISC Point Code", "isup.origination_isc_point_code", FT_UINT16, BASE_DEC, NULL, 0x3FFF, NULL, HFILL }},
12165 { &hf_isup_call_history_info, { "Call history info", "isup.call_history_info", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12166 { &hf_isup_network_specific_facility, { "Network specific facility (refer to 3.36/Q.763 for detailed decoding)", "isup.network_specific_facility", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12167 { &hf_isup_user_service_information_prime, { "User service information prime (-> Q.931 Bearer capability information IE)", "isup.user_service_information_prime", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12168 { &hf_isup_propagation_delay_counter, { "Propagation delay counter", "isup.propagation_delay_counter", FT_UINT16, BASE_DEC|BASE_UNIT_STRING, UNS(&units_milliseconds), 0x0, NULL, HFILL }},
12169 { &hf_isup_remote_operations, { "Remote operations", "isup.remote_operations", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12170 { &hf_isup_feature_code, { "Feature Code", "isup.feature_code", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12171 { &hf_isup_user_teleservice_information, { "User teleservice information (-> Q.931 High Layer Compatibility IE)", "isup.user_teleservice_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12172 { &hf_isup_call_diversion_information, { "Call diversion information", "isup.call_diversion_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12173 { &hf_isup_echo_control_information, { "Echo control information", "isup.echo_control_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12174 { &hf_isup_message_compatibility_information, { "Message compatibility information", "isup.message_compatibility_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12175 { &hf_isup_upgraded_parameter, { "Upgraded parameter", "isup.upgraded_parameter", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_parameter_type_value_ext, 0x0, NULL, HFILL }},
12176 { &hf_isup_instruction_indicators, { "Instruction indicators", "isup.instruction_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12177 { &hf_isup_look_forward_busy, { "Look forward busy", "isup.look_forward_busy", FT_UINT8, BASE_DEC, VALS(isup_mlpp_precedence_look_forward_busy_vals), 0x60, NULL, HFILL }},
12178 { &hf_isup_precedence_level, { "Precedence Level", "isup.precedence_level", FT_UINT8, BASE_DEC, VALS(isup_mlpp_precedence_level_vals), 0x0F, NULL, HFILL }},
12179 { &hf_isup_mlpp_service_domain, { "MLPP service domain", "isup.mlpp_service_domain", FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12180 { &hf_isup_mcid_request_indicators, { "MCID request indicators", "isup.mcid_request_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12181 { &hf_isup_mcid_response_indicators, { "MCID response indicators", "isup.mcid_response_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12182 { &hf_isup_hop_counter, { "Hop counter", "isup.hop_counter", FT_UINT8, BASE_DEC, NULL, EDCBA_8BIT_MASK, NULL, HFILL }},
12183 { &hf_isup_originating_line_info, { "Originating line info", "isup.originating_line_info", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12184 { &hf_isup_presentation_indicator, { "Presentation indicator", "isup.presentation_indicator", FT_UINT8, BASE_DEC, VALS(isup_redirection_presentation_indicator_vals), BA_8BIT_MASK, NULL, HFILL }},
12185 { &hf_isup_call_transfer_identity, { "Call transfer identity", "isup.call_transfer_identity", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12186 { &hf_isup_loop_prevention_indicator_type, { "Type", "isup.loop_prevention_indicator_type", FT_BOOLEAN, 8, TFS(&tfs_response_request), A_8BIT_MASK, NULL, HFILL }},
12187 { &hf_isup_ccss_call_indicator, { "CCSS call indicator", "isup.ccss_call_indicator", FT_BOOLEAN, 8, TFS(&tfs_ccss_call_no_indication), A_8BIT_MASK, NULL, HFILL }},
12188 { &hf_isup_forward_gvns, { "Forward GVNS (refer to 3.66/Q.763 for detailed decoding)", "isup.forward_gvns", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12189 { &hf_isup_redirect_capability, { "Redirect capability", "isup.redirect_capability", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12190 { &hf_isup_backward_gvns, { "Backward GVNS", "isup.backward_gvns", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12191 { &hf_isup_correlation_id, { "Correlation ID (-> Q.1281)", "isup.correlation_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12192 { &hf_isup_scf_id, { "SCF ID (-> Q.1281)", "isup.scf_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12193 { &hf_isup_charged_party_identification, { "Charged party identification (format is national network specific)", "isup.charged_party_identification", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12194 { &hf_isup_display_information, { "Display information (-> Q.931)", "isup.display_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12195 { &hf_isup_uid_action_indicators, { "UID action indicators", "isup.uid_action_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12196 { &hf_isup_uid_capability_indicators, { "UID capability indicators", "isup.uid_capability_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12197 { &hf_isup_redirect_counter, { "Redirect counter", "isup.redirect_counter", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12198 { &hf_isup_collect_call_request_indicator, { "Collect call request indicator", "isup.collect_call_request_indicator", FT_BOOLEAN, 8, TFS(&tfs_collect_call_req_no_indication), A_8BIT_MASK, NULL, HFILL }},
12199 { &hf_isup_geo_loc_shape, { "Calling geodetic location type of shape", "isup.geo_loc_shape", FT_UINT8, BASE_DEC, VALS(isup_location_type_of_shape_value), GFEDCBA_8BIT_MASK, NULL, HFILL }},
12200 { &hf_isup_geo_loc_shape_description, { "Shape description", "isup.shape_description", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12201 { &hf_isup_number_qualifier_indicator, { "Number qualifier indicator", "isup.number_qualifier_indicator", FT_UINT8, BASE_HEX|BASE_RANGE_STRING, RVALS(number_qualifier_indicator_vals), 0x0, NULL, HFILL }},
12202 { &hf_isup_generic_digits, { "Generic digits (refer to 3.24/Q.673 for detailed decoding)", "isup.generic_digits", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12203 };
12204
12205 /* Setup protocol subtree array */
12206 static int *ett[] = {
12207 &ett_isup,
12208 &ett_isup_parameter,
12209 &ett_isup_address_digits,
12210 &ett_isup_carrier_info,
12211 &ett_isup_pass_along_message,
12212 &ett_isup_circuit_state_ind,
12213 &ett_bat_ase,
12214 &ett_bat_ase_element,
12215 &ett_bat_ase_iwfa,
12216 &ett_scs,
12217 &ett_acs,
12218 &ett_isup_apm_msg_fragment,
12219 &ett_isup_apm_msg_fragments,
12220 &ett_isup_range,
12221 &ett_app_transport_fields,
12222 &ett_app_transport,
12223 &ett_apm_seg_indicator,
12224 &ett_echo_control_information,
12225 &ett_instruction_indicators,
12226 &ett_message_compatibility_information,
12227 };
12228
12229 static ei_register_info ei[] = {
12230 { &ei_isup_format_national_matter, { "isup.format_national_matter", PI_PROTOCOL, PI_NOTE, "Format is a national matter", EXPFILL }},
12231 { &ei_isup_message_type_unknown, { "isup.message_type.unknown", PI_PROTOCOL, PI_WARN, "Unknown Message type (possibly reserved/used in former ISUP version)", EXPFILL }},
12232 { &ei_isup_not_dissected_yet, { "isup.not_dissected_yet", PI_UNDECODED, PI_WARN, "Not dissected yet", EXPFILL }},
12233 { &ei_isup_status_subfield_not_present, { "isup.status_subfield_not_present", PI_PROTOCOL, PI_NOTE, "Status subfield is not present with this message type", EXPFILL }},
12234 { &ei_isup_message_type_no_optional_parameters, { "isup.message_type.no_optional_parameters", PI_PROTOCOL, PI_NOTE, "No optional parameters are possible with this message type", EXPFILL }},
12235 { &ei_isup_empty_number, { "isup.empty_number", PI_PROTOCOL, PI_NOTE, "(empty) number", EXPFILL }},
12236 { &ei_isup_too_many_digits, { "isup.too_many_digits", PI_MALFORMED, PI_ERROR, "Too many digits", EXPFILL }},
12237 { &ei_isup_opt_par_length_err, { "isup.opt_par_length_err", PI_MALFORMED, PI_ERROR, "Optional parameter length is wrong", EXPFILL }}
12238 };
12239
12240 static const enum_val_t isup_variants[] = {
12241 {"ITU", "ITU Standard", ISUP_ITU_STANDARD_VARIANT},
12242 {"French", "French National Standard", ISUP_FRENCH_VARIANT},
12243 {"Israeli", "Israeli National Standard", ISUP_ISRAELI_VARIANT},
12244 {"Russian", "Russian National Standard", ISUP_RUSSIAN_VARIANT},
12245 {"Japan", "Japan National Standard", ISUP_JAPAN_VARIANT},
12246 {"Japan_TTC", "Japan National Standard (TTC)", ISUP_JAPAN_TTC_VARIANT},
12247 {NULL, NULL, -1}
12248 };
12249
12250 module_t *isup_module;
12251 expert_module_t* expert_isup;
12252
12253 /* Register the protocol name and description */
12254 proto_isup = proto_register_protocol("ISDN User Part",
12255 "ISUP", "isup");
12256
12257 isup_handle = register_dissector("isup", dissect_isup, proto_isup);
12258
12259 /* Required function calls to register the header fields and subtrees used */
12260 proto_register_field_array(proto_isup, hf, array_length(hf));
12261 proto_register_subtree_array(ett, array_length(ett));
12262 expert_isup = expert_register_protocol(proto_isup);
12263 expert_register_field_array(expert_isup, ei, array_length(ei));
12264
12265 isup_tap = register_tap("isup");
12266
12267 isup_module = prefs_register_protocol(proto_isup, NULL);
12268
12269 prefs_register_enum_preference(isup_module, "variant",
12270 "Select Standard or national ISUP variant",
12271 "Note national variants may not be fully supported",
12272 &g_isup_variant, isup_variants, false);
12273
12274
12275 prefs_register_bool_preference(isup_module, "show_cic_in_info", "Show CIC in Info column",
12276 "Show the CIC value (in addition to the message type) in the Info column",
12277 &isup_show_cic_in_info);
12278
12279 prefs_register_bool_preference(isup_module, "defragment_apm",
12280 "Reassemble APM messages",
12281 "Whether APM messages datagrams should be reassembled",
12282 &isup_apm_desegment);
12283
12284 /* Register the stats_tree */
12285 stats_tree_cfg *st_config = stats_tree_register("isup", "isup_msg", "_ISUP Messages",
12286 0, msg_stats_tree_packet, msg_stats_tree_init, NULL);
12287 stats_tree_set_group(st_config, REGISTER_TELEPHONY_GROUP_UNSORTED);
12288 }
12289
12290
12291 /* ------------------------------------------------------------------ */
12292 /* Register isup with the sub-laying MTP L3 dissector */
12293 void
12294 proto_reg_handoff_isup(void)
12295 {
12296 dissector_handle_t application_isup_handle;
12297
12298 application_isup_handle = create_dissector_handle(dissect_application_isup, proto_isup);
12299 dissector_add_uint("mtp3.service_indicator", MTP_SI_ISUP, isup_handle);
12300 dissector_add_string("media_type", "application/isup", application_isup_handle);
12301 dissector_add_string("tali.opcode", "isot", isup_handle);
12302
12303 }
12304
12305 void
12306 proto_register_bicc(void)
12307 {
12308 /* Setup list of header fields See Section 1.6.1 for details*/
12309 static hf_register_info hf[] = {
12310 { &hf_bicc_cic,
12311 { "Call identification Code (CIC)", "bicc.cic",
12312 FT_UINT32, BASE_DEC, NULL, 0x0,
12313 NULL, HFILL }},
12314 { &hf_bicc_continuity_check_indicator,
12315 { "Continuity Indicator", "bicc.continuity_check_indicator",
12316 FT_UINT8, BASE_HEX, VALS(bicc_continuity_check_ind_value), DC_8BIT_MASK,
12317 NULL, HFILL }},
12318 { &hf_bicc_forw_call_end_to_end_method_indicator,
12319 { "End-to-end method indicator", "bicc.forw_call_end_to_end_method_indicator",
12320 FT_UINT16, BASE_HEX, VALS(bicc_end_to_end_method_ind_value), CB_16BIT_MASK,
12321 NULL, HFILL }},
12322 { &hf_bicc_backw_call_end_to_end_method_ind,
12323 { "End-to-end method indicator", "bicc.backw_call_end_to_end_method_indicator",
12324 FT_UINT16, BASE_HEX, VALS(bicc_end_to_end_method_ind_value), HG_16BIT_MASK,
12325 NULL, HFILL }},
12326 { &hf_bicc_backw_call_end_to_end_info_ind,
12327 { "End-to-end information indicator", "bicc.backw_call_end_to_end_information_indicator",
12328 FT_BOOLEAN, 16, TFS(&bicc_end_to_end_info_ind_value), J_16BIT_MASK,
12329 NULL, HFILL }},
12330 { &hf_bicc_backw_call_isdn_user_part_ind,
12331 { "BICC indicator", "bicc.backw_call_isdn_user_part_indicator",
12332 FT_BOOLEAN, 16, TFS(&bicc_ISDN_user_part_ind_value), K_16BIT_MASK,
12333 NULL, HFILL }},
12334 { &hf_bicc_backw_call_sccp_method_ind,
12335 { "SCCP method indicator", "bicc.backw_call_sccp_method_indicator",
12336 FT_UINT16, BASE_HEX, VALS(bicc_SCCP_method_ind_value), PO_16BIT_MASK,
12337 NULL, HFILL }},
12338 { &hf_bicc_forw_call_end_to_end_info_indicator,
12339 { "End-to-end information indicator", "bicc.forw_call_end_to_end_information_indicator",
12340 FT_BOOLEAN, 16, TFS(&bicc_end_to_end_info_ind_value), E_16BIT_MASK,
12341 NULL, HFILL }},
12342 { &hf_bicc_forw_call_isdn_user_part_indicator,
12343 { "BICC indicator", "bicc.forw_call_isdn_user_part_indicator",
12344 FT_BOOLEAN, 16, TFS(&bicc_ISDN_user_part_ind_value), F_16BIT_MASK,
12345 NULL, HFILL }},
12346 { &hf_bicc_forw_call_preferences_indicator,
12347 { "BICC preference indicator", "bicc.forw_call_preferences_indicator",
12348 FT_UINT16, BASE_HEX, VALS(bicc_preferences_ind_value), HG_16BIT_MASK,
12349 NULL, HFILL }},
12350 { &hf_bicc_forw_call_sccp_method_indicator,
12351 { "SCCP method indicator", "bicc.forw_call_sccp_method_indicator",
12352 FT_UINT16, BASE_HEX, VALS(bicc_SCCP_method_ind_value), KJ_16BIT_MASK,
12353 NULL, HFILL }},
12354 };
12355
12356 /* Setup protocol subtree array */
12357 static int *ett[] = {
12358 &ett_bicc
12359 };
12360
12361 proto_bicc = proto_register_protocol("Bearer Independent Call Control",
12362 "BICC", "bicc");
12363
12364 bicc_handle = register_dissector("bicc", dissect_bicc, proto_bicc);
12365
12366 /* Required function calls to register the header fields and subtrees used */
12367 proto_register_field_array(proto_bicc, hf, array_length(hf));
12368 proto_register_subtree_array(ett, array_length(ett));
12369
12370 reassembly_table_register(&isup_apm_msg_reassembly_table,
12371 &addresses_reassembly_table_functions);
12372
12373 }
12374
12375 /* Register isup with the sub-laying MTP L3 dissector */
12376 void
12377 proto_reg_handoff_bicc(void)
12378 {
12379 sdp_handle = find_dissector_add_dependency("sdp", proto_isup);
12380 q931_ie_handle = find_dissector_add_dependency("q931.ie", proto_isup);
12381
12382 dissector_add_uint("mtp3.service_indicator", MTP_SI_BICC, bicc_handle);
12383 dissector_add_uint("sctp.ppi", BICC_PAYLOAD_PROTOCOL_ID, bicc_handle);
12384 }
12385
12386 /*
12387 * Editor modelines
12388 *
12389 * Local Variables:
12390 * c-basic-offset: 2
12391 * tab-width: 8
12392 * indent-tabs-mode: nil
12393 * End:
12394 *
12395 * ex: set shiftwidth=2 tabstop=8 expandtab:
12396 * :indentSize=2:tabSize=8:noTabs=true:
12397 */
Metzes wireshark repo